1: /* 2: * pi - Pascal interpreter code translator 3: * 4: * Charles Haley, Bill Joy UCB 5: * Version 1.0 August 1977 6: * 7: * pxp - Pascal execution profiler 8: * 9: * Bill Joy UCB 10: * Version 1.0 August 1977 11: */ 12: 13: /* 14: * Yacc grammar for UNIX Pascal 15: * 16: * This grammar is processed by the commands in the shell script 17: * "gram" to yield parse tables and semantic routines in the file 18: * "y.tab.c" and a header defining the lexical tokens in "yy.h". 19: * 20: * In order for the syntactic error recovery possible with this 21: * grammar to work, the grammar must be processed by a yacc which 22: * has been modified to fully enumerate possibilities in states 23: * which involve the symbol "error". 24: * The parser used for Pascal also uses a different encoding of 25: * the test entries in the action table which speeds the parse. 26: * A version of yacc which will work for Pascal is included on 27: * the distribution table as "eyacc". 28: * 29: * The "gram" script also makes the following changes to the "y.tab.c" 30: * file: 31: * 32: * 1) Causes yyval to be declared int *. 33: * 34: * 2) Loads the variable yypv into a register as yyYpv so that 35: * the arguments $1, ... are available as yyYpv[1] etc. 36: * This produces much smaller code in the semantic actions. 37: * 38: * 3) Deletes the unused array yysterm. 39: * 40: * 4) Moves the declarations up to the flag line containing 41: * '##' to the file yy.h so that the routines which use 42: * these "magic numbers" don't have to all be compiled at 43: * the same time. 44: * 45: * 5) Creates the semantic restriction checking routine yyEactr 46: * by processing action lines containing `@'. 47: * 48: * This compiler uses a different version of the yacc parser, a 49: * different yyerror which is called yerror, and requires more 50: * lookahead sets than normally provided by yacc. 51: * 52: * Source for the yacc used with this grammar is included on 53: * distribution tapes. 54: */ 55: 56: /* 57: * TERMINAL DECLARATIONS 58: * 59: * Some of the terminal declarations are out of the most natural 60: * alphabetic order because the error recovery 61: * will guess the first of equal cost non-terminals. 62: * This makes, e.g. YTO preferable to YDOWNTO. 63: */ 64: 65: %term 66: YAND YARRAY YBEGIN YCASE 67: YCONST YDIV YDO YDOTDOT 68: YTO YELSE YEND YFILE 69: YFOR YFORWARD YFUNCTION YGOTO 70: YID YIF YIN YINT 71: YLABEL YMOD YNOT YNUMB 72: YOF YOR YPACKED YNIL 73: YPROCEDURE YPROG YRECORD YREPEAT 74: YSET YSTRING YTHEN YDOWNTO 75: YTYPE YUNTIL YVAR YWHILE 76: YWITH YBINT YOCT YHEX 77: YASSERT YCASELAB YILLCH YLAST 78: 79: /* 80: * PRECEDENCE DECLARATIONS 81: * 82: * Highest precedence is the unary logical NOT. 83: * Next are the multiplying operators, signified by '*'. 84: * Lower still are the binary adding operators, signified by '+'. 85: * Finally, at lowest precedence and non-associative are the relationals. 86: */ 87: 88: %binary '<' '=' '>' YIN 89: %left '+' '-' YOR '|' 90: %left UNARYSIGN 91: %left '*' '/' YDIV YMOD YAND '&' 92: %left YNOT 93: 94: %{ 95: 96: /* 97: * GLOBALS FOR ACTIONS 98: */ 99: 100: /* 101: * The following line marks the end of the yacc 102: * Constant definitions which are removed from 103: * y.tab.c and placed in the file y.tab.h. 104: */ 105: ## 106: 107: #include "0.h" 108: #include "yy.h" 109: #include "tree.h" 110: 111: #ifdef PI 112: #define lineof(l) l 113: #define line2of(l) l 114: #endif 115: 116: %} 117: 118: %% 119: 120: /* 121: * PRODUCTIONS 122: */ 123: 124: goal: 125: prog_hedr decls procs block '.' 126: = funcend($1, $4, lineof($5)); 127: ; 128: 129: prog_hedr: 130: YPROG YID '(' id_list ')' ';' 131: = $$ = funcbody(funchdr(tree5(T_PROG, lineof($1), $2, fixlist($4), NIL))); 132: | 133: YPROG error 134: = { 135: yyPerror("Malformed program statement", PPROG); 136: /* 137: * Should make a program statement 138: * with "input" and "output" here. 139: */ 140: $$ = funcbody(funchdr(tree5(T_PROG, lineof($1), NIL, NIL, NIL))); 141: } 142: ; 143: block: 144: YBEGIN stat_list YEND 145: = { 146: $$ = tree3(T_BSTL, lineof($1), fixlist($2)); 147: if ($3.pint < 0) 148: brerror($1, "begin"); 149: } 150: ; 151: 152: 153: /* 154: * DECLARATION PART 155: */ 156: decls: 157: decls decl 158: = trfree(); 159: | 160: decls error 161: = { 162: Derror: 163: constend(), typeend(), varend(), trfree(); 164: yyPerror("Malformed declaration", PDECL); 165: } 166: | 167: /* lambda */ 168: = trfree(); 169: ; 170: 171: decl: 172: labels 173: | 174: const_decl 175: = constend(); 176: | 177: type_decl 178: = typeend(); 179: | 180: var_decl 181: = varend(); 182: ; 183: 184: /* 185: * LABEL PART 186: */ 187: 188: labels: 189: YLABEL label_decl ';' 190: = label(fixlist($2), lineof($1)); 191: ; 192: label_decl: 193: YINT 194: = $$ = newlist($1 == NIL ? NIL : *hash($1, 1)); 195: | 196: label_decl ',' YINT 197: = $$ = addlist($1, $3 == NIL ? NIL : *hash($3, 1)); 198: ; 199: 200: /* 201: * CONST PART 202: */ 203: 204: const_decl: 205: YCONST YID '=' const ';' 206: = constbeg($1, line2of($2)), const(lineof($3), $2, $4); 207: | 208: const_decl YID '=' const ';' 209: = const(lineof($3), $2, $4); 210: | 211: YCONST error 212: = { 213: constbeg($1, line2of($1)); 214: Cerror: 215: yyPerror("Malformed const declaration", PDECL); 216: } 217: | 218: const_decl error 219: = goto Cerror; 220: ; 221: 222: /* 223: * TYPE PART 224: */ 225: 226: type_decl: 227: YTYPE YID '=' type ';' 228: = typebeg($1, line2of($2)), type(lineof($3), $2, $4); 229: | 230: type_decl YID '=' type ';' 231: = type(lineof($3), $2, $4); 232: | 233: YTYPE error 234: = { 235: typebeg($1, line2of($1)); 236: Terror: 237: yyPerror("Malformed type declaration", PDECL); 238: } 239: | 240: type_decl error 241: = goto Terror; 242: ; 243: 244: /* 245: * VAR PART 246: */ 247: 248: var_decl: 249: YVAR id_list ':' type ';' 250: = varbeg($1, line2of($3)), var(lineof($3), fixlist($2), $4); 251: | 252: var_decl id_list ':' type ';' 253: = var(lineof($3), fixlist($2), $4); 254: | 255: YVAR error 256: = { 257: varbeg($1, line2of($1)); 258: Verror: 259: yyPerror("Malformed var declaration", PDECL); 260: } 261: | 262: var_decl error 263: = goto Verror; 264: ; 265: 266: /* 267: * PROCEDURE AND FUNCTION DECLARATION PART 268: */ 269: 270: procs: 271: /* lambda */ 272: | 273: procs proc 274: = trfree(); 275: ; 276: proc: 277: phead YFORWARD ';' 278: = funcfwd($1); 279: | 280: pheadres decls procs block ';' 281: = funcend($1, $4, lineof($5)); 282: ; 283: pheadres: 284: phead 285: = funcbody($1); 286: ; 287: phead: 288: porf YID params ftype ';' 289: = $$ = funchdr(tree5($1, lineof($5), $2, $3, $4)); 290: ; 291: porf: 292: YPROCEDURE 293: = $$ = T_PDEC; 294: | 295: YFUNCTION 296: = $$ = T_FDEC; 297: ; 298: params: 299: '(' param_list ')' 300: = $$ = fixlist($2); 301: | 302: /* lambda */ 303: = $$ = NIL; 304: ; 305: 306: /* 307: * PARAMETERS 308: */ 309: 310: param: 311: id_list ':' type 312: = $$ = tree3(T_PVAL, fixlist($1), $3); 313: | 314: YVAR id_list ':' type 315: = $$ = tree3(T_PVAR, fixlist($2), $4); 316: | 317: YFUNCTION id_list ':' type 318: = $$ = tree3(T_PFUNC, fixlist($2), $4); 319: | 320: YPROCEDURE id_list 321: = $$ = tree2(T_PPROC, fixlist($2)); 322: ; 323: ftype: 324: ':' type 325: = $$ = $2; 326: | 327: /* lambda */ 328: = $$ = NIL; 329: ; 330: param_list: 331: param 332: = $$ = newlist($1); 333: | 334: param_list ';' param 335: = $$ = addlist($1, $3); 336: ; 337: 338: /* 339: * CONSTANTS 340: */ 341: 342: const: 343: YSTRING 344: = $$ = tree2(T_CSTRNG, $1); 345: | 346: number 347: | 348: '+' number 349: = $$ = tree2(T_PLUSC, $2); 350: | 351: '-' number 352: = $$ = tree2(T_MINUSC, $2); 353: ; 354: number: 355: const_id 356: = $$ = tree2(T_ID, $1); 357: | 358: YINT 359: = $$ = tree2(T_CINT, $1); 360: | 361: YBINT 362: = $$ = tree2(T_CBINT, $1); 363: | 364: YNUMB 365: = $$ = tree2(T_CFINT, $1); 366: ; 367: const_list: 368: const 369: = $$ = newlist($1); 370: | 371: const_list ',' const 372: = $$ = addlist($1, $3); 373: ; 374: 375: /* 376: * TYPES 377: */ 378: 379: type: 380: simple_type 381: | 382: '^' YID 383: = $$ = tree3(T_TYPTR, lineof($1), tree2(T_ID, $2)); 384: | 385: struct_type 386: | 387: YPACKED struct_type 388: = $$ = tree3(T_TYPACK, lineof($1), $2); 389: ; 390: simple_type: 391: type_id 392: | 393: '(' id_list ')' 394: = $$ = tree3(T_TYSCAL, lineof($1), fixlist($2)); 395: | 396: const YDOTDOT const 397: = $$ = tree4(T_TYRANG, lineof($2), $1, $3); 398: ; 399: struct_type: 400: YARRAY '[' simple_type_list ']' YOF type 401: = $$ = tree4(T_TYARY, lineof($1), fixlist($3), $6); 402: | 403: YFILE YOF type 404: = $$ = tree3(T_TYFILE, lineof($1), $3); 405: | 406: YSET YOF simple_type 407: = $$ = tree3(T_TYSET, lineof($1), $3); 408: | 409: YRECORD field_list YEND 410: = { 411: $$ = tree3(T_TYREC, lineof($1), $2); 412: if ($3.pint < 0) 413: brerror($1, "record"); 414: } 415: ; 416: simple_type_list: 417: simple_type 418: = $$ = newlist($1); 419: | 420: simple_type_list ',' simple_type 421: = $$ = addlist($1, $3); 422: ; 423: 424: /* 425: * RECORD TYPE 426: */ 427: field_list: 428: fixed_part variant_part 429: = $$ = tree4(T_FLDLST, lineof(NIL), fixlist($1), $2); 430: ; 431: fixed_part: 432: field 433: = $$ = newlist($1); 434: | 435: fixed_part ';' field 436: = $$ = addlist($1, $3); 437: | 438: fixed_part error 439: = yyPerror("Malformed record declaration", PDECL); 440: ; 441: field: 442: /* lambda */ 443: = $$ = NIL; 444: | 445: id_list ':' type 446: = $$ = tree4(T_RFIELD, lineof($2), fixlist($1), $3); 447: ; 448: 449: variant_part: 450: /* lambda */ 451: = $$ = NIL; 452: | 453: YCASE type_id YOF variant_list 454: = $$ = tree5(T_TYVARPT, lineof($1), NIL, $2, fixlist($4)); 455: | 456: YCASE YID ':' type_id YOF variant_list 457: = $$ = tree5(T_TYVARPT, lineof($1), $2, $4, fixlist($6)); 458: ; 459: variant_list: 460: variant 461: = $$ = newlist($1); 462: | 463: variant_list ';' variant 464: = $$ = addlist($1, $3); 465: | 466: variant_list error 467: = yyPerror("Malformed record declaration", PDECL); 468: ; 469: variant: 470: /* lambda */ 471: = $$ = NIL; 472: | 473: const_list ':' '(' field_list ')' 474: = $$ = tree4(T_TYVARNT, lineof($2), fixlist($1), $4); 475: | 476: const_list ':' '(' ')' 477: = $$ = tree4(T_TYVARNT, lineof($2), fixlist($1), NIL); 478: ; 479: 480: /* 481: * STATEMENT LIST 482: */ 483: 484: stat_list: 485: stat 486: = $$ = newlist($1); 487: | 488: stat_lsth stat 489: = { 490: if ((p = $1) != NIL && (q = p[1])[0] == T_IFX) { 491: q[0] = T_IFEL; 492: q[4] = $2; 493: } else 494: $$ = addlist($1, $2); 495: } 496: ; 497: 498: stat_lsth: 499: stat_list ';' 500: = if ((q = $1) != NIL && (p = q[1]) != NIL && p[0] == T_IF) { 501: if (yychar < 0) 502: yychar = yylex(); 503: if (yyshifts >= 2 && yychar == YELSE) { 504: recovered(); 505: copy(&Y, &OY, sizeof Y); 506: yerror("Deleted ';' before keyword else"); 507: yychar = yylex(); 508: p[0] = T_IFX; 509: } 510: } 511: ; 512: 513: /* 514: * CASE STATEMENT LIST 515: */ 516: 517: cstat_list: 518: cstat 519: = $$ = newlist($1); 520: | 521: cstat_list ';' cstat 522: = $$ = addlist($1, $3); 523: | 524: error 525: = { 526: $$ = NIL; 527: Kerror: 528: yyPerror("Malformed statement in case", PSTAT); 529: } 530: | 531: cstat_list error 532: = goto Kerror; 533: ; 534: 535: cstat: 536: const_list ':' stat 537: = $$ = tree4(T_CSTAT, lineof($2), fixlist($1), $3); 538: | 539: YCASELAB stat 540: = $$ = tree4(T_CSTAT, lineof($1), NIL, $2); 541: | 542: /* lambda */ 543: = $$ = NIL; 544: ; 545: 546: /* 547: * STATEMENT 548: */ 549: 550: stat: 551: /* lambda */ 552: = $$ = NIL; 553: | 554: YINT ':' stat 555: = $$ = tree4(T_LABEL, lineof($2), $1 == NIL ? NIL : *hash($1, 1), $3); 556: | 557: proc_id 558: = $$ = tree4(T_PCALL, lineof(yyline), $1, NIL); 559: | 560: proc_id '(' wexpr_list ')' 561: = $$ = tree4(T_PCALL, lineof($2), $1, fixlist($3)); 562: | 563: YID error 564: = goto NSerror; 565: | 566: assign 567: | 568: YBEGIN stat_list YEND 569: = { 570: $$ = tree3(T_BLOCK, lineof($1), fixlist($2)); 571: if ($3.pint < 0) 572: brerror($1, "begin"); 573: } 574: | 575: YCASE expr YOF cstat_list YEND 576: = { 577: $$ = tree4(T_CASE, lineof($1), $2, fixlist($4)); 578: if ($5.pint < 0) 579: brerror($1, "case"); 580: } 581: | 582: YWITH var_list YDO stat 583: = $$ = tree4(T_WITH, lineof($1), fixlist($2), $4); 584: | 585: YWHILE expr YDO stat 586: = $$ = tree4(T_WHILE, lineof($1), $2, $4); 587: | 588: YREPEAT stat_list YUNTIL expr 589: = $$ = tree4(T_REPEAT, lineof($3), fixlist($2), $4); 590: | 591: YFOR assign YTO expr YDO stat 592: = $$ = tree5(T_FORU, lineof($1), $2, $4, $6); 593: | 594: YFOR assign YDOWNTO expr YDO stat 595: = $$ = tree5(T_FORD, lineof($1), $2, $4, $6); 596: | 597: YGOTO YINT 598: = $$ = tree3(T_GOTO, lineof($1), *hash($2, 1)); 599: | 600: YIF expr YTHEN stat 601: = $$ = tree5(T_IF, lineof($1), $2, $4, NIL); 602: | 603: YIF expr YTHEN stat YELSE stat 604: = $$ = tree5(T_IFEL, lineof($1), $2, $4, $6); 605: | 606: YIF expr YTHEN stat YELSE 607: = $$ = tree5(T_IFEL, lineof($1), $2, $4, NIL); 608: | 609: YASSERT '(' expr ')' 610: = $$ = tree3(T_ASRT, lineof($1), $3); 611: | 612: error 613: = { 614: NSerror: 615: $$ = NIL; 616: Serror: 617: yyPerror("Malformed statement", PSTAT); 618: } 619: ; 620: assign: 621: variable ':' '=' expr 622: = $$ = tree4(T_ASGN, lineof($2), $1, $4); 623: ; 624: 625: /* 626: * EXPRESSION 627: */ 628: 629: expr: 630: error 631: = { 632: NEerror: 633: $$ = NIL; 634: Eerror: 635: yyPerror("Missing/malformed expression", PEXPR); 636: } 637: | 638: expr relop expr %prec '<' 639: = $$ = tree4($2, $1[1] == SAWCON ? $3[1] : $1[1], $1, $3); 640: | 641: '+' expr %prec UNARYSIGN 642: = $$ = tree3(T_PLUS, $2[1], $2); 643: | 644: '-' expr %prec UNARYSIGN 645: = $$ = tree3(T_MINUS, $2[1], $2); 646: | 647: expr addop expr %prec '+' 648: = $$ = tree4($2, $1[1] == SAWCON ? $3[1] : $1[1], $1, $3); 649: | 650: expr divop expr %prec '*' 651: = $$ = tree4($2, $1[1] == SAWCON ? $3[1] : $1[1], $1, $3); 652: | 653: YNIL 654: = $$ = tree2(T_NIL, NOCON); 655: | 656: YSTRING 657: = $$ = tree3(T_STRNG, SAWCON, $1); 658: | 659: YINT 660: = $$ = tree3(T_INT, NOCON, $1); 661: | 662: YBINT 663: = $$ = tree3(T_BINT, NOCON, $1); 664: | 665: YNUMB 666: = $$ = tree3(T_FINT, NOCON, $1); 667: | 668: variable 669: | 670: YID error 671: = goto NEerror; 672: | 673: func_id '(' wexpr_list ')' 674: = $$ = tree4(T_FCALL, NOCON, $1, fixlist($3)); 675: | 676: '(' expr ')' 677: = $$ = $2; 678: | 679: negop expr %prec YNOT 680: = $$ = tree3(T_NOT, NOCON, $2); 681: | 682: '[' element_list ']' 683: = $$ = tree3(T_CSET, SAWCON, fixlist($2)); 684: | 685: '[' ']' 686: = $$ = tree3(T_CSET, SAWCON, NIL); 687: ; 688: 689: element_list: 690: element 691: = $$ = newlist($1); 692: | 693: element_list ',' element 694: = $$ = addlist($1, $3); 695: ; 696: element: 697: expr 698: | 699: expr YDOTDOT expr 700: = $$ = tree3(T_RANG, $1, $3); 701: ; 702: 703: /* 704: * QUALIFIED VARIABLES 705: */ 706: 707: variable: 708: YID 709: = { 710: @ return (identis(var, VAR)); 711: $$ = setupvar($1, NIL); 712: } 713: | 714: qual_var 715: = $1[3] = fixlist($1[3]); 716: ; 717: qual_var: 718: array_id '[' expr_list ']' 719: = $$ = setupvar($1, tree2(T_ARY, fixlist($3))); 720: | 721: qual_var '[' expr_list ']' 722: = $1[3] = addlist($1[3], tree2(T_ARY, fixlist($3))); 723: | 724: record_id '.' field_id 725: = $$ = setupvar($1, tree3(T_FIELD, $3, NIL)); 726: | 727: qual_var '.' field_id 728: = $1[3] = addlist($1[3], tree3(T_FIELD, $3, NIL)); 729: | 730: ptr_id '^' 731: = $$ = setupvar($1, tree1(T_PTR)); 732: | 733: qual_var '^' 734: = $1[3] = addlist($1[3], tree1(T_PTR)); 735: ; 736: 737: /* 738: * Expression with write widths 739: */ 740: wexpr: 741: expr 742: | 743: expr ':' expr 744: = $$ = tree4(T_WEXP, $1, $3, NIL); 745: | 746: expr ':' expr ':' expr 747: = $$ = tree4(T_WEXP, $1, $3, $5); 748: | 749: expr octhex 750: = $$ = tree4(T_WEXP, $1, NIL, $2); 751: | 752: expr ':' expr octhex 753: = $$ = tree4(T_WEXP, $1, $3, $4); 754: ; 755: octhex: 756: YOCT 757: = $$ = OCT; 758: | 759: YHEX 760: = $$ = HEX; 761: ; 762: 763: expr_list: 764: expr 765: = $$ = newlist($1); 766: | 767: expr_list ',' expr 768: = $$ = addlist($1, $3); 769: ; 770: 771: wexpr_list: 772: wexpr 773: = $$ = newlist($1); 774: | 775: wexpr_list ',' wexpr 776: = $$ = addlist($1, $3); 777: ; 778: 779: /* 780: * OPERATORS 781: */ 782: 783: relop: 784: '=' = $$ = T_EQ; 785: | 786: '<' = $$ = T_LT; 787: | 788: '>' = $$ = T_GT; 789: | 790: '<' '>' = $$ = T_NE; 791: | 792: '<' '=' = $$ = T_LE; 793: | 794: '>' '=' = $$ = T_GE; 795: | 796: YIN = $$ = T_IN; 797: ; 798: addop: 799: '+' = $$ = T_ADD; 800: | 801: '-' = $$ = T_SUB; 802: | 803: YOR = $$ = T_OR; 804: | 805: '|' = $$ = T_OR; 806: ; 807: divop: 808: '*' = $$ = T_MULT; 809: | 810: '/' = $$ = T_DIVD; 811: | 812: YDIV = $$ = T_DIV; 813: | 814: YMOD = $$ = T_MOD; 815: | 816: YAND = $$ = T_AND; 817: | 818: '&' = $$ = T_AND; 819: ; 820: 821: negop: 822: YNOT 823: | 824: '~' 825: ; 826: 827: /* 828: * LISTS 829: */ 830: 831: var_list: 832: variable 833: = $$ = newlist($1); 834: | 835: var_list ',' variable 836: = $$ = addlist($1, $3); 837: ; 838: 839: id_list: 840: YID 841: = $$ = newlist($1); 842: | 843: id_list ',' YID 844: = $$ = addlist($1, $3); 845: ; 846: 847: /* 848: * Identifier productions with semantic restrictions 849: * 850: * For these productions, the character @ signifies 851: * that the associated C statement is to provide 852: * the semantic restriction for this reduction. 853: * These lines are made into a procedure yyEactr, similar to 854: * yyactr, which determines whether the corresponding reduction 855: * is permitted, or whether an error is to be signaled. 856: * A zero return from yyEactr is considered an error. 857: * YyEactr is called with an argument "var" giving the string 858: * name of the variable in question, essentially $1, although 859: * $1 will not work because yyEactr is called from loccor in 860: * the recovery routines. 861: */ 862: 863: const_id: 864: YID 865: = @ return (identis(var, CONST)); 866: ; 867: type_id: 868: YID 869: = { 870: @ return (identis(var, TYPE)); 871: $$ = tree3(T_TYID, lineof(yyline), $1); 872: } 873: ; 874: var_id: 875: YID 876: = @ return (identis(var, VAR)); 877: ; 878: array_id: 879: YID 880: = @ return (identis(var, ARRAY)); 881: ; 882: ptr_id: 883: YID 884: = @ return (identis(var, PTRFILE)); 885: ; 886: record_id: 887: YID 888: = @ return (identis(var, RECORD)); 889: ; 890: field_id: 891: YID 892: = @ return (identis(var, FIELD)); 893: ; 894: proc_id: 895: YID 896: = @ return (identis(var, PROC)); 897: ; 898: func_id: 899: YID 900: = @ return (identis(var, FUNC)); 901: ;
Defined macros
|
Last modified: 1981-07-10
Generated: 2016-12-26 |
Generated by src2html V0.67
page hit count: 1164 |
|