![[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 [CSRG BSD Unix] / 43BSDTahoe / lib / mip|
Return to cgram.y CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / lib / mip |
1.1 ! root 1: /* cgram.y 4.22 87/12/09 */ ! 2: ! 3: /* ! 4: * Grammar for the C compiler. ! 5: * ! 6: * This grammar requires the definitions of terminals in the file 'pcctokens'. ! 7: * (YACC doesn't have an 'include' mechanism, unfortunately.) ! 8: */ ! 9: ! 10: ! 11: /* at last count, there were 7 shift/reduce, 1 reduce/reduce conflicts ! 12: /* these involved: ! 13: if/else ! 14: recognizing functions in various contexts, including declarations ! 15: error recovery ! 16: */ ! 17: ! 18: %left CM ! 19: %right ASOP ASSIGN ! 20: %right QUEST COLON ! 21: %left OROR ! 22: %left ANDAND ! 23: %left OR ! 24: %left ER ! 25: %left AND ! 26: %left EQUOP ! 27: %left RELOP ! 28: %left SHIFTOP ! 29: %left PLUS MINUS ! 30: %left MUL DIVOP ! 31: %right UNOP ! 32: %right INCOP SIZEOF ! 33: %left LB LP STROP ! 34: %{ ! 35: # include "pass1.h" ! 36: %} ! 37: ! 38: /* define types */ ! 39: %start ext_def_list ! 40: ! 41: %type <intval> con_e ifelprefix ifprefix whprefix forprefix doprefix switchpart ! 42: enum_head str_head name_lp ! 43: %type <nodep> e .e term attributes oattributes type enum_dcl struct_dcl ! 44: cast_type null_decl funct_idn declarator fdeclarator nfdeclarator ! 45: elist ! 46: ! 47: %token <intval> CLASS NAME STRUCT RELOP CM DIVOP PLUS MINUS SHIFTOP MUL AND OR ER ANDAND OROR ! 48: ASSIGN STROP INCOP UNOP ICON ! 49: %token <nodep> TYPE ! 50: ! 51: %% ! 52: ! 53: %{ ! 54: static int fake = 0; ! 55: #ifndef FLEXNAMES ! 56: static char fakename[NCHNAM+1]; ! 57: #else ! 58: static char fakename[24]; ! 59: #endif ! 60: static int nsizeof = 0; ! 61: %} ! 62: ! 63: ext_def_list: ext_def_list external_def ! 64: | ! 65: =ftnend(); ! 66: ; ! 67: external_def: data_def ! 68: ={ curclass = SNULL; blevel = 0; } ! 69: | error ! 70: ={ curclass = SNULL; blevel = 0; } ! 71: ; ! 72: data_def: ! 73: oattributes SM ! 74: ={ $1->in.op = FREE; } ! 75: | oattributes init_dcl_list SM ! 76: ={ $1->in.op = FREE; } ! 77: | oattributes fdeclarator { ! 78: defid( tymerge($1,$2), curclass==STATIC?STATIC:EXTDEF ); ! 79: #ifndef LINT ! 80: if( nerrors == 0 ) ! 81: pfstab(stab[$2->tn.rval].sname); ! 82: #endif ! 83: } function_body ! 84: ={ ! 85: if( blevel ) cerror( "function level error" ); ! 86: if( reached ) retstat |= NRETVAL; ! 87: $1->in.op = FREE; ! 88: ftnend(); ! 89: } ! 90: ; ! 91: ! 92: function_body: arg_dcl_list compoundstmt ! 93: ; ! 94: arg_dcl_list: arg_dcl_list declaration ! 95: | ={ blevel = 1; } ! 96: ; ! 97: ! 98: stmt_list: stmt_list statement ! 99: | /* empty */ ! 100: ={ bccode(); ! 101: (void) locctr(PROG); ! 102: } ! 103: ; ! 104: ! 105: r_dcl_stat_list : dcl_stat_list attributes SM ! 106: ={ $2->in.op = FREE; ! 107: #ifndef LINT ! 108: if( nerrors == 0 ) plcstab(blevel); ! 109: #endif ! 110: } ! 111: | dcl_stat_list attributes init_dcl_list SM ! 112: ={ $2->in.op = FREE; ! 113: #ifndef LINT ! 114: if( nerrors == 0 ) plcstab(blevel); ! 115: #endif ! 116: } ! 117: ; ! 118: ! 119: dcl_stat_list : dcl_stat_list attributes SM ! 120: ={ $2->in.op = FREE; } ! 121: | dcl_stat_list attributes init_dcl_list SM ! 122: ={ $2->in.op = FREE; } ! 123: | /* empty */ ! 124: ; ! 125: declaration: attributes declarator_list SM ! 126: ={ curclass = SNULL; $1->in.op = FREE; } ! 127: | attributes SM ! 128: ={ curclass = SNULL; $1->in.op = FREE; } ! 129: | error SM ! 130: ={ curclass = SNULL; } ! 131: ; ! 132: oattributes: attributes ! 133: | /* VOID */ ! 134: ={ $$ = mkty(INT,0,INT); curclass = SNULL; } ! 135: ; ! 136: attributes: class type ! 137: ={ $$ = $2; } ! 138: | type class ! 139: | class ! 140: ={ $$ = mkty(INT,0,INT); } ! 141: | type ! 142: ={ curclass = SNULL ; } ! 143: | type class type ! 144: ={ $1->in.type = types( $1->in.type, $3->in.type, UNDEF ); ! 145: $3->in.op = FREE; ! 146: } ! 147: ; ! 148: ! 149: ! 150: class: CLASS ! 151: ={ curclass = $1; } ! 152: ; ! 153: ! 154: type: TYPE ! 155: | TYPE TYPE ! 156: ={ $1->in.type = types( $1->in.type, $2->in.type, UNDEF ); ! 157: $2->in.op = FREE; ! 158: } ! 159: | TYPE TYPE TYPE ! 160: ={ $1->in.type = types( $1->in.type, $2->in.type, $3->in.type ); ! 161: $2->in.op = $3->in.op = FREE; ! 162: } ! 163: | struct_dcl ! 164: | enum_dcl ! 165: ; ! 166: ! 167: enum_dcl: enum_head LC moe_list optcomma RC ! 168: ={ $$ = dclstruct($1); } ! 169: | ENUM NAME ! 170: ={ $$ = rstruct($2,0); stwart = instruct; } ! 171: ; ! 172: ! 173: enum_head: ENUM ! 174: ={ $$ = bstruct(-1,0); stwart = SEENAME; } ! 175: | ENUM NAME ! 176: ={ $$ = bstruct($2,0); stwart = SEENAME; } ! 177: ; ! 178: ! 179: moe_list: moe ! 180: | moe_list CM moe ! 181: ; ! 182: ! 183: moe: NAME ! 184: ={ moedef( $1 ); } ! 185: | NAME ASSIGN con_e ! 186: ={ strucoff = $3; moedef( $1 ); } ! 187: ; ! 188: ! 189: struct_dcl: str_head LC type_dcl_list optsemi RC ! 190: ={ $$ = dclstruct($1); } ! 191: | STRUCT NAME ! 192: ={ $$ = rstruct($2,$1); } ! 193: ; ! 194: ! 195: str_head: STRUCT ! 196: ={ $$ = bstruct(-1,$1); stwart=0; } ! 197: | STRUCT NAME ! 198: ={ $$ = bstruct($2,$1); stwart=0; } ! 199: ; ! 200: ! 201: type_dcl_list: type_declaration ! 202: | type_dcl_list SM type_declaration ! 203: ; ! 204: ! 205: type_declaration: type declarator_list ! 206: ={ curclass = SNULL; stwart=0; $1->in.op = FREE; } ! 207: | type ! 208: ={ if( curclass != MOU ){ ! 209: curclass = SNULL; ! 210: } ! 211: else { ! 212: sprintf( fakename, "$%dFAKE", fake++ ); ! 213: #ifdef FLEXNAMES ! 214: /* No need to hash this, we won't look it up */ ! 215: defid( tymerge($1, bdty(NAME,NIL,lookup( savestr(fakename), SMOS ))), curclass ); ! 216: #else ! 217: defid( tymerge($1, bdty(NAME,NIL,lookup( fakename, SMOS ))), curclass ); ! 218: #endif ! 219: werror("structure typed union member must be named"); ! 220: } ! 221: stwart = 0; ! 222: $1->in.op = FREE; ! 223: } ! 224: ; ! 225: ! 226: ! 227: declarator_list: declarator ! 228: ={ defid( tymerge($<nodep>0,$1), curclass); stwart = instruct; } ! 229: | declarator_list CM {$<nodep>$=$<nodep>0;} declarator ! 230: ={ defid( tymerge($<nodep>0,$4), curclass); stwart = instruct; } ! 231: ; ! 232: declarator: fdeclarator ! 233: | nfdeclarator ! 234: | nfdeclarator COLON con_e ! 235: %prec CM ! 236: ={ if( !(instruct&INSTRUCT) ) uerror( "field outside of structure" ); ! 237: if( $3<0 || $3 >= FIELD ){ ! 238: uerror( "illegal field size" ); ! 239: $3 = 1; ! 240: } ! 241: defid( tymerge($<nodep>0,$1), FIELD|$3 ); ! 242: $$ = NIL; ! 243: } ! 244: | COLON con_e ! 245: %prec CM ! 246: ={ if( !(instruct&INSTRUCT) ) uerror( "field outside of structure" ); ! 247: (void) falloc( stab, $2, -1, $<nodep>0 ); /* alignment or hole */ ! 248: $$ = NIL; ! 249: } ! 250: | error ! 251: ={ $$ = NIL; } ! 252: ; ! 253: ! 254: /* int (a)(); is not a function --- sorry! */ ! 255: nfdeclarator: MUL nfdeclarator ! 256: ={ umul: ! 257: $$ = bdty( UNARY MUL, $2, 0 ); } ! 258: | nfdeclarator LP RP ! 259: ={ uftn: ! 260: $$ = bdty( UNARY CALL, $1, 0 ); } ! 261: | nfdeclarator LB RB ! 262: ={ uary: ! 263: $$ = bdty( LB, $1, 0 ); } ! 264: | nfdeclarator LB con_e RB ! 265: ={ bary: ! 266: if( (int)$3 <= 0 ) werror( "zero or negative subscript" ); ! 267: $$ = bdty( LB, $1, $3 ); } ! 268: | NAME ! 269: ={ $$ = bdty( NAME, NIL, $1 ); } ! 270: | LP nfdeclarator RP ! 271: ={ $$=$2; } ! 272: ; ! 273: fdeclarator: MUL fdeclarator ! 274: ={ goto umul; } ! 275: | fdeclarator LP RP ! 276: ={ goto uftn; } ! 277: | fdeclarator LB RB ! 278: ={ goto uary; } ! 279: | fdeclarator LB con_e RB ! 280: ={ goto bary; } ! 281: | LP fdeclarator RP ! 282: ={ $$ = $2; } ! 283: | name_lp name_list RP ! 284: ={ ! 285: if( blevel!=0 ) uerror("function declaration in bad context"); ! 286: $$ = bdty( UNARY CALL, bdty(NAME,NIL,$1), 0 ); ! 287: stwart = 0; ! 288: } ! 289: | name_lp RP ! 290: ={ ! 291: $$ = bdty( UNARY CALL, bdty(NAME,NIL,$1), 0 ); ! 292: stwart = 0; ! 293: } ! 294: ; ! 295: ! 296: name_lp: NAME LP ! 297: ={ ! 298: /* turn off typedefs for argument names */ ! 299: stwart = SEENAME; ! 300: if( stab[$1].sclass == SNULL ) ! 301: stab[$1].stype = FTN; ! 302: } ! 303: ; ! 304: ! 305: name_list: NAME ! 306: ={ ftnarg( $1 ); stwart = SEENAME; } ! 307: | name_list CM NAME ! 308: ={ ftnarg( $3 ); stwart = SEENAME; } ! 309: | error ! 310: ; ! 311: /* always preceeded by attributes: thus the $<nodep>0's */ ! 312: init_dcl_list: init_declarator ! 313: %prec CM ! 314: | init_dcl_list CM {$<nodep>$=$<nodep>0;} init_declarator ! 315: ; ! 316: /* always preceeded by attributes */ ! 317: xnfdeclarator: nfdeclarator ! 318: ={ int id; ! 319: ! 320: defid( $1 = tymerge($<nodep>0,$1), curclass); ! 321: id = $1->tn.rval; ! 322: beginit(id); ! 323: if( stab[id].sclass == AUTO || ! 324: stab[id].sclass == REGISTER || ! 325: stab[id].sclass == STATIC ) ! 326: stab[id].suse = -lineno; ! 327: } ! 328: | error ! 329: ; ! 330: /* always preceeded by attributes */ ! 331: init_declarator: nfdeclarator ! 332: ={ nidcl( tymerge($<nodep>0,$1) ); } ! 333: | fdeclarator ! 334: ={ defid( tymerge($<nodep>0,$1), uclass(curclass) ); ! 335: if( paramno > 0 ){ ! 336: uerror( "illegal argument" ); ! 337: paramno = 0; ! 338: } ! 339: } ! 340: | xnfdeclarator optasgn e ! 341: %prec CM ! 342: ={ doinit( $3 ); ! 343: endinit(); } ! 344: | xnfdeclarator optasgn LC init_list optcomma RC ! 345: ={ endinit(); } ! 346: | error ! 347: ={ fixinit(); } ! 348: ; ! 349: ! 350: init_list: initializer ! 351: %prec CM ! 352: | init_list CM initializer ! 353: ; ! 354: initializer: e ! 355: %prec CM ! 356: ={ doinit( $1 ); } ! 357: | ibrace init_list optcomma RC ! 358: ={ irbrace(); } ! 359: ; ! 360: ! 361: optcomma : /* VOID */ ! 362: | CM ! 363: ; ! 364: ! 365: optsemi : /* VOID */ ! 366: | SM ! 367: ; ! 368: ! 369: optasgn : /* uncomment for old-fashioned initializations */ ! 370: /* /* VOID */ ! 371: /* ={ werror( "old-fashioned initialization: use =" ); } ! 372: /* | */ ASSIGN ! 373: ; ! 374: ! 375: ibrace : LC ! 376: ={ ilbrace(); } ! 377: ; ! 378: ! 379: /* STATEMENTS */ ! 380: ! 381: compoundstmt: dcmpstmt ! 382: | cmpstmt ! 383: ; ! 384: ! 385: dcmpstmt: begin r_dcl_stat_list stmt_list RC ! 386: ={ ! 387: #ifndef LINT ! 388: if( nerrors == 0 ) prcstab(blevel); ! 389: #endif ! 390: --blevel; ! 391: if( blevel == 1 ) blevel = 0; ! 392: clearst( blevel ); ! 393: checkst( blevel ); ! 394: autooff = *--psavbc; ! 395: regvar = *--psavbc; ! 396: } ! 397: ; ! 398: ! 399: cmpstmt: begin stmt_list RC ! 400: ={ --blevel; ! 401: if( blevel == 1 ) blevel = 0; ! 402: clearst( blevel ); ! 403: checkst( blevel ); ! 404: autooff = *--psavbc; ! 405: regvar = *--psavbc; ! 406: } ! 407: ; ! 408: ! 409: begin: LC ! 410: ={ if( blevel == 1 ) dclargs(); ! 411: ++blevel; ! 412: if( psavbc > &asavbc[BCSZ-2] ) cerror( "nesting too deep" ); ! 413: *psavbc++ = regvar; ! 414: *psavbc++ = autooff; ! 415: } ! 416: ; ! 417: ! 418: statement: e SM ! 419: ={ ecomp( $1 ); } ! 420: | compoundstmt ! 421: | ifprefix statement ! 422: ={ deflab($1); ! 423: reached = 1; ! 424: } ! 425: | ifelprefix statement ! 426: ={ if( $1 != NOLAB ){ ! 427: deflab( $1 ); ! 428: reached = 1; ! 429: } ! 430: } ! 431: | whprefix statement ! 432: ={ branch( contlab ); ! 433: deflab( brklab ); ! 434: if( (flostat&FBRK) || !(flostat&FLOOP)) reached = 1; ! 435: else reached = 0; ! 436: resetbc(0); ! 437: } ! 438: | doprefix statement WHILE LP e RP SM ! 439: ={ deflab( contlab ); ! 440: if( flostat & FCONT ) reached = 1; ! 441: ecomp( buildtree( CBRANCH, buildtree( NOT, $5, NIL ), bcon( $1 ) ) ); ! 442: deflab( brklab ); ! 443: reached = 1; ! 444: resetbc(0); ! 445: } ! 446: | forprefix .e RP statement ! 447: ={ deflab( contlab ); ! 448: if( flostat&FCONT ) reached = 1; ! 449: if( $2 ) ecomp( $2 ); ! 450: branch( $1 ); ! 451: deflab( brklab ); ! 452: if( (flostat&FBRK) || !(flostat&FLOOP) ) reached = 1; ! 453: else reached = 0; ! 454: resetbc(0); ! 455: } ! 456: | switchpart statement ! 457: ={ if( reached ) branch( brklab ); ! 458: deflab( $1 ); ! 459: swend(); ! 460: deflab(brklab); ! 461: if( (flostat&FBRK) || !(flostat&FDEF) ) reached = 1; ! 462: resetbc(FCONT); ! 463: } ! 464: | BREAK SM ! 465: ={ if( brklab == NOLAB ) uerror( "illegal break"); ! 466: else if(reached) branch( brklab ); ! 467: flostat |= FBRK; ! 468: if( brkflag ) goto rch; ! 469: reached = 0; ! 470: } ! 471: | CONTINUE SM ! 472: ={ if( contlab == NOLAB ) uerror( "illegal continue"); ! 473: else branch( contlab ); ! 474: flostat |= FCONT; ! 475: goto rch; ! 476: } ! 477: | RETURN SM ! 478: ={ retstat |= NRETVAL; ! 479: branch( retlab ); ! 480: rch: ! 481: if( !reached ) werror( "statement not reached"); ! 482: reached = 0; ! 483: } ! 484: | RETURN e SM ! 485: ={ register NODE *temp; ! 486: idname = curftn; ! 487: temp = buildtree( NAME, NIL, NIL ); ! 488: if(temp->in.type == TVOID) ! 489: uerror("void function %s cannot return value", ! 490: stab[idname].sname); ! 491: temp->in.type = DECREF( temp->in.type ); ! 492: temp = buildtree( RETURN, temp, $2 ); ! 493: /* now, we have the type of the RHS correct */ ! 494: temp->in.left->in.op = FREE; ! 495: temp->in.op = FREE; ! 496: ecomp( buildtree( FORCE, temp->in.right, NIL ) ); ! 497: retstat |= RETVAL; ! 498: branch( retlab ); ! 499: reached = 0; ! 500: } ! 501: | GOTO NAME SM ! 502: ={ register NODE *q; ! 503: q = block( FREE, NIL, NIL, INT|ARY, 0, INT ); ! 504: q->tn.rval = idname = $2; ! 505: defid( q, ULABEL ); ! 506: stab[idname].suse = -lineno; ! 507: branch( stab[idname].offset ); ! 508: goto rch; ! 509: } ! 510: | SM ! 511: | error SM ! 512: | error RC ! 513: | label statement ! 514: ; ! 515: label: NAME COLON ! 516: ={ register NODE *q; ! 517: q = block( FREE, NIL, NIL, INT|ARY, 0, LABEL ); ! 518: q->tn.rval = $1; ! 519: defid( q, LABEL ); ! 520: reached = 1; ! 521: } ! 522: | CASE e COLON ! 523: ={ addcase($2); ! 524: reached = 1; ! 525: } ! 526: | DEFAULT COLON ! 527: ={ reached = 1; ! 528: adddef(); ! 529: flostat |= FDEF; ! 530: } ! 531: ; ! 532: doprefix: DO ! 533: ={ savebc(); ! 534: if( !reached ) werror( "loop not entered at top"); ! 535: brklab = getlab(); ! 536: contlab = getlab(); ! 537: deflab( $$ = getlab() ); ! 538: reached = 1; ! 539: } ! 540: ; ! 541: ifprefix: IF LP e RP ! 542: ={ ecomp( buildtree( CBRANCH, $3, bcon( $$=getlab()) ) ) ; ! 543: reached = 1; ! 544: } ! 545: ; ! 546: ifelprefix: ifprefix statement ELSE ! 547: ={ if( reached ) branch( $$ = getlab() ); ! 548: else $$ = NOLAB; ! 549: deflab( $1 ); ! 550: reached = 1; ! 551: } ! 552: ; ! 553: ! 554: whprefix: WHILE LP e RP ! 555: ={ savebc(); ! 556: if( !reached ) werror( "loop not entered at top"); ! 557: if( $3->in.op == ICON && $3->tn.lval != 0 ) flostat = FLOOP; ! 558: deflab( contlab = getlab() ); ! 559: reached = 1; ! 560: brklab = getlab(); ! 561: if( flostat == FLOOP ) tfree( $3 ); ! 562: else ecomp( buildtree( CBRANCH, $3, bcon( brklab) ) ); ! 563: } ! 564: ; ! 565: forprefix: FOR LP .e SM .e SM ! 566: ={ if( $3 ) ecomp( $3 ); ! 567: else if( !reached ) werror( "loop not entered at top"); ! 568: savebc(); ! 569: contlab = getlab(); ! 570: brklab = getlab(); ! 571: deflab( $$ = getlab() ); ! 572: reached = 1; ! 573: if( $5 ) ecomp( buildtree( CBRANCH, $5, bcon( brklab) ) ); ! 574: else flostat |= FLOOP; ! 575: } ! 576: ; ! 577: switchpart: SWITCH LP e RP ! 578: ={ register NODE *q; ! 579: ! 580: savebc(); ! 581: brklab = getlab(); ! 582: q = $3; ! 583: switch( q->in.type ) { ! 584: case CHAR: case UCHAR: ! 585: case SHORT: case USHORT: ! 586: case INT: case UNSIGNED: ! 587: case MOE: case ENUMTY: ! 588: break; ! 589: default: ! 590: werror("switch expression not type int"); ! 591: q = makety( q, INT, q->fn.cdim, q->fn.csiz ); ! 592: } ! 593: #ifdef LINT ! 594: if( hflag && q->in.op == ICON ) ! 595: werror( "constant switch expression" ); ! 596: #endif ! 597: ecomp( buildtree( FORCE, q, NIL ) ); ! 598: branch( $$ = getlab() ); ! 599: swstart(); ! 600: reached = 0; ! 601: } ! 602: ; ! 603: /* EXPRESSIONS */ ! 604: con_e: { $<intval>$=instruct; stwart=instruct=0; } e ! 605: %prec CM ! 606: ={ $$ = icons( $2 ); instruct=$<intval>1; } ! 607: ; ! 608: .e: e ! 609: | ! 610: ={ $$=0; } ! 611: ; ! 612: elist: e ! 613: %prec CM ! 614: | elist CM e ! 615: ={ goto bop; } ! 616: ; ! 617: ! 618: e: e RELOP e ! 619: ={ ! 620: preconf: ! 621: if( yychar==RELOP||yychar==EQUOP||yychar==AND||yychar==OR||yychar==ER ){ ! 622: precplaint: ! 623: if( hflag ) werror( "precedence confusion possible: parenthesize!" ); ! 624: } ! 625: bop: ! 626: $$ = buildtree( $2, $1, $3 ); ! 627: } ! 628: | e CM e ! 629: ={ $2 = COMOP; ! 630: goto bop; ! 631: } ! 632: | e DIVOP e ! 633: ={ goto bop; } ! 634: | e PLUS e ! 635: ={ if(yychar==SHIFTOP) goto precplaint; else goto bop; } ! 636: | e MINUS e ! 637: ={ if(yychar==SHIFTOP ) goto precplaint; else goto bop; } ! 638: | e SHIFTOP e ! 639: ={ if(yychar==PLUS||yychar==MINUS) goto precplaint; else goto bop; } ! 640: | e MUL e ! 641: ={ goto bop; } ! 642: | e EQUOP e ! 643: ={ goto preconf; } ! 644: | e AND e ! 645: ={ if( yychar==RELOP||yychar==EQUOP ) goto preconf; else goto bop; } ! 646: | e OR e ! 647: ={ if(yychar==RELOP||yychar==EQUOP) goto preconf; else goto bop; } ! 648: | e ER e ! 649: ={ if(yychar==RELOP||yychar==EQUOP) goto preconf; else goto bop; } ! 650: | e ANDAND e ! 651: ={ goto bop; } ! 652: | e OROR e ! 653: ={ goto bop; } ! 654: | e MUL ASSIGN e ! 655: ={ abop: ! 656: $$ = buildtree( ASG $2, $1, $4 ); ! 657: } ! 658: | e DIVOP ASSIGN e ! 659: ={ goto abop; } ! 660: | e PLUS ASSIGN e ! 661: ={ goto abop; } ! 662: | e MINUS ASSIGN e ! 663: ={ goto abop; } ! 664: | e SHIFTOP ASSIGN e ! 665: ={ goto abop; } ! 666: | e AND ASSIGN e ! 667: ={ goto abop; } ! 668: | e OR ASSIGN e ! 669: ={ goto abop; } ! 670: | e ER ASSIGN e ! 671: ={ goto abop; } ! 672: | e QUEST e COLON e ! 673: ={ $$=buildtree(QUEST, $1, buildtree( COLON, $3, $5 ) ); ! 674: } ! 675: | e ASOP e ! 676: ={ werror( "old-fashioned assignment operator" ); goto bop; } ! 677: | e ASSIGN e ! 678: ={ goto bop; } ! 679: | term ! 680: ; ! 681: term: term INCOP ! 682: ={ $$ = buildtree( $2, $1, bcon(1) ); } ! 683: | MUL term ! 684: ={ ubop: ! 685: $$ = buildtree( UNARY $1, $2, NIL ); ! 686: } ! 687: | AND term ! 688: ={ if( ISFTN($2->in.type) || ISARY($2->in.type) ){ ! 689: werror( "& before array or function: ignored" ); ! 690: $$ = $2; ! 691: } ! 692: else if( $2->in.op == UNARY MUL && ! 693: ($2->in.left->in.op == STASG || ! 694: $2->in.left->in.op == STCALL || ! 695: $2->in.left->in.op == UNARY STCALL) ){ ! 696: /* legal trees but not available to users */ ! 697: uerror( "unacceptable operand of &" ); ! 698: goto ubop; ! 699: } ! 700: else goto ubop; ! 701: } ! 702: | MINUS term ! 703: ={ goto ubop; } ! 704: | UNOP term ! 705: ={ ! 706: $$ = buildtree( $1, $2, NIL ); ! 707: } ! 708: | INCOP term ! 709: ={ $$ = buildtree( $1==INCR ? ASG PLUS : ASG MINUS, ! 710: $2, ! 711: bcon(1) ); ! 712: } ! 713: | pushsizeof term %prec SIZEOF ! 714: ={ $$ = doszof( $2 ); --nsizeof; } ! 715: | LP cast_type RP term %prec INCOP ! 716: ={ $$ = buildtree( CAST, $2, $4 ); ! 717: $$->in.left->in.op = FREE; ! 718: $$->in.op = FREE; ! 719: $$ = $$->in.right; ! 720: } ! 721: | pushsizeof LP cast_type RP %prec SIZEOF ! 722: ={ $$ = doszof( $3 ); --nsizeof; } ! 723: | term LB e RB ! 724: ={ $$ = buildtree( UNARY MUL, buildtree( PLUS, $1, $3 ), NIL ); } ! 725: | funct_idn RP ! 726: ={ $$=buildtree(UNARY CALL,$1,NIL); } ! 727: | funct_idn elist RP ! 728: ={ $$=buildtree(CALL,$1,$2); } ! 729: | term STROP NAME ! 730: ={ if( $2 == DOT ){ ! 731: if( notlval( $1 ) && ! 732: !($1->in.op == UNARY MUL && ! 733: ($1->in.left->in.op == STASG || ! 734: $1->in.left->in.op == STCALL || ! 735: $1->in.left->in.op == UNARY STCALL)) ) ! 736: uerror("structure reference must be addressable"); ! 737: $1 = buildtree( UNARY AND, $1, NIL ); ! 738: } ! 739: idname = $3; ! 740: $$ = buildtree( STREF, $1, buildtree( NAME, NIL, NIL ) ); ! 741: } ! 742: | NAME ! 743: ={ idname = $1; ! 744: /* recognize identifiers in initializations */ ! 745: if( blevel==0 && stab[idname].stype == UNDEF ) { ! 746: register NODE *q; ! 747: #ifndef FLEXNAMES ! 748: werror( "undeclared initializer name %.8s", stab[idname].sname ); ! 749: #else ! 750: werror( "undeclared initializer name %s", stab[idname].sname ); ! 751: #endif ! 752: q = block( FREE, NIL, NIL, INT, 0, INT ); ! 753: q->tn.rval = idname; ! 754: defid( q, EXTERN ); ! 755: } ! 756: $$=buildtree(NAME,NIL,NIL); ! 757: if( nsizeof == 0 ) ! 758: stab[$1].suse = -lineno; ! 759: } ! 760: | ICON ! 761: ={ $$=bcon(0); ! 762: $$->tn.lval = lastcon; ! 763: $$->tn.rval = NONAME; ! 764: if( $1 ) $$->fn.csiz = $$->in.type = ctype(LONG); ! 765: } ! 766: | FCON ! 767: ={ $$=buildtree(FCON,NIL,NIL); ! 768: $$->fpn.fval = fcon; ! 769: } ! 770: | DCON ! 771: ={ $$=buildtree(DCON,NIL,NIL); ! 772: $$->dpn.dval = dcon; ! 773: } ! 774: | STRING ! 775: ={ $$ = getstr(); /* get string contents */ } ! 776: | LP e RP ! 777: ={ $$=$2; } ! 778: ; ! 779: ! 780: cast_type: type null_decl ! 781: ={ ! 782: $$ = tymerge( $1, $2 ); ! 783: $$->in.op = NAME; ! 784: $1->in.op = FREE; ! 785: } ! 786: ; ! 787: ! 788: pushsizeof: SIZEOF ! 789: ={ ++nsizeof; } ! 790: ; ! 791: ! 792: null_decl: /* empty */ ! 793: ={ $$ = bdty( NAME, NIL, -1 ); } ! 794: | LP RP ! 795: ={ $$ = bdty( UNARY CALL, bdty(NAME,NIL,-1),0); } ! 796: | LP null_decl RP LP RP ! 797: ={ $$ = bdty( UNARY CALL, $2, 0 ); } ! 798: | MUL null_decl ! 799: ={ goto umul; } ! 800: | null_decl LB RB ! 801: ={ goto uary; } ! 802: | null_decl LB con_e RB ! 803: ={ goto bary; } ! 804: | LP null_decl RP ! 805: ={ $$ = $2; } ! 806: ; ! 807: ! 808: funct_idn: NAME LP ! 809: ={ if( stab[$1].stype == UNDEF ){ ! 810: register NODE *q; ! 811: q = block( FREE, NIL, NIL, FTN|INT, 0, INT ); ! 812: q->tn.rval = $1; ! 813: defid( q, EXTERN ); ! 814: } ! 815: idname = $1; ! 816: $$=buildtree(NAME,NIL,NIL); ! 817: stab[idname].suse = -lineno; ! 818: } ! 819: | term LP ! 820: ; ! 821: %% ! 822: ! 823: NODE * ! 824: mkty( t, d, s ) unsigned t; { ! 825: return( block( TYPE, NIL, NIL, t, d, s ) ); ! 826: } ! 827: ! 828: NODE * ! 829: bdty( op, p, v ) NODE *p; { ! 830: register NODE *q; ! 831: ! 832: q = block( op, p, NIL, INT, 0, INT ); ! 833: ! 834: switch( op ){ ! 835: ! 836: case UNARY MUL: ! 837: case UNARY CALL: ! 838: break; ! 839: ! 840: case LB: ! 841: q->in.right = bcon(v); ! 842: break; ! 843: ! 844: case NAME: ! 845: q->tn.rval = v; ! 846: break; ! 847: ! 848: default: ! 849: cerror( "bad bdty" ); ! 850: } ! 851: ! 852: return( q ); ! 853: } ! 854: ! 855: dstash( n ){ /* put n into the dimension table */ ! 856: if( curdim >= DIMTABSZ-1 ){ ! 857: cerror( "dimension table overflow"); ! 858: } ! 859: dimtab[ curdim++ ] = n; ! 860: } ! 861: ! 862: savebc() { ! 863: if( psavbc > & asavbc[BCSZ-4 ] ){ ! 864: cerror( "whiles, fors, etc. too deeply nested"); ! 865: } ! 866: *psavbc++ = brklab; ! 867: *psavbc++ = contlab; ! 868: *psavbc++ = flostat; ! 869: *psavbc++ = swx; ! 870: flostat = 0; ! 871: } ! 872: ! 873: resetbc(mask){ ! 874: ! 875: swx = *--psavbc; ! 876: flostat = *--psavbc | (flostat&mask); ! 877: contlab = *--psavbc; ! 878: brklab = *--psavbc; ! 879: ! 880: } ! 881: ! 882: addcase(p) NODE *p; { /* add case to switch */ ! 883: ! 884: p = optim( p ); /* change enum to ints */ ! 885: if( p->in.op != ICON || p->tn.rval != NONAME ){ ! 886: uerror( "non-constant case expression"); ! 887: return; ! 888: } ! 889: if( swp == swtab ){ ! 890: uerror( "case not in switch"); ! 891: return; ! 892: } ! 893: if( swp >= &swtab[SWITSZ] ){ ! 894: cerror( "switch table overflow"); ! 895: } ! 896: swp->sval = p->tn.lval; ! 897: deflab( swp->slab = getlab() ); ! 898: ++swp; ! 899: tfree(p); ! 900: } ! 901: ! 902: adddef(){ /* add default case to switch */ ! 903: if( swtab[swx].slab >= 0 ){ ! 904: uerror( "duplicate default in switch"); ! 905: return; ! 906: } ! 907: if( swp == swtab ){ ! 908: uerror( "default not inside switch"); ! 909: return; ! 910: } ! 911: deflab( swtab[swx].slab = getlab() ); ! 912: } ! 913: ! 914: swstart(){ ! 915: /* begin a switch block */ ! 916: if( swp >= &swtab[SWITSZ] ){ ! 917: cerror( "switch table overflow"); ! 918: } ! 919: swx = swp - swtab; ! 920: swp->slab = -1; ! 921: ++swp; ! 922: } ! 923: ! 924: swend(){ /* end a switch block */ ! 925: ! 926: register struct sw *swbeg, *p, *q, *r, *r1; ! 927: CONSZ temp; ! 928: int tempi; ! 929: ! 930: swbeg = &swtab[swx+1]; ! 931: ! 932: /* sort */ ! 933: ! 934: r1 = swbeg; ! 935: r = swp-1; ! 936: ! 937: while( swbeg < r ){ ! 938: /* bubble largest to end */ ! 939: for( q=swbeg; q<r; ++q ){ ! 940: if( q->sval > (q+1)->sval ){ ! 941: /* swap */ ! 942: r1 = q+1; ! 943: temp = q->sval; ! 944: q->sval = r1->sval; ! 945: r1->sval = temp; ! 946: tempi = q->slab; ! 947: q->slab = r1->slab; ! 948: r1->slab = tempi; ! 949: } ! 950: } ! 951: r = r1; ! 952: r1 = swbeg; ! 953: } ! 954: ! 955: /* it is now sorted */ ! 956: ! 957: for( p = swbeg+1; p<swp; ++p ){ ! 958: if( p->sval == (p-1)->sval ){ ! 959: uerror( "duplicate case in switch, %d", p->sval ); ! 960: return; ! 961: } ! 962: } ! 963: ! 964: genswitch( swbeg-1, swp-swbeg ); ! 965: swp = swbeg-1; ! 966: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.