![[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] / researchv10no / cmd / ccom / common|
Return to cgram.y CVS log | Up to [Research Unix] / researchv10no / cmd / ccom / common |
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: uplevel(); ! 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: default: ! 496: cerror("bad while loop code gen value"); ! 497: /*NOTREACHED*/ ! 498: case LL_TOP: /* test at loop top */ ! 499: deflab(contlab); ! 500: if ($4->in.op == ICON && $4->tn.lval) { ! 501: flostat = FLOOP; ! 502: tfree($4); ! 503: } else { ! 504: $4->ln.lineno = $<lineno>1; ! 505: ecomp(buildtree(CBRANCH, $4, ! 506: bcon(brklab))); ! 507: } ! 508: break; ! 509: case LL_BOT: /* test at loop bottom */ ! 510: if ($4->in.op == ICON && $4->tn.lval) { ! 511: flostat = FLOOP; ! 512: tfree($4); ! 513: deflab(contlab); ! 514: } else { ! 515: branch(contlab); ! 516: deflab($<intval>$ = getlab()); ! 517: } ! 518: break; ! 519: case LL_DUP: /* dup. test at top & bottom */ ! 520: if ($4->in.op == ICON && $4->tn.lval) { ! 521: flostat = FLOOP; ! 522: tfree($4); ! 523: deflab($<intval>$ = contlab); ! 524: } else { ! 525: register NODE *sav; ! 526: extern NODE *treecpy(); ! 527: sav = treecpy($4); ! 528: ecomp(buildtree(CBRANCH,$4, ! 529: bcon(brklab))); ! 530: $4 = sav; ! 531: deflab($<intval>$ = getlab()); ! 532: } ! 533: break; ! 534: } ! 535: } ! 536: statement ! 537: { ! 538: switch (wloop_level) { ! 539: default: ! 540: cerror("bad while loop code gen. value"); ! 541: /*NOTREACHED*/ ! 542: case LL_TOP: /* test at loop top */ ! 543: branch(contlab); ! 544: break; ! 545: case LL_BOT: /* test at loop bottom */ ! 546: if (flostat & FLOOP) ! 547: branch(contlab); ! 548: else { ! 549: reached = 1; ! 550: deflab(contlab); ! 551: ecomp(buildtree(CBRANCH, ! 552: buildtree(NOT, $4, NIL), ! 553: bcon($<intval>6))); ! 554: } ! 555: break; ! 556: case LL_DUP: /* dup. test at top & bottom */ ! 557: if (flostat & FLOOP) ! 558: branch(contlab); ! 559: else { ! 560: if (flostat & FCONT) { ! 561: reached = 1; ! 562: deflab(contlab); ! 563: } ! 564: ecomp(buildtree(CBRANCH, ! 565: buildtree(NOT, $4, NIL), ! 566: bcon($<intval>6))); ! 567: } ! 568: break; ! 569: } ! 570: if ((flostat & FBRK) || !(flostat & FLOOP)) ! 571: reached = 1; ! 572: else ! 573: reached = 0; ! 574: deflab(brklab); ! 575: resetbc(0); ! 576: #ifdef M32B ! 577: whdepth--; ! 578: #endif ! 579: } ! 580: | doprefix statement WHILE LP e RP SM ! 581: { deflab( contlab ); ! 582: if( flostat & FCONT ) reached = 1; ! 583: $5->ln.lineno = $<lineno>3; ! 584: ecomp( buildtree(CBRANCH, ! 585: buildtree(NOT, $5, NIL), bcon($1))); ! 586: deflab( brklab ); ! 587: reached = 1; ! 588: resetbc(0); ! 589: #ifdef M32B ! 590: whdepth--; ! 591: #endif ! 592: } ! 593: | FOR LP .e SM ! 594: { ! 595: #ifdef M32B ! 596: fordepth++; ! 597: #endif ! 598: } ! 599: .e SM ! 600: { ! 601: if ($3) { ! 602: $3->ln.lineno = $<lineno>1; ! 603: ecomp($3); ! 604: } else if (!reached) ! 605: werror("loop not entered at top"); ! 606: savebc(); ! 607: contlab = getlab(); ! 608: brklab = getlab(); ! 609: reached = 1; ! 610: switch (floop_level) { ! 611: default: ! 612: cerror("bad for loop code gen. value"); ! 613: /*NOTREACHED*/ ! 614: case LL_TOP: /* test at loop top */ ! 615: deflab($<intval>$ = getlab()); ! 616: if (!$6) ! 617: flostat |= FLOOP; ! 618: else if ($6->in.op == ICON && $6->tn.lval) { ! 619: flostat |= FLOOP; ! 620: tfree($6); ! 621: $6 = (NODE *)0; ! 622: } else { ! 623: if (!$3) ! 624: $6->ln.lineno = $<lineno>1; ! 625: ecomp(buildtree(CBRANCH, $6, ! 626: bcon(brklab))); ! 627: } ! 628: break; ! 629: case LL_BOT: /* test at loop bottom */ ! 630: if (!$6) ! 631: flostat |= FLOOP; ! 632: else if ($6->in.op == ICON && $6->tn.lval) { ! 633: flostat |= FLOOP; ! 634: tfree($6); ! 635: $6 = (NODE *)0; ! 636: } else ! 637: branch($<intval>1 = getlab()); ! 638: deflab($<intval>$ = getlab()); ! 639: break; ! 640: case LL_DUP: /* dup. test at top & bottom */ ! 641: if (!$6) ! 642: flostat |= FLOOP; ! 643: else if ($6->in.op == ICON && $6->tn.lval) { ! 644: flostat |= FLOOP; ! 645: tfree($6); ! 646: $6 = (NODE *)0; ! 647: } else { ! 648: register NODE *sav; ! 649: extern NODE *treecpy(); ! 650: sav = treecpy($6); ! 651: ecomp(buildtree(CBRANCH, $6, ! 652: bcon(brklab))); ! 653: $6 = sav; ! 654: } ! 655: deflab($<intval>$ = getlab()); ! 656: break; ! 657: } ! 658: } ! 659: .e RP statement ! 660: { ! 661: if (flostat & FCONT) { ! 662: deflab(contlab); ! 663: reached = 1; ! 664: } ! 665: if ($9) ! 666: $9->ln.lineno = lineno, ecomp($9); ! 667: switch (floop_level) { ! 668: default: ! 669: cerror("bad for loop code gen. value"); ! 670: /*NOTREACHED*/ ! 671: case LL_TOP: /* test at loop top */ ! 672: branch($<intval>8); ! 673: break; ! 674: case LL_BOT: /* test at loop bottom */ ! 675: if ($6) ! 676: deflab($<intval>1); ! 677: /*FALLTHROUGH*/ ! 678: case LL_DUP: /* dup. test at top & bottom */ ! 679: if ($6) { ! 680: ecomp(buildtree(CBRANCH, ! 681: buildtree(NOT, $6, NIL), ! 682: bcon($<intval>8))); ! 683: } else ! 684: branch($<intval>8); ! 685: break; ! 686: } ! 687: deflab(brklab); ! 688: if ((flostat & FBRK) || !(flostat & FLOOP)) ! 689: reached = 1; ! 690: else ! 691: reached = 0; ! 692: resetbc(0); ! 693: #ifdef M32B ! 694: fordepth--; ! 695: #endif ! 696: } ! 697: | switchpart statement ! 698: { if( reached ) branch( brklab ); ! 699: deflab( $1 ); ! 700: swend(); ! 701: deflab(brklab); ! 702: if( (flostat&FBRK) || !(flostat&FDEF) ) reached=1; ! 703: resetbc(FCONT); ! 704: #ifdef M32B ! 705: brdepth--; ! 706: #endif ! 707: } ! 708: | BREAK SM ! 709: { if( brklab == NOLAB ) uerror( "illegal break"); ! 710: else if(reached) { ! 711: slineno = $<lineno>1; dbline(); ! 712: branch( brklab ); ! 713: } ! 714: flostat |= FBRK; ! 715: if( brkflag ) goto rch; ! 716: reached = 0; ! 717: } ! 718: | CONTINUE SM ! 719: { if( contlab == NOLAB ) uerror( "illegal continue"); ! 720: else { ! 721: slineno = $<lineno>1; dbline(); ! 722: branch( contlab ); ! 723: } ! 724: flostat |= FCONT; ! 725: goto rch; ! 726: } ! 727: | RETURN SM ! 728: { retstat |= NRETVAL; ! 729: slineno = $<lineno>1; dbline(); ! 730: branch( retlab ); ! 731: rch: ! 732: if( !reached ) werror( "statement not reached"); ! 733: reached = 0; ! 734: } ! 735: | RETURN e SM ! 736: { register NODE *temp; ! 737: TWORD indtype(); ! 738: idname = curftn; ! 739: temp = buildtree( NAME, NIL, NIL ); ! 740: temp->in.type = DECREF(temp->in.type); ! 741: if(temp->in.type == (FTN|VOID)) ! 742: uerror( ! 743: "void function %s cannot return value", ! 744: stab[idname].sname); ! 745: temp->tn.op = RNODE; ! 746: $2 = makety( $2, temp->fn.type, ! 747: temp->fn.cdim, temp->fn.csiz ); ! 748: temp->in.type = indtype( temp->in.type ); ! 749: temp = buildtree( ASSIGN, temp, $2 ); ! 750: temp->ln.lineno = $<lineno>1; ! 751: ecomp( temp ); ! 752: retstat |= RETVAL; ! 753: branch( retlab ); ! 754: reached = 0; ! 755: } ! 756: | GOTO NAME SM ! 757: { register NODE *q; ! 758: q = block( FREE, NIL, NIL, INT|ARY, 0, INT ); ! 759: q->tn.rval = idname = $2; ! 760: defid( q, ULABEL ); ! 761: stab[idname].suse = -lineno; ! 762: slineno = $<lineno>1; dbline(); ! 763: branch( stab[idname].offset ); ! 764: goto rch; ! 765: } ! 766: | SM ! 767: | error SM ! 768: | error RC ! 769: | label statement ! 770: ; ! 771: label: NAME COLON ! 772: { register NODE *q; ! 773: q = block( FREE, NIL, NIL, INT|ARY, 0, LABEL ); ! 774: q->tn.rval = $1; ! 775: defid( q, LABEL ); ! 776: reached = 1; ! 777: } ! 778: | CASE e COLON ! 779: { addcase($2); ! 780: reached = 1; ! 781: } ! 782: | DEFAULT COLON ! 783: { reached = 1; ! 784: adddef(); ! 785: flostat |= FDEF; ! 786: } ! 787: ; ! 788: doprefix: DO ! 789: { savebc(); ! 790: if( !reached ) werror( "loop not entered at top"); ! 791: brklab = getlab(); ! 792: contlab = getlab(); ! 793: deflab( $$ = getlab() ); ! 794: reached = 1; ! 795: #ifdef M32B ! 796: whdepth++; ! 797: #endif ! 798: } ! 799: ; ! 800: ifprefix: IF LP e RP ! 801: { $3->ln.lineno = $<lineno>1; ! 802: ecomp(buildtree(CBRANCH, $3, bcon($$=getlab()))) ; ! 803: reached = 1; ! 804: #ifdef M32B ! 805: brdepth++; ! 806: #endif ! 807: } ! 808: ; ! 809: ifelprefix: ifprefix statement ELSE ! 810: { if( reached ) branch( $$ = getlab() ); ! 811: else $$ = NOLAB; ! 812: deflab( $1 ); ! 813: reached = 1; ! 814: } ! 815: ; ! 816: ! 817: switchpart: SWITCH LP e RP ! 818: { register NODE *temp; ! 819: savebc(); ! 820: temp = block( SNODE, NIL, NIL, INT, 0, INT ); ! 821: temp = buildtree( ASSIGN, temp, $3 ); ! 822: #ifdef M32B ! 823: temp = setswreg( temp ); ! 824: #endif ! 825: brklab = getlab(); ! 826: temp->ln.lineno = $<lineno>1; ! 827: ecomp( temp ); ! 828: branch( $$ = getlab() ); ! 829: swstart(); ! 830: reached = 0; ! 831: #ifdef M32B ! 832: brdepth++; ! 833: #endif ! 834: } ! 835: ; ! 836: /* EXPRESSIONS */ ! 837: con_e: { $<intval>$=instruct; stwart=instruct=0; } e ! 838: %prec CM ! 839: { $$ = icons( $2 ); instruct=$<intval>1; } ! 840: ; ! 841: .e: e ! 842: | ! 843: { $$ = 0; } ! 844: ; ! 845: elist: e ! 846: %prec CM ! 847: | elist CM e ! 848: { goto bop; } ! 849: ; ! 850: ! 851: e: e RELOP e ! 852: { ! 853: preconf: ! 854: if( yychar==RELOP || yychar==EQUOP || yychar==AND ! 855: || yychar==OR || yychar==ER ){ ! 856: precplaint: ! 857: if( hflag ) werror( ! 858: "precedence confusion possible: parenthesize!" ! 859: ); ! 860: } ! 861: bop: ! 862: $$ = buildtree( $2, $1, $3 ); ! 863: } ! 864: | e CM e ! 865: { $2 = COMOP; ! 866: goto bop; ! 867: } ! 868: | e DIVOP e ! 869: { goto bop; } ! 870: | e PLUS e ! 871: { if(yychar==SHIFTOP) goto precplaint; else goto bop; } ! 872: | e MINUS e ! 873: { if(yychar==SHIFTOP ) goto precplaint; else goto bop; } ! 874: | e SHIFTOP e ! 875: { if(yychar==PLUS||yychar==MINUS) goto precplaint; else goto bop; } ! 876: | e MUL e ! 877: { goto bop; } ! 878: | e EQUOP e ! 879: { goto preconf; } ! 880: | e AND e ! 881: { if( yychar==RELOP||yychar==EQUOP ) goto preconf; else goto bop; } ! 882: | e OR e ! 883: { if(yychar==RELOP||yychar==EQUOP) goto preconf; else goto bop; } ! 884: | e ER e ! 885: { if(yychar==RELOP||yychar==EQUOP) goto preconf; else goto bop; } ! 886: | e ANDAND e ! 887: { goto bop; } ! 888: | e OROR e ! 889: { goto bop; } ! 890: | e MUL ASSIGN e ! 891: { abop: ! 892: $$ = buildtree( ASG $2, $1, $4 ); ! 893: } ! 894: | e DIVOP ASSIGN e ! 895: { goto abop; } ! 896: | e PLUS ASSIGN e ! 897: { goto abop; } ! 898: | e MINUS ASSIGN e ! 899: { goto abop; } ! 900: | e SHIFTOP ASSIGN e ! 901: { goto abop; } ! 902: | e AND ASSIGN e ! 903: { goto abop; } ! 904: | e OR ASSIGN e ! 905: { goto abop; } ! 906: | e ER ASSIGN e ! 907: { goto abop; } ! 908: | e QUEST e COLON e ! 909: { $$=buildtree(QUEST, $1, buildtree( COLON, $3, $5 ) ); ! 910: } ! 911: | e ASOP e ! 912: { werror( "old-fashioned assignment operator" ); ! 913: goto bop; } ! 914: | e ASSIGN e ! 915: { goto bop; } ! 916: | term ! 917: ; ! 918: ! 919: term: term INCOP ! 920: { $$ = buildtree( $2, $1, bcon(1) ); } ! 921: | MUL term ! 922: { ubop: ! 923: $$ = buildtree( UNARY $1, $2, NIL ); ! 924: } ! 925: | AND term ! 926: { ! 927: #ifdef M32B ! 928: myand($2); ! 929: #endif ! 930: if( ISFTN($2->in.type) || ISARY($2->in.type) ){ ! 931: werror( "& before array or function: ignored" ); ! 932: $$ = $2; ! 933: } ! 934: else goto ubop; ! 935: } ! 936: | MINUS term ! 937: { goto ubop; } ! 938: | UNOP term ! 939: { ! 940: $$ = buildtree( $1, $2, NIL ); ! 941: } ! 942: | INCOP term ! 943: { $$ = buildtree( $1==INCR ? ASG PLUS : ASG MINUS, ! 944: $2, ! 945: bcon(1) ); ! 946: } ! 947: | SIZEOF term ! 948: { $$ = doszof( $2 ); } ! 949: | LP cast_type RP term %prec INCOP ! 950: { $$ = buildtree( CAST, $2, $4 ); ! 951: $$->in.left->in.op = FREE; ! 952: $$->in.op = FREE; ! 953: $$ = $$->in.right; ! 954: } ! 955: | SIZEOF LP cast_type RP %prec SIZEOF ! 956: { $$ = doszof( $3 ); } ! 957: | term LB e RB ! 958: { $$ = buildtree( LB, $1, $3 ); } ! 959: | term LB e COLON e RB ! 960: { $$ = xicolon( $1, $3, $5 ); } ! 961: | funct_idn RP ! 962: { $$=buildtree(UNARY CALL,$1,NIL); ! 963: } ! 964: | funct_idn elist RP ! 965: { $$=buildtree(CALL,$1,$2); } ! 966: | term STROP NAME ! 967: { if( $2 == DOT ){ ! 968: if( notlval( $1 ) )werror( ! 969: "structure reference must be addressable" ! 970: ); ! 971: $1 = buildtree( UNARY AND, $1, NIL ); ! 972: } ! 973: idname = $3; ! 974: $$ = buildtree( STREF, $1, ! 975: buildtree( NAME, NIL, NIL ) ); ! 976: } ! 977: | NAME ! 978: { idname = $1; ! 979: /* recognize identifiers in initializations */ ! 980: if( blevel==0 && stab[idname].stype == UNDEF ) { ! 981: register NODE *q; ! 982: werror( "undeclared initializer name %s", ! 983: stab[idname].sname ); ! 984: q = block( FREE, NIL, NIL, INT, 0, INT ); ! 985: q->tn.rval = idname; ! 986: defid( q, EXTERN ); ! 987: } ! 988: $$=buildtree(NAME,NIL,NIL); ! 989: stab[$1].suse = -lineno; ! 990: } ! 991: | ICON ! 992: { $$=bcon(0); ! 993: $$->tn.lval = lastcon; ! 994: $$->tn.rval = NONAME; ! 995: if( $1 ) $$->fn.csiz = $$->in.type = ctype(LONG); ! 996: } ! 997: | FCON ! 998: { $$=buildtree(FCON,NIL,NIL); ! 999: $$->fpn.dval = dcon; ! 1000: } ! 1001: | STRING ! 1002: { $$ = getstr(); } ! 1003: | LP e RP ! 1004: { $$=$2; } ! 1005: ; ! 1006: ! 1007: cast_type: type null_decl ! 1008: { ! 1009: $$ = tymerge( $1, $2 ); ! 1010: $$->in.op = NAME; ! 1011: $1->in.op = FREE; ! 1012: } ! 1013: ; ! 1014: ! 1015: null_decl: /* EMPTY */ ! 1016: { $$ = bdty( NAME, NIL, -1 ); } ! 1017: | LP RP ! 1018: { $$ = bdty( UNARY CALL, bdty(NAME,NIL,-1),0); } ! 1019: | LP null_decl RP LP RP ! 1020: { $$ = bdty( UNARY CALL, $2, 0 ); } ! 1021: | MUL null_decl ! 1022: { goto umul; } ! 1023: | null_decl LB RB ! 1024: { goto uary; } ! 1025: | null_decl LB con_e RB ! 1026: { goto bary; } ! 1027: | LP null_decl RP ! 1028: { $$ = $2; } ! 1029: ; ! 1030: ! 1031: funct_idn: NAME LP ! 1032: { if( stab[$1].stype == UNDEF ){ ! 1033: register NODE *q; ! 1034: q = block( FREE, NIL, NIL, FTN|INT, 0, INT ); ! 1035: q->tn.rval = $1; ! 1036: defid( q, EXTERN ); ! 1037: } ! 1038: idname = $1; ! 1039: $$=buildtree(NAME,NIL,NIL); ! 1040: stab[idname].suse = -lineno; ! 1041: } ! 1042: | term LP ! 1043: ; ! 1044: %% ! 1045: ! 1046: NODE * ! 1047: mkty( t, d, s ) unsigned t; { ! 1048: return( block( TYPE, NIL, NIL, t, d, s ) ); ! 1049: } ! 1050: ! 1051: NODE * ! 1052: bdty( op, p, v ) NODE *p; { ! 1053: register NODE *q; ! 1054: ! 1055: q = block( op, p, NIL, INT, 0, INT ); ! 1056: ! 1057: switch( op ){ ! 1058: ! 1059: case UNARY MUL: ! 1060: case UNARY CALL: ! 1061: break; ! 1062: ! 1063: case LB: ! 1064: q->in.right = bcon(v); ! 1065: break; ! 1066: ! 1067: case NAME: ! 1068: q->tn.rval = v; ! 1069: break; ! 1070: ! 1071: default: ! 1072: cerror( "bad bdty" ); ! 1073: } ! 1074: ! 1075: return( q ); ! 1076: } ! 1077: int dimtabsz; ! 1078: allodimtab() ! 1079: { ! 1080: if(!dimtabsz) ! 1081: dimtab = (int *) malloc((dimtabsz = DIMTABSZ)*sizeof(int)); ! 1082: else { ! 1083: dimtabsz *= 3; ! 1084: dimtab = (int *) realloc((char *)dimtab, dimtabsz*sizeof(int)); ! 1085: } ! 1086: if(!dimtab) ! 1087: cerror("dimension table overflow"); ! 1088: } ! 1089: ! 1090: dstash( n ){ /* put n into the dimension table */ ! 1091: if( curdim >= dimtabsz-1 ){ ! 1092: allodimtab(); ! 1093: } ! 1094: dimtab[ curdim++ ] = n; ! 1095: } ! 1096: ! 1097: savebc() { ! 1098: if( psavbc > & asavbc[BCSZ-4 ] ){ ! 1099: cerror( "whiles, fors, etc. too deeply nested"); ! 1100: } ! 1101: *psavbc++ = brklab; ! 1102: *psavbc++ = contlab; ! 1103: *psavbc++ = flostat; ! 1104: *psavbc++ = swx; ! 1105: #ifdef M32B ! 1106: *psavbc++ = swregno; ! 1107: #endif ! 1108: flostat = 0; ! 1109: } ! 1110: ! 1111: resetbc(mask){ ! 1112: ! 1113: #ifdef M32B ! 1114: swregno = *--psavbc; ! 1115: #endif ! 1116: swx = *--psavbc; ! 1117: flostat = *--psavbc | (flostat&mask); ! 1118: contlab = *--psavbc; ! 1119: brklab = *--psavbc; ! 1120: ! 1121: } ! 1122: ! 1123: addcase(p) NODE *p; { /* add case to switch */ ! 1124: ! 1125: p = optim( p ); /* change enum to ints */ ! 1126: if( p->in.op != ICON || p->tn.rval != NONAME){ ! 1127: uerror( "non-constant case expression"); ! 1128: return; ! 1129: } ! 1130: if( swp == swtab ){ ! 1131: uerror( "case not in switch"); ! 1132: return; ! 1133: } ! 1134: if( swp >= &swtab[SWITSZ] ){ ! 1135: cerror( "switch table overflow"); ! 1136: } ! 1137: swp->sval = p->tn.lval; ! 1138: deflab( swp->slab = getlab() ); ! 1139: ++swp; ! 1140: tfree(p); ! 1141: } ! 1142: ! 1143: adddef(){ /* add default case to switch */ ! 1144: if( swtab[swx].slab >= 0 ){ ! 1145: uerror( "duplicate default in switch"); ! 1146: return; ! 1147: } ! 1148: if( swp == swtab ){ ! 1149: uerror( "default not inside switch"); ! 1150: return; ! 1151: } ! 1152: deflab( swtab[swx].slab = getlab() ); ! 1153: } ! 1154: ! 1155: swstart(){ ! 1156: /* begin a switch block */ ! 1157: if( swp >= &swtab[SWITSZ] ){ ! 1158: cerror( "switch table overflow"); ! 1159: } ! 1160: swx = swp - swtab; ! 1161: swp->slab = -1; ! 1162: ++swp; ! 1163: } ! 1164: ! 1165: swend(){ /* end a switch block */ ! 1166: ! 1167: register struct sw *swbeg, *p, *q, *r, *r1; ! 1168: CONSZ temp; ! 1169: int tempi; ! 1170: ! 1171: swbeg = &swtab[swx+1]; ! 1172: ! 1173: /* sort */ ! 1174: ! 1175: r1 = swbeg; ! 1176: r = swp-1; ! 1177: ! 1178: while( swbeg < r ){ ! 1179: /* bubble largest to end */ ! 1180: for( q=swbeg; q<r; ++q ){ ! 1181: if( q->sval > (q+1)->sval ){ ! 1182: /* swap */ ! 1183: r1 = q+1; ! 1184: temp = q->sval; ! 1185: q->sval = r1->sval; ! 1186: r1->sval = temp; ! 1187: tempi = q->slab; ! 1188: q->slab = r1->slab; ! 1189: r1->slab = tempi; ! 1190: } ! 1191: } ! 1192: r = r1; ! 1193: r1 = swbeg; ! 1194: } ! 1195: ! 1196: /* it is now sorted */ ! 1197: ! 1198: for( p = swbeg+1; p<swp; ++p ){ ! 1199: if( p->sval == (p-1)->sval ){ ! 1200: uerror( "duplicate case in switch, %d", tempi=p->sval ); ! 1201: return; ! 1202: } ! 1203: } ! 1204: ! 1205: reached = 1; ! 1206: genswitch( swbeg-1, (int)(swp-swbeg) ); ! 1207: swp = swbeg-1; ! 1208: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.