URL https://opencores.org/ocsvn/light8080/light8080/trunk
Subversion Repositories light8080

[/] [light8080/] [trunk/] [tools/] [c80/] [c80.c] - Blame information for rev 71

Go to most recent revision | Details | Compare with Previous | View Log

//************************************************
//
//              Small-C Compiler 
// 
//              by Ron Cain 
// 
//************************************************
 
// with minor mods by RDK 
#define BANNER  " <><><>   Small-C  V1.2  DOS--CP/M Cross Compiler   <><><>"
#define VERSION " <><><><><>   CP/M Large String Space Version   <><><><><>"
#define AUTHOR  " <><><><><><><><><><>   By Ron Cain   <><><><><><><><><><>"
#define TLINE   " <><><><><><><><><><><><><><>X<><><><><><><><><><><><><><>"
 
/*      Define system dependent parameters      */
/*      Stand-alone definitions                 */
/* INCLUDE THE LIBRARY TO COMPILE THE COMPILER (RDK) */
/* #include smallc.lib */ /* small-c library included in source now */
/* IN DOS USE THE SMALL-C OBJ LIBRARY RATHER THAN IN-LINE ASSEMBLER */
#define NULL 0
#define eol 10 /* was 13 */
 
#include "stdio.h"  /* was <stdio.h> */
 
/*      Define the symbol table parameters      */
#define symsiz          16
#define symtbsz         5760
#define numglbs         300
#define startglb        symtab
#define endglb          startglb+numglbs*symsiz
#define startloc        endglb+symsiz
#define endloc          symtab+symtbsz-symsiz
 
/*      Define symbol table entry format        */
#define name            0
#define ident           9
#define type            10
#define storage         11
#define offset          12
#define initptr         14
 
/*      System wide name size (for symbols)     */
#define namesize        9
#define namemax         8
 
/*      Define possible entries for "ident"     */
#define variable        1
#define array           2
#define pointer         3
#define function        4
 
/*      Define possible entries for "type"      */
#define cchar           1
#define cint            2
#define cport           3 
 
/*      Define possible entries for "storage"   */
#define statik          1
#define stkloc          2
 
/*      Define the "while" statement queue      */
#define wqtabsz         300
#define wqsiz           4
#define wqmax           wq+wqtabsz-wqsiz
 
/*      Define entry offsets in while queue     */
#define wqsym           0
#define wqsp            1
#define wqloop          2
#define wqlab           3
 
/*      Define the literal pool                 */
#define litabsz         8000
#define litmax          litabsz-1
 
/*      Define the input line                   */
#define linesize        256
#define linemax         linesize-1
#define mpmax           linemax
 
/*      Define the macro (define) pool          */
#define macqsize        3000
#define macmax          macqsize-1
 
/*      Define statement types (tokens)         */
#define stif            1
#define stwhile         2
#define streturn        3
#define stbreak         4
#define stcont          5
#define stasm           6
#define stexp           7
 
/* Define how to carve up a name too long for the assembler */
#define asmpref         7
#define asmsuff         7
 
// define the global variable init values que size 
#define initqsz         8192
 
/*      Now reserve some storage words          */
char    symtab[symtbsz];        /* symbol table */
char    *glbptr,*locptr;        /* ptrs to next entries */
 
int             wq[wqtabsz];            /* while queue */
int             *wqptr;                         /* ptr to next entry */
 
char    litq[litabsz];          /* literal pool */
int             litptr;                         /* ptr to next entry */
 
char    macq[macqsize];         /* macro string buffer */
int             macptr;                         /* and its index */
 
char    inittbq[initqsz];       // init value buffer 
int             inittbptr;                      // and its index 
 
char    line[linesize];         /* parsing buffer */
char    mline[linesize];        /* temp macro buffer */
int             lptr,mptr;                      /* ptrs into each */
 
/*      Misc storage    */
int     nxtlab,         /* next avail label # */
        litlab,         /* label # assigned to literal pool */
        Zsp,            /* compiler relative stk ptr */
        argstk,         /* function arg sp */
        ncmp,           /* # open compound statements */
        errcnt,         /* # errors in compilation */
        errstop,        /* stop on error                        gtf 7/17/80 */
        eof,            /* set non-zero on final input eof */
        input,          /* iob # for input file */
        output,         /* iob # for output file (if any) */
        outputv,        /* output valid flag */
        input2,         /* iob # for "include" file */
        glbflag,        /* non-zero if internal globals */
        ctext,          /* non-zero to intermix c-source */
        cmode,          /* non-zero while parsing c-code */
                        /* zero when passing assembly code */
        lastst,         /* last executed statement type */
        mainflg,        /* output is to be first asm file       gtf 4/9/80 */
        saveout,        /* holds output ptr when diverted to console       */
                        /*                                      gtf 7/16/80 */
        fnstart,        /* line# of start of current fn.        gtf 7/2/80 */
        lineno,         /* line# in current file                gtf 7/2/80 */
        infunc,         /* "inside function" flag               gtf 7/2/80 */
        savestart,      /* copy of fnstart "    "               gtf 7/16/80 */
        saveline,       /* copy of lineno  "    "               gtf 7/16/80 */
        saveinfn;       /* copy of infunc  "    "               gtf 7/16/80 */
 
char   *currfn,         /* ptr to symtab entry for current fn.  gtf 7/17/80 */
       *savecurr;       /* copy of currfn for #include          gtf 7/17/80 */
char    *cptr;          /* work ptr to any char buffer */
int     *iptr;          /* work ptr to any int buffer */
 
// interactive mode flag 
int intmode;
// pointer array to input files list from argv[] 
#define MAXINFILES              64
char *infiles[MAXINFILES];
int filesnum, filesidx;
// initial stack pointer value 
int stackptr;
 
/*      >>>>> start cc1 <<<<<<          */
 
/*                                      */
/*      Compiler begins execution here  */
/*                                      */
void main(int argc, char *argv[])
{
int argi, phelp;
 
        glbptr=startglb;        /* clear global symbols */
        locptr=startloc;        /* clear local symbols */
        wqptr=wq;0;              /* clear while queue */
        macptr=0;                /* clear the macro pool */
        litptr=0;                /* clear literal pool */
        Zsp =0;                  /* stack ptr (relative) */
        errcnt=0;                /* no errors */
        errstop=0;               /* keep going after an error            gtf 7/17/80 */
        eof=0;                   /* not eof yet */
        input=0;         /* no input file */
        input2=0;                /* or include file */
        output=0;                /* no open units */
        outputv=0;               /* output is not valid */
        saveout=0;               /* no diverted output */
        ncmp=0;                  /* no open compound states */
        lastst=0;                /* no last statement yet */
        mainflg=0;               /* not first file to asm                gtf 4/9/80 */
        fnstart=0;               /* current "function" started at line 0 gtf 7/2/80 */
        lineno=0;                /* no lines read from file              gtf 7/2/80 */
        infunc=0;                /* not in function now                  gtf 7/2/80 */
        currfn=NULL;    /* no function yet                      gtf 7/2/80 */
        cmode=1;                /* enable preprocessing */
        stackptr=0;              /* default value of stack pointer */
        inittbptr=0;     // clear pointer to init array 
 
        intmode = 1;    // default mode is interactive mode 
        filesnum = 0;    // no input files for now 
        filesidx = 0;
 
        // print original banner 
        printf("\n");
        printf(" <><><><><><><><><><><><><><>X<><><><><><><><><><><><><><>\n");
        printf(" <><><>   Small-C  V1.2  DOS--CP/M Cross Compiler   <><><>\n");
        printf(" <><><><><><><><><><>   By Ron Cain   <><><><><><><><><><>\n");
        printf(" <><><><><>   CP/M Large String Space Version   <><><><><>\n");
        printf(" <><><><><><><><><><><><><><>X<><><><><><><><><><><><><><>\n");
 
        // print adapted banner and usage 
        printf("\n");
        printf(" <><><><><><><><><><><><><><>X<><><><><><><><><><><><><><>\n");
        printf(" <><><>  Small-C adapted for embedded systems by  <><><><>\n");
        printf(" <><><><><><><><><>  Moti  Litochevski  <><><><><><><><><>\n");
        printf(" <><><><><><> Version 0.1 (February 20, 2012) <><><><><><>\n");
        printf(" <><><><><><><><><><><><><><>X<><><><><><><><><><><><><><>\n");
        printf("\n");
        // check if command line options where specified 
        if (argc <= 1) {
                printf(" command line mode usage:\n");
                printf("      c80 -s<hexvalue> -o<filename> <input files>\n");
                printf(" options:\n");
                printf("      -s<hexvalue>   Initial stack pointer value in hex value.\n");
                printf("                     Example: -s800 will init the stack pointer\n");
                printf("                     to 0x800.\n");
                printf("      -o<filename>   Compiler output filename including extension.\n");
                printf(" \n");
        }
 
        // start from the first valid argument 
        argi = 1;
        phelp = 0;
    // loop through input options 
    while (argi < argc) {
            // copy pointer of the current option to the work buffer 
            cptr = argv[argi];
            // loop through input options 
            if (cptr[0] == '-') {
                    // compiler options 
                    if (cptr[1] == 's') {
                            // stack pointer address value 
                            sscanf(&cptr[2], "%x", &stackptr);
                        } else if (cptr[1] == 'o') {
                                // copy the output filename to the line 
                                strcpy(line, &cptr[2]);
                                // open output file 
                                openout(0);
                        } else if ((cptr[1] == 'h') | (cptr[1] == '?')) {
                                // sign that only help should be printed 
                                phelp = 1;
                    } else {
                            printf("error: illegal option.\n");
                    }
                } else {
                        // after all other options the list of input files is given and 
                        // compiler is operated in non-interactive mode 
                        intmode = 0;
 
                        // copy the input files names pointers to the local array 
                        for (filesnum=0; (argi < argc) && (filesnum < MAXINFILES); filesnum++) {
                                infiles[filesnum] = argv[argi];
                                argi++;
                        }
                }
                // update argument index 
                argi++;
    }
 
    // check if compiler should be started 
    if (!phelp) {
            // announce interactive mode compiler 
                printf(" Starting compiler in interactive mode.\n\n");
                // compiler body 
                ask();                  /* get user options */
                if (outputv == 0) openout(1);            /* get an output file */
                openin();               /* and initial input file */
                header();               /* intro code */
                parse();                /* process ALL input */
                dumplits();             /* then dump literal pool */
                dumpglbs();             /* and all static memory */
                trailer();              /* follow-up code */
                closeout();             /* close the output (if any) */
                errorsummary();         /* summarize errors (on console!) */
        }
        return;                 /* then exit to system */
}
 
