Return to 0.h CVS log

Up to [CSRG BSD Unix] / 41BSD / cmd / pi

Annotation of 41BSD/cmd/pi/0.h, revision 1.1

1.1     ! root        1: /* Copyright (c) 1979 Regents of the University of California */
        !             2: 
        !             3: /* static      char sccsid[] = "@(#)0.h 1.3 10/2/80"; */
        !             4: 
        !             5: #define DEBUG
        !             6: #define        CHAR
        !             7: #define        STATIC
        !             8: #define hp21mx 0
        !             9: 
        !            10: #include       <stdio.h>
        !            11: #include       <sys/types.h>
        !            12: 
        !            13: #define                bool    short
        !            14: #define                TRUE    1
        !            15: #define                FALSE   0
        !            16: 
        !            17: /*
        !            18:  * Option flags
        !            19:  *
        !            20:  * The following options are recognized in the text of the program
        !            21:  * and also on the command line:
        !            22:  *
        !            23:  *     b       block buffer the file output
        !            24:  *
        !            25:  *     i       make a listing of the procedures and functions in
        !            26:  *             the following include files
        !            27:  *
        !            28:  *     l       make a listing of the program
        !            29:  *
        !            30:  *     n       place each include file on a new page with a header
        !            31:  *
        !            32:  *     p       disable post mortem and statement limit counting
        !            33:  *
        !            34:  *     t       disable run-time tests
        !            35:  *
        !            36:  *     u       card image mode; only first 72 chars of input count
        !            37:  *
        !            38:  *     w       suppress special diagnostic warnings
        !            39:  *
        !            40:  *     z       generate counters for an execution profile
        !            41:  */
        !            42: #ifdef DEBUG
        !            43: bool   fulltrace, errtrace, testtrace, yyunique;
        !            44: #endif DEBUG
        !            45: 
        !            46: /*
        !            47:  * Each option has a stack of 17 option values, with opts giving
        !            48:  * the current, top value, and optstk the value beneath it.
        !            49:  * One refers to option `l' as, e.g., opt('l') in the text for clarity.
        !            50:  */
        !            51: char   opts[ 'z' - 'A' + 1];
        !            52: short  optstk[ 'z' - 'A' + 1];
        !            53: 
        !            54: #define opt(c) opts[c-'A']
        !            55: 
        !            56: /*
        !            57:  * Monflg is set when we are generating
        !            58:  * a pxp profile.  this is set by the -z command line option.
        !            59:  */
        !            60: bool   monflg;
        !            61: 
        !            62:     /*
        !            63:      * profflag is set when we are generating a prof profile.
        !            64:      * this is set by the -p command line option.
        !            65:      */
        !            66: bool   profflag;
        !            67: 
        !            68: 
        !            69: /*
        !            70:  * NOTES ON THE DYNAMIC NATURE OF THE DATA STRUCTURES
        !            71:  *
        !            72:  * Pi uses expandable tables for
        !            73:  * its namelist (symbol table), string table
        !            74:  * hash table, and parse tree space.  The following
        !            75:  * definitions specify the size of the increments
        !            76:  * for these items in fundamental units so that
        !            77:  * each uses approximately 1024 bytes.
        !            78:  */
        !            79: 
        !            80: #define        STRINC  1024            /* string space increment */
        !            81: #define        TRINC   512             /* tree space increment */
        !            82: #define        HASHINC 509             /* hash table size in words, each increment */
        !            83: #define        NLINC   56              /* namelist increment size in nl structs */
        !            84: 
        !            85: /*
        !            86:  * The initial sizes of the structures.
        !            87:  * These should be large enough to compile
        !            88:  * an "average" sized program so as to minimize
        !            89:  * storage requests.
        !            90:  * On a small system or and 11/34 or 11/40
        !            91:  * these numbers can be trimmed to make the
        !            92:  * compiler smaller.
        !            93:  */
        !            94: #define        ITREE   2000
        !            95: #define        INL     200
        !            96: #define        IHASH   509
        !            97: 
        !            98: /*
        !            99:  * The following limits on hash and tree tables currently
        !           100:  * allow approximately 1200 symbols and 20k words of tree
        !           101:  * space.  The fundamental limit of 64k total data space
        !           102:  * should be exceeded well before these are full.
        !           103:  */
        !           104: /*
        !           105:  * TABLE_MULTIPLIER is for uniformly increasing the sizes of the tables
        !           106:  */
        !           107: #define TABLE_MULTIPLIER       8
        !           108: #define        MAXHASH (4 * TABLE_MULTIPLIER)
        !           109: #define        MAXNL   (12 * TABLE_MULTIPLIER)
        !           110: #define        MAXTREE (30 * TABLE_MULTIPLIER)
        !           111: /*
        !           112:  * MAXDEPTH is the depth of the parse stack.
        !           113:  * STACK_MULTIPLIER is for increasing its size.
        !           114:  */
        !           115: #define        STACK_MULTIPLIER        8
        !           116: #define        MAXDEPTH ( 150 * STACK_MULTIPLIER )
        !           117: 
        !           118: /*
        !           119:  * ERROR RELATED DEFINITIONS
        !           120:  */
        !           121: 
        !           122: /*
        !           123:  * Exit statuses to pexit
        !           124:  *
        !           125:  * AOK
        !           126:  * ERRS                Compilation errors inhibit obj productin
        !           127:  * NOSTART     Errors before we ever got started
        !           128:  * DIED                We ran out of memory or some such
        !           129:  */
        !           130: #define        AOK     0
        !           131: #define        ERRS    1
        !           132: #define        NOSTART 2
        !           133: #define        DIED    3
        !           134: 
        !           135: bool   Recovery;
        !           136: 
        !           137: #define        eholdnl()       Eholdnl = 1
        !           138: #define        nocascade()     Enocascade = 1
        !           139: 
        !           140: bool   Eholdnl, Enocascade;
        !           141: 
        !           142: 
        !           143: /*
        !           144:  * The flag eflg is set whenever we have a hard error.
        !           145:  * The character in errpfx will precede the next error message.
        !           146:  * When cgenflg is set code generation is suppressed.
        !           147:  * This happens whenver we have an error (i.e. if eflg is set)
        !           148:  * and when we are walking the tree to determine types only.
        !           149:  */
        !           150: bool   eflg;
        !           151: char   errpfx;
        !           152: 
        !           153: #define        setpfx(x)       errpfx = x
        !           154: 
        !           155: #define        standard()      setpfx('s')
        !           156: #define        warning()       setpfx('w')
        !           157: #define        recovered()     setpfx('e')
        !           158: 
        !           159: bool   cgenflg;
        !           160: 
        !           161: 
        !           162: /*
        !           163:  * The flag syneflg is used to suppress the diagnostics of the form
        !           164:  *     E 10 a, defined in someprocedure, is neither used nor set
        !           165:  * when there were syntax errors in "someprocedure".
        !           166:  * In this case, it is likely that these warinings would be spurious.
        !           167:  */
        !           168: bool   syneflg;
        !           169: 
        !           170: /*
        !           171:  * The compiler keeps its error messages in a file.
        !           172:  * The variable efil is the unit number on which
        !           173:  * this file is open for reading of error message text.
        !           174:  * Similarly, the file ofil is the unit of the file
        !           175:  * "obj" where we write the interpreter code.
        !           176:  */
        !           177: short  efil;
        !           178: short  ofil;
        !           179: short  obuf[518];
        !           180: 
        !           181: #define        elineoff()      Enoline++
        !           182: #define        elineon()       Enoline = 0
        !           183: 
        !           184: bool   Enoline;
        !           185: 
        !           186: /*
        !           187:  * SYMBOL TABLE STRUCTURE DEFINITIONS
        !           188:  *
        !           189:  * The symbol table is henceforth referred to as the "namelist".
        !           190:  * It consists of a number of structures of the form "nl" below.
        !           191:  * These are contained in a number of segments of the symbol
        !           192:  * table which are dynamically allocated as needed.
        !           193:  * The major namelist manipulation routines are contained in the
        !           194:  * file "nl.c".
        !           195:  *
        !           196:  * The major components of a namelist entry are the "symbol", giving
        !           197:  * a pointer into the string table for the string associated with this
        !           198:  * entry and the "class" which tells which of the (currently 19)
        !           199:  * possible types of structure this is.
        !           200:  *
        !           201:  * Many of the classes use the "type" field for a pointer to the type
        !           202:  * which the entry has.
        !           203:  *
        !           204:  * Other pieces of information in more than one class include the block
        !           205:  * in which the symbol is defined, flags indicating whether the symbol
        !           206:  * has been used and whether it has been assigned to, etc.
        !           207:  *
        !           208:  * A more complete discussion of the features of the namelist is impossible
        !           209:  * here as it would be too voluminous.  Refer to the "PI 1.0 Implementation
        !           210:  * Notes" for more details.
        !           211:  */
        !           212: 
        !           213: /*
        !           214:  * The basic namelist structure.
        !           215:  * There are also two other variants, defining the real
        !           216:  * field as longs or integers given below.
        !           217:  *
        !           218:  * The array disptab defines the hash header for the symbol table.
        !           219:  * Symbols are hashed based on the low 6 bits of their pointer into
        !           220:  * the string table; see the routines in the file "lookup.c" and also "fdec.c"
        !           221:  * especially "funcend".
        !           222:  */
        !           223: #ifdef PTREE
        !           224: #   include    "pTree.h"
        !           225: #endif PTREE
        !           226: struct nl {
        !           227:        char    *symbol;
        !           228:        char    class, nl_flags;
        !           229: #ifdef PC
        !           230:        char    ext_flags;      /* an extra flag is used for externals */
        !           231: #endif PC
        !           232:        struct  nl *type;
        !           233:        struct  nl *chain, *nl_next;
        !           234:        int     *ptr[4];
        !           235: #ifdef PI
        !           236:        int     entloc;
        !           237: #endif PI
        !           238: #      ifdef PTREE
        !           239:            pPointer    inTree;
        !           240: #      endif PTREE
        !           241: } *nlp, *disptab[077+1];
        !           242: 
        !           243: extern struct nl nl[INL];
        !           244: 
        !           245: struct {
        !           246:        char    *symbol;
        !           247:        char    class, nl_flags;
        !           248: #ifdef PC
        !           249:        char    ext_flags;
        !           250: #endif
        !           251:        struct  nl *type;
        !           252:        struct  nl *chain, *nl_next;
        !           253:        double  real;
        !           254: };
        !           255: 
        !           256: struct {
        !           257:        char    *symbol;
        !           258:        char    class, nl_block;
        !           259: #ifdef PC
        !           260:        char    ext_flags;
        !           261: #endif
        !           262:        struct  nl *type;
        !           263:        struct  nl *chain, *nl_next;
        !           264:        long    range[2];
        !           265: };
        !           266: 
        !           267: struct {
        !           268:        char    *symbol;
        !           269:        char    class, nl_flags;
        !           270: #ifdef PC
        !           271:        char    ext_flags;
        !           272: #endif
        !           273:        struct  nl *type;
        !           274:        struct  nl *chain, *nl_next;
        !           275:        long    value[4];
        !           276: };
        !           277: 
        !           278: /*
        !           279:  * NL FLAGS BITS
        !           280:  *
        !           281:  * Definitions of the usage of the bits in
        !           282:  * the nl_flags byte. Note that the low 5 bits of the
        !           283:  * byte are the "nl_block" and that some classes make use
        !           284:  * of this byte as a "width".
        !           285:  *
        !           286:  * The only non-obvious bit definition here is "NFILES"
        !           287:  * which records whether a structure contains any files.
        !           288:  * Such structures are not allowed to be dynamically allocated.
        !           289:  */
        !           290: #define        NUSED   0100
        !           291: #define        NMOD    0040
        !           292: #define        NFORWD  0200
        !           293: #define        NFILES  0200
        !           294: 
        !           295: #ifdef PC
        !           296: #define NEXTERN 0001   /* flag used to mark external funcs and procs */
        !           297: #endif
        !           298: 
        !           299: /*
        !           300:  * Definition of the commonly used "value" fields.
        !           301:  * The most important one is NL_OFFS which gives
        !           302:  * the offset of a variable in its stack mark.
        !           303:  */
        !           304: #define NL_OFFS        0
        !           305: 
        !           306: #define        NL_CNTR 1
        !           307: #define        NL_FVAR 3
        !           308: 
        !           309: #define NL_GOLEV 2
        !           310: #define NL_GOLINE 3
        !           311: #define NL_FORV 1
        !           312: 
        !           313: #define        NL_FLDSZ 1
        !           314: #define        NL_VARNT 2
        !           315: #define        NL_VTOREC 2
        !           316: #define        NL_TAG  3
        !           317: 
        !           318: #define        NL_ELABEL       3
        !           319: 
        !           320: /*
        !           321:  * For BADUSE nl structures, NL_KINDS is a bit vector
        !           322:  * indicating the kinds of illegal usages complained about
        !           323:  * so far.  For kind of bad use "kind", "1 << kind" is set.
        !           324:  * The low bit is reserved as ISUNDEF to indicate whether
        !           325:  * this identifier is totally undefined.
        !           326:  */
        !           327: #define        NL_KINDS        0
        !           328: 
        !           329: #define        ISUNDEF         1
        !           330: 
        !           331: /*
        !           332:  * NAMELIST CLASSES
        !           333:  *
        !           334:  * The following are the namelist classes.
        !           335:  * Different classes make use of the value fields
        !           336:  * of the namelist in different ways.
        !           337:  *
        !           338:  * The namelist should be redesigned by providing
        !           339:  * a number of structure definitions with one corresponding
        !           340:  * to each namelist class, ala a variant record in Pascal.
        !           341:  */
        !           342: #define        BADUSE  0
        !           343: #define        CONST   1
        !           344: #define        TYPE    2
        !           345: #define        VAR     3
        !           346: #define        ARRAY   4
        !           347: #define        PTRFILE 5
        !           348: #define        RECORD  6
        !           349: #define        FIELD   7
        !           350: #define        PROC    8
        !           351: #define        FUNC    9
        !           352: #define        FVAR    10
        !           353: #define        REF     11
        !           354: #define        PTR     12
        !           355: #define        FILET   13
        !           356: #define        SET     14
        !           357: #define        RANGE   15
        !           358: #define        LABEL   16
        !           359: #define        WITHPTR 17
        !           360: #define        SCAL    18
        !           361: #define        STR     19
        !           362: #define        PROG    20
        !           363: #define        IMPROPER 21
        !           364: #define        VARNT   22
        !           365: #define        FPROC   23
        !           366: #define        FFUNC   24
        !           367: 
        !           368: /*
        !           369:  * Clnames points to an array of names for the
        !           370:  * namelist classes.
        !           371:  */
        !           372: char   **clnames;
        !           373: 
        !           374: /*
        !           375:  * PRE-DEFINED NAMELIST OFFSETS
        !           376:  *
        !           377:  * The following are the namelist offsets for the
        !           378:  * primitive types. The ones which are negative
        !           379:  * don't actually exist, but are generated and tested
        !           380:  * internally. These definitions are sensitive to the
        !           381:  * initializations in nl.c.
        !           382:  */
        !           383: #define        TFIRST -7
        !           384: #define        TFILE  -7
        !           385: #define        TREC   -6
        !           386: #define        TARY   -5
        !           387: #define        TSCAL  -4
        !           388: #define        TPTR   -3
        !           389: #define        TSET   -2
        !           390: #define        TSTR   -1
        !           391: #define        NIL     0
        !           392: #define        TBOOL   1
        !           393: #define        TCHAR   2
        !           394: #define        TINT    3
        !           395: #define        TDOUBLE 4
        !           396: #define        TNIL    5
        !           397: #define        T1INT   6
        !           398: #define        T2INT   7
        !           399: #define        T4INT   8
        !           400: #define        T1CHAR  9
        !           401: #define        T1BOOL  10
        !           402: #define        T8REAL  11
        !           403: #define TLAST  11
        !           404: 
        !           405: /*
        !           406:  * SEMANTIC DEFINITIONS
        !           407:  */
        !           408: 
        !           409: /*
        !           410:  * NOCON and SAWCON are flags in the tree telling whether
        !           411:  * a constant set is part of an expression.
        !           412:  */
        !           413: #define NOCON  0
        !           414: #define SAWCON 1
        !           415: 
        !           416: /*
        !           417:  * The variable cbn gives the current block number,
        !           418:  * the variable bn is set as a side effect of a call to
        !           419:  * lookup, and is the block number of the variable which
        !           420:  * was found.
        !           421:  */
        !           422: short  bn, cbn;
        !           423: 
        !           424: /*
        !           425:  * The variable line is the current semantic
        !           426:  * line and is set in stat.c from the numbers
        !           427:  * embedded in statement type tree nodes.
        !           428:  */
        !           429: short  line;
        !           430: 
        !           431: /*
        !           432:  * The size of the display
        !           433:  * which defines the maximum nesting
        !           434:  * of procedures and functions allowed.
        !           435:  * Because of the flags in the current namelist
        !           436:  * this must be no greater than 32.
        !           437:  */
        !           438: #define        DSPLYSZ 20
        !           439: 
        !           440: /*
        !           441:  * The following structure is used
        !           442:  * to keep track of the amount of variable
        !           443:  * storage required by each block.
        !           444:  * "Max" is the high water mark, "off"
        !           445:  * the current need. Temporaries for "for"
        !           446:  * loops and "with" statements are allocated
        !           447:  * in the local variable area and these
        !           448:  * numbers are thereby changed if necessary.
        !           449:  */
        !           450: struct om {
        !           451:        long    om_off;
        !           452:        long    om_max;
        !           453: } sizes[DSPLYSZ];
        !           454: 
        !           455:     /*
        !           456:      * the following structure records whether a level declares
        !           457:      * any variables which are (or contain) files.
        !           458:      * this so that the runtime routines for file cleanup can be invoked.
        !           459:      */
        !           460: bool   dfiles[ DSPLYSZ ];
        !           461: 
        !           462: /*
        !           463:  * Structure recording information about a constant
        !           464:  * declaration.  It is actually the return value from
        !           465:  * the routine "gconst", but since C doesn't support
        !           466:  * record valued functions, this is more convenient.
        !           467:  */
        !           468: struct {
        !           469:        struct nl       *ctype;
        !           470:        short           cival;
        !           471:        double          crval;
        !           472:        int             *cpval;
        !           473: } con;
        !           474: 
        !           475: /*
        !           476:  * The set structure records the lower bound
        !           477:  * and upper bound with the lower bound normalized
        !           478:  * to zero when working with a set. It is set by
        !           479:  * the routine setran in var.c.
        !           480:  */
        !           481: struct {
        !           482:        short   lwrb, uprbp;
        !           483: } set;
        !           484: 
        !           485:     /*
        !           486:      * structures of this kind are filled in by precset and used by postcset
        !           487:      * to indicate things about constant sets.
        !           488:      */
        !           489: struct csetstr {
        !           490:     struct nl  *csettype;
        !           491:     long       paircnt;
        !           492:     long       singcnt;
        !           493:     bool       comptime;
        !           494: };
        !           495: /*
        !           496:  * The following flags are passed on calls to lvalue
        !           497:  * to indicate how the reference is to affect the usage
        !           498:  * information for the variable being referenced.
        !           499:  * MOD is used to set the NMOD flag in the namelist
        !           500:  * entry for the variable, ASGN permits diagnostics
        !           501:  * to be formed when a for variable is assigned to in
        !           502:  * the range of the loop.
        !           503:  */
        !           504: #define        NOFLAGS 0
        !           505: #define        MOD     01
        !           506: #define        ASGN    02
        !           507: #define        NOUSE   04
        !           508: 
        !           509:     /*
        !           510:      * the following flags are passed to lvalue and rvalue
        !           511:      * to tell them whether an lvalue or rvalue is required.
        !           512:      * the semantics checking is done according to the function called,
        !           513:      * but for pc, lvalue may put out an rvalue by indirecting afterwards,
        !           514:      * and rvalue may stop short of putting out the indirection.
        !           515:      */
        !           516: #define        LREQ    01
        !           517: #define        RREQ    02
        !           518: 
        !           519: double MAXINT;
        !           520: double MININT;
        !           521: 
        !           522: /*
        !           523:  * Variables for generation of profile information.
        !           524:  * Monflg is set when we want to generate a profile.
        !           525:  * Gocnt record the total number of goto's and
        !           526:  * cnts records the current counter for generating
        !           527:  * COUNT operators.
        !           528:  */
        !           529: short  gocnt;
        !           530: short  cnts;
        !           531: 
        !           532: /*
        !           533:  * Most routines call "incompat" rather than asking "!compat"
        !           534:  * for historical reasons.
        !           535:  */
        !           536: #define incompat       !compat
        !           537: 
        !           538: /*
        !           539:  * Parts records which declaration parts have been seen.
        !           540:  * The grammar allows the "label" "const" "type" "var" and routine
        !           541:  * parts to be repeated and to be in any order, so that
        !           542:  * they can be detected semantically to give better
        !           543:  * error diagnostics.
        !           544:  */
        !           545: int    parts[ DSPLYSZ ];
        !           546: 
        !           547: #define        LPRT    1
        !           548: #define        CPRT    2
        !           549: #define        TPRT    4
        !           550: #define        VPRT    8
        !           551: #define        RPRT    16
        !           552: 
        !           553: /*
        !           554:  * Flags for the "you used / instead of div" diagnostic
        !           555:  */
        !           556: bool   divchk;
        !           557: bool   divflg;
        !           558: 
        !           559: short  errcnt[DSPLYSZ];
        !           560: 
        !           561: /*
        !           562:  * Forechain links those types which are
        !           563:  *     ^ sometype
        !           564:  * so that they can be evaluated later, permitting
        !           565:  * circular, recursive list structures to be defined.
        !           566:  */
        !           567: struct nl *forechain;
        !           568: 
        !           569: /*
        !           570:  * Withlist links all the records which are currently
        !           571:  * opened scopes because of with statements.
        !           572:  */
        !           573: struct nl *withlist;
        !           574: 
        !           575: struct nl *intset;
        !           576: struct nl *input, *output;
        !           577: struct nl *program;
        !           578: 
        !           579: /* progseen flag used by PC to determine if
        !           580:  * a routine segment is being compiled (and
        !           581:  * therefore no program statement seen)
        !           582:  */
        !           583: bool   progseen;
        !           584: 
        !           585: 
        !           586: /*
        !           587:  * STRUCTURED STATEMENT GOTO CHECKING
        !           588:  *
        !           589:  * The variable level keeps track of the current
        !           590:  * "structured statement level" when processing the statement
        !           591:  * body of blocks.  This is used in the detection of goto's into
        !           592:  * structured statements in a block.
        !           593:  *
        !           594:  * Each label's namelist entry contains two pieces of information
        !           595:  * related to this check. The first `NL_GOLEV' either contains
        !           596:  * the level at which the label was declared, `NOTYET' if the label
        !           597:  * has not yet been declared, or `DEAD' if the label is dead, i.e.
        !           598:  * if we have exited the level in which the label was defined.
        !           599:  *
        !           600:  * When we discover a "goto" statement, if the label has not
        !           601:  * been defined yet, then we record the current level and the current line
        !           602:  * for a later error check.  If the label has been already become "DEAD"
        !           603:  * then a reference to it is an error.  Now the compiler maintains,
        !           604:  * for each block, a linked list of the labels headed by "gotos[bn]".
        !           605:  * When we exit a structured level, we perform the routine
        !           606:  * ungoto in stat.c. It notices labels whose definition levels have been
        !           607:  * exited and makes them be dead. For labels which have not yet been
        !           608:  * defined, ungoto will maintain NL_GOLEV as the minimum structured level
        !           609:  * since the first usage of the label. It is not hard to see that the label
        !           610:  * must eventually be declared at this level or an outer level to this
        !           611:  * one or a goto into a structured statement will exist.
        !           612:  */
        !           613: short  level;
        !           614: struct nl *gotos[DSPLYSZ];
        !           615: 
        !           616: #define        NOTYET  10000
        !           617: #define        DEAD    10000
        !           618: 
        !           619: /*
        !           620:  * Noreach is true when the next statement will
        !           621:  * be unreachable unless something happens along
        !           622:  * (like exiting a looping construct) to save
        !           623:  * the day.
        !           624:  */
        !           625: bool   noreach;
        !           626: 
        !           627: /*
        !           628:  * UNDEFINED VARIABLE REFERENCE STRUCTURES
        !           629:  */
        !           630: struct udinfo {
        !           631:        int     ud_line;
        !           632:        struct  udinfo *ud_next;
        !           633:        char    nullch;
        !           634: };
        !           635: 
        !           636: /*
        !           637:  * CODE GENERATION DEFINITIONS
        !           638:  */
        !           639: 
        !           640: /*
        !           641:  * NSTAND is or'ed onto the abstract machine opcode
        !           642:  * for non-standard built-in procedures and functions.
        !           643:  */
        !           644: #define        NSTAND  0400
        !           645: 
        !           646: #define        codeon()        cgenflg++
        !           647: #define        codeoff()       --cgenflg
        !           648: 
        !           649: /*
        !           650:  * Codeline is the last lino output in the code generator.
        !           651:  * It used to be used to suppress LINO operators but no
        !           652:  * more since we now count statements.
        !           653:  * Lc is the intepreter code location counter.
        !           654:  *
        !           655: short  codeline;
        !           656:  */
        !           657: char   *lc;
        !           658: 
        !           659: 
        !           660: /*
        !           661:  * Routines which need types
        !           662:  * other than "integer" to be
        !           663:  * assumed by the compiler.
        !           664:  */
        !           665: double         atof();
        !           666: long           lwidth();
        !           667: long           aryconst();
        !           668: long           a8tol();
        !           669: struct nl      *lookup();
        !           670: double         atof();
        !           671: int            *tree();
        !           672: int            *hash();
        !           673: char           *alloc();
        !           674: int            *calloc();
        !           675: char           *savestr();
        !           676: struct nl      *lookup1();
        !           677: struct nl      *hdefnl();
        !           678: struct nl      *defnl();
        !           679: struct nl      *enter();
        !           680: struct nl      *nlcopy();
        !           681: struct nl      *tyrecl();
        !           682: struct nl      *tyary();
        !           683: struct nl      *fields();
        !           684: struct nl      *variants();
        !           685: struct nl      *deffld();
        !           686: struct nl      *defvnt();
        !           687: struct nl      *tyrec1();
        !           688: struct nl      *reclook();
        !           689: struct nl      *asgnop1();
        !           690: struct nl      *gtype();
        !           691: struct nl      *call();
        !           692: struct nl      *lvalue();
        !           693: struct nl      *rvalue();
        !           694: struct nl      *cset();
        !           695: 
        !           696: /*
        !           697:  * type cast NIL to keep lint happy (which is not so bad)
        !           698:  */
        !           699: #define                NLNIL   ( (struct nl *) NIL )
        !           700: 
        !           701: /*
        !           702:  * Funny structures to use
        !           703:  * pointers in wild and wooly ways
        !           704:  */
        !           705: struct {
        !           706:        char    pchar;
        !           707: };
        !           708: struct {
        !           709:        short   pint;
        !           710:        short   pint2;
        !           711: };
        !           712: struct {
        !           713:        long    plong;
        !           714: };
        !           715: struct {
        !           716:        double  pdouble;
        !           717: };
        !           718: 
        !           719: #define        OCT     1
        !           720: #define        HEX     2
        !           721: 
        !           722: /*
        !           723:  * MAIN PROGRAM VARIABLES, MISCELLANY
        !           724:  */
        !           725: 
        !           726: /*
        !           727:  * Variables forming a data base referencing
        !           728:  * the command line arguments with the "i" option, e.g.
        !           729:  * in "pi -i scanner.i compiler.p".
        !           730:  */
        !           731: char   **pflist;
        !           732: short  pflstc;
        !           733: short  pfcnt;
        !           734: 
        !           735: char   *filename;              /* current source file name */
        !           736: long   tvec;
        !           737: extern char    *snark;         /* SNARK */
        !           738: extern char    *classes[ ];    /* maps namelist classes to string names */
        !           739: 
        !           740: #define        derror error
        !           741: 
        !           742: #ifdef PC
        !           743: 
        !           744:     /*
        !           745:      * the current function number, for [ lines
        !           746:      */
        !           747:     int        ftnno;
        !           748: 
        !           749:     /*
        !           750:      * the pc output stream
        !           751:      */
        !           752:     FILE *pcstream;
        !           753: 
        !           754: #endif PC

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.