Fixed windows compilation and style issues.

src/Logger.cpp

@@ -2,6 +2,12 @@
 #include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
 
 #include "OSSupport/IsThread.h"
+#ifdef _WIN32
+	#include <time.h>
+#endif
+
+
+
 
 
 cLogger & cLogger::GetInstance(void)
@@ -10,23 +16,31 @@ cLogger & cLogger::GetInstance(void)
 	return Instance;
 }
 
+
+
+
+
 void cLogger::InitiateMultithreading()
 {
 	GetInstance();
 }
 
+
+
+
+
 void cLogger::LogSimple(AString a_Message, eLogLevel a_LogLevel)
 {
 	time_t rawtime;
-	time ( &rawtime);
+	time(&rawtime);
 
-	struct tm* timeinfo;
+	struct tm * timeinfo;
 	#ifdef _MSC_VER
 		struct tm timeinforeal;
 		timeinfo = &timeinforeal;
 		localtime_s(timeinfo, &rawtime);
 	#else
-		timeinfo = localtime( &rawtime);
+		timeinfo = localtime(&rawtime);
 	#endif
 
 	AString Line;
@@ -38,7 +52,7 @@ void cLogger::LogSimple(AString a_Message, eLogLevel a_LogLevel)
 
 	
 	cCSLock Lock(m_CriticalSection);
-	for(size_t i = 0; i < m_LogListeners.size(); i++)
+	for (size_t i = 0; i < m_LogListeners.size(); i++)
 	{
 		m_LogListeners[i]->Log(a_Message, a_LogLevel);
 	}
@@ -55,12 +69,20 @@ void cLogger::Log(const char * a_Format, eLogLevel a_LogLevel, va_list a_ArgList
 	LogSimple(Message, a_LogLevel);
 }
 
+
+
+
+
 void cLogger::AttachListener(cListener * a_Listener)
 {
 	cCSLock Lock(m_CriticalSection);
 	m_LogListeners.push_back(a_Listener);
 }
 
+
+
+
+
 void cLogger::DetachListener(cListener * a_Listener)
 {
 	cCSLock Lock(m_CriticalSection);
@@ -69,10 +91,12 @@ void cLogger::DetachListener(cListener * a_Listener)
 
 
 
+
+
 ////////////////////////////////////////////////////////////////////////////////
 // Global functions
 
-void LOG(const char* a_Format, ...)
+void LOG(const char * a_Format, ...)
 {
 	va_list argList;
 	va_start(argList, a_Format);
@@ -80,7 +104,11 @@ void LOG(const char* a_Format, ...)
 	va_end(argList);
 }
 
-void LOGINFO(const char* a_Format, ...)
+
+
+
+
+void LOGINFO(const char * a_Format, ...)
 {
 	va_list argList;
 	va_start(argList, a_Format);
@@ -88,7 +116,11 @@ void LOGINFO(const char* a_Format, ...)
 	va_end(argList);
 }
 
-void LOGWARN(const char* a_Format, ...)
+
+
+
+
+void LOGWARN(const char * a_Format, ...)
 {
 	va_list argList;
 	va_start(argList, a_Format);
@@ -96,7 +128,11 @@ void LOGWARN(const char* a_Format, ...)
 	va_end(argList);
 }
 
-void LOGERROR(const char* a_Format, ...)
+
+
+
+
+void LOGERROR(const char * a_Format, ...)
 {
 	va_list argList;
 	va_start(argList, a_Format);

src/LoggerListeners.cpp

@@ -5,6 +5,7 @@
 
 #if defined(_WIN32)
 	#include <io.h>  // Needed for _isatty(), not available on Linux
+	#include <time.h>
 #elif defined(__linux) && !defined(ANDROID_NDK)
 	#include <unistd.h>  // Needed for isatty() on Linux
 #elif defined(ANDROID_NDK)
@@ -29,10 +30,15 @@
 	};
 #endif
 
+
+
+
+
 #ifdef _WIN32
 	class cWindowsConsoleListener
 		: public cColouredConsoleListener
 	{
+		typedef cColouredConsoleListener super;
 	public:
 		cWindowsConsoleListener(HANDLE a_Console, WORD a_DefaultConsoleAttrib) :
 			m_Console(a_Console),
@@ -43,7 +49,7 @@
 		#ifdef DEBUG
 			virtual void Log(AString a_Message, cLogger::eLogLevel a_LogLevel) override
 			{
-				cColouredConsoleListener::Log(a_Message, a_LogLevel);
+				super::Log(a_Message, a_LogLevel);
 				// In a Windows Debug build, output the log to debug console as well:
 				OutputDebugStringA(a_Message.c_str());
 			}
@@ -57,33 +63,51 @@
 			switch (a_LogLevel)
 			{
 				case cLogger::llRegular:
+				{
 					// Gray on black 
 					Attrib = FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED;
 					break;
+				}
 				case cLogger::llInfo:
+				{
 					// Yellow on black
-				    Attrib = FOREGROUND_GREEN | ;
+					Attrib = FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY;
 					break;
+				}
 				case cLogger::llWarning:
+				{
 					// Red on black
 					Attrib = FOREGROUND_RED | FOREGROUND_INTENSITY;
 					break;
+				}
 				case cLogger::llError:
+				{
 					// Black on red
 					Attrib = BACKGROUND_RED | BACKGROUND_INTENSITY;
 					break;
 				}
+			}
 			SetConsoleTextAttribute(m_Console, Attrib);
 		}
+		
+		
 		virtual void SetDefaultLogColour() override
 		{ 
 			SetConsoleTextAttribute(m_Console, m_DefaultConsoleAttrib);
 		}
+		
 	private:
+	
 		HANDLE m_Console;
 		WORD m_DefaultConsoleAttrib;
 	};
+	
+	
+	
 #elif defined (__linux) && !defined(ANDROID_NDK)
+
+
+
 	class cLinuxConsoleListener
 		: public cColouredConsoleListener
 	{
@@ -93,30 +117,46 @@
 			switch (a_LogLevel)
 			{
 				case cLogger::llRegular:
+				{
 					// Whatever the console default is 
 					printf("\x1b[0m");
 					break;  
+				}
 				case cLogger::llInfo:
+				{
 					// Yellow on black 
 					printf("\x1b[33;1m");
 					break;
+				}
 				case cLogger::llWarning:
+				{
 					// Red on black
 					printf("\x1b[31;1m");
 					break;  
+				}
 				case cLogger::llError:
+				{
 					// Yellow on red
 					printf("\x1b[1;33;41;1m");
 					break;
 				}
 			}
+		}
+		
+		
 		virtual void SetDefaultLogColour() override
 		{
 			// Whatever the console default is 
 			printf("\x1b[0m");
 		}
 	};