/*                                      */
/*      Abort compilation               */
/*              gtf 7/17/80             */
zabort()
{
        if(input2)
                endinclude();
        if(input)
                fclose(input);
        closeout();
        toconsole();
        pl("Compilation aborted.");  nl();
        exit();
/* end zabort */}
 
/*                                      */
/*      Process all input text          */
/*                                      */
/* At this level, only static declarations, */
/*      defines, includes, and function */
/*      definitions are legal...        */
parse()
{
        while (eof==0)           /* do until no more input */
        {
                if(amatch("char",4)){declglb(cchar);ns();}
                else if(amatch("int",3)){declglb(cint);ns();}
                else if(amatch("port",4)){declglb(cport);ns();}
                else if(match("#asm"))doasm();
                else if(match("#include"))doinclude();
                else if(match("#define"))addmac();
                else newfunc();
                blanks();       /* force eof if pending */
        }
}
/*                                      */
/*      Dump the literal pool           */
/*                                      */
dumplits()
        {int j,k;
        if (litptr==0) return;   /* if nothing there, exit...*/
        printlabel(litlab);col();nl(); /* print literal label */
        k=0;                     /* init an index... */
        while (k<litptr)        /*      to loop with */
                {defbyte();     /* pseudo-op to define byte */
                j=10;           /* max bytes per line */
                while(j--)
                        {outdec((litq[k++]&127));
                        if ((j==0) | (k>=litptr))
                                {nl();          /* need <cr> */
                                break;
                                }
                        outbyte(',');   /* separate bytes */
                        }
                }
        }
/*                                      */
/*      Dump all static variables       */
/*                                      */
dumpglbs()
{
int j,dptr,idx;
 
        if (glbflag==0) return;  /* don't if user said no */
        cptr=startglb;
        while (cptr<glbptr) {
                if ((cptr[ident]!=function) && (cptr[type]!=cport)) {
                        // do if anything but function or port 
                        // output name as label ... 
                        outname(cptr);col();nl();
                        // calculate number of bytes 
                        j = ((cptr[offset]&255) + ((cptr[offset+1]&255)<<8));
                        if ((cptr[type]==cint) | (cptr[ident]==pointer))
                                j=j+j;  // 2 bytes for integer values 
                        // check if the global has an init value 
                        dptr = ((cptr[initptr]&255) + ((cptr[initptr+1]&255)<<8));
                        // the value below represent the -1 value 
                        if (dptr==0xffff) {
                                // no init value, use original storage definition 
                                // define storage 
                                defstorage();
                                outdec(j);      /* need that many */
                                nl();
                        }
                        else {
                                // define the data section 
                                defbyte();
                                // loop through init value 
                                idx=1;
                                while (j--) {
                                        // write the next byte 
                                        outdec(inittbq[dptr++]);
                                        if ((j==0) | (dptr>=inittbptr)) {
                                                nl();           /* need <cr> */
                                                break;
                                        }
                                        // every 10 values reopen the line 
                                        if (idx++ == 10) {
                                                // add <cr> and restart byte definition 
                                                nl();
                                                defbyte();
                                                idx=1;
                                        } else
                                                // separate bytes 
                                                outbyte(',');
                                }
                        }
                }
                cptr=cptr+symsiz;
        }
}
/*                                      */
/*      Report errors for user          */
/*                                      */
errorsummary()
{
        /* see if anything left hanging... */
        if (ncmp) error("missing closing bracket");
                /* open compound statement ... */
        printf("\nThere were %d errors in compilation.\n\n", errcnt);
}
 
/* Get options from user */
ask()
{
int k,num[1];
 
        kill();                 /* clear input line */
        // by default enabling C text in the output file in form of comments (for clarity) 
        ctext=1;        /* user said yes */
        // by default assuming all files are compiled together 
        glbflag=1;      /* define globals */
        mainflg=1;      /* first file to assembler */
        nxtlab =0;       /* start numbers at lowest possible */
        // compiler does noy pause on errors 
        errstop=0;
 
        litlab=getlabel();      /* first label=literal pool */
        kill();                 /* erase line */
}
 
/*                                      */
/*      Get output filename             */
/*                                      */
openout(char flag)
{
        if (flag) {
                kill();                 /* erase line */
                output=0;                /* start with none */
                pl("Output filename? "); /* ask...*/
                gets(line);     /* get a filename */
        }
        if(ch()==0)return;       /* none given... */
        /* if given, open */
        if((output=fopen(line,"w"))==NULL) {
                output=0;        /* can't open */
                error("Open failure!");
        } else
                outputv = 1;
        kill();                 /* erase line */
}
/*                                      */
/*      Get (next) input file           */
/*                                      */
openin()
{
        input=0;         /* none to start with */
        while (input==0) {       /* any above 1 allowed */
                kill();         /* clear line */
                // check if we are using interactive mode or not 
                if (intmode) {
                        // use the old style input file from the user 
                        if (eof) break; /* if user said none */
                        pl("Input filename? ");
                        gets(line);     /* get a name */
                        if (ch()==0)
                                {eof=1;break;} /* none given... */
                } else {
                        // copy the file names from the name array 
                        if (filesidx < filesnum) {
                                strcpy(line, infiles[filesidx]);
                                printf("Processing Input file %d: %s\n", filesidx, line);
                                filesidx++;
                        } else {
                                // no more files 
                                eof=1;
                                break;
                        }
                }
 
                if ((input=fopen(line,"r"))!=NULL)
                        newfile();                      /* gtf 7/16/80 */
                else {
                        input=0; /* can't open it */
                        pl("Open failure");
                }
        }
        kill();         /* erase line */
}
 
/*                                      */
/*      Reset line count, etc.          */
/*                      gtf 7/16/80     */
newfile()
{
        lineno  = 0;     /* no lines read */
        fnstart = 0;     /* no fn. start yet. */
        currfn  = NULL; /* because no fn. yet */
        infunc  = 0;     /* therefore not in fn. */
/* end newfile */}
 
/*                                      */
/*      Open an include file            */
/*                                      */
doinclude()
{
        blanks();       /* skip over to name */
 
        toconsole();                                    /* gtf 7/16/80 */
        outstr("#include "); outstr(line+lptr); nl();
        tofile();
 
        if(input2)                                      /* gtf 7/16/80 */
                error("Cannot nest include files");
        else if ((input2=fopen(line+lptr,"r"))==NULL) {
                input2=0;
                error("Open failure on include file");
        }
        else {
                saveline = lineno;
                savecurr = currfn;
                saveinfn = infunc;
                savestart= fnstart;
                newfile();
        }
        kill();         /* clear rest of line */
                        /* so next read will come from */
                        /* new file (if open */
}
 
/*                                      */
/*      Close an include file           */
/*                      gtf 7/16/80     */
endinclude()
{
        toconsole();
        outstr("#end include"); nl();
        tofile();
 
        input2  = 0;
        lineno  = saveline;
        currfn  = savecurr;
        infunc  = saveinfn;
        fnstart = savestart;
/* end endinclude */}
 
