mirror of
https://github.com/VCMP-SqMod/SqMod.git
synced 2025-11-07 09:47:18 +01:00
Dumped the old implementation. Started with a more simple approach.
This commit is contained in:
Sandu Liviu Catalin
@@ -1,50 +1,55 @@
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
#include "Logger.hpp"
|
||||
#include "Register.hpp"
|
||||
#include "Core.hpp"
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
#include <ctime>
|
||||
#include <cstdio>
|
||||
#include <cstdarg>
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
#include <sqstdstring.h>
|
||||
#include <time.h>
|
||||
#include <stdio.h>
|
||||
#include <stdarg.h>
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
namespace {
|
||||
|
||||
#ifdef SQMOD_OS_WINDOWS
|
||||
#include <Windows.h>
|
||||
|
||||
enum
|
||||
{
|
||||
LOG_COLOR_NORMAL = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE,
|
||||
LOG_COLOR_WHITE = FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE,
|
||||
LOG_COLOR_GRAY = FOREGROUND_INTENSITY,
|
||||
LOG_COLOR_LIGHT_BLUE = FOREGROUND_INTENSITY | FOREGROUND_BLUE,
|
||||
LOG_COLOR_DARK_BLUE = FOREGROUND_BLUE,
|
||||
LOG_COLOR_LIGHT_GREEN = FOREGROUND_INTENSITY | FOREGROUND_GREEN,
|
||||
LOG_COLOR_DARK_GREEN = FOREGROUND_GREEN,
|
||||
LOG_COLOR_LIGHT_CYAN = FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_BLUE,
|
||||
LOG_COLOR_DARK_CYAN = FOREGROUND_GREEN | FOREGROUND_BLUE,
|
||||
LOG_COLOR_LIGHT_YELLOW = FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN,
|
||||
LOG_COLOR_DARK_YELLOW = FOREGROUND_RED | FOREGROUND_GREEN,
|
||||
LOG_COLOR_LIGHT_RED = FOREGROUND_INTENSITY | FOREGROUND_RED,
|
||||
LOG_COLOR_DARK_RED = FOREGROUND_RED,
|
||||
LOG_COLOR_LIGHT_MAGENTA = FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_BLUE,
|
||||
LOG_COLOR_DARK_MAGENTA = FOREGROUND_RED | FOREGROUND_BLUE
|
||||
};
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
#include <Windows.h>
|
||||
|
||||
enum
|
||||
{
|
||||
LOG_COLOR_DBG = LOG_COLOR_LIGHT_BLUE,
|
||||
LOG_COLOR_MSG = LOG_COLOR_GRAY,
|
||||
LOG_COLOR_SCS = LOG_COLOR_LIGHT_GREEN,
|
||||
LOG_COLOR_INF = LOG_COLOR_LIGHT_CYAN,
|
||||
LOG_COLOR_WRN = LOG_COLOR_LIGHT_YELLOW,
|
||||
LOG_COLOR_ERR = LOG_COLOR_LIGHT_MAGENTA,
|
||||
LOG_COLOR_FTL = LOG_COLOR_LIGHT_RED
|
||||
};
|
||||
/* ------------------------------------------------------------------------------------------------
|
||||
* ...
|
||||
*/
|
||||
enum
|
||||
{
|
||||
LC_NORMAL = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE,
|
||||
LC_WHITE = FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE,
|
||||
LC_GRAY = FOREGROUND_INTENSITY,
|
||||
LC_LIGHT_BLUE = FOREGROUND_INTENSITY | FOREGROUND_BLUE,
|
||||
LC_DARK_BLUE = FOREGROUND_BLUE,
|
||||
LC_LIGHT_GREEN = FOREGROUND_INTENSITY | FOREGROUND_GREEN,
|
||||
LC_DARK_GREEN = FOREGROUND_GREEN,
|
||||
LC_LIGHT_CYAN = FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_BLUE,
|
||||
LC_DARK_CYAN = FOREGROUND_GREEN | FOREGROUND_BLUE,
|
||||
LC_LIGHT_YELLOW = FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN,
|
||||
LC_DARK_YELLOW = FOREGROUND_RED | FOREGROUND_GREEN,
|
||||
LC_LIGHT_RED = FOREGROUND_INTENSITY | FOREGROUND_RED,
|
||||
LC_DARK_RED = FOREGROUND_RED,
|
||||
LC_LIGHT_MAGENTA = FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_BLUE,
|
||||
LC_DARK_MAGENTA = FOREGROUND_RED | FOREGROUND_BLUE
|
||||
};
|
||||
|
||||
/* ------------------------------------------------------------------------------------------------
|
||||
* ...
|
||||
*/
|
||||
enum
|
||||
{
|
||||
LC_DBG = LC_LIGHT_BLUE,
|
||||
LC_USER = LC_GRAY,
|
||||
LC_SCS = LC_LIGHT_GREEN,
|
||||
LC_INF = LC_LIGHT_CYAN,
|
||||
LC_WRN = LC_LIGHT_YELLOW,
|
||||
LC_ERR = LC_LIGHT_MAGENTA,
|
||||
LC_FTL = LC_LIGHT_RED
|
||||
};
|
||||
|
||||
#endif // SQMOD_OS_WINDOWS
|
||||
|
||||
@@ -53,428 +58,340 @@ namespace {
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
namespace SqMod {
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
const Logger::Pointer _Log = Logger::Inst();
|
||||
// --------------------------------------------------------------------------------------------
|
||||
Logger * _Log = NULL;
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
inline const char * GetLevelTag(Uint8 type)
|
||||
/* ------------------------------------------------------------------------------------------------
|
||||
* ...
|
||||
*/
|
||||
inline CCStr GetLevelTag(Uint8 type)
|
||||
{
|
||||
switch (type)
|
||||
{
|
||||
case Logger::LEVEL_DBG: return "[DBG]";
|
||||
case Logger::LEVEL_MSG: return "[MSG]";
|
||||
case Logger::LEVEL_SCS: return "[SCS]";
|
||||
case Logger::LEVEL_INF: return "[INF]";
|
||||
case Logger::LEVEL_WRN: return "[WRN]";
|
||||
case Logger::LEVEL_ERR: return "[ERR]";
|
||||
case Logger::LEVEL_FTL: return "[FTL]";
|
||||
case LL_DBG: return "[DBG]";
|
||||
case LL_USR: return "[USR]";
|
||||
case LL_SCS: return "[SCS]";
|
||||
case LL_INF: return "[INF]";
|
||||
case LL_WRN: return "[WRN]";
|
||||
case LL_ERR: return "[ERR]";
|
||||
case LL_FTL: return "[FTL]";
|
||||
default: return "[UNK]";
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef SQMOD_OS_WINDOWS
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
/* ------------------------------------------------------------------------------------------------
|
||||
* ...
|
||||
*/
|
||||
inline Uint16 GetLevelColor(Uint8 type)
|
||||
{
|
||||
switch (type)
|
||||
{
|
||||
case Logger::LEVEL_DBG: return LOG_COLOR_DBG;
|
||||
case Logger::LEVEL_MSG: return LOG_COLOR_MSG;
|
||||
case Logger::LEVEL_SCS: return LOG_COLOR_SCS;
|
||||
case Logger::LEVEL_INF: return LOG_COLOR_INF;
|
||||
case Logger::LEVEL_WRN: return LOG_COLOR_WRN;
|
||||
case Logger::LEVEL_ERR: return LOG_COLOR_ERR;
|
||||
case Logger::LEVEL_FTL: return LOG_COLOR_FTL;
|
||||
default: return LOG_COLOR_NORMAL;
|
||||
case LL_DBG: return LC_DBG;
|
||||
case LL_USR: return LC_USER;
|
||||
case LL_SCS: return LC_SCS;
|
||||
case LL_INF: return LC_INF;
|
||||
case LL_WRN: return LC_WRN;
|
||||
case LL_ERR: return LC_ERR;
|
||||
case LL_FTL: return LC_FTL;
|
||||
default: return LC_NORMAL;
|
||||
}
|
||||
}
|
||||
#else
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
inline const char * GetLevelColor(Uint8 type)
|
||||
/* ------------------------------------------------------------------------------------------------
|
||||
* ...
|
||||
*/
|
||||
inline CCStr GetLevelColor(Uint8 type)
|
||||
{
|
||||
return "";
|
||||
return g_EmptyStr;
|
||||
}
|
||||
|
||||
#endif // SQMOD_OS_WINDOWS
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
Logger::Logger()
|
||||
: m_ConsoleTime(false), m_FileTime(true)
|
||||
, m_ConsoleLevels(Logger::LEVEL_ANY), m_FileLevels(Logger::LEVEL_ANY)
|
||||
, m_LogPath("./logs/"), m_DebugLevel(SQMOD_DEBUG_LEVEL), m_Verbosity(0)
|
||||
: m_Buffer(4096)
|
||||
, m_TmBuff()
|
||||
, m_Levels(LL_ANY)
|
||||
, m_Time(false)
|
||||
{
|
||||
|
||||
/* ... */
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
Logger::~Logger()
|
||||
{
|
||||
|
||||
/* ... */
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void Logger::_Finalizer(Logger * ptr)
|
||||
void Logger::Send(Uint8 type, bool sub, CCStr fmt, va_list args)
|
||||
{
|
||||
if (ptr) delete ptr;
|
||||
if (!(m_Levels & type))
|
||||
return;
|
||||
m_Buffer.WriteF(0, fmt, args);
|
||||
Proccess(type, sub);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
Logger::Pointer Logger::Inst()
|
||||
{
|
||||
if (!_Log) return Pointer(new Logger(), &Logger::_Finalizer);
|
||||
return Pointer(nullptr, &Logger::_Finalizer);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
bool Logger::Init()
|
||||
{
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Logger::Load()
|
||||
{
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void Logger::Deinit()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void Logger::Unload()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void Logger::Terminate()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void Logger::ToggleConsoleTime(bool enabled)
|
||||
{
|
||||
m_ConsoleTime = enabled;
|
||||
}
|
||||
|
||||
void Logger::ToggleFileTime(bool enabled)
|
||||
{
|
||||
m_FileTime = enabled;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
bool Logger::HasConsoleTime() const
|
||||
{
|
||||
return m_ConsoleTime;
|
||||
}
|
||||
|
||||
bool Logger::HasFileTime()const
|
||||
{
|
||||
return m_FileTime;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void Logger::SetConsoleLevels(Uint8 levels)
|
||||
{
|
||||
m_ConsoleLevels = levels;
|
||||
}
|
||||
|
||||
void Logger::SetFileLevels(Uint8 levels)
|
||||
{
|
||||
m_FileLevels = levels;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
Uint8 Logger::GetConsoleLevels() const
|
||||
{
|
||||
return m_ConsoleLevels;
|
||||
}
|
||||
|
||||
Uint8 Logger::GetFileLevels() const
|
||||
{
|
||||
return m_FileLevels;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void Logger::EnableConsoleLevel(Uint8 level)
|
||||
{
|
||||
m_ConsoleLevels |= level;
|
||||
}
|
||||
|
||||
void Logger::EnableFileLevel(Uint8 level)
|
||||
{
|
||||
m_FileLevels |= level;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void Logger::DisableConsoleLevel(Uint8 level)
|
||||
{
|
||||
if (m_ConsoleLevels & level) m_ConsoleLevels ^= level;
|
||||
}
|
||||
|
||||
void Logger::DisableFileLevel(Uint8 level)
|
||||
{
|
||||
if (m_FileLevels & level) m_FileLevels ^= level;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
Uint8 Logger::GetDebugLevel() const
|
||||
{
|
||||
return m_DebugLevel;
|
||||
}
|
||||
|
||||
void Logger::SetDebugLevel(Uint8 level)
|
||||
{
|
||||
m_DebugLevel = level;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
SQInt32 Logger::GetVerbosity() const
|
||||
{
|
||||
return m_Verbosity;
|
||||
}
|
||||
|
||||
void Logger::SetVerbosity(SQInt32 level)
|
||||
{
|
||||
m_Verbosity = level;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void Logger::Send(Uint8 type, bool sub, const char * fmt, va_list args)
|
||||
{
|
||||
// Verify that this level is allowed to be streamed
|
||||
if (!(m_ConsoleLevels & type) && !(m_FileLevels & type)) return;
|
||||
|
||||
// Allocate space for the time stamp string
|
||||
char timebuff[80];
|
||||
|
||||
// Grab the local time into a string if required
|
||||
if (m_ConsoleTime || m_FileTime)
|
||||
{
|
||||
// Create the variables required to retrieve the time.
|
||||
time_t rawtime;
|
||||
struct tm * timeinfo;
|
||||
|
||||
// Retrieve the local time.
|
||||
time(&rawtime);
|
||||
timeinfo = localtime(&rawtime);
|
||||
|
||||
// Format the retrieved time.
|
||||
strftime(timebuff, 80, "%Y-%m-%d %H:%M:%S", timeinfo);
|
||||
}
|
||||
|
||||
// Output to console if streaming to console is enabled
|
||||
if (m_ConsoleLevels & type)
|
||||
{
|
||||
#ifdef SQMOD_OS_WINDOWS
|
||||
// Get the handle to the output stream
|
||||
HANDLE hstdout = GetStdHandle(STD_OUTPUT_HANDLE);
|
||||
|
||||
// Save the current state of the console screen buffer
|
||||
CONSOLE_SCREEN_BUFFER_INFO csb_state;
|
||||
GetConsoleScreenBufferInfo(hstdout, &csb_state);
|
||||
|
||||
// Set the attributes for the message information
|
||||
SetConsoleTextAttribute(hstdout, GetLevelColor(type));
|
||||
|
||||
// Output the message information
|
||||
if (m_ConsoleTime)
|
||||
{
|
||||
printf("%s %s ", GetLevelTag(type), timebuff);
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("%s ", GetLevelTag(type));
|
||||
}
|
||||
|
||||
// Set the attributes for the message content
|
||||
SetConsoleTextAttribute(hstdout, sub ? LOG_COLOR_NORMAL : LOG_COLOR_WHITE);
|
||||
|
||||
// Print the specified message
|
||||
vprintf(fmt, args);
|
||||
|
||||
// Restore the state of the console screen buffer
|
||||
SetConsoleTextAttribute(hstdout, csb_state.wAttributes);
|
||||
#else
|
||||
// Output the message information
|
||||
if (m_ConsoleTime)
|
||||
{
|
||||
printf("%s %s ", GetLevelTag(type), timebuff);
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("%s ", GetLevelTag(type));
|
||||
}
|
||||
|
||||
// Print the specified message
|
||||
vprintf(fmt, args);
|
||||
#endif // SQMOD_OS_WINDOWS
|
||||
|
||||
// Terminate the line
|
||||
puts("");
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void Logger::Message(Uint8 type, bool sub, const char * fmt, ...)
|
||||
void Logger::Message(Uint8 type, bool sub, CCStr fmt, ...)
|
||||
{
|
||||
if (!(m_Levels & type))
|
||||
return;
|
||||
va_list args;
|
||||
va_start(args, fmt);
|
||||
Send(type, sub, fmt, args);
|
||||
m_Buffer.WriteF(0, fmt, args);
|
||||
Proccess(type, sub);
|
||||
va_end(args);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void Logger::Throw(CCStr fmt, ...)
|
||||
{
|
||||
va_list args;
|
||||
va_start(args, fmt);
|
||||
m_Buffer.WriteF(0, fmt, args);
|
||||
va_end(args);
|
||||
Error::Throw(DefaultVM::Get(), m_Buffer.Data());
|
||||
}
|
||||
|
||||
void Logger::Throw(CCStr fmt, va_list args)
|
||||
{
|
||||
m_Buffer.WriteF(0, fmt, args);
|
||||
Error::Throw(DefaultVM::Get(), m_Buffer.Data());
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void Logger::Debug(CCStr fmt, ...)
|
||||
{
|
||||
va_list args;
|
||||
va_start(args, fmt);
|
||||
Debug(fmt, args);
|
||||
va_end(args);
|
||||
}
|
||||
|
||||
void Logger::Debug(CCStr fmt, va_list args)
|
||||
{
|
||||
HSQUIRRELVM vm = DefaultVM::Get();
|
||||
SQStackInfos si;
|
||||
Int32 ret = m_Buffer.WriteF(0, fmt, args);
|
||||
|
||||
if (SQ_SUCCEEDED(sq_stackinfos(vm, 1, &si)))
|
||||
m_Buffer.WriteF(ret, "\n[\n=>Location: %s\n=>Line: %d\n=>Function: %s\n]"
|
||||
, si.source ? si.source : _SC("unknown")
|
||||
, si.line
|
||||
, si.funcname ? si.funcname : _SC("unknown"));
|
||||
else
|
||||
m_Buffer.WriteF(ret, "\n[\n=>Location: unknown\n=>Line: unknown\n=>Function: unknown\n]");
|
||||
|
||||
Proccess(LL_ERR, true);
|
||||
|
||||
ret = m_Buffer.WriteF(0, "Traceback:\n[\n");
|
||||
|
||||
for (Int32 level = 1; SQ_SUCCEEDED(sq_stackinfos(vm, level, &si)); ++level)
|
||||
{
|
||||
ret += m_Buffer.WriteF(ret, "=> [%d] %s (%d) [%s]\n", level
|
||||
, si.source ? si.source : _SC("unknown")
|
||||
, si.line
|
||||
, si.funcname ? si.funcname : _SC("unknown"));
|
||||
}
|
||||
|
||||
m_Buffer.WriteF(ret, "]");
|
||||
Proccess(LL_INF, true);
|
||||
|
||||
CCStr s_ = 0, name = 0;
|
||||
SQInteger i_, seq = 0;
|
||||
SQFloat f_;
|
||||
SQUserPointer p_;
|
||||
|
||||
ret = m_Buffer.WriteF(0, "Locals:\n[\n");
|
||||
|
||||
for (Int32 level = 0; level < 10; level++)
|
||||
{
|
||||
seq = 0;
|
||||
while((name = sq_getlocal(vm, level, seq)))
|
||||
{
|
||||
++seq;
|
||||
switch(sq_gettype(vm, -1))
|
||||
{
|
||||
case OT_NULL:
|
||||
ret += m_Buffer.WriteF(ret, "=> [%d] NULL [%s] : ...\n", level, name);
|
||||
break;
|
||||
case OT_INTEGER:
|
||||
sq_getinteger(vm, -1, &i_);
|
||||
ret += m_Buffer.WriteF(ret, "=> [%d] INTEGER [%s] : %d\n", level, name, i_);
|
||||
break;
|
||||
case OT_FLOAT:
|
||||
sq_getfloat(vm, -1, &f_);
|
||||
ret += m_Buffer.WriteF(ret, "=> [%d] FLOAT [%s] : %f\n", level, name, f_);
|
||||
break;
|
||||
case OT_USERPOINTER:
|
||||
sq_getuserpointer(vm, -1, &p_);
|
||||
ret += m_Buffer.WriteF(ret, "=> [%d] USERPOINTER [%s] : %p\n", level, name, p_);
|
||||
break;
|
||||
case OT_STRING:
|
||||
sq_getstring(vm, -1, &s_);
|
||||
ret += m_Buffer.WriteF(ret, "=> [%d] STRING [%s] : %s\n", level, name, s_);
|
||||
break;
|
||||
case OT_TABLE:
|
||||
ret += m_Buffer.WriteF(ret, "=> [%d] TABLE [%s] : ...\n", level, name);
|
||||
break;
|
||||
case OT_ARRAY:
|
||||
ret += m_Buffer.WriteF(ret, "=> [%d] ARRAY [%s] : ...\n", level, name);
|
||||
break;
|
||||
case OT_CLOSURE:
|
||||
ret += m_Buffer.WriteF(ret, "=> [%d] CLOSURE [%s] : ...\n", level, name);
|
||||
break;
|
||||
case OT_NATIVECLOSURE:
|
||||
ret += m_Buffer.WriteF(ret, "=> [%d] NATIVECLOSURE [%s] : ...\n", level, name);
|
||||
break;
|
||||
case OT_GENERATOR:
|
||||
ret += m_Buffer.WriteF(ret, "=> [%d] GENERATOR [%s] : ...\n", level, name);
|
||||
break;
|
||||
case OT_USERDATA:
|
||||
ret += m_Buffer.WriteF(ret, "=> [%d] USERDATA [%s] : ...\n", level, name);
|
||||
break;
|
||||
case OT_THREAD:
|
||||
ret += m_Buffer.WriteF(ret, "=> [%d] THREAD [%s] : ...\n", level, name);
|
||||
break;
|
||||
case OT_CLASS:
|
||||
ret += m_Buffer.WriteF(ret, "=> [%d] CLASS [%s] : ...\n", level, name);
|
||||
break;
|
||||
case OT_INSTANCE:
|
||||
ret += m_Buffer.WriteF(ret, "=> [%d] INSTANCE [%s] : ...\n", level, name);
|
||||
break;
|
||||
case OT_WEAKREF:
|
||||
ret += m_Buffer.WriteF(ret, "=> [%d] WEAKREF [%s] : ...\n", level, name);
|
||||
break;
|
||||
case OT_BOOL:
|
||||
sq_getinteger(vm, -1, &i_);
|
||||
ret += m_Buffer.WriteF(ret, "=> [%d] BOOL [%s] : %s\n", level, name, i_ ? _SC("true") : _SC("false"));
|
||||
break;
|
||||
default:
|
||||
ret += m_Buffer.WriteF(ret, "=> [%d] UNKNOWN [%s] : ...\n", level, name);
|
||||
break;
|
||||
}
|
||||
sq_pop(vm, 1);
|
||||
}
|
||||
}
|
||||
|
||||
m_Buffer.WriteF(ret, "]");
|
||||
Proccess(LL_INF, true);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void Logger::Proccess(Uint8 type, bool sub)
|
||||
{
|
||||
if (m_Time)
|
||||
{
|
||||
time_t rawtime;
|
||||
struct tm * timeinfo;
|
||||
time(&rawtime);
|
||||
timeinfo = localtime(&rawtime);
|
||||
strftime(m_TmBuff, 80, "%Y-%m-%d %H:%M:%S", timeinfo);
|
||||
}
|
||||
else
|
||||
m_TmBuff[0] = 0;
|
||||
#ifdef SQMOD_OS_WINDOWS
|
||||
HANDLE hstdout = GetStdHandle(STD_OUTPUT_HANDLE);
|
||||
CONSOLE_SCREEN_BUFFER_INFO csb_state;
|
||||
GetConsoleScreenBufferInfo(hstdout, &csb_state);
|
||||
SetConsoleTextAttribute(hstdout, GetLevelColor(type));
|
||||
if (m_Time)
|
||||
printf("%s %s ", GetLevelTag(type), m_TmBuff);
|
||||
else
|
||||
printf("%s ", GetLevelTag(type));
|
||||
SetConsoleTextAttribute(hstdout, sub ? LC_NORMAL : LC_WHITE);
|
||||
puts(m_Buffer.Data());
|
||||
SetConsoleTextAttribute(hstdout, csb_state.wAttributes);
|
||||
#else
|
||||
if (m_Time)
|
||||
printf("%s %s ", GetLevelTag(type), m_TmBuff);
|
||||
else
|
||||
printf("%s ", GetLevelTag(type));
|
||||
puts(m_Buffer.Data());
|
||||
#endif // SQMOD_OS_WINDOWS
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
#define SQMOD_LOG(N_, L_, S_) /*
|
||||
*/ void Logger::N_(const char * fmt, ...) /*
|
||||
*/ void N_(CCStr fmt, ...) /*
|
||||
*/ { /*
|
||||
*/ va_list args; /*
|
||||
*/ va_start(args, fmt); /*
|
||||
*/ Send(L_, S_, fmt, args); /*
|
||||
*/ if (_Log) /*
|
||||
*/ _Log->Send(L_, S_, fmt, args); /*
|
||||
*/ else /*
|
||||
*/ vprintf(fmt, args); /*
|
||||
*/ va_end(args); /*
|
||||
*/ } /*
|
||||
*/
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
SQMOD_LOG(Dbg, LEVEL_DBG, false)
|
||||
SQMOD_LOG(Msg, LEVEL_MSG, false)
|
||||
SQMOD_LOG(Scs, LEVEL_SCS, false)
|
||||
SQMOD_LOG(Inf, LEVEL_INF, false)
|
||||
SQMOD_LOG(Wrn, LEVEL_WRN, false)
|
||||
SQMOD_LOG(Err, LEVEL_ERR, false)
|
||||
SQMOD_LOG(Ftl, LEVEL_FTL, false)
|
||||
SQMOD_LOG(LogDbg, LL_DBG, false)
|
||||
SQMOD_LOG(LogUsr, LL_USR, false)
|
||||
SQMOD_LOG(LogScs, LL_SCS, false)
|
||||
SQMOD_LOG(LogInf, LL_INF, false)
|
||||
SQMOD_LOG(LogWrn, LL_WRN, false)
|
||||
SQMOD_LOG(LogErr, LL_ERR, false)
|
||||
SQMOD_LOG(LogFtl, LL_FTL, false)
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
SQMOD_LOG(SDbg, LEVEL_DBG, true)
|
||||
SQMOD_LOG(SMsg, LEVEL_MSG, true)
|
||||
SQMOD_LOG(SScs, LEVEL_SCS, true)
|
||||
SQMOD_LOG(SInf, LEVEL_INF, true)
|
||||
SQMOD_LOG(SWrn, LEVEL_WRN, true)
|
||||
SQMOD_LOG(SErr, LEVEL_ERR, true)
|
||||
SQMOD_LOG(SFtl, LEVEL_FTL, true)
|
||||
SQMOD_LOG(LogSDbg, LL_DBG, true)
|
||||
SQMOD_LOG(LogSUsr, LL_USR, true)
|
||||
SQMOD_LOG(LogSScs, LL_SCS, true)
|
||||
SQMOD_LOG(LogSInf, LL_INF, true)
|
||||
SQMOD_LOG(LogSWrn, LL_WRN, true)
|
||||
SQMOD_LOG(LogSErr, LL_ERR, true)
|
||||
SQMOD_LOG(LogSFtl, LL_FTL, true)
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
#define SQMOD_CLOG(N_, L_, S_) /*
|
||||
*/bool Logger::N_(bool c, const char * fmt, ...) /*
|
||||
*/bool N_(bool c, CCStr fmt, ...) /*
|
||||
*/ { /*
|
||||
*/ if (c) /*
|
||||
*/ { /*
|
||||
*/ va_list args; /*
|
||||
*/ va_start(args, fmt); /*
|
||||
*/ Send(L_, S_, fmt, args); /*
|
||||
*/ va_end(args); /*
|
||||
*/ } /*
|
||||
*/ if (!c) /*
|
||||
*/ return c; /*
|
||||
*/ va_list args; /*
|
||||
*/ va_start(args, fmt); /*
|
||||
*/ if (_Log) /*
|
||||
*/ _Log->Send(L_, S_, fmt, args); /*
|
||||
*/ else /*
|
||||
*/ vprintf(fmt, args); /*
|
||||
*/ va_end(args); /*
|
||||
*/ return c; /*
|
||||
*/ } /*
|
||||
*/
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
SQMOD_CLOG(cDbg, LEVEL_DBG, false)
|
||||
SQMOD_CLOG(cMsg, LEVEL_MSG, false)
|
||||
SQMOD_CLOG(cScs, LEVEL_SCS, false)
|
||||
SQMOD_CLOG(cInf, LEVEL_INF, false)
|
||||
SQMOD_CLOG(cWrn, LEVEL_WRN, false)
|
||||
SQMOD_CLOG(cErr, LEVEL_ERR, false)
|
||||
SQMOD_CLOG(cFtl, LEVEL_FTL, false)
|
||||
SQMOD_CLOG(cLogDbg, LL_DBG, false)
|
||||
SQMOD_CLOG(cLogUsr, LL_USR, false)
|
||||
SQMOD_CLOG(cLogScs, LL_SCS, false)
|
||||
SQMOD_CLOG(cLogInf, LL_INF, false)
|
||||
SQMOD_CLOG(cLogWrn, LL_WRN, false)
|
||||
SQMOD_CLOG(cLogErr, LL_ERR, false)
|
||||
SQMOD_CLOG(cLogFtl, LL_FTL, false)
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
SQMOD_CLOG(cSDbg, LEVEL_DBG, true)
|
||||
SQMOD_CLOG(cSMsg, LEVEL_MSG, true)
|
||||
SQMOD_CLOG(cSScs, LEVEL_SCS, true)
|
||||
SQMOD_CLOG(cSInf, LEVEL_INF, true)
|
||||
SQMOD_CLOG(cSWrn, LEVEL_WRN, true)
|
||||
SQMOD_CLOG(cSErr, LEVEL_ERR, true)
|
||||
SQMOD_CLOG(cSFtl, LEVEL_FTL, true)
|
||||
SQMOD_CLOG(cLogSDbg, LL_DBG, true)
|
||||
SQMOD_CLOG(cLogSUsr, LL_USR, true)
|
||||
SQMOD_CLOG(cLogSScs, LL_SCS, true)
|
||||
SQMOD_CLOG(cLogSInf, LL_INF, true)
|
||||
SQMOD_CLOG(cLogSWrn, LL_WRN, true)
|
||||
SQMOD_CLOG(cLogSErr, LL_ERR, true)
|
||||
SQMOD_CLOG(cLogSFtl, LL_FTL, true)
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
template < Uint8 L, bool S > static SQInteger LogBasicMessage(HSQUIRRELVM vm)
|
||||
void SqThrow(CCStr fmt, ...)
|
||||
{
|
||||
const SQInteger top = sq_gettop(vm);
|
||||
// Are there any arguments on the stack?
|
||||
if (top <= 1)
|
||||
{
|
||||
_Log->Err("Attempting to <log message> without specifying a value");
|
||||
}
|
||||
// Is there a single string or at least something that can convert to a string on the stack?
|
||||
else if (top == 2 && ((sq_gettype(vm, -1) == OT_STRING) || !SQ_FAILED(sq_tostring(vm, -1))))
|
||||
{
|
||||
// Variable where the resulted string will be retrieved
|
||||
const SQChar * msg = 0;
|
||||
// Attempt to retrieve the specified message from the stack
|
||||
if (SQ_FAILED(sq_getstring(vm, -1, &msg)))
|
||||
{
|
||||
_Log->Err("Unable to <retrieve the log message> from the stack");
|
||||
// Pop any pushed values pushed to the stack
|
||||
sq_settop(vm, top);
|
||||
// Failed to log the value
|
||||
return 0;
|
||||
}
|
||||
// Pop any pushed values pushed to the stack
|
||||
sq_settop(vm, top);
|
||||
// Log the specified string
|
||||
_Log->Message(L, S, "%s", msg);
|
||||
}
|
||||
else if (top > 2)
|
||||
{
|
||||
// Variables containing the resulted string
|
||||
SQChar * msg = NULL;
|
||||
SQInteger len = 0;
|
||||
// Attempt to call the format function with the passed arguments
|
||||
if (SQ_FAILED(sqstd_format(vm, 2, &len, &msg)))
|
||||
{
|
||||
_Log->Err("Unable to <generate the log message> because : %s", Error::Message(vm).c_str());
|
||||
// Failed to log the value
|
||||
return 0;
|
||||
}
|
||||
// Log the resulted string
|
||||
_Log->Message(L, S, "%s", msg);
|
||||
}
|
||||
va_list args;
|
||||
va_start(args, fmt);
|
||||
if (_Log)
|
||||
_Log->Throw(fmt, args);
|
||||
else
|
||||
{
|
||||
_Log->Err("Unable to <extract the log message> from the specified value");
|
||||
}
|
||||
// At this point everything went correctly
|
||||
return 0;
|
||||
}
|
||||
|
||||
// ================================================================================================
|
||||
bool Register_Log(HSQUIRRELVM vm)
|
||||
{
|
||||
|
||||
// // Attempt to create the Log namespace
|
||||
Sqrat::Table logns(vm);
|
||||
|
||||
// Output debugging information
|
||||
LogDbg("Beginning registration of <Log functions> type");
|
||||
// Attempt to register the free functions
|
||||
logns.SquirrelFunc(_SC("Dbg"), &LogBasicMessage< Logger::LEVEL_DBG, false >);
|
||||
logns.SquirrelFunc(_SC("Msg"), &LogBasicMessage< Logger::LEVEL_MSG, false >);
|
||||
logns.SquirrelFunc(_SC("Scs"), &LogBasicMessage< Logger::LEVEL_SCS, false >);
|
||||
logns.SquirrelFunc(_SC("Inf"), &LogBasicMessage< Logger::LEVEL_INF, false >);
|
||||
logns.SquirrelFunc(_SC("Wrn"), &LogBasicMessage< Logger::LEVEL_WRN, false >);
|
||||
logns.SquirrelFunc(_SC("Err"), &LogBasicMessage< Logger::LEVEL_ERR, false >);
|
||||
logns.SquirrelFunc(_SC("Ftl"), &LogBasicMessage< Logger::LEVEL_FTL, false >);
|
||||
logns.SquirrelFunc(_SC("SDbg"), &LogBasicMessage< Logger::LEVEL_DBG, true >);
|
||||
logns.SquirrelFunc(_SC("SMsg"), &LogBasicMessage< Logger::LEVEL_MSG, true >);
|
||||
logns.SquirrelFunc(_SC("SScs"), &LogBasicMessage< Logger::LEVEL_SCS, true >);
|
||||
logns.SquirrelFunc(_SC("SInf"), &LogBasicMessage< Logger::LEVEL_INF, true >);
|
||||
logns.SquirrelFunc(_SC("SWrn"), &LogBasicMessage< Logger::LEVEL_WRN, true >);
|
||||
logns.SquirrelFunc(_SC("SErr"), &LogBasicMessage< Logger::LEVEL_ERR, true >);
|
||||
logns.SquirrelFunc(_SC("SFtl"), &LogBasicMessage< Logger::LEVEL_FTL, true >);
|
||||
// Output debugging information
|
||||
LogDbg("Registration of <Log functions> type was successful");
|
||||
|
||||
// Attempt to bind the namespace to the root table
|
||||
Sqrat::RootTable(vm).Bind(_SC("Log"), logns);
|
||||
|
||||
// Registration succeeded
|
||||
return true;
|
||||
vprintf(fmt, args);
|
||||
va_end(args);
|
||||
}
|
||||
|
||||
} // Namespace:: SqMod
|
||||
|
||||
Reference in New Issue
Block a user