+	
+	
+	
 #elif defined(ANDROID_NDK)
+
+
+
 	class cAndroidConsoleListener
 		: public cLogger::cListener
 	{
@@ -127,23 +167,36 @@
 			switch (a_LogLevel)
 			{
 				case cLogger::llRegular:
+				{
 					AndroidLogLevel = ANDROID_LOG_VERBOSE;
 					break;
+				}
 				case cLogger::llInfo:
+				{
 					AndroidLogLevel = ANDROID_LOG_INFO;
 					break;
+				}
 				case cLogger::llWarning:
+				{
 					AndroidLogLevel = ANDROID_LOG_WARNING;
 					break;
+				}
 				case cLogger::llError:
+				{
 					AndroidLogLevel = ANDROID_LOG_ERROR;
 					break;
 				}
+			}
 			__android_log_print(AndroidLogLevel, "MCServer", "%s", a_Message.c_str());
 		}
 	};
+	
 #endif
 
+
+
+
+
 class cVanillaCPPConsoleListener
 	: public cLogger::cListener
 {
@@ -154,25 +207,35 @@ public:
 		switch (a_LogLevel)
 		{
 			case cLogger::llRegular:
+			{
 				LogLevelString = "Log";
 				break;
+			}
 			case cLogger::llInfo:
+			{
 				LogLevelString = "Info";
 				break;
+			}
 			case cLogger::llWarning:
+			{
 				LogLevelString = "Warning";
 				break;
+			}
 			case cLogger::llError:
+			{
 				LogLevelString = "Error";
 				break;
 			}
+		}
 		printf("%s: %s", LogLevelString.c_str(), a_Message.c_str());
 	}
 };
 
 
 
