Core: Fixed some level 4 warnings (msvc)

8 files changed, 93 insertions, 80 deletions

diff --git a/src/server/shared/Cryptography/BigNumber.cpp b/src/server/shared/Cryptography/BigNumber.cpp
index def0a7fd02e..b5392830931 100644
--- a/src/server/shared/Cryptography/BigNumber.cpp
+++ b/src/server/shared/Cryptography/BigNumber.cpp
@@ -28,7 +28,7 @@ BigNumber::BigNumber()
     , _array(NULL)
 { }
 
-BigNumber::BigNumber(const BigNumber &bn)
+BigNumber::BigNumber(BigNumber const& bn)
     : _bn(BN_dup(bn._bn))
     , _array(NULL)
 { }
@@ -58,44 +58,45 @@ void BigNumber::SetQword(uint64 val)
     BN_add_word(_bn, (uint32)(val & 0xFFFFFFFF));
 }
 
-void BigNumber::SetBinary(const uint8 *bytes, int len)
+void BigNumber::SetBinary(uint8 const* bytes, int32 len)
 {
     uint8 t[1000];
     for (int i = 0; i < len; i++) t[i] = bytes[len - 1 - i];
     BN_bin2bn(t, len, _bn);
 }
 
-void BigNumber::SetHexStr(const char *str)
+void BigNumber::SetHexStr(char const* str)
 {
     BN_hex2bn(&_bn, str);
 }
 
-void BigNumber::SetRand(int numbits)
+void BigNumber::SetRand(int32 numbits)
 {
     BN_rand(_bn, numbits, 0, 1);
 }
 
-BigNumber& BigNumber::operator=(const BigNumber &bn)
+BigNumber& BigNumber::operator=(BigNumber const& bn)
 {
     if (this == &bn)
         return *this;
+
     BN_copy(_bn, bn._bn);
     return *this;
 }
 
-BigNumber BigNumber::operator+=(const BigNumber &bn)
+BigNumber BigNumber::operator+=(BigNumber const& bn)
 {
     BN_add(_bn, _bn, bn._bn);
     return *this;
 }
 
-BigNumber BigNumber::operator-=(const BigNumber &bn)
+BigNumber BigNumber::operator-=(BigNumber const& bn)
 {
     BN_sub(_bn, _bn, bn._bn);
     return *this;
 }
 
-BigNumber BigNumber::operator*=(const BigNumber &bn)
+BigNumber BigNumber::operator*=(BigNumber const& bn)
 {
     BN_CTX *bnctx;
 
@@ -106,7 +107,7 @@ BigNumber BigNumber::operator*=(const BigNumber &bn)
     return *this;
 }
 
-BigNumber BigNumber::operator/=(const BigNumber &bn)
+BigNumber BigNumber::operator/=(BigNumber const& bn)
 {
     BN_CTX *bnctx;
 
@@ -117,7 +118,7 @@ BigNumber BigNumber::operator/=(const BigNumber &bn)
     return *this;
 }
 
-BigNumber BigNumber::operator%=(const BigNumber &bn)
+BigNumber BigNumber::operator%=(BigNumber const& bn)
 {
     BN_CTX *bnctx;
 
@@ -128,7 +129,7 @@ BigNumber BigNumber::operator%=(const BigNumber &bn)
     return *this;
 }
 
-BigNumber BigNumber::Exp(const BigNumber &bn)
+BigNumber BigNumber::Exp(BigNumber const& bn)
 {
     BigNumber ret;
     BN_CTX *bnctx;
@@ -140,7 +141,7 @@ BigNumber BigNumber::Exp(const BigNumber &bn)
     return ret;
 }
 
-BigNumber BigNumber::ModExp(const BigNumber &bn1, const BigNumber &bn2)
+BigNumber BigNumber::ModExp(BigNumber const& bn1, BigNumber const& bn2)
 {
     BigNumber ret;
     BN_CTX *bnctx;
@@ -152,7 +153,7 @@ BigNumber BigNumber::ModExp(const BigNumber &bn1, const BigNumber &bn2)
     return ret;
 }
 
-int BigNumber::GetNumBytes(void)
+int32 BigNumber::GetNumBytes(void)
 {
     return BN_num_bytes(_bn);
 }
@@ -167,7 +168,7 @@ bool BigNumber::isZero() const
     return BN_is_zero(_bn);
 }
 
