Moved headers and started moving tests

ChangeLog

 
  OpenRaider (0.1.2) xythobuz <xythobuz@xythobuz.de>
 
+	[ 20140109 ]
+	* Renamed all memeory references to memory
+	* Moved headers into include/
+	* Put Unit Tests into test/
+
 	[ 20140107 ]
 	* Removed hel/Mass. There was an object of this class in World,
 	  but it was never used!

Makefile

 # -DUNICODE_SUPPORT			Add unicode/internation keyboard support
 # -DUSING_EMITTER_IN_GAME	Run particle test in game
 
-BASE_DEFS=$(shell sdl-config --cflags) -Isrc -DSDL_INTERFACE \
+BASE_DEFS=$(shell sdl-config --cflags) -Iinclude -DSDL_INTERFACE \
 	-DUSING_OPENGL -DZLIB_SUPPORT -DUSING_EMITTER \
 	-DUSING_OPENAL -DUSING_MTK_TGA -DUSING_PTHREADS \
 	-DUSING_HEL -DHAVE_SDL_TTF
 	CFLAGS="$(DEBUG_CFLAGS) -DDEDICATED_SERVER" \
 	LD_FLAGS="$(LD_FLAGS)"
 
-# -DDEBUG_MEMEORY_VERBOSE
-# -DDEBUG_MEMEORY
+# -DDEBUG_MEMORY_VERBOSE
+# -DDEBUG_MEMORY
 memory:
 	@-mkdir -p $(BUILD_MEM_DIR)
 	$(MAKE) targets BUILDDIR=$(BUILD_MEM_DIR) \
 	DEBUG_OBJ="$(BUILD_MEM_DIR)/memory_test.o" \
-	CFLAGS="$(DEBUG_CFLAGS) -DDEBUG_MEMEORY" \
+	CFLAGS="$(DEBUG_CFLAGS) -DDEBUG_MEMORY" \
 	LD_FLAGS="$(LD_FLAGS)"
 
 depend:
 TombRaider.test:
 	@-mkdir -p $(BUILD_TEST_DIR)
 	$(MAKE) targets NAME=TombRaider.test BUILDDIR=$(BUILD_TEST_DIR) \
-	OBJS="$(BUILD_TEST_DIR)/TombRaider.o $(BUILD_TEST_DIR)/mtk_tga.o $(BUILD_TEST_DIR)/memeory_test.o" \
-	CFLAGS="$(BASE_CFLAGS) -g -D__TOMBRAIDER_TEST__ -D__TEST_TR5_DUMP_TGA -D__TEST_32BIT_TEXTILES -DDEBUG_MEMEORY" \
+	OBJS="$(BUILD_TEST_DIR)/TombRaider.o $(BUILD_TEST_DIR)/mtk_tga.o $(BUILD_TEST_DIR)/memory_test.o" \
+	CFLAGS="$(BASE_CFLAGS) -g -D__TOMBRAIDER_TEST__ -D__TEST_TR5_DUMP_TGA -D__TEST_32BIT_TEXTILES -DDEBUG_MEMORY" \
 	LD_FLAGS="-lz -lstdc++"
 
 #################################################################
 
 GLString.test:
 	mkdir -p $(BUILD_TEST_DIR)
-	$(CC) -Wall -Isrc -D__TEST__ -DHAVE_MTK -DHAVE_SDL -DUSING_MTK_TGA \
+	$(CC) -Wall -Iinclude -D__TEST__ -DHAVE_MTK -DHAVE_SDL -DUSING_MTK_TGA \
 	$(shell sdl-config --cflags) $(shell sdl-config --libs) \
 	$(GL_LIBS) $(GL_DEFS) -lm -lstdc++ \
 	src/Texture.cpp src/mtk_tga.cpp \
 Matrix.test:
 	@-echo "Building Matrix unit test"
 	mkdir -p $(BUILD_TEST_DIR)
-	$(CC) -Wall -g -DMATRIX_UNIT_TEST -lm -lstdc++ -Isrc \
+	$(CC) -Wall -g -DMATRIX_UNIT_TEST -lm -lstdc++ -Iinclude \
 	src/hel/Matrix.cpp src/hel/Quaternion.cpp src/hel/Vector3d.cpp \
 	-o $(BUILD_TEST_DIR)/Matrix.test
 	@-echo "================================================="
 Quaternion.test:
 	@-echo "Building Quaternion unit test"
 	mkdir -p $(BUILD_TEST_DIR)
-	$(CC) -Wall -g -DUNIT_TEST_QUATERNION -lm -lstdc++ -Isrc \
+	$(CC) -Wall -g -DUNIT_TEST_QUATERNION -lm -lstdc++ -Iinclude \
 	src/hel/Quaternion.cpp -o $(BUILD_TEST_DIR)/Quaternion.test
 	@-echo "================================================="
 	@-echo "Running Quaternion unit test"
 Math.test:
 	@-echo "Building Math unit test"
 	mkdir -p $(BUILD_TEST_DIR)
-	$(CC) -Wall -g -DMATH_UNIT_TEST -lm -lstdc++ -Isrc \
+	$(CC) -Wall -g -DMATH_UNIT_TEST -lm -lstdc++ -Iinclude \
 	src/hel/math.cpp src/hel/Vector3d.cpp -o $(BUILD_TEST_DIR)/Math.test
 	@-echo "================================================="
 	@-echo "Running hel unit test"
 
 Memory.test:
 	mkdir -p $(BUILD_TEST_DIR)
-	$(CC) -Wall -g -D__TEST__ -lstdc++ \
-	-DDEBUG_MEMEORY -DDEBUG_MEMEORY_ERROR \
-	src/memeory_test.cpp -o $(BUILD_TEST_DIR)/memory_test.test
+	$(CC) -Wall -g -lstdc++ -Iinclude \
+	-DDEBUG_MEMORY -DDEBUG_MEMORY_ERROR \
+	src/memory_test.cpp test/memory_test.cpp -o $(BUILD_TEST_DIR)/memory_test.test
 
 #################################################################
 

src/memeory_test.h → include/memory_test.h

 
 #include <cstddef>
 
-#ifndef __MTK_MONGOOSE_MEMEORY_TEST_H_
-#define __MTK_MONGOOSE_MEMEORY_TEST_H_
+#ifndef __MTK_MONGOOSE_MEMORY_TEST_H_
+#define __MTK_MONGOOSE_MEMORY_TEST_H_
 
