From: Ryan C. Gordon Date: Wed, 12 May 2010 22:27:07 +0000 (-0400) Subject: Removed Logger (it's not GPL compatible). X-Git-Url: https://git.jsancho.org/?a=commitdiff_plain;h=a4422339d9aefd773d8edc7689f0c50e99438016;p=lugaru.git Removed Logger (it's not GPL compatible). --- diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt index b2ffe3f..862214d 100644 --- a/Source/CMakeLists.txt +++ b/Source/CMakeLists.txt @@ -54,8 +54,7 @@ set(LUGARU_SRCS unpack_private.c Weapons.cpp MacCompatibility.cpp - logger/logger.cpp - OpenGL_Windows.cpp + OpenGL_Windows.cpp openal_wrapper.cpp WinInput.cpp) diff --git a/Source/GameInitDispose.cpp b/Source/GameInitDispose.cpp index 118a7b5..2c157c9 100644 --- a/Source/GameInitDispose.cpp +++ b/Source/GameInitDispose.cpp @@ -115,6 +115,12 @@ extern FSOUND_STREAM * strm[20]; extern "C" void PlaySoundEx(int channel, FSOUND_SAMPLE *sptr, FSOUND_DSPUNIT *dsp, signed char startpaused); extern "C" void PlayStreamEx(int chan, FSOUND_STREAM *sptr, FSOUND_DSPUNIT *dsp, signed char startpaused); +void LOG(const std::string &fmt, ...) +{ + // !!! FIXME: write me. +} + + Game::TextureList Game::textures; void Game::Dispose() diff --git a/Source/OpenGL_Windows.cpp b/Source/OpenGL_Windows.cpp index 7fbeb49..a50c24f 100644 --- a/Source/OpenGL_Windows.cpp +++ b/Source/OpenGL_Windows.cpp @@ -1574,7 +1574,6 @@ int main(int argc, char **argv) LOGFUNC; #ifndef WIN32 // this is in WinMain, too. - logger.start(true); memset( &g_theKeys, 0, sizeof( KeyMap)); #endif @@ -1705,7 +1704,7 @@ int main(int argc, char **argv) std::string e = "Caught exception: "; e += error.what(); - LOG(e, Logger::LOG_ERR); + LOG(e); MessageBox(g_windowHandle, error.what(), "ERROR", MB_OK | MB_ICONEXCLAMATION); } @@ -2364,8 +2363,6 @@ int main(int argc, char **argv) } } - logger.start(true); - memset( &g_theKeys, 0, sizeof( KeyMap)); unsigned int i = 0; diff --git a/Source/gamegl.h b/Source/gamegl.h index 203cc4d..38f0d4c 100644 --- a/Source/gamegl.h +++ b/Source/gamegl.h @@ -70,7 +70,9 @@ typedef RGBColor * RGBColorPtr; using namespace std; -#include "logger/logger.h" +/* !!! FIXME: until we replace logger better. --ryan. */ +#define LOGFUNC +void LOG(const std::string &fmt, ...); #endif diff --git a/Source/logger/Copy of logger.cpp b/Source/logger/Copy of logger.cpp deleted file mode 100644 index edd22e2..0000000 --- a/Source/logger/Copy of logger.cpp +++ /dev/null @@ -1,448 +0,0 @@ -// --------------------------------------------------------------------------------------------------------------------------------- -// _ -// | | -// | | ___ __ _ __ _ ___ _ __ ___ _ __ _ __ -// | |/ _ \ / _` |/ _` |/ _ \ '__| / __| '_ \| '_ \ -// | | (_) | (_| | (_| | __/ | _ | (__| |_) | |_) | -// |_|\___/ \__, |\__, |\___|_| (_) \___| .__/| .__/ -// __/ | __/ | | | | | -// |___/ |___/ |_| |_| -// -// Generic informational logging class -// -// --------------------------------------------------------------------------------------------------------------------------------- -// -// Restrictions & freedoms pertaining to usage and redistribution of this software: -// -// * This software is 100% free -// * If you use this software (in part or in whole) you must credit the author. -// * This software may not be re-distributed (in part or in whole) in a modified -// form without clear documentation on how to obtain a copy of the original work. -// * You may not use this software to directly or indirectly cause harm to others. -// * This software is provided as-is and without warrantee. Use at your own risk. -// -// For more information, visit HTTP://www.FluidStudios.com -// -// --------------------------------------------------------------------------------------------------------------------------------- -// Originally created on 07/06/2000 by Paul Nettle -// -// Copyright 2000, Fluid Studios, Inc., all rights reserved. -// --------------------------------------------------------------------------------------------------------------------------------- - -//#include "stdafx.h" // If this line gives you an error, comment it out -#include -#include -#include -#include -#include -#include -#include -//#include -#include -#include -#include -#include -using namespace std; - -#include "logger.h" - -class LogFunc -{ -public: - LogFunc(void) {} - - void pushMessage(const std::string & str) - { - entries.push_back(str); - } - - void dump(std::ostream & os) - { - std::list::iterator it = entries.begin(); - for (; it != entries.end(); ++it) - { - os << *it; - } - } - -private: - std::list entries; -}; - -class LogStack -{ -public: - LogStack(void) - { - pushFunc(); - } - - void pushFunc(void) - { - entries.push_back(LogFunc()); - } - - void popFunc(void) - { - if (entries.size() > 1) - { - entries.pop_back(); - } - } - - void logMessage(const std::string & str_) - { - entries.back().pushMessage(str_); - } - - void dump(std::ostream & os) - { - std::list::iterator it = entries.begin(); - for (; it != entries.end(); ++it) - { - it->dump(os); - } - } - -private: - std::list entries; -}; - -// --------------------------------------------------------------------------------------------------------------------------------- -// The global log stack object -// --------------------------------------------------------------------------------------------------------------------------------- -LogStack logStack; - -void pushFunc(void) {logStack.pushFunc();} -void popFunc(void) {logStack.popFunc();} - -void dumpLog(void) -{ - ofstream of(logger.logFile().c_str(), ios::out | ios::trunc); - if (!of) return; - logStack.dump(of); -} - -// --------------------------------------------------------------------------------------------------------------------------------- -// The global logger object -// --------------------------------------------------------------------------------------------------------------------------------- - -Logger logger; - -// --------------------------------------------------------------------------------------------------------------------------------- -#ifdef _DEBUG -void Logger::limitFileSize() const -{ - if (fileSizeLimit() < 0) return; - struct _stat sbuf; - _stat(logFile().c_str(), &sbuf); - if (sbuf.st_size > fileSizeLimit()) - { - unlink(logFile().c_str()); - } -} - -// --------------------------------------------------------------------------------------------------------------------------------- - -void Logger::start(const bool reset) -{ - std::stringstream ss; - - if (logStarted()) return; - _logStarted = true; - - // Get the time - - time_t t = time(NULL); - string ts = asctime(localtime(&t)); - ts[ts.length() - 1] = 0; - - // Start the log - - //limitFileSize(); - //ofstream of(logFile().c_str(), ios::out | (reset ? ios::trunc : ios::app)); - //if (!of) return; - - //of << "---------------------------------------------- Log begins on " << ts << " ----------------------------------------------" << endl; - ss << "---------------------------------------------- Log begins on " << ts << " ----------------------------------------------" << endl; - logStack.logMessage(ss.str()); -} - -// --------------------------------------------------------------------------------------------------------------------------------- - -void Logger::stop() -{ - std::stringstream ss; - - // Automatic One time only startup - - if (!logStarted()) return; - _logStarted = false; - - // Get the time - - time_t t = time(NULL); - string ts = asctime(localtime(&t)); - ts.erase(ts.length() - 1); - - // Stop the log - - limitFileSize(); - ofstream of(logFile().c_str(), ios::out|ios::app); - if (!of) return; - - //of << "----------------------------------------------- Log ends on " << ts << " -----------------------------------------------" << endl << endl; - ss << "----------------------------------------------- Log ends on " << ts << " -----------------------------------------------" << endl << endl; - logStack.logMessage(ss.str()); -} - -// --------------------------------------------------------------------------------------------------------------------------------- - -void Logger::logTex(const string &s, const LogFlags logBits) -{ - std::stringstream ss; - - // If the bits don't match the mask, then bail - - if (!(logBits & logMask())) return; - - // Open the file - - limitFileSize(); - ofstream of(logFile().c_str(), ios::out|ios::app); - if (!of) return; - - // Output to the log file - - //of << headerString(logBits) << s << endl; - ss << headerString(logBits) << s << endl; - logStack.logMessage(ss.str()); -} - -// --------------------------------------------------------------------------------------------------------------------------------- - -void Logger::logRaw(const string &s) -{ - std::stringstream ss; - - // Open the file - - //limitFileSize(); - //ofstream of(logFile().c_str(), ios::out|ios::app); - //if (!of) return; - - // Log the output - - //of << s << endl; - ss << s << endl; - logStack.logMessage(ss.str()); -} - -// --------------------------------------------------------------------------------------------------------------------------------- - -void Logger::logHex(const char *buffer, const unsigned int count, const LogFlags logBits) -{ - std::stringstream ss; - - // No input? No output - - if (!buffer) return; - - // If the bits don't match the mask, then bail - - if (!(logBits & logMask())) return; - - // Open the file - - //limitFileSize(); - //ofstream of(logFile().c_str(), ios::out|ios::app); - //if (!of) return; - - // Log the output - - unsigned int logged = 0; - while(logged < count) - { - // One line at a time... - - string line; - - // The number of characters per line - - unsigned int hexLength = 20; - - // Default the buffer - - unsigned int i; - for (i = 0; i < hexLength; i++) - { - line += "-- "; - } - - for (i = 0; i < hexLength; i++) - { - line += "."; - } - - // Fill it in with real data - - for (i = 0; i < hexLength && logged < count; i++, logged++) - { - unsigned char byte = buffer[logged]; - unsigned int index = i * 3; - - // The hex characters - - const string hexlist("0123456789ABCDEF"); - line[index+0] = hexlist[byte >> 4]; - line[index+1] = hexlist[byte & 0xf]; - - // The ascii characters - - if (byte < 0x20 || byte > 0x7f) byte = '.'; - line[(hexLength*3)+i+0] = byte; - } - - // Write it to the log file - - //of << headerString(logBits) << line << endl; - ss << headerString(logBits) << line << endl; - logStack.logMessage(ss.str()); - } -} - -// --------------------------------------------------------------------------------------------------------------------------------- - -void Logger::indent(const string &s, const LogFlags logBits) -{ - std::stringstream ss; - - // If the bits don't match the mask, then bail - - if (!(logBits & logMask())) return; - - // Open the file - - //limitFileSize(); - //ofstream of(logFile().c_str(), ios::out|ios::app); - //if (!of) return; - - // Log the output - - //if (lineCharsFlag()) of << headerString(logBits) << "\xDA\xC4\xC4" << s << endl; - //else of << headerString(logBits) << "+- " << s << endl; - - if (lineCharsFlag()) ss << headerString(logBits) << "\xDA\xC4\xC4" << s << endl; - else ss << headerString(logBits) << "+- " << s << endl; - logStack.logMessage(ss.str()); - - // Indent... - - _indentCount += _indentChars; -} - -// --------------------------------------------------------------------------------------------------------------------------------- - -void Logger::undent(const string &s, const LogFlags logBits) -{ - std::stringstream ss; - - // If the bits don't match the mask, then bail - - if (!(logBits & logMask())) return; - - // Undo the indentation - - _indentCount -= _indentChars; - if (_indentCount < 0) _indentCount = 0; - - // Open the file - - limitFileSize(); - ofstream of(logFile().c_str(), ios::out|ios::app); - if (!of) return; - - // Log the output - - //if (lineCharsFlag()) of << headerString(logBits) << "\xC0\xC4\xC4" << s << endl; - //else of << headerString(logBits) << "+- " << s << endl; - - if (lineCharsFlag()) ss << headerString(logBits) << "\xC0\xC4\xC4" << s << endl; - else ss << headerString(logBits) << "+- " << s << endl; - logStack.logMessage(ss.str()); -} - -// --------------------------------------------------------------------------------------------------------------------------------- - -const string &Logger::headerString(const LogFlags logBits) const -{ - static string headerString; - headerString.erase(); - - // Get the string that represents the bits - - switch(logBits) - { - case LOG_INDENT : headerString += "> "; break; - case LOG_UNDENT : headerString += "< "; break; - case LOG_ALL : headerString += "A "; break; - case LOG_CRIT : headerString += "! "; break; - case LOG_DATA : headerString += "D "; break; - case LOG_ERR : headerString += "E "; break; - case LOG_FLOW : headerString += "F "; break; - case LOG_INFO : headerString += "I "; break; - case LOG_WARN : headerString += "W "; break; - default: headerString += " "; break; - } - - // File string (strip out the path) - - char temp[1024]; - int ix = sourceFile().rfind('\\'); - ix = (ix == (int) string::npos ? 0: ix+1); - sprintf(temp, "%25s[%04d]", sourceFile().substr(ix).c_str(), sourceLine()); - headerString += temp; - - // Time string (specially formatted to save room) - - time_t t = time(NULL); - struct tm *tme = localtime(&t); - sprintf(temp, "%02d/%02d %02d:%02d ", tme->tm_mon + 1, tme->tm_mday, tme->tm_hour, tme->tm_min); - headerString += temp; - - // Spaces for indentation - - memset(temp, ' ', sizeof(temp)); - temp[_indentCount] = '\0'; - - // Add the indentation markers - - int count = 0; - while(count < _indentCount) - { - if (lineCharsFlag()) temp[count] = '\xB3'; - else temp[count] = '|'; - count += _indentChars; - } - headerString += temp; - - return headerString; -} - -#else /*Release Build*/ - std::string release_Null; - void Logger::limitFileSize() const {} - const string &Logger::headerString(const LogFlags logBits) const{return release_Null;} - void Logger::start(const bool reset){} - void Logger::stop(){} - void Logger::logTex(const string &s, const LogFlags logBits /*= LOG_INFO*/){} - void Logger::logRaw(const string &s){} - void Logger::logHex(const char *buffer, const unsigned int count, const LogFlags logBits /*= LOG_INFO*/){} - void Logger::indent(const string &s, const LogFlags logBits /*= LOG_INDENT*/){} - void Logger::undent(const string &s, const LogFlags logBits /*= LOG_UNDENT*/){} -#endif - -// --------------------------------------------------------------------------------------------------------------------------------- -// logger.cpp - End of file -// --------------------------------------------------------------------------------------------------------------------------------- - diff --git a/Source/logger/Copy of logger.h b/Source/logger/Copy of logger.h deleted file mode 100644 index 4019bc0..0000000 --- a/Source/logger/Copy of logger.h +++ /dev/null @@ -1,186 +0,0 @@ -// --------------------------------------------------------------------------------------------------------------------------------- -// _ _ -// | | | | -// | | ___ __ _ __ _ ___ _ __ | |__ -// | |/ _ \ / _` |/ _` |/ _ \ '__| | '_ \ -// | | (_) | (_| | (_| | __/ | _ | | | | -// |_|\___/ \__, |\__, |\___|_| (_)|_| |_| -// __/ | __/ | -// |___/ |___/ -// -// Generic informational logging class -// -// --------------------------------------------------------------------------------------------------------------------------------- -// -// Restrictions & freedoms pertaining to usage and redistribution of this software: -// -// * This software is 100% free -// * If you use this software (in part or in whole) you must credit the author. -// * This software may not be re-distributed (in part or in whole) in a modified -// form without clear documentation on how to obtain a copy of the original work. -// * You may not use this software to directly or indirectly cause harm to others. -// * This software is provided as-is and without warrantee. Use at your own risk. -// -// For more information, visit HTTP://www.FluidStudios.com -// -// --------------------------------------------------------------------------------------------------------------------------------- -// Originally created on 07/06/2000 by Paul Nettle -// -// Copyright 2000, Fluid Studios, Inc., all rights reserved. -// --------------------------------------------------------------------------------------------------------------------------------- - -#ifndef _H_LOGGER -#define _H_LOGGER - -// --------------------------------------------------------------------------------------------------------------------------------- -// The global logger -// --------------------------------------------------------------------------------------------------------------------------------- - -class Logger; -extern Logger logger; - -// --------------------------------------------------------------------------------------------------------------------------------- -// Macros (necessary evil to take advantage of __LINE__ and __FILE__) -// --------------------------------------------------------------------------------------------------------------------------------- - -#define LOG logger.sourceLine() = __LINE__, logger.sourceFile() = __FILE__,logger.logTex -#define HEX logger.sourceLine() = __LINE__, logger.sourceFile() = __FILE__,logger.logHex -#define RAW logger.sourceLine() = __LINE__, logger.sourceFile() = __FILE__,logger.logRaw -#define INDENT logger.sourceLine() = __LINE__, logger.sourceFile() = __FILE__,logger.indent -#define UNDENT logger.sourceLine() = __LINE__, logger.sourceFile() = __FILE__,logger.undent -#define LOGBLOCK logger.sourceLine() = __LINE__, logger.sourceFile() = __FILE__;LogBlock __lb__ - -// If you compiler supports __FUNCTION__, then replace the "#if 1" with "#if 0". Note that this will change the usage of the macro - -#if 0 -#define LOGFUNC logger.sourceLine() = __LINE__, logger.sourceFile() = __FILE__;LogFlow __lf__ -#else -#define LOGFUNC logger.sourceLine() = __LINE__, logger.sourceFile() = __FILE__;LogFlow __lf__(__FUNCTION__) -#endif - -// --------------------------------------------------------------------------------------------------------------------------------- -// The logger class: does the actual logging -// --------------------------------------------------------------------------------------------------------------------------------- - -class Logger -{ -public: - // Enumerations - - enum LogFlags - { - LOG_INDENT = 0x00000001, - LOG_UNDENT = 0x00000002, - LOG_FLOW = 0x00000004, - LOG_BLOK = 0x00000008, - LOG_DATA = 0x00000010, - LOG_INFO = 0x00000012, - LOG_WARN = 0x00000014, - LOG_ERR = 0x00000018, - LOG_CRIT = 0x00000020, - LOG_ALL = 0xFFFFFFFF - }; - - // Construction/Destruction - -inline Logger() - : _sourceLine(0), _indentCount(0), _indentChars(4), _fileSizeLimit(-1), _logMask(LOG_ALL), - _logStarted(false), _lineCharsFlag(false), _logFile("logger.log") - { - } - -virtual ~Logger() - { - stop(); - } - - // Operators - -inline void operator +=(const string &s) {logTex(s);} - - // Accessors - -inline const bool &lineCharsFlag() const {return _lineCharsFlag;} -inline bool &lineCharsFlag() {return _lineCharsFlag;} - -inline const int &fileSizeLimit() const {return _fileSizeLimit;} -inline int &fileSizeLimit() {return _fileSizeLimit;} - -inline const unsigned int &logMask() const {return _logMask;} -inline unsigned int &logMask() {return _logMask;} - -inline const string &logFile() const {return _logFile;} -inline string &logFile() {return _logFile;} - -inline const unsigned int &sourceLine() const {return _sourceLine;} -inline unsigned int &sourceLine() {return _sourceLine;} - -inline const string &sourceFile() const {return _sourceFile;} -inline string &sourceFile() {return _sourceFile;} - -inline bool logStarted() const {return _logStarted;} - - // Utilitarian (public) - -virtual void start(const bool reset); -virtual void stop(); -virtual void logTex(const string &s, const LogFlags logBits = LOG_INFO); -virtual void logRaw(const string &s); -virtual void logHex(const char *buffer, const unsigned int count, const LogFlags logBits = LOG_INFO); -virtual void indent(const string &s, const LogFlags logBits = LOG_INDENT); -virtual void undent(const string &s, const LogFlags logBits = LOG_UNDENT); - -private: - // Utilitarian (private) - -virtual void limitFileSize() const; -virtual const string &headerString(const LogFlags logBits) const; - - // Data - - string _logFile; - string _sourceFile; - unsigned int _sourceLine; - int _indentCount; - int _indentChars; - int _fileSizeLimit; - unsigned int _logMask; - bool _logStarted; - bool _lineCharsFlag; -}; - -// --------------------------------------------------------------------------------------------------------------------------------- -// The LogBlock class: used for automatic indentation -// --------------------------------------------------------------------------------------------------------------------------------- - -class LogBlock -{ -public: -inline LogBlock(const string &s) {str = s;logger.indent("Begin block: " + str, Logger::LOG_INDENT);} -inline ~LogBlock() {logger.undent("", Logger::LOG_UNDENT);} -private: - string str; -}; - -// --------------------------------------------------------------------------------------------------------------------------------- -// The LogFlow class: used for logging code flow -// --------------------------------------------------------------------------------------------------------------------------------- - -void pushFunc(void); -void popFunc(void); -void dumpLog(void); - -class LogFlow -{ -public: -inline LogFlow(const string &function) {pushFunc(); str = function;logger.indent(str, Logger::LOG_FLOW);} -inline ~LogFlow() {logger.undent("", Logger::LOG_FLOW); popFunc();} -private: - string str; -}; - -#endif // _H_LOGGER -// --------------------------------------------------------------------------------------------------------------------------------- -// logger.h - End of file -// --------------------------------------------------------------------------------------------------------------------------------- - diff --git a/Source/logger/logger.cpp b/Source/logger/logger.cpp deleted file mode 100644 index 3a67a07..0000000 --- a/Source/logger/logger.cpp +++ /dev/null @@ -1,337 +0,0 @@ -// --------------------------------------------------------------------------------------------------------------------------------- -// _ -// | | -// | | ___ __ _ __ _ ___ _ __ ___ _ __ _ __ -// | |/ _ \ / _` |/ _` |/ _ \ '__| / __| '_ \| '_ \ -// | | (_) | (_| | (_| | __/ | _ | (__| |_) | |_) | -// |_|\___/ \__, |\__, |\___|_| (_) \___| .__/| .__/ -// __/ | __/ | | | | | -// |___/ |___/ |_| |_| -// -// Generic informational logging class -// -// --------------------------------------------------------------------------------------------------------------------------------- -// -// Restrictions & freedoms pertaining to usage and redistribution of this software: -// -// * This software is 100% free -// * If you use this software (in part or in whole) you must credit the author. -// * This software may not be re-distributed (in part or in whole) in a modified -// form without clear documentation on how to obtain a copy of the original work. -// * You may not use this software to directly or indirectly cause harm to others. -// * This software is provided as-is and without warrantee. Use at your own risk. -// -// For more information, visit HTTP://www.FluidStudios.com -// -// --------------------------------------------------------------------------------------------------------------------------------- -// Originally created on 07/06/2000 by Paul Nettle -// -// Copyright 2000, Fluid Studios, Inc., all rights reserved. -// --------------------------------------------------------------------------------------------------------------------------------- - -//#include "stdafx.h" // If this line gives you an error, comment it out -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -using namespace std; - -#include "logger.h" - -// --------------------------------------------------------------------------------------------------------------------------------- -// The global logger object -// --------------------------------------------------------------------------------------------------------------------------------- - -Logger logger; - -// --------------------------------------------------------------------------------------------------------------------------------- -#ifdef _DEBUG -void Logger::limitFileSize() const -{ - if (fileSizeLimit() < 0) return; - struct _stat sbuf; - _stat(logFile().c_str(), &sbuf); - if (sbuf.st_size > fileSizeLimit()) - { - unlink(logFile().c_str()); - } -} - -// --------------------------------------------------------------------------------------------------------------------------------- - -void Logger::start(const bool reset) -{ - if (logStarted()) return; - _logStarted = true; - - // Get the time - - time_t t = time(NULL); - string ts = asctime(localtime(&t)); - ts[ts.length() - 1] = 0; - - // Start the log - - limitFileSize(); - ofstream of(logFile().c_str(), ios::out | (reset ? ios::trunc : ios::app)); - if (!of) return; - - of << "---------------------------------------------- Log begins on " << ts << " ----------------------------------------------" << endl; -} - -// --------------------------------------------------------------------------------------------------------------------------------- - -void Logger::stop() -{ - // Automatic One time only startup - - if (!logStarted()) return; - _logStarted = false; - - // Get the time - - time_t t = time(NULL); - string ts = asctime(localtime(&t)); - ts.erase(ts.length() - 1); - - // Stop the log - - limitFileSize(); - ofstream of(logFile().c_str(), ios::out|ios::app); - if (!of) return; - - of << "----------------------------------------------- Log ends on " << ts << " -----------------------------------------------" << endl << endl; -} - -// --------------------------------------------------------------------------------------------------------------------------------- - -void Logger::logTex(const string &s, const LogFlags logBits) -{ - // If the bits don't match the mask, then bail - - if (!(logBits & logMask())) return; - - // Open the file - - limitFileSize(); - ofstream of(logFile().c_str(), ios::out|ios::app); - if (!of) return; - - // Output to the log file - - of << headerString(logBits) << s << endl; -} - -// --------------------------------------------------------------------------------------------------------------------------------- - -void Logger::logRaw(const string &s) -{ - // Open the file - - limitFileSize(); - ofstream of(logFile().c_str(), ios::out|ios::app); - if (!of) return; - - // Log the output - - of << s << endl; -} - -// --------------------------------------------------------------------------------------------------------------------------------- - -void Logger::logHex(const char *buffer, const unsigned int count, const LogFlags logBits) -{ - // No input? No output - - if (!buffer) return; - - // If the bits don't match the mask, then bail - - if (!(logBits & logMask())) return; - - // Open the file - - limitFileSize(); - ofstream of(logFile().c_str(), ios::out|ios::app); - if (!of) return; - - // Log the output - - unsigned int logged = 0; - while(logged < count) - { - // One line at a time... - - string line; - - // The number of characters per line - - unsigned int hexLength = 20; - - // Default the buffer - - unsigned int i; - for (i = 0; i < hexLength; i++) - { - line += "-- "; - } - - for (i = 0; i < hexLength; i++) - { - line += "."; - } - - // Fill it in with real data - - for (i = 0; i < hexLength && logged < count; i++, logged++) - { - unsigned char byte = buffer[logged]; - unsigned int index = i * 3; - - // The hex characters - - const string hexlist("0123456789ABCDEF"); - line[index+0] = hexlist[byte >> 4]; - line[index+1] = hexlist[byte & 0xf]; - - // The ascii characters - - if (byte < 0x20 || byte > 0x7f) byte = '.'; - line[(hexLength*3)+i+0] = byte; - } - - // Write it to the log file - - of << headerString(logBits) << line << endl; - } -} - -// --------------------------------------------------------------------------------------------------------------------------------- - -void Logger::indent(const string &s, const LogFlags logBits) -{ - // If the bits don't match the mask, then bail - - if (!(logBits & logMask())) return; - - // Open the file - - limitFileSize(); - ofstream of(logFile().c_str(), ios::out|ios::app); - if (!of) return; - - // Log the output - - if (lineCharsFlag()) of << headerString(logBits) << "\xDA\xC4\xC4" << s << endl; - else of << headerString(logBits) << "+- " << s << endl; - - // Indent... - - _indentCount += _indentChars; -} - -// --------------------------------------------------------------------------------------------------------------------------------- - -void Logger::undent(const string &s, const LogFlags logBits) -{ - // If the bits don't match the mask, then bail - - if (!(logBits & logMask())) return; - - // Undo the indentation - - _indentCount -= _indentChars; - if (_indentCount < 0) _indentCount = 0; - - // Open the file - - limitFileSize(); - ofstream of(logFile().c_str(), ios::out|ios::app); - if (!of) return; - - // Log the output - - if (lineCharsFlag()) of << headerString(logBits) << "\xC0\xC4\xC4" << s << endl; - else of << headerString(logBits) << "+- " << s << endl; -} - -// --------------------------------------------------------------------------------------------------------------------------------- - -const string &Logger::headerString(const LogFlags logBits) const -{ - static string headerString; - headerString.erase(); - - // Get the string that represents the bits - - switch(logBits) - { - case LOG_INDENT : headerString += "> "; break; - case LOG_UNDENT : headerString += "< "; break; - case LOG_ALL : headerString += "A "; break; - case LOG_CRIT : headerString += "! "; break; - case LOG_DATA : headerString += "D "; break; - case LOG_ERR : headerString += "E "; break; - case LOG_FLOW : headerString += "F "; break; - case LOG_INFO : headerString += "I "; break; - case LOG_WARN : headerString += "W "; break; - default: headerString += " "; break; - } - - // File string (strip out the path) - - char temp[1024]; - int ix = sourceFile().rfind('\\'); - ix = (ix == (int) string::npos ? 0: ix+1); - sprintf(temp, "%25s[%04d]", sourceFile().substr(ix).c_str(), sourceLine()); - headerString += temp; - - // Time string (specially formatted to save room) - - time_t t = time(NULL); - struct tm *tme = localtime(&t); - sprintf(temp, "%02d/%02d %02d:%02d ", tme->tm_mon + 1, tme->tm_mday, tme->tm_hour, tme->tm_min); - headerString += temp; - - // Spaces for indentation - - memset(temp, ' ', sizeof(temp)); - temp[_indentCount] = '\0'; - - // Add the indentation markers - - int count = 0; - while(count < _indentCount) - { - if (lineCharsFlag()) temp[count] = '\xB3'; - else temp[count] = '|'; - count += _indentChars; - } - headerString += temp; - - return headerString; -} - -#else /*Release Build*/ - std::string release_Null; - void Logger::limitFileSize() const {} - const string &Logger::headerString(const LogFlags logBits) const{return release_Null;} - void Logger::start(const bool reset){} - void Logger::stop(){} - void Logger::logTex(const string &s, const LogFlags logBits /*= LOG_INFO*/){} - void Logger::logRaw(const string &s){} - void Logger::logHex(const char *buffer, const unsigned int count, const LogFlags logBits /*= LOG_INFO*/){} - void Logger::indent(const string &s, const LogFlags logBits /*= LOG_INDENT*/){} - void Logger::undent(const string &s, const LogFlags logBits /*= LOG_UNDENT*/){} -#endif -// --------------------------------------------------------------------------------------------------------------------------------- -// logger.cpp - End of file -// --------------------------------------------------------------------------------------------------------------------------------- - diff --git a/Source/logger/logger.h b/Source/logger/logger.h deleted file mode 100644 index f58b8f7..0000000 --- a/Source/logger/logger.h +++ /dev/null @@ -1,182 +0,0 @@ -// --------------------------------------------------------------------------------------------------------------------------------- -// _ _ -// | | | | -// | | ___ __ _ __ _ ___ _ __ | |__ -// | |/ _ \ / _` |/ _` |/ _ \ '__| | '_ \ -// | | (_) | (_| | (_| | __/ | _ | | | | -// |_|\___/ \__, |\__, |\___|_| (_)|_| |_| -// __/ | __/ | -// |___/ |___/ -// -// Generic informational logging class -// -// --------------------------------------------------------------------------------------------------------------------------------- -// -// Restrictions & freedoms pertaining to usage and redistribution of this software: -// -// * This software is 100% free -// * If you use this software (in part or in whole) you must credit the author. -// * This software may not be re-distributed (in part or in whole) in a modified -// form without clear documentation on how to obtain a copy of the original work. -// * You may not use this software to directly or indirectly cause harm to others. -// * This software is provided as-is and without warrantee. Use at your own risk. -// -// For more information, visit HTTP://www.FluidStudios.com -// -// --------------------------------------------------------------------------------------------------------------------------------- -// Originally created on 07/06/2000 by Paul Nettle -// -// Copyright 2000, Fluid Studios, Inc., all rights reserved. -// --------------------------------------------------------------------------------------------------------------------------------- - -#ifndef _H_LOGGER -#define _H_LOGGER - -// --------------------------------------------------------------------------------------------------------------------------------- -// The global logger -// --------------------------------------------------------------------------------------------------------------------------------- - -class Logger; -extern Logger logger; - -// --------------------------------------------------------------------------------------------------------------------------------- -// Macros (necessary evil to take advantage of __LINE__ and __FILE__) -// --------------------------------------------------------------------------------------------------------------------------------- - -#define LOG logger.sourceLine() = __LINE__, logger.sourceFile() = __FILE__,logger.logTex -#define HEX logger.sourceLine() = __LINE__, logger.sourceFile() = __FILE__,logger.logHex -#define RAW logger.sourceLine() = __LINE__, logger.sourceFile() = __FILE__,logger.logRaw -#define INDENT logger.sourceLine() = __LINE__, logger.sourceFile() = __FILE__,logger.indent -#define UNDENT logger.sourceLine() = __LINE__, logger.sourceFile() = __FILE__,logger.undent -#define LOGBLOCK logger.sourceLine() = __LINE__, logger.sourceFile() = __FILE__;LogBlock __lb__ - -// If you compiler supports __FUNCTION__, then replace the "#if 1" with "#if 0". Note that this will change the usage of the macro - -#if 0 -#define LOGFUNC logger.sourceLine() = __LINE__, logger.sourceFile() = __FILE__;LogFlow __lf__ -#else -#define LOGFUNC logger.sourceLine() = __LINE__, logger.sourceFile() = __FILE__;LogFlow __lf__(__FUNCTION__) -#endif - -// --------------------------------------------------------------------------------------------------------------------------------- -// The logger class: does the actual logging -// --------------------------------------------------------------------------------------------------------------------------------- - -class Logger -{ -public: - // Enumerations - - enum LogFlags - { - LOG_INDENT = 0x00000001, - LOG_UNDENT = 0x00000002, - LOG_FLOW = 0x00000004, - LOG_BLOK = 0x00000008, - LOG_DATA = 0x00000010, - LOG_INFO = 0x00000012, - LOG_WARN = 0x00000014, - LOG_ERR = 0x00000018, - LOG_CRIT = 0x00000020, - LOG_ALL = 0xFFFFFFFF - }; - - // Construction/Destruction - -inline Logger() - : _sourceLine(0), _indentCount(0), _indentChars(4), _fileSizeLimit(-1), _logMask(LOG_ALL), - _logStarted(false), _lineCharsFlag(false), _logFile("logger.log") - { - } - -virtual ~Logger() - { - stop(); - } - - // Operators - -inline void operator +=(const string &s) {logTex(s);} - - // Accessors - -inline const bool &lineCharsFlag() const {return _lineCharsFlag;} -inline bool &lineCharsFlag() {return _lineCharsFlag;} - -inline const int &fileSizeLimit() const {return _fileSizeLimit;} -inline int &fileSizeLimit() {return _fileSizeLimit;} - -inline const unsigned int &logMask() const {return _logMask;} -inline unsigned int &logMask() {return _logMask;} - -inline const string &logFile() const {return _logFile;} -inline string &logFile() {return _logFile;} - -inline const unsigned int &sourceLine() const {return _sourceLine;} -inline unsigned int &sourceLine() {return _sourceLine;} - -inline const string &sourceFile() const {return _sourceFile;} -inline string &sourceFile() {return _sourceFile;} - -inline bool logStarted() const {return _logStarted;} - - // Utilitarian (public) - -virtual void start(const bool reset); -virtual void stop(); -virtual void logTex(const string &s, const LogFlags logBits = LOG_INFO); -virtual void logRaw(const string &s); -virtual void logHex(const char *buffer, const unsigned int count, const LogFlags logBits = LOG_INFO); -virtual void indent(const string &s, const LogFlags logBits = LOG_INDENT); -virtual void undent(const string &s, const LogFlags logBits = LOG_UNDENT); - -private: - // Utilitarian (private) - -virtual void limitFileSize() const; -virtual const string &headerString(const LogFlags logBits) const; - - // Data - - string _logFile; - string _sourceFile; - unsigned int _sourceLine; - int _indentCount; - int _indentChars; - int _fileSizeLimit; - unsigned int _logMask; - bool _logStarted; - bool _lineCharsFlag; -}; - -// --------------------------------------------------------------------------------------------------------------------------------- -// The LogBlock class: used for automatic indentation -// --------------------------------------------------------------------------------------------------------------------------------- - -class LogBlock -{ -public: -inline LogBlock(const string &s) {str = s;logger.indent("Begin block: " + str, Logger::LOG_INDENT);} -inline ~LogBlock() {logger.undent("", Logger::LOG_UNDENT);} -private: - string str; -}; - -// --------------------------------------------------------------------------------------------------------------------------------- -// The LogFlow class: used for logging code flow -// --------------------------------------------------------------------------------------------------------------------------------- - -class LogFlow -{ -public: -inline LogFlow(const string &function) {str = function;logger.indent(str, Logger::LOG_FLOW);} -inline ~LogFlow() {logger.undent("", Logger::LOG_FLOW);} -private: - string str; -}; - -#endif // _H_LOGGER -// --------------------------------------------------------------------------------------------------------------------------------- -// logger.h - End of file -// --------------------------------------------------------------------------------------------------------------------------------- - diff --git a/makefile.old b/makefile.old index 223e3b8..c042a08 100644 --- a/makefile.old +++ b/makefile.old @@ -181,7 +181,6 @@ SRCS := \ unpack_private.c \ Weapons.cpp \ MacCompatibility.cpp \ - logger/logger.cpp \ WinInput.cpp \ OpenGL_Windows.cpp \ openal_wrapper.cpp \ @@ -380,7 +379,6 @@ $(EXE) : $(OBJS) $(APPOBJS) clean: rm -f $(BINDIR)/*.o rm -f $(BINDIR)/$(SRCDIR)/*.o - rm -f $(BINDIR)/$(SRCDIR)/logger/*.o rm -f $(BINDIR)/$(GLUDIR)/*.o rm -f $(BINDIR)/$(LIBPNGDIR)/*.o rm -f $(BINDIR)/$(JPEGLIBDIR)/*.o