diff options
Diffstat (limited to '')
-rw-r--r-- | libraries/embryo/src/bin/embryo_cc_sc.h | 667 |
1 files changed, 667 insertions, 0 deletions
diff --git a/libraries/embryo/src/bin/embryo_cc_sc.h b/libraries/embryo/src/bin/embryo_cc_sc.h new file mode 100644 index 0000000..e62cbc3 --- /dev/null +++ b/libraries/embryo/src/bin/embryo_cc_sc.h | |||
@@ -0,0 +1,667 @@ | |||
1 | /* Small compiler | ||
2 | * | ||
3 | * Drafted after the Small-C compiler Version 2.01, originally created | ||
4 | * by Ron Cain, july 1980, and enhanced by James E. Hendrix. | ||
5 | * | ||
6 | * This version comes close to a complete rewrite. | ||
7 | * | ||
8 | * Copyright R. Cain, 1980 | ||
9 | * Copyright J.E. Hendrix, 1982, 1983 | ||
10 | * Copyright T. Riemersma, 1997-2003 | ||
11 | * | ||
12 | * Version: $Id: embryo_cc_sc.h 59489 2011-05-18 08:37:38Z raster $ | ||
13 | * | ||
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. | ||
17 | * | ||
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: | ||
21 | * | ||
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. | ||
29 | */ | ||
30 | |||
31 | #ifndef EMBRYO_CC_SC_H | ||
32 | #define EMBRYO_CC_SC_H | ||
33 | |||
34 | #include <limits.h> | ||
35 | #include <stdarg.h> | ||
36 | #include <stdio.h> | ||
37 | #include <setjmp.h> | ||
38 | |||
39 | #ifndef _MSC_VER | ||
40 | # include <stdint.h> | ||
41 | #else | ||
42 | # include <stddef.h> | ||
43 | # include <Evil.h> | ||
44 | #endif | ||
45 | |||
46 | #include "embryo_cc_amx.h" | ||
47 | |||
48 | /* Note: the "cell" and "ucell" types are defined in AMX.H */ | ||
49 | |||
50 | #define PUBLIC_CHAR '@' /* character that defines a function "public" */ | ||
51 | #define CTRL_CHAR '\\' /* default control character */ | ||
52 | |||
53 | #define DIRSEP_CHAR '/' /* directory separator character */ | ||
54 | |||
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 */ | ||
62 | |||
63 | typedef intptr_t stkitem; /* type of items stored on the stack */ | ||
64 | |||
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 */ | ||
72 | int dim[sDIMEN_MAX]; | ||
73 | int numdim; /* number of dimensions */ | ||
74 | unsigned char hasdefault; /* bit0: is there a default value? bit6: "tagof"; bit7: "sizeof" */ | ||
75 | union | ||
76 | { | ||
77 | cell val; /* default value */ | ||
78 | struct | ||
79 | { | ||
80 | char *symname; /* name of another symbol */ | ||
81 | short level; /* indirection level for that symbol */ | ||
82 | } size; /* used for "sizeof" default value */ | ||
83 | struct | ||
84 | { | ||
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 */ | ||
89 | } array; | ||
90 | } defvalue; /* default value, or pointer to default array */ | ||
91 | int defvalue_tag; /* tag of the default value */ | ||
92 | } arginfo; | ||
93 | |||
94 | /* Equate table, tagname table, library table */ | ||
95 | typedef struct __s_constvalue | ||
96 | { | ||
97 | struct __s_constvalue *next; | ||
98 | char name[sNAMEMAX + 1]; | ||
99 | cell value; | ||
100 | short index; | ||
101 | } constvalue; | ||
102 | |||
103 | /* Symbol table format | ||
104 | * | ||
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 | ||
112 | */ | ||
113 | typedef struct __s_symbol | ||
114 | { | ||
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 */ | ||
125 | union | ||
126 | { | ||
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' */ | ||
131 | union | ||
132 | { | ||
133 | arginfo *arglist; /* types of all parameters for functions */ | ||
134 | struct | ||
135 | { | ||
136 | cell length; /* arrays: length (size) */ | ||
137 | short level; /* number of dimensions below this level */ | ||
138 | } array; | ||
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 */ | ||
143 | } symbol; | ||
144 | |||
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. | ||
149 | */ | ||
150 | #define iLABEL 0 | ||
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 */ | ||
153 | #define iARRAY 3 | ||
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) */ | ||
159 | #define iFUNCTN 9 | ||
160 | #define iREFFUNC 10 /* function passed as a parameter */ | ||
161 | #define iVARARGS 11 /* function specified ... as argument(s) */ | ||
162 | |||
163 | /* Possible entries for "usage" | ||
164 | * | ||
165 | * This byte is used as a serie of bits, the syntax is different for | ||
166 | * functions and other symbols: | ||
167 | * | ||
168 | * VARIABLE | ||
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) | ||
175 | * | ||
176 | * FUNCTION | ||
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 | ||
185 | * | ||
186 | * CONSTANT | ||
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 | ||
190 | */ | ||
191 | #define uDEFINE 0x01 | ||
192 | #define uREAD 0x02 | ||
193 | #define uWRITTEN 0x04 | ||
194 | #define uRETVALUE 0x04 /* function returns (or should return) a value */ | ||
195 | #define uCONST 0x08 | ||
196 | #define uPROTOTYPED 0x08 | ||
197 | #define uPREDEF 0x08 /* constant is pre-defined */ | ||
198 | #define uPUBLIC 0x10 | ||
199 | #define uNATIVE 0x20 | ||
200 | #define uSTOCK 0x40 | ||
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. | ||
205 | */ | ||
206 | #define uRETNONE 0x10 | ||
207 | |||
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 */ | ||
210 | |||
211 | #define uMAINFUNC "main" | ||
212 | |||
213 | #define sGLOBAL 0 /* global/local variable/constant class */ | ||
214 | #define sLOCAL 1 | ||
215 | #define sSTATIC 2 /* global life, local scope */ | ||
216 | |||
217 | typedef struct | ||
218 | { | ||
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 */ | ||
227 | } value; | ||
228 | |||
229 | /* "while" statement queue (also used for "for" and "do - while" loops) */ | ||
230 | enum | ||
231 | { | ||
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) */ | ||
236 | /* --- */ | ||
237 | wqSIZE /* "while queue" size */ | ||
238 | }; | ||
239 | |||
240 | #define wqTABSZ (24*wqSIZE) /* 24 nested loop statements */ | ||
241 | |||
242 | enum | ||
243 | { | ||
244 | statIDLE, /* not compiling yet */ | ||
245 | statFIRST, /* first pass */ | ||
246 | statWRITE, /* writing output */ | ||
247 | statSKIP, /* skipping output */ | ||
248 | }; | ||
249 | |||
250 | typedef struct __s_stringlist | ||
251 | { | ||
252 | struct __s_stringlist *next; | ||
253 | char *line; | ||
254 | } stringlist; | ||
255 | |||
256 | typedef struct __s_stringpair | ||
257 | { | ||
258 | struct __s_stringpair *next; | ||
259 | char *first; | ||
260 | char *second; | ||
261 | int matchlength; | ||
262 | } stringpair; | ||
263 | |||
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 */ | ||
267 | |||
268 | /* Tokens recognized by lex() | ||
269 | * Some of these constants are assigned as well to the variable "lastst" | ||
270 | */ | ||
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) */ | ||
300 | #define tASSERT 280 | ||
301 | #define tBREAK 281 | ||
302 | #define tCASE 282 | ||
303 | #define tCHAR 283 | ||
304 | #define tCONST 284 | ||
305 | #define tCONTINUE 285 | ||
306 | #define tDEFAULT 286 | ||
307 | #define tDEFINED 287 | ||
308 | #define tDO 288 | ||
309 | #define tELSE 289 | ||
310 | #define tENUM 290 | ||
311 | #define tEXIT 291 | ||
312 | #define tFOR 292 | ||
313 | #define tFORWARD 293 | ||
314 | #define tGOTO 294 | ||
315 | #define tIF 295 | ||
316 | #define tNATIVE 296 | ||
317 | #define tNEW 297 | ||
318 | #define tOPERATOR 298 | ||
319 | #define tPUBLIC 299 | ||
320 | #define tRETURN 300 | ||
321 | #define tSIZEOF 301 | ||
322 | #define tSLEEP 302 | ||
323 | #define tSTATIC 303 | ||
324 | #define tSTOCK 304 | ||
325 | #define tSWITCH 305 | ||
326 | #define tTAGOF 306 | ||
327 | #define tWHILE 307 | ||
328 | /* compiler directives */ | ||
329 | #define tpASSERT 308 /* #assert */ | ||
330 | #define tpDEFINE 309 | ||
331 | #define tpELSE 310 /* #else */ | ||
332 | #define tpEMIT 311 | ||
333 | #define tpENDIF 312 | ||
334 | #define tpENDINPUT 313 | ||
335 | #define tpENDSCRPT 314 | ||
336 | #define tpFILE 315 | ||
337 | #define tpIF 316 /* #if */ | ||
338 | #define tINCLUDE 317 | ||
339 | #define tpLINE 318 | ||
340 | #define tpPRAGMA 319 | ||
341 | #define tpUNDEF 320 | ||
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 */ | ||
348 | #define tSYMBOL 325 | ||
349 | #define tLABEL 326 | ||
350 | #define tSTRING 327 | ||
351 | #define tEXPR 328 /* for assigment to "lastst" only */ | ||
352 | |||
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 */ | ||
358 | |||
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 */ | ||
370 | |||
371 | /* Miscellaneous */ | ||
372 | #if !defined TRUE | ||
373 | #define FALSE 0 | ||
374 | #define TRUE 1 | ||
375 | #endif | ||
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 */ | ||
385 | |||
386 | #if INT_MAX<0x8000u | ||
387 | #define PUBLICTAG 0x8000u | ||
388 | #define FIXEDTAG 0x4000u | ||
389 | #else | ||
390 | #define PUBLICTAG 0x80000000Lu | ||
391 | #define FIXEDTAG 0x40000000Lu | ||
392 | #endif | ||
393 | #define TAGMASK (~PUBLICTAG) | ||
394 | |||
395 | |||
396 | /* | ||
397 | * Functions you call from the "driver" program | ||
398 | */ | ||
399 | int sc_compile(int argc, char **argv); | ||
400 | int sc_addconstant(char *name, cell value, int tag); | ||
401 | int sc_addtag(char *name); | ||
402 | |||
403 | /* | ||
404 | * Functions called from the compiler (to be implemented by you) | ||
405 | */ | ||
406 | |||
407 | /* general console output */ | ||
408 | int sc_printf(const char *message, ...); | ||
409 | |||
410 | /* error report function */ | ||
411 | int sc_error(int number, char *message, char *filename, | ||
412 | int firstline, int lastline, va_list argptr); | ||
413 | |||
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); | ||
421 | |||
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); | ||
428 | |||
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 */ | ||
435 | |||
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, | ||
443 | short index); | ||
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); | ||
448 | |||
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); | ||
455 | void lexinit(void); | ||
456 | int lex(cell * lexvalue, char **lexsym); | ||
457 | void lexpush(void); | ||
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, | ||
475 | int tag, int usage); | ||
476 | symbol *addvariable(char *name, cell addr, int ident, int vclass, | ||
477 | int tag, int dim[], int numdim, int idxtag[]); | ||
478 | int getlabel(void); | ||
479 | char *itoh(ucell val); | ||
480 | |||
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, | ||
486 | int chkfuncresult); | ||
487 | int hier14(value * lval1); /* the highest expression level */ | ||
488 | |||
489 | /* function prototypes in SC4.C */ | ||
490 | void writeleader(void); | ||
491 | void writetrailer(void); | ||
492 | void begcseg(void); | ||
493 | void begdseg(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); | ||
501 | void endfunc(void); | ||
502 | void alignframe(int numbytes); | ||
503 | void defsymbol(char *name, int ident, int vclass, cell offset, | ||
504 | int tag); | ||
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); | ||
514 | void moveto1(void); | ||
515 | void push1(void); | ||
516 | void push2(void); | ||
517 | void pushval(cell val); | ||
518 | void pop1(void); | ||
519 | void pop2(void); | ||
520 | void swap1(void); | ||
521 | void ffswitch(int label); | ||
522 | void ffcase(cell value, char *labelname, int newtable); | ||
523 | void ffcall(symbol * sym, int numargs); | ||
524 | void ffret(void); | ||
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); | ||
540 | |||
541 | /* Code generation functions for arithmetic operators. | ||
542 | * | ||
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 | ||
548 | */ | ||
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) */ | ||
568 | |||
569 | void lneg(void); | ||
570 | void neg(void); | ||
571 | void invert(void); | ||
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); | ||
578 | |||
579 | /* function prototypes in SC5.C */ | ||
580 | int error(int number, ...); | ||
581 | void errorset(int code); | ||
582 | |||
583 | /* function prototypes in SC6.C */ | ||
584 | void assemble(FILE * fout, FILE * fin); | ||
585 | |||
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); | ||
596 | |||
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, | ||
606 | int prefixlen); | ||
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); | ||
611 | |||
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 */ | ||
660 | |||
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 */ | ||
664 | |||
665 | extern jmp_buf errbuf; /* target of longjmp() on a fatal error */ | ||
666 | |||
667 | #endif | ||