/*                                      */
/*      Close the output file           */
/*                                      */
closeout()
{
        tofile();       /* if diverted, return to file */
        if(output)fclose(output); /* if open, close it */
        output=0;                /* mark as closed */
}
/*                                      */
/*      Declare a static variable       */
/*        (i.e. define for use)         */
/*                                      */
/* makes an entry in the symbol table so subsequent */
/*  references can call symbol by name  */
declglb(typ)            /* typ is cchar or cint or cport (added by Moti Litchevski) */
        int typ;
{
int k,j,iptr,idx,num[1];
char sname[namesize];
 
        while (1) {
                while (1) {
                        if(endst())return;      /* do line */
                        k=1;            /* assume 1 element */
                        if(match("*"))  /* pointer ? */
                                j=pointer;      /* yes */
                        else
                                j=variable; /* no */
 
                        // added by Moti Litochevski 
                        if (match("(")) {
                                // make sure this option is only used for port definition 
                                if (typ != cport)
                                        error("port address definition is only used for port type");
                                // get port address 
                                k=portadr();
                                k=k&0xff;
                        } else if (typ == cport) {
                                error("port definition syntax error, need to define port address in brackets");
                        }
 
                        if (symname(sname)==0) /* name ok? */
                                illname(); /* no... */
                        if(findglb(sname)) /* already there? */
                                multidef(sname);
                        if (match("[")) {       /* array? */
                                if (typ==cport) error("port cannot be defined as an array");
                                k=needsub();    /* get size */
                                if(k)j=array;   /* !0=array */
                                else j=pointer; /* 0=ptr */
                        }
 
                        // check if the declared global has a default value 
                        if (match("=")) {
                                // check if variable type supports init 
                                if ((typ!=cchar) & (typ!=cint))
                                        error("variable type does not support init value");
 
                                // set the init pointer to the current init pointer 
                                iptr=inittbptr;
                                idx=0;
 
                                // new defined variable has a default init value 
                                // check if the variable is defined as string, list of values {} or a 
                                // single value
                                if (match("\"")) {
                                        // init value is defined as a string 
                                        // copy the string values to the init buffer 
                                        while (idx++ < k) {
                                                // check if new value is valid 
                                                if ((ch() != '"') & (ch() != 0))
                                                        inittbq[inittbptr++] = gch();
                                                else
                                                        inittbq[inittbptr++] = 0;
 
                                                // check that init buffer is full 
                                                if (inittbptr == initqsz) {
                                                        // clear the variable init pointer and print error message 
                                                        iptr=0xffff;
                                                        error("init buffer is full, variable will not be initialized");
                                                        // sign that init is done 
                                                        idx=k;
                                                }
                                        }
                                        // look for matching quote mark 
                                        if (match("\"")==0) {
                                                error("end of string expected");
                                        }
                                }
                                else if (match("{")) {
                                        // init value is defined as a list of values 
                                        // copy the list of values to the init buffer 
                                        while (idx++ < k) {
                                                // check if new value is valid 
                                                if ((ch() != '}') & (ch() != 0)) {
                                                        // make sure that the next value is a number 
                                                        if (!number(num) & !pstr(num))
                                                                error("could not find valid value in initialization list");
                                                }
                                                else
                                                        // use zero value as init 
                                                        num[0]=0;
 
                                                // save the values according to array type 
                                                if (typ==cint) {
                                                        inittbq[inittbptr++] = (char)(num[0]&255);
                                                        inittbq[inittbptr++] = (char)((num[0]>>8)&255);
                                                }
                                                else
                                                        inittbq[inittbptr++] = (char)(num[0]&255);
 
                                                // check that init buffer is full 
                                                if (inittbptr == initqsz) {
                                                        // clear the variable init pointer and print error message 
                                                        iptr=0xffff;
                                                        error("init buffer is full, variable will not be initialized");
                                                        // sign that init is done 
                                                        idx=k;
                                                }
                                                // remove comma if it is there 
                                                match(",");
                                        }
                                        // look for ending brackets 
                                        if (match("}")==0) {
                                                error("end of initialization list expected");
                                        }
                                }
                                else {
                                        // expecting a single input value 
                                        if (!number(num) & !pstr(num))
                                                error("could not find initialization value");
 
                                        // save the values according to variable type 
                                        if (typ==cint) {
                                                inittbq[inittbptr++] = (char)(num[0]&255);
                                                inittbq[inittbptr++] = (char)((num[0]>>8)&255);
                                        }
                                        else
                                                inittbq[inittbptr++] = (char)(num[0]&255);
                                        // update index 
                                        idx=1;
 
                                        // init to end of array is more than one 
                                        while (idx++ < k) {
                                                // fill the rest of the init list with zeros 
                                                if (typ==cint) {
                                                        inittbq[inittbptr++] = 0;
                                                        inittbq[inittbptr++] = 0;
                                                }
                                                else
                                                        inittbq[inittbptr++] = 0;
 
                                                // check that init buffer is full 
                                                if (inittbptr == initqsz) {
                                                        // clear the variable init pointer and print error message 
                                                        iptr=0xffff;
                                                        error("init buffer is full, variable will not be initialized");
                                                        // sign that init is done 
                                                        idx=k;
                                                }
                                        }
                                }
                        } else {
                                // no default value point init pointer to null 
                                iptr=0xffff;
                        }
                        // add symbol 
                        addglb(sname,j,typ,k,iptr);
                        break;
                }
                if (match(",")==0) return; /* more? */
        }
}
/*                                      */
/*      Declare local variables         */
/*      (i.e. define for use)           */
/*                                      */
/* works just like "declglb" but modifies machine stack */
/*      and adds symbol table entry with appropriate */
/*      stack offset to find it again                   */
declloc(typ)            /* typ is cchar or cint */
        int typ;
        {
        int k,j;char sname[namesize];
        while(1)
                {while(1)
                        {if(endst())return;
                        if(match("*"))
                                j=pointer;
                                else j=variable;
                        if (symname(sname)==0)
                                illname();
                        if(findloc(sname))
                                multidef(sname);
                        if (match("["))
                                {k=needsub();
                                if(k)
                                        {j=array;
                                        if(typ==cint)k=k+k;
                                        }
                                else
                                        {j=pointer;
                                        k=2;
                                        }
                                }
                        else
                                if((typ==cchar)
                                        &(j!=pointer))
                                        k=1;else k=2;
                        /* change machine stack */
                        Zsp=modstk(Zsp-k);
                        addloc(sname,j,typ,Zsp);
                        break;
                        }
                if (match(",")==0) return;
                }
        }
/*      >>>>>> start of cc2 <<<<<<<<    */
 
/*                                      */
/*      Get required array size         */
/*                                      */
/* invoked when declared variable is followed by "[" */
/*      this routine makes subscript the absolute */
/*      size of the array. */
needsub()
{
int num[1];
 
        if(match("]"))return 0;  /* null size */
        if (number(num)==0)      /* go after a number */
                {error("must be constant");     /* it isn't */
                num[0]=1;                /* so force one */
                }
        if (num[0]<0)
                {error("negative size illegal");
                num[0]=(-num[0]);
                }
        needbrack("]");         /* force single dimension */
        return num[0];           /* and return size */
}
//
// get array size function changed to get a port address 
//
portadr()
{
int num[1];
 
        if(match(")")) {
                error("port address value must be defined");
                return 0;        /* null size */
        }
        if (number(num)==0) {    /* go after a number */
                error("port address must be constant"); /* it isn't */
                num[0]=1;                /* so force one */
        }
        if (num[0]<0) {
                error("negative port address illegal");
                num[0]=(-num[0]);
        }
        needbrack(")");         /* force single dimension */
        return num[0];           /* and return size */
}
 
/*                                      */
/*      Begin a function                */
/*                                      */
/* Called from "parse" this routine tries to make a function */
/*      out of what follows.    */
newfunc()
        {
        char n[namesize];       /* ptr => currfn,  gtf 7/16/80 */
        if (symname(n)==0)
                {error("illegal function or declaration");
                kill(); /* invalidate line */
                return;
                }
        fnstart=lineno;         /* remember where fn began      gtf 7/2/80 */
        infunc=1;               /* note, in function now.       gtf 7/16/80 */
        if(currfn=findglb(n))   /* already in symbol table ? */
                {if(currfn[ident]!=function)multidef(n);
                        /* already variable by that name */
                else if(currfn[offset]==function)multidef(n);
                        /* already function by that name */
                else currfn[offset]=function;
                        /* otherwise we have what was earlier*/
                        /*  assumed to be a function */
                }
        /* if not in table, define as a function now */
        else currfn=addglb(n,function,cint,function,-1);
 
        toconsole();                                    /* gtf 7/16/80 */
        outstr("====== "); outstr(currfn+name); outstr("()"); nl();
        tofile();
 
        /* we had better see open paren for args... */
        if(match("(")==0)error("missing open paren");
        outname(n);col();nl();  /* print function name */
        argstk=0;                /* init arg count */
        while(match(")")==0)     /* then count args */
                /* any legal name bumps arg count */
                {if(symname(n))argstk=argstk+2;
                else{error("illegal argument name");junk();}
                blanks();
                /* if not closing paren, should be comma */
                if(streq(line+lptr,")")==0)
                        {if(match(",")==0)
                        error("expected comma");
                        }
                if(endst())break;
                }
        locptr=startloc;        /* "clear" local symbol table*/
        Zsp=0;                   /* preset stack ptr */
        while(argstk)
                /* now let user declare what types of things */
                /*      those arguments were */
                {if(amatch("char",4)){getarg(cchar);ns();}
                else if(amatch("int",3)){getarg(cint);ns();}
                else{error("wrong number args");break;}
                }
        if(statement()!=streturn) /* do a statement, but if */
                                /* it's a return, skip */
                                /* cleaning up the stack */
                {modstk(0);
                zret();
                }
        Zsp=0;                   /* reset stack ptr again */
        locptr=startloc;        /* deallocate all locals */
        infunc=0;                /* not in fn. any more          gtf 7/2/80 */
        }
