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