Import Aliens vs Predator - Gold (Build 116)

Source code release, imported from:
https://www.gamefront.com/games/aliens-vs-predator-3/file/avp-gold-complete-source-code

All text files were converted to Unix format.

1 files changed, 183 insertions, 0 deletions

diff --git a/3dc/include/mem3dc.h b/3dc/include/mem3dc.h
new file mode 100644
index 0000000..958960d
--- /dev/null
+++ b/3dc/include/mem3dc.h
@@ -0,0 +1,183 @@
+/* mem3dc.h */
+#ifndef MEM3DC_H_INCLUDED
+#define MEM3DC_H_INCLUDED
+
+#ifdef __cplusplus
+
+	extern "C" {
+
+#endif
+
+#include "system.h"
+#include <stddef.h>
+
+/* defines */
+#if Saturn
+#define DBGMALLOC 1
+#endif
+
+#if SupportWindows95
+#if 1
+#define DBGMALLOC 0
+#else
+	#ifdef _DEBUG /* standard compiler command line debugging-ON switch */
+		#define DBGMALLOC 1
+	#elif defined(NDEBUG) /* standard compiler command line debugging-OFF switch */
+		#define DBGMALLOC 0
+	#elif defined(_DBGMALLOC) /* alternate compiler command line switch */
+		#define DBGMALLOC _DBGMALLOC
+	#else /* default switch */
+		#define DBGMALLOC 1
+	#endif
+#endif
+#endif
+
+#if PSX
+#define DBGMALLOC 0
+#endif
+
+/* parameters for DumpMallocInfo */
+#define PARTIALDUMP 0    /* print outstanding mallocs number and total memory allocated */
+#define DUMPTOSCREEN  1  /* print all outstanding mallocs to screen */
+#define DUMPTOFILE 2     /* write outstanding malloc details to file (filename defined with MALLOCDUMPFILE) */
+#define CPPGLOBAL 0x100000 /* line numbers offset by this value if the malloc is as part of a constructor for a C++ global whose dealloc may not be recorded */
+
+/* JH - 30.5.97
+I noticed that the MALLOC_RECORD structure has char[40]
+for the filename. Since I know that on the PC, the __FILE__
+macro results in a string compiled into the executable, and
+evaulates to a pointer to that string, we do not need to make
+a separate copy of the string for each malloc - just store the
+pointer.
+So, on PC this reduces the data size for the malloc records from 1.04Mb to 320K ! */
+
+#if SupportWindows95 || PSX
+#define COPY_FILENAME 0 /* new behavior */
+#else
+#define COPY_FILENAME 1 /* previous behavior */
+#endif
+
+/* platform specific memory allocation and deallocation declarations */
+extern void *AllocMem(size_t __size);
+extern void DeallocMem(void *__ptr);
+
+/* mem.c public functions */
+#if COPY_FILENAME
+extern void record_free(void *ptr, char string[], unsigned long lineno);
+extern void *record_malloc(long size, char string[], unsigned long lineno);
+#else /* new prototypes to take just pointers - dunno if it's really necessary */
+extern void record_free(void *ptr, char const * string, unsigned long lineno);
+extern void *record_malloc(long size, char const * string, unsigned long lineno);
+#endif
+extern void DumpMallocInfo(int type);
+extern void DumpBoundsCheckInfo(int type);
+extern void DumpInfo(int type);
+
+#if DBGMALLOC
+#define AllocateMem(x) record_malloc(x,__FILE__, __LINE__) 
+#define DeallocateMem(x) record_free(x,__FILE__, __LINE__)
+
+#ifdef __cplusplus
+
+/* JH 30/5/97 - 2/6/97
+Overloaded new and delete to use record_malloc and record_free
+Notes:
+1.
+Although these are declared as inline, C++ files which do not include this
+header will still use the overloaded operators new and delete (as long as at
+least one C++ file includes this header), although the lack of the macro for
+new will mean that you will not have file and line number information in the
+malloc record.
+2.
+Since it is not possible to have a user defined delete operator which takes
+extra parameters, the malloc record will not be able to track the file and
+line number of delete operations. For this reason, it is also necessary to
+overload the default operator new, so that corresponding delete operations
+(which will go through the record_free function) cause the memory to be
+deallocated in the same way.
+3.
+Global C++ objects may have constructors which call new and delete.
+Since their deconstructors will only be called after the function 'main' or
+'WinMain' has returned and after all functions specified with calls to atexit
+have returned, it is not possible to gruarantee a dump of the malloc info
+after they have been destroyed. I have introduced a global C++ object with a
+constructor and decostructor, which turn malloc recording on and off
+respectively. This will help prevent misreported memory leaks, because global
+objects contructed before this special object will be destroyed after it,
+hence any associated memory allocation and deallocation will not be recorded
+in the same way. A malloc dump called from the destructor of this special
+object will not misreport memory leaks for some global objects (those which
+happen to be constructed after the special object and deconstructed before
+it), though it will report the outstanding allocations as being from the
+constructor of a global C++ object. This is a intended as a warning - these
+outstanding allocations are probably not leaks, since they will be
+deconstructed fully before the program terminates.
+*/
+
+extern "C++" {
+
+extern int __cpp_new_recording;
+
+inline void * operator new(size_t s, char const * file, unsigned long line)
+{
+	return
+		__cpp_new_recording
+			? record_malloc(s,file,line)
+			: record_malloc(s,file,line+CPPGLOBAL)
+		;
+}
+inline void * operator new(size_t s)
+{
+	return
+		__cpp_new_recording
+			? record_malloc(s,"Unknown file (C++ new)",0)
+			: record_malloc(s,"Unknown file (C++ new)",CPPGLOBAL)
+		;
+}
+inline void operator delete(void * p)
+{
+	record_free(p,"Unknown file (C++ delete)",0);
+}
+#ifndef _MSC_VER
+inline void * operator new[](size_t s, char const * file, unsigned long line)
+{
+	return
+		__cpp_new_recording
+			? record_malloc(s,file,line)
+			: record_malloc(s,file,line+CPPGLOBAL)
+		;
+}
+inline void * operator new[](size_t s)
+{
+	return
+		__cpp_new_recording
+			? record_malloc(s,"Unknown file (C++ new[])",0)
+			: record_malloc(s,"Unknown file (C++ new[])",CPPGLOBAL)
+		;
+}
+inline void operator delete[](void * p)
+{
+	record_free(p,"Unknown file (C++ delete[])",0);
+}
+#endif
+
+#define new new(__FILE__,__LINE__)
+
+}
+
+#endif
+
+#else
+#define AllocateMem(x) AllocMem(x) 
+#define DeallocateMem(x) DeallocMem(x) 
+#endif
+
+
+#ifdef __cplusplus
+
+	};
+
+#endif
+
+
+#endif