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.
This commit is contained in:
Rebellion Developments
Patryk Obara
commit
218ca90543
572 changed files with 434587 additions and 0 deletions
824
3dc/mem3dc.c
Normal file
824
3dc/mem3dc.c
Normal file
|
|
@ -0,0 +1,824 @@
|
|||
|
||||
/*******************************************************************
|
||||
*
|
||||
* DESCRIPTION: mem3dc.c
|
||||
*
|
||||
* AUTHOR: Rob Rodger
|
||||
*
|
||||
* HISTORY: 23/12/96
|
||||
*
|
||||
*******************************************************************/
|
||||
|
||||
|
||||
/* mem3dc.c simply keeps a record of all memory allocations called by */
|
||||
/* AllocateMem() and checks if DeallocateMem() calls are legitimate */
|
||||
/* i.e. the address freed has been allocated. This record */
|
||||
/* includes the address, size, filename and line number for the associated */
|
||||
/* AllocateMem() call. */
|
||||
/* */
|
||||
/* Also, fills in MALLOC_FILL_VALUE in memory malloced and FREE_FILL_VALUE */
|
||||
/* in memory freed. */
|
||||
/* */
|
||||
/* A record is kept of the total amount of allocated memory outstanding in */
|
||||
/* global TotalMemAllocated as well as the total number of outstanding mallocs */
|
||||
/* in the global TotalMallocNum. Finally, a call to DumpMallocInfo(DUMPTOSCREEN) */
|
||||
/* will give a textprint of each outstanding malloc record while */
|
||||
/* while DumpMallocInfo(DUMPTOFILE) writes malloc records to a file with */
|
||||
/* filename defined by MALLOCDUMPFILE define. Set APPEND_TO_DUMPFILE to 1 */
|
||||
/* in define below if you wish to append malloc info to MALLOCDUMPFILE rather */
|
||||
/* than over writing file each time. */
|
||||
/* */
|
||||
/* To use, define DBGMALLOC as 1 in "mem3dc.h". Obviously for final code */
|
||||
/* set DBGMALLOC to 0. */
|
||||
/* */
|
||||
/* Note, must use AllocateMem() and DeallocateMem() in code - Do not */
|
||||
/* make direct calls to AllocMem()/DeallocMem() contained in platform */
|
||||
/* file our_mem.c */
|
||||
|
||||
#include "3dc.h"
|
||||
|
||||
#include <string.h>
|
||||
#include "mem3dc.h" /* contains extern declarations for platform
|
||||
specific memory allocation/deallocation.
|
||||
Also contains DBGMALLOC define */
|
||||
|
||||
#if DBGMALLOC
|
||||
|
||||
#include "ourasert.h"
|
||||
|
||||
#if PSX || Saturn
|
||||
#define MAXMALLOCS 600
|
||||
#else
|
||||
#define MAXMALLOCS 2500000
|
||||
/* assertion fires if max exceeded */
|
||||
/* changed to 1000000 by DHM 7/4/98; was 70001 */
|
||||
#endif
|
||||
|
||||
#define MALLOC_FILL_VALUE 0x21
|
||||
#define FREE_FILL_VALUE 0x89
|
||||
#define MALLOCDUMPFILE "dbgdump.txt"
|
||||
#define APPEND_TO_DUMPFILE 0 /* define as 0 if overwrite dbgdump.txt rather than append */
|
||||
#define FREEING_MEMORY -1
|
||||
|
||||
#define AllowedToDeleteNULL Yes
|
||||
/*
|
||||
Option added 7/4/98 by DHM:
|
||||
---------------------------
|
||||
This option checks for NULL in record_free() and doesn't update the records.
|
||||
|
||||
According to 2nd and 3rd edition Stroustrup, it's legal to "delete NULL", and it
|
||||
has no effect (see e.g. 3rd Edition Stroustrup, p128 paragraph 2).
|
||||
According to Appendix B of K&R, free NULL has no effect.
|
||||
*/
|
||||
|
||||
#if APPEND_TO_DUMPFILE
|
||||
#define FILEPERM "a"
|
||||
#else
|
||||
#define FILEPERM "w"
|
||||
#endif
|
||||
|
||||
#if SupportWindows95 && !defined(_MSC_VER) /* not required for MS C since MS C has CRT debugging available */
|
||||
#define OVERRUN_SIZEMIN 2
|
||||
#define OVERRUN_SIZEMAX 128
|
||||
#define OVERRUN_SIZEFACTOR 2 /* this is a shift down */
|
||||
|
||||
#define OVERRUN_SIZE(sz) ((sz)>OVERRUN_SIZEMAX<<OVERRUN_SIZEFACTOR ? OVERRUN_SIZEMAX : (sz)<OVERRUN_SIZEMIN<<OVERRUN_SIZEFACTOR ? OVERRUN_SIZEMIN : (sz)>>OVERRUN_SIZEFACTOR)
|
||||
/* I just selected these at random - the 0 term is necessary for wrap around */
|
||||
static unsigned char const overrun_code [] = { 0xef, 0x94, 0x56, 0x27, 0xf6, 0x76, 0x23, 0x43, 0 };
|
||||
|
||||
#else
|
||||
#undef OVERRUN_SIZE
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
typedef struct{
|
||||
unsigned long addr;
|
||||
unsigned long size;
|
||||
#if COPY_FILENAME
|
||||
char filename[40];
|
||||
#else
|
||||
char const * filename; /* JH 30/5/97 - since __FILE__ generates a string in the executable, to which we get passed a pointer, we don't need to make another copy unnecessarily wasting 720K of space on PC !! */
|
||||
#endif
|
||||
unsigned long linenum;
|
||||
}MALLOC_RECORD;
|
||||
|
||||
/* globals */
|
||||
MALLOC_RECORD MallocRecord[MAXMALLOCS];
|
||||
unsigned long TotalMemAllocated = 0;
|
||||
unsigned long TotalMallocNum = 0;
|
||||
|
||||
/* extern function declarations */
|
||||
extern int textprint(const char* string, ...);
|
||||
extern void ExitSystem(void);
|
||||
extern void WaitForReturn(void);
|
||||
|
||||
/* textprint on psx impacts frame rate massively if not
|
||||
used just for error messages, so it is often turned off.
|
||||
Hence the use of textprint2 below */
|
||||
|
||||
#if PSX
|
||||
#define textprint2 printf
|
||||
#else
|
||||
#define textprint2 textprint
|
||||
#endif
|
||||
|
||||
/* function declarations */
|
||||
#if COPY_FILENAME
|
||||
void record_free(void *ptr, char string[], unsigned long lineno);
|
||||
void *record_malloc(long size, char string[], unsigned long lineno);
|
||||
static int AdjustMallocRecord(unsigned long addr, long size, char string[], unsigned long lineno);
|
||||
#else /* new prototypes to take just pointers - dunno if it's really necessary */
|
||||
void record_free(void *ptr, char const * string, unsigned long lineno);
|
||||
void *record_malloc(long size, char const * string, unsigned long lineno);
|
||||
static int AdjustMallocRecord(unsigned long addr, long size, char const * string, unsigned long lineno);
|
||||
#endif
|
||||
void DumpMallocInfo(int type);
|
||||
static void InitMallocRecords(void);
|
||||
|
||||
/* function definitions */
|
||||
|
||||
#if COPY_FILENAME
|
||||
void *record_malloc(long size, char string[], unsigned long lineno)
|
||||
#else
|
||||
void *record_malloc(long size, char const * string, unsigned long lineno)
|
||||
#endif
|
||||
{
|
||||
#ifdef OVERRUN_SIZE
|
||||
void *ptr = (void *)AllocMem((size_t) size + OVERRUN_SIZE(size));
|
||||
#else
|
||||
void *ptr = (void *)AllocMem((size_t) size);
|
||||
#endif
|
||||
if(ptr==NULL)
|
||||
{
|
||||
textprint2("\nMalloc Error! %d bytes attempted\n", size);
|
||||
return((void *)NULL);
|
||||
}
|
||||
|
||||
GLOBALASSERT(size>0); /* should be redundant cos picked up by above malloc attempt */
|
||||
|
||||
AdjustMallocRecord((long)ptr,size, string, lineno);
|
||||
|
||||
return(ptr);
|
||||
}
|
||||
|
||||
#if COPY_FILENAME
|
||||
void record_free(void *ptr, char string[], unsigned long lineno)
|
||||
#else
|
||||
void record_free(void *ptr, char const * string, unsigned long lineno)
|
||||
#endif
|
||||
{
|
||||
if(AdjustMallocRecord((long)ptr,FREEING_MEMORY, string, lineno))
|
||||
DeallocMem((void *)ptr); /* free previously malloced ptr */
|
||||
return;
|
||||
}
|
||||
|
||||
#if PSX || Saturn
|
||||
|
||||
#if COPY_FILENAME
|
||||
static int AdjustMallocRecord(unsigned long addr, long size, char string[], unsigned long lineno)
|
||||
#else
|
||||
static int AdjustMallocRecord(unsigned long addr, long size, char const * string, unsigned long lineno)
|
||||
#endif
|
||||
|
||||
{
|
||||
|
||||
int i=0;
|
||||
char *ptr = (char *)addr;
|
||||
static int no_record_init = 1;
|
||||
MALLOC_RECORD *recordPtr = MallocRecord;
|
||||
|
||||
if(no_record_init)
|
||||
{
|
||||
InitMallocRecords();
|
||||
no_record_init = 0;
|
||||
}
|
||||
|
||||
|
||||
if(size==FREEING_MEMORY) /* must be freeing memory */
|
||||
{
|
||||
GLOBALASSERT(addr); /* ensure not null addr */
|
||||
|
||||
while(i<MAXMALLOCS)
|
||||
{
|
||||
if(recordPtr->addr==addr)
|
||||
{
|
||||
TotalMallocNum--;
|
||||
|
||||
size = recordPtr->size;
|
||||
|
||||
while (size--)
|
||||
{
|
||||
*ptr++ = FREE_FILL_VALUE;
|
||||
}
|
||||
#ifdef OVERRUN_SIZE
|
||||
{
|
||||
char const * overrun_ptr = overrun_code;
|
||||
int ov_cnt = OVERRUN_SIZE(recordPtr->size);
|
||||
do /* a memcmp - dunno if its supported on all platforms */
|
||||
{
|
||||
if (!*overrun_ptr) overrun_ptr = overrun_code; /* repeat */
|
||||
if (*overrun_ptr++ != *ptr++)
|
||||
{
|
||||
textprint2("\nOut of Bounds!\n%lu bytes allocated to %p\nat %s, line %lu\n", recordPtr->size,(void *)recordPtr->addr,recordPtr->filename,recordPtr->linenum);
|
||||
GLOBALASSERT(!"OUT OF BOUNDS detected in FREE");
|
||||
}
|
||||
}
|
||||
while (--ov_cnt);
|
||||
}
|
||||
#endif
|
||||
|
||||
recordPtr->addr = 0;
|
||||
TotalMemAllocated -= recordPtr->size;
|
||||
recordPtr->size = 0;
|
||||
#if COPY_FILENAME
|
||||
recordPtr->filename[0] = 0;
|
||||
#else
|
||||
recordPtr->filename = "";
|
||||
#endif
|
||||
recordPtr->linenum = 0;
|
||||
break; /* exit while loop */
|
||||
}
|
||||
i++;
|
||||
recordPtr++;
|
||||
}
|
||||
|
||||
if(i>=MAXMALLOCS)
|
||||
{
|
||||
textprint2("\n\n\n\nFree Error! %s, line %d\n", string, (int)lineno);
|
||||
GLOBALASSERT(0);
|
||||
return(0);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
else /* must be mallocing memory */
|
||||
{
|
||||
TotalMallocNum++;
|
||||
GLOBALASSERT(TotalMallocNum<MAXMALLOCS); /* just increase MAXMALLOCS define above if this fires */
|
||||
|
||||
|
||||
// RWH chack to see that this address isn't already in use
|
||||
i = 0;
|
||||
recordPtr = MallocRecord;
|
||||
while(i<MAXMALLOCS)
|
||||
{
|
||||
if(recordPtr->addr == addr)
|
||||
{
|
||||
GLOBALASSERT(0);
|
||||
}
|
||||
i++;
|
||||
recordPtr++;
|
||||
}
|
||||
i = 0;
|
||||
recordPtr = MallocRecord;
|
||||
while(i<MAXMALLOCS)
|
||||
{
|
||||
if(recordPtr->addr==0)
|
||||
{
|
||||
recordPtr->addr = addr;
|
||||
recordPtr->size = size;
|
||||
TotalMemAllocated += size;
|
||||
#if COPY_FILENAME
|
||||
strcpy(recordPtr->filename, string);
|
||||
#else
|
||||
recordPtr->filename = string;
|
||||
#endif
|
||||
recordPtr->linenum = lineno;
|
||||
while (size--)
|
||||
{
|
||||
*ptr++ = MALLOC_FILL_VALUE;
|
||||
}
|
||||
#ifdef OVERRUN_SIZE
|
||||
{
|
||||
char const * overrun_ptr = overrun_code;
|
||||
int ov_cnt = OVERRUN_SIZE(recordPtr->size);
|
||||
do /* a memcpy */
|
||||
{
|
||||
if (!*overrun_ptr) overrun_ptr = overrun_code; /* repeat */
|
||||
*ptr++ = *overrun_ptr++;
|
||||
}
|
||||
while (--ov_cnt);
|
||||
}
|
||||
#endif
|
||||
break; /* exit while loop */
|
||||
}
|
||||
i++;
|
||||
recordPtr++;
|
||||
}
|
||||
|
||||
GLOBALASSERT(i<MAXMALLOCS); /* This should never fire - oh well */
|
||||
|
||||
}
|
||||
|
||||
return(1);
|
||||
|
||||
}
|
||||
#else
|
||||
#if COPY_FILENAME
|
||||
static int AdjustMallocRecord(unsigned long addr, long size, char string[], unsigned long lineno)
|
||||
#else
|
||||
static int AdjustMallocRecord(unsigned long addr, long size, char const * string, unsigned long lineno)
|
||||
#endif
|
||||
{
|
||||
|
||||
int Starti=addr % MAXMALLOCS;
|
||||
int i=Starti;
|
||||
char *ptr = (char *)addr;
|
||||
static int no_record_init = 1;
|
||||
MALLOC_RECORD *recordPtr,*StartRecordPtr;
|
||||
recordPtr=StartRecordPtr=&MallocRecord[Starti];
|
||||
|
||||
if(no_record_init)
|
||||
{
|
||||
InitMallocRecords();
|
||||
no_record_init = 0;
|
||||
}
|
||||
|
||||
|
||||
if(size==FREEING_MEMORY) /* must be freeing memory */
|
||||
{
|
||||
#if AllowedToDeleteNULL
|
||||
if (NULL == addr)
|
||||
{
|
||||
return 1;
|
||||
/*
|
||||
...so the record_free() function calls
|
||||
DeallocMem(NULL), which ought to do nothing
|
||||
(refer to citations in comment near the top of
|
||||
this file)
|
||||
*/
|
||||
}
|
||||
#endif
|
||||
|
||||
GLOBALASSERT(addr); /* ensure not null addr */
|
||||
|
||||
while(i<MAXMALLOCS)
|
||||
{
|
||||
if(recordPtr->addr==addr)
|
||||
{
|
||||
TotalMallocNum--;
|
||||
|
||||
size = recordPtr->size;
|
||||
|
||||
while (size--)
|
||||
{
|
||||
*ptr++ = FREE_FILL_VALUE;
|
||||
}
|
||||
#ifdef OVERRUN_SIZE
|
||||
{
|
||||
char const * overrun_ptr = overrun_code;
|
||||
int ov_cnt = OVERRUN_SIZE(recordPtr->size);
|
||||
do /* a memcmp - dunno if its supported on all platforms */
|
||||
{
|
||||
if (!*overrun_ptr) overrun_ptr = overrun_code; /* repeat */
|
||||
if (*overrun_ptr++ != *ptr++)
|
||||
{
|
||||
textprint2("\nOut of Bounds!\n%lu bytes allocated to %p\nat %s, line %lu\n", recordPtr->size,(void *)recordPtr->addr,recordPtr->filename,recordPtr->linenum);
|
||||
GLOBALASSERT(!"OUT OF BOUNDS detected in FREE");
|
||||
}
|
||||
}
|
||||
while (--ov_cnt);
|
||||
}
|
||||
#endif
|
||||
|
||||
recordPtr->addr = 0;
|
||||
TotalMemAllocated -= recordPtr->size;
|
||||
recordPtr->size = 0;
|
||||
#if COPY_FILENAME
|
||||
recordPtr->filename[0] = 0;
|
||||
#else
|
||||
recordPtr->filename = "";
|
||||
#endif
|
||||
recordPtr->linenum = 0;
|
||||
break; /* exit while loop */
|
||||
}
|
||||
i++;
|
||||
recordPtr++;
|
||||
}
|
||||
if(i==MAXMALLOCS)
|
||||
{
|
||||
i=0;
|
||||
recordPtr=&MallocRecord[0];
|
||||
|
||||
while(i<Starti)
|
||||
{
|
||||
if(recordPtr->addr==addr)
|
||||
{
|
||||
TotalMallocNum--;
|
||||
|
||||
size = recordPtr->size;
|
||||
|
||||
while (size--)
|
||||
{
|
||||
*ptr++ = FREE_FILL_VALUE;
|
||||
}
|
||||
#ifdef OVERRUN_SIZE
|
||||
{
|
||||
char const * overrun_ptr = overrun_code;
|
||||
int ov_cnt = OVERRUN_SIZE(recordPtr->size);
|
||||
do /* a memcmp - dunno if its supported on all platforms */
|
||||
{
|
||||
if (!*overrun_ptr) overrun_ptr = overrun_code; /* repeat */
|
||||
if (*overrun_ptr++ != *ptr++)
|
||||
{
|
||||
textprint2("\nOut of Bounds!\n%lu bytes allocated to %p\nat %s, line %lu\n", recordPtr->size,(void *)recordPtr->addr,recordPtr->filename,recordPtr->linenum);
|
||||
GLOBALASSERT(!"OUT OF BOUNDS detected in FREE");
|
||||
}
|
||||
}
|
||||
while (--ov_cnt);
|
||||
}
|
||||
#endif
|
||||
|
||||
recordPtr->addr = 0;
|
||||
TotalMemAllocated -= recordPtr->size;
|
||||
recordPtr->size = 0;
|
||||
#if COPY_FILENAME
|
||||
recordPtr->filename[0] = 0;
|
||||
#else
|
||||
recordPtr->filename = "";
|
||||
#endif
|
||||
recordPtr->linenum = 0;
|
||||
break; /* exit while loop */
|
||||
}
|
||||
i++;
|
||||
recordPtr++;
|
||||
}
|
||||
if(i>=Starti)
|
||||
{
|
||||
textprint2("\n\n\n\nFree Error! %s, line %d\n", string, (int)lineno);
|
||||
GLOBALASSERT(0);
|
||||
return(0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
else /* must be mallocing memory */
|
||||
{
|
||||
TotalMallocNum++;
|
||||
GLOBALASSERT(TotalMallocNum<MAXMALLOCS); /* just increase MAXMALLOCS define above if this fires */
|
||||
|
||||
|
||||
// RWH chack to see that this address isn't already in use
|
||||
while(i<MAXMALLOCS)
|
||||
{
|
||||
if(recordPtr->addr==0)
|
||||
{
|
||||
recordPtr->addr = addr;
|
||||
recordPtr->size = size;
|
||||
TotalMemAllocated += size;
|
||||
#if COPY_FILENAME
|
||||
strcpy(recordPtr->filename, string);
|
||||
#else
|
||||
recordPtr->filename = string;
|
||||
#endif
|
||||
recordPtr->linenum = lineno;
|
||||
while (size--)
|
||||
{
|
||||
*ptr++ = MALLOC_FILL_VALUE;
|
||||
}
|
||||
#ifdef OVERRUN_SIZE
|
||||
{
|
||||
char const * overrun_ptr = overrun_code;
|
||||
int ov_cnt = OVERRUN_SIZE(recordPtr->size);
|
||||
do /* a memcpy */
|
||||
{
|
||||
if (!*overrun_ptr) overrun_ptr = overrun_code; /* repeat */
|
||||
*ptr++ = *overrun_ptr++;
|
||||
}
|
||||
while (--ov_cnt);
|
||||
}
|
||||
#endif
|
||||
break; /* exit while loop */
|
||||
}
|
||||
i++;
|
||||
recordPtr++;
|
||||
}
|
||||
if(i>=MAXMALLOCS)
|
||||
{
|
||||
i=0;
|
||||
recordPtr=&MallocRecord[0];
|
||||
while(i<Starti)
|
||||
{
|
||||
if(recordPtr->addr==0)
|
||||
{
|
||||
recordPtr->addr = addr;
|
||||
recordPtr->size = size;
|
||||
TotalMemAllocated += size;
|
||||
#if COPY_FILENAME
|
||||
strcpy(recordPtr->filename, string);
|
||||
#else
|
||||
recordPtr->filename = string;
|
||||
#endif
|
||||
recordPtr->linenum = lineno;
|
||||
while (size--)
|
||||
{
|
||||
*ptr++ = MALLOC_FILL_VALUE;
|
||||
}
|
||||
#ifdef OVERRUN_SIZE
|
||||
{
|
||||
char const * overrun_ptr = overrun_code;
|
||||
int ov_cnt = OVERRUN_SIZE(recordPtr->size);
|
||||
do /* a memcpy */
|
||||
{
|
||||
if (!*overrun_ptr) overrun_ptr = overrun_code; /* repeat */
|
||||
*ptr++ = *overrun_ptr++;
|
||||
}
|
||||
while (--ov_cnt);
|
||||
}
|
||||
#endif
|
||||
break; /* exit while loop */
|
||||
}
|
||||
i++;
|
||||
recordPtr++;
|
||||
}
|
||||
GLOBALASSERT(i<Starti); /* This should never fire - oh well */
|
||||
}
|
||||
}
|
||||
return(1);
|
||||
|
||||
}
|
||||
#endif
|
||||
void DumpMallocInfo(int type)
|
||||
{
|
||||
int i;
|
||||
|
||||
if(type==DUMPTOSCREEN)
|
||||
{
|
||||
for (i=0;i<MAXMALLOCS;i++ )
|
||||
{
|
||||
if(MallocRecord[i].addr!=0)
|
||||
{
|
||||
if (!(MallocRecord[i].linenum & CPPGLOBAL))
|
||||
{
|
||||
textprint2("\nmalloc: %d bytes,line %d in %s",
|
||||
(int)MallocRecord[i].size, (int)MallocRecord[i].linenum, MallocRecord[i].filename);
|
||||
}
|
||||
else
|
||||
{
|
||||
textprint2("\nC++ global construct malloc: %d bytes,line %d in %s",
|
||||
(int)MallocRecord[i].size, (int)(MallocRecord[i].linenum &~CPPGLOBAL), MallocRecord[i].filename);
|
||||
}
|
||||
}
|
||||
}
|
||||
textprint2("\n\n\n\nTotalMemAllocated: %d\nTotalMallocNum: %d",
|
||||
(int)TotalMemAllocated, (int)TotalMallocNum);
|
||||
WaitForReturn();
|
||||
}
|
||||
else if (type==DUMPTOFILE)
|
||||
{
|
||||
|
||||
#if SupportWindows95
|
||||
FILE *fp;
|
||||
|
||||
if( (fp = fopen(MALLOCDUMPFILE,FILEPERM))== (FILE *)NULL)
|
||||
{
|
||||
textprint2("\n\n\nfile open error %s", MALLOCDUMPFILE);
|
||||
}
|
||||
else
|
||||
{
|
||||
fprintf(fp,"\n\n\n\nOUTSTANDING MEMORY ALLOCATIONS\n\n");
|
||||
for (i=0;i<MAXMALLOCS;i++ )
|
||||
{
|
||||
if(MallocRecord[i].addr!=0)
|
||||
{
|
||||
if (!(MallocRecord[i].linenum & CPPGLOBAL))
|
||||
{
|
||||
fprintf(fp,"\nmalloc: %d bytes,line %d in %s",
|
||||
(int)MallocRecord[i].size, (int)MallocRecord[i].linenum, MallocRecord[i].filename);
|
||||
}
|
||||
else
|
||||
{
|
||||
fprintf(fp,"\nC++ global construct malloc: %d bytes,line %d in %s",
|
||||
(int)MallocRecord[i].size, (int)(MallocRecord[i].linenum &~CPPGLOBAL), MallocRecord[i].filename);
|
||||
}
|
||||
}
|
||||
}
|
||||
fprintf(fp,"\n\nTotalMemAllocated: %d\nTotalMallocNum: %d\n",
|
||||
(int)TotalMemAllocated, (int)TotalMallocNum);
|
||||
|
||||
fclose(fp);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if PSX
|
||||
long fd;
|
||||
|
||||
fd = PCopen(MALLOCDUMPFILE,1,0);
|
||||
if(fd<0)
|
||||
{
|
||||
fd = PCcreat(MALLOCDUMPFILE,0);
|
||||
PCclose(fd);
|
||||
fd = PCopen(MALLOCDUMPFILE,1,0);
|
||||
}
|
||||
|
||||
if(fd<0)
|
||||
{
|
||||
textprint2("\n\n\nfile open error %s", MALLOCDUMPFILE);
|
||||
}
|
||||
else
|
||||
{
|
||||
char stringbuf[200];
|
||||
sprintf(stringbuf,"\n\n\n\nOUTSTANDING MEMORY ALLOCATIONS\n\n");
|
||||
#if APPEND_TO_DUMPFILE
|
||||
PClseek(fd,0,2);
|
||||
#endif
|
||||
PCwrite(fd,stringbuf,strlen(stringbuf));
|
||||
for (i=0;i<MAXMALLOCS;i++ )
|
||||
{
|
||||
if(MallocRecord[i].addr!=0)
|
||||
{
|
||||
if (!(MallocRecord[i].linenum & CPPGLOBAL))
|
||||
{
|
||||
sprintf(stringbuf,"\nmalloc: %d bytes,line %d in %s",
|
||||
(int)MallocRecord[i].size, (int)MallocRecord[i].linenum, MallocRecord[i].filename);
|
||||
}
|
||||
else
|
||||
{
|
||||
sprintf(stringbuf,"\nC++ global construct malloc: %d bytes,line %d in %s",
|
||||
(int)MallocRecord[i].size, (int)(MallocRecord[i].linenum &~CPPGLOBAL), MallocRecord[i].filename);
|
||||
}
|
||||
PCwrite(fd,stringbuf,strlen(stringbuf));
|
||||
}
|
||||
}
|
||||
|
||||
sprintf(stringbuf,"\n\nTotalMemAllocated: %d\nTotalMallocNum: %d\n",
|
||||
(int)TotalMemAllocated, (int)TotalMallocNum);
|
||||
|
||||
PCwrite(fd,stringbuf,strlen(stringbuf));
|
||||
|
||||
PCclose(fd);
|
||||
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void DumpBoundsCheckInfo(int type)
|
||||
{
|
||||
#ifdef OVERRUN_SIZE
|
||||
int i;
|
||||
|
||||
if(type==DUMPTOSCREEN)
|
||||
{
|
||||
int bc_errcnt = 0;
|
||||
for (i=0;i<MAXMALLOCS;i++ )
|
||||
{
|
||||
if(MallocRecord[i].addr!=0)
|
||||
{
|
||||
MALLOC_RECORD *recordPtr = &MallocRecord[i];
|
||||
|
||||
unsigned char const * overrun_ptr = overrun_code;
|
||||
unsigned char const * ptr = (unsigned char const *)recordPtr->addr + recordPtr->size;
|
||||
int ov_cnt = OVERRUN_SIZE(recordPtr->size);
|
||||
do /* a memcmp - dunno if its supported on all platforms */
|
||||
{
|
||||
if (!*overrun_ptr) overrun_ptr = overrun_code; /* repeat */
|
||||
if (*overrun_ptr++ != *ptr++)
|
||||
{
|
||||
textprint2("\nOut of Bounds!\n%lu bytes allocated to %p\nat %s, line %lu\n", recordPtr->size,(void *)recordPtr->addr,recordPtr->filename,recordPtr->linenum);
|
||||
++bc_errcnt;
|
||||
break;
|
||||
}
|
||||
}
|
||||
while (--ov_cnt);
|
||||
}
|
||||
}
|
||||
if (bc_errcnt)
|
||||
WaitForReturn();
|
||||
else
|
||||
textprint2("No bounds errors detected\n");
|
||||
|
||||
}
|
||||
else if (type==DUMPTOFILE)
|
||||
{
|
||||
|
||||
#if SupportWindows95
|
||||
FILE *fp;
|
||||
|
||||
if( (fp = fopen(MALLOCDUMPFILE,FILEPERM))== (FILE *)NULL)
|
||||
{
|
||||
textprint2("\n\n\nfile open error %s", MALLOCDUMPFILE);
|
||||
}
|
||||
else
|
||||
{
|
||||
fprintf(fp,"\n\n\n\nBOUNDS CHECK PROBLEMS\n\n");
|
||||
for (i=0;i<MAXMALLOCS;i++ )
|
||||
{
|
||||
if(MallocRecord[i].addr!=0)
|
||||
{
|
||||
MALLOC_RECORD *recordPtr = &MallocRecord[i];
|
||||
|
||||
unsigned char const * overrun_ptr = overrun_code;
|
||||
unsigned char const * ptr = (unsigned char const *)recordPtr->addr + recordPtr->size;
|
||||
int ov_cnt = OVERRUN_SIZE(recordPtr->size);
|
||||
do /* a memcmp - dunno if its supported on all platforms */
|
||||
{
|
||||
if (!*overrun_ptr) overrun_ptr = overrun_code; /* repeat */
|
||||
if (*overrun_ptr++ != *ptr++)
|
||||
{
|
||||
fprintf(fp,"\nOut of Bounds!\n%lu bytes allocated to %p\nat %s, line %lu\n", recordPtr->size,(void *)recordPtr->addr,recordPtr->filename,recordPtr->linenum);
|
||||
break;
|
||||
}
|
||||
}
|
||||
while (--ov_cnt);
|
||||
}
|
||||
}
|
||||
fprintf(fp,"\n\nTotalMemAllocated: %d\nTotalMallocNum: %d\n",
|
||||
(int)TotalMemAllocated, (int)TotalMallocNum);
|
||||
|
||||
fclose(fp);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if PSX
|
||||
long fd;
|
||||
|
||||
fd = PCopen(MALLOCDUMPFILE,1,0);
|
||||
if(fd<0)
|
||||
{
|
||||
fd = PCcreat(MALLOCDUMPFILE,0);
|
||||
PCclose(fd);
|
||||
fd = PCopen(MALLOCDUMPFILE,1,0);
|
||||
}
|
||||
|
||||
if(fd<0)
|
||||
{
|
||||
textprint2("\n\n\nfile open error %s", MALLOCDUMPFILE);
|
||||
}
|
||||
else
|
||||
{
|
||||
char stringbuf[200];
|
||||
sprintf(stringbuf,"\n\n\n\nBOUNDS_CHECK_PROBLEMS\n\n");
|
||||
#if APPEND_TO_DUMPFILE
|
||||
PClseek(fd,0,2);
|
||||
#endif
|
||||
PCwrite(fd,stringbuf,strlen(stringbuf));
|
||||
for (i=0;i<MAXMALLOCS;i++ )
|
||||
{
|
||||
if(MallocRecord[i].addr!=0)
|
||||
{
|
||||
MALLOC_RECORD *recordPtr = &MallocRecord[i];
|
||||
|
||||
unsigned char const * overrun_ptr = overrun_code;
|
||||
unsigned char const * ptr = (unsigned char const *)recordPtr->addr + recordPtr->size;
|
||||
int ov_cnt = OVERRUN_SIZE(recordPtr->size);
|
||||
do /* a memcmp - dunno if its supported on all platforms */
|
||||
{
|
||||
if (!*overrun_ptr) overrun_ptr = overrun_code; /* repeat */
|
||||
if (*overrun_ptr++ != *ptr++)
|
||||
{
|
||||
sprintf(stringbuf,"\nOut of Bounds!\n%lu bytes allocated to %p\nat %s, line %lu\n", recordPtr->size,(void *)recordPtr->addr,recordPtr->filename,recordPtr->linenum);
|
||||
PCwrite(fd,stringbuf,strlen(stringbuf));
|
||||
break;
|
||||
}
|
||||
}
|
||||
while (--ov_cnt);
|
||||
}
|
||||
}
|
||||
|
||||
PCclose(fd);
|
||||
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
void InitMallocRecords(void)
|
||||
{
|
||||
int i;
|
||||
MALLOC_RECORD *recordPtr = MallocRecord;
|
||||
|
||||
for (i=0;i<MAXMALLOCS;i++,recordPtr++)
|
||||
{
|
||||
recordPtr->addr = 0;
|
||||
recordPtr->size = 0;
|
||||
#if COPY_FILENAME
|
||||
recordPtr->filename[0] = 0;
|
||||
#else
|
||||
recordPtr->filename = "";
|
||||
#endif
|
||||
recordPtr->linenum = 0;
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
#else
|
||||
void DumpMallocInfo(int type);
|
||||
void DumpMallocInfo(int type)
|
||||
{
|
||||
/* empty if not debugging */
|
||||
}
|
||||
void DumpBoundsCheckInfo(int type)
|
||||
{}
|
||||
#endif
|
||||
Loading…
Add table
Add a link
Reference in a new issue