-uint8 *BigNumber::AsByteArray(int minSize, bool reverse)
+uint8* BigNumber::AsByteArray(int32 minSize, bool reverse)
 {
     int length = (minSize >= GetNumBytes()) ? minSize : GetNumBytes();
 
diff --git a/src/server/shared/Cryptography/BigNumber.h b/src/server/shared/Cryptography/BigNumber.h
index 36a618056a5..5f0fdf4934a 100644
--- a/src/server/shared/Cryptography/BigNumber.h
+++ b/src/server/shared/Cryptography/BigNumber.h
@@ -28,45 +28,49 @@ class BigNumber
 {
     public:
         BigNumber();
-        BigNumber(const BigNumber &bn);
+        BigNumber(BigNumber const& bn);
         BigNumber(uint32);
         ~BigNumber();
 
         void SetDword(uint32);
         void SetQword(uint64);
-        void SetBinary(const uint8 *bytes, int len);
-        void SetHexStr(const char *str);
+        void SetBinary(uint8 const* bytes, int32 len);
+        void SetHexStr(char const* str);
 
-        void SetRand(int numbits);
+        void SetRand(int32 numbits);
 
-        BigNumber& operator=(const BigNumber &bn);
+        BigNumber& operator=(BigNumber const& bn);
 
-        BigNumber operator+=(const BigNumber &bn);
-        BigNumber operator+(const BigNumber &bn)
+        BigNumber operator+=(BigNumber const& bn);
+        BigNumber operator+(BigNumber const& bn)
         {
             BigNumber t(*this);
             return t += bn;
         }
-        BigNumber operator-=(const BigNumber &bn);
-        BigNumber operator-(const BigNumber &bn)
+
+        BigNumber operator-=(BigNumber const& bn);
+        BigNumber operator-(BigNumber const& bn)
         {
             BigNumber t(*this);
             return t -= bn;
         }
-        BigNumber operator*=(const BigNumber &bn);
-        BigNumber operator*(const BigNumber &bn)
+
+        BigNumber operator*=(BigNumber const& bn);
+        BigNumber operator*(BigNumber const& bn)
         {
             BigNumber t(*this);
             return t *= bn;
         }
-        BigNumber operator/=(const BigNumber &bn);
-        BigNumber operator/(const BigNumber &bn)
+
+        BigNumber operator/=(BigNumber const& bn);
+        BigNumber operator/(BigNumber const& bn)
         {
             BigNumber t(*this);
             return t /= bn;
         }
-        BigNumber operator%=(const BigNumber &bn);
-        BigNumber operator%(const BigNumber &bn)
+
+        BigNumber operator%=(BigNumber const& bn);
+        BigNumber operator%(BigNumber const& bn)
         {
             BigNumber t(*this);
             return t %= bn;
@@ -74,15 +78,15 @@ class BigNumber
 
         bool isZero() const;
 
-        BigNumber ModExp(const BigNumber &bn1, const BigNumber &bn2);
-        BigNumber Exp(const BigNumber &);
+        BigNumber ModExp(BigNumber const& bn1, BigNumber const& bn2);
+        BigNumber Exp(BigNumber const&);
 
-        int GetNumBytes(void);
+        int32 GetNumBytes(void);
 
         struct bignum_st *BN() { return _bn; }
 
         uint32 AsDword();
-        uint8* AsByteArray(int minSize = 0, bool reverse = true);
+        uint8* AsByteArray(int32 minSize = 0, bool reverse = true);
 
         char * AsHexStr() const;
         char * AsDecStr() const;
diff --git a/src/server/shared/DataStores/DBCStore.h b/src/server/shared/DataStores/DBCStore.h
index e872ead35db..a89b8a5f028 100644
--- a/src/server/shared/DataStores/DBCStore.h
+++ b/src/server/shared/DataStores/DBCStore.h
@@ -28,20 +28,20 @@
 
 struct SqlDbc
 {
-    const std::string * formatString;
-    const std::string * indexName;
+    std::string const* formatString;
+    std::string const* indexName;
     std::string sqlTableName;
     int32 indexPos;
     int32 sqlIndexPos;
-    SqlDbc(const std::string * _filename, const std::string * _format, const std::string * _idname, const char * fmt)
-        :formatString(_format), indexName (_idname), sqlIndexPos(0)
+    SqlDbc(std::string const* _filename, std::string const* _format, std::string const* _idname, char const* fmt)
+        : formatString(_format), indexName (_idname), sqlIndexPos(0)
     {
         // Convert dbc file name to sql table name
         sqlTableName = *_filename;
         for (uint32 i = 0; i< sqlTableName.size(); ++i)
         {
             if (isalpha(sqlTableName[i]))
-                sqlTableName[i] = tolower(sqlTableName[i]);
+                sqlTableName[i] = char(tolower(sqlTableName[i]));
             else if (sqlTableName[i] == '.')
                 sqlTableName[i] = '_';
         }
@@ -70,22 +70,24 @@ class DBCStorage
 {
     typedef std::list<char*> StringPoolList;
     public:
-        explicit DBCStorage(const char *f) :
-            fmt(f), nCount(0), fieldCount(0), dataTable(NULL)
+        explicit DBCStorage(char const* f)
+            : fmt(f), nCount(0), fieldCount(0), dataTable(NULL)
         {
             indexTable.asT = NULL;
         }
+
         ~DBCStorage() { Clear(); }
 
         T const* LookupEntry(uint32 id) const
         {
             return (id >= nCount) ? NULL : indexTable.asT[id];
         }
+
         uint32  GetNumRows() const { return nCount; }
         char const* GetFormat() const { return fmt; }
         uint32 GetFieldCount() const { return fieldCount; }
 
-        bool Load(char const* fn, SqlDbc * sql)
+        bool Load(char const* fn, SqlDbc* sql)
         {
             DBCFileLoader dbc;
             // Check if load was sucessful, only then continue
@@ -114,8 +116,9 @@ class DBCStorage
                         fields = result->Fetch();
                         sqlHighestIndex = fields[sql->sqlIndexPos].GetUInt32();
                     }
+
                     // Check if sql index pos is valid
-                    if (int32(result->GetFieldCount()-1) < sql->sqlIndexPos)
+                    if (int32(result->GetFieldCount() - 1) < sql->sqlIndexPos)
                     {
                         sLog->outError(LOG_FILTER_SERVER_LOADING, "Invalid index pos for dbc:'%s'", sql->sqlTableName.c_str());
                         return false;
@@ -123,13 +126,13 @@ class DBCStorage
                 }
             }
 
-            char * sqlDataTable;
+            char* sqlDataTable = NULL;
             fieldCount = dbc.GetCols();
 
-            dataTable = (T*)dbc.AutoProduceData(fmt, nCount, indexTable.asChar,
-                sqlRecordCount, sqlHighestIndex, sqlDataTable);
+            dataTable = reinterpret_cast<T*>(dbc.AutoProduceData(fmt, nCount, indexTable.asChar,
+                sqlRecordCount, sqlHighestIndex, sqlDataTable));
 
-            stringPoolList.push_back(dbc.AutoProduceStrings(fmt, (char*)dataTable));
+            stringPoolList.push_back(dbc.AutoProduceStrings(fmt, reinterpret_cast<char*>(dataTable)));
 
             // Insert sql data into arrays
             if (result)
@@ -151,10 +154,12 @@ class DBCStorage
                                 sLog->outError(LOG_FILTER_SERVER_LOADING, "Index %d already exists in dbc:'%s'", id, sql->sqlTableName.c_str());
                                 return false;
                             }
-                            indexTable.asT[id]=(T*)&sqlDataTable[offset];
+
+                            indexTable.asT[id] = reinterpret_cast<T*>(&sqlDataTable[offset]);
                         }
                         else
-                            indexTable.asT[rowIndex]=(T*)&sqlDataTable[offset];
+                            indexTable.asT[rowIndex]= reinterpret_cast<T*>(&sqlDataTable[offset]);
+
                         uint32 columnNumber = 0;
                         uint32 sqlColumnNumber = 0;
 
@@ -165,22 +170,22 @@ class DBCStorage
                                 switch (fmt[columnNumber])
                                 {
                                     case FT_FLOAT:
-                                        *((float*)(&sqlDataTable[offset]))= 0.0f;
-                                        offset+=4;
+                                        *reinterpret_cast<float*>(&sqlDataTable[offset]) = 0.0f;
+                                        offset += 4;
                                         break;
                                     case FT_IND:
                                     case FT_INT:
-                                        *((uint32*)(&sqlDataTable[offset]))=uint32(0);
-                                        offset+=4;
+                                        *reinterpret_cast<uint32*>(&sqlDataTable[offset]) = uint32(0);
+                                        offset += 4;
                                         break;
                                     case FT_BYTE:
-                                        *((uint8*)(&sqlDataTable[offset]))=uint8(0);
-                                        offset+=1;
+                                        *reinterpret_cast<uint8*>(&sqlDataTable[offset]) = uint8(0);
+                                        offset += 1;
                                         break;
                                     case FT_STRING:
                                         // Beginning of the pool - empty string
-                                        *((char**)(&sqlDataTable[offset]))=stringPoolList.back();
-                                        offset+=sizeof(char*);
+                                        *reinterpret_cast<char**>(&sqlDataTable[offset]) = stringPoolList.back();
+                                        offset += sizeof(char*);
                                         break;
                                 }
                             }
@@ -190,17 +195,17 @@ class DBCStorage
                                 switch (fmt[columnNumber])
                                 {
                                     case FT_FLOAT:
-                                        *((float*)(&sqlDataTable[offset]))=fields[sqlColumnNumber].GetFloat();
-                                        offset+=4;
+                                        *reinterpret_cast<float*>(&sqlDataTable[offset]) = fields[sqlColumnNumber].GetFloat();
+                                        offset += 4;
                                         break;
                                     case FT_IND:
                                     case FT_INT:
-                                        *((uint32*)(&sqlDataTable[offset]))=fields[sqlColumnNumber].GetUInt32();
-                                        offset+=4;
+                                        *reinterpret_cast<uint32*>(&sqlDataTable[offset]) = fields[sqlColumnNumber].GetUInt32();
+                                        offset += 4;
                                         break;
                                     case FT_BYTE:
-                                        *((uint8*)(&sqlDataTable[offset]))=fields[sqlColumnNumber].GetUInt8();
-                                        offset+=1;
+                                        *reinterpret_cast<uint8*>(&sqlDataTable[offset]) = fields[sqlColumnNumber].GetUInt8();
+                                        offset += 1;
                                         break;
                                     case FT_STRING:
                                         sLog->outError(LOG_FILTER_SERVER_LOADING, "Unsupported data type in table '%s' at char %d", sql->sqlTableName.c_str(), columnNumber);
@@ -209,6 +214,7 @@ class DBCStorage
                                         break;
                                     default:
                                         validSqlColumn = false;
+                                        break;
                                 }
                                 if (validSqlColumn && (columnNumber != (sql->formatString->size()-1)))
                                     sqlColumnNumber++;
@@ -219,7 +225,8 @@ class DBCStorage
                                 return false;
                             }
                         }
