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