-#ifdef DEBUG_MEMEORY
+#if defined(DEBUG_MEMORY) && !defined(UNIT_TEST_MEMORY)
 
 #define DEBUG_NEW new(__FILE__, __LINE__)
 void *operator new(size_t size, const char *file, int line);
 	void dump_memory_report();
 	/*------------------------------------------------------
 	 * Pre  :
-	 * Post : Dumps raw Tree holding memeory accounting
+	 * Post : Dumps raw Tree holding memory accounting
 	 *
 	 *-- History ------------------------------------------
 	 *
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
+#ifdef DEBUG_MEMORY
+
+    #define DWORD unsigned long
+    #define ZERO_ALLOC_SLOTS 3
+
+    typedef enum { RB_BLACK = 0, RB_RED = 1 } rbtree_color_t;
+
+    typedef struct rbtree_s {
+        void *data;
+        DWORD key;
+        rbtree_color_t color;
+        struct rbtree_s *left;
+        struct rbtree_s *right;
+        struct rbtree_s *parent;
+    } rbtree_t;
+
+    typedef struct meminfo_filename_s {
+        char *filename;
+        char filename_len;
+        DWORD size;
+        unsigned int alloc_zero;
+        unsigned short int alloc_zero_at_line[ZERO_ALLOC_SLOTS];
+        struct meminfo_filename_s *next;
+    } meminfo_filename_t;
+
+    extern rbtree_t *MEMORY_INFO;
+    extern meminfo_filename_t *MEMORY_FILENAME;
+    extern long MEMORY_USED;
+    extern long MEMORYA_USED;
+    extern long MEMORYC_USED;
+    extern long MAX_MEMORY_USED;
+    extern long MAX_MEMORYA_USED;
+    extern long MAX_MEMORYC_USED;
+
+    void tree_valid_report(rbtree_t *root);
+
+#endif
 
 #endif

src/mstl/List.h → include/mstl/List.h

 /* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
 /*================================================================
- * 
+ *
  * Project : Freyja
  * Author  : Mongoose
  * Website : http://www.westga.edu/~stu7440/
  * Comments: mtk Template list
  *
  *           UINT_MAX is an error condition, used in place of -1
- * 
- *           This file was generated using Mongoose's C++ 
+ *
+ *           This file was generated using Mongoose's C++
  *           template generator script.  <stu7440@westga.edu>
- * 
- *-- History ------------------------------------------------ 
+ *
+ *-- History ------------------------------------------------
  *
  * 2000-10-26:
  * Mongoose - Created
 #include <limits.h>
 #include <stdio.h>
 
-#ifdef DEBUG_MEMEORY
-#   include "memeory_test.h"
+#ifdef DEBUG_MEMORY
+#include <memory_test.h>
 #endif
 
- 
+
 template <class T> class ListNode
 {
  public:
 
       last = current;
       current = current->Next();
-    }    
+    }
 
     return 0;
   }
 
       last = current;
       current = current->Next();
-    }    
+    }
 
     return UINT_MAX;
   }
 
 	if (_current == current)
 	  _current = NULL;
-	
+
 	delete current;
 	_num_items--;
 
 
       last = current;
       current = current->Next();
-    }    
+    }
   }
 
   void Remove(T data)
 	{
 	  last->Next(current->Next());
 	}
-	
+
 	if (_current == current)
 	  _current = NULL;
 
 
       last = current;
       current = current->Next();
-    }    
+    }
   }
 
   bool Empty()
 
     printf(" [%i] {\n", _num_items);
 
-    
+
     while (current)
     {
       printf("#%i, ", current->Id());
       fflush(stdout);
     }
 
-    printf(" }\n");    
+    printf(" }\n");
   }
 
 
 
     printf("List %i {\n", _num_items);
 
-    
+
     while (current)
     {
       //current->Print();
   {
     if (!_current)
       return UINT_MAX;
-    
+
     return _current->Id();
   }
 
 	{
 	  node->Id(i);
 	  node->Next(current);
-	  
+
 	  if (current == _head)
 	    _head = node;
 	  else if (last)

src/mstl/Map.h → include/mstl/Map.h

 /* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
 /*================================================================
- * 
+ *
  * Project : Freyja
  * Author  : Mongoose
  * Website : http://www.westga.edu/~stu7440/
  * Object  : Map
  * License : No use w/o permission (C) 2000-2002 Mongoose
  * Comments: mtk Template list
- * 
- *           This file was generated using Mongoose's C++ 
+ *
+ *           This file was generated using Mongoose's C++
  *           template generator script.  <stu7440@westga.edu>
- * 
- *-- History ------------------------------------------------ 
+ *
+ *-- History ------------------------------------------------
  *
  * 2002.02.19:
  * Mongoose - Using RBTree and list overlay for faster access
  * Mongoose - Binary tree overlay started... at 0300  /_\ Zzzz
  *
  * 2002.02.01:
- * Mongoose - Dug out of cobwebs and fixed up 
+ * Mongoose - Dug out of cobwebs and fixed up
  *            Yes, I believe in code reuse!  =)
  *
  * 2000.10.26:
 
 #include <stdlib.h>
 #include <stdio.h>
-#include "Tree.h"
 
-#ifdef DEBUG_MEMEORY
-#   include "memeory_test.h"
+#include <mstl/Tree.h>
+
+#ifdef DEBUG_MEMORY
+#include <memory_test.h>
 #endif
 
 
 		_next = NULL;
 	}
 
-	
+
 	~MapNode()
 	{
 	}
-	
+
 
 	void Key(K key)
 	{
 		_key = key;
 	}
-	
+
 
 	K Key()
 	{
 		return _key;
 	}
-	
+
 
 	void Data(D data)
 	{
     _data = data;
 	}
-	
+
 
 	D Data()
 	{
 		return _data;
 	}
-	
+
 
 	MapNode<K, D> *Next()
 	{
 		return _next;
 	}
-	
+
 
 	void Next(MapNode<K, D> *next)
 	{
 		_next = next;
 	}
-	
+
 private:
 
 	MapNode<K, D> *_next;
 template <class K, class D> class Map
 {
 public:
-	
+
 	Map()
 	{
 		UnSetError();
 		_current = NULL;
 		_cache = NULL;
 	}
-	
-	
+
+
 	~Map()
 	{
 		Clear();
 	}
-	
+
 
 	void Clear()
 	{
 		UnSetError();
 		_num_items = 0;
 		_cache = NULL;
-		
+
 		while (_head)
 		{
 			_current = _head;
 	{
 		_error = true;
 	}
-	
+
 
 	void UnSetError()
 	{
 		_error = false;
 	}
-	
+
 
 	bool GetError()
 	{
 	{
 		MapNode<K, D> *current = NULL;
 		MapNode<K, D> *next = NULL;
-		
+
 
 		if (_head)
 		{
 				if (_error)
 					return false;
 			}
-			
+
 			if (current)
 			{
 				_cache = _current = current;
 	{
 		return FindDataByKey(key);
 	}
-	
+
 
 	K FindKeyByData(D data)
 	{
 		MapNode<K, D> *current = _head;
 		MapNode<K, D> *last = NULL;
-		
+
 
 		UnSetError();
-		
+
 		while (current)
 		{
 			// Found
 				_cache = current;
 				return current->Key();
 			}
-			
+
 			last = current;
 			current = current->Next();
 		}
 			{
 				current = _tree.SearchByKey(key, &_error);
 			}
-			
+
 			if (current)
 			{
 				_cache = _current = current;
 		return false;
 	}
 
-	
+
 	bool Add(K key, D data)
 	{
 		MapNode<K, D> *node;
-		
-		
+
+
 		UnSetError();
 		node = new MapNode<K, D>(key, data);
 		_num_items++;
 				if (current->Key() > node->Key())
 				{
 					node->Next(current);
-					
+
 					if (current == _head)
 					{
 						_head = node;
 				last = current;
 				current = current->Next();
 			}
-			
+
 			// Append
 			last->Next(node);
 		}
 			_head = node;
 		}
 
-		_tree.Insert(node->Key(), node);		
+		_tree.Insert(node->Key(), node);
 		return true;
 	}
 
 	{
 		MapNode<K, D> *current = _head;
 		MapNode<K, D> *last = NULL;
-		
+
 
 		UnSetError();
 
 				{
 					last->Next(current->Next());
 				}
-				
+
 				if (_current == current)
 				{
 					_current = NULL;
 				_tree.RemoveByKey(current->Key());
 				delete current;
 				_num_items--;
-				
+
 				return;
 			}
-			
+
 			last = current;
 			current = current->Next();
 		}
 	{
 		MapNode<K, D> *current = _head;
 		MapNode<K, D> *last = NULL;
-		
+
 
 		UnSetError();
 
 				{
 					last->Next(current->Next());
 				}
-				
+
 				if (_current == current)
 				{
 					_current = NULL;
 				_tree.RemoveByKey(current->Key());
 				delete current;
 				_num_items--;
-				
+
 				return;
 			}
-			
+
 			last = current;
 			current = current->Next();
 		}
 		}
 
 		printf(" [%i] {\n", _num_items);
-		
+
 		while (current)
 		{
 			printf("(");
 			(*print_data_func)(current->Data());
 			printf("), ");
 
-			current = current->Next();			
+			current = current->Next();
 			fflush(stdout);
 		}
-		
-		printf(" }\n");    
+
+		printf(" }\n");
 	}
 
 
 		{
 			_current = _current->Next();
 		}
-		
+
 		return (_current != NULL);
 	}
 
 	K CurrentKey()
 	{
 		UnSetError();
-		
+
 		if (!_current)
 		{
 			SetError();
 			return 0;
 		}
-		
+
 		return _current->Key();
 	}
 
 	D Current()
 	{
 		UnSetError();
-		
+
 		if (!_current)
 		{
 			SetError();
 			return 0;
 		}
-		
+
 		return _current->Data();
 	}
 
 private:
-	
+
 	unsigned int _num_items;
-	
+
 	bool _error;
-	
+
 	Tree<K, MapNode<K, D> *> _tree;
 
 	MapNode<K, D> *_head;
-	
+
 	MapNode<K, D> *_current;
 
 	MapNode<K, D> *_cache;

src/mstl/Tree.h → include/mstl/Tree.h

 #include <stdio.h>
 
 #ifdef USE_IOSTREAM
-#   include <iostream.h>
+#include <iostream.h>
 #endif
 
-#ifdef DEBUG_MEMEORY
-#   include "memeory_test.h"
+#ifdef DEBUG_MEMORY
+#include <memory_test.h>
 #endif
 
 

src/mstl/Vector.h → include/mstl/Vector.h

 #include <stdlib.h>
 #include <stdio.h>
 
-#ifdef DEBUG_MEMEORY
-#   include "memeory_test.h"
+#ifdef DEBUG_MEMORY
+#include <memory_test.h>
 #endif
 
 

src/Camera.cpp

 
 #include <stdio.h>
 #include <math.h>
-#include "hel/math.h"
-#include "Camera.h"
 
-#ifdef DEBUG_MEMEORY
-#   include "memeory_test.h"
+#include <hel/math.h>
+#include <Camera.h>
+
+#ifdef DEBUG_MEMORY
+#include <memory_test.h>
 #endif
 
 

src/Emitter.cpp

 #include <GL/gl.h>
 #include <GL/glu.h>
 #endif
-#include "Emitter.h"
 
-#ifdef DEBUG_MEMEORY
-#   include "memeory_test.h"
+#include <Emitter.h>
+
+#ifdef DEBUG_MEMORY
+#include <memory_test.h>
 #endif
 
 vec_t Emitter::mFrustum[6][4];

src/GLString.cpp

 #include <GL/gl.h>
 #endif
 
-#include "Texture.h"
+#include <Texture.h>
+#include <GLString.h>
 
-#include "GLString.h"
-
-#ifdef DEBUG_MEMEORY
-#include "memeory_test.h"
+#ifdef DEBUG_MEMORY
+#include <memory_test.h>
 #endif
 
 
 #endif
 
 #ifdef HAVE_MTK
-#   include "Texture.h"
-#   include "mtk_tga.h"
+#include <Texture.h>
+#include <mtk_tga.h>
 
 Texture gTexture;
 #else
-#   error "Requires MTK: Texture and mtk_tga"
+#error "Requires MTK: Texture and mtk_tga"
 #endif
 
 

src/Light.cpp

  * Mongoose - Created
  =================================================================*/
 