-cLogger::cListener * MakeConsoleListener()
+
+
+cLogger::cListener * MakeConsoleListener(void)
 {
 	#ifdef _WIN32
 		// See whether we are writing to a console the default console attrib:
@@ -180,12 +243,14 @@ cLogger::cListener * MakeConsoleListener()
 		if (ShouldColorOutput)
 		{
 			CONSOLE_SCREEN_BUFFER_INFO sbi;
-			HANDLE Console = getStdHandle(STD_OUTPUT_HANDLE);
+			HANDLE Console = GetStdHandle(STD_OUTPUT_HANDLE);
 			GetConsoleScreenBufferInfo(Console, &sbi);
 			WORD DefaultConsoleAttrib = sbi.wAttributes;
 			return new cWindowsConsoleListener(Console, DefaultConsoleAttrib);
-		} else {
+		}
-			return new cVanillaCPPConsoleListener();
+		else
+		{
+			return new cVanillaCPPConsoleListener;
 		}
 		
 	#elif defined (__linux) && !defined(ANDROID_NDK)
@@ -193,7 +258,9 @@ cLogger::cListener * MakeConsoleListener()
 		if (isatty(fileno(stdout)))
 		{
 			return new cLinuxConsoleListener();
-		} else {
+		}
+		else
+		{
 			return new cVanillaCPPConsoleListener();
 		}
 	#else
@@ -201,7 +268,14 @@ cLogger::cListener * MakeConsoleListener()
 	#endif
 }
 
-cFileListener::cFileListener()
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// cFileListener:
+
+cFileListener::cFileListener(void)
 {
 	cFile::CreateFolder(FILE_IO_PREFIX + AString("logs"));
 	AString FileName;
@@ -209,23 +283,39 @@ cFileListener::cFileListener()
 	m_File.Open(FileName, cFile::fmAppend);
 }
 
+
+
+
+
 void cFileListener::Log(AString a_Message, cLogger::eLogLevel a_LogLevel)
 {
 	AString LogLevelString;
 	switch (a_LogLevel)
 	{
 		case cLogger::llRegular:
+		{
 			LogLevelString = "Log";
 			break;
+		}
 		case cLogger::llInfo:
+		{
 			LogLevelString = "Info";
 			break;
+		}
 		case cLogger::llWarning:
+		{
 			LogLevelString = "Warning";
 			break;
+		}
 		case cLogger::llError:
+		{
 			LogLevelString = "Error";
 			break;
 		}
+	}
 	m_File.Printf("%s: %s", LogLevelString.c_str(), a_Message.c_str());
 }
+
+
+
+

src/LoggerListeners.h

@@ -1,17 +1,31 @@
 
 #include "Logger.h"
 
+
+
+
+
 class cFileListener
 	: public cLogger::cListener
 {
-	public:
+public:
 
 	cFileListener();
 	cFileListener(AString a_Filename);
 
 	virtual void Log(AString a_Message, cLogger::eLogLevel a_LogLevel) override;
-	private:
+	
+private:
+
 	cFile m_File;
 };
 
+
+
+
+
 cLogger::cListener * MakeConsoleListener();
+
+
+
+