2.9BSD - /usr/src/cmd/mip/cgram.y

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

Defined functions