cmain.c

CC386 is a general-purpose 32-bit C compiler. It is not an optimizing compiler but given that the co

        if (*s == '=')
            *s++ = 0;
        glbdefine(n, s);
        l = l->link;
    }
    sscanf(CC_STRING_VERSION, "%d.%d", &major, &minor);
    sprintf(buf, "%d", major *100+minor);
    glbdefine("__CCDL__", buf);
    #if !defined(__CCDL__)
        glbdefine("__NONNATIVE_BUILD",""); // the borland version of the compiler can't handle infinities
    #endif
    #ifdef i386
        glbdefine("__386__", "");
        glbdefine("__i386__", "");
    #endif 
    #ifndef MSDOS
        glbdefine("__WIN32__", "");
    #endif 
        if (prm_cplusplus)
        {
            glbdefine("__cplusplus", "");
            if (prm_xcept)
                glbdefine("__RTTI__", "");
        }
#ifdef i386
    if (prm_lscrtdll)
        glbdefine("__LSCRTL_DLL", "");
#endif
    // for the standard headers, we may fix this later
    //   if (prm_ansi)
    glbdefine("__STDC__", "1");
    if (prm_c99)
        glbdefine("__STDC_VERSION__", "199901L");
    //   glbdefine("__STDC_IEC_599__","1");
    //   glbdefine("__STDC_IEC_599_COMPLEX__","1");
    //   glbdefine("__STDC_ISO_10646__","199712L");
    glbdefine(GLBDEFINE, "");
}

//-------------------------------------------------------------------------

void InsertAnyFile(FILE *inf, FILE *outf, char *filename, char *path, int drive)
/*
 * Insert a file name onto the list of files to process
 */

{
    char *newbuffer, buffer[100],  *p = buffer;
    LIST *r = &clist;

    file_count++;

    if (drive !=  - 1)
    {
        *p++ = (char)(drive + 'A');
        *p++ = ':';
    }
    if (path)
    {
        strcpy(p, path);
        strcat(p, "\\");
    }
    else
        *p = 0;
    /* Allocate buffer and make .C if no extension */
    strcat(buffer, filename);
    #ifdef i386
        if (prm_compileonly || !InsertExternalFile(buffer))
    #endif 
    {
        AddExt(buffer, ".C");
        newbuffer = (char*)malloc(strlen(buffer) + 1);
        if (!newbuffer)
            return ;
        strcpy(newbuffer, buffer);

        /* Insert file */
        /* this is screwy, r is actually a pointer to a pointer.  It only works
         * because the link field is the first field
         */
        while (r->link)
            r = r->link;
        r->link = malloc(sizeof(LIST));
        r = r->link;
        if (!r)
            return ;
        r->link = 0;
        r->data = newbuffer;
    }
}

//-------------------------------------------------------------------------

void dumperrs(FILE *file);
void setfile(char *buf, char *orgbuf, char *ext)
/*
 * Get rid of a file path an add an extension to the file name
 */
{
    char *p = strrchr(orgbuf, '\\');
    if (!p)
        p = orgbuf;
    else
        p++;
    strcpy(buf, p);
    StripExt(buf);
    AddExt(buf, ext);
}

//-------------------------------------------------------------------------

void outputfile(char *buf, char *orgbuf, char *ext)
{
    if (has_output_file)
        AddExt(buf, ext);
    else
        setfile(buf, orgbuf, ext);
}

//-------------------------------------------------------------------------

void scan_env(char *output, char *string)
{
    char name[256],  *p = name;
    while (*string)
    {
        if (*string == '%')
        {
            p = name;
            string++;
            while (*string &&  *string != '%')
                *p++ =  *string++;
            if (*string)
                string++;
            *p = 0;
            p = getenv(name);
            if (p)
            {
                strcpy(output, p);
                output += strlen(output);
            }

        }
        else
            *output++ =  *string++;
    }
    *output = 0;
}

//-------------------------------------------------------------------------

int parse_arbitrary(char *string)
/*
 * take a C string and and convert it to ARGC, ARGV format and then run
 * it through the argument parser
 */
{
    char *argv[40];
    char output[1024];
    int rv, i;
    int argc = 1;
    if (!string || ! *string)
        return 1;
    scan_env(output, string);
    string = output;
    while (1)
    {
        int quoted = ' ';
        while (*string == ' ')
            string++;
        if (! *string)
            break;
        if (*string == '\"')
            quoted =  *string++;
        argv[argc++] = string;
        while (*string &&  *string != quoted)
            string++;
        if (! *string)
            break;
        *string = 0;
        string++;
    }
    rv = parse_args(&argc, argv, TRUE);
    for (i = 1; i < argc; i++)
        InsertAnyFile(0, 0, argv[i], 0,  - 1);
    return rv;
}

