[Sync] Project sync

src/shared/ByteBuffer.h

@@ -52,12 +52,24 @@ class ObjectGuid;
 class ByteBufferException
 {
     public:
+    /**
+     * @brief
+     *
+     * @param _add
+     * @param _pos
+     * @param _esize
+     * @param _size
+     */
         ByteBufferException(bool _add, size_t _pos, size_t _esize, size_t _size)
             : add(_add), pos(_pos), esize(_esize), size(_size)
         {
             PrintPosError();
         }
 
+        /**
+         * @brief
+         *
+         */
         void PrintPosError() const
         {
             char const* traceStr;
@@ -76,10 +88,10 @@ class ByteBufferException
                 traceStr ? "\n" : "", traceStr ? traceStr : "");
         }
     private:
-        bool add;
+        bool add; /**< TODO */
-        size_t pos;
+        size_t pos; /**< TODO */
-        size_t esize;
+        size_t esize; /**< TODO */
-        size_t size;
+        size_t size; /**< TODO */
 };
 
 class BitStream
@@ -124,11 +136,23 @@ class BitStream
 };
 
 template<class T>
+/**
+ * @brief
+ *
+ */
 struct Unused
 {
+/**
+ * @brief
+ *
+ */
     Unused() {}
 };
 
+/**
+ * @brief
+ *
+ */
 class ByteBuffer
 {
     public:
@@ -152,6 +176,10 @@ class ByteBuffer
         {
         }
 
+        /**
+         * @brief
+         *
+         */
         void clear()
         {
             _storage.clear();
@@ -325,68 +353,132 @@ class ByteBuffer
             put(pos, (uint8*)&value, sizeof(value));
         }
 
+        /**
+         * @brief
+         *
+         * @param value
+         * @return ByteBuffer &operator
+         */
         ByteBuffer& operator<<(uint8 value)
         {
             append<uint8>(value);
             return *this;
         }
 
+        /**
+         * @brief
+         *
+         * @param value
+         * @return ByteBuffer &operator
+         */
         ByteBuffer& operator<<(uint16 value)
         {
             append<uint16>(value);
             return *this;
         }
 
+        /**
+         * @brief
+         *
+         * @param value
+         * @return ByteBuffer &operator
+         */
         ByteBuffer& operator<<(uint32 value)
         {
             append<uint32>(value);
             return *this;
         }
 
+        /**
+         * @brief
+         *
+         * @param value
+         * @return ByteBuffer &operator
+         */
         ByteBuffer& operator<<(uint64 value)
         {
             append<uint64>(value);
             return *this;
         }
 
-        // signed as in 2e complement
+        /**
+         * @brief signed as in 2e complement
+         *
+         * @param value
+         * @return ByteBuffer &operator
+         */
         ByteBuffer& operator<<(int8 value)
         {
             append<int8>(value);
             return *this;
         }
 
+        /**
+         * @brief
+         *
+         * @param value
+         * @return ByteBuffer &operator
+         */
         ByteBuffer& operator<<(int16 value)
         {
             append<int16>(value);
             return *this;
         }
 
+        /**
+         * @brief
+         *
+         * @param value
+         * @return ByteBuffer &operator
+         */
         ByteBuffer& operator<<(int32 value)
         {
             append<int32>(value);
             return *this;
         }
 
+        /**
+         * @brief
+         *
+         * @param value
+         * @return ByteBuffer &operator
+         */
         ByteBuffer& operator<<(int64 value)
         {
             append<int64>(value);
             return *this;
         }
 
-        // floating points
+        /**
+         * @brief floating points
+         *
+         * @param value
+         * @return ByteBuffer &operator
+         */
         ByteBuffer& operator<<(float value)
         {
             append<float>(value);
             return *this;
         }
 
+        /**
+         * @brief
+         *
+         * @param value
+         * @return ByteBuffer &operator
+         */
         ByteBuffer& operator<<(double value)
         {
             append<double>(value);
             return *this;
         }
 
+        /**
+         * @brief
+         *
+         * @param value
+         * @return ByteBuffer &operator
+         */
         ByteBuffer& operator<<(const std::string& value)
         {
             append((uint8 const*)value.c_str(), value.length());
@@ -394,6 +486,12 @@ class ByteBuffer
             return *this;
         }
 
+        /**
+         * @brief
+         *
+         * @param str
+         * @return ByteBuffer &operator
+         */
         ByteBuffer& operator<<(const char* str)
         {
             append((uint8 const*)str, str ? strlen(str) : 0);
@@ -401,73 +499,144 @@ class ByteBuffer
             return *this;
         }
 
+        /**
+         * @brief
+         *
+         * @param value
+         * @return ByteBuffer &operator >>
+         */
         ByteBuffer& operator>>(bool& value)
         {
             value = read<char>() > 0 ? true : false;
             return *this;
         }
 
+        /**
+         * @brief
+         *
+         * @param value
+         * @return ByteBuffer &operator >>
+         */
         ByteBuffer& operator>>(uint8& value)
         {
             value = read<uint8>();
             return *this;
         }
 
+        /**
+         * @brief
+         *
+         * @param value
+         * @return ByteBuffer &operator >>
+         */
         ByteBuffer& operator>>(uint16& value)
         {
             value = read<uint16>();
             return *this;
         }
 
+        /**
+         * @brief
+         *
+         * @param value
+         * @return ByteBuffer &operator >>
+         */
         ByteBuffer& operator>>(uint32& value)
         {
             value = read<uint32>();
             return *this;
         }
 
+        /**
+         * @brief
+         *
+         * @param value
+         * @return ByteBuffer &operator >>
+         */
         ByteBuffer& operator>>(uint64& value)
         {
             value = read<uint64>();
             return *this;
         }
 
-        // signed as in 2e complement
+        /**
+         * @brief signed as in 2e complement
+         *
+         * @param value
+         * @return ByteBuffer &operator >>
+         */
         ByteBuffer& operator>>(int8& value)
         {
             value = read<int8>();
             return *this;
         }
 
+        /**
+         * @brief
+         *
+         * @param value
+         * @return ByteBuffer &operator >>
+         */
         ByteBuffer& operator>>(int16& value)
         {
             value = read<int16>();
             return *this;
         }
 
+        /**
+         * @brief
+         *
+         * @param value
+         * @return ByteBuffer &operator >>
+         */
         ByteBuffer& operator>>(int32& value)
         {
             value = read<int32>();
             return *this;
         }
 
+        /**
+         * @brief
+         *
+         * @param value
+         * @return ByteBuffer &operator >>
+         */
         ByteBuffer& operator>>(int64& value)
         {
             value = read<int64>();
             return *this;
         }
 
+        /**
+         * @brief
+         *
+         * @param value
+         * @return ByteBuffer &operator >>
+         */
         ByteBuffer& operator>>(float& value)
         {
             value = read<float>();
             return *this;
         }
 
+        /**
+         * @brief
+         *
+         * @param value
+         * @return ByteBuffer &operator >>
+         */
         ByteBuffer& operator>>(double& value)
         {
             value = read<double>();
             return *this;
         }
 
+        /**
+         * @brief
+         *
+         * @param value
+         * @return ByteBuffer &operator >>
+         */
         ByteBuffer& operator>>(std::string& value)
         {
             value.clear();
@@ -475,13 +644,19 @@ class ByteBuffer
             {
                 char c = read<char>();
                 if (c == 0)
-                    break;
+                    { break; }
                 value += c;
             }
             return *this;
         }
 
         template<class T>
+        /**
+         * @brief
+         *
+         * @param
+         * @return ByteBuffer &operator >>
+         */
         ByteBuffer& operator>>(Unused<T> const&)
         {
             return read_skip<T>();
@@ -501,8 +676,19 @@ class ByteBuffer
             return _storage[pos];
         }
 
+        /**
+         * @brief
+         *
+         * @return size_t
+         */
         size_t rpos() const { return _rpos; }
 
+        /**
+         * @brief
+         *
+         * @param rpos_
+         * @return size_t
+         */
         size_t rpos(size_t rpos_)
         {
             _rpos = rpos_;
@@ -516,6 +702,12 @@ class ByteBuffer
 
         size_t wpos() const { return _wpos; }
 
+        /**
+         * @brief
+         *
+         * @param wpos_
+         * @return size_t
+         */
         size_t wpos(size_t wpos_)
         {
             _wpos = wpos_;
@@ -539,6 +731,11 @@ class ByteBuffer
             return *this;
         }
 
+        /**
+         * @brief
+         *
+         * @return T
+         */
         template <typename T> T read()
         {
             ResetBitReader();
@@ -547,10 +744,16 @@ class ByteBuffer
             return r;
         }
 
+        /**
+         * @brief
+         *
+         * @param pos
+         * @return T
+         */
         template <typename T> T read(size_t pos) const
         {
-            if(pos + sizeof(T) > size())
+            if (pos + sizeof(T) > size())
-                throw ByteBufferException(false, pos, sizeof(T), size());
+                { throw ByteBufferException(false, pos, sizeof(T), size()); }
             T val = *((T const*)&_storage[pos]);
             EndianConvert(val);
             return val;
@@ -567,15 +770,20 @@ class ByteBuffer
             return *this;
         }
 
+        /**
+         * @brief
+         *
+         * @return uint64
+         */
         uint64 readPackGUID()
         {
             uint64 guid = 0;
             uint8 guidmark = 0;
             (*this) >> guidmark;
 
-            for(int i = 0; i < 8; ++i)
+            for (int i = 0; i < 8; ++i)
             {
-                if(guidmark & (uint8(1) << i))
+                if (guidmark & (uint8(1) << i))
                 {
                     uint8 bit;
                     (*this) >> bit;

src/shared/CMakeLists.txt

@@ -1,3 +1,26 @@
+# This code is part of MaNGOS. Contributor & Copyright details are in AUTHORS/THANKS.
+#
+# ***** BEGIN GPL LICENSE BLOCK *****
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+# ***** END GPL LICENSE BLOCK *****
+#
+# World of Warcraft, and all World of Warcraft or Warcraft art, images,
+# and lore are copyrighted by Blizzard Entertainment, Inc.
+
 set(LIBRARY_NAME shared)
 
 set(SRC_GRP_AUTH

src/shared/Common.cpp

@@ -57,7 +57,7 @@ LocaleConstant GetLocaleByName(const std::string& name)
 {
     for (LocaleNameStr const* itr = &fullLocaleNameList[0]; itr->name; ++itr)
         if (name == itr->name)
-            return itr->locale;
+            { return itr->locale; }
 
     return LOCALE_enUS;                                     // including enGB case
 }

src/shared/Common.h

@@ -103,6 +103,10 @@
 // Old ACE versions (pre-ACE-5.5.4) not have this type (add for allow use at Unix side external old ACE versions)
 #if PLATFORM != PLATFORM_WINDOWS
 #  ifndef ACE_OFF_T
+/**
+ * @brief
+ *
+ */
 typedef off_t ACE_OFF_T;
 #  endif
 #endif
@@ -154,6 +158,12 @@ typedef off_t ACE_OFF_T;
 
 #define SIZEFMTD ACE_SIZE_T_FORMAT_SPECIFIER
 
+/**
+ * @brief
+ *
+ * @param f
+ * @return float
+ */
 inline float finiteAlways(float f) { return finite(f) ? f : 0.0f; }
 
 #define atol(a) strtoul( a, NULL, 10)
@@ -169,6 +179,10 @@ inline float finiteAlways(float f) { return finite(f) ? f : 0.0f; }
 #define PAIR32_HIPART(x)   (uint16)((uint32(x) >> 16) & 0x0000FFFF)
 #define PAIR32_LOPART(x)   (uint16)(uint32(x)         & 0x0000FFFF)
 
+/**
+ * @brief
+ *
+ */
 enum TimeConstants
 {
     MINUTE = 60,
@@ -180,6 +194,10 @@ enum TimeConstants
     IN_MILLISECONDS = 1000
 };
 
+/**
+ * @brief
+ *
+ */
 enum AccountTypes
 {
     SEC_PLAYER         = 0,
@@ -189,7 +207,10 @@ enum AccountTypes
     SEC_CONSOLE        = 4                                  // must be always last in list, accounts must have less security level always also
 };
 
-// Used in mangosd/realmd
+/**
+ * @brief Used in mangosd/realmd
+ *
+ */
 enum RealmFlags
 {
     REALM_FLAG_NONE         = 0x00,
@@ -203,6 +224,10 @@ enum RealmFlags
     REALM_FLAG_FULL         = 0x80
 };
 
+/**
+ * @brief
+ *
+ */
 enum LocaleConstant
 {
     LOCALE_enUS = 0,                                        // also enGB
@@ -218,20 +243,35 @@ enum LocaleConstant
 
 #define MAX_LOCALE 9
 
+/**
+ * @brief
+ *
+ * @param name
+ * @return LocaleConstant
+ */
 LocaleConstant GetLocaleByName(const std::string& name);
 
-extern char const* localeNames[MAX_LOCALE];
 
+extern char const* localeNames[MAX_LOCALE]; /**< TODO */
+
+/**
+ * @brief
+ *
+ */
 struct LocaleNameStr
 {
-    char const* name;
+    char const* name; /**< TODO */
-    LocaleConstant locale;
+    LocaleConstant locale; /**< TODO */
 };
 
-// used for iterate all names including alternative
+extern LocaleNameStr const fullLocaleNameList[]; /**< used for iterate all names including alternative */
-extern LocaleNameStr const fullLocaleNameList[];
 
-// operator new[] based version of strdup() function! Release memory by using operator delete[] !
+/**
+ * @brief operator new[] based version of strdup() function! Release memory by using operator delete[] !
+ *
+ * @param source
+ * @return char
+ */
 inline char* mangos_strdup(const char* source)
 {
     char* dest = new char[strlen(source) + 1];

src/shared/Errors.h

@@ -38,39 +38,39 @@
 #ifdef HAVE_ACE_STACK_TRACE_H
 // Normal assert.
 #define WPError(CONDITION) \
-if (!(CONDITION)) \
+    if (!(CONDITION)) \
-{ \
+    { \
         ACE_Stack_Trace st; \
         printf("%s:%i: Error: Assertion in %s failed: %s\nStack Trace:\n%s", \
                __FILE__, __LINE__, __FUNCTION__, STRINGIZE(CONDITION), st.c_str()); \
         assert(STRINGIZE(CONDITION) && 0); \
-}
+    }
 
 // Just warn.
 #define WPWarning(CONDITION) \
-if (!(CONDITION)) \
+    if (!(CONDITION)) \
-{ \
+    { \
         ACE_Stack_Trace st; \
         printf("%s:%i: Warning: Assertion in %s failed: %s\nStack Trace:\n%s",\
                __FILE__, __LINE__, __FUNCTION__, STRINGIZE(CONDITION), st.c_str()); \
-}
+    }
 #else
 // Normal assert.
 #define WPError(CONDITION) \
-if (!(CONDITION)) \
+    if (!(CONDITION)) \
-{ \
+    { \
         printf("%s:%i: Error: Assertion in %s failed: %s", \
                __FILE__, __LINE__, __FUNCTION__, STRINGIZE(CONDITION)); \
         assert(STRINGIZE(CONDITION) && 0); \
-}
+    }
 
 // Just warn.
 #define WPWarning(CONDITION) \
-if (!(CONDITION)) \
+    if (!(CONDITION)) \
-{ \
+    { \
         printf("%s:%i: Warning: Assertion in %s failed: %s",\
                __FILE__, __LINE__, __FUNCTION__, STRINGIZE(CONDITION)); \
-}
+    }
 #endif
 
 #ifdef MANGOS_DEBUG

src/shared/LockedQueue.h

@@ -33,45 +33,61 @@
 
 namespace ACE_Based
 {
-    template <class T, class LockType, typename StorageType = std::deque<T> >
+    template < class T, class LockType, typename StorageType = std::deque<T> >
+    /**
+     * @brief
+     *
+     */
     class LockedQueue
     {
-            //! Lock access to the queue.
+            LockType _lock; /**< Lock access to the queue. */
-            LockType _lock;
 
-            //! Storage backing the queue.
+            StorageType _queue; /**< Storage backing the queue. */
-            StorageType _queue;
 
-            //! Cancellation flag.
+            /*volatile*/ bool _canceled; /**< Cancellation flag. */
-            /*volatile*/ bool _canceled;
 
         public:
 
-            //! Create a LockedQueue.
+            /**
+             * @brief Create a LockedQueue.
+             *
+             */
             LockedQueue()
                 : _canceled(false)
             {
             }
 
-            //! Destroy a LockedQueue.
+            /**
+             * @brief Destroy a LockedQueue.
+             *
+             */
             virtual ~LockedQueue()
             {
             }
 
-            //! Adds an item to the queue.
+            /**
+             * @brief Adds an item to the queue.
+             *
+             * @param item
+             */
             void add(const T& item)
             {
                 ACE_Guard<LockType> g(this->_lock);
                 _queue.push_back(item);
             }
 
-            //! Gets the next result in the queue, if any.
+            /**
+             * @brief Gets the next result in the queue, if any.
+             *
+             * @param result
+             * @return bool
+             */
             bool next(T& result)
             {
                 ACE_GUARD_RETURN(LockType, g, this->_lock, false);
 
                 if (_queue.empty())
-                    return false;
+                    { return false; }
 
                 result = _queue.front();
                 _queue.pop_front();
@@ -80,22 +96,33 @@ namespace ACE_Based
             }
 
             template<class Checker>
+            /**
+             * @brief
+             *
+             * @param result
+             * @param check
+             * @return bool
+             */
             bool next(T& result, Checker& check)
             {
                 ACE_GUARD_RETURN(LockType, g, this->_lock, false);
 
                 if (_queue.empty())
-                    return false;
+                    { return false; }
 
                 result = _queue.front();
                 if (!check.Process(result))
-                    return false;
+                    { return false; }
 
                 _queue.pop_front();
                 return true;
             }
 
-            //! Peeks at the top of the queue. Remember to unlock after use.
+            /**
+             * @brief Peeks at the top of the queue. Remember to unlock after use.
+             *
+             * @return T
+             */
             T& peek()
             {
                 lock();
@@ -105,33 +132,50 @@ namespace ACE_Based
                 return result;
             }
 
-            //! Cancels the queue.
+            /**
+             * @brief Cancels the queue.
+             *
+             */
             void cancel()
             {
                 ACE_Guard<LockType> g(this->_lock);
                 _canceled = true;
             }
 
-            //! Checks if the queue is cancelled.
+            /**
+             * @brief Checks if the queue is cancelled.
+             *
+             * @return bool
+             */
             bool cancelled()
             {
                 ACE_Guard<LockType> g(this->_lock);
                 return _canceled;
             }
 
-            //! Locks the queue for access.
+            /**
+             * @brief Locks the queue for access.
+             *
+             */
             void lock()
             {
                 this->_lock.acquire();
             }
 
-            //! Unlocks the queue.
+            /**
+             * @brief Unlocks the queue.
+             *
+             */
             void unlock()
             {
                 this->_lock.release();
             }
 
-            ///! Checks if we're empty or not with locks held
+            /**
+             * @brief Checks if we're empty or not with locks held
+             *
+             * @return bool
+             */
             bool empty()
             {
                 ACE_Guard<LockType> g(this->_lock);

src/shared/Log.cpp

@@ -96,14 +96,14 @@ void Log::InitColors(const std::string& str)
         ss >> color[i];
 
         if (!ss)
-            return;
+            { return; }
 
         if (color[i] < 0 || color[i] >= Color_count)
-            return;
+            { return; }
     }
 
     for (int i = 0; i < LogType_count; ++i)
-        m_colors[i] = Color(color[i]);
+        { m_colors[i] = Color(color[i]); }
 
     m_colored = true;
 }
@@ -199,9 +199,9 @@ void Log::SetLogLevel(char* level)
     int32 newLevel = atoi((char*)level);
 
     if (newLevel < LOG_LVL_MINIMAL)
-        newLevel = LOG_LVL_MINIMAL;
+        { newLevel = LOG_LVL_MINIMAL; }
     else if (newLevel > LOG_LVL_DEBUG)
-        newLevel = LOG_LVL_DEBUG;
+        { newLevel = LOG_LVL_DEBUG; }
 
     m_logLevel = LogLevel(newLevel);
 
@@ -213,9 +213,9 @@ void Log::SetLogFileLevel(char* level)
     int32 newLevel = atoi((char*)level);
 
     if (newLevel < LOG_LVL_MINIMAL)
-        newLevel = LOG_LVL_MINIMAL;
+        { newLevel = LOG_LVL_MINIMAL; }
     else if (newLevel > LOG_LVL_DEBUG)
-        newLevel = LOG_LVL_DEBUG;
+        { newLevel = LOG_LVL_DEBUG; }
 
     m_logFileLevel = LogLevel(newLevel);
 
@@ -229,7 +229,7 @@ void Log::Initialize()
     if (!m_logsDir.empty())
     {
         if ((m_logsDir.at(m_logsDir.length() - 1) != '/') && (m_logsDir.at(m_logsDir.length() - 1) != '\\'))
-            m_logsDir.append("/");
+            { m_logsDir.append("/"); }
     }
 
     m_logsTimestamp = "_" + GetTimestampStr();
@@ -239,7 +239,7 @@ void Log::Initialize()
 
     m_gmlog_per_account = sConfig.GetBoolDefault("GmLogPerAccount", false);
     if (!m_gmlog_per_account)
-        gmLogfile = openLogFile("GMLogFile", "GmLogTimestamp", "a");
+        { gmLogfile = openLogFile("GMLogFile", "GmLogTimestamp", "a"); }
     else
     {
         // GM log settings for per account case
@@ -252,7 +252,7 @@ void Log::Initialize()
             if (dot_pos != m_gmlog_filename_format.npos)
             {
                 if (m_gmlog_timestamp)
-                    m_gmlog_filename_format.insert(dot_pos, m_logsTimestamp);
+                    { m_gmlog_filename_format.insert(dot_pos, m_logsTimestamp); }
 
                 m_gmlog_filename_format.insert(dot_pos, "_#%u");
             }
@@ -261,7 +261,7 @@ void Log::Initialize()
                 m_gmlog_filename_format += "_#%u";
 
                 if (m_gmlog_timestamp)
-                    m_gmlog_filename_format += m_logsTimestamp;
+                    { m_gmlog_filename_format += m_logsTimestamp; }
             }
 
             m_gmlog_filename_format = m_logsDir + m_gmlog_filename_format;
@@ -284,7 +284,7 @@ void Log::Initialize()
     for (int i = 0; i < LOG_FILTER_COUNT; ++i)
         if (*logFilterData[i].name)
             if (sConfig.GetBoolDefault(logFilterData[i].configName, logFilterData[i].defaultState))
-                m_logFilter |= (1 << i);
+                { m_logFilter |= (1 << i); }
 
     // Char log settings
     m_charLog_Dump = sConfig.GetBoolDefault("CharLogDump", false);
@@ -294,15 +294,15 @@ FILE* Log::openLogFile(char const* configFileName, char const* configTimeStampFl
 {
     std::string logfn = sConfig.GetStringDefault(configFileName, "");
     if (logfn.empty())
-        return NULL;
+        { return NULL; }
 
     if (configTimeStampFlag && sConfig.GetBoolDefault(configTimeStampFlag, false))
     {
         size_t dot_pos = logfn.find_last_of(".");
         if (dot_pos != logfn.npos)
-            logfn.insert(dot_pos, m_logsTimestamp);
+            { logfn.insert(dot_pos, m_logsTimestamp); }
         else
-            logfn += m_logsTimestamp;
+            { logfn += m_logsTimestamp; }
     }
 
     return fopen((m_logsDir + logfn).c_str(), mode);
@@ -311,7 +311,7 @@ FILE* Log::openLogFile(char const* configFileName, char const* configTimeStampFl
 FILE* Log::openGmlogPerAccount(uint32 account)
 {
     if (m_gmlog_filename_format.empty())
-        return NULL;
+        { return NULL; }
 
     char namebuf[MANGOS_PATH_MAX];
     snprintf(namebuf, MANGOS_PATH_MAX, m_gmlog_filename_format.c_str(), account);
@@ -362,7 +362,7 @@ std::string Log::GetTimestampStr()
 void Log::outString()
 {
     if (m_includeTime)
-        outTime();
+        { outTime(); }
     printf("\n");
     if (logfile)
     {
@@ -377,13 +377,13 @@ void Log::outString()
 void Log::outString(const char* str, ...)
 {
     if (!str)
-        return;
+        { return; }
 
     if (m_colored)
-        SetColor(true, m_colors[LogNormal]);
+        { SetColor(true, m_colors[LogNormal]); }
 
     if (m_includeTime)
-        outTime();
+        { outTime(); }
 
     va_list ap;
 
@@ -392,7 +392,7 @@ void Log::outString(const char* str, ...)
     va_end(ap);
 
     if (m_colored)
-        ResetColor(true);
+        { ResetColor(true); }
 
     printf("\n");
 
@@ -414,13 +414,13 @@ void Log::outString(const char* str, ...)
 void Log::outError(const char* err, ...)
 {
     if (!err)
-        return;
+        { return; }
 
     if (m_colored)
-        SetColor(false, m_colors[LogError]);
+        { SetColor(false, m_colors[LogError]); }
 
     if (m_includeTime)
-        outTime();
+        { outTime(); }
 
     va_list ap;
 
@@ -429,7 +429,7 @@ void Log::outError(const char* err, ...)
     va_end(ap);
 
     if (m_colored)
-        ResetColor(false);
+        { ResetColor(false); }
 
     fprintf(stderr, "\n");
     if (logfile)
@@ -451,7 +451,7 @@ void Log::outError(const char* err, ...)
 void Log::outErrorDb()
 {
     if (m_includeTime)
-        outTime();
+        { outTime(); }
 
     fprintf(stderr, "\n");
 
@@ -475,13 +475,13 @@ void Log::outErrorDb()
 void Log::outErrorDb(const char* err, ...)
 {
     if (!err)
-        return;
+        { return; }
 
     if (m_colored)
-        SetColor(false, m_colors[LogError]);
+        { SetColor(false, m_colors[LogError]); }
 
     if (m_includeTime)
-        outTime();
+        { outTime(); }
 
     va_list ap;
 
@@ -490,7 +490,7 @@ void Log::outErrorDb(const char* err, ...)
     va_end(ap);
 
     if (m_colored)
-        ResetColor(false);
+        { ResetColor(false); }
 
     fprintf(stderr, "\n");
 
@@ -526,7 +526,7 @@ void Log::outErrorDb(const char* err, ...)
 void Log::outErrorEventAI()
 {
     if (m_includeTime)
-        outTime();
+        { outTime(); }
 
     fprintf(stderr, "\n");
 
@@ -550,13 +550,13 @@ void Log::outErrorEventAI()
 void Log::outErrorEventAI(const char* err, ...)
 {
     if (!err)
-        return;
+        { return; }
 
     if (m_colored)
-        SetColor(false, m_colors[LogError]);
+        { SetColor(false, m_colors[LogError]); }
 
     if (m_includeTime)
-        outTime();
+        { outTime(); }
 
     va_list ap;
 
@@ -565,7 +565,7 @@ void Log::outErrorEventAI(const char* err, ...)
     va_end(ap);
 
     if (m_colored)
-        ResetColor(false);
+        { ResetColor(false); }
 
     fprintf(stderr, "\n");
 
@@ -601,15 +601,15 @@ void Log::outErrorEventAI(const char* err, ...)
 void Log::outBasic(const char* str, ...)
 {
     if (!str)
-        return;
+        { return; }
 
     if (m_logLevel >= LOG_LVL_BASIC)
     {
         if (m_colored)
-            SetColor(true, m_colors[LogDetails]);
+            { SetColor(true, m_colors[LogDetails]); }
 
         if (m_includeTime)
-            outTime();
+            { outTime(); }
 
         va_list ap;
         va_start(ap, str);
@@ -617,7 +617,7 @@ void Log::outBasic(const char* str, ...)
         va_end(ap);
 
         if (m_colored)
-            ResetColor(true);
+            { ResetColor(true); }
 
         printf("\n");
     }
@@ -639,15 +639,15 @@ void Log::outBasic(const char* str, ...)
 void Log::outDetail(const char* str, ...)
 {
     if (!str)
-        return;
+        { return; }
 
     if (m_logLevel >= LOG_LVL_DETAIL)
     {
         if (m_colored)
-            SetColor(true, m_colors[LogDetails]);
+            { SetColor(true, m_colors[LogDetails]); }
 
         if (m_includeTime)
-            outTime();
+            { outTime(); }
 
         va_list ap;
         va_start(ap, str);
@@ -655,7 +655,7 @@ void Log::outDetail(const char* str, ...)
         va_end(ap);
 
         if (m_colored)
-            ResetColor(true);
+            { ResetColor(true); }
 
         printf("\n");
     }
@@ -679,15 +679,15 @@ void Log::outDetail(const char* str, ...)
 void Log::outDebug(const char* str, ...)
 {
     if (!str)
-        return;
+        { return; }
 
     if (m_logLevel >= LOG_LVL_DEBUG)
     {
         if (m_colored)
-            SetColor(true, m_colors[LogDebug]);
+            { SetColor(true, m_colors[LogDebug]); }
 
         if (m_includeTime)
-            outTime();
+            { outTime(); }
 
         va_list ap;
         va_start(ap, str);
@@ -695,7 +695,7 @@ void Log::outDebug(const char* str, ...)
         va_end(ap);
 
         if (m_colored)
-            ResetColor(true);
+            { ResetColor(true); }
 
         printf("\n");
     }
@@ -719,15 +719,15 @@ void Log::outDebug(const char* str, ...)
 void Log::outCommand(uint32 account, const char* str, ...)
 {
     if (!str)
-        return;
+        { return; }
 
     if (m_logLevel >= LOG_LVL_DETAIL)
     {
         if (m_colored)
-            SetColor(true, m_colors[LogDetails]);
+            { SetColor(true, m_colors[LogDetails]); }
 
         if (m_includeTime)
-            outTime();
+            { outTime(); }
 
         va_list ap;
         va_start(ap, str);
@@ -735,7 +735,7 @@ void Log::outCommand(uint32 account, const char* str, ...)
         va_end(ap);
 
         if (m_colored)
-            ResetColor(true);
+            { ResetColor(true); }
 
         printf("\n");
     }
@@ -781,7 +781,7 @@ void Log::outCommand(uint32 account, const char* str, ...)
 void Log::outChar(const char* str, ...)
 {
     if (!str)
-        return;
+        { return; }
 
     if (charLogfile)
     {
@@ -798,7 +798,7 @@ void Log::outChar(const char* str, ...)
 void Log::outErrorScriptLib()
 {
     if (m_includeTime)
-        outTime();
+        { outTime(); }
 
     fprintf(stderr, "\n");
 
@@ -806,9 +806,9 @@ void Log::outErrorScriptLib()
     {
         outTimestamp(logfile);
         if (m_scriptLibName)
-            fprintf(logfile, "<%s ERROR:> ", m_scriptLibName);
+            { fprintf(logfile, "<%s ERROR:> ", m_scriptLibName); }
         else
-            fprintf(logfile, "<Scripting Library ERROR>: ");
+            { fprintf(logfile, "<Scripting Library ERROR>: "); }
         fflush(logfile);
     }
 
@@ -825,13 +825,13 @@ void Log::outErrorScriptLib()
 void Log::outErrorScriptLib(const char* err, ...)
 {
     if (!err)
-        return;
+        { return; }
 
     if (m_colored)
-        SetColor(false, m_colors[LogError]);
+        { SetColor(false, m_colors[LogError]); }
 
     if (m_includeTime)
-        outTime();
+        { outTime(); }
 
     va_list ap;
 
@@ -840,7 +840,7 @@ void Log::outErrorScriptLib(const char* err, ...)
     va_end(ap);
 
     if (m_colored)
-        ResetColor(false);
+        { ResetColor(false); }
 
     fprintf(stderr, "\n");
 
@@ -848,9 +848,9 @@ void Log::outErrorScriptLib(const char* err, ...)
     {
         outTimestamp(logfile);
         if (m_scriptLibName)
-            fprintf(logfile, "<%s ERROR>: ", m_scriptLibName);
+            { fprintf(logfile, "<%s ERROR>: ", m_scriptLibName); }
         else
-            fprintf(logfile, "<Scripting Library ERROR>: ");
+            { fprintf(logfile, "<Scripting Library ERROR>: "); }
 
         va_start(ap, err);
         vfprintf(logfile, err, ap);
@@ -879,7 +879,7 @@ void Log::outErrorScriptLib(const char* err, ...)
 void Log::outWorldPacketDump(uint32 socket, uint32 opcode, char const* opcodeName, ByteBuffer const* packet, bool incoming)
 {
     if (!worldLogfile)
-        return;
+        { return; }
 
     ACE_GUARD(ACE_Thread_Mutex, GuardObj, m_worldLogMtx);
 
@@ -893,7 +893,7 @@ void Log::outWorldPacketDump(uint32 socket, uint32 opcode, char const* opcodeNam
     while (p < packet->size())
     {
         for (size_t j = 0; j < 16 && p < packet->size(); ++j)
-            fprintf(worldLogfile, "%.2X ", (*packet)[p++]);
+            { fprintf(worldLogfile, "%.2X ", (*packet)[p++]); }
 
         fprintf(worldLogfile, "\n");
     }
@@ -914,7 +914,7 @@ void Log::outCharDump(const char* str, uint32 account_id, uint32 guid, const cha
 void Log::outRALog(const char* str, ...)
 {
     if (!str)
-        return;
+        { return; }
 
     if (raLogfile)
     {
@@ -958,7 +958,7 @@ void Log::setScriptLibraryErrorFile(char const* fname, char const* libName)
     m_scriptLibName = libName;
 
     if (scriptErrLogFile)
-        fclose(scriptErrLogFile);
+        { fclose(scriptErrLogFile); }
 
     if (!fname)
     {
@@ -974,7 +974,7 @@ void Log::setScriptLibraryErrorFile(char const* fname, char const* libName)
 void outstring_log(const char* str, ...)
 {
     if (!str)
-        return;
+        { return; }
 
     char buf[256];
     va_list ap;
@@ -988,7 +988,7 @@ void outstring_log(const char* str, ...)
 void detail_log(const char* str, ...)
 {
     if (!str)
-        return;
+        { return; }
 
     char buf[256];
     va_list ap;
@@ -1002,7 +1002,7 @@ void detail_log(const char* str, ...)
 void debug_log(const char* str, ...)
 {
     if (!str)
-        return;
+        { return; }
 
     char buf[256];
     va_list ap;
@@ -1016,7 +1016,7 @@ void debug_log(const char* str, ...)
 void error_log(const char* str, ...)
 {
     if (!str)
-        return;
+        { return; }
 
     char buf[256];
     va_list ap;
@@ -1030,7 +1030,7 @@ void error_log(const char* str, ...)
 void error_db_log(const char* str, ...)
 {
     if (!str)
-        return;
+        { return; }
 
     char buf[256];
     va_list ap;
@@ -1049,7 +1049,7 @@ void setScriptLibraryErrorFile(char const* fname, char const* libName)
 void script_error_log(const char* str, ...)
 {
     if (!str)
-        return;
+        { return; }
 
     char buf[256];
     va_list ap;

src/shared/Log.h

@@ -31,15 +31,22 @@
 class Config;
 class ByteBuffer;
 
+/**
+ * @brief various levels for logging
+ *
+ */
 enum LogLevel
 {
-    LOG_LVL_MINIMAL = 0,                                    // unconditional and errors
+    LOG_LVL_MINIMAL = 0,
     LOG_LVL_BASIC   = 1,
     LOG_LVL_DETAIL  = 2,
     LOG_LVL_DEBUG   = 3
 };
 
-// bitmask (not forgot update logFilterData content)
+/**
+ * @brief bitmask (not forgot update logFilterData content)
+ *
+ */
 enum LogFilters
 {
     LOG_FILTER_TRANSPORT_MOVES    = 0x000001,               //  0 any related to transport moves
@@ -66,15 +73,23 @@ enum LogFilters
 
 #define LOG_FILTER_COUNT            20
 
+/**
+ * @brief
+ *
+ */
 struct LogFilterData
 {
-    char const* name;
+    char const* name; /**< TODO */
-    char const* configName;
+    char const* configName; /**< TODO */
-    bool defaultState;
+    bool defaultState; /**< TODO */
 };
 
-extern LogFilterData logFilterData[LOG_FILTER_COUNT];
+extern LogFilterData logFilterData[LOG_FILTER_COUNT]; /**< TODO */
 
+/**
+ * @brief
+ *
+ */
 enum Color
 {
     BLACK,
@@ -94,135 +109,324 @@ enum Color
     WHITE
 };
 
-const int Color_count = int(WHITE) + 1;
+const int Color_count = int(WHITE) + 1; /**< TODO */
 
+/**
+ * @brief
+ *
+ */
 class Log : public MaNGOS::Singleton<Log, MaNGOS::ClassLevelLockable<Log, ACE_Thread_Mutex> >
 {
         friend class MaNGOS::OperatorNew<Log>;
+        /**
+         * @brief
+         *
+         */
         Log();
 
+        /**
+         * @brief
+         *
+         */
         ~Log()
         {
             if (logfile != NULL)
-                fclose(logfile);
+                { fclose(logfile); }
             logfile = NULL;
 
             if (gmLogfile != NULL)
-                fclose(gmLogfile);
+                { fclose(gmLogfile); }
             gmLogfile = NULL;
 
             if (charLogfile != NULL)
-                fclose(charLogfile);
+                { fclose(charLogfile); }
             charLogfile = NULL;
 
             if (dberLogfile != NULL)
-                fclose(dberLogfile);
+                { fclose(dberLogfile); }
             dberLogfile = NULL;
 
             if (eventAiErLogfile != NULL)
-                fclose(eventAiErLogfile);
+                { fclose(eventAiErLogfile); }
             eventAiErLogfile = NULL;
 
             if (scriptErrLogFile != NULL)
-                fclose(scriptErrLogFile);
+                { fclose(scriptErrLogFile); }
             scriptErrLogFile = NULL;
 
             if (raLogfile != NULL)
-                fclose(raLogfile);
+                { fclose(raLogfile); }
             raLogfile = NULL;
 
             if (worldLogfile != NULL)
-                fclose(worldLogfile);
+                { fclose(worldLogfile); }
             worldLogfile = NULL;
         }
     public:
+        /**
+         * @brief
+         *
+         */
         void Initialize();
+        /**
+         * @brief
+         *
+         * @param init_str
+         */
         void InitColors(const std::string& init_str);
 
+        /**
+         * @brief
+         *
+         * @param account
+         * @param str...
+         */
         void outCommand(uint32 account, const char* str, ...) ATTR_PRINTF(3, 4);
-        void outString();                                   // any log level
+        /**
-        // any log level
+         * @brief any log level
+         *
+         */
+        void outString();
+        /**
+         * @brief any log level
+         *
+         * @param str...
+         */
         void outString(const char* str, ...)      ATTR_PRINTF(2, 3);
-        // any log level
+        /**
+         * @brief any log level
+         *
+         * @param err...
+         */
         void outError(const char* err, ...)       ATTR_PRINTF(2, 3);
-        // log level >= 1
+        /**
+         * @brief log level >= 1
+         *
+         * @param str...
+         */
         void outBasic(const char* str, ...)       ATTR_PRINTF(2, 3);
-        // log level >= 2
+        /**
+         * @brief log level >= 2
+         *
+         * @param str...
+         */
         void outDetail(const char* str, ...)      ATTR_PRINTF(2, 3);
-        // log level >= 3
+        /**
+         * @brief log level >= 3
+         *
+         * @param str...
+         */
         void outDebug(const char* str, ...)       ATTR_PRINTF(2, 3);
-
+        /**
-        void outErrorDb();                                  // any log level
+         * @brief any log level
-        // any log level
+         *
+         */
+        void outErrorDb();
+        /**
+         * @brief any log level
+         *
+         * @param str...
+         */
         void outErrorDb(const char* str, ...)     ATTR_PRINTF(2, 3);
-        // any log level
+        /**
+         * @brief any log level
+         *
+         * @param str...
+         */
         void outChar(const char* str, ...)        ATTR_PRINTF(2, 3);
 
-        void outErrorEventAI();                             // any log level
+        /**
-        // any log level
+         * @brief any log level
+         *
+         */
+        void outErrorEventAI();
+        /**
+         * @brief any log level
+         *
+         * @param str...
+         */
         void outErrorEventAI(const char* str, ...)      ATTR_PRINTF(2, 3);
 
-        void outErrorScriptLib();                           // any log level
+        /**
-        // any log level
+         * @brief any log level
+         *
+         */
+        void outErrorScriptLib();
+        /**
+         * @brief any log level
+         *
+         * @param str...
+         */
         void outErrorScriptLib(const char* str, ...)     ATTR_PRINTF(2, 3);
 
+        /**
+         * @brief any log level
+         *
+         * @param socket
+         * @param opcode
+         * @param opcodeName
+         * @param packet
+         * @param incoming
+         */
         void outWorldPacketDump(uint32 socket, uint32 opcode, char const* opcodeName, ByteBuffer const* packet, bool incoming);
-        // any log level
+        /**
+         * @brief any log level
+         *
+         * @param str
+         * @param account_id
+         * @param guid
+         * @param name
+         */
         void outCharDump(const char* str, uint32 account_id, uint32 guid, const char* name);
+        /**
+         * @brief
+         *
+         * @param str...
+         */
         void outRALog(const char* str, ...)       ATTR_PRINTF(2, 3);
+        /**
+         * @brief
+         *
+         * @return uint32
+         */
         uint32 GetLogLevel() const { return m_logLevel; }
+        /**
+         * @brief
+         *
+         * @param Level
+         */
         void SetLogLevel(char* Level);
+        /**
+         * @brief
+         *
+         * @param Level
+         */
         void SetLogFileLevel(char* Level);
+        /**
+         * @brief
+         *
+         * @param stdout_stream
+         * @param color
+         */
         void SetColor(bool stdout_stream, Color color);
+        /**
+         * @brief
+         *
+         * @param stdout_stream
+         */
         void ResetColor(bool stdout_stream);
+        /**
+         * @brief
+         *
+         */
         void outTime();
+        /**
+         * @brief
+         *
+         * @param file
+         */
         static void outTimestamp(FILE* file);
+        /**
+         * @brief
+         *
+         * @return std::string
+         */
         static std::string GetTimestampStr();
+        /**
+         * @brief
+         *
+         * @param filter
+         * @return bool
+         */
         bool HasLogFilter(uint32 filter) const { return m_logFilter & filter; }
-        void SetLogFilter(LogFilters filter, bool on) { if (on) m_logFilter |= filter; else m_logFilter &= ~filter; }
+        /**
+         * @brief
+         *
+         * @param filter
+         * @param on
+         */
+        void SetLogFilter(LogFilters filter, bool on) { if (on) { m_logFilter |= filter; } else { m_logFilter &= ~filter; } }
+        /**
+         * @brief
+         *
+         * @param loglvl
+         * @return bool
+         */
         bool HasLogLevelOrHigher(LogLevel loglvl) const { return m_logLevel >= loglvl || (m_logFileLevel >= loglvl && logfile); }
+        /**
+         * @brief
+         *
+         * @return bool
+         */
         bool IsOutCharDump() const { return m_charLog_Dump; }
+        /**
+         * @brief
+         *
+         * @return bool
+         */
         bool IsIncludeTime() const { return m_includeTime; }
 
+        /**
+         * @brief
+         *
+         */
         static void WaitBeforeContinueIfNeed();
 
-        // Set filename for scriptlibrary error output
+        /**
+         * @brief Set filename for scriptlibrary error output
+         *
+         * @param fname
+         * @param libName
+         */
         void setScriptLibraryErrorFile(char const* fname, char const* libName);
 
     private:
+        /**
+         * @brief
+         *
+         * @param configFileName
+         * @param configTimeStampFlag
+         * @param mode
+         * @return FILE
+         */
         FILE* openLogFile(char const* configFileName, char const* configTimeStampFlag, char const* mode);
+        /**
+         * @brief
+         *
+         * @param account
+         * @return FILE
+         */
         FILE* openGmlogPerAccount(uint32 account);
 
-        FILE* raLogfile;
+        FILE* raLogfile; /**< TODO */
-        FILE* logfile;
+        FILE* logfile; /**< TODO */
-        FILE* gmLogfile;
+        FILE* gmLogfile; /**< TODO */
-        FILE* charLogfile;
+        FILE* charLogfile; /**< TODO */
-        FILE* dberLogfile;
+        FILE* dberLogfile; /**< TODO */
-        FILE* eventAiErLogfile;
+        FILE* eventAiErLogfile; /**< TODO */
-        FILE* scriptErrLogFile;
+        FILE* scriptErrLogFile; /**< TODO */
-        FILE* worldLogfile;
+        FILE* worldLogfile; /**< TODO */
-        ACE_Thread_Mutex m_worldLogMtx;
+        ACE_Thread_Mutex m_worldLogMtx; /**< TODO */
 
-        // log/console control
+        LogLevel m_logLevel; /**< log/console control */
-        LogLevel m_logLevel;
+        LogLevel m_logFileLevel; /**< TODO */
-        LogLevel m_logFileLevel;
+        bool m_colored; /**< TODO */
-        bool m_colored;
+        bool m_includeTime; /**< TODO */
-        bool m_includeTime;
+        Color m_colors[4]; /**< TODO */
-        Color m_colors[4];
+        uint32 m_logFilter; /**< TODO */
-        uint32 m_logFilter;
 
         // cache values for after initilization use (like gm log per account case)
-        std::string m_logsDir;
+        std::string m_logsDir; /**< TODO */
-        std::string m_logsTimestamp;
+        std::string m_logsTimestamp; /**< TODO */
 
         // char log control
-        bool m_charLog_Dump;
+        bool m_charLog_Dump; /**< TODO */
 
         // gm log control
-        bool m_gmlog_per_account;
+        bool m_gmlog_per_account; /**< TODO */
-        std::string m_gmlog_filename_format;
+        std::string m_gmlog_filename_format; /**< TODO */
 
-        char const* m_scriptLibName;
+        char const* m_scriptLibName; /**< TODO */
 };
 
 #define sLog MaNGOS::Singleton<Log>::Instance()
@@ -272,13 +476,48 @@ class Log : public MaNGOS::Singleton<Log, MaNGOS::ClassLevelLockable<Log, ACE_Th
 #define ERROR_DB_STRICT_LOG(...) \
     ERROR_DB_FILTER_LOG(LOG_FILTER_DB_STRICTED_CHECK, __VA_ARGS__)
 
-// primary for script library
+/**
+ * @brief primary for script library
+ *
+ * @param str...
+ */
 void MANGOS_DLL_SPEC outstring_log(const char* str, ...) ATTR_PRINTF(1, 2);
+/**
+ * @brief
+ *
+ * @param str...
+ */
 void MANGOS_DLL_SPEC detail_log(const char* str, ...) ATTR_PRINTF(1, 2);
+/**
+ * @brief
+ *
+ * @param str...
+ */
 void MANGOS_DLL_SPEC debug_log(const char* str, ...) ATTR_PRINTF(1, 2);
+/**
+ * @brief
+ *
+ * @param str...
+ */
 void MANGOS_DLL_SPEC error_log(const char* str, ...) ATTR_PRINTF(1, 2);
+/**
+ * @brief
+ *
+ * @param str...
+ */
 void MANGOS_DLL_SPEC error_db_log(const char* str, ...) ATTR_PRINTF(1, 2);
+/**
+ * @brief
+ *
+ * @param fname
+ * @param libName
+ */
 void MANGOS_DLL_SPEC setScriptLibraryErrorFile(char const* fname, char const* libName);
+/**
+ * @brief
+ *
+ * @param str...
+ */
 void MANGOS_DLL_SPEC script_error_log(const char* str, ...) ATTR_PRINTF(1, 2);
 
 #endif

src/shared/PosixDaemon.cpp

@@ -16,7 +16,10 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * World of Warcraft, and all World of Warcraft or Warcraft art, images,
+ * and lore are copyrighted by Blizzard Entertainment, Inc.
  */
 
 #include "Config/Config.h"
@@ -86,9 +89,12 @@ void startDaemon(uint32_t timeout)
         exit(EXIT_FAILURE);
     }
 
-    freopen("/dev/null", "rt", stdin);
+    if (!freopen("/dev/null", "rt", stdin))
-    freopen("/dev/null", "wt", stdout);
+        exit(EXIT_FAILURE);
-    freopen("/dev/null", "wt", stderr);
+    if (!freopen("/dev/null", "wt", stdout))
+        exit(EXIT_FAILURE);
+    if (!freopen("/dev/null", "wt", stderr))
+        exit(EXIT_FAILURE);
 }
 
 void stopDaemon()

src/shared/PosixDaemon.h

@@ -25,6 +25,19 @@
 #include "Common.h"
 #include "Log.h"
 
+/**
+ * @brief
+ *
+ * @param timeout
+ */
 void startDaemon(uint32_t timeout = 10);
+/**
+ * @brief
+ *
+ */
 void stopDaemon();
+/**
+ * @brief
+ *
+ */
 void detachDaemon();

src/shared/ProgressBar.cpp

@@ -56,7 +56,7 @@ BarGoLink::BarGoLink(uint64 row_count)
 BarGoLink::~BarGoLink()
 {
     if (!m_showOutput)
-        return;
+        { return; }
 
     printf("\n");
     fflush(stdout);
@@ -70,14 +70,14 @@ void BarGoLink::init(int row_count)
     num_rec   = row_count;
 
     if (!m_showOutput)
-        return;
+        { return; }
 
 #ifdef _WIN32
     printf("\x3D");
 #else
     printf("[");
 #endif
-    for (int i = 0; i < indic_len; ++i) printf(empty);
+    for (int i = 0; i < indic_len; ++i) { printf(empty); }
 #ifdef _WIN32
     printf("\x3D 0%%\r\x3D");
 #else
@@ -89,11 +89,11 @@ void BarGoLink::init(int row_count)
 void BarGoLink::step()
 {
     if (!m_showOutput)
-        return;
+        { return; }
 
     int i, n;
 
-    if (num_rec == 0) return;
+    if (num_rec == 0) { return; }
     ++rec_no;
     n = rec_no * indic_len / num_rec;
     if (n != rec_pos)
@@ -103,8 +103,8 @@ void BarGoLink::step()
 #else
         printf("\r[");
 #endif
-        for (i = 0; i < n; ++i) printf(full);
+        for (i = 0; i < n; ++i) { printf(full); }
-        for (; i < indic_len; ++i) printf(empty);
+        for (; i < indic_len; ++i) { printf(empty); }
         float percent = (((float)n / (float)indic_len) * 100);
 #ifdef _WIN32
         printf("\x3D %i%%  \r\x3D", (int)percent);

src/shared/ProgressBar.h

@@ -21,33 +21,61 @@
  * World of Warcraft, and all World of Warcraft or Warcraft art, images,
  * and lore are copyrighted by Blizzard Entertainment, Inc.
  */
+
 #ifndef MANGOSSERVER_PROGRESSBAR_H
 #define MANGOSSERVER_PROGRESSBAR_H
 
 #include "Platform/Define.h"
 
+/**
+ * @brief
+ *
+ */
 class MANGOS_DLL_SPEC BarGoLink
 {
-    public:                                                 // constructors
+    public:
+        /**
+         * @brief constructors
+         *
+         * @param row_count
+         */
         explicit BarGoLink(int row_count);
         explicit BarGoLink(uint32 row_count);               // row_count < ACE_INT32_MAX
         explicit BarGoLink(uint64 row_count);               // row_count < ACE_INT32_MAX
+        /**
+         * @brief
+         *
+         */
         ~BarGoLink();
 
-    public:                                                 // modifiers
+    public:
+        /**
+         * @brief modifiers
+         *
+         */
         void step();
 
+        /**
+         * @brief
+         *
+         * @param on
+         */
         static void SetOutputState(bool on);
     private:
+        /**
+         * @brief
+         *
+         * @param row_count
+         */
         void init(int row_count);
 
-        static bool m_showOutput;                           // not recommended change with existed active bar
+        static bool m_showOutput; /**< not recommended change with existed active bar */
-        static char const* const empty;
+        static char const* const empty; /**< TODO */
-        static char const* const full;
+        static char const* const full; /**< TODO */
 
-        int rec_no;
+        int rec_no; /**< TODO */
-        int rec_pos;
+        int rec_pos; /**< TODO */
-        int num_rec;
+        int num_rec; /**< TODO */
-        int indic_len;
+        int indic_len; /**< TODO */
 };
 #endif

src/shared/ServiceWin32.cpp

@@ -16,7 +16,10 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * World of Warcraft, and all World of Warcraft or Warcraft art, images,
+ * and lore are copyrighted by Blizzard Entertainment, Inc.
  */
 
 #ifdef WIN32
@@ -27,6 +30,11 @@
 #include <windows.h>
 #include <winsvc.h>
 
+// stupid ACE define
+#ifdef main
+#undef main
+#endif
+
 #if !defined(WINADVAPI)
 #if !defined(_ADVAPI32_)
 #define WINADVAPI DECLSPEC_IMPORT
@@ -159,7 +167,7 @@ bool WinServiceUninstall()
     if (QueryServiceStatus(service, &serviceStatus2))
     {
         if (serviceStatus2.dwCurrentState == SERVICE_STOPPED)
-            DeleteService(service);
+            { DeleteService(service); }
     }
 
     CloseServiceHandle(service);
@@ -197,10 +205,10 @@ void WINAPI ServiceControlHandler(DWORD controlCode)
         default:
             if (controlCode >= 128 && controlCode <= 255)
                 // user defined control code
-                break;
+                { break; }
             else
                 // unrecognized control code
-                break;
+                { break; }
     }
 
     SetServiceStatus(serviceStatusHandle, &serviceStatus);
@@ -228,7 +236,7 @@ void WINAPI ServiceMain(DWORD argc, char* argv[])
 
         for (i = 0; i < std::strlen(path); ++i)
         {
-            if (path[i] == '\\') last_slash = i;
+            if (path[i] == '\\') { last_slash = i; }
         }
 
         path[last_slash] = 0;

src/shared/ServiceWin32.h

@@ -16,7 +16,10 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * World of Warcraft, and all World of Warcraft or Warcraft art, images,
+ * and lore are copyrighted by Blizzard Entertainment, Inc.
  */
 
 #ifdef WIN32

src/shared/Threading.cpp

@@ -33,7 +33,7 @@ using namespace ACE_Based;
 ThreadPriority::ThreadPriority()
 {
     for (int i = Idle; i < MAXPRIORITYNUM; ++i)
-        m_priority[i] = ACE_THR_PRI_OTHER_DEF;
+        { m_priority[i] = ACE_THR_PRI_OTHER_DEF; }
 
     m_priority[Idle] = ACE_Sched_Params::priority_min(ACE_SCHED_OTHER);
     m_priority[Realtime] = ACE_Sched_Params::priority_max(ACE_SCHED_OTHER);
@@ -68,11 +68,11 @@ ThreadPriority::ThreadPriority()
         // since we have only 7(seven) values in enum Priority
         // and 3 we know already (Idle, Normal, Realtime) so
         // we need to split each list [Idle...Normal] and [Normal...Realtime]
-        // into ¹ piesces
+        // into pieces
         const size_t _divider = 4;
         size_t _div = (norm_pos - min_pos) / _divider;
         if (_div == 0)
-            _div = 1;
+            { _div = 1; }
 
         min_pos = (norm_pos - 1);
 
@@ -81,7 +81,7 @@ ThreadPriority::ThreadPriority()
 
         _div = (max_pos - norm_pos) / _divider;
         if (_div == 0)
-            _div = 1;
+            { _div = 1; }
 
         min_pos = norm_pos - 1;
 
@@ -93,10 +93,10 @@ ThreadPriority::ThreadPriority()
 int ThreadPriority::getPriority(Priority p) const
 {
     if (p < Idle)
-        p = Idle;
+        { p = Idle; }
 
     if (p > Realtime)
-        p = Realtime;
+        { p = Realtime; }
 
     return m_priority[p];
 }
@@ -115,7 +115,7 @@ Thread::Thread(Runnable* instance) : m_iThreadId(0), m_hThreadHandle(0), m_task(
 {
     // register reference to m_task to prevent it deeltion until destructor
     if (m_task)
-        m_task->incReference();
+        { m_task->incReference(); }
 
     bool _start = start();
     MANGOS_ASSERT(_start);
@@ -127,7 +127,7 @@ Thread::~Thread()
 
     // deleted runnable object (if no other references)
     if (m_task)
-        m_task->decReference();
+        { m_task->decReference(); }
 }
 
 // initialize Thread's class static member
@@ -137,12 +137,12 @@ ThreadPriority Thread::m_TpEnum;
 bool Thread::start()
 {
     if (m_task == 0 || m_iThreadId != 0)
-        return false;
+        { return false; }
 
     bool res = (ACE_Thread::spawn(&Thread::ThreadTask, (void*)m_task, THREADFLAG, &m_iThreadId, &m_hThreadHandle) == 0);
 
     if (res)
-        m_task->incReference();
+        { m_task->incReference(); }
 
     return res;
 }
@@ -150,7 +150,7 @@ bool Thread::start()
 bool Thread::wait()
 {
     if (!m_hThreadHandle || !m_task)
-        return false;
+        { return false; }
 
     ACE_THR_FUNC_RETURN _value = ACE_THR_FUNC_RETURN(-1);
     int _res = ACE_Thread::join(m_hThreadHandle, &_value);
@@ -164,10 +164,10 @@ bool Thread::wait()
 void Thread::destroy()
 {
     if (!m_iThreadId || !m_task)
-        return;
+        { return; }
 
     if (ACE_Thread::kill(m_iThreadId, -1) != 0)
-        return;
+        { return; }
 
     m_iThreadId = 0;
     m_hThreadHandle = 0;

src/shared/Threading.h

@@ -32,22 +32,46 @@
 
 namespace ACE_Based
 {
+    /**
+     * @brief
+     *
+     */
     class Runnable
     {
         public:
+            /**
+             * @brief
+             *
+             */
             virtual ~Runnable() {}
+            /**
+             * @brief
+             *
+             */
             virtual void run() = 0;
 
+            /**
+             * @brief
+             *
+             */
             void incReference() { ++m_refs; }
+            /**
+             * @brief
+             *
+             */
             void decReference()
             {
                 if (!--m_refs)
-                    delete this;
+                    { delete this; }
             }
         private:
-            ACE_Atomic_Op<ACE_Thread_Mutex, long> m_refs;
+            ACE_Atomic_Op<ACE_Thread_Mutex, long> m_refs; /**< TODO */
     };
 
+    /**
+     * @brief
+     *
+     */
     enum Priority
     {
         Idle,
@@ -56,57 +80,154 @@ namespace ACE_Based
         Normal,
         High,
         Highest,
-        Realtime,
+        Realtime
     };
 
 #define MAXPRIORITYNUM (Realtime + 1)
 
+    /**
+     * @brief
+     *
+     */
     class ThreadPriority
     {
         public:
+            /**
+             * @brief
+             *
+             */
             ThreadPriority();
+            /**
+             * @brief
+             *
+             * @param p
+             * @return int
+             */
             int getPriority(Priority p) const;
 
         private:
-            int m_priority[MAXPRIORITYNUM];
+            int m_priority[MAXPRIORITYNUM]; /**< TODO */
     };
 
+    /**
+     * @brief
+     *
+     */
     class Thread
     {
         public:
+            /**
+             * @brief
+             *
+             */
             Thread();
+            /**
+             * @brief
+             *
+             * @param instance
+             */
             explicit Thread(Runnable* instance);
+            /**
+             * @brief
+             *
+             */
             ~Thread();
 
+            /**
+             * @brief
+             *
+             * @return bool
+             */
             bool start();
+            /**
+             * @brief
+             *
+             * @return bool
+             */
             bool wait();
+            /**
+             * @brief
+             *
+             */
             void destroy();
 
+            /**
+             * @brief
+             *
+             */
             void suspend();
+            /**
+             * @brief
+             *
+             */
             void resume();
 
+            /**
+             * @brief
+             *
+             * @param type
+             */
             void setPriority(Priority type);
 
+            /**
+             * @brief
+             *
+             * @param msecs
+             */
             static void Sleep(unsigned long msecs);
+            /**
+             * @brief
+             *
+             * @return ACE_thread_t
+             */
             static ACE_thread_t currentId();
+            /**
+             * @brief
+             *
+             * @return ACE_hthread_t
+             */
             static ACE_hthread_t currentHandle();
+            /**
+             * @brief
+             *
+             * @return Thread
+             */
             static Thread* current();
 
         private:
+            /**
+             * @brief
+             *
+             * @param
+             */
             Thread(const Thread&);
+            /**
+             * @brief
+             *
+             * @param
+             * @return Thread &operator
+             */
             Thread& operator=(const Thread&);
 
+            /**
+             * @brief
+             *
+             * @param param
+             * @return ACE_THR_FUNC_RETURN
+             */
             static ACE_THR_FUNC_RETURN ThreadTask(void* param);
 
-            ACE_thread_t m_iThreadId;
+            ACE_thread_t m_iThreadId; /**< TODO */
-            ACE_hthread_t m_hThreadHandle;
+            ACE_hthread_t m_hThreadHandle; /**< TODO */
-            Runnable* m_task;
+            Runnable* m_task; /**< TODO */
 
+            /**
+             * @brief
+             *
+             */
             typedef ACE_TSS<Thread> ThreadStorage;
-            // global object - container for Thread class representation of every thread
+            static ThreadStorage m_ThreadStorage; /**< global object - container for Thread class representation of every thread */
-            static ThreadStorage m_ThreadStorage;
+            static ThreadPriority m_TpEnum; /**< use this object to determine current OS thread priority values mapped to enum Priority{} */
-            // use this object to determine current OS thread priority values mapped to enum Priority{}
-            static ThreadPriority m_TpEnum;
     };
 }
 #endif

src/shared/Timer.h

@@ -28,14 +28,28 @@
 #include "Common.h"
 #include <ace/OS_NS_sys_time.h>
 
+/**
+ * @brief
+ *
+ */
 class WorldTimer
 {
     public:
 
-        // get current server time
+        /**
+         * @brief get current server time
+         *
+         * @return uint32
+         */
         static uint32 getMSTime();
 
-        // get time difference between two timestamps
+        /**
+         * @brief get time difference between two timestamps
+         *
+         * @param oldMSTime
+         * @param newMSTime
+         * @return uint32
+         */
         static inline uint32 getMSTimeDiff(const uint32& oldMSTime, const uint32& newMSTime)
         {
             if (oldMSTime > newMSTime)
@@ -49,103 +63,271 @@ class WorldTimer
             return newMSTime - oldMSTime;
         }
 
-        // get last world tick time
+        /**
+         * @brief get last world tick time
+         *
+         * @return uint32
+         */
         static MANGOS_DLL_SPEC uint32 tickTime();
-        // get previous world tick time
+        /**
+         * @brief get previous world tick time
+         *
+         * @return uint32
+         */
         static MANGOS_DLL_SPEC uint32 tickPrevTime();
-        // tick world timer
+        /**
+         * @brief tick world timer
+         *
+         * @return uint32
+         */
         static MANGOS_DLL_SPEC uint32 tick();
 
     private:
+        /**
+         * @brief
+         *
+         */
         WorldTimer();
+        /**
+         * @brief
+         *
+         * @param
+         */
         WorldTimer(const WorldTimer&);
 
-        // analogue to getMSTime() but it persists m_SystemTickTime
+        /**
+         * @brief analogue to getMSTime() but it persists m_SystemTickTime
+         *
+         * @param savetime
+         * @return uint32
+         */
         static uint32 getMSTime_internal(bool savetime = false);
 
-        static MANGOS_DLL_SPEC uint32 m_iTime;
+        static MANGOS_DLL_SPEC uint32 m_iTime; /**< TODO */
-        static MANGOS_DLL_SPEC uint32 m_iPrevTime;
+        static MANGOS_DLL_SPEC uint32 m_iPrevTime; /**< TODO */
 };
 
+/**
+ * @brief
+ *
+ */
 class IntervalTimer
 {
     public:
+        /**
+         * @brief
+         *
+         */
         IntervalTimer() : _interval(0), _current(0) {}
 
+        /**
+         * @brief
+         *
+         * @param diff
+         */
         void Update(time_t diff)
         {
             _current += diff;
             if (_current < 0)
-                _current = 0;
+                { _current = 0; }
         }
+        /**
+         * @brief
+         *
+         * @return bool
+         */
         bool Passed() const { return _current >= _interval; }
+        /**
+         * @brief
+         *
+         */
         void Reset()
         {
             if (_current >= _interval)
-                _current -= _interval;
+                { _current -= _interval; }
         }
 
+        /**
+         * @brief
+         *
+         * @param current
+         */
         void SetCurrent(time_t current) { _current = current; }
+        /**
+         * @brief
+         *
+         * @param interval
+         */
         void SetInterval(time_t interval) { _interval = interval; }
+        /**
+         * @brief
+         *
+         * @return time_t
+         */
         time_t GetInterval() const { return _interval; }
+        /**
+         * @brief
+         *
+         * @return time_t
+         */
         time_t GetCurrent() const { return _current; }
 
     private:
-        time_t _interval;
+        time_t _interval; /**< TODO */
-        time_t _current;
+        time_t _current; /**< TODO */
 };
 
+/**
+ * @brief
+ *
+ */
 class ShortIntervalTimer
 {
     public:
+        /**
+         * @brief
+         *
+         */
         ShortIntervalTimer() : _interval(0), _current(0) {}
 
+        /**
+         * @brief
+         *
+         * @param diff
+         */
         void Update(uint32 diff)
         {
             _current += diff;
         }
 
+        /**
+         * @brief
+         *
+         * @return bool
+         */
         bool Passed() const { return _current >= _interval; }
+        /**
+         * @brief
+         *
+         */
         void Reset()
         {
             if (_current >= _interval)
-                _current -= _interval;
+                { _current -= _interval; }
         }
 
+        /**
+         * @brief
+         *
+         * @param current
+         */
         void SetCurrent(uint32 current) { _current = current; }
+        /**
+         * @brief
+         *
+         * @param interval
+         */
         void SetInterval(uint32 interval) { _interval = interval; }
+        /**
+         * @brief
+         *
+         * @return uint32
+         */
         uint32 GetInterval() const { return _interval; }
+        /**
+         * @brief
+         *
+         * @return uint32
+         */
         uint32 GetCurrent() const { return _current; }
 
     private:
-        uint32 _interval;
+        uint32 _interval; /**< TODO */
-        uint32 _current;
+        uint32 _current; /**< TODO */
 };
 
+/**
+ * @brief
+ *
+ */
 struct TimeTracker
 {
     public:
+        /**
+         * @brief
+         *
+         * @param expiry
+         */
         TimeTracker(time_t expiry) : i_expiryTime(expiry) {}
+        /**
+         * @brief
+         *
+         * @param diff
+         */
         void Update(time_t diff) { i_expiryTime -= diff; }
+        /**
+         * @brief
+         *
+         * @return bool
+         */
         bool Passed() const { return (i_expiryTime <= 0); }
+        /**
+         * @brief
+         *
+         * @param interval
+         */
         void Reset(time_t interval) { i_expiryTime = interval; }
+        /**
+         * @brief
+         *
+         * @return time_t
+         */
         time_t GetExpiry() const { return i_expiryTime; }
 
     private:
-        time_t i_expiryTime;
+        time_t i_expiryTime; /**< TODO */
 };
 
+/**
+ * @brief
+ *
+ */
 struct ShortTimeTracker
 {
     public:
+        /**
+         * @brief
+         *
+         * @param expiry
+         */
         ShortTimeTracker(int32 expiry = 0) : i_expiryTime(expiry) {}
+        /**
+         * @brief
+         *
+         * @param diff
+         */
         void Update(int32 diff) { i_expiryTime -= diff; }
+        /**
+         * @brief
+         *
+         * @return bool
+         */
         bool Passed() const { return (i_expiryTime <= 0); }
+        /**
+         * @brief
+         *
+         * @param interval
+         */
         void Reset(int32 interval) { i_expiryTime = interval; }
+        /**
+         * @brief
+         *
+         * @return int32
+         */
         int32 GetExpiry() const { return i_expiryTime; }
 
     private:
-        int32 i_expiryTime;
+        int32 i_expiryTime; /**< TODO */
 };
 
 #endif

src/shared/Util.cpp

@@ -122,7 +122,7 @@ Tokens StrSplit(const std::string& src, const std::string& sep)
     {
         if (sep.find(*i) != std::string::npos)
         {
-            if (s.length()) r.push_back(s);
+            if (s.length()) { r.push_back(s); }
             s = "";
         }
         else
@@ -130,14 +130,14 @@ Tokens StrSplit(const std::string& src, const std::string& sep)
             s += *i;
         }
     }
-    if (s.length()) r.push_back(s);
+    if (s.length()) { r.push_back(s); }
     return r;
 }
 
 uint32 GetUInt32ValueFromArray(Tokens const& data, uint16 index)
 {
     if (index >= data.size())
-        return 0;
+        { return 0; }
 
     return (uint32)atoi(data[index].c_str());
 }
@@ -186,15 +186,15 @@ void stripLineInvisibleChars(std::string& str)
         else
         {
             if (wpos != pos)
-                str[wpos++] = str[pos];
+                { str[wpos++] = str[pos]; }
             else
-                ++wpos;
+                { ++wpos; }
             space = false;
         }
     }
 
     if (wpos < str.size())
-        str.erase(wpos, str.size());
+        { str.erase(wpos, str.size()); }
 }
 
 std::string secsToTimeString(time_t timeInSecs, bool shortText, bool hoursOnly)
@@ -206,15 +206,15 @@ std::string secsToTimeString(time_t timeInSecs, bool shortText, bool hoursOnly)
 
     std::ostringstream ss;
     if (days)
-        ss << days << (shortText ? "d" : " Day(s) ");
+        { ss << days << (shortText ? "d" : " Day(s) "); }
     if (hours || hoursOnly)
-        ss << hours << (shortText ? "h" : " Hour(s) ");
+        { ss << hours << (shortText ? "h" : " Hour(s) "); }
     if (!hoursOnly)
     {
         if (minutes)
-            ss << minutes << (shortText ? "m" : " Minute(s) ");
+            { ss << minutes << (shortText ? "m" : " Minute(s) "); }
         if (secs || (!days && !hours && !minutes))
-            ss << secs << (shortText ? "s" : " Second(s).");
+            { ss << secs << (shortText ? "s" : " Second(s)."); }
     }
 
     return ss.str();
@@ -300,7 +300,7 @@ std::string MoneyToString(uint64 money)
 bool IsIPAddress(char const* ipaddress)
 {
     if (!ipaddress)
-        return false;
+        { return false; }
 
     // Let the big boys do it.
     // Drawback: all valid ip address formats are recognized e.g.: 12.23,121234,0xABCD)
@@ -312,7 +312,7 @@ uint32 CreatePIDFile(const std::string& filename)
 {
     FILE* pid_file = fopen(filename.c_str(), "w");
     if (pid_file == NULL)
-        return 0;
+        { return 0; }
 
 #ifdef WIN32
     DWORD pid = GetCurrentProcessId();
@@ -345,7 +345,7 @@ void utf8truncate(std::string& utf8str, size_t len)
     {
         size_t wlen = utf8::distance(utf8str.c_str(), utf8str.c_str() + utf8str.size());
         if (wlen <= len)
-            return;
+            { return; }
 
         std::wstring wstr;
         wstr.resize(wlen);
@@ -368,7 +368,7 @@ bool Utf8toWStr(char const* utf8str, size_t csize, wchar_t* wstr, size_t& wsize)
         if (len > wsize)
         {
             if (wsize > 0)
-                wstr[0] = L'\0';
+                { wstr[0] = L'\0'; }
             wsize = 0;
             return false;
         }
@@ -380,7 +380,7 @@ bool Utf8toWStr(char const* utf8str, size_t csize, wchar_t* wstr, size_t& wsize)
     catch (std::exception)
     {
         if (wsize > 0)
-            wstr[0] = L'\0';
+            { wstr[0] = L'\0'; }
         wsize = 0;
         return false;
     }
@@ -396,7 +396,7 @@ bool Utf8toWStr(const std::string& utf8str, std::wstring& wstr)
         wstr.resize(len);
 
         if (len)
-            utf8::utf8to16(utf8str.c_str(), utf8str.c_str() + utf8str.size(), &wstr[0]);
+            { utf8::utf8to16(utf8str.c_str(), utf8str.c_str() + utf8str.size(), &wstr[0]); }
     }
     catch (std::exception)
     {
@@ -453,7 +453,7 @@ std::wstring GetMainPartOfName(std::wstring wname, uint32 declension)
 {
     // supported only Cyrillic cases
     if (wname.size() < 1 || !isCyrillicCharacter(wname[0]) || declension > 5)
-        return wname;
+    { return wname; }
 
     // Important: end length must be <= MAX_INTERNAL_PLAYER_NAME-MAX_PLAYER_NAME (3 currently)
 
@@ -489,7 +489,7 @@ std::wstring GetMainPartOfName(std::wstring wname, uint32 declension)
         size_t len = size_t((*itr)[-1]);                    // get length from string size field
 
         if (wname.substr(wname.size() - len, len) == *itr)
-            return wname.substr(0, wname.size() - len);
+        { return wname.substr(0, wname.size() - len); }
     }
 
     return wname;
@@ -500,7 +500,7 @@ bool utf8ToConsole(const std::string& utf8str, std::string& conStr)
 #if PLATFORM == PLATFORM_WINDOWS
     std::wstring wstr;
     if (!Utf8toWStr(utf8str, wstr))
-        return false;
+        { return false; }
 
     conStr.resize(wstr.size());
     CharToOemBuffW(&wstr[0], &conStr[0], wstr.size());
@@ -532,13 +532,13 @@ bool Utf8FitTo(const std::string& str, std::wstring search)
     std::wstring temp;
 
     if (!Utf8toWStr(str, temp))
-        return false;
+        { return false; }
 
     // converting to lower case
     wstrToLower(temp);
 
     if (temp.find(search) == std::wstring::npos)
-        return false;
+        { return false; }
 
     return true;
 }
@@ -579,9 +579,9 @@ void hexEncodeByteArray(uint8* bytes, uint32 arrayLen, std::string& result)
             unsigned char nibble = 0x0F & (bytes[i] >> ((1 - j) * 4));
             char encodedNibble;
             if (nibble < 0x0A)
-                encodedNibble = '0' + nibble;
+                { encodedNibble = '0' + nibble; }
             else
-                encodedNibble = 'A' + nibble - 0x0A;
+                { encodedNibble = 'A' + nibble - 0x0A; }
             ss << encodedNibble;
         }
     }

src/shared/Util.h

@@ -30,311 +30,627 @@
 #include <string>
 #include <vector>
 
+/**
+ * @brief
+ *
+ */
 typedef std::vector<std::string> Tokens;
 
+/**
+ * @brief
+ *
+ * @param src
+ * @param sep
+ * @return Tokens
+ */
 Tokens StrSplit(const std::string& src, const std::string& sep);
+/**
+ * @brief
+ *
+ * @param data
+ * @param index
+ * @return uint32
+ */
 uint32 GetUInt32ValueFromArray(Tokens const& data, uint16 index);
+/**
+ * @brief
+ *
+ * @param data
+ * @param index
+ * @return float
+ */
 float GetFloatValueFromArray(Tokens const& data, uint16 index);
 
 float NormalizeOrientation(float o);
-
+/**
+ * @brief
+ *
+ * @param src
+ */
 void stripLineInvisibleChars(std::string& src);
 
+/**
+ * @brief
+ *
+ * @param timeInSecs
+ * @param shortText
+ * @param hoursOnly
+ * @return std::string
+ */
 std::string secsToTimeString(time_t timeInSecs, bool shortText = false, bool hoursOnly = false);
+/**
+ * @brief
+ *
+ * @param timestring
+ * @return uint32
+ */
 uint32 TimeStringToSecs(const std::string& timestring);
+/**
+ * @brief
+ *
+ * @param t
+ * @return std::string
+ */
 std::string TimeToTimestampStr(time_t t);
 time_t timeBitFieldsToSecs(uint32 packedDate);
 
 std::string MoneyToString(uint64 money);
-
+/**
+ * @brief
+ *
+ * @param secs
+ * @return uint32
+ */
 inline uint32 secsToTimeBitFields(time_t secs)
 {
     tm* lt = localtime(&secs);
     return (lt->tm_year - 100) << 24 | lt->tm_mon  << 20 | (lt->tm_mday - 1) << 14 | lt->tm_wday << 11 | lt->tm_hour << 6 | lt->tm_min;
 }
 
-/* Return a random number in the range min..max; (max-min) must be smaller than 32768. */
+/**
+ * @brief Return a random number in the range min..max; (max-min) must be smaller than 32768.
+ *
+ * @param min
+ * @param max
+ * @return int32
+ */
 MANGOS_DLL_SPEC int32 irand(int32 min, int32 max);
 
-/* Return a random number in the range min..max (inclusive). For reliable results, the difference
+/**
-* between max and min should be less than RAND32_MAX. */
+ * @brief Return a random number in the range min..max (inclusive).
+ *
+ * For reliable results, the difference between max and min should be less than
+ * RAND32_MAX.
+ *
+ * @param min
+ * @param max
+ * @return uint32
+ */
 MANGOS_DLL_SPEC uint32 urand(uint32 min, uint32 max);
 
-/* Return a random number in the range min..max (inclusive). */
+/**
+ * @brief Return a random number in the range min..max (inclusive).
+ *
+ * @param min
+ * @param max
+ * @return float
+ */
 MANGOS_DLL_SPEC float frand(float min, float max);
 
-/* Return a random number in the range 0 .. RAND32_MAX. */
+/**
+ * @brief Return a random number in the range 0 .. RAND32_MAX.
+ *
+ * @return int32
+ */
 MANGOS_DLL_SPEC int32 rand32();
 
-/* Return a random double from 0.0 to 1.0 (exclusive). Floats support only 7 valid decimal digits.
+/**
- * A double supports up to 15 valid decimal digits and is used internally (RAND32_MAX has 10 digits).
+ * @brief Return a random double from 0.0 to 1.0 (exclusive).
- * With an FPU, there is usually no difference in performance between float and double. */
+ *
+ * Floats support only 7 valid decimal digits. A double supports up to 15 valid
+ * decimaldigits and is used internally (RAND32_MAX has 10 digits). With an FPU
+ * there is usually no difference in performance between float and double.
+ *
+ * @return double
+ */
 MANGOS_DLL_SPEC double rand_norm(void);
 
+/**
+ * @brief
+ *
+ * @return float
+ */
 MANGOS_DLL_SPEC float rand_norm_f(void);
 
-/* Return a random double from 0.0 to 99.9999999999999. Floats support only 7 valid decimal digits.
+/**
- * A double supports up to 15 valid decimal digits and is used internaly (RAND32_MAX has 10 digits).
+ * @brief Return a random double from 0.0 to 99.9999999999999.
- * With an FPU, there is usually no difference in performance between float and double. */
+ *
+ * Floats support only 7 valid decimal digits. A double supports up to 15 valid
+ * decimal digits and is used internaly (RAND32_MAX has 10 digits). With an FPU
+ * there is usually no difference in performance between float and double.
+ *
+ * @return double
+ */
 MANGOS_DLL_SPEC double rand_chance(void);
 
+/**
+ * @brief
+ *
+ * @return float
+ */
 MANGOS_DLL_SPEC float rand_chance_f(void);
 
-/* Return true if a random roll fits in the specified chance (range 0-100). */
+/**
+ * @brief Return true if a random roll gets above the given chance
+ *
+ * ie: if the given value is 0 the chance to succeed is also 0 which gives false
+ * as the return value at all cases. On the other hand, giving 100 as the chance
+ * will make sure that we always succeed
+ *
+ * @param chance How big the chance to succeed is. Value between 0.0f-100.0f
+ * @return bool Return true if a random roll fits in the specified chance (range 0-100).
+ */
 inline bool roll_chance_f(float chance)
 {
     return chance > rand_chance();
 }
 
-/* Return true if a random roll fits in the specified chance (range 0-100). */
+/**
+ * @brief Return true if a random roll fits in the specified chance (range 0-100).
+ *
+ * @param chance
+ * @return bool
+ */
 inline bool roll_chance_i(int chance)
 {
     return chance > irand(0, 99);
 }
 
+/**
+ * @brief
+ *
+ * @param var
+ * @param val
+ * @param apply
+ */
 inline void ApplyModUInt32Var(uint32& var, int32 val, bool apply)
 {
     int32 cur = var;
     cur += (apply ? val : -val);
     if (cur < 0)
-        cur = 0;
+        { cur = 0; }
     var = cur;
 }
 
+/**
+ * @brief
+ *
+ * @param var
+ * @param val
+ * @param apply
+ */
 inline void ApplyModFloatVar(float& var, float  val, bool apply)
 {
     var += (apply ? val : -val);
     if (var < 0)
-        var = 0;
+        { var = 0; }
 }
 
+/**
+ * @brief
+ *
+ * @param var
+ * @param val
+ * @param apply
+ */
 inline void ApplyPercentModFloatVar(float& var, float val, bool apply)
 {
     if (val == -100.0f)     // prevent set var to zero
-        val = -99.99f;
+        { val = -99.99f; }
     var *= (apply ? (100.0f + val) / 100.0f : 100.0f / (100.0f + val));
 }
 
+/**
+ * @brief
+ *
+ * @param utf8str
+ * @param wstr
+ * @return bool
+ */
 bool Utf8toWStr(const std::string& utf8str, std::wstring& wstr);
-// in wsize==max size of buffer, out wsize==real string size
+/**
+ * @brief
+ *
+ * @param utf8str
+ * @param csize
+ * @param wstr
+ * @param wsize
+ * @return bool
+ */
 bool Utf8toWStr(char const* utf8str, size_t csize, wchar_t* wstr, size_t& wsize);
+/**
+ * @brief
+ *
+ * @param utf8str
+ * @param wstr
+ * @param wsize
+ * @return bool
+ */
 inline bool Utf8toWStr(const std::string& utf8str, wchar_t* wstr, size_t& wsize)
 {
     return Utf8toWStr(utf8str.c_str(), utf8str.size(), wstr, wsize);
 }
 
+/**
+ * @brief
+ *
+ * @param wstr
+ * @param utf8str
+ * @return bool
+ */
 bool WStrToUtf8(std::wstring wstr, std::string& utf8str);
-// size==real string size
+/**
+ * @brief
+ *
+ * @param wstr
+ * @param size
+ * @param utf8str
+ * @return bool
+ */
 bool WStrToUtf8(wchar_t* wstr, size_t size, std::string& utf8str);
 
+/**
+ * @brief
+ *
+ * @param utf8str
+ * @return size_t
+ */
 size_t utf8length(std::string& utf8str);                    // set string to "" if invalid utf8 sequence
+/**
+ * @brief
+ *
+ * @param utf8str
+ * @param len
+ */
 void utf8truncate(std::string& utf8str, size_t len);
 
+/**
+ * @brief
+ *
+ * @param wchar
+ * @return bool
+ */
 inline bool isBasicLatinCharacter(wchar_t wchar)
 {
     if (wchar >= L'a' && wchar <= L'z')                     // LATIN SMALL LETTER A - LATIN SMALL LETTER Z
-        return true;
+        { return true; }
     if (wchar >= L'A' && wchar <= L'Z')                     // LATIN CAPITAL LETTER A - LATIN CAPITAL LETTER Z
-        return true;
+        { return true; }
     return false;
 }
 
+/**
+ * @brief
+ *
+ * @param wchar
+ * @return bool
+ */
 inline bool isExtendedLatinCharacter(wchar_t wchar)
 {
     if (isBasicLatinCharacter(wchar))
-        return true;
+        { return true; }
     if (wchar >= 0x00C0 && wchar <= 0x00D6)                 // LATIN CAPITAL LETTER A WITH GRAVE - LATIN CAPITAL LETTER O WITH DIAERESIS
-        return true;
+        { return true; }
     if (wchar >= 0x00D8 && wchar <= 0x00DF)                 // LATIN CAPITAL LETTER O WITH STROKE - LATIN CAPITAL LETTER THORN
-        return true;
+        { return true; }
     if (wchar == 0x00DF)                                    // LATIN SMALL LETTER SHARP S
-        return true;
+        { return true; }
     if (wchar >= 0x00E0 && wchar <= 0x00F6)                 // LATIN SMALL LETTER A WITH GRAVE - LATIN SMALL LETTER O WITH DIAERESIS
-        return true;
+        { return true; }
     if (wchar >= 0x00F8 && wchar <= 0x00FE)                 // LATIN SMALL LETTER O WITH STROKE - LATIN SMALL LETTER THORN
-        return true;
+        { return true; }
     if (wchar >= 0x0100 && wchar <= 0x012F)                 // LATIN CAPITAL LETTER A WITH MACRON - LATIN SMALL LETTER I WITH OGONEK
-        return true;
+        { return true; }
     if (wchar == 0x1E9E)                                    // LATIN CAPITAL LETTER SHARP S
-        return true;
+        { return true; }
     return false;
 }
 
+/**
+ * @brief
+ *
+ * @param wchar
+ * @return bool
+ */
 inline bool isCyrillicCharacter(wchar_t wchar)
 {
     if (wchar >= 0x0410 && wchar <= 0x044F)                 // CYRILLIC CAPITAL LETTER A - CYRILLIC SMALL LETTER YA
-        return true;
+        { return true; }
     if (wchar == 0x0401 || wchar == 0x0451)                 // CYRILLIC CAPITAL LETTER IO, CYRILLIC SMALL LETTER IO
-        return true;
+        { return true; }
     return false;
 }
 
+/**
+ * @brief
+ *
+ * @param wchar
+ * @return bool
+ */
 inline bool isEastAsianCharacter(wchar_t wchar)
 {
     if (wchar >= 0x1100 && wchar <= 0x11F9)                 // Hangul Jamo
-        return true;
+        { return true; }
     if (wchar >= 0x3041 && wchar <= 0x30FF)                 // Hiragana + Katakana
-        return true;
+        { return true; }
     if (wchar >= 0x3131 && wchar <= 0x318E)                 // Hangul Compatibility Jamo
-        return true;
+        { return true; }
     if (wchar >= 0x31F0 && wchar <= 0x31FF)                 // Katakana Phonetic Ext.
-        return true;
+        { return true; }
     if (wchar >= 0x3400 && wchar <= 0x4DB5)                 // CJK Ideographs Ext. A
-        return true;
+        { return true; }
     if (wchar >= 0x4E00 && wchar <= 0x9FC3)                 // Unified CJK Ideographs
-        return true;
+        { return true; }
     if (wchar >= 0xAC00 && wchar <= 0xD7A3)                 // Hangul Syllables
-        return true;
+        { return true; }
     if (wchar >= 0xFF01 && wchar <= 0xFFEE)                 // Halfwidth forms
-        return true;
+        { return true; }
     return false;
 }
 
+/**
+ * @brief
+ *
+ * @param c
+ * @return bool
+ */
 inline bool isWhiteSpace(char c)
 {
     return ::isspace(int(c)) != 0;
 }
 
+/**
+ * @brief
+ *
+ * @param wchar
+ * @return bool
+ */
 inline bool isNumeric(wchar_t wchar)
 {
     return (wchar >= L'0' && wchar <= L'9');
 }
 
+/**
+ * @brief
+ *
+ * @param c
+ * @return bool
+ */
 inline bool isNumeric(char c)
 {
     return (c >= '0' && c <= '9');
 }
 
+/**
+ * @brief
+ *
+ * @param wchar
+ * @return bool
+ */
 inline bool isNumericOrSpace(wchar_t wchar)
 {
     return isNumeric(wchar) || wchar == L' ';
 }
 
+/**
+ * @brief
+ *
+ * @param str
+ * @return bool
+ */
 inline bool isNumeric(char const* str)
 {
     for (char const* c = str; *c; ++c)
         if (!isNumeric(*c))
-            return false;
+            { return false; }
 
     return true;
 }
 
+/**
+ * @brief
+ *
+ * @param str
+ * @return bool
+ */
 inline bool isNumeric(std::string const& str)
 {
     for (std::string::const_iterator itr = str.begin(); itr != str.end(); ++itr)
         if (!isNumeric(*itr))
-            return false;
+            { return false; }
 
     return true;
 }
 
+/**
+ * @brief
+ *
+ * @param str
+ * @return bool
+ */
 inline bool isNumeric(std::wstring const& str)
 {
     for (std::wstring::const_iterator itr = str.begin(); itr != str.end(); ++itr)
         if (!isNumeric(*itr))
-            return false;
+            { return false; }
 
     return true;
 }
 
+/**
+ * @brief
+ *
+ * @param wstr
+ * @param numericOrSpace
+ * @return bool
+ */
 inline bool isBasicLatinString(std::wstring wstr, bool numericOrSpace)
 {
     for (size_t i = 0; i < wstr.size(); ++i)
         if (!isBasicLatinCharacter(wstr[i]) && (!numericOrSpace || !isNumericOrSpace(wstr[i])))
-            return false;
+            { return false; }
     return true;
 }
 
+/**
+ * @brief
+ *
+ * @param wstr
+ * @param numericOrSpace
+ * @return bool
+ */
 inline bool isExtendedLatinString(std::wstring wstr, bool numericOrSpace)
 {
     for (size_t i = 0; i < wstr.size(); ++i)
         if (!isExtendedLatinCharacter(wstr[i]) && (!numericOrSpace || !isNumericOrSpace(wstr[i])))
-            return false;
+            { return false; }
     return true;
 }
 
+/**
+ * @brief
+ *
+ * @param wstr
+ * @param numericOrSpace
+ * @return bool
+ */
 inline bool isCyrillicString(std::wstring wstr, bool numericOrSpace)
 {
     for (size_t i = 0; i < wstr.size(); ++i)
         if (!isCyrillicCharacter(wstr[i]) && (!numericOrSpace || !isNumericOrSpace(wstr[i])))
-            return false;
+            { return false; }
     return true;
 }
 
+/**
+ * @brief
+ *
+ * @param wstr
+ * @param numericOrSpace
+ * @return bool
+ */
 inline bool isEastAsianString(std::wstring wstr, bool numericOrSpace)
 {
     for (size_t i = 0; i < wstr.size(); ++i)
         if (!isEastAsianCharacter(wstr[i]) && (!numericOrSpace || !isNumericOrSpace(wstr[i])))
-            return false;
+            { return false; }
     return true;
 }
 
+/**
+ * @brief
+ *
+ * @param str
+ */
 inline void strToUpper(std::string& str)
 {
     std::transform(str.begin(), str.end(), str.begin(), toupper);
 }
 
+/**
+ * @brief
+ *
+ * @param str
+ */
 inline void strToLower(std::string& str)
 {
     std::transform(str.begin(), str.end(), str.begin(), tolower);
 }
 
+/**
+ * @brief
+ *
+ * @param wchar
+ * @return wchar_t
+ */
 inline wchar_t wcharToUpper(wchar_t wchar)
 {
     if (wchar >= L'a' && wchar <= L'z')                     // LATIN SMALL LETTER A - LATIN SMALL LETTER Z
-        return wchar_t(uint16(wchar) - 0x0020);
+        { return wchar_t(uint16(wchar) - 0x0020); }
     if (wchar == 0x00DF)                                    // LATIN SMALL LETTER SHARP S
-        return wchar_t(0x1E9E);
+        { return wchar_t(0x1E9E); }
     if (wchar >= 0x00E0 && wchar <= 0x00F6)                 // LATIN SMALL LETTER A WITH GRAVE - LATIN SMALL LETTER O WITH DIAERESIS
-        return wchar_t(uint16(wchar) - 0x0020);
+        { return wchar_t(uint16(wchar) - 0x0020); }
     if (wchar >= 0x00F8 && wchar <= 0x00FE)                 // LATIN SMALL LETTER O WITH STROKE - LATIN SMALL LETTER THORN
-        return wchar_t(uint16(wchar) - 0x0020);
+        { return wchar_t(uint16(wchar) - 0x0020); }
     if (wchar >= 0x0101 && wchar <= 0x012F)                 // LATIN SMALL LETTER A WITH MACRON - LATIN SMALL LETTER I WITH OGONEK (only %2=1)
     {
         if (wchar % 2 == 1)
-            return wchar_t(uint16(wchar) - 0x0001);
+            { return wchar_t(uint16(wchar) - 0x0001); }
     }
     if (wchar >= 0x0430 && wchar <= 0x044F)                 // CYRILLIC SMALL LETTER A - CYRILLIC SMALL LETTER YA
-        return wchar_t(uint16(wchar) - 0x0020);
+        { return wchar_t(uint16(wchar) - 0x0020); }
     if (wchar == 0x0451)                                    // CYRILLIC SMALL LETTER IO
-        return wchar_t(0x0401);
+        { return wchar_t(0x0401); }
 
     return wchar;
 }
 
+/**
+ * @brief
+ *
+ * @param wchar
+ * @return wchar_t
+ */
 inline wchar_t wcharToUpperOnlyLatin(wchar_t wchar)
 {
     return isBasicLatinCharacter(wchar) ? wcharToUpper(wchar) : wchar;
 }
 
+/**
+ * @brief
+ *
+ * @param wchar
+ * @return wchar_t
+ */
 inline wchar_t wcharToLower(wchar_t wchar)
 {
     if (wchar >= L'A' && wchar <= L'Z')                     // LATIN CAPITAL LETTER A - LATIN CAPITAL LETTER Z
-        return wchar_t(uint16(wchar) + 0x0020);
+        { return wchar_t(uint16(wchar) + 0x0020); }
     if (wchar >= 0x00C0 && wchar <= 0x00D6)                 // LATIN CAPITAL LETTER A WITH GRAVE - LATIN CAPITAL LETTER O WITH DIAERESIS
-        return wchar_t(uint16(wchar) + 0x0020);
+        { return wchar_t(uint16(wchar) + 0x0020); }
     if (wchar >= 0x00D8 && wchar <= 0x00DE)                 // LATIN CAPITAL LETTER O WITH STROKE - LATIN CAPITAL LETTER THORN
-        return wchar_t(uint16(wchar) + 0x0020);
+        { return wchar_t(uint16(wchar) + 0x0020); }
     if (wchar >= 0x0100 && wchar <= 0x012E)                 // LATIN CAPITAL LETTER A WITH MACRON - LATIN CAPITAL LETTER I WITH OGONEK (only %2=0)
     {
         if (wchar % 2 == 0)
-            return wchar_t(uint16(wchar) + 0x0001);
+            { return wchar_t(uint16(wchar) + 0x0001); }
     }
     if (wchar == 0x1E9E)                                    // LATIN CAPITAL LETTER SHARP S
-        return wchar_t(0x00DF);
+        { return wchar_t(0x00DF); }
     if (wchar == 0x0401)                                    // CYRILLIC CAPITAL LETTER IO
-        return wchar_t(0x0451);
+        { return wchar_t(0x0451); }
     if (wchar >= 0x0410 && wchar <= 0x042F)                 // CYRILLIC CAPITAL LETTER A - CYRILLIC CAPITAL LETTER YA
-        return wchar_t(uint16(wchar) + 0x0020);
+        { return wchar_t(uint16(wchar) + 0x0020); }
 
     return wchar;
 }
 
+/**
+ * @brief
+ *
+ * @param str
+ */
 inline void wstrToUpper(std::wstring& str)
 {
     std::transform(str.begin(), str.end(), str.begin(), wcharToUpper);
 }
 
+/**
+ * @brief
+ *
+ * @param str
+ */
 inline void wstrToLower(std::wstring& str)
 {
     std::transform(str.begin(), str.end(), str.begin(), wcharToLower);
@@ -342,14 +658,67 @@ inline void wstrToLower(std::wstring& str)
 
 std::wstring GetMainPartOfName(std::wstring wname, uint32 declension);
 
+/**
+ * @brief
+ *
+ * @param utf8str
+ * @param conStr
+ * @return bool
+ */
 bool utf8ToConsole(const std::string& utf8str, std::string& conStr);
+/**
+ * @brief
+ *
+ * @param conStr
+ * @param utf8str
+ * @return bool
+ */
 bool consoleToUtf8(const std::string& conStr, std::string& utf8str);
+/**
+ * @brief
+ *
+ * @param str
+ * @param search
+ * @return bool
+ */
 bool Utf8FitTo(const std::string& str, std::wstring search);
+/**
+ * @brief
+ *
+ * @param out
+ * @param str...
+ */
 void utf8printf(FILE* out, const char* str, ...);
+/**
+ * @brief
+ *
+ * @param out
+ * @param str
+ * @param ap
+ */
 void vutf8printf(FILE* out, const char* str, va_list* ap);
 
+/**
+ * @brief
+ *
+ * @param ipaddress
+ * @return bool
+ */
 bool IsIPAddress(char const* ipaddress);
+/**
+ * @brief
+ *
+ * @param filename
+ * @return uint32
+ */
 uint32 CreatePIDFile(const std::string& filename);
 
+/**
+ * @brief
+ *
+ * @param bytes
+ * @param arrayLen
+ * @param result
+ */
 void hexEncodeByteArray(uint8* bytes, uint32 arrayLen, std::string& result);
 #endif

src/shared/WheatyExceptionReport.cpp

@@ -61,7 +61,7 @@ WheatyExceptionReport::WheatyExceptionReport()              // Constructor
 WheatyExceptionReport::~WheatyExceptionReport()
 {
     if (m_previousFilter)
-        SetUnhandledExceptionFilter(m_previousFilter);
+        { SetUnhandledExceptionFilter(m_previousFilter); }
 }
 
 //===========================================================
@@ -74,7 +74,7 @@ LONG WINAPI WheatyExceptionReport::WheatyUnhandledExceptionFilter(
     GetModuleFileName(0, module_folder_name, MAX_PATH);
     TCHAR* pos = _tcsrchr(module_folder_name, '\\');
     if (!pos)
-        return 0;
+        { return 0; }
     pos[0] = '\0';
     ++pos;
 
@@ -83,7 +83,7 @@ LONG WINAPI WheatyExceptionReport::WheatyUnhandledExceptionFilter(
     if (!CreateDirectory(crash_folder_path, NULL))
     {
         if (GetLastError() != ERROR_ALREADY_EXISTS)
-            return 0;
+            { return 0; }
     }
 
     SYSTEMTIME systime;
@@ -110,34 +110,34 @@ LONG WINAPI WheatyExceptionReport::WheatyUnhandledExceptionFilter(
     }
 
     if (m_previousFilter)
-        return m_previousFilter(pExceptionInfo);
+        { return m_previousFilter(pExceptionInfo); }
     else
-        return EXCEPTION_EXECUTE_HANDLER/*EXCEPTION_CONTINUE_SEARCH*/;
+        { return EXCEPTION_EXECUTE_HANDLER/*EXCEPTION_CONTINUE_SEARCH*/; }
 }
 
 BOOL WheatyExceptionReport::_GetProcessorName(TCHAR* sProcessorName, DWORD maxcount)
 {
     if (!sProcessorName)
-        return FALSE;
+        { return FALSE; }
 
     HKEY hKey;
     LONG lRet;
     lRet = ::RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0"),
                           0, KEY_QUERY_VALUE, &hKey);
     if (lRet != ERROR_SUCCESS)
-        return FALSE;
+        { return FALSE; }
     TCHAR szTmp[2048];
     DWORD cntBytes = sizeof(szTmp);
     lRet = ::RegQueryValueEx(hKey, _T("ProcessorNameString"), NULL, NULL,
                              (LPBYTE)szTmp, &cntBytes);
     if (lRet != ERROR_SUCCESS)
-        return FALSE;
+        { return FALSE; }
     ::RegCloseKey(hKey);
     sProcessorName[0] = '\0';
     // Skip spaces
     TCHAR* psz = szTmp;
     while (iswspace(*psz))
-        ++psz;
+        { ++psz; }
     _tcsncpy(sProcessorName, psz, maxcount);
     return TRUE;
 }
@@ -154,7 +154,7 @@ BOOL WheatyExceptionReport::_GetWindowsVersion(TCHAR* szVersion, DWORD cntMax)
     {
         osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
         if (!::GetVersionEx((OSVERSIONINFO*)&osvi))
-            return FALSE;
+            { return FALSE; }
     }
     *szVersion = _T('\0');
     TCHAR wszTmp[128];
@@ -167,21 +167,21 @@ BOOL WheatyExceptionReport::_GetWindowsVersion(TCHAR* szVersion, DWORD cntMax)
             {
                 default: // 2
                     if (osvi.wProductType == VER_NT_WORKSTATION)
-                        _tcsncat(szVersion, _T("Windows 8 "), cntMax);
+                        { _tcsncat(szVersion, _T("Windows 8 "), cntMax); }
                     else
-                        _tcsncat(szVersion, _T("Windows Server 2012 "), cntMax);
+                        { _tcsncat(szVersion, _T("Windows Server 2012 "), cntMax); }
                     break;
                 case 1:
                     if (osvi.wProductType == VER_NT_WORKSTATION)
-                        _tcsncat(szVersion, _T("Windows 7 "), cntMax);
+                        { _tcsncat(szVersion, _T("Windows 7 "), cntMax); }
                     else
-                        _tcsncat(szVersion, _T("Windows Server 2008 R2 "), cntMax);
+                        { _tcsncat(szVersion, _T("Windows Server 2008 R2 "), cntMax); }
                     break;
                 case 0:
                     if (osvi.wProductType == VER_NT_WORKSTATION)
-                        _tcsncat(szVersion, _T("Windows Vista "), cntMax);
+                        { _tcsncat(szVersion, _T("Windows Vista "), cntMax); }
                     else
-                        _tcsncat(szVersion, _T("Windows Server 2008 "), cntMax);
+                        { _tcsncat(szVersion, _T("Windows Server 2008 "), cntMax); }
                     break;
             }
             break;
@@ -235,9 +235,9 @@ void WheatyExceptionReport::PrintSystemInfo()
                  SystemInfo.dwNumberOfProcessors, MemoryStatus.dwTotalPhys / 0x400, MemoryStatus.dwAvailPhys / 0x400, MemoryStatus.dwTotalPageFile / 0x400);
 
     if (_GetWindowsVersion(sString, countof(sString)))
-        _tprintf(_T("\r\n*** Operation System ***\r\n%s\r\n"), sString);
+        { _tprintf(_T("\r\n*** Operation System ***\r\n%s\r\n"), sString); }
     else
-        _tprintf(_T("\r\n*** Operation System:\r\n<unknown>\r\n"));
+        { _tprintf(_T("\r\n*** Operation System:\r\n<unknown>\r\n")); }
 }
 
 //===========================================================================
@@ -251,7 +251,7 @@ void WheatyExceptionReport::printTracesForAllThreads()
     // Take a snapshot of all running threads
     hThreadSnap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
     if (hThreadSnap == INVALID_HANDLE_VALUE)
-        return;
+        { return; }
 
     // Fill in the size of the structure before using it.
     te32.dwSize = sizeof(THREADENTRY32);
@@ -456,12 +456,12 @@ BOOL WheatyExceptionReport::GetLogicalAddress(
     MEMORY_BASIC_INFORMATION mbi;
 
     if (!VirtualQuery(addr, &mbi, sizeof(mbi)))
-        return FALSE;
+        { return FALSE; }
 
     DWORD_PTR hMod = (DWORD_PTR)mbi.AllocationBase;
 
     if (!GetModuleFileName((HMODULE)hMod, szModule, len))
-        return FALSE;
+        { return FALSE; }
 
     // Point to the DOS header in memory
     PIMAGE_DOS_HEADER pDosHdr = (PIMAGE_DOS_HEADER)hMod;
@@ -561,9 +561,9 @@ void WheatyExceptionReport::WriteStackDetails(
                           SymFunctionTableAccess64,
                           SymGetModuleBase64,
                           0))
-            break;
+            { break; }
         if (0 == sf.AddrFrame.Offset)                       // Basic sanity check to make sure
-            break;                                          // the frame is OK.  Bail if not.
+            { break; }                                          // the frame is OK.  Bail if not.
 #ifdef _M_IX86
         _tprintf(_T("%08X  %08X  "), sf.AddrPC.Offset, sf.AddrFrame.Offset);
 #endif
@@ -643,9 +643,9 @@ WheatyExceptionReport::EnumerateSymbolsCallback(
     {
         if (FormatSymbolValue(pSymInfo, (STACKFRAME*)UserContext,
         szBuffer, sizeof(szBuffer)))
-            _tprintf(_T("\t%s\r\n"), szBuffer);
+            { _tprintf(_T("\t%s\r\n"), szBuffer); }
     }
-    __except (1)
+    __except(1)
     {
         _tprintf(_T("punting on symbol %s\r\n"), pSymInfo->Name);
     }
@@ -668,13 +668,13 @@ bool WheatyExceptionReport::FormatSymbolValue(
 
     // Indicate if the variable is a local or parameter
     if (pSym->Flags & IMAGEHLP_SYMBOL_INFO_PARAMETER)
-        pszCurrBuffer += sprintf(pszCurrBuffer, "Parameter ");
+        { pszCurrBuffer += sprintf(pszCurrBuffer, "Parameter "); }
     else if (pSym->Flags & IMAGEHLP_SYMBOL_INFO_LOCAL)
-        pszCurrBuffer += sprintf(pszCurrBuffer, "Local ");
+        { pszCurrBuffer += sprintf(pszCurrBuffer, "Local "); }
 
     // If it's a function, don't do anything.
     if (pSym->Tag == 5)                                     // SymTagFunction from CVCONST.H from the DIA SDK
-        return false;
+        { return false; }
 
     DWORD_PTR pVariable = 0;                                // Will point to the variable's data in memory
 
@@ -754,7 +754,7 @@ char* WheatyExceptionReport::DumpTypeIndex(
                    &dwChildrenCount);
 
     if (!dwChildrenCount)                                   // If no children, we're done
-        return pszCurrBuffer;
+        { return pszCurrBuffer; }
 
     // Prepare to get an array of "TypeIds", representing each of the children.
     // SymGetTypeInfo(TI_FINDCHILDREN) expects more memory than just a
@@ -783,7 +783,7 @@ char* WheatyExceptionReport::DumpTypeIndex(
     {
         // Add appropriate indentation level (since this routine is recursive)
         for (unsigned j = 0; j <= nestingLevel + 1; ++j)
-            pszCurrBuffer += sprintf(pszCurrBuffer, "\t");
+            { pszCurrBuffer += sprintf(pszCurrBuffer, "\t"); }
 
         // Recurse for each of the child types
         bool bHandled2;
@@ -840,9 +840,9 @@ char* WheatyExceptionReport::FormatOutputValue(char* pszCurrBuffer,
 {
     // Format appropriately (assuming it's a 1, 2, or 4 bytes (!!!)
     if (length == 1)
-        pszCurrBuffer += sprintf(pszCurrBuffer, " = %X", *(PBYTE)pAddress);
+        { pszCurrBuffer += sprintf(pszCurrBuffer, " = %X", *(PBYTE)pAddress); }
     else if (length == 2)
-        pszCurrBuffer += sprintf(pszCurrBuffer, " = %X", *(PWORD)pAddress);
+        { pszCurrBuffer += sprintf(pszCurrBuffer, " = %X", *(PWORD)pAddress); }
     else if (length == 4)
     {
         if (basicType == btFloat)
@@ -861,7 +861,7 @@ char* WheatyExceptionReport::FormatOutputValue(char* pszCurrBuffer,
                                          *(PDWORD)pAddress);
         }
         else
-            pszCurrBuffer += sprintf(pszCurrBuffer, " = %X", *(PDWORD)pAddress);
+            { pszCurrBuffer += sprintf(pszCurrBuffer, " = %X", *(PDWORD)pAddress); }
     }
     else if (length == 8)
     {

src/shared/WheatyExceptionReport.h

@@ -1,3 +1,27 @@
+/**
+ * MaNGOS is a full featured server for World of Warcraft, supporting
+ * the following clients: 1.12.x, 2.4.3, 3.3.5a, 4.3.4a and 5.4.8
+ *
+ * Copyright (C) 2005-2014  MaNGOS project <http://getmangos.eu>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * World of Warcraft, and all World of Warcraft or Warcraft art, images,
+ * and lore are copyrighted by Blizzard Entertainment, Inc.
+ */
+
 #ifndef _WHEATYEXCEPTIONREPORT_
 #define _WHEATYEXCEPTIONREPORT_
 

src/shared/WorldPacket.h

@@ -31,19 +31,42 @@
 
 // Note: m_opcode and size stored in platfom dependent format
 // ignore endianess until send, and converted at receive
+/**
+ * @brief
+ *
+ */
 class WorldPacket : public ByteBuffer
 {
     public:
-        // just container for later use
+        /**
+         * @brief just container for later use
+         *
+         */
         WorldPacket() : ByteBuffer(0), m_opcode(MSG_NULL_ACTION)
         {
         }
+        /**
+         * @brief
+         *
+         * @param opcode
+         * @param res
+         */
         explicit WorldPacket(Opcodes opcode, size_t res = 200) : ByteBuffer(res), m_opcode(opcode) { }
-        // copy constructor
+        /**
+         * @brief copy constructor
+         *
+         * @param packet
+         */
         WorldPacket(const WorldPacket& packet) : ByteBuffer(packet), m_opcode(packet.m_opcode)
         {
         }
 
+        /**
+         * @brief
+         *
+         * @param opcode
+         * @param newres
+         */
         void Initialize(Opcodes opcode, size_t newres = 200)
         {
             clear();
@@ -51,8 +74,23 @@ class WorldPacket : public ByteBuffer
             m_opcode = opcode;
         }
 
+        /**
+         * @brief
+         *
+         * @return uint16
+         */
         Opcodes GetOpcode() const { return m_opcode; }
+        /**
+         * @brief
+         *
+         * @param opcode
+         */
         void SetOpcode(Opcodes opcode) { m_opcode = opcode; }
+        /**
+         * @brief
+         *
+         * @return const char
+         */
         inline const char* GetOpcodeName() const { return LookupOpcodeName(m_opcode); }
 
     protected: