3 * Drafted after the Small-C compiler Version 2.01, originally created
4 * by Ron Cain, july 1980, and enhanced by James E. Hendrix.
6 * This version comes close to a complete rewrite.
8 * Copyright R. Cain, 1980
9 * Copyright J.E. Hendrix, 1982, 1983
10 * Copyright T. Riemersma, 1997-2003
14 * This software is provided "as-is", without any express or implied warranty.
15 * In no event will the authors be held liable for any damages arising from
16 * the use of this software.
18 * Permission is granted to anyone to use this software for any purpose,
19 * including commercial applications, and to alter it and redistribute it
20 * freely, subject to the following restrictions:
22 * 1. The origin of this software must not be misrepresented; you must not
23 * claim that you wrote the original software. If you use this software in
24 * a product, an acknowledgment in the product documentation would be
25 * appreciated but is not required.
26 * 2. Altered source versions must be plainly marked as such, and must not be
27 * misrepresented as being the original software.
28 * 3. This notice may not be removed or altered from any source distribution.
31 #ifndef EMBRYO_CC_SC_H
32 #define EMBRYO_CC_SC_H
46 #include "embryo_cc_amx.h"
48 /* Note: the "cell" and "ucell" types are defined in AMX.H */
50 #define PUBLIC_CHAR '@' /* character that defines a function "public" */
51 #define CTRL_CHAR '\\' /* default control character */
53 #define DIRSEP_CHAR '/' /* directory separator character */
55 #define sDIMEN_MAX 2 /* maximum number of array dimensions */
56 #define sDEF_LITMAX 500 /* initial size of the literal pool, in "cells" */
57 #define sLINEMAX (640 * 1024) /* input line length (in characters) */
58 #define sDEF_AMXSTACK 4096 /* default stack size for AMX files */
59 #define sSTKMAX 80 /* stack for nested #includes and other uses */
60 #define PREPROC_TERM '\x7f' /* termination character for preprocessor expressions (the "DEL" code) */
61 #define sDEF_PREFIX "default.inc" /* default prefix filename */
63 typedef intptr_t stkitem; /* type of items stored on the stack */
65 typedef struct __s_arginfo
66 { /* function argument info */
67 char name[sNAMEMAX + 1];
68 char ident; /* iVARIABLE, iREFERENCE, iREFARRAY or iVARARGS */
69 char usage; /* uCONST */
70 int *tags; /* argument tag id. list */
71 int numtags; /* number of tags in the tag list */
73 int numdim; /* number of dimensions */
74 unsigned char hasdefault; /* bit0: is there a default value? bit6: "tagof"; bit7: "sizeof" */
77 cell val; /* default value */
80 char *symname; /* name of another symbol */
81 short level; /* indirection level for that symbol */
82 } size; /* used for "sizeof" default value */
85 cell *data; /* values of default array */
86 int size; /* complete length of default array */
87 int arraysize; /* size to reserve on the heap */
88 cell addr; /* address of the default array in the data segment */
90 } defvalue; /* default value, or pointer to default array */
91 int defvalue_tag; /* tag of the default value */
94 /* Equate table, tagname table, library table */
95 typedef struct __s_constvalue
97 struct __s_constvalue *next;
98 char name[sNAMEMAX + 1];
103 /* Symbol table format
105 * The symbol name read from the input file is stored in "name", the
106 * value of "addr" is written to the output file. The address in "addr"
107 * depends on the class of the symbol:
108 * global offset into the data segment
109 * local offset relative to the stack frame
110 * label generated hexadecimal number
111 * function offset into code segment
113 typedef struct __s_symbol
115 struct __s_symbol *next;
116 struct __s_symbol *parent; /* hierarchical types (multi-dimensional arrays) */
117 char name[sNAMEMAX + 1];
118 unsigned int hash; /* value derived from name, for quicker searching */
119 cell addr; /* address or offset (or value for constant, index for native function) */
120 char vclass; /* sLOCAL if "addr" refers to a local symbol */
121 char ident; /* see below for possible values */
122 char usage; /* see below for possible values */
123 int compound; /* compound level (braces nesting level) */
124 int tag; /* tagname id */
127 int declared; /* label: how many local variables are declared */
128 int idxtag; /* array: tag of array indices */
129 constvalue *lib; /* native function: library it is part of *///??? use "stringlist"
130 } x; /* 'x' for 'extra' */
133 arginfo *arglist; /* types of all parameters for functions */
136 cell length; /* arrays: length (size) */
137 short level; /* number of dimensions below this level */
139 } dim; /* for 'dimension', both functions and arrays */
140 int fnumber; /* static global variables: file number in which the declaration is visible */
141 struct __s_symbol **refer; /* referrer list, functions that "use" this symbol */
142 int numrefers; /* number of entries in the referrer list */
145 /* Possible entries for "ident". These are used in the "symbol", "value"
146 * and arginfo structures. Not every constant is valid for every use.
147 * In an argument list, the list is terminated with a "zero" ident; labels
148 * cannot be passed as function arguments, so the value 0 is overloaded.
151 #define iVARIABLE 1 /* cell that has an address and that can be fetched directly (lvalue) */
152 #define iREFERENCE 2 /* iVARIABLE, but must be dereferenced */
154 #define iREFARRAY 4 /* an array passed by reference (i.e. a pointer) */
155 #define iARRAYCELL 5 /* array element, cell that must be fetched indirectly */
156 #define iARRAYCHAR 6 /* array element, character from cell from array */
157 #define iEXPRESSION 7 /* expression result, has no address (rvalue) */
158 #define iCONSTEXPR 8 /* constant expression (or constant symbol) */
160 #define iREFFUNC 10 /* function passed as a parameter */
161 #define iVARARGS 11 /* function specified ... as argument(s) */
163 /* Possible entries for "usage"
165 * This byte is used as a serie of bits, the syntax is different for
166 * functions and other symbols:
169 * bits: 0 (uDEFINE) the variable is defined in the source file
170 * 1 (uREAD) the variable is "read" (accessed) in the source file
171 * 2 (uWRITTEN) the variable is altered (assigned a value)
172 * 3 (uCONST) the variable is constant (may not be assigned to)
173 * 4 (uPUBLIC) the variable is public
174 * 6 (uSTOCK) the variable is discardable (without warning)
177 * bits: 0 (uDEFINE) the function is defined ("implemented") in the source file
178 * 1 (uREAD) the function is invoked in the source file
179 * 2 (uRETVALUE) the function returns a value (or should return a value)
180 * 3 (uPROTOTYPED) the function was prototyped
181 * 4 (uPUBLIC) the function is public
182 * 5 (uNATIVE) the function is native
183 * 6 (uSTOCK) the function is discardable (without warning)
184 * 7 (uMISSING) the function is not implemented in this source file
187 * bits: 0 (uDEFINE) the symbol is defined in the source file
188 * 1 (uREAD) the constant is "read" (accessed) in the source file
189 * 3 (uPREDEF) the constant is pre-defined and should be kept between passes
193 #define uWRITTEN 0x04
194 #define uRETVALUE 0x04 /* function returns (or should return) a value */
196 #define uPROTOTYPED 0x08
197 #define uPREDEF 0x08 /* constant is pre-defined */
201 #define uMISSING 0x80
202 /* uRETNONE is not stored in the "usage" field of a symbol. It is
203 * used during parsing a function, to detect a mix of "return;" and
204 * "return value;" in a few special cases.
206 #define uRETNONE 0x10
208 #define uTAGOF 0x40 /* set in the "hasdefault" field of the arginfo struct */
209 #define uSIZEOF 0x80 /* set in the "hasdefault" field of the arginfo struct */
211 #define uMAINFUNC "main"
213 #define sGLOBAL 0 /* global/local variable/constant class */
215 #define sSTATIC 2 /* global life, local scope */
219 symbol *sym; /* symbol in symbol table, NULL for (constant) expression */
220 cell constval; /* value of the constant expression (if ident==iCONSTEXPR)
221 * also used for the size of a literal array */
222 int tag; /* tagname id (of the expression) */
223 char ident; /* iCONSTEXPR, iVARIABLE, iARRAY, iARRAYCELL,
224 * iEXPRESSION or iREFERENCE */
225 char boolresult; /* boolean result for relational operators */
226 cell *arrayidx; /* last used array indices, for checking self assignment */
229 /* "while" statement queue (also used for "for" and "do - while" loops) */
232 wqBRK, /* used to restore stack for "break" */
233 wqCONT, /* used to restore stack for "continue" */
234 wqLOOP, /* loop start label number */
235 wqEXIT, /* loop exit label number (jump if false) */
237 wqSIZE /* "while queue" size */
240 #define wqTABSZ (24*wqSIZE) /* 24 nested loop statements */
244 statIDLE, /* not compiling yet */
245 statFIRST, /* first pass */
246 statWRITE, /* writing output */
247 statSKIP, /* skipping output */
250 typedef struct __s_stringlist
252 struct __s_stringlist *next;
256 typedef struct __s_stringpair
258 struct __s_stringpair *next;
264 /* macros for code generation */
265 #define opcodes(n) ((n)*sizeof(cell)) /* opcode size */
266 #define opargs(n) ((n)*sizeof(cell)) /* size of typical argument */
268 /* Tokens recognized by lex()
269 * Some of these constants are assigned as well to the variable "lastst"
271 #define tFIRST 256 /* value of first multi-character operator */
272 #define tMIDDLE 279 /* value of last multi-character operator */
273 #define tLAST 320 /* value of last multi-character match-able token */
274 /* multi-character operators */
275 #define taMULT 256 /* *= */
276 #define taDIV 257 /* /= */
277 #define taMOD 258 /* %= */
278 #define taADD 259 /* += */
279 #define taSUB 260 /* -= */
280 #define taSHL 261 /* <<= */
281 #define taSHRU 262 /* >>>= */
282 #define taSHR 263 /* >>= */
283 #define taAND 264 /* &= */
284 #define taXOR 265 /* ^= */
285 #define taOR 266 /* |= */
286 #define tlOR 267 /* || */
287 #define tlAND 268 /* && */
288 #define tlEQ 269 /* == */
289 #define tlNE 270 /* != */
290 #define tlLE 271 /* <= */
291 #define tlGE 272 /* >= */
292 #define tSHL 273 /* << */
293 #define tSHRU 274 /* >>> */
294 #define tSHR 275 /* >> */
295 #define tINC 276 /* ++ */
296 #define tDEC 277 /* -- */
297 #define tELLIPS 278 /* ... */
298 #define tDBLDOT 279 /* .. */
299 /* reserved words (statements) */
305 #define tCONTINUE 285
318 #define tOPERATOR 298
328 /* compiler directives */
329 #define tpASSERT 308 /* #assert */
331 #define tpELSE 310 /* #else */
334 #define tpENDINPUT 313
335 #define tpENDSCRPT 314
337 #define tpIF 316 /* #if */
342 /* semicolon is a special case, because it can be optional */
343 #define tTERM 321 /* semicolon or newline */
344 #define tENDEXPR 322 /* forced end of expression */
345 /* other recognized tokens */
346 #define tNUMBER 323 /* integer number */
347 #define tRATIONAL 324 /* rational number */
351 #define tEXPR 328 /* for assigment to "lastst" only */
353 /* (reversed) evaluation of staging buffer */
354 #define sSTARTREORDER 1
355 #define sENDREORDER 2
356 #define sEXPRSTART 0xc0 /* top 2 bits set, rest is free */
357 #define sMAXARGS 64 /* relates to the bit pattern of sEXPRSTART */
359 /* codes for ffabort() */
360 #define xEXIT 1 /* exit code in PRI */
361 #define xASSERTION 2 /* abort caused by failing assertion */
362 #define xSTACKERROR 3 /* stack/heap overflow */
363 #define xBOUNDSERROR 4 /* array index out of bounds */
364 #define xMEMACCESS 5 /* data access error */
365 #define xINVINSTR 6 /* invalid instruction */
366 #define xSTACKUNDERFLOW 7 /* stack underflow */
367 #define xHEAPUNDERFLOW 8 /* heap underflow */
368 #define xCALLBACKERR 9 /* no, or invalid, callback */
369 #define xSLEEP 12 /* sleep, exit code in PRI, tag in ALT */
376 #define sIN_CSEG 1 /* if parsing CODE */
377 #define sIN_DSEG 2 /* if parsing DATA */
378 #define sCHKBOUNDS 1 /* bit position in "debug" variable: check bounds */
379 #define sSYMBOLIC 2 /* bit position in "debug" variable: symbolic info */
380 #define sNOOPTIMIZE 4 /* bit position in "debug" variable: no optimization */
381 #define sRESET 0 /* reset error flag */
382 #define sFORCESET 1 /* force error flag on */
383 #define sEXPRMARK 2 /* mark start of expression */
384 #define sEXPRRELEASE 3 /* mark end of expression */
387 #define PUBLICTAG 0x8000u
388 #define FIXEDTAG 0x4000u
390 #define PUBLICTAG 0x80000000Lu
391 #define FIXEDTAG 0x40000000Lu
393 #define TAGMASK (~PUBLICTAG)
397 * Functions you call from the "driver" program
399 int sc_compile(int argc, char **argv);
400 int sc_addconstant(char *name, cell value, int tag);
401 int sc_addtag(char *name);
404 * Functions called from the compiler (to be implemented by you)
407 /* general console output */
408 int sc_printf(const char *message, ...);
410 /* error report function */
411 int sc_error(int number, char *message, char *filename,
412 int firstline, int lastline, va_list argptr);
414 /* input from source file */
415 void *sc_opensrc(char *filename); /* reading only */
416 void sc_closesrc(void *handle); /* never delete */
417 void sc_resetsrc(void *handle, void *position); /* reset to a position marked earlier */
418 char *sc_readsrc(void *handle, char *target, int maxchars);
419 void *sc_getpossrc(void *handle); /* mark the current position */
420 int sc_eofsrc(void *handle);
422 /* output to intermediate (.ASM) file */
423 void *sc_openasm(int fd); /* read/write */
424 void sc_closeasm(void *handle);
425 void sc_resetasm(void *handle);
426 int sc_writeasm(void *handle, char *str);
427 char *sc_readasm(void *handle, char *target, int maxchars);
429 /* output to binary (.AMX) file */
430 void *sc_openbin(char *filename);
431 void sc_closebin(void *handle, int deletefile);
432 void sc_resetbin(void *handle);
433 int sc_writebin(void *handle, void *buffer, int size);
434 long sc_lengthbin(void *handle); /* return the length of the file */
436 /* function prototypes in SC1.C */
437 symbol *fetchfunc(char *name, int tag);
438 char *operator_symname(char *symname, char *opername, int tag1,
439 int tag2, int numtags, int resulttag);
440 char *funcdisplayname(char *dest, char *funcname);
441 int constexpr(cell * val, int *tag);
442 constvalue *append_constval(constvalue * table, char *name, cell val,
444 constvalue *find_constval(constvalue * table, char *name, short index);
445 void delete_consttable(constvalue * table);
446 void add_constant(char *name, cell val, int vclass, int tag);
447 void exporttag(int tag);
449 /* function prototypes in SC2.C */
450 void pushstk(stkitem val);
451 stkitem popstk(void);
452 int plungequalifiedfile(char *name); /* explicit path included */
453 int plungefile(char *name, int try_currentpath, int try_includepaths); /* search through "include" paths */
454 void preprocess(void);
456 int lex(cell * lexvalue, char **lexsym);
458 void lexclr(int clreol);
459 int matchtoken(int token);
460 int tokeninfo(cell * val, char **str);
461 int needtoken(int token);
462 void stowlit(cell value);
463 int alphanum(char c);
464 void delete_symbol(symbol * root, symbol * sym);
465 void delete_symbols(symbol * root, int level, int del_labels,
466 int delete_functions);
467 int refer_symbol(symbol * entry, symbol * bywhom);
468 void markusage(symbol * sym, int usage);
469 unsigned int namehash(char *name);
470 symbol *findglb(char *name);
471 symbol *findloc(char *name);
472 symbol *findconst(char *name);
473 symbol *finddepend(symbol * parent);
474 symbol *addsym(char *name, cell addr, int ident, int vclass,
476 symbol *addvariable(char *name, cell addr, int ident, int vclass,
477 int tag, int dim[], int numdim, int idxtag[]);
479 char *itoh(ucell val);
481 /* function prototypes in SC3.C */
482 int check_userop(void (*oper) (void), int tag1, int tag2,
483 int numparam, value * lval, int *resulttag);
484 int matchtag(int formaltag, int actualtag, int allowcoerce);
485 int expression(int *constant, cell * val, int *tag,
487 int hier14(value * lval1); /* the highest expression level */
489 /* function prototypes in SC4.C */
490 void writeleader(void);
491 void writetrailer(void);
494 void setactivefile(int fnumber);
495 cell nameincells(char *name);
496 void setfile(char *name, int fileno);
497 void setline(int line, int fileno);
498 void setlabel(int index);
499 void endexpr(int fullexpr);
500 void startfunc(char *fname);
502 void alignframe(int numbytes);
503 void defsymbol(char *name, int ident, int vclass, cell offset,
505 void symbolrange(int level, cell size);
506 void rvalue(value * lval);
507 void address(symbol * ptr);
508 void store(value * lval);
509 void memcopy(cell size);
510 void copyarray(symbol * sym, cell size);
511 void fillarray(symbol * sym, cell size, cell value);
512 void const1(cell val);
513 void const2(cell val);
517 void pushval(cell val);
521 void ffswitch(int label);
522 void ffcase(cell value, char *labelname, int newtable);
523 void ffcall(symbol * sym, int numargs);
525 void ffabort(int reason);
526 void ffbounds(cell size);
527 void jumplabel(int number);
528 void defstorage(void);
529 void modstk(int delta);
530 void setstk(cell value);
531 void modheap(int delta);
532 void setheap_pri(void);
533 void setheap(cell value);
534 void cell2addr(void);
535 void cell2addr_alt(void);
536 void addr2cell(void);
537 void char2addr(void);
538 void charalign(void);
539 void addconst(cell value);
541 /* Code generation functions for arithmetic operators.
543 * Syntax: o[u|s|b]_name
544 * | | | +--- name of operator
545 * | | +----- underscore
546 * | +--------- "u"nsigned operator, "s"igned operator or "b"oth
547 * +------------- "o"perator
549 void os_mult(void); /* multiplication (signed) */
550 void os_div(void); /* division (signed) */
551 void os_mod(void); /* modulus (signed) */
552 void ob_add(void); /* addition */
553 void ob_sub(void); /* subtraction */
554 void ob_sal(void); /* shift left (arithmetic) */
555 void os_sar(void); /* shift right (arithmetic, signed) */
556 void ou_sar(void); /* shift right (logical, unsigned) */
557 void ob_or(void); /* bitwise or */
558 void ob_xor(void); /* bitwise xor */
559 void ob_and(void); /* bitwise and */
560 void ob_eq(void); /* equality */
561 void ob_ne(void); /* inequality */
562 void relop_prefix(void);
563 void relop_suffix(void);
564 void os_le(void); /* less or equal (signed) */
565 void os_ge(void); /* greater or equal (signed) */
566 void os_lt(void); /* less (signed) */
567 void os_gt(void); /* greater (signed) */
572 void nooperation(void);
573 void inc(value * lval);
574 void dec(value * lval);
575 void jmp_ne0(int number);
576 void jmp_eq0(int number);
577 void outval(cell val, int newline);
579 /* function prototypes in SC5.C */
580 int error(int number, ...);
581 void errorset(int code);
583 /* function prototypes in SC6.C */
584 void assemble(FILE * fout, FILE * fin);
586 /* function prototypes in SC7.C */
587 void stgbuffer_cleanup(void);
588 void stgmark(char mark);
589 void stgwrite(char *st);
590 void stgout(int index);
591 void stgdel(int index, cell code_index);
592 int stgget(int *index, cell * code_index);
593 void stgset(int onoff);
594 int phopt_init(void);
595 int phopt_cleanup(void);
597 /* function prototypes in SCLIST.C */
598 stringpair *insert_alias(char *name, char *alias);
599 stringpair *find_alias(char *name);
600 int lookup_alias(char *target, char *name);
601 void delete_aliastable(void);
602 stringlist *insert_path(char *path);
603 char *get_path(int index);
604 void delete_pathtable(void);
605 stringpair *insert_subst(char *pattern, char *substitution,
607 int get_subst(int index, char **pattern, char **substitution);
608 stringpair *find_subst(char *name, int length);
609 int delete_subst(char *name, int length);
610 void delete_substtable(void);
612 /* external variables (defined in scvars.c) */
613 extern symbol loctab; /* local symbol table */
614 extern symbol glbtab; /* global symbol table */
615 extern cell *litq; /* the literal queue */
616 extern char pline[]; /* the line read from the input file */
617 extern char *lptr; /* points to the current position in "pline" */
618 extern constvalue tagname_tab; /* tagname table */
619 extern constvalue libname_tab; /* library table (#pragma library "..." syntax) *///??? use "stringlist" type
620 extern constvalue *curlibrary; /* current library */
621 extern symbol *curfunc; /* pointer to current function */
622 extern char *inpfname; /* name of the file currently read from */
623 extern char outfname[]; /* output file name */
624 extern char sc_ctrlchar; /* the control character (or escape character) */
625 extern int litidx; /* index to literal table */
626 extern int litmax; /* current size of the literal table */
627 extern int stgidx; /* index to the staging buffer */
628 extern int labnum; /* number of (internal) labels */
629 extern int staging; /* true if staging output */
630 extern cell declared; /* number of local cells declared */
631 extern cell glb_declared; /* number of global cells declared */
632 extern cell code_idx; /* number of bytes with generated code */
633 extern int ntv_funcid; /* incremental number of native function */
634 extern int errnum; /* number of errors */
635 extern int warnnum; /* number of warnings */
636 extern int sc_debug; /* debug/optimization options (bit field) */
637 extern int charbits; /* number of bits for a character */
638 extern int sc_packstr; /* strings are packed by default? */
639 extern int sc_asmfile; /* create .ASM file? */
640 extern int sc_listing; /* create .LST file? */
641 extern int sc_compress; /* compress bytecode? */
642 extern int sc_needsemicolon; /* semicolon required to terminate expressions? */
643 extern int sc_dataalign; /* data alignment value */
644 extern int sc_alignnext; /* must frame of the next function be aligned? */
645 extern int curseg; /* 1 if currently parsing CODE, 2 if parsing DATA */
646 extern cell sc_stksize; /* stack size */
647 extern int freading; /* is there an input file ready for reading? */
648 extern int fline; /* the line number in the current file */
649 extern int fnumber; /* number of files in the file table (debugging) */
650 extern int fcurrent; /* current file being processed (debugging) */
651 extern int intest; /* true if inside a test */
652 extern int sideeffect; /* true if an expression causes a side-effect */
653 extern int stmtindent; /* current indent of the statement */
654 extern int indent_nowarn; /* skip warning "217 loose indentation" */
655 extern int sc_tabsize; /* number of spaces that a TAB represents */
656 extern int sc_allowtags; /* allow/detect tagnames in lex() */
657 extern int sc_status; /* read/write status */
658 extern int sc_rationaltag; /* tag for rational numbers */
659 extern int rational_digits; /* number of fractional digits */
661 extern FILE *inpf; /* file read from (source or include) */
662 extern FILE *inpf_org; /* main source file */
663 extern FILE *outf; /* file written to */
665 extern jmp_buf errbuf; /* target of longjmp() on a fatal error */
667 #define sc_isspace(x) isspace ((int)((unsigned char)x))
668 #define sc_isalpha(x) isalpha ((int)((unsigned char)x))
669 #define sc_isdigit(x) isdigit ((int)((unsigned char)x))
670 #define sc_isupper(x) isupper ((int)((unsigned char)x))
671 #define sc_isxdigit(x) isxdigit((int)((unsigned char)x))