2.9BSD - /usr/src/cmd/yacc/y2.c

   1: # include "dextern"
   2: # define IDENTIFIER 257
   3: # define MARK 258
   4: # define TERM 259
   5: # define LEFT 260
   6: # define RIGHT 261
   7: # define BINARY 262
   8: # define PREC 263
   9: # define LCURLY 264
  10: # define C_IDENTIFIER 265  /* name followed by colon */
  11: # define NUMBER 266
  12: # define START 267
  13: # define TYPEDEF 268
  14: # define TYPENAME 269
  15: # define UNION 270
  16: # define ENDFILE 0
  17: 
  18:     /* communication variables between various I/O routines */
  19: 
  20: char *infile;   /* input file name */
  21: int numbval;    /* value of an input number */
  22: char tokname[NAMESIZE]; /* input token name */
  23: 
  24:     /* storage of names */
  25: 
  26: char cnames[CNAMSZ];    /* place where token and nonterminal names are stored */
  27: int cnamsz = CNAMSZ;    /* size of cnames */
  28: char * cnamp = cnames;  /* place where next name is to be put in */
  29: int ndefout = 3;  /* number of defined symbols output */
  30: 
  31:     /* storage of types */
  32: int ntypes; /* number of types defined */
  33: char * typeset[NTYPES]; /* pointers to type tags */
  34: 
  35:     /* symbol tables for tokens and nonterminals */
  36: 
  37: int ntokens = 0;
  38: struct toksymb tokset[NTERMS];
  39: int toklev[NTERMS];
  40: int nnonter = -1;
  41: struct ntsymb nontrst[NNONTERM];
  42: int start;  /* start symbol */
  43: 
  44:     /* assigned token type values */
  45: int extval = 0;
  46: 
  47:     /* input and output file descriptors */
  48: 
  49: FILE * finput;      /* yacc input file */
  50: FILE * faction;     /* file for saving actions */
  51: FILE * fdefine;     /* file for # defines */
  52: FILE * ftable;      /* y.tab.c file */
  53: FILE * ftemp;       /* tempfile to pass 2 */
  54: FILE * foutput;     /* y.output file */
  55: 
  56:     /* storage for grammar rules */
  57: 
  58: int mem0[MEMSIZE] ; /* production storage */
  59: int *mem = mem0;
  60: int nprod= 1;   /* number of productions */
  61: int *prdptr[NPROD]; /* pointers to descriptions of productions */
  62: int levprd[NPROD] ; /* precedence levels for the productions */
  63: 
  64: 
  65: setup(argc,argv) int argc; char *argv[];
  66: {   int i,j,lev,t, ty;
  67:     int c;
  68:     int *p;
  69:     char actname[8];
  70: 
  71:     foutput = NULL;
  72:     fdefine = NULL;
  73:     i = 1;
  74:     while( argc >= 2  && argv[1][0] == '-' ) {
  75:         while( *++(argv[1]) ){
  76:             switch( *argv[1] ){
  77:             case 'v':
  78:             case 'V':
  79:                 foutput = fopen(FILEU, "w" );
  80:                 if( foutput == NULL ) error( "cannot open y.output" );
  81:                 continue;
  82:             case 'D':
  83:             case 'd':
  84:                 fdefine = fopen( FILED, "w" );
  85:                 continue;
  86:             case 'o':
  87:             case 'O':
  88:                 fprintf( stderr, "`o' flag now default in yacc\n" );
  89:                 continue;
  90: 
  91:             case 'r':
  92:             case 'R':
  93:                 error( "Ratfor Yacc is dead: sorry...\n" );
  94: 
  95:             default:
  96:                 error( "illegal option: %c", *argv[1]);
  97:                 }
  98:             }
  99:         argv++;
 100:         argc--;
 101:         }
 102: 
 103:     ftable = fopen( OFILE, "w" );
 104:     if( ftable == NULL ) error( "cannot open table file" );
 105: 
 106:     ftemp = fopen( TEMPNAME, "w" );
 107:     faction = fopen( ACTNAME, "w" );
 108:     if( ftemp==NULL || faction==NULL ) error( "cannot open temp file" );
 109: 
 110:     if( argc < 2 || ((finput=fopen( infile=argv[1], "r" )) == NULL ) ){
 111:         error( "cannot open input file" );
 112:         }
 113: 
 114:     cnamp = cnames;
 115:     defin(0,"$end");
 116:     extval = 0400;
 117:     defin(0,"error");
 118:     defin(1,"$accept");
 119:     mem=mem0;
 120:     lev = 0;
 121:     ty = 0;
 122:     i=0;
 123: 
 124:     /* sorry -- no yacc parser here.....
 125: 		we must bootstrap somehow... */
 126: 
 127:     for( t=gettok();  t!=MARK && t!= ENDFILE; ){
 128:         switch( t ){
 129: 
 130:         case ';':
 131:             t = gettok();
 132:             break;
 133: 
 134:         case START:
 135:             if( (t=gettok()) != IDENTIFIER ){
 136:                 error( "bad %%start construction" );
 137:                 }
 138:             start = chfind(1,tokname);
 139:             t = gettok();
 140:             continue;
 141: 
 142:         case TYPEDEF:
 143:             if( (t=gettok()) != TYPENAME ) error( "bad syntax in %%type" );
 144:             ty = numbval;
 145:             for(;;){
 146:                 t = gettok();
 147:                 switch( t ){
 148: 
 149:                 case IDENTIFIER:
 150:                     if( (t=chfind( 1, tokname ) ) < NTBASE ) {
 151:                         j = TYPE( toklev[t] );
 152:                         if( j!= 0 && j != ty ){
 153:                             error( "type redeclaration of token %s",
 154:                                 tokset[t].name );
 155:                             }
 156:                         else SETTYPE( toklev[t],ty);
 157:                         }
 158:                     else {
 159:                         j = nontrst[t-NTBASE].tvalue;
 160:                         if( j != 0 && j != ty ){
 161:                             error( "type redeclaration of nonterminal %s",
 162:                                 nontrst[t-NTBASE].name );
 163:                             }
 164:                         else nontrst[t-NTBASE].tvalue = ty;
 165:                         }
 166:                 case ',':
 167:                     continue;
 168: 
 169:                 case ';':
 170:                     t = gettok();
 171:                     break;
 172:                 default:
 173:                     break;
 174:                     }
 175:                 break;
 176:                 }
 177:             continue;
 178: 
 179:         case UNION:
 180:             /* copy the union declaration to the output */
 181:             cpyunion();
 182:             t = gettok();
 183:             continue;
 184: 
 185:         case LEFT:
 186:         case BINARY:
 187:         case RIGHT:
 188:             ++i;
 189:         case TERM:
 190:             lev = t-TERM;  /* nonzero means new prec. and assoc. */
 191:             ty = 0;
 192: 
 193:             /* get identifiers so defined */
 194: 
 195:             t = gettok();
 196:             if( t == TYPENAME ){ /* there is a type defined */
 197:                 ty = numbval;
 198:                 t = gettok();
 199:                 }
 200: 
 201:             for(;;) {
 202:                 switch( t ){
 203: 
 204:                 case ',':
 205:                     t = gettok();
 206:                     continue;
 207: 
 208:                 case ';':
 209:                     break;
 210: 
 211:                 case IDENTIFIER:
 212:                     j = chfind(0,tokname);
 213:                     if( lev ){
 214:                         if( ASSOC(toklev[j]) ) error( "redeclaration of precedence of %s", tokname );
 215:                         SETASC(toklev[j],lev);
 216:                         SETPLEV(toklev[j],i);
 217:                         }
 218:                     if( ty ){
 219:                         if( TYPE(toklev[j]) ) error( "redeclaration of type of %s", tokname );
 220:                         SETTYPE(toklev[j],ty);
 221:                         }
 222:                     if( (t=gettok()) == NUMBER ){
 223:                         tokset[j].value = numbval;
 224:                         if( j < ndefout && j>2 ){
 225:                             error( "please define type number of %s earlier",
 226:                                 tokset[j].name );
 227:                             }
 228:                         t=gettok();
 229:                         }
 230:                     continue;
 231: 
 232:                     }
 233: 
 234:                 break;
 235:                 }
 236: 
 237:             continue;
 238: 
 239:         case LCURLY:
 240:             defout();
 241:             cpycode();
 242:             t = gettok();
 243:             continue;
 244: 
 245:         default:
 246:             error( "syntax error" );
 247: 
 248:             }
 249: 
 250:         }
 251: 
 252:     if( t == ENDFILE ){
 253:         error( "unexpected EOF before %%" );
 254:         }
 255: 
 256:     /* t is MARK */
 257: 
 258:     defout();
 259: 
 260:         fprintf( ftable,  "#define yyclearin yychar = -1\n" );
 261:         fprintf( ftable,  "#define yyerrok yyerrflag = 0\n" );
 262:         fprintf( ftable,  "extern int yychar;\nextern short yyerrflag;\n" );
 263:         fprintf( ftable,  "#ifndef YYMAXDEPTH\n#define YYMAXDEPTH 150\n#endif\n" );
 264:         if( !ntypes ) fprintf( ftable,  "#ifndef YYSTYPE\n#define YYSTYPE int\n#endif\n" );
 265:         fprintf( ftable,  "YYSTYPE yylval, yyval;\n" );
 266: 
 267:     prdptr[0]=mem;
 268:     /* added production */
 269:     *mem++ = NTBASE;
 270:     *mem++ = start;  /* if start is 0, we will overwrite with the lhs of the first rule */
 271:     *mem++ = 1;
 272:     *mem++ = 0;
 273:     prdptr[1]=mem;
 274: 
 275:     while( (t=gettok()) == LCURLY ) cpycode();
 276: 
 277:     if( t != C_IDENTIFIER ) error( "bad syntax on first rule" );
 278: 
 279:     if( !start ) prdptr[0][1] = chfind(1,tokname);
 280: 
 281:     /* read rules */
 282: 
 283:     while( t!=MARK && t!=ENDFILE ){
 284: 
 285:         /* process a rule */
 286: 
 287:         if( t == '|' ){
 288:             *mem++ = *prdptr[nprod-1];
 289:             }
 290:         else if( t == C_IDENTIFIER ){
 291:             *mem = chfind(1,tokname);
 292:             if( *mem < NTBASE ) error( "token illegal on LHS of grammar rule" );
 293:             ++mem;
 294:             }
 295:         else error( "illegal rule: missing semicolon or | ?" );
 296: 
 297:         /* read rule body */
 298: 
 299: 
 300:         t = gettok();
 301:     more_rule:
 302:         while( t == IDENTIFIER ) {
 303:             *mem = chfind(1,tokname);
 304:             if( *mem<NTBASE ) levprd[nprod] = toklev[*mem];
 305:             ++mem;
 306:             t = gettok();
 307:             }
 308: 
 309: 
 310:         if( t == PREC ){
 311:             if( gettok()!=IDENTIFIER) error( "illegal %%prec syntax" );
 312:             j = chfind(2,tokname);
 313:             if( j>=NTBASE)error("nonterminal %s illegal after %%prec", nontrst[j-NTBASE].name);
 314:             levprd[nprod]=toklev[j];
 315:             t = gettok();
 316:             }
 317: 
 318:         if( t == '=' ){
 319:             levprd[nprod] |= ACTFLAG;
 320:             fprintf( faction, "\ncase %d:", nprod );
 321:             cpyact( mem-prdptr[nprod]-1 );
 322:             fprintf( faction, " break;" );
 323:             if( (t=gettok()) == IDENTIFIER ){
 324:                 /* action within rule... */
 325: 
 326:                 sprintf( actname, "$$%d", nprod );
 327:                 j = chfind(1,actname);  /* make it a nonterminal */
 328: 
 329:                 /* the current rule will become rule number nprod+1 */
 330:                 /* move the contents down, and make room for the null */
 331: 
 332:                 for( p=mem; p>=prdptr[nprod]; --p ) p[2] = *p;
 333:                 mem += 2;
 334: 
 335:                 /* enter null production for action */
 336: 
 337:                 p = prdptr[nprod];
 338: 
 339:                 *p++ = j;
 340:                 *p++ = -nprod;
 341: 
 342:                 /* update the production information */
 343: 
 344:                 levprd[nprod+1] = levprd[nprod] & ~ACTFLAG;
 345:                 levprd[nprod] = ACTFLAG;
 346: 
 347:                 if( ++nprod >= NPROD ) error( "more than %d rules", NPROD );
 348:                 prdptr[nprod] = p;
 349: 
 350:                 /* make the action appear in the original rule */
 351:                 *mem++ = j;
 352: 
 353:                 /* get some more of the rule */
 354: 
 355:                 goto more_rule;
 356:                 }
 357: 
 358:             }
 359: 
 360:         while( t == ';' ) t = gettok();
 361: 
 362:         *mem++ = -nprod;
 363: 
 364:         /* check that default action is reasonable */
 365: 
 366:         if( ntypes && !(levprd[nprod]&ACTFLAG) && nontrst[*prdptr[nprod]-NTBASE].tvalue ){
 367:             /* no explicit action, LHS has value */
 368:             register tempty;
 369:             tempty = prdptr[nprod][1];
 370:             if( tempty < 0 ) error( "must return a value, since LHS has a type" );
 371:             else if( tempty >= NTBASE ) tempty = nontrst[tempty-NTBASE].tvalue;
 372:             else tempty = TYPE( toklev[tempty] );
 373:             if( tempty != nontrst[*prdptr[nprod]-NTBASE].tvalue ){
 374:                 error( "default action causes potential type clash" );
 375:                 }
 376:             }
 377: 
 378:         if( ++nprod >= NPROD ) error( "more than %d rules", NPROD );
 379:         prdptr[nprod] = mem;
 380:         levprd[nprod]=0;
 381: 
 382:         }
 383: 
 384:     /* end of all rules */
 385: 
 386:     finact();
 387:     if( t == MARK ){
 388:         fprintf( ftable, "\n# line %d \"%s\"\n", lineno, infile );
 389:         while( (c=getc(finput)) != EOF ) putc( c, ftable );
 390:         }
 391:     fclose( finput );
 392:     }
 393: 
 394: finact(){
 395:     /* finish action routine */
 396: 
 397:     fclose(faction);
 398: 
 399:     fprintf( ftable, "# define YYERRCODE %d\n", tokset[2].value );
 400: 
 401:     }
 402: 
 403: defin( t, s ) register char  *s; {
 404: /*	define s to be a terminal if t=0
 405: 	or a nonterminal if t=1		*/
 406: 
 407:     register val;
 408: 
 409:     if (t) {
 410:         if( ++nnonter >= NNONTERM ) error("too many nonterminals, limit %d",NNONTERM);
 411:         nontrst[nnonter].name = cstash(s);
 412:         return( NTBASE + nnonter );
 413:         }
 414:     /* must be a token */
 415:     if( ++ntokens >= NTERMS ) error("too many terminals, limit %d",NTERMS );
 416:     tokset[ntokens].name = cstash(s);
 417: 
 418:     /* establish value for token */
 419: 
 420:     if( s[0]==' ' && s[2]=='\0' ) /* single character literal */
 421:         val = s[1];
 422:     else if ( s[0]==' ' && s[1]=='\\' ) { /* escape sequence */
 423:         if( s[3] == '\0' ){ /* single character escape sequence */
 424:             switch ( s[2] ){
 425:                      /* character which is escaped */
 426:             case 'n': val = '\n'; break;
 427:             case 'r': val = '\r'; break;
 428:             case 'b': val = '\b'; break;
 429:             case 't': val = '\t'; break;
 430:             case 'f': val = '\f'; break;
 431:             case '\'': val = '\''; break;
 432:             case '"': val = '"'; break;
 433:             case '\\': val = '\\'; break;
 434:             default: error( "invalid escape" );
 435:                 }
 436:             }
 437:         else if( s[2] <= '7' && s[2]>='0' ){ /* \nnn sequence */
 438:             if( s[3]<'0' || s[3] > '7' || s[4]<'0' ||
 439:                 s[4]>'7' || s[5] != '\0' ) error("illegal \\nnn construction" );
 440:             val = 64*s[2] + 8*s[3] + s[4] - 73*'0';
 441:             if( val == 0 ) error( "'\\000' is illegal" );
 442:             }
 443:         }
 444:     else {
 445:         val = extval++;
 446:         }
 447:     tokset[ntokens].value = val;
 448:     toklev[ntokens] = 0;
 449:     return( ntokens );
 450:     }
 451: 
 452: defout(){ /* write out the defines (at the end of the declaration section) */
 453: 
 454:     register int i, c;
 455:     register char *cp;
 456: 
 457:     for( i=ndefout; i<=ntokens; ++i ){
 458: 
 459:         cp = tokset[i].name;
 460:         if( *cp == ' ' ) ++cp;  /* literals */
 461: 
 462:         for( ; (c= *cp)!='\0'; ++cp ){
 463: 
 464:             if( islower(c) || isupper(c) || isdigit(c) || c=='_' );  /* VOID */
 465:             else goto nodef;
 466:             }
 467: 
 468:         fprintf( ftable, "# define %s %d\n", tokset[i].name, tokset[i].value );
 469:         if( fdefine != NULL ) fprintf( fdefine, "# define %s %d\n", tokset[i].name, tokset[i].value );
 470: 
 471:     nodef:  ;
 472:         }
 473: 
 474:     ndefout = ntokens+1;
 475: 
 476:     }
 477: 
 478: char *
 479: cstash( s ) register char *s; {
 480:     char *temp;
 481: 
 482:     temp = cnamp;
 483:     do {
 484:         if( cnamp >= &cnames[cnamsz] ) error("too many characters in id's and literals" );
 485:         else *cnamp++ = *s;
 486:         }  while ( *s++ );
 487:     return( temp );
 488:     }
 489: 
 490: gettok() {
 491:     register i, base;
 492:     static int peekline; /* number of '\n' seen in lookahead */
 493:     register c, match, reserve;
 494: 
 495: begin:
 496:     reserve = 0;
 497:     lineno += peekline;
 498:     peekline = 0;
 499:     c = getc(finput);
 500:     while( c==' ' || c=='\n' || c=='\t' || c=='\f' ){
 501:         if( c == '\n' ) ++lineno;
 502:         c=getc(finput);
 503:         }
 504:     if( c == '/' ){ /* skip comment */
 505:         lineno += skipcom();
 506:         goto begin;
 507:         }
 508: 
 509:     switch(c){
 510: 
 511:     case EOF:
 512:         return(ENDFILE);
 513:     case '{':
 514:         ungetc( c, finput );
 515:         return( '=' );  /* action ... */
 516:     case '<':  /* get, and look up, a type name (union member name) */
 517:         i = 0;
 518:         while( (c=getc(finput)) != '>' && c>=0 && c!= '\n' ){
 519:             tokname[i] = c;
 520:             if( ++i >= NAMESIZE ) --i;
 521:             }
 522:         if( c != '>' ) error( "unterminated < ... > clause" );
 523:         tokname[i] = '\0';
 524:         for( i=1; i<=ntypes; ++i ){
 525:             if( !strcmp( typeset[i], tokname ) ){
 526:                 numbval = i;
 527:                 return( TYPENAME );
 528:                 }
 529:             }
 530:         typeset[numbval = ++ntypes] = cstash( tokname );
 531:         return( TYPENAME );
 532: 
 533:     case '"':
 534:     case '\'':
 535:         match = c;
 536:         tokname[0] = ' ';
 537:         i = 1;
 538:         for(;;){
 539:             c = getc(finput);
 540:             if( c == '\n' || c == EOF )
 541:                 error("illegal or missing ' or \"" );
 542:             if( c == '\\' ){
 543:                 c = getc(finput);
 544:                 tokname[i] = '\\';
 545:                 if( ++i >= NAMESIZE ) --i;
 546:                 }
 547:             else if( c == match ) break;
 548:             tokname[i] = c;
 549:             if( ++i >= NAMESIZE ) --i;
 550:             }
 551:         break;
 552: 
 553:     case '%':
 554:     case '\\':
 555: 
 556:         switch(c=getc(finput)) {
 557: 
 558:         case '0':   return(TERM);
 559:         case '<':   return(LEFT);
 560:         case '2':   return(BINARY);
 561:         case '>':   return(RIGHT);
 562:         case '%':
 563:         case '\\':  return(MARK);
 564:         case '=':   return(PREC);
 565:         case '{':   return(LCURLY);
 566:         default:    reserve = 1;
 567:             }
 568: 
 569:     default:
 570: 
 571:         if( isdigit(c) ){ /* number */
 572:             numbval = c-'0' ;
 573:             base = (c=='0') ? 8 : 10 ;
 574:             for( c=getc(finput); isdigit(c) ; c=getc(finput) ){
 575:                 numbval = numbval*base + c - '0';
 576:                 }
 577:             ungetc( c, finput );
 578:             return(NUMBER);
 579:             }
 580:         else if( islower(c) || isupper(c) || c=='_' || c=='.' || c=='$' ){
 581:             i = 0;
 582:             while( islower(c) || isupper(c) || isdigit(c) || c=='_' || c=='.' || c=='$' ){
 583:                 tokname[i] = c;
 584:                 if( reserve && isupper(c) ) tokname[i] += 'a'-'A';
 585:                 if( ++i >= NAMESIZE ) --i;
 586:                 c = getc(finput);
 587:                 }
 588:             }
 589:         else return(c);
 590: 
 591:         ungetc( c, finput );
 592:         }
 593: 
 594:     tokname[i] = '\0';
 595: 
 596:     if( reserve ){ /* find a reserved word */
 597:         if( !strcmp(tokname,"term")) return( TERM );
 598:         if( !strcmp(tokname,"token")) return( TERM );
 599:         if( !strcmp(tokname,"left")) return( LEFT );
 600:         if( !strcmp(tokname,"nonassoc")) return( BINARY );
 601:         if( !strcmp(tokname,"binary")) return( BINARY );
 602:         if( !strcmp(tokname,"right")) return( RIGHT );
 603:         if( !strcmp(tokname,"prec")) return( PREC );
 604:         if( !strcmp(tokname,"start")) return( START );
 605:         if( !strcmp(tokname,"type")) return( TYPEDEF );
 606:         if( !strcmp(tokname,"union")) return( UNION );
 607:         error("invalid escape, or illegal reserved word: %s", tokname );
 608:         }
 609: 
 610:     /* look ahead to distinguish IDENTIFIER from C_IDENTIFIER */
 611: 
 612:     c = getc(finput);
 613:     while( c==' ' || c=='\t'|| c=='\n' || c=='\f' || c== '/' ) {
 614:         if( c == '\n' ) ++peekline;
 615:         else if( c == '/' ){ /* look for comments */
 616:             peekline += skipcom();
 617:             }
 618:         c = getc(finput);
 619:         }
 620:     if( c == ':' ) return( C_IDENTIFIER );
 621:     ungetc( c, finput );
 622:     return( IDENTIFIER );
 623: }
 624: 
 625: fdtype( t ){ /* determine the type of a symbol */
 626:     register v;
 627:     if( t >= NTBASE ) v = nontrst[t-NTBASE].tvalue;
 628:     else v = TYPE( toklev[t] );
 629:     if( v <= 0 ) error( "must specify type for %s", (t>=NTBASE)?nontrst[t-NTBASE].name:
 630:             tokset[t].name );
 631:     return( v );
 632:     }
 633: 
 634: chfind( t, s ) register char *s; {
 635:     int i;
 636: 
 637:     if (s[0]==' ')t=0;
 638:     TLOOP(i){
 639:         if(!strcmp(s,tokset[i].name)){
 640:             return( i );
 641:             }
 642:         }
 643:     NTLOOP(i){
 644:         if(!strcmp(s,nontrst[i].name)) {
 645:             return( i+NTBASE );
 646:             }
 647:         }
 648:     /* cannot find name */
 649:     if( t>1 )
 650:         error( "%s should have been defined earlier", s );
 651:     return( defin( t, s ) );
 652:     }
 653: 
 654: cpyunion(){
 655:     /* copy the union declaration to the output, and the define file if present */
 656: 
 657:     int level, c;
 658:     fprintf( ftable, "\n# line %d \"%s\"\n", lineno, infile );
 659:     fprintf( ftable, "typedef union " );
 660:     if( fdefine ) fprintf( fdefine, "\ntypedef union " );
 661: 
 662:     level = 0;
 663:     for(;;){
 664:         if( (c=getc(finput)) < 0 ) error( "EOF encountered while processing %%union" );
 665:         putc( c, ftable );
 666:         if( fdefine ) putc( c, fdefine );
 667: 
 668:         switch( c ){
 669: 
 670:         case '\n':
 671:             ++lineno;
 672:             break;
 673: 
 674:         case '{':
 675:             ++level;
 676:             break;
 677: 
 678:         case '}':
 679:             --level;
 680:             if( level == 0 ) { /* we are finished copying */
 681:                 fprintf( ftable, " YYSTYPE;\n" );
 682:                 if( fdefine ) fprintf( fdefine, " YYSTYPE;\nextern YYSTYPE yylval;\n" );
 683:                 return;
 684:                 }
 685:             }
 686:         }
 687:     }
 688: 
 689: cpycode(){ /* copies code between \{ and \} */
 690: 
 691:     int c;
 692:     c = getc(finput);
 693:     if( c == '\n' ) {
 694:         c = getc(finput);
 695:         lineno++;
 696:         }
 697:     fprintf( ftable, "\n# line %d \"%s\"\n", lineno, infile );
 698:     while( c>=0 ){
 699:         if( c=='\\' )
 700:             if( (c=getc(finput)) == '}' ) return;
 701:             else putc('\\', ftable );
 702:         if( c=='%' )
 703:             if( (c=getc(finput)) == '}' ) return;
 704:             else putc('%', ftable );
 705:         putc( c , ftable );
 706:         if( c == '\n' ) ++lineno;
 707:         c = getc(finput);
 708:         }
 709:     error("eof before %%}" );
 710:     }
 711: 
 712: skipcom(){ /* skip over comments */
 713:     register c, i=0;  /* i is the number of lines skipped */
 714: 
 715:     /* skipcom is called after reading a / */
 716: 
 717:     if( getc(finput) != '*' ) error( "illegal comment" );
 718:     c = getc(finput);
 719:     while( c != EOF ){
 720:         while( c == '*' ){
 721:             if( (c=getc(finput)) == '/' ) return( i );
 722:             }
 723:         if( c == '\n' ) ++i;
 724:         c = getc(finput);
 725:         }
 726:     error( "EOF inside comment" );
 727:     /* NOTREACHED */
 728:     }
 729: 
 730: cpyact(offset){ /* copy C action to the next ; or closing } */
 731:     int brac, c, match, j, s, tok;
 732: 
 733:     fprintf( faction, "\n# line %d \"%s\"\n", lineno, infile );
 734: 
 735:     brac = 0;
 736: 
 737: loop:
 738:     c = getc(finput);
 739: swt:
 740:     switch( c ){
 741: 
 742: case ';':
 743:         if( brac == 0 ){
 744:             putc( c , faction );
 745:             return;
 746:             }
 747:         goto lcopy;
 748: 
 749: case '{':
 750:         brac++;
 751:         goto lcopy;
 752: 
 753: case '$':
 754:         s = 1;
 755:         tok = -1;
 756:         c = getc(finput);
 757:         if( c == '<' ){ /* type description */
 758:             ungetc( c, finput );
 759:             if( gettok() != TYPENAME ) error( "bad syntax on $<ident> clause" );
 760:             tok = numbval;
 761:             c = getc(finput);
 762:             }
 763:         if( c == '$' ){
 764:             fprintf( faction, "yyval");
 765:             if( ntypes ){ /* put out the proper tag... */
 766:                 if( tok < 0 ) tok = fdtype( *prdptr[nprod] );
 767:                 fprintf( faction, ".%s", typeset[tok] );
 768:                 }
 769:             goto loop;
 770:             }
 771:         if( c == '-' ){
 772:             s = -s;
 773:             c = getc(finput);
 774:             }
 775:         if( isdigit(c) ){
 776:             j=0;
 777:             while( isdigit(c) ){
 778:                 j= j*10+c-'0';
 779:                 c = getc(finput);
 780:                 }
 781: 
 782:             j = j*s - offset;
 783:             if( j > 0 ){
 784:                 error( "Illegal use of $%d", j+offset );
 785:                 }
 786: 
 787:             fprintf( faction, "yypvt[-%d]", -j );
 788:             if( ntypes ){ /* put out the proper tag */
 789:                 if( j+offset <= 0 && tok < 0 ) error( "must specify type of $%d", j+offset );
 790:                 if( tok < 0 ) tok = fdtype( prdptr[nprod][j+offset] );
 791:                 fprintf( faction, ".%s", typeset[tok] );
 792:                 }
 793:             goto swt;
 794:             }
 795:         putc( '$' , faction );
 796:         if( s<0 ) putc('-', faction );
 797:         goto swt;
 798: 
 799: case '}':
 800:         if( --brac ) goto lcopy;
 801:         putc( c, faction );
 802:         return;
 803: 
 804: 
 805: case '/':   /* look for comments */
 806:         putc( c , faction );
 807:         c = getc(finput);
 808:         if( c != '*' ) goto swt;
 809: 
 810:         /* it really is a comment */
 811: 
 812:         putc( c , faction );
 813:         c = getc(finput);
 814:         while( c != EOF ){
 815:             while( c=='*' ){
 816:                 putc( c , faction );
 817:                 if( (c=getc(finput)) == '/' ) goto lcopy;
 818:                 }
 819:             putc( c , faction );
 820:             if( c == '\n' )++lineno;
 821:             c = getc(finput);
 822:             }
 823:         error( "EOF inside comment" );
 824: 
 825: case '\'':  /* character constant */
 826:         match = '\'';
 827:         goto string;
 828: 
 829: case '"':   /* character string */
 830:         match = '"';
 831: 
 832:     string:
 833: 
 834:         putc( c , faction );
 835:         while( c=getc(finput) ){
 836: 
 837:             if( c=='\\' ){
 838:                 putc( c , faction );
 839:                 c=getc(finput);
 840:                 if( c == '\n' ) ++lineno;
 841:                 }
 842:             else if( c==match ) goto lcopy;
 843:             else if( c=='\n' ) error( "newline in string or char. const." );
 844:             putc( c , faction );
 845:             }
 846:         error( "EOF in string or character constant" );
 847: 
 848: case EOF:
 849:         error("action does not terminate" );
 850: 
 851: case '\n':  ++lineno;
 852:         goto lcopy;
 853: 
 854:         }
 855: 
 856: lcopy:
 857:     putc( c , faction );
 858:     goto loop;
 859:     }

Defined functions

Defined variables

Defined macros