static char *palloc(int *sizepos,int size,int *indxpos,BLK **blk)
/*
* main allocation routine
*/
{
BLK *bp;
char *rv;
if( size & 1 ) /* if odd size */
size += 1; /* make it even */
/* if anything left, try to allocate from it */
if( *sizepos >= size ) {
rv = &((*blk)->m[*indxpos]);
*sizepos -= size;
*indxpos += size;
return rv;
}
else {
long allocsize;
/* else check for size > normal blcok size */
if (size > 2048) {
/* this is going to fragment memory!!! I'd fix it except
* the fragmentation is partially dependent on the calloc
* implementation
*/
allocsize = size - 1;
*sizepos = 0;
}
else {
/* as long as we stick to normal blocks, fragmentation
* won't be an issue because as long as all blocks are the
* same size calloc is guaranteed to find one if there are any
*/
allocsize = 2047;
*sizepos = 2048 - size;
}
/* allocate mem */
bp = calloc(1,sizeof(BLK) + allocsize);
if( bp == NULL ) {
release_global();
release_local();
release_opt();
release_oc();
mem_summary();
fatal(" not enough memory.");
}
bp->blksize = allocsize;
/* link the block and return the base */
bp->next = *blk;
*blk = bp;
*indxpos = size;
return (*blk)->m;
}
}
int main(int argc, char *argv[])
{
char buffer[256];
char *p;
BOOLEAN multipleFiles = FALSE;
int rv;
char realOutFile[260];
char oldOutFile[260];
srand(time(0));
/* signal(SIGSEGV,internalError) ;*/
/* signal(SIGFPE, internalError) ;*/
/* initialize back end */
if (!init_backend(&argc,argv))
fatal("Could not initialize back end");
if (chosenAssembler->Args)
{
CMDLIST *newArgs = calloc(sizeof(Args) + sizeof(Args[0]) * chosenAssembler->ArgCount, 1);
if (newArgs)
{
memcpy(&newArgs[0], chosenAssembler->Args,
chosenAssembler->ArgCount *sizeof(Args[0]));
memcpy(&newArgs[chosenAssembler->ArgCount], &Args[0], sizeof(Args));
ArgList = newArgs;
}
}
/* parse environment variables, command lines, and config files */
ccinit(argc, argv);
/* loop through and preprocess all the files on the file list */
if (clist && clist->next)
multipleFiles = TRUE;
#ifdef PARSER_ONLY
strcpy(buffer, clist->data);
strcpy(realOutFile, outfile);
outputfile(realOutFile, buffer, ".ods");
if (!ccDBOpen(realOutFile))
fatal("Cannot open database file %s", realOutFile);
#else
BitInit();
regInit();
#endif
while (clist)
{
cparams.prm_cplusplus = FALSE;
strcpy(buffer, clist->data);
#ifndef PARSER_ONLY
strcpy(realOutFile, outfile);
if (cparams.prm_asmfile)
outputfile(realOutFile, buffer, chosenAssembler->asmext);
else
outputfile(realOutFile, buffer, chosenAssembler->objext);
strcpy(oldOutFile, realOutFile);
StripExt(oldOutFile);
AddExt(oldOutFile, ".tmp");
#else
ccNewFile(buffer, TRUE);
#endif
AddExt(buffer, ".C");
p = strrchr(buffer, '.');
if (*(p - 1) != '.')
{
if (p[1] == 'h' || p[1] == 'H') // compile H files as C++ for the IDE
cparams.prm_cplusplus = TRUE;
if (p[1] == 'c' || p[1] == 'C')
if (p[2] == 'p' || p[2] == 'P')
{
if (p[3] == 'p' || p[3] == 'P')
cparams.prm_cplusplus = TRUE;
}
else
{
if (p[2] == 'x' || p[2] == 'X')
{
if (p[3] == 'x' || p[3] == 'X')
cparams.prm_cplusplus = TRUE;
}
}
else if ((p[2] == 'c' ||p[2] == 'C' ) && !p[3])
{
cparams.prm_cplusplus = TRUE;
}
else
{
if (p[2] == '+')
{
if (p[3] == '+')
cparams.prm_cplusplus = TRUE;
}
}
}
inputFile = SrchPth2(buffer, "", "r");
if (!inputFile)
fatal("Cannot open input file %s", buffer);
strcpy(infile, buffer);
if (cparams.prm_makestubs)
{
MakeStubs();
}
else
{
#ifndef PARSER_ONLY
unlink(oldOutFile);
rename(realOutFile, oldOutFile);
outputFile = fopen(realOutFile, cparams.prm_asmfile ? "w" : "wb");
if (!outputFile)
{
fclose(inputFile);
fatal("Cannot open output file %s", realOutFile);
}
setvbuf(outputFile,0,_IOFBF,32768);
#endif
if (cparams.prm_cppfile)
{
StripExt(buffer);
AddExt(buffer, ".i");
strcpy(cppfile, buffer);
cppFile = fopen(buffer, "w");
if (!cppFile)
{
fclose(inputFile);
fclose(outputFile);
fatal("Cannot open preprocessor output file %s", buffer);
}
}
if (cparams.prm_listfile)
{
StripExt(buffer);
AddExt(buffer, ".lst");
listFile = fopen(buffer, "w");
if (!listFile)
{
fclose(inputFile);
fclose(cppFile);
fclose(outputFile);
fatal("Cannot open list file %s", buffer);
}
}
if (cparams.prm_errfile)
{
StripExt(buffer);
AddExt(buffer, ".err");
errFile = fopen(buffer, "w");
if (!errFile)
{
fclose(inputFile);
fclose(cppFile);
fclose(listFile);
fclose(outputFile);
fatal("Cannot open error file %s", buffer);
}
}
if (cparams.prm_browse)
{
char name[260];
strcpy(name, outfile);
StripExt(name);
AddExt(name, ".cbr");
browseFile = fopen(name, "wb");
if (!browseFile)
{
fclose(errFile);
fclose(inputFile);
fclose(cppFile);
fclose(listFile);
fclose(outputFile);
fatal("Cannot open browse file %s", buffer);
}
setvbuf(browseFile,0,_IOFBF,32768);
}
if (cparams.prm_icdfile)
{
StripExt(buffer);
AddExt(buffer, ".icd");
icdFile = fopen(buffer, "w");
if (!icdFile)
{
fclose(browseFile);
fclose(errFile);
fclose(inputFile);
fclose(cppFile);
fclose(listFile);
fclose(outputFile);
fatal("Cannot open error file %s", buffer);
}
setvbuf(icdFile,0,_IOFBF,32768);
}
if (multipleFiles && !cparams.prm_quiet)
printf("%s\n", clist->data);
compile();
}
#ifdef PARSER_ONLY
localFree();
#endif
globalFree();
if (cparams.prm_diag)
{
mem_summary();
printf("Intermediate stats:\n");
printf(" Block peak: %d\n", maxBlocks);
printf(" Temp peak: %d\n", maxTemps);
printf(" Allocation Spills: %d\n", maxAllocationSpills);
printf(" Allocation Passes: %d\n", maxAllocationPasses);
printf(" Allocation Accesses: %d\n", maxAllocationAccesses);
}
maxBlocks = maxTemps = maxAllocationSpills = maxAllocationPasses = maxAllocationAccesses = 0;
#ifdef PARSER_ONLY
ccCloseFile(inputFile);
#else
fclose(inputFile);
#endif
if (outputFile)
fclose(outputFile);
if (cppFile)
fclose(cppFile);
if (listFile)
fclose(listFile);
if (errFile)
fclose(errFile);
if (browseFile)
fclose(browseFile);
if (icdFile)
fclose(icdFile);
if (total_errors)
{
unlink(realOutFile);
rename(oldOutFile, realOutFile);
}
else
{
unlink (oldOutFile);
}
/* Flag to stop if there are any errors */
stoponerr |= total_errors;
clist = clist->next;
}
rv = !!stoponerr ;
if (!cparams.prm_makestubs)
{
if (!cparams.prm_compileonly && !stoponerr) {
rv = 0 ;
if (chosenAssembler->compiler_postprocess)
{
char buf[260];
#ifdef MICROSOFT
GetModuleFileNameA(NULL, buffer, sizeof(buffer));
#else
strcpy(buffer, argv[0]);
#endif
rv = chosenAssembler->compiler_postprocess(buffer);
}
}
if (chosenAssembler->rundown)
chosenAssembler->rundown();
}
return rv;
}