/*                                      */
/*      Declare argument types          */
/*                                      */
/* called from "newfunc" this routine adds an entry in the */
/*      local symbol table for each named argument */
getarg(t)               /* t = cchar or cint */
        int t;
        {
        char n[namesize],c;int j;
        while(1)
                {if(argstk==0)return;    /* no more args */
                if(match("*"))j=pointer;
                        else j=variable;
                if(symname(n)==0) illname();
                if(findloc(n))multidef(n);
                if(match("["))  /* pointer ? */
                /* it is a pointer, so skip all */
                /* stuff between "[]" */
                        {while(inbyte()!=']')
                                if(endst())break;
                        j=pointer;
                        /* add entry as pointer */
                        }
                addloc(n,j,t,argstk);
                argstk=argstk-2;        /* cnt down */
                if(endst())return;
                if(match(",")==0)error("expected comma");
                }
        }
/*                                      */
/*      Statement parser                */
/*                                      */
/* called whenever syntax requires      */
/*      a statement.                     */
/*  this routine performs that statement */
/*  and returns a number telling which one */
statement()
{
        /* NOTE (RDK) --- On DOS there is no CPM function so just try */
        /* commenting it out for the first test compilation to see if */
        /* the compiler basic framework works OK in the DOS environment */
        /* if(cpm(11,0) & 1)    /* check for ctrl-C gtf 7/17/80 */
                /* if(getchar()==3) */
                        /* zabort(); */
 
        if ((ch()==0) & (eof)) return;
        else if(amatch("char",4))
                {declloc(cchar);ns();}
        else if(amatch("int",3))
                {declloc(cint);ns();}
        else if(match("{"))compound();
        else if(amatch("if",2))
                {doif();lastst=stif;}
        else if(amatch("while",5))
                {dowhile();lastst=stwhile;}
        else if(amatch("return",6))
                {doreturn();ns();lastst=streturn;}
        else if(amatch("break",5))
                {dobreak();ns();lastst=stbreak;}
        else if(amatch("continue",8))
                {docont();ns();lastst=stcont;}
        else if(match(";"));
        else if(match("#asm"))
                {doasm();lastst=stasm;}
        /* if nothing else, assume it's an expression */
        else{expression();ns();lastst=stexp;}
        return lastst;
}
/*                                      */
/*      Semicolon enforcer              */
/*                                      */
/* called whenever syntax requires a semicolon */
ns()    {if(match(";")==0)error("missing semicolon");}
/*                                      */
/*      Compound statement              */
/*                                      */
/* allow any number of statements to fall between "{}" */
compound()
        {
        ++ncmp;         /* new level open */
        while (match("}")==0) statement(); /* do one */
        --ncmp;         /* close current level */
        }
/*                                      */
/*              "if" statement          */
/*                                      */
doif()
        {
        int flev,fsp,flab1,flab2;
        flev=locptr;    /* record current local level */
        fsp=Zsp;                /* record current stk ptr */
        flab1=getlabel(); /* get label for false branch */
        test(flab1);    /* get expression, and branch false */
        statement();    /* if true, do a statement */
        Zsp=modstk(fsp);        /* then clean up the stack */
        locptr=flev;    /* and deallocate any locals */
        if (amatch("else",4)==0) /* if...else ? */
                /* simple "if"...print false label */
                {printlabel(flab1);col();nl();
                return;         /* and exit */
                }
        /* an "if...else" statement. */
        jump(flab2=getlabel()); /* jump around false code */
        printlabel(flab1);col();nl();   /* print false label */
        statement();            /* and do "else" clause */
        Zsp=modstk(fsp);                /* then clean up stk ptr */
        locptr=flev;            /* and deallocate locals */
        printlabel(flab2);col();nl();   /* print true label */
        }
/*                                      */
/*      "while" statement               */
/*                                      */
dowhile()
        {
        int wq[4];              /* allocate local queue */
        wq[wqsym]=locptr;       /* record local level */
        wq[wqsp]=Zsp;           /* and stk ptr */
        wq[wqloop]=getlabel();  /* and looping label */
        wq[wqlab]=getlabel();   /* and exit label */
        addwhile(wq);           /* add entry to queue */
                                /* (for "break" statement) */
        printlabel(wq[wqloop]);col();nl(); /* loop label */
        test(wq[wqlab]);        /* see if true */
        statement();            /* if so, do a statement */
        Zsp = modstk(wq[wqsp]); /* zap local vars: 9/25/80 gtf */
        jump(wq[wqloop]);       /* loop to label */
        printlabel(wq[wqlab]);col();nl(); /* exit label */
        locptr=wq[wqsym];       /* deallocate locals */
        delwhile();             /* delete queue entry */
        }
/*                                      */
/*      "return" statement              */
/*                                      */
doreturn()
        {
        /* if not end of statement, get an expression */
        if(endst()==0)expression();
        modstk(0);       /* clean up stk */
        zret();         /* and exit function */
        }
/*                                      */
/*      "break" statement               */
/*                                      */
dobreak()
        {
        int *ptr;
        /* see if any "whiles" are open */
        if ((ptr=readwhile())==0) return;        /* no */
        modstk((ptr[wqsp]));    /* else clean up stk ptr */
        jump(ptr[wqlab]);       /* jump to exit label */
        }
/*                                      */
/*      "continue" statement            */
/*                                      */
docont()
        {
        int *ptr;
        /* see if any "whiles" are open */
        if ((ptr=readwhile())==0) return;        /* no */
        modstk((ptr[wqsp]));    /* else clean up stk ptr */
        jump(ptr[wqloop]);      /* jump to loop label */
        }
/*                                      */
/*      "asm" pseudo-statement          */
/*                                      */
/* enters mode where assembly language statement are */
/*      passed intact through parser    */
doasm()
{
        cmode=0;         /* mark mode as "asm" */
        while (1) {
                finline();      /* get and print lines */
                if (match("#endasm")) break;    /* until... */
                if(eof)break;
                outstr(line);
                nl();
        }
        kill();         /* invalidate line */
        cmode=1;                /* then back to parse level */
}
/*      >>>>> start of cc3 <<<<<<<<<    */
 
/*                                      */
/*      Perform a function call         */
/*                                      */
/* called from heir11, this routine will either call */
/*      the named function, or if the supplied ptr is */
/*      zero, will call the contents of HL              */
callfunction(ptr)
        char *ptr;      /* symbol table entry (or 0) */
{       int nargs;
        nargs=0;
        blanks();       /* already saw open paren */
        if(ptr==0)zpush();       /* calling HL */
        while(streq(line+lptr,")")==0)
                {if(endst())break;
                expression();   /* get an argument */
                if(ptr==0)swapstk(); /* don't push addr */
                zpush();        /* push argument */
                nargs=nargs+2;  /* count args*2 */
                if (match(",")==0) break;
                }
        needbrack(")");
        if(ptr)zcall(ptr);
        else callstk();
        Zsp=modstk(Zsp+nargs);  /* clean up arguments */
}
junk()
{       if(an(inbyte()))
                while(an(ch()))gch();
        else while(an(ch())==0)
                {if(ch()==0)break;
                gch();
                }
        blanks();
}
endst()
{       blanks();
        return ((streq(line+lptr,";")|(ch()==0)));
}
illname()
{       error("illegal symbol name");junk();}
multidef(sname)
        char *sname;
{       error("already defined");
        comment();
        outstr(sname);nl();
}
needbrack(str)
        char *str;
{
        if (match(str)==0) {
                error("missing bracket");
                comment();outstr(str);nl();
        }
}
needlval()
{       error("must be lvalue");
}
findglb(sname)
        char *sname;
{       char *ptr;
        ptr=startglb;
        while(ptr!=glbptr) {
                if (astreq(sname,ptr,namemax)) return ptr;
                ptr=ptr+symsiz;
        }
        return 0;
}
findloc(sname)
        char *sname;
{       char *ptr;
        ptr=startloc;
        while (ptr!=locptr) {
                if(astreq(sname,ptr,namemax))return ptr;
                ptr=ptr+symsiz;
        }
        return 0;
}
addglb(sname,id,typ,value,iptr)
        char *sname,id,typ;
        int value,iptr;
{       char *ptr;
        if(cptr=findglb(sname))return cptr;
        if(glbptr>=endglb)
                {error("global symbol table overflow");
                return 0;
                }
        cptr=ptr=glbptr;
        while (an(*ptr++ = *sname++));  /* copy name */
        cptr[ident]=id;
        cptr[type]=typ;
        cptr[storage]=statik;
        cptr[offset]=value;
        cptr[offset+1]=value>>8;
        cptr[initptr]=iptr&255;
        cptr[initptr+1]=iptr>>8;
        glbptr=glbptr+symsiz;
        return cptr;
}
addloc(sname,id,typ,value)
        char *sname,id,typ;
        int value;
{       char *ptr;
        if(cptr=findloc(sname))return cptr;
        if(locptr>=endloc)
                {error("local symbol table overflow");
                return 0;
                }
        cptr=ptr=locptr;
        while(an(*ptr++ = *sname++));   /* copy name */
        cptr[ident]=id;
        cptr[type]=typ;
        cptr[storage]=stkloc;
        cptr[offset]=value;
        cptr[offset+1]=value>>8;
        locptr=locptr+symsiz;
        return cptr;
}
/* Test if next input string is legal symbol name */
symname(sname)
        char *sname;
{       int k;char c;
        blanks();
        if(alpha(ch())==0)return 0;
        k=0;
        while(an(ch()))sname[k++]=gch();
        sname[k]=0;
        return 1;
        }