//-------------------------------------------------------------------------

void parsefile(char select, char *string)
/*
 * parse arguments from an input file
 */
{
    FILE *temp;
    if (!(temp = fopen(string, "r")))
        fatal("Argument file not found");
    while (!feof(temp))
    {
        char buf[256];
        buf[0] = 0;
        fgets(buf, 256, temp);
        if (buf[strlen(buf) - 1] == '\n')
            buf[strlen(buf) - 1] = 0;
        if (!parse_arbitrary(buf))
            break;
    }
    fclose(temp);
}

//-------------------------------------------------------------------------

void addinclude(void)
/*
 * Look up the INCLUDE environment variable and append it to the
 * search path
 */
{
    #ifdef COLDFIRE
        char *string = getenv("cfccincl");
    #else 
        char *string = getenv("CCINCL");
    #endif 
    if (string && string[0])
    {
        char temp[1000];
        strcpy(temp, string);
        if (*set_searchpath)
        {
            strcat(temp, ";");
            strcat(temp,  *set_searchpath);
            free(*set_searchpath);
        }
        *set_searchpath = malloc(strlen(temp) + 1);
        strcpy(*set_searchpath, temp);
    }
}

//-------------------------------------------------------------------------

int parseenv(char *name)
/*
 * Parse the environment argument string
 */
{
    char *string = getenv(name);
    return parse_arbitrary(string);
}

//-------------------------------------------------------------------------

int parseconfigfile(char *name)
{
    char buf[256],  *p;
    strcpy(buf, name);
    p = strrchr(buf, '\\');
    if (p)
    {
        FILE *temp;
        strcpy(p + 1, PROGNAME);
        strcat(p, ".CFG");
        if (!(temp = fopen(buf, "r")))
            return 0;
        set_searchpath = &sys_searchpath;
        while (!feof(temp))
        {
            buf[0] = 0;
            fgets(buf, 256, temp);
            if (buf[strlen(buf) - 1] == '\n')
                buf[strlen(buf) - 1] = 0;
            if (!parse_arbitrary(buf))
                break;
        }
        set_searchpath = &prm_searchpath;
        fclose(temp);
    }
    return 0;

}

//-------------------------------------------------------------------------

void dumperrs(FILE *file)
{
    #ifdef DIAGNOSTICS
        if (diagcount && !total_errors)
            fprintf(file, "%d Diagnostics detected\n", diagcount);
    #endif 
    if (total_errors)
        fprintf(file, "%d Total errors\n", total_errors);
    if (prm_diag)
        mem_summary();
}

//-------------------------------------------------------------------------

void summary(void)
{
    if (prm_listfile)
    {
        fprintf(listFile, "\f\n *** global scope symbol table ***\n\n");
        list_table(gsyms, 0);
        fprintf(listFile, "\n *** structures and unions ***\n\n");
        list_table(tagtable, 0);
        dumperrs(listFile);
    }
}

//-------------------------------------------------------------------------

void ctrlchandler(int aa)
{
    longjmp(ctrlcreturn, 1);
}

//-------------------------------------------------------------------------

void internalError(int a)
{
    printf("Internal Error - Aborting compile");
    exit(1);
}

//-------------------------------------------------------------------------