-                        if (sqlColumnNumber != (result->GetFieldCount()-1))
+
+                        if (sqlColumnNumber != (result->GetFieldCount() - 1))
                         {
                             sLog->outError(LOG_FILTER_SERVER_LOADING, "SQL and DBC format strings are not matching for table: '%s'", sql->sqlTableName.c_str());
                             return false;
@@ -227,7 +234,7 @@ class DBCStorage
 
                         fields = NULL;
                         ++rowIndex;
-                    }while (result->NextRow());
+                    } while (result->NextRow());
                 }
             }
 
@@ -246,7 +253,7 @@ class DBCStorage
             if (!dbc.Load(fn, fmt))
                 return false;
 
-            stringPoolList.push_back(dbc.AutoProduceStrings(fmt, (char*)dataTable));
+            stringPoolList.push_back(dbc.AutoProduceStrings(fmt, reinterpret_cast<char*>(dataTable)));
 
             return true;
         }
@@ -256,9 +263,9 @@ class DBCStorage
             if (!indexTable.asT)
                 return;
 
-            delete[] ((char*)indexTable.asT);
+            delete[] reinterpret_cast<char*>(indexTable.asT);
             indexTable.asT = NULL;
-            delete[] ((char*)dataTable);
+            delete[] reinterpret_cast<char*>(dataTable);
             dataTable = NULL;
 
             while (!stringPoolList.empty())
