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