cc.p

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

/* Protogen Version 1.00 Sunday November 15, 1998  14:00:16 */

                              /* Analyze.c */

int equalnode(ENODE *node1, ENODE *node2);
CSE *searchnode(ENODE *node);
ENODE *copynode(ENODE *node);
CSE *enternode(ENODE *node,int duse,int size);
CSE *voidauto(ENODE *node);
void voidall(void);
void scanexpr(ENODE *node, int duse,int size);
void scan(SNODE *block);
void exchange(CSE **c1);
int     desire(CSE *csp);
int     bsort(CSE **list);
void repexpr(ENODE *node, int size);
void repcse(SNODE *block);
void voidAssign(SNODE *block, int state) ;
void allocstack(void);
void opt1(SNODE *block);

                               /* Cmain.c */

void bool_setup(char select, char *string); /* PROTOTYPE */
void err_setup(char select, char *string); /* PROTOTYPE */
void incl_setup(char select, char *string); /* PROTOTYPE */
void def_setup(char select, char *string); /* PROTOTYPE */
void codegen_setup(char select, char *string); /* PROTOTYPE */
void optimize_setup(char select, char *string); /* PROTOTYPE */
void warning_setup(char select, char *string); /* PROTOTYPE */
void parsefile(char select, char *string); /* PROTOTYPE */
void bool_setup(char select, char *string);
void codegen_setup(char select, char *string);
void optimize_setup(char select, char *string);
void err_setup(char select, char *string);
void incl_setup(char select, char * string);
void def_setup(char select, char *string);
void setglbdefs(void);
void InsertAnyFile(FILE *inf, FILE *outf, char *filename, char *path, int drive);
void dumperrs(FILE *file); /* PROTOTYPE */
void setfile(char *buf,char *orgbuf,char *ext);
int parse_arbitrary(char *string);
void parsefile(char select, char *string);
void addinclude(void);
int parseenv(char *name);
void dumperrs(FILE *file);
void summary(void);
void ctrlchandler(int aa);
int main(int argc,char *argv[]);

                               /* cppbltin.c */

void installCPPBuiltins(void) ;

                               /* Decl.c */

void declini(void);
int     imax(int i,int j);
char    *litlate(char *s);
TYP     *maketype(int bt,int siz);
TYP *cponetype(TYP *t);
TYP *copytype(TYP *itp, int flags);
int istype(void);
SYM *parsetype(SYM *typesp, int pass);
int     decl(TABLE *table,int cppflags);
void checkclasstype(void);
SYM* makesym(enum e_sc sc);
ENODE * do_constructor(SYM *sp_in, TYP *tp, TYP *head1, ENODE *node, int size, int offset, int assn, int implicit);
ENODE * do_destructor(SYM *sp_in, TYP *tp, TYP *head1, ENODE *node, int size, int offset, int assn) ;
int conspair (SYM *sp, enum e_sc al,int flag, TYP *tp1, ENODE *node, int assn, int offs, int implicit) ;
SYM *decl1(enum e_sc sc, SYM *sp);
void decl2(enum e_sc sc, SYM *sp);
void decl3(void);
int bitsize(int type);
int oksize(void);
int     basedeclare(TABLE *table,int al,long ilc,int ztype, int flags, int xcppflags);
int     declare(TABLE *table,int al,int ztype, int flags, int xcppflags);
int     declare2(TABLE *table,int al,int ztype, int flags, int xcppflags, long val);
int     declbegin(int st);
void declenum(TABLE *table,int cppflags);
SYM *enumbody(SYM *sp, TABLE *table);
void declstruct(TABLE *table, int ztype, int flags,int cppflags);
void structbody(SYM *sp, int ztype);
void check_used(void);
void compile(void);
void insertTemplateChar(short t)  ;
void createTemplate(TABLE *tbl, enum e_sc sc);
void using_keyword(void) ;
void dodecl(int defclass);
int blockdecl();
void doargdecl(int defclass, char *names[], int *nparms, TABLE *table, int isinline);

                              /* Declass.c */

void defclassini(void);
SYM *copysym(SYM *sp);
int loadclassdata(SYM *sp, SYM* spc, int mode, int virtual);
int insertVirtualData(SYM *sp);
void addvtabentry(SYM *cl, SYM *sp);
void classerrs(SYM *sp);
void consreferr(SYM *sp, ENODE *constree, SYM **inittab, int count);
TYP *classnameref(ENODE **node, SYM **pos);
ENODE *conscall(ENODE *tcnode, SYM *sp, ENODE* ep);
void destcall(SYM *sp);
TYP * basedecl(ENODE **rv, SYM *sp);
void classbaseasn(SYM *sp, SYM *func);
void gen_vtab(SYM *sp);

/* Protogen Version 1.00 Sunday November 15, 1998  14:00:16 */

                               /* Error.c */

