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