![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cgram.y CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jerq / sgs / comp|
Return to cgram.y CVS log | Up to [Research Unix] / researchv9 / jerq / sgs / comp |
1.1 ! root 1: /* @(#) cgram.y: 1.2 2/9/84 */ ! 2: %{ ! 3: static char SCCSID[] = "@(#) cgram.y: 2.1 83/08/02"; ! 4: %} ! 5: %term NAME 2 ! 6: %term STRING 3 ! 7: %term ICON 4 ! 8: %term FCON 5 ! 9: %term PLUS 6 ! 10: %term MINUS 8 ! 11: %term MUL 11 ! 12: %term AND 14 ! 13: %term OR 17 ! 14: %term ER 19 ! 15: %term QUEST 21 ! 16: %term COLON 22 ! 17: %term ANDAND 23 ! 18: %term OROR 24 ! 19: ! 20: /* special interfaces for yacc alone */ ! 21: /* These serve as abbreviations of 2 or more ops: ! 22: ASOP =, = ops ! 23: RELOP LE,LT,GE,GT ! 24: EQUOP EQ,NE ! 25: DIVOP DIV,MOD ! 26: SHIFTOP LS,RS ! 27: ICOP ICR,DECR ! 28: UNOP NOT,COMPL ! 29: STROP DOT,STREF ! 30: ! 31: */ ! 32: %term ASOP 25 ! 33: %term RELOP 26 ! 34: %term EQUOP 27 ! 35: %term DIVOP 28 ! 36: %term SHIFTOP 29 ! 37: %term INCOP 30 ! 38: %term UNOP 31 ! 39: %term STROP 32 ! 40: ! 41: /* reserved words, etc */ ! 42: %term TYPE 33 ! 43: %term CLASS 34 ! 44: %term STRUCT 35 ! 45: %term RETURN 36 ! 46: %term GOTO 37 ! 47: %term IF 38 ! 48: %term ELSE 39 ! 49: %term SWITCH 40 ! 50: %term BREAK 41 ! 51: %term CONTINUE 42 ! 52: %term WHILE 43 ! 53: %term DO 44 ! 54: %term FOR 45 ! 55: %term DEFAULT 46 ! 56: %term CASE 47 ! 57: %term SIZEOF 48 ! 58: %term ENUM 49 ! 59: ! 60: /* little symbols, etc. */ ! 61: /* namely, ! 62: ! 63: LP ( ! 64: RP ) ! 65: ! 66: LC { ! 67: RC } ! 68: ! 69: LB [ ! 70: RB ] ! 71: ! 72: CM , ! 73: SM ; ! 74: ! 75: */ ! 76: ! 77: %term LP 50 ! 78: %term RP 51 ! 79: %term LC 52 ! 80: %term RC 53 ! 81: %term LB 54 ! 82: %term RB 55 ! 83: %term CM 56 ! 84: %term SM 57 ! 85: %term ASSIGN 58 ! 86: %term ASM 59 ! 87: ! 88: /* at last count, there were 7 shift/reduce, 1 reduce/reduce conflicts ! 89: /* these involved: ! 90: if/else ! 91: recognizing functions in various contexts, including declarations ! 92: error recovery ! 93: */ ! 94: ! 95: %left CM ! 96: %right ASOP ASSIGN ! 97: %right QUEST COLON ! 98: %left OROR ! 99: %left ANDAND ! 100: %left OR ! 101: %left ER ! 102: %left AND ! 103: %left EQUOP ! 104: %left RELOP ! 105: %left SHIFTOP ! 106: %left PLUS MINUS ! 107: %left MUL DIVOP ! 108: %right UNOP ! 109: %right INCOP SIZEOF ! 110: %left LB LP STROP ! 111: %{ ! 112: # include "mfile1.h" ! 113: %} ! 114: ! 115: /* define types */ ! 116: %start ext_def_list ! 117: ! 118: %type <intval> con_e ifelprefix ifprefix doprefix switchpart ! 119: enum_head str_head name_lp ! 120: %type <nodep> e .e term attributes oattributes type enum_dcl struct_dcl ! 121: cast_type null_decl funct_idn declarator fdeclarator ! 122: nfdeclarator elist ! 123: ! 124: %token <intval> CLASS NAME STRUCT RELOP CM DIVOP PLUS MINUS SHIFTOP MUL AND OR ! 125: ER ANDAND OROR ASSIGN STROP INCOP UNOP ICON ! 126: %token <nodep> TYPE ! 127: ! 128: %% ! 129: ! 130: %{ ! 131: extern int wloop_level; /* specifies while loop code generation */ ! 132: extern int floop_level; /* specifies for loop code generation */ ! 133: static int fake = 0; ! 134: static char fakename[NCHNAM+1]; ! 135: %} ! 136: ! 137: ext_def_list: ext_def_list external_def ! 138: | /* EMPTY */ ! 139: { ! 140: #ifndef LINT ! 141: beg_file(); ! 142: #endif ! 143: ftnend(); ! 144: } ! 145: ; ! 146: external_def: data_def ! 147: { curclass = SNULL; blevel = 0; } ! 148: | error ! 149: { curclass = SNULL; blevel = 0; } ! 150: | ASM SM ! 151: { asmout(); curclass = SNULL; blevel = 0; } ! 152: ; ! 153: data_def: oattributes SM ! 154: { $1->in.op = FREE; } ! 155: | oattributes init_dcl_list SM ! 156: { $1->in.op = FREE; } ! 157: | oattributes fdeclarator ! 158: { defid( tymerge($1,$2), ! 159: curclass==STATIC?STATIC:EXTDEF ); } ! 160: function_body ! 161: { ! 162: if( blevel ) cerror( "function level error" ); ! 163: if( reached ) retstat |= NRETVAL; ! 164: $1->in.op = FREE; ! 165: ftnend(); ! 166: } ! 167: ; ! 168: ! 169: function_body: arg_dcl_list compoundstmt ! 170: { regvar = 0; } /* clear out arguments */ ! 171: ; ! 172: ! 173: arg_dcl_list: arg_dcl_list attributes declarator_list SM ! 174: { curclass = SNULL; $2->in.op = FREE; } ! 175: | arg_dcl_list attributes SM ! 176: /* to permit structs in decl. lists */ ! 177: { curclass = SNULL; $2->in.op = FREE; } ! 178: | /* EMPTY */ { blevel = 1; } ! 179: ; ! 180: ! 181: stmt_list: stmt_list statement ! 182: | /* EMPTY */ ! 183: { bccode(); ! 184: locctr(PROG); ! 185: } ! 186: ; ! 187: ! 188: dcl_stat_list : dcl_stat_list attributes SM ! 189: { $2->in.op = FREE; } ! 190: | dcl_stat_list attributes init_dcl_list SM ! 191: { $2->in.op = FREE; } ! 192: | /* EMPTY */ ! 193: ; ! 194: ! 195: oattributes: attributes ! 196: | /* empty */ ! 197: { $$ = mkty(INT,0,INT); curclass = SNULL; } ! 198: ; ! 199: attributes: class type ! 200: { $$ = $2; } ! 201: | type class ! 202: | class ! 203: { $$ = mkty(INT,0,INT); } ! 204: | type ! 205: { curclass = SNULL ; } ! 206: | type class type ! 207: { $1->in.type = types( $1->in.type, $3->in.type, ! 208: UNDEF ); ! 209: $3->in.op = FREE; ! 210: } ! 211: ; ! 212: ! 213: class: CLASS ! 214: { curclass = $1; } ! 215: ; ! 216: ! 217: type: TYPE ! 218: | TYPE TYPE ! 219: { $1->in.type = types( $1->in.type, $2->in.type, UNDEF ); ! 220: $2->in.op = FREE; ! 221: } ! 222: | TYPE TYPE TYPE ! 223: { $1->in.type = types( $1->in.type, $2->in.type, $3->in.type ); ! 224: $2->in.op = $3->in.op = FREE; ! 225: } ! 226: | struct_dcl ! 227: | enum_dcl ! 228: ; ! 229: ! 230: enum_dcl: enum_head LC moe_list optcomma RC ! 231: { $$ = dclstruct($1); } ! 232: | ENUM NAME ! 233: { $$ = rstruct($2,0); stwart = instruct; } ! 234: ; ! 235: ! 236: enum_head: ENUM ! 237: { $$ = bstruct(-1,0); stwart = SEENAME; } ! 238: | ENUM NAME ! 239: { $$ = bstruct($2,0); stwart = SEENAME; } ! 240: ; ! 241: ! 242: moe_list: moe ! 243: | moe_list CM moe ! 244: ; ! 245: ! 246: moe: NAME ! 247: { moedef( $1 ); } ! 248: | NAME ASSIGN con_e ! 249: { strucoff = $3; moedef( $1 ); } ! 250: ; ! 251: ! 252: struct_dcl: str_head LC type_dcl_list optsemi RC ! 253: { $$ = dclstruct($1); } ! 254: | STRUCT NAME ! 255: { $$ = rstruct($2,$1); } ! 256: ; ! 257: ! 258: str_head: STRUCT ! 259: { $$ = bstruct(-1,$1); stwart=0; } ! 260: | STRUCT NAME ! 261: { $$ = bstruct($2,$1); stwart=0; } ! 262: ; ! 263: ! 264: type_dcl_list: type_declaration ! 265: | type_dcl_list SM type_declaration ! 266: ; ! 267: ! 268: type_declaration: type declarator_list ! 269: { curclass = SNULL; stwart=0; $1->in.op = FREE; } ! 270: | type ! 271: { if( curclass != MOU ){ ! 272: curclass = SNULL; ! 273: } ! 274: else { ! 275: sprintf( fakename, "$%dFAKE", fake++ ); ! 276: defid( tymerge($1, bdty(NAME,NIL, ! 277: lookup( fakename, SMOS ))), curclass ); ! 278: werror("union member must be named"); ! 279: } ! 280: stwart = 0; ! 281: $1->in.op = FREE; ! 282: } ! 283: ; ! 284: ! 285: ! 286: declarator_list: declarator ! 287: { defid( tymerge($<nodep>0,$1), curclass); ! 288: stwart = instruct; } ! 289: | declarator_list CM {$<nodep>$=$<nodep>0;} declarator ! 290: { defid( tymerge($<nodep>0,$4), curclass); ! 291: stwart = instruct; } ! 292: ; ! 293: declarator: nfdeclarator ! 294: | nfdeclarator COLON con_e ! 295: %prec CM ! 296: { if( !(instruct&INSTRUCT) ) ! 297: uerror( "field outside of structure" ); ! 298: if( $3<0 || $3 >= FIELD ){ ! 299: uerror( "illegal field size" ); ! 300: $3 = 1; ! 301: } ! 302: defid( tymerge($<nodep>0,$1), FIELD|$3 ); ! 303: $$ = NIL; ! 304: } ! 305: | COLON con_e ! 306: %prec CM ! 307: { if( !(instruct&INSTRUCT) ) ! 308: uerror( "field outside of structure" ); ! 309: /* alignment or hole */ ! 310: falloc( stab, $2, -1, $<nodep>0 ); ! 311: $$ = NIL; ! 312: } ! 313: | error ! 314: { $$ = NIL; } ! 315: ; ! 316: ! 317: /* int (a)(); is not a function --- sorry! */ ! 318: nfdeclarator: MUL nfdeclarator ! 319: { umul: ! 320: $$ = bdty( UNARY MUL, $2, 0 ); } ! 321: | nfdeclarator LP RP ! 322: { uftn: ! 323: $$ = bdty( UNARY CALL, $1, 0 ); } ! 324: | nfdeclarator LB RB ! 325: { uary: ! 326: $$ = bdty( LB, $1, 0 ); } ! 327: | nfdeclarator LB con_e RB ! 328: { bary: ! 329: if( (int)$3 <= 0 ) ! 330: werror( "zero or negative subscript" ); ! 331: $$ = bdty( LB, $1, $3 ); } ! 332: | NAME ! 333: { $$ = bdty( NAME, NIL, $1 ); } ! 334: | LP nfdeclarator RP ! 335: { $$=$2; } ! 336: ; ! 337: fdeclarator: MUL fdeclarator ! 338: { goto umul; } ! 339: | fdeclarator LP RP ! 340: { goto uftn; } ! 341: | fdeclarator LB RB ! 342: { goto uary; } ! 343: | fdeclarator LB con_e RB ! 344: { goto bary; } ! 345: | LP fdeclarator RP ! 346: { $$ = $2; } ! 347: | name_lp ! 348: { if (paramno) ! 349: uerror("arg list in declaration"); } ! 350: name_list RP ! 351: { ! 352: if( blevel!=0 ) ! 353: uerror( ! 354: "function declaration in bad context"); ! 355: $$ = bdty( UNARY CALL, bdty(NAME,NIL,$1), 0 ); ! 356: stwart = 0; ! 357: } ! 358: | name_lp ! 359: { if (paramno) ! 360: uerror("arg list in declaration"); } ! 361: RP ! 362: { ! 363: $$ = bdty( UNARY CALL, bdty(NAME,NIL,$1), 0 ); ! 364: stwart = 0; ! 365: } ! 366: ; ! 367: ! 368: name_lp: NAME LP ! 369: { ! 370: /* turn off typedefs for argument names */ ! 371: stwart = SEENAME; ! 372: if( stab[$1].sclass == SNULL ) ! 373: stab[$1].stype = FTN; ! 374: } ! 375: ; ! 376: ! 377: name_list: NAME ! 378: { ftnarg( $1 ); stwart = SEENAME; } ! 379: | name_list CM NAME ! 380: { ftnarg( $3 ); stwart = SEENAME; } ! 381: | error ! 382: ; ! 383: /* always preceeded by attributes: thus the $<nodep>0's */ ! 384: init_dcl_list: init_declarator ! 385: %prec CM ! 386: | init_dcl_list CM {$<nodep>$=$<nodep>0;} init_declarator ! 387: ; ! 388: /* always preceeded by attributes */ ! 389: xnfdeclarator: nfdeclarator ! 390: { defid( $1 = tymerge($<nodep>0,$1), curclass); ! 391: beginit($1->tn.rval); ! 392: } ! 393: | error ! 394: ; ! 395: /* always preceeded by attributes */ ! 396: init_declarator: nfdeclarator ! 397: { nidcl( tymerge($<nodep>0,$1) ); } ! 398: | fdeclarator ! 399: { defid( tymerge($<nodep>0,$1), uclass(curclass) ); ! 400: } ! 401: | xnfdeclarator ASSIGN e ! 402: %prec CM ! 403: { doinit( $3 ); ! 404: endinit(); } ! 405: | xnfdeclarator ASSIGN LC init_list optcomma RC ! 406: { endinit(); } ! 407: | error ! 408: ; ! 409: ! 410: init_list: initializer ! 411: %prec CM ! 412: | init_list CM initializer ! 413: ; ! 414: initializer: e ! 415: %prec CM ! 416: { doinit( $1 ); } ! 417: | ibrace init_list optcomma RC ! 418: { irbrace(); } ! 419: ; ! 420: ! 421: optcomma : /* empty */ ! 422: | CM ! 423: ; ! 424: ! 425: optsemi : /* empty */ ! 426: | SM ! 427: ; ! 428: ! 429: ibrace : LC ! 430: { ilbrace(); } ! 431: ; ! 432: ! 433: /* STATEMENTS */ ! 434: ! 435: compoundstmt: begin dcl_stat_list stmt_list RC ! 436: { ! 437: clearst(blevel); ! 438: if (--blevel == 1) ! 439: { ! 440: clearst(blevel); ! 441: blevel = 0; ! 442: } ! 443: checkst(blevel); ! 444: autooff = *--psavbc; ! 445: regvar = *--psavbc; ! 446: } ! 447: ; ! 448: ! 449: begin: LC ! 450: { if( blevel == 1 ) dclargs(); ! 451: ++blevel; ! 452: if( psavbc > &asavbc[BCSZ-2] ) ! 453: cerror( "nesting too deep" ); ! 454: *psavbc++ = regvar; ! 455: *psavbc++ = autooff; ! 456: } ! 457: ; ! 458: ! 459: statement: e SM ! 460: { ecomp( $1 ); } ! 461: | ASM SM ! 462: { asmout(); } ! 463: | compoundstmt ! 464: | ifprefix statement ! 465: { deflab($1); ! 466: reached = 1; ! 467: #ifdef M32B ! 468: brdepth--; ! 469: #endif ! 470: } ! 471: | ifelprefix statement ! 472: { if( $1 != NOLAB ){ ! 473: deflab( $1 ); ! 474: reached = 1; ! 475: } ! 476: #ifdef M32B ! 477: brdepth--; ! 478: #endif ! 479: } ! 480: | WHILE ! 481: { ! 482: #ifdef M32B ! 483: whdepth++; ! 484: #endif ! 485: } ! 486: LP e RP ! 487: { ! 488: savebc(); ! 489: if (!reached) ! 490: werror("loop not entered at top"); ! 491: reached = 1; ! 492: brklab = getlab(); ! 493: contlab = getlab(); ! 494: switch (wloop_level) ! 495: { ! 496: default: ! 497: cerror("bad while loop code gen value"); ! 498: /*NOTREACHED*/ ! 499: case LL_TOP: /* test at loop top */ ! 500: deflab(contlab); ! 501: if ($4->in.op == ICON && ! 502: $4->tn.lval != 0) ! 503: { ! 504: flostat = FLOOP; ! 505: tfree($4); ! 506: } ! 507: else ! 508: ecomp(buildtree(CBRANCH, $4, ! 509: bcon(brklab))); ! 510: break; ! 511: case LL_BOT: /* test at loop bottom */ ! 512: if ($4->in.op == ICON && ! 513: $4->tn.lval != 0) ! 514: { ! 515: flostat = FLOOP; ! 516: tfree($4); ! 517: deflab(contlab); ! 518: } ! 519: else ! 520: { ! 521: branch(contlab); ! 522: deflab($<intval>$ = getlab()); ! 523: } ! 524: break; ! 525: case LL_DUP: /* dup. test at top & bottom */ ! 526: if ($4->in.op == ICON && ! 527: $4->tn.lval != 0) ! 528: { ! 529: flostat = FLOOP; ! 530: tfree($4); ! 531: deflab($<intval>$ = contlab); ! 532: } ! 533: else ! 534: { ! 535: #ifndef LINT ! 536: /* don't rotate loops for lint */ ! 537: register NODE *sav; ! 538: extern NODE *treecpy(); ! 539: ! 540: sav = treecpy($4); ! 541: ecomp(buildtree(CBRANCH,$4, ! 542: bcon(brklab))); ! 543: $4 = sav; ! 544: #endif ! 545: deflab($<intval>$ = getlab()); ! 546: } ! 547: break; ! 548: } ! 549: } ! 550: statement ! 551: { ! 552: switch (wloop_level) ! 553: { ! 554: default: ! 555: cerror("bad while loop code gen. value"); ! 556: /*NOTREACHED*/ ! 557: case LL_TOP: /* test at loop top */ ! 558: branch(contlab); ! 559: break; ! 560: case LL_BOT: /* test at loop bottom */ ! 561: if (flostat & FLOOP) ! 562: branch(contlab); ! 563: else ! 564: { ! 565: reached = 1; ! 566: deflab(contlab); ! 567: ecomp(buildtree(CBRANCH, ! 568: buildtree(NOT, $4, NIL), ! 569: bcon($<intval>6))); ! 570: } ! 571: break; ! 572: case LL_DUP: /* dup. test at top & bottom */ ! 573: if (flostat & FLOOP) ! 574: branch(contlab); ! 575: else ! 576: { ! 577: if (flostat & FCONT) ! 578: { ! 579: reached = 1; ! 580: deflab(contlab); ! 581: } ! 582: ecomp(buildtree(CBRANCH, ! 583: buildtree(NOT, $4, NIL), ! 584: bcon($<intval>6))); ! 585: } ! 586: break; ! 587: } ! 588: if ((flostat & FBRK) || !(flostat & FLOOP)) ! 589: reached = 1; ! 590: else ! 591: reached = 0; ! 592: deflab(brklab); ! 593: resetbc(0); ! 594: #ifdef M32B ! 595: whdepth--; ! 596: #endif ! 597: } ! 598: | doprefix statement WHILE LP e RP SM ! 599: { deflab( contlab ); ! 600: if( flostat & FCONT ) reached = 1; ! 601: ecomp( buildtree( CBRANCH, ! 602: buildtree( NOT, $5, NIL ), bcon( $1 ) ) ); ! 603: deflab( brklab ); ! 604: reached = 1; ! 605: resetbc(0); ! 606: #ifdef M32B ! 607: whdepth--; ! 608: #endif ! 609: } ! 610: | FOR LP .e SM ! 611: { ! 612: #ifdef M32B ! 613: fordepth++; ! 614: #endif ! 615: } ! 616: .e SM ! 617: { ! 618: if ($3) ! 619: ecomp($3); ! 620: else if (!reached) ! 621: werror("loop not entered at top"); ! 622: savebc(); ! 623: contlab = getlab(); ! 624: brklab = getlab(); ! 625: reached = 1; ! 626: switch (floop_level) ! 627: { ! 628: default: ! 629: cerror("bad for loop code gen. value"); ! 630: /*NOTREACHED*/ ! 631: case LL_TOP: /* test at loop top */ ! 632: deflab($<intval>$ = getlab()); ! 633: if (!$6) ! 634: flostat |= FLOOP; ! 635: else if ($6->in.op == ICON && ! 636: $6->tn.lval != 0) ! 637: { ! 638: flostat |= FLOOP; ! 639: tfree($6); ! 640: $6 = (NODE *)0; ! 641: } ! 642: else ! 643: ecomp(buildtree(CBRANCH, $6, ! 644: bcon(brklab))); ! 645: break; ! 646: case LL_BOT: /* test at loop bottom */ ! 647: if (!$6) ! 648: flostat |= FLOOP; ! 649: else if ($6->in.op == ICON && ! 650: $6->tn.lval != 0) ! 651: { ! 652: flostat |= FLOOP; ! 653: tfree($6); ! 654: $6 = (NODE *)0; ! 655: } ! 656: else ! 657: branch($<intval>1 = getlab()); ! 658: deflab($<intval>$ = getlab()); ! 659: break; ! 660: case LL_DUP: /* dup. test at top & bottom */ ! 661: if (!$6) ! 662: flostat |= FLOOP; ! 663: else if ($6->in.op == ICON && ! 664: $6->tn.lval != 0) ! 665: { ! 666: flostat |= FLOOP; ! 667: tfree($6); ! 668: $6 = (NODE *)0; ! 669: } ! 670: else ! 671: { ! 672: #ifndef LINT ! 673: /* don't rotate loops for lint */ ! 674: register NODE *sav; ! 675: extern NODE *treecpy(); ! 676: ! 677: sav = treecpy($6); ! 678: ecomp(buildtree(CBRANCH, $6, ! 679: bcon(brklab))); ! 680: $6 = sav; ! 681: #endif ! 682: } ! 683: deflab($<intval>$ = getlab()); ! 684: break; ! 685: } ! 686: } ! 687: .e RP statement ! 688: { ! 689: if (flostat & FCONT) ! 690: { ! 691: deflab(contlab); ! 692: reached = 1; ! 693: } ! 694: if ($9) ! 695: ecomp($9); ! 696: switch (floop_level) ! 697: { ! 698: default: ! 699: cerror("bad for loop code gen. value"); ! 700: /*NOTREACHED*/ ! 701: case LL_TOP: /* test at loop top */ ! 702: branch($<intval>8); ! 703: break; ! 704: case LL_BOT: /* test at loop bottom */ ! 705: if ($6) ! 706: deflab($<intval>1); ! 707: /*FALLTHROUGH*/ ! 708: case LL_DUP: /* dup. test at top & bottom */ ! 709: if ($6) ! 710: { ! 711: ecomp(buildtree(CBRANCH, ! 712: buildtree(NOT, $6, NIL), ! 713: bcon($<intval>8))); ! 714: } ! 715: else ! 716: branch($<intval>8); ! 717: break; ! 718: } ! 719: deflab(brklab); ! 720: if ((flostat & FBRK) || !(flostat & FLOOP)) ! 721: reached = 1; ! 722: else ! 723: reached = 0; ! 724: resetbc(0); ! 725: #ifdef M32B ! 726: fordepth--; ! 727: #endif ! 728: } ! 729: | switchpart statement ! 730: { if( reached ) branch( brklab ); ! 731: deflab( $1 ); ! 732: swend(); ! 733: deflab(brklab); ! 734: if( (flostat&FBRK) || !(flostat&FDEF) ) reached=1; ! 735: resetbc(FCONT); ! 736: #ifdef M32B ! 737: brdepth--; ! 738: #endif ! 739: } ! 740: | BREAK SM ! 741: { if( brklab == NOLAB ) uerror( "illegal break"); ! 742: else if(reached) branch( brklab ); ! 743: flostat |= FBRK; ! 744: if( brkflag ) goto rch; ! 745: reached = 0; ! 746: } ! 747: | CONTINUE SM ! 748: { if( contlab == NOLAB ) uerror( "illegal continue"); ! 749: else branch( contlab ); ! 750: flostat |= FCONT; ! 751: goto rch; ! 752: } ! 753: | RETURN SM ! 754: { retstat |= NRETVAL; ! 755: branch( retlab ); ! 756: rch: ! 757: if( !reached ) werror( "statement not reached"); ! 758: reached = 0; ! 759: } ! 760: | RETURN e SM ! 761: { register NODE *temp; ! 762: TWORD indtype(); ! 763: idname = curftn; ! 764: temp = buildtree( NAME, NIL, NIL ); ! 765: temp->in.type = DECREF(temp->in.type); ! 766: if(temp->in.type == (FTN|VOID)) ! 767: uerror( ! 768: "void function %s cannot return value", ! 769: stab[idname].sname); ! 770: temp->tn.op = RNODE; ! 771: $2 = makety( $2, temp->fn.type, ! 772: temp->fn.cdim, temp->fn.csiz ); ! 773: temp->in.type = indtype( temp->in.type ); ! 774: temp = buildtree( ASSIGN, temp, $2 ); ! 775: ecomp( temp ); ! 776: retstat |= RETVAL; ! 777: branch( retlab ); ! 778: reached = 0; ! 779: } ! 780: | GOTO NAME SM ! 781: { register NODE *q; ! 782: q = block( FREE, NIL, NIL, INT|ARY, 0, INT ); ! 783: q->tn.rval = idname = $2; ! 784: defid( q, ULABEL ); ! 785: stab[idname].suse = -lineno; ! 786: branch( stab[idname].offset ); ! 787: goto rch; ! 788: } ! 789: | SM ! 790: | error SM ! 791: | error RC ! 792: | label statement ! 793: ; ! 794: label: NAME COLON ! 795: { register NODE *q; ! 796: q = block( FREE, NIL, NIL, INT|ARY, 0, LABEL ); ! 797: q->tn.rval = $1; ! 798: defid( q, LABEL ); ! 799: reached = 1; ! 800: } ! 801: | CASE e COLON ! 802: { addcase($2); ! 803: reached = 1; ! 804: } ! 805: | DEFAULT COLON ! 806: { reached = 1; ! 807: adddef(); ! 808: flostat |= FDEF; ! 809: } ! 810: ; ! 811: doprefix: DO ! 812: { savebc(); ! 813: if( !reached ) werror( "loop not entered at top"); ! 814: brklab = getlab(); ! 815: contlab = getlab(); ! 816: deflab( $$ = getlab() ); ! 817: reached = 1; ! 818: #ifdef M32B ! 819: whdepth++; ! 820: #endif ! 821: } ! 822: ; ! 823: ifprefix: IF LP e RP ! 824: { ecomp( buildtree( CBRANCH, $3, bcon( $$=getlab()) ) ) ; ! 825: reached = 1; ! 826: #ifdef M32B ! 827: brdepth++; ! 828: #endif ! 829: } ! 830: ; ! 831: ifelprefix: ifprefix statement ELSE ! 832: { if( reached ) branch( $$ = getlab() ); ! 833: else $$ = NOLAB; ! 834: deflab( $1 ); ! 835: reached = 1; ! 836: } ! 837: ; ! 838: ! 839: switchpart: SWITCH LP e RP ! 840: { register NODE *temp; ! 841: savebc(); ! 842: temp = block( SNODE, NIL, NIL, INT, 0, INT ); ! 843: temp = buildtree( ASSIGN, temp, $3 ); ! 844: #ifdef M32B ! 845: temp = setswreg( temp ); ! 846: #endif ! 847: brklab = getlab(); ! 848: ecomp( temp ); ! 849: branch( $$ = getlab() ); ! 850: swstart(); ! 851: reached = 0; ! 852: #ifdef M32B ! 853: brdepth++; ! 854: #endif ! 855: } ! 856: ; ! 857: /* EXPRESSIONS */ ! 858: con_e: { $<intval>$=instruct; stwart=instruct=0; } e ! 859: %prec CM ! 860: { $$ = icons( $2 ); instruct=$<intval>1; } ! 861: ; ! 862: .e: e ! 863: | ! 864: { $$=0; } ! 865: ; ! 866: elist: e ! 867: %prec CM ! 868: | elist CM e ! 869: { goto bop; } ! 870: ; ! 871: ! 872: e: e RELOP e ! 873: { ! 874: preconf: ! 875: if( yychar==RELOP || yychar==EQUOP || yychar==AND ! 876: || yychar==OR || yychar==ER ){ ! 877: precplaint: ! 878: if( hflag ) werror( ! 879: "precedence confusion possible: parenthesize!" ! 880: ); ! 881: } ! 882: bop: ! 883: $$ = buildtree( $2, $1, $3 ); ! 884: } ! 885: | e CM e ! 886: { $2 = COMOP; ! 887: goto bop; ! 888: } ! 889: | e DIVOP e ! 890: { goto bop; } ! 891: | e PLUS e ! 892: { if(yychar==SHIFTOP) goto precplaint; else goto bop; } ! 893: | e MINUS e ! 894: { if(yychar==SHIFTOP ) goto precplaint; else goto bop; } ! 895: | e SHIFTOP e ! 896: { if(yychar==PLUS||yychar==MINUS) goto precplaint; else goto bop; } ! 897: | e MUL e ! 898: { goto bop; } ! 899: | e EQUOP e ! 900: { goto preconf; } ! 901: | e AND e ! 902: { if( yychar==RELOP||yychar==EQUOP ) goto preconf; else goto bop; } ! 903: | e OR e ! 904: { if(yychar==RELOP||yychar==EQUOP) goto preconf; else goto bop; } ! 905: | e ER e ! 906: { if(yychar==RELOP||yychar==EQUOP) goto preconf; else goto bop; } ! 907: | e ANDAND e ! 908: { goto bop; } ! 909: | e OROR e ! 910: { goto bop; } ! 911: | e MUL ASSIGN e ! 912: { abop: ! 913: $$ = buildtree( ASG $2, $1, $4 ); ! 914: } ! 915: | e DIVOP ASSIGN e ! 916: { goto abop; } ! 917: | e PLUS ASSIGN e ! 918: { goto abop; } ! 919: | e MINUS ASSIGN e ! 920: { goto abop; } ! 921: | e SHIFTOP ASSIGN e ! 922: { goto abop; } ! 923: | e AND ASSIGN e ! 924: { goto abop; } ! 925: | e OR ASSIGN e ! 926: { goto abop; } ! 927: | e ER ASSIGN e ! 928: { goto abop; } ! 929: | e QUEST e COLON e ! 930: { $$=buildtree(QUEST, $1, buildtree( COLON, $3, $5 ) ); ! 931: } ! 932: | e ASOP e ! 933: { werror( "old-fashioned assignment operator" ); ! 934: goto bop; } ! 935: | e ASSIGN e ! 936: { goto bop; } ! 937: | term ! 938: ; ! 939: ! 940: term: term INCOP ! 941: { $$ = buildtree( $2, $1, bcon(1) ); } ! 942: | MUL term ! 943: { ubop: ! 944: $$ = buildtree( UNARY $1, $2, NIL ); ! 945: } ! 946: | AND term ! 947: { ! 948: #ifdef M32B ! 949: myand($2); ! 950: #endif ! 951: if( ISFTN($2->in.type) || ISARY($2->in.type) ){ ! 952: werror( "& before array or function: ignored" ); ! 953: $$ = $2; ! 954: } ! 955: else goto ubop; ! 956: } ! 957: | MINUS term ! 958: { goto ubop; } ! 959: | UNOP term ! 960: { ! 961: $$ = buildtree( $1, $2, NIL ); ! 962: } ! 963: | INCOP term ! 964: { $$ = buildtree( $1==INCR ? ASG PLUS : ASG MINUS, ! 965: $2, ! 966: bcon(1) ); ! 967: } ! 968: | SIZEOF term ! 969: { $$ = doszof( $2 ); } ! 970: | LP cast_type RP term %prec INCOP ! 971: { $$ = buildtree( CAST, $2, $4 ); ! 972: $$->in.left->in.op = FREE; ! 973: $$->in.op = FREE; ! 974: $$ = $$->in.right; ! 975: } ! 976: | SIZEOF LP cast_type RP %prec SIZEOF ! 977: { $$ = doszof( $3 ); } ! 978: | term LB e RB ! 979: { $$ = buildtree( LB, $1, $3 ); } ! 980: | term LB e COLON e RB ! 981: { $$ = xicolon( $1, $3, $5 ); } ! 982: | funct_idn RP ! 983: { $$=buildtree(UNARY CALL,$1,NIL); } ! 984: | funct_idn elist RP ! 985: { $$=buildtree(CALL,$1,$2); } ! 986: | term STROP NAME ! 987: { if( $2 == DOT ){ ! 988: if( notlval( $1 ) )uerror( ! 989: "structure reference must be addressable" ! 990: ); ! 991: $1 = buildtree( UNARY AND, $1, NIL ); ! 992: } ! 993: idname = $3; ! 994: $$ = buildtree( STREF, $1, ! 995: buildtree( NAME, NIL, NIL ) ); ! 996: } ! 997: | NAME ! 998: { idname = $1; ! 999: /* recognize identifiers in initializations */ ! 1000: if( blevel==0 && stab[idname].stype == UNDEF ) { ! 1001: register NODE *q; ! 1002: werror( "undeclared initializer name %s", ! 1003: stab[idname].sname ); ! 1004: q = block( FREE, NIL, NIL, INT, 0, INT ); ! 1005: q->tn.rval = idname; ! 1006: defid( q, EXTERN ); ! 1007: } ! 1008: $$=buildtree(NAME,NIL,NIL); ! 1009: stab[$1].suse = -lineno; ! 1010: } ! 1011: | ICON ! 1012: { $$=bcon(0); ! 1013: $$->tn.lval = lastcon; ! 1014: $$->tn.rval = NONAME; ! 1015: if( $1 ) $$->fn.csiz = $$->in.type = ctype(LONG); ! 1016: } ! 1017: | FCON ! 1018: { $$=buildtree(FCON,NIL,NIL); ! 1019: $$->fpn.dval = dcon; ! 1020: } ! 1021: | STRING ! 1022: { $$ = getstr(); /* get string contents */ } ! 1023: | LP e RP ! 1024: { $$=$2; } ! 1025: ; ! 1026: ! 1027: cast_type: type null_decl ! 1028: { ! 1029: $$ = tymerge( $1, $2 ); ! 1030: $$->in.op = NAME; ! 1031: $1->in.op = FREE; ! 1032: } ! 1033: ; ! 1034: ! 1035: null_decl: /* EMPTY */ ! 1036: { $$ = bdty( NAME, NIL, -1 ); } ! 1037: | LP RP ! 1038: { $$ = bdty( UNARY CALL, bdty(NAME,NIL,-1),0); } ! 1039: | LP null_decl RP LP RP ! 1040: { $$ = bdty( UNARY CALL, $2, 0 ); } ! 1041: | MUL null_decl ! 1042: { goto umul; } ! 1043: | null_decl LB RB ! 1044: { goto uary; } ! 1045: | null_decl LB con_e RB ! 1046: { goto bary; } ! 1047: | LP null_decl RP ! 1048: { $$ = $2; } ! 1049: ; ! 1050: ! 1051: funct_idn: NAME LP ! 1052: { if( stab[$1].stype == UNDEF ){ ! 1053: register NODE *q; ! 1054: q = block( FREE, NIL, NIL, FTN|INT, 0, INT ); ! 1055: q->tn.rval = $1; ! 1056: defid( q, EXTERN ); ! 1057: } ! 1058: idname = $1; ! 1059: $$=buildtree(NAME,NIL,NIL); ! 1060: stab[idname].suse = -lineno; ! 1061: } ! 1062: | term LP ! 1063: ; ! 1064: %% ! 1065: ! 1066: NODE * ! 1067: mkty( t, d, s ) unsigned t; { ! 1068: return( block( TYPE, NIL, NIL, t, d, s ) ); ! 1069: } ! 1070: ! 1071: NODE * ! 1072: bdty( op, p, v ) NODE *p; { ! 1073: register NODE *q; ! 1074: ! 1075: q = block( op, p, NIL, INT, 0, INT ); ! 1076: ! 1077: switch( op ){ ! 1078: ! 1079: case UNARY MUL: ! 1080: case UNARY CALL: ! 1081: break; ! 1082: ! 1083: case LB: ! 1084: q->in.right = bcon(v); ! 1085: break; ! 1086: ! 1087: case NAME: ! 1088: q->tn.rval = v; ! 1089: break; ! 1090: ! 1091: default: ! 1092: cerror( "bad bdty" ); ! 1093: } ! 1094: ! 1095: return( q ); ! 1096: } ! 1097: ! 1098: dstash( n ){ /* put n into the dimension table */ ! 1099: if( curdim >= DIMTABSZ-1 ){ ! 1100: cerror( "dimension table overflow"); ! 1101: } ! 1102: dimtab[ curdim++ ] = n; ! 1103: } ! 1104: ! 1105: savebc() { ! 1106: if( psavbc > & asavbc[BCSZ-4 ] ){ ! 1107: cerror( "whiles, fors, etc. too deeply nested"); ! 1108: } ! 1109: *psavbc++ = brklab; ! 1110: *psavbc++ = contlab; ! 1111: *psavbc++ = flostat; ! 1112: *psavbc++ = swx; ! 1113: #ifdef M32B ! 1114: *psavbc++ = swregno; ! 1115: #endif ! 1116: flostat = 0; ! 1117: } ! 1118: ! 1119: resetbc(mask){ ! 1120: ! 1121: #ifdef M32B ! 1122: swregno = *--psavbc; ! 1123: #endif ! 1124: swx = *--psavbc; ! 1125: flostat = *--psavbc | (flostat&mask); ! 1126: contlab = *--psavbc; ! 1127: brklab = *--psavbc; ! 1128: ! 1129: } ! 1130: ! 1131: addcase(p) NODE *p; { /* add case to switch */ ! 1132: ! 1133: p = optim( p ); /* change enum to ints */ ! 1134: if( p->in.op != ICON ){ ! 1135: uerror( "non-constant case expression"); ! 1136: return; ! 1137: } ! 1138: if( swp == swtab ){ ! 1139: uerror( "case not in switch"); ! 1140: return; ! 1141: } ! 1142: if( swp >= &swtab[SWITSZ] ){ ! 1143: cerror( "switch table overflow"); ! 1144: } ! 1145: swp->sval = p->tn.lval; ! 1146: deflab( swp->slab = getlab() ); ! 1147: ++swp; ! 1148: tfree(p); ! 1149: } ! 1150: ! 1151: adddef(){ /* add default case to switch */ ! 1152: if( swtab[swx].slab >= 0 ){ ! 1153: uerror( "duplicate default in switch"); ! 1154: return; ! 1155: } ! 1156: if( swp == swtab ){ ! 1157: uerror( "default not inside switch"); ! 1158: return; ! 1159: } ! 1160: deflab( swtab[swx].slab = getlab() ); ! 1161: } ! 1162: ! 1163: swstart(){ ! 1164: /* begin a switch block */ ! 1165: if( swp >= &swtab[SWITSZ] ){ ! 1166: cerror( "switch table overflow"); ! 1167: } ! 1168: swx = swp - swtab; ! 1169: swp->slab = -1; ! 1170: ++swp; ! 1171: } ! 1172: ! 1173: swend(){ /* end a switch block */ ! 1174: ! 1175: register struct sw *swbeg, *p, *q, *r, *r1; ! 1176: CONSZ temp; ! 1177: int tempi; ! 1178: ! 1179: swbeg = &swtab[swx+1]; ! 1180: ! 1181: /* sort */ ! 1182: ! 1183: r1 = swbeg; ! 1184: r = swp-1; ! 1185: ! 1186: while( swbeg < r ){ ! 1187: /* bubble largest to end */ ! 1188: for( q=swbeg; q<r; ++q ){ ! 1189: if( q->sval > (q+1)->sval ){ ! 1190: /* swap */ ! 1191: r1 = q+1; ! 1192: temp = q->sval; ! 1193: q->sval = r1->sval; ! 1194: r1->sval = temp; ! 1195: tempi = q->slab; ! 1196: q->slab = r1->slab; ! 1197: r1->slab = tempi; ! 1198: } ! 1199: } ! 1200: r = r1; ! 1201: r1 = swbeg; ! 1202: } ! 1203: ! 1204: /* it is now sorted */ ! 1205: ! 1206: for( p = swbeg+1; p<swp; ++p ){ ! 1207: if( p->sval == (p-1)->sval ){ ! 1208: uerror( "duplicate case in switch, %d", tempi=p->sval ); ! 1209: return; ! 1210: } ! 1211: } ! 1212: ! 1213: reached = 1; ! 1214: genswitch( swbeg-1, (int)(swp-swbeg) ); ! 1215: swp = swbeg-1; ! 1216: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.