void initerr(void);
void warning_setup(char select, char *string);
void diag(char *s);
int printerr(char *buf, ERRORS *err);
void     lferror(void);
void basicskim(int *skimlist);
BALANCE *newbalance(BALANCE *bal);
void setbalance(BALANCE **bal);
void expskim(int *skimlist,int tpl);
void basicerror(int n, void *data);
void Error(char *string);
void generror(int n,int data, int *skimlist);
void gensymerror(int n, char *data);
void genfuncerror(int n, char*func, char *data);
void genfunc2error(int n, char*func, char *func2);
void genclasserror(int n, char *name);
void genclass2error(int n, char *struc, char *elem);
void genmismatcherror(TYP *tp1, TYP *tp2);
void expecttoken(int n, int *skimlist);
void generrorexp(int n, int data, int *skimlist);
void gensymerrorexp(int n, char *data);
void expecttokenexp(int n, int *skimlist);

                               /* Expr.c */

void exprini(void);
ENODE    *makenode(enum e_node nt, char *v1, char *v2);
ENODE *makeintnode(enum e_node nt, LLONG_TYPE val) ;
TYP *basictype(TYP *t) ;
TYP *deref(ENODE **node, TYP *tp);
ENODE *copy_default(ENODE *node) ;
ENODE* make_callblock(ENODE *ep1, ENODE *ep2,TYP *tp,int size);
ENODE *dummyvar(int size, TYP *type, char *name);
ENODE *copy_enode(ENODE *node) ;
int isintconst(int type);
int isfloatconst(int type);
int isimaginaryconst(int type);
int matchreflvalue(ENODE **node,TYP *tp1, TYP *tp2);
TYP     *nameref(ENODE **node, TYP *tin);
int cppcast(TYP *newtype, TYP *oldtype, ENODE **node, int alwayserr) ;
void promote_type(TYP *typ, ENODE **node);
TYP *gatherparms( ENODE **node, int isvoid);
int checkparmconst(TYP *tp, TYP *tpi);
void parmlist(ENODE **node, TYP *tpi, TYP *tp);
int floatrecurse(ENODE *node);
void floatcheck(ENODE *node);
int     castbegin(int st);
int tostring(void);
TYP *dooperator(ENODE **node) ;
TYP     *primary(ENODE **node);
int issturctured (TYP *tp);
int			castvalue(ENODE *node);
int     lvalue(ENODE *node);
TYP     *unary(ENODE **node);
TYP *mathoverload(enum e_bt lst,TYP *tp1,TYP *tp2,ENODE **ep1,ENODE **ep2);
TYP *maxsize(TYP *tp1, TYP *tp2);
TYP *inttype(enum e_bt t1);
TYP     *forcefit(ENODE **node1,TYP *tp1,ENODE **node2,TYP *tp2, 
            int allowpointers);
TYP     *asnfit(ENODE **node1,TYP *tp1,ENODE **node2,TYP *tp2, 
            int matchref);
int     isscalar(TYP *tp);
int scalarnoncomplex(TYP *tp);
int scalarnonfloat(TYP *tp) ;
void checknp(TYP *tp1,TYP*tp2,ENODE *ep1, ENODE *ep2);
int isunsignedresult(TYP *tp1, TYP *tp2, ENODE *ep1, ENODE *ep2);
TYP     *multops(ENODE **node);
TYP     *addops(ENODE **node);
TYP     *shiftop(ENODE **node);
TYP     *relation(ENODE **node);
TYP     *equalops(ENODE **node);
TYP     *binop(ENODE **node,TYP *(*xfunc)(),int nt,int sy);
TYP     *bitand(ENODE **node);
TYP     *bitxor(ENODE **node);
TYP     *bitor(ENODE **node);
TYP     *andop(ENODE **node);
TYP     *orop(ENODE **node);
TYP     *conditional(ENODE **node);
TYP     *autoasnop(ENODE **node, SYM *sp,int);
void asncombine(ENODE **node);
void 	checkConstClass(ENODE *node);
TYP     *asnop(ENODE **node,TYP *tptr);
TYP     *exprnc(ENODE **node);
TYP     *commaop(ENODE **node);
TYP     *expression(ENODE **node, int tocheck);

                             /* Floatexp.c */

long double floatexpr(void); /* PROTOTYPE */
long double floatexpr(void);

                               /* Func.c */

void funcini(void);
void declfuncarg(int isint, int isfar, SYM *sp);
void check_funcused(TABLE *oldlsym, TABLE *lsyms);
void funcbody(SYM *sp);
SYM     *makeint(char *name, TABLE *table);
void addrundown(SNODE *snp);
void addblocklist(SYM *sp, SYM *old);
void block(SNODE *vlainit);
void gather_labels(TABLE *oldlsym, TABLE *lsyms);
SNODE *compoundblock(void);

  			      /* Inline.c */
#ifdef CPLUSPLUS
ENODE *inlineexpr(ENODE *node);
ENODE * asm_inlinestmt(ENODE *e);
SNODE *inlinestmt(SNODE *block);
ENODE *inlinefuncargs(ENODE *node,SYM *sp);
void inlinereblock(SYM *sp);
ENODE *doinline(ENODE *node);
#endif



			      /* intrins.c */
void IntrinsIni(void);
void SearchIntrins(SYM *sp);
struct amode *HandleIntrins(ENODE *node, int novalue);