Removed Logger (it's not GPL compatible).
authorRyan C. Gordon <icculus@icculus.org>
Wed, 12 May 2010 18:27:07 -0400
changeset 122 c3af28d0f07c
parent 121 d557d0a12bf7
child 124 9e8d18d7810b
Removed Logger (it's not GPL compatible).
Source/CMakeLists.txt
Source/GameInitDispose.cpp
Source/OpenGL_Windows.cpp
Source/gamegl.h
Source/logger/Copy of logger.cpp
Source/logger/Copy of logger.h
Source/logger/logger.cpp
Source/logger/logger.h
makefile.old
--- a/Source/CMakeLists.txt	Wed May 12 18:25:58 2010 -0400
+++ b/Source/CMakeLists.txt	Wed May 12 18:27:07 2010 -0400
@@ -54,8 +54,7 @@
 	unpack_private.c
 	Weapons.cpp
 	MacCompatibility.cpp
-	logger/logger.cpp
-	OpenGL_Windows.cpp 
+	OpenGL_Windows.cpp
 	openal_wrapper.cpp
 	WinInput.cpp)
 
--- a/Source/GameInitDispose.cpp	Wed May 12 18:25:58 2010 -0400
+++ b/Source/GameInitDispose.cpp	Wed May 12 18:27:07 2010 -0400
@@ -115,6 +115,12 @@
 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()
--- a/Source/OpenGL_Windows.cpp	Wed May 12 18:25:58 2010 -0400
+++ b/Source/OpenGL_Windows.cpp	Wed May 12 18:27:07 2010 -0400
@@ -1574,7 +1574,6 @@
 	LOGFUNC;
 
 #ifndef WIN32  // this is in WinMain, too.
-	logger.start(true);
 	memset( &g_theKeys, 0, sizeof( KeyMap));
 #endif
 
@@ -1705,7 +1704,7 @@
 		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 @@
 			}
 		}
 
-		logger.start(true);
-
 		memset( &g_theKeys, 0, sizeof( KeyMap));
 
 		unsigned int i = 0;
--- a/Source/gamegl.h	Wed May 12 18:25:58 2010 -0400
+++ b/Source/gamegl.h	Wed May 12 18:27:07 2010 -0400
@@ -70,7 +70,9 @@
 
 using namespace std;
 
-#include "logger/logger.h"
+/* !!! FIXME: until we replace logger better. --ryan. */
+#define LOGFUNC
+void LOG(const std::string &fmt, ...);
 
 #endif
 
--- a/Source/logger/Copy of logger.cpp	Wed May 12 18:25:58 2010 -0400
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -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
-// ---------------------------------------------------------------------------------------------------------------------------------
-
--- a/Source/logger/Copy of logger.h	Wed May 12 18:25:58 2010 -0400
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -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
-// ---------------------------------------------------------------------------------------------------------------------------------
-
--- a/Source/logger/logger.cpp	Wed May 12 18:25:58 2010 -0400
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -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
-// ---------------------------------------------------------------------------------------------------------------------------------
-
--- a/Source/logger/logger.h	Wed May 12 18:25:58 2010 -0400
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -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
-// ---------------------------------------------------------------------------------------------------------------------------------
-
--- a/makefile.old	Wed May 12 18:25:58 2010 -0400
+++ b/makefile.old	Wed May 12 18:27:07 2010 -0400
@@ -181,7 +181,6 @@
 	unpack_private.c \
 	Weapons.cpp \
 	MacCompatibility.cpp \
-	logger/logger.cpp \
 	WinInput.cpp \
 	OpenGL_Windows.cpp \
 	openal_wrapper.cpp \
@@ -380,7 +379,6 @@
 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