int main(int argc, char *argv[])
{
    char buffer[256];
    char *p;
    int oldmode = _fmode;
    strcpy(copyright, PRODUCT_COPYRIGHT);
    strcpy(version, CC_STRING_VERSION);
    banner("%s Version %s %s", PROGNAME, version, copyright);

    #ifndef ICODE
        //   signal(SIGSEGV,internalError) ;
        //   signal(SIGFPE, internalError) ;
    #endif 
    if (OBJEXT[0])
        prm_asmfile = FALSE;

    outfile[0] = 0;

    /* parse the environment and command line */
    if (!parseenv(ENVNAME))
        usage(argv[0]);
    parseconfigfile(argv[0]);
    if (!parse_args(&argc, argv, TRUE) || (!file_count && argc == 1))
        usage(argv[0]);


    /* tack the environment includes in */
    addinclude();

    /* processor-dependent initialization */
    confsetup();

    #ifdef i386
        if (has_output_file && !prm_compileonly)
        {
            InsertOutputFile(outfile);
            has_output_file = FALSE;
        }
    #endif 
    /* Scan the command line for file names or response files */
    {
        int i;
        for (i = 1; i < argc; i++)
            InsertAnyFile(0, 0, argv[i], 0,  - 1);
    }

    if (file_count > 1 && has_output_file)
        fatal("Cannot specify output file for multiple input files\n");

    /* Set up a ctrl-C handler so we can exit the prog */
    signal(SIGINT, ctrlchandler);
    if (setjmp(ctrlcreturn))
        exit(1);
    /* loop through and compile all the files on the file list */
    while (clist)
    {
        prm_cplusplus = FALSE;
        anyusedfloat = 0;
        packlevel = 0;
        #ifndef ICODE
            regini();
            IntrinsIni();
            inasmini();
        #endif 
        constoptinit();
        memini();
        symini();
        stmtini();
        initini();
        preprocini();
        exprini();
        declini();
        template_init();
        defclassini();
        funcini();
        peepini();
        inlineinit();
        outcodeini();
        outcode_file_init();
        dbginit();
        browse_init();
        xceptinit();
        oinit();
        //      if (!prm_quieterrors)
        //         printf("file: %s\n",clist->data);
        strcpy(buffer, clist->data);
        if (prm_asmfile)
            outputfile(outfile, buffer, SOURCEXT);
        else
            outputfile(outfile, buffer, OBJEXT);
        setfile(cppfile, buffer, ".I");
        setfile(listfile, buffer, ".LST");
        setfile(errorfile, buffer, ".ERR");
#ifdef ICODE
		setfile(icdfile, buffer, ".ICD");
#endif
        AddExt(buffer, ".C");
            p = strrchr(buffer, '.');
            if (*(p - 1) != '.')
            {
                if (p[1] == 'c' || p[1] == 'C')
                if (p[2] == 'p' || p[2] == 'P')
                {
                    if (p[3] == 'p' || p[3] == 'P')
                        prm_cplusplus = TRUE;
                }
                else
                {
                    if (p[2] == 'x' || p[2] == 'x')
                    {
                        if (p[3] == 'x' || p[3] == 'x')
                            prm_cplusplus = TRUE;
                    }
                }
                else
                {
                    if (p[2] == '+' || p[2] == '+')
                    {
                        if (p[3] == '+' || p[3] == '+')
                            prm_cplusplus = TRUE;
                    }
                }
            }
        kwini();

        if (prm_cppfile)
        {
            if (!(cppFile = fopen(cppfile, "w")))
                fatal("Cannot open preprocessor file %s", cppfile);
        }
        if ((inputFile = srchpth(buffer, "", O_RDONLY | O_BINARY)) ==  - 1)
            fatal("Cannot open input file %s", buffer);
        infile = errfile = litlate(buffer);
        browse_startfile(infile);
        if ((outputFile = fopen(outfile,prm_asmfile ? "w" : "wb")) == 0)
        {
            close(inputFile);
            fatal("Cannot open output file %s", outfile);
        }
		setvbuf(outputFile,0,_IOFBF,32768);
        if (prm_asmfile)
            asm_header();
        if (prm_listfile)
        if (!(listFile = fopen(listfile, "w")))
        {
            close(inputFile);
            fclose(outputFile);
            fatal("Cannot open list file %s", listfile);
        } else {
            fprintf(listFile, "LADsoft C compiler Version %s - %s\n\n", version,
                clist->data);
        }
        if (prm_errfile)
        if (!(errFile = fopen(errorfile, "w")))
        {
            fclose(listFile);
            close(inputFile);
            fclose(outputFile);
            fatal("Cannot open error file %s", errorfile);
        }
#ifdef ICODE
        if (prm_icdfile) {
			if ((icdFile = fopen(icdfile,"w")) == 0)
    	    {
				fclose(errFile);
        	    fclose(listFile);
            	close(inputFile);
            	fclose(outputFile);
            	fatal("Cannot open output file %s", outfile);
        	}
			setvbuf(icdFile,0,_IOFBF,32768);
		}
#endif
        initerr();
        initsym();
        setglbdefs();
        installCPPBuiltins();
        getch();
        getsym();
        compile();
        summary();
        release_global();
        dumperrs(stdout);
        close(inputFile);
        //      if (prm_asmfile) {
        oflush(outputFile);
        close(outputFile);
        //      }
        if (prm_listfile)
            fclose(listFile);
        if (prm_errfile)
            fclose(errFile);
        if (prm_cppfile)
            fclose(cppFile);
#ifdef ICODE
		if (prm_icdfile)
			fclose(icdFile);
#endif
        clist = clist->link;

        /* Remove the ASM file if there are errors */
        if (total_errors)
            remove(outfile);

        /* Remove the ERR file if no warnings / errors */
        if (!errlist && prm_errfile)
            remove(errorfile);

        /* Flag to stop if there are any errors */
        stoponerr |= total_errors;
    }
    if (stoponerr)
        return (1);
    #ifdef i386
        else if (!prm_compileonly)
            return RunExternalFiles();
    #endif 
    else
        return (0);
}