@@ -266,6 +273,7 @@ class DBCStorage
                 delete[] stringPoolList.front();
                 stringPoolList.pop_front();
             }
+
             nCount = 0;
         }
 
diff --git a/src/server/shared/Database/PreparedStatement.cpp b/src/server/shared/Database/PreparedStatement.cpp
index 21aef0f1834..a32d937abcd 100644
--- a/src/server/shared/Database/PreparedStatement.cpp
+++ b/src/server/shared/Database/PreparedStatement.cpp
@@ -33,7 +33,7 @@ void PreparedStatement::BindParameters()
 {
     ASSERT (m_stmt);
 
-    uint32 i = 0;
+    uint8 i = 0;
     for (; i < statement_data.size(); i++)
     {
         switch (statement_data[i].type)
diff --git a/src/server/shared/Logging/AppenderDB.cpp b/src/server/shared/Logging/AppenderDB.cpp
index d85a4db9f7a..e9feef0e858 100644
--- a/src/server/shared/Logging/AppenderDB.cpp
+++ b/src/server/shared/Logging/AppenderDB.cpp
@@ -18,8 +18,8 @@
 #include "AppenderDB.h"
 #include "Database/DatabaseEnv.h"
 
-AppenderDB::AppenderDB(uint8 id, std::string const& name, LogLevel level, uint8 realmId):
-Appender(id, name, APPENDER_DB, level), realm(realmId), enable(false)
+AppenderDB::AppenderDB(uint8 id, std::string const& name, LogLevel level, uint32 realmId)
+    : Appender(id, name, APPENDER_DB, level), realm(realmId), enable(false)
 {
 }
 
@@ -41,8 +41,8 @@ void AppenderDB::_write(LogMessage& message)
             PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_INS_LOG);
             stmt->setUInt64(0, message.mtime);
             stmt->setUInt32(1, realm);
-            stmt->setUInt8(2, message.type);
-            stmt->setUInt8(3, message.level);
+            stmt->setUInt8(2, uint8(message.type));
+            stmt->setUInt8(3, uint8(message.level));
             stmt->setString(4, message.text);
             LoginDatabase.Execute(stmt);
             break;
diff --git a/src/server/shared/Logging/AppenderDB.h b/src/server/shared/Logging/AppenderDB.h
index 4399195b181..f1b680c2c5e 100644
--- a/src/server/shared/Logging/AppenderDB.h
+++ b/src/server/shared/Logging/AppenderDB.h
@@ -23,12 +23,12 @@
 class AppenderDB: public Appender
 {
     public:
-        AppenderDB(uint8 _id, std::string const& _name, LogLevel level, uint8 realmId);
+        AppenderDB(uint8 _id, std::string const& _name, LogLevel level, uint32 realmId);
         ~AppenderDB();
         void setEnable(bool enable);
 
     private:
-        uint8 realm;
+        uint32 realm;
         bool enable;
         void _write(LogMessage& message);
 };
diff --git a/src/server/shared/Logging/Log.cpp b/src/server/shared/Logging/Log.cpp
index d8914ac8ee0..c2aef9ac125 100644
--- a/src/server/shared/Logging/Log.cpp
+++ b/src/server/shared/Logging/Log.cpp
@@ -169,7 +169,7 @@ void Log::CreateLoggerFromConfig(const char* name)
         return;
 
     LogLevel level = LOG_LEVEL_DISABLED;
-    int32 type = -1;
+    uint8 type = uint8(-1);
 
     std::string options = "Logger.";
     options.append(name);
@@ -190,7 +190,7 @@ void Log::CreateLoggerFromConfig(const char* name)
         return;
     }
 
