]> git.jsancho.org Git - lugaru.git/commitdiff
Removed Logger (it's not GPL compatible).
authorRyan C. Gordon <icculus@icculus.org>
Wed, 12 May 2010 22:27:07 +0000 (18:27 -0400)
committerRyan C. Gordon <icculus@icculus.org>
Wed, 12 May 2010 22:27:07 +0000 (18:27 -0400)
Source/CMakeLists.txt
Source/GameInitDispose.cpp
Source/OpenGL_Windows.cpp
Source/gamegl.h
Source/logger/Copy of logger.cpp [deleted file]
Source/logger/Copy of logger.h [deleted file]
Source/logger/logger.cpp [deleted file]
Source/logger/logger.h [deleted file]
makefile.old

index b2ffe3f1d9f62b9d5050c301895d693d2275ee8c..862214da6effcc8690aa49b01d527adce40b3f18 100644 (file)
@@ -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)
 
index 118a7b5f2006829bd23fdc09d458843b6e567ef3..2c157c9c7b558e18cacd572ba09453a29e3b146b 100644 (file)
@@ -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()
index 7fbeb494e423053f40bb92037ef9eae2f931f84e..a50c24ff99d7f2f5ac4ae6446f0c60c313c57c01 100644 (file)
@@ -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;
index 203cc4dd410d3e42bee8e8140c8f3b77c55ae122..38f0d4c935d47dc4ef2adec3564ccb3e493cc498 100644 (file)
@@ -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 (file)
index edd22e2..0000000
+++ /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 <string>
-#include <list>
-#include <map>
-#include <vector>
-#include <iostream>
-#include <fstream>
-#include <iomanip>
-//#include <strstream>
-#include <sstream>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <ctime>
-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<std::string>::iterator it = entries.begin();
-               for (; it != entries.end(); ++it)
-               {
-                       os << *it;
-               }
-       }
-
-private:
-       std::list<std::string> 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<LogFunc>::iterator it = entries.begin();
-               for (; it != entries.end(); ++it)
-               {
-                       it->dump(os);
-               }
-       }
-
-private:
-       std::list<LogFunc> 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 (file)
index 4019bc0..0000000
+++ /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 (file)
index 3a67a07..0000000
+++ /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 <string>
-#include <list>
-#include <map>
-#include <vector>
-#include <iostream>
-#include <fstream>
-#include <iomanip>
-#include <strstream>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <ctime>
-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 (file)
index f58b8f7..0000000
+++ /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
-// ---------------------------------------------------------------------------------------------------------------------------------
-
index 223e3b81382b71345ad00783160cdf76a255bde0..c042a0814857b0aae2cf3ac071a2411a5fdd9dbd 100644 (file)
@@ -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