wearable/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 #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 #define sc_isspace(x)  isspace ((int)((unsigned char)x))
 668 #define sc_isalpha(x)  isalpha ((int)((unsigned char)x))
 669 #define sc_isdigit(x)  isdigit ((int)((unsigned char)x))
 670 #define sc_isupper(x)  isupper ((int)((unsigned char)x))
 671 #define sc_isxdigit(x) isxdigit((int)((unsigned char)x))
 672
 673 #endif