/* Return next avail internal label number */
getlabel()
{       return(++nxtlab);
}
/* Print specified number as label */
printlabel(label)
        int label;
{       outasm("cc");
        outdec(label);
}
/* Test if given character is alpha */
alpha(c)
        char c;
{       c=c&127;
        return(((c>='a')&(c<='z'))|
                ((c>='A')&(c<='Z'))|
                (c=='_'));
}
// Test if given character is numeric 
numeric(c)
        char c;
{       c=c&127;
        return ((c>='0')&(c<='9'));
}
// Test if given character is hexadecimal 
hexnum(c)
        char c;
{       c=c&127;
        return (((c>='0')&(c<='9')) | ((c>='a')&(c<='f')) | ((c>='A')&(c<='F')));
}
/* Test if given character is alphanumeric */
an(c)
        char c;
{       return((alpha(c))|(numeric(c)));
}
/* Print a carriage return and a string only to console */
pl(str)
        char *str;
{       int k;
        k=0;
        putchar(eol);
        while(str[k])putchar(str[k++]);
}
addwhile(ptr)
        int ptr[];
 {
        int k;
        if (wqptr==wqmax)
                {error("too many active whiles");return;}
        k=0;
        while (k<wqsiz)
                {*wqptr++ = ptr[k++];}
}
delwhile()
        {if(readwhile()) wqptr=wqptr-wqsiz;
        }
readwhile()
 {
        if (wqptr==wq){error("no active whiles");return 0;}
        else return (wqptr-wqsiz);
 }
ch()
{       return(line[lptr]&127);
}
nch()
{       if(ch()==0)return 0;
                else return(line[lptr+1]&127);
}
gch()
{       if(ch()==0)return 0;
                else return(line[lptr++]&127);
}
kill()
{       lptr=0;
        line[lptr]=0;
}
inbyte()
{
        while(ch()==0)
                {if (eof) return 0;
                finline();
                preprocess();
                }
        return gch();
}
inchar()
{
        if(ch()==0)finline();
        if(eof)return 0;
        return(gch());
}
finline()
{
        int k,unit;
        while(1)
                {if (input==0)openin();
                if(eof)return;
                if((unit=input2)==0)unit=input;
                kill();
                while((k=getc(unit))>0)
                        {if((k==eol)|(lptr>=linemax))break;
                        line[lptr++]=k;
                        }
                line[lptr]=0;    /* append null */
                lineno++;       /* read one more line           gtf 7/2/80 */
                if(k<=0)
                        {fclose(unit);
                        if(input2)endinclude();         /* gtf 7/16/80 */
                                else input=0;
                        }
                if(lptr)
                        {if((ctext)&(cmode))
                                {comment();
                                outstr(line);
                                nl();
                                }
                        lptr=0;
                        return;
                        }
                }
}
/*      >>>>>> start of cc4 <<<<<<<     */
 
keepch(c)
        char c;
{       mline[mptr]=c;
        if(mptr<mpmax)mptr++;
        return c;
}
preprocess()
{       int k;
        char c,sname[namesize];
        if(cmode==0)return;
        mptr=lptr=0;
        while(ch())
                {if((ch()==' ')|(ch()==9))
                        {keepch(' ');
                        while((ch()==' ')|
                                (ch()==9))
                                gch();
                        }
                else if(ch()=='"')
                        {keepch(ch());
                        gch();
                        while(ch()!='"')
                                {if(ch()==0)
                                  {error("missing quote");
                                  break;
                                  }
                                keepch(gch());
                                }
                        gch();
                        keepch('"');
                        }
                else if(ch()==39)
                        {keepch(39);
                        gch();
                        while(ch()!=39)
                                {if(ch()==0)
                                  {error("missing apostrophe");
                                  break;
                                  }
                                keepch(gch());
                                }
                        gch();
                        keepch(39);
                        }
                else if((ch()=='/')&(nch()=='/')) {
                        // delete the entire line 
                        kill();
                }
                else if((ch()=='/')&(nch()=='*')) {
                        inchar();inchar();
                        while (((ch()=='*') & (nch()=='/'))==0) {
                                if(ch()==0)finline();
                                        else inchar();
                                if(eof)break;
                        }
                        inchar();inchar();
                }
                else if(alpha(ch()))    /* from an(): 9/22/80 gtf */
                        {k=0;
                        while(an(ch()))
                                {if(k<namemax)sname[k++]=ch();
                                gch();
                                }
                        sname[k]=0;
                        if(k=findmac(sname))
                                while(c=macq[k++])
                                        keepch(c);
                        else
                                {k=0;
                                while(c=sname[k++])
                                        keepch(c);
                                }
                        }
                else keepch(gch());
                }
        keepch(0);
        if(mptr>=mpmax)error("line too long");
        lptr=mptr=0;
        while(line[lptr++]=mline[mptr++]);
        lptr=0;
        }
addmac()
{
char sname[namesize];
int k;
 
        if (symname(sname)==0) {
                illname();
                kill();
                return;
        }
        k=0;
        while (putmac(sname[k++]));
        while (ch()==' ' | ch()==9) gch();
        while (putmac(gch()));
        if (macptr>=macmax) error("macro table full");
}
putmac(c)
        char c;
{
        macq[macptr]=c;
        if(macptr<macmax)macptr++;
        return c;
}
findmac(sname)
        char *sname;
{       int k;
        k=0;
        while (k<macptr) {
                if (astreq(sname, macq+k, namemax)) {
                        while(macq[k++]);
                        return k;
                        }
                while(macq[k++]);
                while(macq[k++]);
        }
        return 0;
}
/* direct output to console             gtf 7/16/80 */
toconsole()
{
        saveout = output;
        output = 0;
/* end toconsole */}
 
/* direct output back to file           gtf 7/16/80 */
tofile()
{
        if(saveout)
                output = saveout;
        saveout = 0;
/* end tofile */}
 
outbyte(c)
        char c;
{
        if(c==0)return 0;
        if(output)
                {if((putc(c,output))<=0)
                        {closeout();
                        error("Output file error");
                        zabort();                       /* gtf 7/17/80 */
                        }
                }
        else putchar(c);
        return c;
}
outstr(ptr)
        char ptr[];
 {
        int k;
        k=0;
        while(outbyte(ptr[k++]));
 }
 
/* write text destined for the assembler to read */
/* (i.e. stuff not in comments)                 */
/*  gtf  6/26/80 */
outasm(ptr)
char *ptr;
{
        while(outbyte(lower(*ptr++)));
/* end outasm */}
 
nl()
        {outbyte(eol);}
tab()
        {outbyte(9);}
col()
        {outbyte(58);}
bell()                          /* gtf 7/16/80 */
        {outbyte(7);}
/*                              replaced 7/2/80 gtf
 * error(ptr)
 *      char ptr[];
 * {
 *      int k;
 *      comment();outstr(line);nl();comment();
 *      k=0;
 *      while(k<lptr)
 *              {if(line[k]==9) tab();
 *                      else outbyte(' ');
 *              ++k;
 *              }
 *      outbyte('^');
 *      nl();comment();outstr("******  ");
 *      outstr(ptr);
 *      outstr("  ******");
 *      nl();
 *      ++errcnt;
 * }
 */
 
error(ptr)
char ptr[];
{       int k;
        char junk[81];
 
        toconsole();
        bell();
        outstr("Line "); outdec(lineno); outstr(", ");
        if(infunc==0)
                outbyte('(');
        if(currfn==NULL)
                outstr("start of file");
        else    outstr(currfn+name);
        if(infunc==0)
                outbyte(')');
        outstr(" + ");
        outdec(lineno-fnstart);
        outstr(": ");  outstr(ptr);  nl();
 
        outstr(line); nl();
 
        k=0;     /* skip to error position */
        while(k<lptr){
                if(line[k++]==9)
                        tab();
                else    outbyte(' ');
                }
        outbyte('^');  nl();
        ++errcnt;
 
        if(errstop){
                pl("Continue (Y,n,g) ? ");
                gets(junk);
                k=junk[0];
                if((k=='N') | (k=='n'))
                        zabort();
                if((k=='G') | (k=='g'))
                        errstop=0;
                }
        tofile();
/* end error */}
 