-#include "Light.h"
+#include <Light.h>
 
 
 Light::Light()

src/Network.cpp

 /* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
 /*================================================================
- * 
+ *
  * Project : UnRaider
  * Author  : Terry 'Mongoose' Hendrix II
  * Website : http://www.westga.edu/~stu7440/
  * Email   : stu7440@westga.edu
  * Object  : Network
  * License : No use w/o permission (C) 2002 Mongoose
- * Comments: 
+ * Comments:
  *
  *
- *           This file was generated using Mongoose's C++ 
+ *           This file was generated using Mongoose's C++
  *           template generator script.  <stu7440@westga.edu>
- * 
- *-- History ------------------------------------------------- 
+ *
+ *-- History -------------------------------------------------
  *
  * 2002.06.21:
  * Mongoose - Created
  =================================================================*/
 
-#include "Network.h"
+#include <Network.h>
 
 #include <unistd.h>
 #include <signal.h>
 
 Network *Network::Instance()
 {
-	if (mInstance == 0x0) 
+	if (mInstance == 0x0)
 	{
 		mInstance = new Network();
 	}
-	
+
 	return mInstance;
 }
 
 void killNetworkSingleton()
 {
 	printf("Shutting down Network...\n");
-	
+
 	// Requires public deconstructor
 	delete Network::Instance();
 }
 	srand(tv.tv_usec);
 
 	return ((unsigned int)(tv.tv_sec * getRandom(2.0, 3.3) -
-								  tv.tv_sec * getRandom(1.0, 2.0)) + 
+								  tv.tv_sec * getRandom(1.0, 2.0)) +
 			  (unsigned int)(tv.tv_usec * getRandom(2.0, 3.3) -
 								  tv.tv_usec * getRandom(1.0, 2.0)) +
 			  (unsigned int)getRandom(666.0, 5000.0));
 	struct sockaddr_in s_in, from;
 	char hostid[64];
 	network_frame_t f;
-	unsigned int i;	
+	unsigned int i;
 	unsigned int packetsRecieved = 0;
 
 
 			return -1;
 		}
 
-		printf("Server: gethostname returned '%s'\n", hostid); 
+		printf("Server: gethostname returned '%s'\n", hostid);
 		fflush(stdout);
 	}
 
 
 	cip = ntohl(s_in.sin_addr.s_addr);
 
