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