ol(ptr)
        char ptr[];
{
        ot(ptr);
        nl();
}
ot(ptr)
        char ptr[];
{
        tab();
        outasm(ptr);
}
streq(str1,str2)
        char str1[],str2[];
{
int k;
 
        k=0;
        while (str2[k])
                {if ((str1[k])!=(str2[k])) return 0;
                k++;
                }
        return k;
}
astreq(str1,str2,len)
        char str1[],str2[];int len;
{
int k;
 
        k=0;
        while (k<len) {
                if ((str1[k])!=(str2[k]))break;
                if(str1[k]==0)break;
                if(str2[k]==0)break;
                k++;
        }
        if (an(str1[k]))return 0;
        if (an(str2[k]))return 0;
        return k;
}
match(lit)
        char *lit;
{
        int k;
        blanks();
        if (k=streq(line+lptr,lit)) {
                lptr=lptr+k;
                return 1;
        }
        return 0;
}
amatch(lit,len)
        char *lit;int len;
 {
        int k;
        blanks();
        if (k=astreq(line+lptr,lit,len))
                {lptr=lptr+k;
                while(an(ch())) inbyte();
                return 1;
                }
        return 0;
 }
blanks()
{
        while (1) {
                while (ch()==0) {
                        finline();
                        preprocess();
                        if(eof)break;
                }
                if (ch()==' ') gch();
                else if (ch()==9) gch();
                else return;
        }
}
/* output a decimal number - rewritten 4/1/81 gtf */
outdec(n)
int n;
{
        if(n<0)
                outbyte('-');
        else    n = -n;
        outint(n);
/* end outdec */}
 
outint(n)       /* added 4/1/81 */
int n;
{       int q;
 
        q = n/10;
        if(q) outint(q);
        outbyte('0'-(n-q*10));
/* end outint */}
 
/* return the length of a string */
/* gtf 4/8/80 */
strlen(s)
char *s;
{       char *t;
 
        t = s;
        while(*s) s++;
        return(s-t);
/* end strlen */}
 
/* convert lower case to upper */
/* gtf 6/26/80 */
raise(c)
char c;
{
        if((c>='a') & (c<='z'))
                c = c - 'a' + 'A';
        return(c);
/* end raise */}
 
/* convert upper case to lower */
/* ml 28/2/2012 */
lower(c)
char c;
{
        if((c>='A') & (c<='Z'))
                c = c - 'A' + 'a';
        return(c);
/* end raise */}
 
/* ------------------------------------------------------------- */
 
/*      >>>>>>> start of cc5 <<<<<<<    */
 
/* as of 5/5/81 rj */
 
expression()
{
        int lval[2];
        if(heir1(lval))rvalue(lval);
}
heir1(lval)
        int lval[];
{
        int k,lval2[2];
        k=heir2(lval);
        if (match("="))
                {if(k==0){needlval();return 0;}
                if (lval[1])zpush();
                if(heir1(lval2))rvalue(lval2);
                store(lval);
                return 0;
                }
        else return k;
}
heir2(lval)
        int lval[];
{       int k,lval2[2];
        k=heir3(lval);
        blanks();
        if(ch()!='|')return k;
        if(k)rvalue(lval);
        while(1)
                {if (match("|"))
                        {zpush();
                        if(heir3(lval2)) rvalue(lval2);
                        zpop();
                        zor();
                        }
                else return 0;
                }
}
heir3(lval)
        int lval[];
{       int k,lval2[2];
        k=heir4(lval);
        blanks();
        if(ch()!='^')return k;
        if(k)rvalue(lval);
        while(1)
                {if (match("^"))
                        {zpush();
                        if(heir4(lval2))rvalue(lval2);
                        zpop();
                        zxor();
                        }
                else return 0;
                }
}
heir4(lval)
        int lval[];
{       int k,lval2[2];
        k=heir5(lval);
        blanks();
        if(ch()!='&')return k;
        if(k)rvalue(lval);
        while(1)
                {if (match("&"))
                        {zpush();
                        if(heir5(lval2))rvalue(lval2);
                        zpop();
                        zand();
                        }
                else return 0;
                }
}
heir5(lval)
        int lval[];
{
        int k,lval2[2];
        k=heir6(lval);
        blanks();
        if((streq(line+lptr,"==")==0)&
                (streq(line+lptr,"!=")==0))return k;
        if(k)rvalue(lval);
        while(1)
                {if (match("=="))
                        {zpush();
                        if(heir6(lval2))rvalue(lval2);
                        zpop();
                        zeq();
                        }
                else if (match("!="))
                        {zpush();
                        if(heir6(lval2))rvalue(lval2);
                        zpop();
                        zne();
                        }
                else return 0;
                }
}
heir6(lval)
        int lval[];
{
        int k,lval2[2];
        k=heir7(lval);
        blanks();
        if((streq(line+lptr,"<")==0)&
                (streq(line+lptr,">")==0)&
                (streq(line+lptr,"<=")==0)&
                (streq(line+lptr,">=")==0))return k;
                if(streq(line+lptr,">>"))return k;
                if(streq(line+lptr,"<<"))return k;
        if(k)rvalue(lval);
        while(1)
                {if (match("<="))
                        {zpush();
                        if(heir7(lval2))rvalue(lval2);
                        zpop();
                        if(cptr=lval[0])
                                if(cptr[ident]==pointer)
                                {ule();
                                continue;
                                }
                        if(cptr=lval2[0])
                                if(cptr[ident]==pointer)
                                {ule();
                                continue;
                                }
                        zle();
                        }
                else if (match(">="))
                        {zpush();
                        if(heir7(lval2))rvalue(lval2);
                        zpop();
                        if(cptr=lval[0])
                                if(cptr[ident]==pointer)
                                {uge();
                                continue;
                                }
                        if(cptr=lval2[0])
                                if(cptr[ident]==pointer)
                                {uge();
                                continue;
                                }
                        zge();
                        }
                else if((streq(line+lptr,"<"))&
                        (streq(line+lptr,"<<")==0))
                        {inbyte();
                        zpush();
                        if(heir7(lval2))rvalue(lval2);
                        zpop();
                        if(cptr=lval[0])
                                if(cptr[ident]==pointer)
                                {ult();
                                continue;
                                }
                        if(cptr=lval2[0])
                                if(cptr[ident]==pointer)
                                {ult();
                                continue;
                                }
                        zlt();
                        }
                else if((streq(line+lptr,">"))&
                        (streq(line+lptr,">>")==0))
                        {inbyte();
                        zpush();
                        if(heir7(lval2))rvalue(lval2);
                        zpop();
                        if(cptr=lval[0])
                                if(cptr[ident]==pointer)
                                {ugt();
                                continue;
                                }
                        if(cptr=lval2[0])
                                if(cptr[ident]==pointer)
                                {ugt();
                                continue;
                                }
                        zgt();
                        }
                else return 0;
                }
}
/*      >>>>>> start of cc6 <<<<<<      */
 