-    type = atoi(*iter);
+    type = uint8(atoi(*iter));
     if (type > MaxLogFilter)
     {
         fprintf(stderr, "Log::CreateLoggerFromConfig: Wrong type %u for logger %s\n", type, name);
@@ -334,7 +334,7 @@ bool Log::SetLogLevel(std::string const& name, const char* newLevelc, bool isLog
 
 bool Log::ShouldLog(LogFilterType type, LogLevel level) const
 {
-    LoggerMap::const_iterator it = loggers.find(type);
+    LoggerMap::const_iterator it = loggers.find(uint8(type));
     if (it != loggers.end())
     {
         LogLevel loggerLevel = it->second.getLogLevel();
diff --git a/src/server/shared/Utilities/Util.cpp b/src/server/shared/Utilities/Util.cpp
index 407d0704619..cc4e5e6fe07 100644
--- a/src/server/shared/Utilities/Util.cpp
+++ b/src/server/shared/Utilities/Util.cpp
@@ -163,9 +163,9 @@ int32 MoneyStringToMoney(const std::string& moneyString)
     for (Tokenizer::const_iterator itr = tokens.begin(); itr != tokens.end(); ++itr)
     {
         std::string tokenString(*itr);
-        uint32 gCount = std::count(tokenString.begin(), tokenString.end(), 'g');
-        uint32 sCount = std::count(tokenString.begin(), tokenString.end(), 's');
-        uint32 cCount = std::count(tokenString.begin(), tokenString.end(), 'c');
+        size_t gCount = std::count(tokenString.begin(), tokenString.end(), 'g');
+        size_t sCount = std::count(tokenString.begin(), tokenString.end(), 's');
+        size_t cCount = std::count(tokenString.begin(), tokenString.end(), 'c');
         if (gCount + sCount + cCount != 1)
             return 0;