-	printf("Server: Started on ( %i.%i.%i.%i:%i )\n", 
-			 cip >> 24, cip << 8 >> 24, 
+	printf("Server: Started on ( %i.%i.%i.%i:%i )\n",
+			 cip >> 24, cip << 8 >> 24,
 			 cip << 16 >> 24, cip << 24 >> 24, s_in.sin_port);
 
 	for (; !mKillClient;)
 
 		// 1. Wait for event
 		// 2. Get inbound frame
-		cc = recvfrom(socket_fd, &f, sizeof(network_frame_t), 0, 
+		cc = recvfrom(socket_fd, &f, sizeof(network_frame_t), 0,
 						  (struct sockaddr *)&from, &fsize);
 
 		if (cc < 0)
 					gClients[i].frameExpected = 0;
 					++gNumClients;
 
-					printf("Server: %u made connection, as client %i\n", 
+					printf("Server: %u made connection, as client %i\n",
 							 gClients[i].uid, i);
 					break;
 				}
 
 		if (mDebug)
 		{
-			printf("Server: Client (Famliy %d, Address %i.%i.%i.%i:%d)\n", 
-					 ntohs(from.sin_family), cip >> 24, cip << 8 >> 24, 
-					 cip << 16 >> 24, cip << 24 >> 24, 
+			printf("Server: Client (Famliy %d, Address %i.%i.%i.%i:%d)\n",
+					 ntohs(from.sin_family), cip >> 24, cip << 8 >> 24,
+					 cip << 16 >> 24, cip << 24 >> 24,
 					 ntohs(from.sin_port));
 
-			printf("Server: Datalink layer recieved: packet seq %i\n", 
+			printf("Server: Datalink layer recieved: packet seq %i\n",
 					 f.seq);
 		}
 
 			to_network_layer(f.data);
 			gClients[i].frameExpected = !gClients[i].frameExpected;
 		}
-		
+
 		fflush(stdout);
-		
+
 #ifdef UNIT_TEST_NETWORK
 		if ((rand() % 10 == 0))
 		{
 			continue;
 		}
 #endif
-		
+
 		// 4. Send ACK, w/ piggyback if requested
 		if (mPiggyBack)
 		{
 				printf("SERVER> Sending data by piggyback\n");
 			}
 
-			cc = sendto(socket_fd, &gPiggyBack, sizeof(gPiggyBack), 0, 
+			cc = sendto(socket_fd, &gPiggyBack, sizeof(gPiggyBack), 0,
 							(struct sockaddr *)&from, sizeof(from));
 		}
 		else
 			f.seq = 0;
 			f.uid = gUID;
 
-			cc = sendto(socket_fd, &f, sizeof(f), 0, 
+			cc = sendto(socket_fd, &f, sizeof(f), 0,
 							(struct sockaddr *)&from, sizeof(from));
 		}
-		
+
 		if (cc < 0)
 		{
 			perror("Server: send_udp:sendto");
 	fd_set  readfds;
 	unsigned int packetsSent = 0;
 	unsigned int seq = 0;
-	char timedOut = 1;  
+	char timedOut = 1;
 
 	if (!mRemoteHost || !mRemoteHost[0])
 	{
 		return;
 	}
 
-	memset((char*) &timeout, 0, sizeof(timeout)); 
-	timeout.tv_sec = 5; 
+	memset((char*) &timeout, 0, sizeof(timeout));
+	timeout.tv_sec = 5;
 
 	socket_fd = socket(AF_INET, SOCK_DGRAM, 0);
 
 		perror("Client: send_udp: socket");
 		exit(0);
 	}
-    
+
 	if ((hostptr = gethostbyname(mRemoteHost)) == NULL)
 	{
-		fprintf(stderr, "Client: send_udp: invalid host name, %s\n", 
+		fprintf(stderr, "Client: send_udp: invalid host name, %s\n",
 				  mRemoteHost);
 		exit(0);
 	}
 #endif
 
 
-	// init	
+	// init
 	f.data.send = 0;
 	f.seq = 0;
 
 				printf("Client: Sending packet %i\n", f.seq);
 			}
 
-			cc = sendto(socket_fd, &f, sizeof(f), 0, 
+			cc = sendto(socket_fd, &f, sizeof(f), 0,
 							(struct sockaddr *)&dest, sizeof(dest));
 
 			if (cc < 0)
 
 		// 4. Wait for +ack or resend
 		FD_ZERO(&readfds);
- 
+
 		// Setup socket to listen on here
 		FD_SET(socket_fd, &readfds);
 
 		// Set timeout in milliseconds
-		timeout.tv_usec = 850; 
+		timeout.tv_usec = 850;
 
 		cc = select(socket_fd + 1, &readfds, NULL, NULL, &timeout);
 
-		if ((cc < 0) && (errno != EINTR)) 
+		if ((cc < 0) && (errno != EINTR))
 		{
 			// there was an local error with select
 		}
 		f.header = 0;
 
 		fsize = sizeof(dest);
-		cc = recvfrom(socket_fd, &f, sizeof(f), 0, 
-						  (struct sockaddr *)&dest, &fsize); 
+		cc = recvfrom(socket_fd, &f, sizeof(f), 0,
+						  (struct sockaddr *)&dest, &fsize);
 
 		if (cc < 0)
 		{

src/OpenGLMesh.cpp

 #else
 #include <GL/gl.h>
 #endif
-#include "OpenGLMesh.h"
+
+#include <OpenGLMesh.h>
 
 
 ////////////////////////////////////////////////////////////

src/OpenRaider.cpp

 #include <math.h>
 #include <sys/types.h>
 
-#ifdef DEBUG_MEMEORY
-#include "memeory_test.h"
+#ifdef DEBUG_MEMORY
+#include <memory_test.h>
 #endif
 
-#include "World.h"
-#include "SkeletalModel.h"
-#include "TombRaider1.h" // tmp stop-gap
-#include "OpenRaider.h"
+#include <World.h>
+#include <SkeletalModel.h>
+#include <TombRaider1.h> // tmp stop-gap
+#include <OpenRaider.h>
 
 enum OpenRaiderText { textConsole = 2, textMenu = 3, textOutput = 4 };
 
 	//delete OpenRaider::Instance();
 #warning "Can't delete OpenRaider::Instance() without a not-allocated-free error. Something is fishy here..."
 
-#ifdef DEBUG_MEMEORY
-	printf("\n[Mongoose MEMEORY_DEBUG]\nMemory leak table:\n");
+#ifdef DEBUG_MEMORY
+	printf("\n[Mongoose MEMORY_DEBUG]\nMemory leak table:\n");
 	dump_memory_report();
 #endif
 
 	// Cache/process sound fx
 	processPakSounds();
 
-#ifdef DEBUG_MEMEORY
+#ifdef DEBUG_MEMORY
 	// Right before pak is cleared will be highest use or memory
 	display_memory_usage();
 #endif
 
 	print(true, "Level pak freed from memory, Starting game...");
 
-#ifdef DEBUG_MEMEORY
+#ifdef DEBUG_MEMORY
 	display_memory_usage();
 #endif
 
 	}
 	else if (rc_command("mem", cmd))
 	{
-#ifdef DEBUG_MEMEORY
+#ifdef DEBUG_MEMORY
 		if (rc_command("usage", cmd))
 		{
 			display_memory_usage();
 			dump_memory_report();
 		}
 #else
-		printf("This build isn't DEBUG_MEMEORY enabled\n");
+		printf("This build isn't DEBUG_MEMORY enabled\n");
 #endif
 	}
 	else if (rc_command("loadlevel", cmd))

src/Particle.cpp

 
 #include <stdlib.h>
 #include <stdio.h>
-#include "Particle.h"
 
-#ifdef DEBUG_MEMEORY
-#   include "memeory_test.h"
+#include <Particle.h>
+
+#ifdef DEBUG_MEMORY
+#include <memory_test.h>
 #endif
 
 

src/Render.cpp

 #include <string.h>
 
 #ifdef USING_EMITTER
-#include "Emitter.h"
+#include <Emitter.h>
 #endif
 
-#ifdef DEBUG_MEMEORY
-#include "memeory_test.h"
+#ifdef DEBUG_MEMORY
+#include <memory_test.h>
 #endif
 
-#ifdef DEBUG_GL
-#include "gl_test.cpp"
-#endif
-
-#include "Render.h"
+#include <Render.h>
 
 extern entity_t *LARA;
 extern World gWorld;

src/SDLSystem.cpp

 #include <string.h>
 #include <cmath>
 
-#ifdef MEMEORY_TEST
-#include "memeory_test.h"
+#ifdef MEMORY_TEST
+#include <memory_test.h>
 #endif
 
 #ifdef USING_OPENGL
 #error "SDLSystem requires -DUSING_OPENGL"
 #endif
 
-#ifdef PS2_LINUX
-#include "ps2.h"
-#endif
-
-#include "SDLSystem.h"
+#include <SDLSystem.h>
 
 
 unsigned int *gWidth = 0x0;
 	//SDL_QuitSubSystem(SDL_OPENGL);
 	//SDL_Quit(); // Moved to atexit() call
 
-	//#ifdef DEBUG_MEMEORY
-	//printf("[Mongoose MEMEORY_DEBUG]\nUnfreed memory table:\n");
+	//#ifdef DEBUG_MEMORY
+	//printf("[Mongoose MEMORY_DEBUG]\nUnfreed memory table:\n");
 	//dump_memory_report();
 	//#endif
 

src/SkeletalModel.cpp

  * Mongoose - Created
  =================================================================*/
 
-#include "SkeletalModel.h"
+#include <SkeletalModel.h>
 
 
 ////////////////////////////////////////////////////////////

src/Sound.cpp

 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
-#include "Sound.h"
 
-#ifdef DEBUG_MEMEORY
-#include "memeory_test.h"
+#include <Sound.h>
+
+#ifdef DEBUG_MEMORY
+#include <memory_test.h>
 #endif
 
 

src/System.cpp

 #include <sys/time.h>
 #endif
 
-#ifdef MEMEORY_TEST
-#include "memeory_test.h"
+#ifdef MEMORY_TEST
+#include <memory_test.h>
 #endif
 
-#ifdef PS2_LINUX
-#include "ps2linux.h"
-#endif
-
-#include "System.h"
+#include <System.h>
 
 ////////////////////////////////////////////////////////////
 // Constructors

src/Texture.cpp

 #include <stdio.h>
 #include <stdarg.h>
 
-#ifdef DEBUG_MEMEORY
-#   include "memeory_test.h"
+#ifdef DEBUG_MEMORY
+#include <memory_test.h>
 #endif
 
 #ifdef USING_MTK_TGA
-#   include "mtk_tga.h"
+#include <mtk_tga.h>
 #endif
 
 #ifdef USING_MTK_PNG
-#   include "mtk_png.h"
+#include <mtk_png.h>
 #endif
 
 #ifdef HAVE_SDL_TTF
-#   include <SDL/SDL_ttf.h>
+#include <SDL/SDL_ttf.h>
 #endif
 
 #ifdef __APPLE__
 #include <GL/glu.h>
 #endif
 
-#include "Texture.h"
+#include <Texture.h>
 
 //Texture *gTextureManager = 0x0;
 gl_font_t *gFontTest = 0x0;

src/TombRaider.cpp

 #include <math.h>
 #include <string.h>
 #include <stdarg.h>
-#include "TombRaider.h"
+
+#include <TombRaider.h>
 
 #ifdef ZLIB_SUPPORT
-#   include "zlib.h"
+#include <zlib.h>
 #else
 #warning "No zlib. Won't support TR4+ files!"
 #endif
 
 #ifdef __TEST_TR5_DUMP_TGA
-#   include "mtk_tga.h"
+#include <mtk_tga.h>
 #endif
 
-#ifdef DEBUG_MEMEORY
-#   include "memeory_test.h"
+#ifdef DEBUG_MEMORY
+#include <memory_test.h>
 #endif
 
 
 {
 	test_main(argc, argv);
 
-#ifdef DEBUG_MEMEORY
+#ifdef DEBUG_MEMORY
   dump_memory_report();
 #endif
 

src/World.cpp

  * Mongoose - Created
  =================================================================*/
 
-#ifdef DEBUG_MEMEORY
-#   include "memeory_test.h"
+#ifdef DEBUG_MEMORY
+#include <memory_test.h>
 #endif
 
 #include <math.h>
-#include "World.h"
+
+#include <World.h>
 
 
 ////////////////////////////////////////////////////////////

src/endian.cpp

 /*==========================================================================
- * 
- * Project : MDDC 
+ *
+ * Project : MDDC
  * Author  : Terry 'Mongoose' Hendrix II
  * Website : http://www.westga.edu/~stu7440
  * Email   : stu7440@westga.edu
- * Object  : 
+ * Object  :
  * Comments: This is the endian utils.
  *
  *           See file COPYING for license details.
  *
- *           Based on type converting code by: 
- *           Michael Vance <mkv102@psu.edu> 
- * 
- *-- History ---------------------------------------------------------- 
+ *           Based on type converting code by:
+ *           Michael Vance <mkv102@psu.edu>
+ *
+ *-- History ----------------------------------------------------------
  *
  * 2000-03-17:
- * Mongoose: Created, I combined some endian checking with fread wrapper 
+ * Mongoose: Created, I combined some endian checking with fread wrapper
  ==========================================================================*/
 
-#include "endian.h"
+#include <endian.h>
 
 
 int fread_u_int_small(unsigned int *ptr, FILE *stream)
-{  
+{
 #ifdef BIG_ENDIAN
    unsigned char b1, b2, b3, b4;
    unsigned int l;
 #endif
- 
+
    if (fread(ptr, 4, 1, stream) != 1)
    {
       printf("FreadSmallInt> Failed fread.\n");
    }
 
 #ifdef BIG_ENDIAN
-   l = *ptr; 
+   l = *ptr;
 
    b1 = l & 255;
    b2 = ( l >> 8 ) & 255;
 
 
 int fread_int_small(int *ptr, FILE *stream)
-{  
+{
 #ifdef BIG_ENDIAN
    unsigned char b1, b2, b3, b4;
    int l;
 #endif
- 
+
    if (fread(ptr, 4, 1, stream) != 1)
    {
       printf("FreadSmallInt> Failed fread.\n");
    }
 
 #ifdef BIG_ENDIAN
-   l = *ptr; 
+   l = *ptr;
 
    b1 = l & 255;
    b2 = ( l >> 8 ) & 255;
 }
 
 int fread_float_small(float *ptr, FILE *stream)
-{  
+{
 #ifdef BIG_ENDIAN
    union
    {
       unsigned char b[4];
-      float f; 
+      float f;
    } in, out;
-	
+
    float l;
 #endif
- 
+
    if (fread(ptr, 4, 1, stream) != 1)
    {
       printf("FreadSmallFloat> Failed fread.\n");
    }
 
 #ifdef BIG_ENDIAN
-   l = *ptr; 
+   l = *ptr;
 
    in.f = l;
    out.b[0] = in.b[3];
    out.b[1] = in.b[2];
    out.b[2] = in.b[1];
    out.b[3] = in.b[0];
-	
+
    *ptr = out.f;
 #endif
 

src/hel/Matrix.cpp

 
 #include <stdio.h>
 #include <math.h>
-#include "Matrix.h"
+
+#include <hel/Matrix.h>
 
 
 ////////////////////////////////////////////////////////////

src/hel/Quaternion.cpp

  =================================================================*/
 
 #include <math.h>
-#include "Quaternion.h"
+
+#include <hel/Quaternion.h>
 
 
 ////////////////////////////////////////////////////////////

src/hel/Vector3d.cpp

  =================================================================*/
 
 #include <math.h>
-#include "Vector3d.h"
+
+#include <hel/Vector3d.h>
 
 
 ////////////////////////////////////////////////////////////

src/hel/ViewVolume.cpp

 /* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
 /*================================================================
- * 
+ *
  * Project : hel
  * Author  : Terry 'Mongoose' Hendrix II
  * Website : http://www.westga.edu/~stu7440/
  *           Thanks Mark Morley for the article I used
  *           to get several algorithms.
  *
- *           This file was generated using Mongoose's C++ 
+ *           This file was generated using Mongoose's C++
  *           template generator script.  <stu7440@westga.edu>
- * 
- *-- History ------------------------------------------------- 
+ *
+ *-- History -------------------------------------------------
  *
  * 2002.12.15:
  * Mongoose - Created
  =================================================================*/
 
 #include <math.h>
-#include "ViewVolume.h"
+
+#include <hel/ViewVolume.h>
 
 
 ////////////////////////////////////////////////////////////
 
    for (p = 0; p < 6; ++p)
 	{
-      if (mFrustum[p][0] * x + mFrustum[p][1] * y + mFrustum[p][2] * z + 
+      if (mFrustum[p][0] * x + mFrustum[p][1] * y + mFrustum[p][2] * z +
 			 mFrustum[p][3] <= 0)
 		{
          return false;
 
    for (p = 0; p < 6; ++p)
    {
-      if (mFrustum[p][0] * min[0] + 
-			 mFrustum[p][1] * min[1] + 
+      if (mFrustum[p][0] * min[0] +
+			 mFrustum[p][1] * min[1] +
 			 mFrustum[p][2] * min[2] + mFrustum[p][3] > 0)
          continue;
 
-      if (mFrustum[p][0] * max[0] + 
-			 mFrustum[p][1] * max[1] + 
+      if (mFrustum[p][0] * max[0] +
+			 mFrustum[p][1] * max[1] +
 			 mFrustum[p][2] * max[2] + mFrustum[p][3] > 0)
          continue;
 
-      if (mFrustum[p][0] * min[0] + 
-			 mFrustum[p][1] * max[1] + 
+      if (mFrustum[p][0] * min[0] +
+			 mFrustum[p][1] * max[1] +
 			 mFrustum[p][2] * max[2] + mFrustum[p][3] > 0)
          continue;
 
-      if (mFrustum[p][0] * min[0] + 
-			 mFrustum[p][1] * min[1] + 
+      if (mFrustum[p][0] * min[0] +
+			 mFrustum[p][1] * min[1] +
 			 mFrustum[p][2] * max[2] + mFrustum[p][3] > 0)
          continue;
 
-      if (mFrustum[p][0] * min[0] + 
-			 mFrustum[p][1] * max[1] + 
+      if (mFrustum[p][0] * min[0] +
+			 mFrustum[p][1] * max[1] +
 			 mFrustum[p][2] * min[2] + mFrustum[p][3] > 0)
          continue;
 
-      if (mFrustum[p][0] * max[0] + 
-			 mFrustum[p][1] * min[1] + 
+      if (mFrustum[p][0] * max[0] +
+			 mFrustum[p][1] * min[1] +
 			 mFrustum[p][2] * min[2] + mFrustum[p][3] > 0)
          continue;
 
-      if (mFrustum[p][0] * max[0] + 
-			 mFrustum[p][1] * max[1] + 
+      if (mFrustum[p][0] * max[0] +
+			 mFrustum[p][1] * max[1] +
 			 mFrustum[p][2] * min[2] + mFrustum[p][3] > 0)
          continue;
 
-      if (mFrustum[p][0] * max[0] + 
-			 mFrustum[p][1] * min[1] + 
+      if (mFrustum[p][0] * max[0] +
+			 mFrustum[p][1] * min[1] +
 			 mFrustum[p][2] * max[2] + mFrustum[p][3] > 0)
          continue;
 
 }
 
 
-vec_t ViewVolume::getDistToSphereFromNear(vec_t x, vec_t y, vec_t z, 
+vec_t ViewVolume::getDistToSphereFromNear(vec_t x, vec_t y, vec_t z,
 														vec_t radius)
 {
    unsigned int p;
 	helMidpoint3v(min, max, center);
 
 	// 5 should be near plane
-	d = (mFrustum[5][0] * center[0] + 
-		  mFrustum[5][1] * center[1] + 
-		  mFrustum[5][2] * center[2] + 
+	d = (mFrustum[5][0] * center[0] +
+		  mFrustum[5][1] * center[1] +
+		  mFrustum[5][2] * center[2] +
 		  mFrustum[5][3]);
 
 	radius = helDist3v(max, center);
    mFrustum[0][3] = clip[15] - clip[12];
 
    /* Normalize the result */
-   t = sqrt(mFrustum[0][0] * mFrustum[0][0] + 
-				mFrustum[0][1] * mFrustum[0][1] + 
+   t = sqrt(mFrustum[0][0] * mFrustum[0][0] +
+				mFrustum[0][1] * mFrustum[0][1] +
 				mFrustum[0][2] * mFrustum[0][2]);
    mFrustum[0][0] /= t;
    mFrustum[0][1] /= t;
    mFrustum[1][3] = clip[15] + clip[12];
 
    /* Normalize the result */
-   t = sqrt(mFrustum[1][0] * mFrustum[1][0] + 
-				mFrustum[1][1] * mFrustum[1][1] + 
+   t = sqrt(mFrustum[1][0] * mFrustum[1][0] +
+				mFrustum[1][1] * mFrustum[1][1] +
 				mFrustum[1][2] * mFrustum[1][2]);
    mFrustum[1][0] /= t;
    mFrustum[1][1] /= t;
    mFrustum[2][3] = clip[15] + clip[13];
 
    /* Normalize the result */
-   t = sqrt(mFrustum[2][0] * mFrustum[2][0] + 
-				mFrustum[2][1] * mFrustum[2][1] + 
+   t = sqrt(mFrustum[2][0] * mFrustum[2][0] +
+				mFrustum[2][1] * mFrustum[2][1] +
 				mFrustum[2][2] * mFrustum[2][2]);
    mFrustum[2][0] /= t;
    mFrustum[2][1] /= t;
    mFrustum[3][3] = clip[15] - clip[13];
 
    /* Normalize the result */
-   t = sqrt(mFrustum[3][0] * mFrustum[3][0] + 
-				mFrustum[3][1] * mFrustum[3][1] + 
+   t = sqrt(mFrustum[3][0] * mFrustum[3][0] +
+				mFrustum[3][1] * mFrustum[3][1] +
 				mFrustum[3][2] * mFrustum[3][2]);
    mFrustum[3][0] /= t;
    mFrustum[3][1] /= t;
    mFrustum[4][3] = clip[15] - clip[14];
 
    /* Normalize the result */
-   t = sqrt(mFrustum[4][0] * mFrustum[4][0] + 
-				mFrustum[4][1] * mFrustum[4][1] + 
+   t = sqrt(mFrustum[4][0] * mFrustum[4][0] +
+				mFrustum[4][1] * mFrustum[4][1] +
 				mFrustum[4][2] * mFrustum[4][2]);
    mFrustum[4][0] /= t;
    mFrustum[4][1] /= t;
    mFrustum[5][3] = clip[15] + clip[14];
 
    /* Normalize the result */
-   t = sqrt(mFrustum[5][0] * mFrustum[5][0] + 
-				mFrustum[5][1] * mFrustum[5][1] + 
+   t = sqrt(mFrustum[5][0] * mFrustum[5][0] +
+				mFrustum[5][1] * mFrustum[5][1] +
 				mFrustum[5][2] * mFrustum[5][2]);
    mFrustum[5][0] /= t;
    mFrustum[5][1] /= t;

src/memeory_test.cpp → src/memory_test.cpp

  * Author  : Terry 'Mongoose' Hendrix II
  * Website : http://www.westga.edu/~stu7440/
  * Email   : stu7440@westga.edu
- * Object  : memeory_test
+ * Object  : memory_test
  * License : No use w/o permission (C) 2002 Mongoose
  * Comments: Memory testing tool kit
  *
 #include <stdio.h>
 #include <stdlib.h>
 
+#define UNIT_TEST_MEMORY
+#include <memory_test.h>
 
-#define DWORD unsigned long
 #define USE_ITERATIVE_TREE_INSERT
 
 
-typedef enum { RB_BLACK = 0, RB_RED = 1 } rbtree_color_t;
-
-typedef struct rbtree_s
-{
-	void *data;
-	DWORD key;
-
-	rbtree_color_t color;
-
-	struct rbtree_s *left;
-	struct rbtree_s *right;
-	struct rbtree_s *parent;
-
-} rbtree_t;
-
-
-
 bool tree_check(rbtree_t *tree, char *file, int line)
 {
 	bool ret = true;
 	{
 		(*print_func)(tree->data);
 
-#ifdef DEBUG_MEMEORY_RBTREE
+#ifdef DEBUG_MEMORY_RBTREE
 		printf(" :%s%s)",
 				 (!tree->parent) ? " (root, " : " ("),
 				 (tree->color == RB_BLACK) ? "black" : "red");
 }
 
 
-#ifdef DEBUG_MEMEORY
-
-#define ZERO_ALLOC_SLOTS 3
-
-typedef struct meminfo_filename_s
-{
-	char *filename;
-	char filename_len;
-	DWORD size;
-	unsigned int alloc_zero;
-	unsigned short int alloc_zero_at_line[ZERO_ALLOC_SLOTS];
-
-	struct meminfo_filename_s *next;
-
-} meminfo_filename_t;
+#ifdef DEBUG_MEMORY
 
 
 typedef struct meminfo_s
 ///////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////
 
-rbtree_t *MEMEORY_INFO = 0;
-meminfo_filename_t *MEMEORY_FILENAME = 0;
-long MEMEORY_USED  = 0L;
-long MEMEORYA_USED = 0L;
-long MEMEORYC_USED = 0L;
-long MAX_MEMEORY_USED = 0L;
-long MAX_MEMEORYA_USED = 0L;
-long MAX_MEMEORYC_USED = 0L;
+rbtree_t *MEMORY_INFO = 0;
+meminfo_filename_t *MEMORY_FILENAME = 0;
+long MEMORY_USED  = 0L;
+long MEMORYA_USED = 0L;
+long MEMORYC_USED = 0L;
+long MAX_MEMORY_USED = 0L;
+long MAX_MEMORYA_USED = 0L;
+long MAX_MEMORYC_USED = 0L;
 
 
 typedef enum
 	switch (query)
 	{
 	case MEMORY_USED_BY_PROGRAM:
-		return MEMEORY_USED;
+		return MEMORY_USED;
 		break;
 	case MAX_MEMORY_USED_BY_PROGRAM:
-		return MAX_MEMEORY_USED;
+		return MAX_MEMORY_USED;
 		break;
 	case MAX_MEMORY_USED_BY_OVERHEAD:
-		return MAX_MEMEORYA_USED + MAX_MEMEORYC_USED;
+		return MAX_MEMORYA_USED + MAX_MEMORYC_USED;
 		break;
 	case MEMORY_USED_BY_OVERHEAD:
-		return MEMEORYA_USED + MEMEORYC_USED;
+		return MEMORYA_USED + MEMORYC_USED;
 		break;
 	case MEMORY_USED_TOTAL:
-		return MEMEORY_USED + MEMEORYA_USED + MEMEORYC_USED;
+		return MEMORY_USED + MEMORYA_USED + MEMORYC_USED;
 		break;
 	default:
 		;
 void display_memory_usage()
 {
 	unsigned int i;
-	meminfo_filename_t *cur = MEMEORY_FILENAME;
+	meminfo_filename_t *cur = MEMORY_FILENAME;
 
 
 	printf("\n============================================================\n");
 	{
 		printf(" %s : ( %lu bytes, %3.2f%% )\n",
 				 cur->filename, cur->size,
-				 100.0 * ((float)cur->size / (float)MEMEORY_USED));
+				 100.0 * ((float)cur->size / (float)MEMORY_USED));
 
 		cur = cur->next;
 	}
 
 	printf("------------------------------------------------------------\n");
 
-	cur = MEMEORY_FILENAME;
+	cur = MEMORY_FILENAME;
 
 	printf("Memory special errors per file:\n");
 
 	printf("Memory usage summary:\n");
 
 	printf(" Tracked program memory    : %lu bytes \t(%.2f MB)\n",
-			 MEMEORY_USED, (double)MEMEORY_USED / 1024000.0);
+			 MEMORY_USED, (double)MEMORY_USED / 1024000.0);
 	printf(" Untracked overhead memory : %lu bytes \t(%.2f MB)\n",
-			 MEMEORYA_USED, (double)MEMEORYA_USED / 1024000.0);
+			 MEMORYA_USED, (double)MEMORYA_USED / 1024000.0);
 	printf(" Untracked m-string memory : %lu bytes\n",
-			 MEMEORYC_USED);
+			 MEMORYC_USED);
 
 	printf("\n Total accounted memory    : %lu bytes \t(%.2f MB)\n",
-			 MEMEORY_USED + MEMEORYA_USED + MEMEORYC_USED,
-			 (double)(MEMEORY_USED + MEMEORYA_USED + MEMEORYC_USED) / 1024000.0);
+			 MEMORY_USED + MEMORYA_USED + MEMORYC_USED,
+			 (double)(MEMORY_USED + MEMORYA_USED + MEMORYC_USED) / 1024000.0);
 
 	printf("------------------------------------------------------------\n");
 
 	printf("Memory max usage summary:\n");
 
 	printf(" Tracked program memory    : %lu bytes \t(%.2f MB)\n",
-			 MAX_MEMEORY_USED, (double)MAX_MEMEORY_USED / 1024000.0);
+			 MAX_MEMORY_USED, (double)MAX_MEMORY_USED / 1024000.0);
 	printf(" Untracked overhead memory : %lu bytes \t(%.2f MB)\n",
-			 MAX_MEMEORYA_USED, (double)MAX_MEMEORYA_USED / 1024000.0);
+			 MAX_MEMORYA_USED, (double)MAX_MEMORYA_USED / 1024000.0);
 	printf(" Untracked m-string memory : %lu bytes\n",
-			 MAX_MEMEORYC_USED);
+			 MAX_MEMORYC_USED);
 
 	printf("\n Total accounted memory    : %lu bytes \t(%.2f MB)\n",
-			 MAX_MEMEORY_USED + MAX_MEMEORYA_USED + MAX_MEMEORYC_USED,
-			 (double)(MAX_MEMEORY_USED + MAX_MEMEORYA_USED + MAX_MEMEORYC_USED) / 1024000.0);
+			 MAX_MEMORY_USED + MAX_MEMORYA_USED + MAX_MEMORYC_USED,
+			 (double)(MAX_MEMORY_USED + MAX_MEMORYA_USED + MAX_MEMORYC_USED) / 1024000.0);
 
 	printf("============================================================\n");
 }
 
 
 	printf("\n============================================================\n");
-	printf(" Memeory status report\n");
+	printf(" Memory status report\n");
 	printf("============================================================\n");
 	printf("Memory tracking table:\n");
-	i = tree_print(MEMEORY_INFO, (void (*)(void *))&__print_meminfo);
+	i = tree_print(MEMORY_INFO, (void (*)(void *))&__print_meminfo);
 	printf("%i records, %u bytes each : %i bytes\n",
 			 i, sizeof(meminfo_t), i * sizeof(meminfo_t));
 	display_memory_usage();
 	unsigned int len, i;
 
 
-	MEMEORY_USED += size;
+	MEMORY_USED += size;
 
-	if (MEMEORY_USED > MAX_MEMEORY_USED)
+	if (MEMORY_USED > MAX_MEMORY_USED)
 	{
-		MAX_MEMEORY_USED = MEMEORY_USED;
+		MAX_MEMORY_USED = MEMORY_USED;
 	}
 
-	MEMEORYA_USED += sizeof(meminfo_t);
+	MEMORYA_USED += sizeof(meminfo_t);
 
-	if (MEMEORYA_USED > MAX_MEMEORYA_USED)
+	if (MEMORYA_USED > MAX_MEMORYA_USED)
 	{
-		MAX_MEMEORYA_USED = MEMEORYA_USED;
+		MAX_MEMORYA_USED = MEMORYA_USED;
 	}
 
 	meminfo = (meminfo_t *)malloc(sizeof(meminfo_t));
 
 		memfile = memfile_prev = 0;
 
-		if (MEMEORY_FILENAME)
+		if (MEMORY_FILENAME)
 		{
-			memfile = MEMEORY_FILENAME;
+			memfile = MEMORY_FILENAME;
 
 			while (memfile)
 			{
 			memfile->alloc_zero_at_line[1] = 0;
 			memfile->alloc_zero_at_line[2] = 0;
 
-			MEMEORYC_USED += sizeof(meminfo_filename_t) + memfile->filename_len;
+			MEMORYC_USED += sizeof(meminfo_filename_t) + memfile->filename_len;
 
-			if (MEMEORYC_USED > MAX_MEMEORYC_USED)
-				MAX_MEMEORYC_USED = MEMEORYC_USED;
+			if (MEMORYC_USED > MAX_MEMORYC_USED)
+				MAX_MEMORYC_USED = MEMORYC_USED;
 
 			if (memfile_prev)
 			{
 				memfile_prev->next = memfile;
 			}
 
-			if (!MEMEORY_FILENAME)
+			if (!MEMORY_FILENAME)
 			{
-				MEMEORY_FILENAME = memfile;
+				MEMORY_FILENAME = memfile;
 			}
 		}
 
 		}
 	}
 
-	MEMEORYA_USED += sizeof(rbtree_t);
-	tree_insert(&MEMEORY_INFO, meminfo, meminfo->address);
+	MEMORYA_USED += sizeof(rbtree_t);
+	tree_insert(&MEMORY_INFO, meminfo, meminfo->address);
 
-#ifdef DEBUG_MEMEORY_VERBOSE
+#ifdef DEBUG_MEMORY_VERBOSE
 	printf("add_track> addr 0x%08lx, size %lu, filename %s, line %lu\n",
 			 addr, size, filename, line_num);
 #endif
 	rbtree_t *tree = 0;
 
 
-	tree = tree_find(MEMEORY_INFO, addr);
+	tree = tree_find(MEMORY_INFO, addr);
 
 	if (tree)
 	{
 
 		if (meminfo)
 		{
-			tree_remove(&MEMEORY_INFO, tree);
+			tree_remove(&MEMORY_INFO, tree);
 
 			if (meminfo->filename)
 			{
 						 meminfo->line);
 			}
 
-			MEMEORY_USED -= meminfo->size;
-			MEMEORYA_USED -= sizeof(meminfo_t);
-			MEMEORYA_USED -= sizeof(rbtree_t);
+			MEMORY_USED -= meminfo->size;
+			MEMORYA_USED -= sizeof(meminfo_t);
+			MEMORYA_USED -= sizeof(rbtree_t);
 
 			free(meminfo);
 		}
 	}
 	else
 	{
-#ifndef DEBUG_MEMEORY_ERROR_OFF
+#ifndef DEBUG_MEMORY_ERROR_OFF
 		printf("\nERROR: remove_track> Unknown addr 0x%08lx ", addr);
 		delete_check(0, 0, 1);
 		printf("?\n");
 #endif
 	}
 
-	if (!MEMEORY_INFO)
+	if (!MEMORY_INFO)
 	{
 		meminfo_filename_t *cur;
 		meminfo_filename_t *del;
 
 
-		cur = MEMEORY_FILENAME;
-		MEMEORY_FILENAME = 0;
+		cur = MEMORY_FILENAME;
+		MEMORY_FILENAME = 0;
 
 		while (cur)
 		{
 			del = cur;
 			cur = cur->next;
 
-			MEMEORYC_USED -= sizeof(meminfo_filename_t);
+			MEMORYC_USED -= sizeof(meminfo_filename_t);
 
 			if (del->filename)
 			{
-				MEMEORYC_USED -= del->filename_len;
+				MEMORYC_USED -= del->filename_len;
 				free(del->filename);
 			}
 
 		}
 	}
 
-#ifdef DEBUG_MEMEORY_VERBOSE
+#ifdef DEBUG_MEMORY_VERBOSE
 	printf("remove_track> addr 0x%lx\n", addr);
 #endif
 }
 };
 #endif
 
-
-
-////////////////////////////////////////////////////////////
-// Unit Test code
-////////////////////////////////////////////////////////////
-
-#ifdef __TEST__
-#include "memeory_test.h"
-
-#define PRINT_TEST_BREAK_LINE	printf("\n############################################################\n\n");
-
-int memeory_test_unit_test(int argc, char *argv[])
-{
-	int *i, *j, *k, *l, *m, *n, *o;
-
-
-	PRINT_TEST_BREAK_LINE
-	printf("Memeory test\n");
-	PRINT_TEST_BREAK_LINE
-
-	printf(">\ti = new int;  %s:%i\n", __FILE__, __LINE__);
-	i = new int;
-	dump_memory_report();
-	tree_valid_report(MEMEORY_INFO);
-
-	printf(">\tdelete i; (%p)  %s:%i\n", i, __FILE__, __LINE__);
-	delete i;
-	dump_memory_report();
-	tree_valid_report(MEMEORY_INFO);
-
-	PRINT_TEST_BREAK_LINE
-
-	printf(">\ti = new int[3]; (%p)  %s:%i\n", i, __FILE__, __LINE__);
-	i = new int[3];
-	dump_memory_report();
-	tree_valid_report(MEMEORY_INFO);
-
-	printf(">\tdelete [] i; (%p)  %s:%i\n", i, __FILE__, __LINE__);
-	delete [] i;
-	dump_memory_report();
-	tree_valid_report(MEMEORY_INFO);
-
-	PRINT_TEST_BREAK_LINE
-
-	printf(">\ti = new int[3]; (%p)  %s:%i\n", i, __FILE__, __LINE__);
-	i = new int[3];
-	printf(">\tj = new int; (%p)  %s:%i\n", j, __FILE__, __LINE__);
-	j = new int;
-	printf(">\tk = new int[3]; (%p)  %s:%i\n", k, __FILE__, __LINE__);
-	k = new int[3];
-	dump_memory_report();
-	tree_valid_report(MEMEORY_INFO);
-	printf(">\tdelete [] i; (%p)  %s:%i\n", i, __FILE__, __LINE__);
-	delete [] i;
-	printf(">\tdelete j; (%p)  %s:%i\n", j, __FILE__, __LINE__);
-	delete j;
-	printf(">\tdelete [] k; (%p)  %s:%i\n", k, __FILE__, __LINE__);
-	delete [] k;
-	dump_memory_report();
-	tree_valid_report(MEMEORY_INFO);
-
-	PRINT_TEST_BREAK_LINE
-
-	printf(">\ti = new int[3]; (%p)  %s:%i\n", i, __FILE__, __LINE__);
-	i = new int[3];
-	printf(">\tj = new int; (%p)  %s:%i\n", j, __FILE__, __LINE__);
-	j = new int;
-	printf(">\tk = new int[3]; (%p)  %s:%i\n", k, __FILE__, __LINE__);
-	k = new int[3];
-	dump_memory_report();
-	tree_valid_report(MEMEORY_INFO);
-	printf(">\tdelete j; (%p)  %s:%i\n", j, __FILE__, __LINE__);
-	delete j;
-	dump_memory_report();
-	tree_valid_report(MEMEORY_INFO);
-	printf(">\tj = new int[3]; (%p)  %s:%i\n", j, __FILE__, __LINE__);
-	j = new int[3];
-	dump_memory_report();
-	tree_valid_report(MEMEORY_INFO);
-	printf(">\tl = new int[3]; (%p)  %s:%i\n", l, __FILE__, __LINE__);
-	l = new int[3];
-	dump_memory_report();
-	tree_valid_report(MEMEORY_INFO);
-	printf(">\tm = new int[3]; (%p)  %s:%i\n", m, __FILE__, __LINE__);
-	m = new int[3];
-	dump_memory_report();
-	tree_valid_report(MEMEORY_INFO);
-
-	printf(">\tn = new int[3]; (%p)  %s:%i\n", n, __FILE__, __LINE__);
-	n = new int[3];
-	dump_memory_report();
-	tree_valid_report(MEMEORY_INFO);
-
-	printf(">\to = new int[3]; (%p)  %s:%i\n", o, __FILE__, __LINE__);
-	o = new int[3];
-	dump_memory_report();
-	tree_valid_report(MEMEORY_INFO);
-
-	printf(">\tdelete [] k; (%p)  %s:%i\n", k, __FILE__, __LINE__);
-	delete [] k;
-	dump_memory_report();
-	tree_valid_report(MEMEORY_INFO);
-
-	printf(">\tdelete [] j; (%p)  %s:%i\n", j, __FILE__, __LINE__);
-	delete [] j;
-	dump_memory_report();
-	tree_valid_report(MEMEORY_INFO);
-
-	printf(">\tdelete [] l; (%p)  %s:%i\n", l, __FILE__, __LINE__);
-	delete [] l;
-	dump_memory_report();
-	tree_valid_report(MEMEORY_INFO);
-
-	printf(">\tdelete [] m; (%p)  %s:%i\n", m, __FILE__, __LINE__);
-	delete [] m;
-	dump_memory_report();
-	tree_valid_report(MEMEORY_INFO);
-
-	printf(">\tdelete [] n; (%p)  %s:%i\n", n, __FILE__, __LINE__);
-	delete [] n;
-	dump_memory_report();
-	tree_valid_report(MEMEORY_INFO);
-
-	printf(">\tdelete [] o; (%p)  %s:%i\n", o, __FILE__, __LINE__);
-	delete [] o;
-	dump_memory_report();
-	tree_valid_report(MEMEORY_INFO);
-
-	printf(">\tdelete [] i; (%p)  %s:%i\n", i, __FILE__, __LINE__);
-	delete [] i;
-	dump_memory_report();
-	tree_valid_report(MEMEORY_INFO);
-
-	PRINT_TEST_BREAK_LINE
-
-	return 0;
-}
-
-
-int main(int argc, char *argv[])
-{
-	printf("[memeory_test test]\n");
-
-	return memeory_test_unit_test(argc, argv);
-}
-#endif

src/mtk_tga.cpp

 #include <string.h>
 #include <stdarg.h>
 
-#include "mtk_tga.h"
+#include <mtk_tga.h>
 
-#ifdef DEBUG_MEMEORY
-#   include "memeory_test.h"
+#ifdef DEBUG_MEMORY
+#include <memory_test.h>
 #endif
 
 

test/memory_test.cpp

+/* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
+/*================================================================
+ *
+ * Project : MTK
+ * Author  : Terry 'Mongoose' Hendrix II
+ * Website : http://www.westga.edu/~stu7440/
+ * Email   : stu7440@westga.edu
+ * Object  : memory_test
+ * License : No use w/o permission (C) 2002 Mongoose
+ * Comments: Memory testing tool kit
+ *
+ *
+ *           This file was generated using Mongoose's C++
+ *           template generator script.  <stu7440@westga.edu>
+ *
+ *-- History -------------------------------------------------
+ *
+ * 2002.03.27:
+ * Mongoose - Created
+ =================================================================*/
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <memory_test.h>
+
+#define PRINT_TEST_BREAK_LINE	printf("\n############################################################\n\n");
+
+int memory_test_unit_test(int argc, char *argv[])
+{
+	int *i, *j, *k, *l, *m, *n, *o;
+
+
+	PRINT_TEST_BREAK_LINE
+	printf("Memory test\n");
+	PRINT_TEST_BREAK_LINE
+
+	printf(">\ti = new int;  %s:%i\n", __FILE__, __LINE__);
+	i = new int;
+	dump_memory_report();
+	tree_valid_report(MEMORY_INFO);
+
+	printf(">\tdelete i; (%p)  %s:%i\n", i, __FILE__, __LINE__);
+	delete i;
+	dump_memory_report();
+	tree_valid_report(MEMORY_INFO);
+
+	PRINT_TEST_BREAK_LINE
+
+	printf(">\ti = new int[3]; (%p)  %s:%i\n", i, __FILE__, __LINE__);
+	i = new int[3];
+	dump_memory_report();
+	tree_valid_report(MEMORY_INFO);
+
+	printf(">\tdelete [] i; (%p)  %s:%i\n", i, __FILE__, __LINE__);
+	delete [] i;
+	dump_memory_report();
+	tree_valid_report(MEMORY_INFO);
+
+	PRINT_TEST_BREAK_LINE
+
+	printf(">\ti = new int[3]; (%p)  %s:%i\n", i, __FILE__, __LINE__);
+	i = new int[3];
+	printf(">\tj = new int; (%p)  %s:%i\n", j, __FILE__, __LINE__);
+	j = new int;
+	printf(">\tk = new int[3]; (%p)  %s:%i\n", k, __FILE__, __LINE__);
+	k = new int[3];
+	dump_memory_report();
+	tree_valid_report(MEMORY_INFO);
+	printf(">\tdelete [] i; (%p)  %s:%i\n", i, __FILE__, __LINE__);
+	delete [] i;
+	printf(">\tdelete j; (%p)  %s:%i\n", j, __FILE__, __LINE__);
+	delete j;
+	printf(">\tdelete [] k; (%p)  %s:%i\n", k, __FILE__, __LINE__);
+	delete [] k;
+	dump_memory_report();
+	tree_valid_report(MEMORY_INFO);
+
+	PRINT_TEST_BREAK_LINE
+
+	printf(">\ti = new int[3]; (%p)  %s:%i\n", i, __FILE__, __LINE__);
+	i = new int[3];
+	printf(">\tj = new int; (%p)  %s:%i\n", j, __FILE__, __LINE__);
+	j = new int;
+	printf(">\tk = new int[3]; (%p)  %s:%i\n", k, __FILE__, __LINE__);
+	k = new int[3];
+	dump_memory_report();
+	tree_valid_report(MEMORY_INFO);
+	printf(">\tdelete j; (%p)  %s:%i\n", j, __FILE__, __LINE__);
+	delete j;
+	dump_memory_report();
+	tree_valid_report(MEMORY_INFO);
+	printf(">\tj = new int[3]; (%p)  %s:%i\n", j, __FILE__, __LINE__);
+	j = new int[3];
+	dump_memory_report();
+	tree_valid_report(MEMORY_INFO);
+	printf(">\tl = new int[3]; (%p)  %s:%i\n", l, __FILE__, __LINE__);
+	l = new int[3];
+	dump_memory_report();
+	tree_valid_report(MEMORY_INFO);
+	printf(">\tm = new int[3]; (%p)  %s:%i\n", m, __FILE__, __LINE__);
+	m = new int[3];
+	dump_memory_report();
+	tree_valid_report(MEMORY_INFO);
+
+	printf(">\tn = new int[3]; (%p)  %s:%i\n", n, __FILE__, __LINE__);
+	n = new int[3];
+	dump_memory_report();
+	tree_valid_report(MEMORY_INFO);
+
+	printf(">\to = new int[3]; (%p)  %s:%i\n", o, __FILE__, __LINE__);
+	o = new int[3];
+	dump_memory_report();
+	tree_valid_report(MEMORY_INFO);
+
+	printf(">\tdelete [] k; (%p)  %s:%i\n", k, __FILE__, __LINE__);
+	delete [] k;
+	dump_memory_report();
+	tree_valid_report(MEMORY_INFO);
+
+	printf(">\tdelete [] j; (%p)  %s:%i\n", j, __FILE__, __LINE__);
+	delete [] j;
+	dump_memory_report();
+	tree_valid_report(MEMORY_INFO);
+
+	printf(">\tdelete [] l; (%p)  %s:%i\n", l, __FILE__, __LINE__);
+	delete [] l;
+	dump_memory_report();
+	tree_valid_report(MEMORY_INFO);
+
+	printf(">\tdelete [] m; (%p)  %s:%i\n", m, __FILE__, __LINE__);
+	delete [] m;
+	dump_memory_report();
+	tree_valid_report(MEMORY_INFO);
+
+	printf(">\tdelete [] n; (%p)  %s:%i\n", n, __FILE__, __LINE__);
+	delete [] n;
+	dump_memory_report();
+	tree_valid_report(MEMORY_INFO);
+
+	printf(">\tdelete [] o; (%p)  %s:%i\n", o, __FILE__, __LINE__);
+	delete [] o;
+	dump_memory_report();
+	tree_valid_report(MEMORY_INFO);
+
+	printf(">\tdelete [] i; (%p)  %s:%i\n", i, __FILE__, __LINE__);
+	delete [] i;
+	dump_memory_report();
+	tree_valid_report(MEMORY_INFO);
+
+	PRINT_TEST_BREAK_LINE
+
+	return 0;
+}
+
+
+int main(int argc, char *argv[])
+{
+	printf("[memory_test test]\n");
+
+	return memory_test_unit_test(argc, argv);
+}
+