heir7(lval)
        int lval[];
{
        int k,lval2[2];
        k=heir8(lval);
        blanks();
        if((streq(line+lptr,">>")==0)&
                (streq(line+lptr,"<<")==0))return k;
        if(k)rvalue(lval);
        while(1)
                {if (match(">>"))
                        {zpush();
                        if(heir8(lval2))rvalue(lval2);
                        zpop();
                        asr();
                        }
                else if (match("<<"))
                        {zpush();
                        if(heir8(lval2))rvalue(lval2);
                        zpop();
                        asl();
                        }
                else return 0;
                }
}
heir8(lval)
        int lval[];
{
        int k,lval2[2];
        k=heir9(lval);
        blanks();
        if((ch()!='+')&(ch()!='-'))return k;
        if(k)rvalue(lval);
        while(1)
                {if (match("+"))
                        {zpush();
                        if(heir9(lval2))rvalue(lval2);
                        if(cptr=lval[0])
                                if((cptr[ident]==pointer)&
                                (cptr[type]==cint))
                                doublereg();
                        zpop();
                        zadd();
                        }
                else if (match("-"))
                        {zpush();
                        if(heir9(lval2))rvalue(lval2);
                        if(cptr=lval[0])
                                if((cptr[ident]==pointer)&
                                (cptr[type]==cint))
                                doublereg();
                        zpop();
                        zsub();
                        }
                else return 0;
                }
}
heir9(lval)
        int lval[];
{
        int k,lval2[2];
        k=heir10(lval);
        blanks();
        if((ch()!='*')&(ch()!='/')&
                (ch()!='%'))return k;
        if(k)rvalue(lval);
        while(1)
                {if (match("*"))
                        {zpush();
                        if(heir9(lval2))rvalue(lval2);
                        zpop();
                        mult();
                        }
                else if (match("/"))
                        {zpush();
                        if(heir10(lval2))rvalue(lval2);
                        zpop();
                        div();
                        }
                else if (match("%"))
                        {zpush();
                        if(heir10(lval2))rvalue(lval2);
                        zpop();
                        zmod();
                        }
                else return 0;
                }
}
heir10(lval)
        int lval[];
{
        int k;
        char *ptr;
        if(match("++"))
                {if((k=heir10(lval))==0)
                        {needlval();
                        return 0;
                        }
                if(lval[1])zpush();
                rvalue(lval);
                inc();
                ptr=lval[0];
                if((ptr[ident]==pointer)&
                        (ptr[type]==cint))
                                inc();
                store(lval);
                return 0;
                }
        else if(match("--"))
                {if((k=heir10(lval))==0)
                        {needlval();
                        return 0;
                        }
                if(lval[1])zpush();
                rvalue(lval);
                dec();
                ptr=lval[0];
                if((ptr[ident]==pointer)&
                        (ptr[type]==cint))
                                dec();
                store(lval);
                return 0;
                }
        else if (match("-"))
                {k=heir10(lval);
                if (k) rvalue(lval);
                neg();
                return 0;
                }
        else if(match("*"))
                {k=heir10(lval);
                if(k)rvalue(lval);
                lval[1]=cint;
                if(ptr=lval[0])lval[1]=ptr[type];
                lval[0]=0;
                return 1;
                }
        else if(match("&"))
                {k=heir10(lval);
                if(k==0)
                        {error("illegal address");
                        return 0;
                        }
                else if(lval[1])return 0;
                else
                        {immed();
                        outname(ptr=lval[0]);
                        nl();
                        lval[1]=ptr[type];
                        return 0;
                        }
                }
        else
                {k=heir11(lval);
                if(match("++"))
                        {if(k==0)
                                {needlval();
                                return 0;
                                }
                        if(lval[1])zpush();
                        rvalue(lval);
                        inc();
                        ptr=lval[0];
                        if((ptr[ident]==pointer)&
                                (ptr[type]==cint))
                                        inc();
                        store(lval);
                        dec();
                        if((ptr[ident]==pointer)&
                                (ptr[type]==cint))
                                dec();
                        return 0;
                        }
                else if(match("--"))
                        {if(k==0)
                                {needlval();
                                return 0;
                                }
                        if(lval[1])zpush();
                        rvalue(lval);
                        dec();
                        ptr=lval[0];
                        if((ptr[ident]==pointer)&
                                (ptr[type]==cint))
                                        dec();
                        store(lval);
                        inc();
                        if((ptr[ident]==pointer)&
                                (ptr[type]==cint))
                                inc();
                        return 0;
                        }
                else return k;
                }
        }
/*      >>>>>> start of cc7 <<<<<<      */
 
heir11(lval)
        int *lval;
{       int k;char *ptr;
        k=primary(lval);
        ptr=lval[0];
        blanks();
        if((ch()=='[')|(ch()=='('))
        while(1)
                {if(match("["))
                        {if(ptr==0)
                                {error("can't subscript");
                                junk();
                                needbrack("]");
                                return 0;
                                }
                        else if(ptr[ident]==pointer)rvalue(lval);
                        else if(ptr[ident]!=array)
                                {error("can't subscript");
                                k=0;
                                }
                        zpush();
                        expression();
                        needbrack("]");
                        if(ptr[type]==cint)doublereg();
                        zpop();
                        zadd();
                        lval[1]=ptr[type];
                                /* 4/1/81 - after subscripting, not ptr anymore */
                        lval[0]=0;
                        k=1;
                        }
                else if(match("("))
                        {if(ptr==0)
                                {callfunction(0);
                                }
                        else if(ptr[ident]!=function)
                                {rvalue(lval);
                                callfunction(0);
                                }
                        else callfunction(ptr);
                        k=lval[0]=0;
                        }
                else return k;
                }
        if(ptr==0)return k;
        if(ptr[ident]==function)
                {immed();
                outname(ptr);
                nl();
                return 0;
                }
        return k;
}
primary(lval)
        int *lval;
{       char *ptr,sname[namesize];int num[1];
        int k;
        if(match("("))
                {k=heir1(lval);
                needbrack(")");
                return k;
                }
        if(symname(sname))
                {if(ptr=findloc(sname))
                        {getloc(ptr);
                        lval[0]=ptr;
                        lval[1]=ptr[type];
                        if(ptr[ident]==pointer)lval[1]=cint;
                        if(ptr[ident]==array)return 0;
                                else return 1;
                        }
                if(ptr=findglb(sname))
                        if(ptr[ident]!=function)
                        {lval[0]=ptr;
                        lval[1]=0;
                        if(ptr[ident]!=array)return 1;
                        immed();
                        outname(ptr);nl();
                        lval[1]=ptr[type];
                        return 0;
                        }
                ptr=addglb(sname,function,cint,0,-1);
                lval[0]=ptr;
                lval[1]=0;
                return 0;
                }
        if(constant(num))
                return(lval[0]=lval[1]=0);
        else
                {error("invalid expression");
                immed();outdec(0);nl();
                junk();
                return 0;
                }
        }
store(lval)
        int *lval;
{       if (lval[1]==0)putmem(lval[0]);
        else putstk(lval[1]);
}
rvalue(lval)
        int *lval;
{       if((lval[0] != 0) & (lval[1] == 0))
                getmem(lval[0]);
                else indirect(lval[1]);
}
test(label)
        int label;
{
        needbrack("(");
        expression();
        needbrack(")");
        testjump(label);
}
constant(val)
        int val[];
{
        if (number(val)) {
                immed();
                outdec(val[0]);
        }
        else if (pstr(val)) {
                immed();
                outdec(val[0]);
        }
        else if (qstr(val)) {
                immed();
                printlabel(litlab);
                outbyte('+');
                outdec(val[0]);
        }
        else
                return 0;
        nl();
        return 1;
}
// get a numeric value from the source file 
number(val)
int val[];
{
int k,minus;
char c;
 
        k=minus=1;
        while (k) {
                k=0;
                if (match("+")) k=1;
                if (match("-")) {
                        minus=(-minus);
                        k=1;
                }
        }
        // check if hexadecimal value 
        if ((ch()=='0') & (nch()=='x')) {
                // remove first two characters ("0x") 
                inchar();inchar();
                // make sure the next value is legal 
                if (hexnum(ch())==0) return 0;
                // continue to read hexadecimal value 
                while (hexnum(ch())) {
                        c=raise(inbyte());
                        if (numeric(c)!=0)
                                k=k*16+(c-'0');
                        else
                                k=k*16+(c-'A')+10;
                }
                if (minus<0) k=(-k);
                val[0]=k;
                return 1;
        }
        // check if decimal value 
        else if (numeric(ch())!=0) {
                while (numeric(ch())) {
                        c=inbyte();
                        k=k*10+(c-'0');
                }
                if (minus<0) k=(-k);
                val[0]=k;
                return 1;
        }
        else
                return 0;
}
pstr(val)
int val[];
{
int k;
char c;
 
        k=0;
        if (match("'")==0) return 0;
        while((c=gch())!=39)
                k=(k&255)*256 + (c&127);
        val[0]=k;
        return 1;
}
qstr(val)
int val[];
{
char c;
 
        if (match("\"")==0) return 0;
        val[0]=litptr;
        while (ch()!='"')
                {if(ch()==0)break;
                if(litptr>=litmax)
                        {error("string space exhausted");
                        while(match("\"")==0)
                                if(gch()==0)break;
                        return 1;
                        }
                litq[litptr++]=gch();
                }
        gch();
        litq[litptr++]=0;
        return 1;
}
/*      >>>>>> start of cc8 <<<<<<<     */
 
/* Begin a comment line for the assembler */
comment()
{       outbyte(';');
}
 
/* Put out assembler info before any code is generated */
header()
{       comment();
        outstr(BANNER);
        nl();
        comment();
        outstr(VERSION);
        nl();
        comment();
        outstr(AUTHOR);
        nl();
        comment();
        nl();
        if (mainflg) {          /* do stuff needed for first */
                ol("code");
                ol("org #0000"); /* assembler file. */
                ot("ld hl,"); outdec(stackptr); nl();   /* set up stack */
                ol("ld sp,hl");
                zcall("main");  /* call the code generated by small-c */
        }
}
/* Print any assembler stuff needed after all code */
trailer()
{       /* ol("END"); */        /*...note: commented out! */
 
        nl();                   /* 6 May 80 rj errorsummary() now goes to console */
        comment();
        outstr(" --- End of Compilation ---");
        nl();
}
/* Print out a name such that it won't annoy the assembler */
/*      (by matching anything reserved, like opcodes.) */
/*      gtf 4/7/80 */
outname(sname)
char *sname;
{       int len, i,j;
 
        outasm("__");
        len = strlen(sname);
        if (len>(asmpref+asmsuff)) {
                i = asmpref;
                len = len-asmpref-asmsuff;
                while(i-- > 0)
                        outbyte(lower(*sname++));
                while(len-- > 0)
                        sname++;
                while(*sname)
                        outbyte(lower(*sname++));
                }
        else    outasm(sname);
/* end outname */}
/* Fetch a static memory cell into the primary register */
getmem(sym)
        char *sym;
{
int padr;
 
        if ((sym[ident]!=pointer)&(sym[type]==cchar)) {
                ot("ld a,(");
                outname(sym+name);
                outasm(")");
                nl();
                callrts("ccsxt");
        } else if (sym[type]==cport) {
                padr=sym[offset] & 0xff;
                ot("in a,(");outdec(padr);outasm(")");nl();
                callrts("ccsxt");
        } else {
                ot("ld hl,(");
                outname(sym+name);
                outasm(")");
                nl();
        }
}
/* Fetch the address of the specified symbol */
/*      into the primary register */
getloc(sym)
        char *sym;
{
int off_val;
 
        immed();
        off_val = ((sym[offset]&255)+((sym[offset+1]&255)<<8))-Zsp;
        off_val &= 0xffff;
        outdec(off_val);
        nl();
        ol("add hl,sp");
}
/* Store the primary register into the specified */
/*      static memory cell */
putmem(sym)
        char *sym;
{
int padr;
 
        if((sym[ident]!=pointer)&(sym[type]==cchar)) {
                ol("ld a,l");
                ot("ld (");
                outname(sym+name);
                outasm("),a");
        } else if (sym[type]==cport) {
                padr=sym[offset] & 0xff;
                ol("ld a,l");
                ot("out (");outdec(padr);outasm("),a");nl();
        } else {
                ot("ld (");
                outname(sym+name);
                outasm("),hl");
        }
 
        nl();
        }
