src/bin/embryo_cc_sc.h

   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$
  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 #include "embryo_cc_osdefs.h"
  40 #include "embryo_cc_amx.h"
  41
  42 /* Note: the "cell" and "ucell" types are defined in AMX.H */
  43
  44 #define PUBLIC_CHAR '@'         /* character that defines a function "public" */
  45 #define CTRL_CHAR   '\\'        /* default control character */
  46
  47 #define DIRSEP_CHAR '/'         /* directory separator character */
  48
  49 #define sDIMEN_MAX     2        /* maximum number of array dimensions */
  50 #define sDEF_LITMAX  500        /* initial size of the literal pool, in "cells" */
  51 #define sLINEMAX     65535      /* input line length (in characters) */
  52 #define sDEF_AMXSTACK 4096      /* default stack size for AMX files */
  53 #define sSTKMAX       80        /* stack for nested #includes and other uses */
  54 #define PREPROC_TERM  '\x7f'    /* termination character for preprocessor expressions (the "DEL" code) */
  55 #define sDEF_PREFIX   "default.inc"     /* default prefix filename */
  56
  57 typedef void       *stkitem;    /* type of items stored on the stack */
  58
  59 typedef struct __s_arginfo
  60 {                               /* function argument info */
  61    char                name[sNAMEMAX + 1];
  62    char                ident;   /* iVARIABLE, iREFERENCE, iREFARRAY or iVARARGS */
  63    char                usage;   /* uCONST */
  64    int                *tags;    /* argument tag id. list */
  65    int                 numtags; /* number of tags in the tag list */
  66    int                 dim[sDIMEN_MAX];
  67    int                 numdim;  /* number of dimensions */
  68    unsigned char       hasdefault;      /* bit0: is there a default value? bit6: "tagof"; bit7: "sizeof" */
  69    union
  70    {
  71       cell                val;  /* default value */
  72       struct
  73       {
  74          char               *symname;   /* name of another symbol */
  75          short               level;     /* indirection level for that symbol */
  76       } size;                   /* used for "sizeof" default value */
  77       struct
  78       {
  79          cell               *data;      /* values of default array */
  80          int                 size;      /* complete length of default array */
  81          int                 arraysize; /* size to reserve on the heap */
  82          cell                addr;      /* address of the default array in the data segment */
  83       } array;
  84    } defvalue;                  /* default value, or pointer to default array */
  85    int                 defvalue_tag;    /* tag of the default value */
  86 } arginfo;
  87
  88 /*  Equate table, tagname table, library table */
  89 typedef struct __s_constvalue
  90 {
  91    struct __s_constvalue *next;
  92    char                name[sNAMEMAX + 1];
  93    cell                value;
  94    short               index;
  95 } constvalue;
  96
  97 /*  Symbol table format
  98  *
  99  *  The symbol name read from the input file is stored in "name", the
 100  *  value of "addr" is written to the output file. The address in "addr"
 101  *  depends on the class of the symbol:
 102  *      global          offset into the data segment
 103  *      local           offset relative to the stack frame
 104  *      label           generated hexadecimal number
 105  *      function        offset into code segment
 106  */
 107 typedef struct __s_symbol
 108 {
 109    struct __s_symbol  *next;
 110    struct __s_symbol  *parent;  /* hierarchical types (multi-dimensional arrays) */
 111    char                name[sNAMEMAX + 1];
 112    unsigned int        hash;    /* value derived from name, for quicker searching */
 113    cell                addr;    /* address or offset (or value for constant, index for native function) */
 114    char                vclass;  /* sLOCAL if "addr" refers to a local symbol */
 115    char                ident;   /* see below for possible values */
 116    char                usage;   /* see below for possible values */
 117    int                 compound;        /* compound level (braces nesting level) */
 118    int                 tag;     /* tagname id */
 119    union
 120    {
 121       int                 declared;     /* label: how many local variables are declared */
 122       int                 idxtag;       /* array: tag of array indices */
 123       constvalue         *lib;  /* native function: library it is part of *///??? use "stringlist"
 124    } x;                         /* 'x' for 'extra' */
 125    union
 126    {
 127       arginfo            *arglist;      /* types of all parameters for functions */
 128       struct
 129       {
 130          cell                length;    /* arrays: length (size) */
 131          short               level;     /* number of dimensions below this level */
 132       } array;
 133    } dim;                       /* for 'dimension', both functions and arrays */
 134    int                 fnumber; /* static global variables: file number in which the declaration is visible */
 135    struct __s_symbol **refer;   /* referrer list, functions that "use" this symbol */
 136    int                 numrefers;       /* number of entries in the referrer list */
 137 } symbol;
 138
 139 /*  Possible entries for "ident". These are used in the "symbol", "value"
 140  *  and arginfo structures. Not every constant is valid for every use.
 141  *  In an argument list, the list is terminated with a "zero" ident; labels
 142  *  cannot be passed as function arguments, so the value 0 is overloaded.
 143  */
 144 #define iLABEL      0
 145 #define iVARIABLE   1           /* cell that has an address and that can be fetched directly (lvalue) */
 146 #define iREFERENCE  2           /* iVARIABLE, but must be dereferenced */
 147 #define iARRAY      3
 148 #define iREFARRAY   4           /* an array passed by reference (i.e. a pointer) */
 149 #define iARRAYCELL  5           /* array element, cell that must be fetched indirectly */
 150 #define iARRAYCHAR  6           /* array element, character from cell from array */
 151 #define iEXPRESSION 7           /* expression result, has no address (rvalue) */
 152 #define iCONSTEXPR  8           /* constant expression (or constant symbol) */
 153 #define iFUNCTN     9
 154 #define iREFFUNC    10          /* function passed as a parameter */
 155 #define iVARARGS    11          /* function specified ... as argument(s) */
 156
 157 /*  Possible entries for "usage"
 158  *
 159  *  This byte is used as a serie of bits, the syntax is different for
 160  *  functions and other symbols:
 161  *
 162  *  VARIABLE
 163  *  bits: 0     (uDEFINE) the variable is defined in the source file
 164  *        1     (uREAD) the variable is "read" (accessed) in the source file
 165  *        2     (uWRITTEN) the variable is altered (assigned a value)
 166  *        3     (uCONST) the variable is constant (may not be assigned to)
 167  *        4     (uPUBLIC) the variable is public
 168  *        6     (uSTOCK) the variable is discardable (without warning)
 169  *
 170  *  FUNCTION
 171  *  bits: 0     (uDEFINE) the function is defined ("implemented") in the source file
 172  *        1     (uREAD) the function is invoked in the source file
 173  *        2     (uRETVALUE) the function returns a value (or should return a value)
 174  *        3     (uPROTOTYPED) the function was prototyped
 175  *        4     (uPUBLIC) the function is public
 176  *        5     (uNATIVE) the function is native
 177  *        6     (uSTOCK) the function is discardable (without warning)
 178  *        7     (uMISSING) the function is not implemented in this source file
 179  *
 180  *  CONSTANT
 181  *  bits: 0     (uDEFINE) the symbol is defined in the source file
 182  *        1     (uREAD) the constant is "read" (accessed) in the source file
 183  *        3     (uPREDEF) the constant is pre-defined and should be kept between passes
 184  */
 185 #define uDEFINE   0x01
 186 #define uREAD     0x02
 187 #define uWRITTEN  0x04
 188 #define uRETVALUE 0x04          /* function returns (or should return) a value */
 189 #define uCONST    0x08
 190 #define uPROTOTYPED 0x08
 191 #define uPREDEF   0x08          /* constant is pre-defined */
 192 #define uPUBLIC   0x10
 193 #define uNATIVE   0x20
 194 #define uSTOCK    0x40
 195 #define uMISSING  0x80
 196 /* uRETNONE is not stored in the "usage" field of a symbol. It is
 197  * used during parsing a function, to detect a mix of "return;" and
 198  * "return value;" in a few special cases.
 199  */
 200 #define uRETNONE  0x10
 201
 202 #define uTAGOF    0x40          /* set in the "hasdefault" field of the arginfo struct */
 203 #define uSIZEOF   0x80          /* set in the "hasdefault" field of the arginfo struct */
 204
 205 #define uMAINFUNC "main"
 206
 207 #define sGLOBAL   0             /* global/local variable/constant class */
 208 #define sLOCAL    1
 209 #define sSTATIC   2             /* global life, local scope */
 210
 211 typedef struct
 212 {
 213    symbol             *sym;     /* symbol in symbol table, NULL for (constant) expression */
 214    cell                constval;        /* value of the constant expression (if ident==iCONSTEXPR)
 215                                          * also used for the size of a literal array */
 216    int                 tag;     /* tagname id (of the expression) */
 217    char                ident;   /* iCONSTEXPR, iVARIABLE, iARRAY, iARRAYCELL,
 218                                  * iEXPRESSION or iREFERENCE */
 219    char                boolresult;      /* boolean result for relational operators */
 220    cell               *arrayidx;        /* last used array indices, for checking self assignment */
 221 } value;
 222
 223 /*  "while" statement queue (also used for "for" and "do - while" loops) */
 224 enum
 225 {
 226    wqBRK,                       /* used to restore stack for "break" */
 227    wqCONT,                      /* used to restore stack for "continue" */
 228    wqLOOP,                      /* loop start label number */
 229    wqEXIT,                      /* loop exit label number (jump if false) */
 230    /* --- */
 231    wqSIZE                       /* "while queue" size */
 232 };
 233
 234 #define wqTABSZ (24*wqSIZE)     /* 24 nested loop statements */
 235
 236 enum
 237 {
 238    statIDLE,                    /* not compiling yet */
 239    statFIRST,                   /* first pass */
 240    statWRITE,                   /* writing output */
 241    statSKIP,                    /* skipping output */
 242 };
 243
 244 typedef struct __s_stringlist
 245 {
 246    struct __s_stringlist *next;
 247    char               *line;
 248 } stringlist;
 249
 250 typedef struct __s_stringpair
 251 {
 252    struct __s_stringpair *next;
 253    char               *first;
 254    char               *second;
 255    int                 matchlength;
 256 } stringpair;
 257
 258 /* macros for code generation */
 259 #define opcodes(n)      ((n)*sizeof(cell))      /* opcode size */
 260 #define opargs(n)       ((n)*sizeof(cell))      /* size of typical argument */
 261
 262 /*  Tokens recognized by lex()
 263  *  Some of these constants are assigned as well to the variable "lastst"
 264  */
 265 #define tFIRST   256            /* value of first multi-character operator */
 266 #define tMIDDLE  279            /* value of last multi-character operator */
 267 #define tLAST    320            /* value of last multi-character match-able token */
 268 /* multi-character operators */
 269 #define taMULT   256            /* *= */
 270 #define taDIV    257            /* /= */
 271 #define taMOD    258            /* %= */
 272 #define taADD    259            /* += */
 273 #define taSUB    260            /* -= */
 274 #define taSHL    261            /* <<= */
 275 #define taSHRU   262            /* >>>= */
 276 #define taSHR    263            /* >>= */
 277 #define taAND    264            /* &= */
 278 #define taXOR    265            /* ^= */
 279 #define taOR     266            /* |= */
 280 #define tlOR     267            /* || */
 281 #define tlAND    268            /* && */
 282 #define tlEQ     269            /* == */
 283 #define tlNE     270            /* != */
 284 #define tlLE     271            /* <= */
 285 #define tlGE     272            /* >= */
 286 #define tSHL     273            /* << */
 287 #define tSHRU    274            /* >>> */
 288 #define tSHR     275            /* >> */
 289 #define tINC     276            /* ++ */
 290 #define tDEC     277            /* -- */
 291 #define tELLIPS  278            /* ... */
 292 #define tDBLDOT  279            /* .. */
 293 /* reserved words (statements) */
 294 #define tASSERT  280
 295 #define tBREAK   281
 296 #define tCASE    282
 297 #define tCHAR    283
 298 #define tCONST   284
 299 #define tCONTINUE 285
 300 #define tDEFAULT 286
 301 #define tDEFINED 287
 302 #define tDO      288
 303 #define tELSE    289
 304 #define tENUM    290
 305 #define tEXIT    291
 306 #define tFOR     292
 307 #define tFORWARD 293
 308 #define tGOTO    294
 309 #define tIF      295
 310 #define tNATIVE  296
 311 #define tNEW     297
 312 #define tOPERATOR 298
 313 #define tPUBLIC  299
 314 #define tRETURN  300
 315 #define tSIZEOF  301
 316 #define tSLEEP   302
 317 #define tSTATIC  303
 318 #define tSTOCK   304
 319 #define tSWITCH  305
 320 #define tTAGOF   306
 321 #define tWHILE   307
 322 /* compiler directives */
 323 #define tpASSERT 308            /* #assert */
 324 #define tpDEFINE 309
 325 #define tpELSE   310            /* #else */
 326 #define tpEMIT   311
 327 #define tpENDIF  312
 328 #define tpENDINPUT 313
 329 #define tpENDSCRPT 314
 330 #define tpFILE   315
 331 #define tpIF     316            /* #if */
 332 #define tINCLUDE 317
 333 #define tpLINE   318
 334 #define tpPRAGMA 319
 335 #define tpUNDEF  320
 336 /* semicolon is a special case, because it can be optional */
 337 #define tTERM    321            /* semicolon or newline */
 338 #define tENDEXPR 322            /* forced end of expression */
 339 /* other recognized tokens */
 340 #define tNUMBER  323            /* integer number */
 341 #define tRATIONAL 324           /* rational number */
 342 #define tSYMBOL  325
 343 #define tLABEL   326
 344 #define tSTRING  327
 345 #define tEXPR    328            /* for assigment to "lastst" only */
 346
 347 /* (reversed) evaluation of staging buffer */
 348 #define sSTARTREORDER 1
 349 #define sENDREORDER   2
 350 #define sEXPRSTART    0xc0      /* top 2 bits set, rest is free */
 351 #define sMAXARGS      64        /* relates to the bit pattern of sEXPRSTART */
 352
 353 /* codes for ffabort() */
 354 #define xEXIT           1       /* exit code in PRI */
 355 #define xASSERTION      2       /* abort caused by failing assertion */
 356 #define xSTACKERROR     3       /* stack/heap overflow */
 357 #define xBOUNDSERROR    4       /* array index out of bounds */
 358 #define xMEMACCESS      5       /* data access error */
 359 #define xINVINSTR       6       /* invalid instruction */
 360 #define xSTACKUNDERFLOW 7       /* stack underflow */
 361 #define xHEAPUNDERFLOW  8       /* heap underflow */
 362 #define xCALLBACKERR    9       /* no, or invalid, callback */
 363 #define xSLEEP         12       /* sleep, exit code in PRI, tag in ALT */
 364
 365 /* Miscellaneous  */
 366 #if !defined TRUE
 367 #define FALSE         0
 368 #define TRUE          1
 369 #endif
 370 #define sIN_CSEG        1       /* if parsing CODE */
 371 #define sIN_DSEG        2       /* if parsing DATA */
 372 #define sCHKBOUNDS      1       /* bit position in "debug" variable: check bounds */
 373 #define sSYMBOLIC       2       /* bit position in "debug" variable: symbolic info */
 374 #define sNOOPTIMIZE     4       /* bit position in "debug" variable: no optimization */
 375 #define sRESET          0       /* reset error flag */
 376 #define sFORCESET       1       /* force error flag on */
 377 #define sEXPRMARK       2       /* mark start of expression */
 378 #define sEXPRRELEASE    3       /* mark end of expression */
 379
 380 #if INT_MAX<0x8000u
 381 #define PUBLICTAG   0x8000u
 382 #define FIXEDTAG    0x4000u
 383 #else
 384 #define PUBLICTAG   0x80000000Lu
 385 #define FIXEDTAG    0x40000000Lu
 386 #endif
 387 #define TAGMASK       (~PUBLICTAG)
 388
 389
 390 /*
 391  * Functions you call from the "driver" program
 392  */
 393    int                 sc_compile(int argc, char **argv);
 394    int                 sc_addconstant(char *name, cell value, int tag);
 395    int                 sc_addtag(char *name);
 396
 397 /*
 398  * Functions called from the compiler (to be implemented by you)
 399  */
 400
 401 /* general console output */
 402    int                 sc_printf(const char *message, ...);
 403
 404 /* error report function */
 405    int                 sc_error(int number, char *message, char *filename,
 406                                 int firstline, int lastline, va_list argptr);
 407
 408 /* input from source file */
 409    void               *sc_opensrc(char *filename);      /* reading only */
 410    void                sc_closesrc(void *handle);       /* never delete */
 411    void                sc_resetsrc(void *handle, void *position);       /* reset to a position marked earlier */
 412    char               *sc_readsrc(void *handle, char *target, int maxchars);
 413    void               *sc_getpossrc(void *handle);      /* mark the current position */
 414    int                 sc_eofsrc(void *handle);
 415
 416 /* output to intermediate (.ASM) file */
 417    void               *sc_openasm(int fd);      /* read/write */
 418    void                sc_closeasm(void *handle);
 419    void                sc_resetasm(void *handle);
 420    int                 sc_writeasm(void *handle, char *str);
 421    char               *sc_readasm(void *handle, char *target, int maxchars);
 422
 423 /* output to binary (.AMX) file */
 424    void               *sc_openbin(char *filename);
 425    void                sc_closebin(void *handle, int deletefile);
 426    void                sc_resetbin(void *handle);
 427    int                 sc_writebin(void *handle, void *buffer, int size);
 428    long                sc_lengthbin(void *handle);      /* return the length of the file */
 429
 430 /* function prototypes in SC1.C */
 431 symbol     *fetchfunc(char *name, int tag);
 432 char       *operator_symname(char *symname, char *opername, int tag1,
 433                                      int tag2, int numtags, int resulttag);
 434 char       *funcdisplayname(char *dest, char *funcname);
 435 int         constexpr(cell * val, int *tag);
 436 constvalue *append_constval(constvalue * table, char *name, cell val,
 437                                     short index);
 438 constvalue *find_constval(constvalue * table, char *name, short index);
 439 void        delete_consttable(constvalue * table);
 440 void        add_constant(char *name, cell val, int vclass, int tag);
 441 void        exporttag(int tag);
 442
 443 /* function prototypes in SC2.C */
 444 void        pushstk(stkitem val);
 445 stkitem     popstk(void);
 446 int         plungequalifiedfile(char *name);    /* explicit path included */
 447 int         plungefile(char *name, int try_currentpath, int try_includepaths);  /* search through "include" paths */
 448 void        preprocess(void);
 449 void        lexinit(void);
 450 int         lex(cell * lexvalue, char **lexsym);
 451 void        lexpush(void);
 452 void        lexclr(int clreol);
 453 int         matchtoken(int token);
 454 int         tokeninfo(cell * val, char **str);
 455 int         needtoken(int token);
 456 void        stowlit(cell value);
 457 int         alphanum(char c);
 458 void        delete_symbol(symbol * root, symbol * sym);
 459 void        delete_symbols(symbol * root, int level, int del_labels,
 460                                    int delete_functions);
 461 int         refer_symbol(symbol * entry, symbol * bywhom);
 462 void        markusage(symbol * sym, int usage);
 463 unsigned int namehash(char *name);
 464 symbol     *findglb(char *name);
 465 symbol     *findloc(char *name);
 466 symbol     *findconst(char *name);
 467 symbol     *finddepend(symbol * parent);
 468 symbol     *addsym(char *name, cell addr, int ident, int vclass,
 469                            int tag, int usage);
 470 symbol     *addvariable(char *name, cell addr, int ident, int vclass,
 471                                 int tag, int dim[], int numdim, int idxtag[]);
 472 int         getlabel(void);
 473 char       *itoh(ucell val);
 474
 475 /* function prototypes in SC3.C */
 476 int         check_userop(void (*oper) (void), int tag1, int tag2,
 477                                  int numparam, value * lval, int *resulttag);
 478 int         matchtag(int formaltag, int actualtag, int allowcoerce);
 479 int         expression(int *constant, cell * val, int *tag,
 480                                int chkfuncresult);
 481 int         hier14(value * lval1);      /* the highest expression level */
 482
 483 /* function prototypes in SC4.C */
 484 void        writeleader(void);
 485 void        writetrailer(void);
 486 void        begcseg(void);
 487 void        begdseg(void);
 488 void        setactivefile(int fnumber);
 489 cell        nameincells(char *name);
 490 void        setfile(char *name, int fileno);
 491 void        setline(int line, int fileno);
 492 void        setlabel(int index);
 493 void        endexpr(int fullexpr);
 494 void        startfunc(char *fname);
 495 void        endfunc(void);
 496 void        alignframe(int numbytes);
 497 void        defsymbol(char *name, int ident, int vclass, cell offset,
 498                               int tag);
 499 void        symbolrange(int level, cell size);
 500 void        rvalue(value * lval);
 501 void        address(symbol * ptr);
 502 void        store(value * lval);
 503 void        memcopy(cell size);
 504 void        copyarray(symbol * sym, cell size);
 505 void        fillarray(symbol * sym, cell size, cell value);
 506 void        const1(cell val);
 507 void        const2(cell val);
 508 void        moveto1(void);
 509 void        push1(void);
 510 void        push2(void);
 511 void        pushval(cell val);
 512 void        pop1(void);
 513 void        pop2(void);
 514 void        swap1(void);
 515 void        ffswitch(int label);
 516 void        ffcase(cell value, char *labelname, int newtable);
 517 void        ffcall(symbol * sym, int numargs);
 518 void        ffret(void);
 519 void        ffabort(int reason);
 520 void        ffbounds(cell size);
 521 void        jumplabel(int number);
 522 void        defstorage(void);
 523 void        modstk(int delta);
 524 void        setstk(cell value);
 525 void        modheap(int delta);
 526 void        setheap_pri(void);
 527 void        setheap(cell value);
 528 void        cell2addr(void);
 529 void        cell2addr_alt(void);
 530 void        addr2cell(void);
 531 void        char2addr(void);
 532 void        charalign(void);
 533 void        addconst(cell value);
 534
 535 /*  Code generation functions for arithmetic operators.
 536  *
 537  *  Syntax: o[u|s|b]_name
 538  *          |   |   | +--- name of operator
 539  *          |   |   +----- underscore
 540  *          |   +--------- "u"nsigned operator, "s"igned operator or "b"oth
 541  *          +------------- "o"perator
 542  */
 543 void        os_mult(void);      /* multiplication (signed) */
 544 void        os_div(void);       /* division (signed) */
 545 void        os_mod(void);       /* modulus (signed) */
 546 void        ob_add(void);       /* addition */
 547 void        ob_sub(void);       /* subtraction */
 548 void        ob_sal(void);       /* shift left (arithmetic) */
 549 void        os_sar(void);       /* shift right (arithmetic, signed) */
 550 void        ou_sar(void);       /* shift right (logical, unsigned) */
 551 void        ob_or(void);        /* bitwise or */
 552 void        ob_xor(void);       /* bitwise xor */
 553 void        ob_and(void);       /* bitwise and */
 554 void        ob_eq(void);        /* equality */
 555 void        ob_ne(void);        /* inequality */
 556 void        relop_prefix(void);
 557 void        relop_suffix(void);
 558 void        os_le(void);        /* less or equal (signed) */
 559 void        os_ge(void);        /* greater or equal (signed) */
 560 void        os_lt(void);        /* less (signed) */
 561 void        os_gt(void);        /* greater (signed) */
 562
 563 void        lneg(void);
 564 void        neg(void);
 565 void        invert(void);
 566 void        nooperation(void);
 567 void        inc(value * lval);
 568 void        dec(value * lval);
 569 void        jmp_ne0(int number);
 570 void        jmp_eq0(int number);
 571 void        outval(cell val, int newline);
 572
 573 /* function prototypes in SC5.C */
 574 int         error(int number, ...);
 575 void        errorset(int code);
 576
 577 /* function prototypes in SC6.C */
 578 void        assemble(FILE * fout, FILE * fin);
 579
 580 /* function prototypes in SC7.C */
 581 void        stgbuffer_cleanup(void);
 582 void        stgmark(char mark);
 583 void        stgwrite(char *st);
 584 void        stgout(int index);
 585 void        stgdel(int index, cell code_index);
 586 int         stgget(int *index, cell * code_index);
 587 void        stgset(int onoff);
 588 int         phopt_init(void);
 589 int         phopt_cleanup(void);
 590
 591 /* function prototypes in SCLIST.C */
 592 stringpair *insert_alias(char *name, char *alias);
 593 stringpair *find_alias(char *name);
 594 int         lookup_alias(char *target, char *name);
 595 void        delete_aliastable(void);
 596 stringlist *insert_path(char *path);
 597 char       *get_path(int index);
 598 void        delete_pathtable(void);
 599 stringpair *insert_subst(char *pattern, char *substitution,
 600                                  int prefixlen);
 601 int         get_subst(int index, char **pattern, char **substitution);
 602 stringpair *find_subst(char *name, int length);
 603 int         delete_subst(char *name, int length);
 604 void        delete_substtable(void);
 605
 606 /* external variables (defined in scvars.c) */
 607 extern symbol     loctab;       /* local symbol table */
 608 extern symbol     glbtab;       /* global symbol table */
 609 extern cell      *litq; /* the literal queue */
 610 extern char       pline[];      /* the line read from the input file */
 611 extern char      *lptr; /* points to the current position in "pline" */
 612 extern constvalue tagname_tab;  /* tagname table */
 613 extern constvalue libname_tab;  /* library table (#pragma library "..." syntax) *///??? use "stringlist" type
 614 extern constvalue *curlibrary;  /* current library */
 615 extern symbol    *curfunc;      /* pointer to current function */
 616 extern char      *inpfname;     /* name of the file currently read from */
 617 extern char       outfname[];   /* output file name */
 618 extern char       sc_ctrlchar;  /* the control character (or escape character) */
 619 extern int        litidx;       /* index to literal table */
 620 extern int        litmax;       /* current size of the literal table */
 621 extern int        stgidx;       /* index to the staging buffer */
 622 extern int        labnum;       /* number of (internal) labels */
 623 extern int        staging;      /* true if staging output */
 624 extern cell       declared;     /* number of local cells declared */
 625 extern cell       glb_declared; /* number of global cells declared */
 626 extern cell       code_idx;     /* number of bytes with generated code */
 627 extern int        ntv_funcid;   /* incremental number of native function */
 628 extern int        errnum;       /* number of errors */
 629 extern int        warnnum;      /* number of warnings */
 630 extern int        sc_debug;     /* debug/optimization options (bit field) */
 631 extern int        charbits;     /* number of bits for a character */
 632 extern int        sc_packstr;   /* strings are packed by default? */
 633 extern int        sc_asmfile;   /* create .ASM file? */
 634 extern int        sc_listing;   /* create .LST file? */
 635 extern int        sc_compress;  /* compress bytecode? */
 636 extern int        sc_needsemicolon;     /* semicolon required to terminate expressions? */
 637 extern int        sc_dataalign; /* data alignment value */
 638 extern int        sc_alignnext; /* must frame of the next function be aligned? */
 639 extern int        curseg;       /* 1 if currently parsing CODE, 2 if parsing DATA */
 640 extern cell       sc_stksize;   /* stack size */
 641 extern int        freading;     /* is there an input file ready for reading? */
 642 extern int        fline;        /* the line number in the current file */
 643 extern int        fnumber;      /* number of files in the file table (debugging) */
 644 extern int        fcurrent;     /* current file being processed (debugging) */
 645 extern int        intest;       /* true if inside a test */
 646 extern int        sideeffect;   /* true if an expression causes a side-effect */
 647 extern int        stmtindent;   /* current indent of the statement */
 648 extern int        indent_nowarn;        /* skip warning "217 loose indentation" */
 649 extern int        sc_tabsize;   /* number of spaces that a TAB represents */
 650 extern int        sc_allowtags; /* allow/detect tagnames in lex() */
 651 extern int        sc_status;    /* read/write status */
 652 extern int        sc_rationaltag;       /* tag for rational numbers */
 653 extern int        rational_digits;      /* number of fractional digits */
 654
 655 extern FILE      *inpf; /* file read from (source or include) */
 656 extern FILE      *inpf_org;     /* main source file */
 657 extern FILE      *outf; /* file written to */
 658
 659 extern jmp_buf    errbuf;       /* target of longjmp() on a fatal error */
 660
 661 #endif