/* Store the specified object type in the primary register */
/*      at the address on the top of the stack */
putstk(typeobj)
char typeobj;
{       zpop();
        if(typeobj==cint)
                callrts("ccpint");
        else {  ol("ld a,l");           /* per Ron Cain: gtf 9/25/80 */
                ol("ld (de),a");
                }
        }
/* Fetch the specified object type indirect through the */
/*      primary register into the primary register */
indirect(typeobj)
        char typeobj;
{       if(typeobj==cchar)callrts("ccgchar");
                else callrts("ccgint");
}
/* Swap the primary and secondary registers */
swap()
{       ol("ex de,hl");
}
/* Print partial instruction to get an immediate value */
/*      into the primary register */
immed()
{       ot("ld hl,");
}
/* Push the primary register onto the stack */
zpush()
{       ol("push hl");
        Zsp=Zsp-2;
}
/* Pop the top of the stack into the secondary register */
zpop()
{       ol("pop de");
        Zsp=Zsp+2;
}
/* Swap the primary register and the top of the stack */
swapstk()
{       ol("ex (sp),hl");
}
/* Call the specified subroutine name */
zcall(sname)
        char *sname;
{       ot("call ");
        outname(sname);
        nl();
}
/* Call a run-time library routine */
callrts(sname)
char *sname;
{
        ot("call ");
        outasm(sname);
        nl();
/*end callrts*/}
 
/* Return from subroutine */
zret()
{       ol("ret");
}
/* Perform subroutine call to value on top of stack */
callstk()
{       immed();
        outasm("$+5");
        nl();
        swapstk();
        ol("jp (hl)");
        Zsp=Zsp+2; /* corrected 5 May 81 rj */
        }
/* Jump to specified internal label number */
jump(label)
        int label;
{       ot("jp ");
        printlabel(label);
        nl();
        }
/* Test the primary register and jump if false to label */
testjump(label)
        int label;
{       ol("ld a,h");
        ol("or l");
        ot("jp z,");
        printlabel(label);
        nl();
        }
/* Print pseudo-op to define a byte */
defbyte()
{       ot("db ");
}
/*Print pseudo-op to define storage */
defstorage()
{       ot("ds ");
}
/* Print pseudo-op to define a word */
defword()
{       ot("dw ");
}
/* Modify the stack pointer to the new value indicated */
modstk(newsp)
        int newsp;
 {      int k;
        k=newsp-Zsp;
        if(k==0)return newsp;
        if(k>=0)
                {if(k<7)
                        {if(k&1)
                                {ol("inc sp");
                                k--;
                                }
                        while(k)
                                {ol("pop bc");
                                k=k-2;
                                }
                        return newsp;
                        }
                }
        if(k<0)
                {if(k>-7)
                        {if(k&1)
                                {ol("dec sp");
                                k++;
                                }
                        while(k)
                                {ol("push bc");
                                k=k+2;
                                }
                        return newsp;
                        }
                }
        swap();
        immed();outdec(k);nl();
        ol("add hl,sp");
        ol("ld sp,hl");
        swap();
        return newsp;
}
/* Double the primary register */
doublereg()
{       ol("add hl,hl");
}
/* Add the primary and secondary registers */
/*      (results in primary) */
zadd()
{       ol("add hl,de");
}
/* Subtract the primary register from the secondary */
/*      (results in primary) */
zsub()
{       callrts("ccsub");
}
/* Multiply the primary and secondary registers */
/*      (results in primary */
mult()
{       callrts("ccmult");
}
/* Divide the secondary register by the primary */
/*      (quotient in primary, remainder in secondary) */
div()
{       callrts("ccdiv");
}
/* Compute remainder (mod) of secondary register divided */
/*      by the primary */
/*      (remainder in primary, quotient in secondary) */
zmod()
{       div();
        swap();
        }
/* Inclusive 'or' the primary and the secondary registers */
/*      (results in primary) */
zor()
        {callrts("ccor");}
/* Exclusive 'or' the primary and seconday registers */
/*      (results in primary) */
zxor()
        {callrts("ccxor");}
/* 'And' the primary and secondary registers */
/*      (results in primary) */
zand()
        {callrts("ccand");}
/* Arithmetic shift right the secondary register number of */
/*      times in primary (results in primary) */
asr()
        {callrts("ccasr");}
/* Arithmetic left shift the secondary register number of */
/*      times in primary (results in primary) */
asl()
        {callrts("ccasl");}
/* Form two's complement of primary register */
neg()
        {callrts("ccneg");}
/* Form one's complement of primary register */
com()
        {callrts("cccom");}
/* Increment the primary register by one */
inc()
        {ol("inc hl");}
/* Decrement the primary register by one */
dec()
        {ol("dec hl");}
 
/* Following are the conditional operators */
/* They compare the secondary register against the primary */
/* and put a literal 1 in the primary if the condition is */
/* true, otherwise they clear the primary register */
 
/* Test for equal */
zeq()
        {callrts("cceq");}
/* Test for not equal */
zne()
        {callrts("ccne");}
/* Test for less than (signed) */
zlt()
        {callrts("cclt");}
/* Test for less than or equal to (signed) */
zle()
        {callrts("ccle");}
/* Test for greater than (signed) */
zgt()
        {callrts("ccgt");}
/* Test for greater than or equal to (signed) */
zge()
        {callrts("ccge");}
/* Test for less than (unsigned) */
ult()
        {callrts("ccult");}
/* Test for less than or equal to (unsigned) */
ule()
        {callrts("ccule");}
/* Test for greater than (unsigned) */
ugt()
        {callrts("ccugt");}
/* Test for greater than or equal to (unsigned) */
uge()
        {callrts("ccuge");}
 
/*      <<<<<  End of small-c compiler  >>>>>   */
 
Browse

Tools

Subversion Repositories light8080

[/] [light8080/] [trunk/] [tools/] [c80/] [c80.c] - Blame information for rev 71

Line No.	Rev	Author	Line
1	65	motilito	`//************************************************`
2			`//`
3			`// Small-C Compiler`
4			`//`
5			`// by Ron Cain`
6			`//`
7			`//************************************************`
8
9			`// with minor mods by RDK`
10			`#define BANNER " <><><> Small-C V1.2 DOS--CP/M Cross Compiler <><><>"`
11			`#define VERSION " <><><><><> CP/M Large String Space Version <><><><><>"`
12			`#define AUTHOR " <><><><><><><><><><> By Ron Cain <><><><><><><><><><>"`
13			`#define TLINE " <><><><><><><><><><><><><><>X<><><><><><><><><><><><><><>"`
14
15			`/* Define system dependent parameters */`
16			`/* Stand-alone definitions */`
17			`/* INCLUDE THE LIBRARY TO COMPILE THE COMPILER (RDK) */`
18			`/* #include smallc.lib / / small-c library included in source now */`
19			`/* IN DOS USE THE SMALL-C OBJ LIBRARY RATHER THAN IN-LINE ASSEMBLER */`
20			`#define NULL 0`
21			`#define eol 10 /* was 13 */`
22
23			`#include "stdio.h" /* was <stdio.h> */`
24
25			`/* Define the symbol table parameters */`
26			`#define symsiz 16`
27			`#define symtbsz 5760`
28			`#define numglbs 300`
29			`#define startglb symtab`
30			`#define endglb startglb+numglbs*symsiz`
31			`#define startloc endglb+symsiz`
32			`#define endloc symtab+symtbsz-symsiz`
33
34			`/* Define symbol table entry format */`
35			`#define name 0`
36			`#define ident 9`
37			`#define type 10`
38			`#define storage 11`
39			`#define offset 12`
40			`#define initptr 14`