git.sur5r.net Git - cc65/blob - test/ref/yacc.c

   1 /*
   2   !!DESCRIPTION!!
   3   !!ORIGIN!!      LCC 4.1 Testsuite
   4   !!LICENCE!!     own, freely distributeable for non-profit. read CPYRIGHT.LCC
   5 */
   6
   7 /*#define STANDALONE*/
   8
   9 #ifndef YACCDBG
  10
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <ctype.h>
  14
  15 /*
  16 #define LEXDEBUG
  17 #define YYDEBUG
  18 */
  19
  20 #endif
  21
  22 /* hack the original tables to work with both petscii and ascii */
  23 #define CHARSETHACK
  24
  25 # define ID 257
  26 # define CON 258
  27 # define UNARYMINUS 259
  28 #define yyclearin yychar = -1
  29 #define yyerrok yyerrflag = 0
  30 extern int yychar;
  31 extern short yyerrflag;
  32 #ifndef YYMAXDEPTH
  33 /*#define YYMAXDEPTH 150*/
  34 #define YYMAXDEPTH 50
  35 #endif
  36 #ifndef YYSTYPE
  37 #define YYSTYPE int
  38 #endif
  39 YYSTYPE yylval, yyval;
  40 # define YYERRCODE 256
  41
  42 # define U(x) x
  43 # define NLSTATE yyprevious=YYNEWLINE
  44 # define BEGIN yybgin = yysvec + 1 +
  45 # define INITIAL 0
  46 # define YYLERR yysvec
  47 # define YYSTATE (yyestate-yysvec-1)
  48 # define YYOPTIM 1
  49 # define YYLMAX 200
  50 # define output(c) (void)putc(c,yyout)
  51
  52 /* # define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):getc(yyin))==10?(yylineno++,yytchar):yytchar)==EOF?0:yytchar) */
  53 # define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):getchar())==('\n')?(yylineno++,yytchar):yytchar)==EOF?0:yytchar)
  54
  55 # define unput(c) {yytchar= (c);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;}
  56 # define yymore() (yymorfg=1)
  57 # define ECHO fprintf(yyout, "%s",yytext)
  58 # define REJECT { nstr = yyreject(); goto yyfussy;}
  59 int yyleng; extern char yytext[];
  60 int yymorfg;
  61 extern char *yysptr, yysbuf[];
  62 int yytchar;
  63
  64 /*FILE *yyin ={stdin}, *yyout ={stdout};*/
  65 #define yyin  infile
  66 #define yyout outfile
  67
  68 extern int yylineno;
  69 struct yysvf
  70 {
  71         struct yywork *yystoff;
  72         struct yysvf *yyother;
  73         int *yystops;
  74 };
  75 struct yysvf *yyestate;
  76 extern struct yysvf yysvec[], *yybgin;
  77
  78 /*# define YYNEWLINE 10 */
  79 # define YYNEWLINE ('\n')
  80
  81 #ifdef NO_IMPLICIT_FUNC_PROTOTYPES
  82 yylook();
  83 int yywrap();
  84 yyparse();
  85 yyerror(char *s);
  86 yyunput(int c);
  87 yyoutput(int c);
  88 yyinput();
  89 yyback(int *p,int m);
  90 #endif
  91
  92 #ifdef YYDEBUG
  93 void printchar(char *name,int ch)
  94 {
  95         if((ch==YYNEWLINE))
  96         {
  97                 fprintf(yyout," %s=YYNEWLINE\n",name);
  98         }
  99         else if((ch<0)||(ch>0xf0)||(!isprint(ch)))
 100         {
 101                 fprintf(yyout," %s=%04x\n",name,ch &0xffff);
 102         }
 103         else
 104         {
 105                 fprintf(yyout," %s='%c'\n",name,ch);
 106         }
 107 }
 108 #endif
 109
 110 yylex()
 111 {
 112 int nstr;
 113 extern int yyprevious;
 114
 115 #ifdef YYDEBUG
 116         fprintf(yyout,"yylex()\n");
 117 #endif
 118
 119         while((nstr = yylook()) >= 0)
 120         {
 121 #ifdef YYDEBUG
 122         fprintf(yyout,"yylex: nstr=%d\n",nstr);
 123 #endif
 124 yyfussy:
 125         switch(nstr)
 126         {
 127                 case 0:
 128                         if(yywrap()) return(0);
 129                         break;
 130                 case 1:
 131                         return ID;
 132                 break;
 133                 case 2:
 134                         return CON;
 135                 break;
 136                 case 3:
 137                         ;
 138                 break;
 139                 case 4:
 140                         return yytext[0];
 141                 break;
 142                 case -1:
 143                 break;
 144                 default:
 145                         fprintf(yyout,"yylex: bad switch yylook %d\n",nstr);
 146         }
 147
 148         }
 149
 150 #ifdef YYDEBUG
 151         fprintf(yyout,"yylex: return 0\n");
 152 #endif
 153         return(0);
 154 }
 155 /* end of yylex */
 156
 157 int yyvstop[] =
 158 {
 159         0,4,0,3,4,0,2,4,0,1,4,0,2,0,1,0,0
 160 };
 161
 162 # define YYTYPE char
 163 struct yywork
 164 {
 165         YYTYPE verify, advance;
 166 } yycrank[] =
 167 {
 168         {0,0},  {0,0},  {1,3},  {0,0},
 169         {0,0},  {0,0},  {0,0},  {0,0},
 170         {0,0},  {0,0},  {1,4},  {1,3},
 171         {0,0},  {0,0},  {0,0},  {0,0},
 172
 173         {0,0},  {0,0},  {0,0},  {0,0},
 174         {0,0},  {0,0},  {0,0},  {0,0},
 175         {0,0},  {0,0},  {0,0},  {0,0},
 176         {0,0},  {0,0},  {0,0},  {0,0},
 177
 178         {0,0},  {0,0},  {0,0},  {0,0},
 179         {0,0},  {0,0},  {0,0},  {0,0},
 180         {0,0},  {0,0},  {0,0},  {0,0},
 181         {0,0},  {0,0},  {0,0},  {0,0},
 182
 183         {0,0},  {1,5},  {5,7},  {5,7},
 184         {5,7},  {5,7},  {5,7},  {5,7},
 185         {5,7},  {5,7},  {5,7},  {5,7},
 186         {0,0},  {0,0},  {0,0},  {0,0},
 187 /* 0x40 */
 188         {0,0},  {0,0},  {1,6},  {6,8},
 189         {6,8},  {6,8},  {6,8},  {6,8},
 190         {6,8},  {6,8},  {6,8},  {6,8},
 191         {6,8},  {0,0},  {0,0},  {0,0},
 192
 193         {0,0},  {0,0},  {0,0},  {0,0},
 194         {6,8},  {6,8},  {6,8},  {6,8},
 195         {6,8},  {6,8},  {6,8},  {6,8},
 196         {6,8},  {6,8},  {6,8},  {6,8},
 197
 198         {6,8},  {6,8},  {6,8},  {6,8},
 199         {6,8},  {6,8},  {6,8},  {6,8},
 200         {6,8},  {6,8},  {6,8},  {6,8},
 201         {6,8},  {6,8},  {0,0},  {0,0},
 202
 203         {0,0},  {0,0},  {6,8},  {0,0},
 204         {6,8},  {6,8},  {6,8},  {6,8},
 205         {6,8},  {6,8},  {6,8},  {6,8},
 206         {6,8},  {6,8},  {6,8},  {6,8},
 207 /* 0x80 */
 208         {6,8},  {6,8},  {6,8},  {6,8},
 209         {6,8},  {6,8},  {6,8},  {6,8},
 210         {6,8},  {6,8},  {6,8},  {6,8},
 211         {6,8},  {6,8},  {0,0},  {0,0},
 212
 213 #ifdef CHARSETHACK
 214         {0,0},  {0,0},  {0,0},  {0,0},
 215         {0,0},  {0,0},  {0,0},  {0,0},
 216         {0,0},  {0,0},  {0,0},  {0,0},
 217         {0,0},  {0,0},  {0,0},  {0,0},
 218
 219         {0,0},  {0,0},  {0,0},  {0,0},
 220         {0,0},  {0,0},  {0,0},  {0,0},
 221         {0,0},  {0,0},  {0,0},  {0,0},
 222         {0,0},  {0,0},  {0,0},  {0,0},
 223
 224         {0,0},  {0,0},  {0,0},  {0,0},
 225         {0,0},  {0,0},  {0,0},  {0,0},
 226         {0,0},  {0,0},  {0,0},  {0,0},
 227         {0,0},  {0,0},  {0,0},  {0,0},
 228
 229 /* 0xc0 */
 230         {0,0},  {0,0},  {1,6},  {6,8},
 231         {6,8},  {6,8},  {6,8},  {6,8},
 232         {6,8},  {6,8},  {6,8},  {6,8},
 233         {6,8},  {0,0},  {0,0},  {0,0},
 234 #endif
 235         {0,0}
 236 };
 237
 238 /*
 239 struct yysvf
 240 {
 241         struct yywork *yystoff;
 242         struct yysvf *yyother;
 243         int *yystops;
 244 };
 245 */
 246 struct yysvf yysvec[] =
 247 {
 248         {0,     0,      0},
 249         {yycrank+-1,    0,              0},
 250         {yycrank+0,     yysvec+1,       0},
 251         {yycrank+0,     0,              yyvstop+1},
 252         {yycrank+0,     0,              yyvstop+3},
 253         {yycrank+2,     0,              yyvstop+6},
 254         {yycrank+19,    0,              yyvstop+9},
 255         {yycrank+0,     yysvec+5,       yyvstop+12},
 256         {yycrank+0,     yysvec+6,       yyvstop+14},
 257         {0,     0,      0}
 258 };
 259  /* 0x8d */
 260 /* struct yywork *yytop = yycrank+141; */
 261  /* 0xff */
 262 struct yywork *yytop = yycrank+255;
 263
 264 struct yysvf *yybgin = yysvec+1;
 265
 266 /*
 267         WARNING: this table contains one entry per character
 268                  in the execution character set and must match it.
 269 */
 270 char yymatch[] =
 271 {
 272         00  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
 273 #ifdef CHARSETHACK
 274         01  ,011 ,012 ,01  ,01  ,012  ,01  ,01  ,
 275 #else
 276         01  ,011 ,012 ,01  ,01  ,01  ,01  ,01  ,
 277 #endif
 278         01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
 279         01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
 280
 281         011 ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
 282         01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
 283
 284         '0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,
 285         '0' ,'0' ,01  ,01  ,01  ,01  ,01  ,01  ,
 286
 287 /* 0x40 (ascii) @A... (petscii) @a... */
 288         01  ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
 289         'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
 290
 291         'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
 292         'A' ,'A' ,'A' ,01  ,01  ,01  ,01  ,'A' ,
 293
 294 /* 0x60 (ascii) @a... */
 295         01  ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
 296         'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
 297
 298         'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
 299         'A' ,'A' ,'A' ,01  ,01  ,01  ,01  ,01  ,
 300
 301 #ifdef CHARSETHACK
 302 /* 0x80 */
 303         0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
 304         0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
 305         0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
 306         0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
 307
 308 /* 0xc0 (petcii) @A... */
 309         01  ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
 310         'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
 311
 312         'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
 313         'A' ,'A' ,'A' ,01  ,01  ,01  ,01  ,01  ,
 314
 315         0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
 316         0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
 317         0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
 318 #endif
 319         0
 320 };
 321 char yyextra[] =
 322 {
 323         0,0,0,0,0,0,0,0,0
 324 };
 325
 326 /*      ncform  4.1     83/08/11        */
 327
 328 int yylineno =1;
 329 # define YYU(x) x
 330 # define NLSTATE yyprevious=YYNEWLINE
 331 char yytext[YYLMAX];
 332 struct yysvf *yylstate [YYLMAX], **yylsp, **yyolsp;
 333 char yysbuf[YYLMAX];
 334 char *yysptr = yysbuf;
 335 int *yyfnd;
 336 extern struct yysvf *yyestate;
 337 int yyprevious = YYNEWLINE;
 338
 339 unsigned char testbreak=0;
 340
 341 yylook()
 342 {
 343         register struct yysvf *yystate, **lsp;
 344         register struct yywork *yyt;
 345         struct yysvf *yyz;
 346         int yych;
 347         struct yywork *yyr;
 348 /*
 349 # ifdef LEXDEBUG
 350         int debug;
 351 # endif
 352 */
 353
 354         char *yylastch;
 355
 356         /* start off machines */
 357
 358 /*
 359 # ifdef LEXDEBUG
 360         debug = 1;
 361 # else
 362         debug = 0;
 363 # endif
 364 */
 365
 366 # ifdef LEXDEBUG
 367 #define debug 1
 368 # else
 369 #define debug 0
 370 #endif
 371
 372 #ifdef YYDEBUG
 373         fprintf(yyout,"yylook()\n");
 374 # endif
 375
 376         if (!yymorfg)
 377                 yylastch = yytext;
 378         else
 379         {
 380                 yymorfg=0;
 381                 yylastch = yytext+yyleng;
 382         }
 383
 384 #ifdef YYDEBUG
 385         fprintf(yyout,"yylook: yymorfg=%d\n",yymorfg);
 386 # endif
 387
 388         for(;;)
 389         {
 390 #ifdef YYDEBUG
 391                 fprintf(yyout,"yylook:  (outer loop)");
 392                 printchar("yyprevious",yyprevious);
 393 # endif
 394                 lsp = yylstate;
 395                 yyestate = yystate = yybgin;
 396                 if (yyprevious==YYNEWLINE) yystate++;
 397
 398                 testbreak=0;
 399
 400                 for (;;)
 401                 {
 402 # ifdef LEXDEBUG
 403                         fprintf(yyout,"yylook:   (inner loop) state %d\n",yystate-yysvec-1);
 404 # endif
 405                         if(testbreak==5)
 406                         {
 407                                 fprintf(yyout,"yylook:   error, aborted after 5 loops\n");
 408                                 exit(0);
 409                         }
 410                         testbreak++;
 411
 412                         yyt = yystate->yystoff;
 413
 414 /*                      fprintf(yyout,"yylook:   yyt offs: %02x\n",yyt-yycrank); */
 415
 416
 417                         if(yyt == yycrank)
 418                         {               /* may not be any transitions */
 419                                 yyz = yystate->yyother;
 420                                 if(yyz == 0)break;
 421                                 if(yyz->yystoff == yycrank)break;
 422                         }
 423                         *yylastch++ = yych = input();
 424
 425 # ifdef LEXDEBUG
 426                         fprintf(yyout,"yylook:   input ");
 427                         printchar("yych",yych);
 428 # endif
 429
 430                 tryagain:
 431
 432 # ifdef LEXDEBUG
 433 /*                      fprintf(yyout,"yylook:   yych=%02x yymatch[yych]=%02x\n",yych,yymatch[yych]); */
 434                         fprintf(yyout,"yylook:   tryagain\n");
 435 # endif
 436                         yyr = yyt;
 437
 438 /*                      fprintf(yyout,"yylook:   yyr offs: %02x\n",yyr-yycrank); */
 439
 440                         if ( yyt > yycrank)
 441                         {
 442                                 yyt = yyr + yych;
 443                                 if (yyt <= yytop && yyt->verify+yysvec == yystate)
 444                                 {
 445                                         if(yyt->advance+yysvec == YYLERR)       /* error transitions */
 446                                         {
 447 # ifdef LEXDEBUG
 448                                                 fprintf(yyout,"yylook:   unput (1) ");
 449                                                 printchar("*yylastch",*yylastch);
 450 # endif
 451                                                 unput(*--yylastch);
 452                                                 break;
 453                                         }
 454                                         *lsp++ = yystate = yyt->advance+yysvec;
 455 # ifdef LEXDEBUG
 456                                         fprintf(yyout,"yylook:   continue (1)\n");
 457 # endif
 458                                         goto contin;
 459                                 }
 460 # ifdef LEXDEBUG
 461                                 fprintf(yyout,"yylook:   ( yyt > yycrank)\n");
 462 # endif
 463                         }
 464 # ifdef YYOPTIM
 465                         else if(yyt < yycrank) /* r < yycrank */
 466                         {
 467                                 yyt = yyr = yycrank+(yycrank-yyt);
 468 # ifdef LEXDEBUG
 469                                 fprintf(yyout,"yylook:   compressed state\n");
 470 # endif
 471                                 yyt = yyt + yych;
 472                                 if(yyt <= yytop && yyt->verify+yysvec == yystate)
 473                                 {
 474 # ifdef LEXDEBUG
 475                                         fprintf(yyout,"yylook:   (1)\n");
 476 # endif
 477                                         if(yyt->advance+yysvec == YYLERR)       /* error transitions */
 478                                         {
 479 # ifdef LEXDEBUG
 480                                                 fprintf(yyout,"yylook:   unput (2) ");
 481                                                 printchar("*yylastch",*yylastch);
 482 # endif
 483                                                 unput(*--yylastch);
 484                                                 break;
 485                                         }
 486                                         *lsp++ = yystate = yyt->advance+yysvec;
 487 # ifdef LEXDEBUG
 488                                         fprintf(yyout,"yylook:   continue (2)\n");
 489 # endif
 490                                         goto contin;
 491
 492                                 }
 493 # ifdef LEXDEBUG
 494 /*
 495                                 fprintf(yyout,"yylook:   yych=%02x yymatch[yych]=%02x\n",yych,yymatch[yych]);
 496                                 fprintf(yyout,"yylook:   yyt offs: %02x\n",yyt-yycrank);
 497                                 fprintf(yyout,"yylook:   yyr offs: %02x\n",yyr-yycrank);
 498 */
 499 # endif
 500                                 yyt = yyr + YYU(yymatch[yych]);
 501 # ifdef LEXDEBUG
 502 /*
 503                                 fprintf(yyout,"yylook:   yyt offs: %02x <= yytop offs: %02x\n",yyt-yycrank,yytop-yycrank);
 504                                 fprintf(yyout,"yylook:   yyt->verify=%04x yysvec=%04x (yyt->verify+yysvec)=%04x == yystate=%04x\n",yyt->verify,yysvec,(yyt->verify+yysvec),yystate);
 505 */
 506                                 fprintf(yyout,"yylook:   try fall back character\n");
 507 # endif
 508                                 if(yyt <= yytop && yyt->verify+yysvec == yystate)
 509                                 {
 510 # ifdef LEXDEBUG
 511                                         fprintf(yyout,"yylook:   (2a)\n");
 512 # endif
 513
 514                                         if(yyt->advance+yysvec == YYLERR)       /* error transition */
 515                                         {
 516 # ifdef LEXDEBUG
 517 /* cc65 compiles this ?!                                                fprintf(yyout,"yylook:   unput (3) ",); */
 518                                                 fprintf(yyout,"yylook:   unput (3) ");
 519                                                 printchar("*yylastch",*yylastch);
 520 # endif
 521                                                 unput(*--yylastch);
 522                                                 break;
 523                                         }
 524                                         *lsp++ = yystate = yyt->advance+yysvec;
 525 # ifdef LEXDEBUG
 526 /*                                      fprintf(yyout,"yylook:   yyt offs: %02x yyt->advance=%d\n",yyt-yycrank,yyt->advance); */
 527                                         fprintf(yyout,"yylook:   continue (3)\n");
 528 # endif
 529                                         goto contin;
 530
 531                                 }
 532 # ifdef LEXDEBUG
 533                                 fprintf(yyout,"yylook:   (2)\n");
 534 # endif
 535                         }
 536                         if ((yystate = yystate->yyother) && (yyt= yystate->yystoff) != yycrank)
 537                         {
 538 # ifdef LEXDEBUG
 539                                 fprintf(yyout,"yylook:   fall back to state %d\n",yystate-yysvec-1);
 540 # endif
 541                                 goto tryagain;
 542                         }
 543 # endif
 544                         else
 545                         {
 546 # ifdef LEXDEBUG
 547                                 fprintf(yyout,"yylook:   unput (4) ");
 548                                 printchar("*yylastch",*yylastch);
 549 # endif
 550                                 unput(*--yylastch);
 551                                 break;
 552                         }
 553                 contin:
 554 # ifdef LEXDEBUG
 555                         fprintf(yyout,"yylook:   contin state=%d\n",yystate-yysvec-1);
 556 # endif
 557                         ;
 558                 }
 559
 560 # ifdef LEXDEBUG
 561                 if((*(lsp-1)-yysvec-1)<0)
 562                 {
 563                         fprintf(yyout,"yylook:  stopped (end)\n");
 564                 }
 565                 else
 566                 {
 567                         fprintf(yyout,"yylook:  stopped at %d with\n",*(lsp-1)-yysvec-1);
 568                 }
 569 # endif
 570                 while (lsp-- > yylstate)
 571                 {
 572                         *yylastch-- = 0;
 573                         if (*lsp != 0 && (yyfnd= (*lsp)->yystops) && *yyfnd > 0)
 574                         {
 575                                 yyolsp = lsp;
 576                                 if(yyextra[*yyfnd]) /* must backup */
 577                                 {
 578                                         while(yyback((*lsp)->yystops,-*yyfnd) != 1 && lsp > yylstate)
 579                                         {
 580                                                 lsp--;
 581 # ifdef LEXDEBUG
 582                                                 fprintf(yyout,"yylook:   unput (5) ");
 583                                                 printchar("*yylastch",*yylastch);
 584 # endif
 585                                                 unput(*yylastch--);
 586                                         }
 587                                 }
 588                                 yyprevious = YYU(*yylastch);
 589                                 yylsp = lsp;
 590                                 yyleng = yylastch-yytext+1;
 591                                 yytext[yyleng] = 0;
 592 # ifdef LEXDEBUG
 593                                 fprintf(yyout,"\nyylook:  match action %d\n",*yyfnd);
 594                                 fprintf(yyout,"yylook:  done loops: %d\n",testbreak);
 595 # endif
 596                                 return(*yyfnd++);
 597                         }
 598                         unput(*yylastch);
 599                 }
 600                 if (yytext[0] == 0  /* && feof(yyin) */)
 601                 {
 602                         yysptr=yysbuf;
 603 # ifdef LEXDEBUG
 604                         fprintf(yyout,"yylook:  done loops: %d\n",testbreak);
 605 # endif
 606                         return(0);
 607                 }
 608                 yyprevious = yytext[0] = input();
 609
 610 # ifdef LEXDEBUG
 611                 fprintf(yyout,"yylook:   input ");
 612                 printchar("yyprevious",yyprevious);
 613 # endif
 614
 615                 if (yyprevious>0)
 616                         output(yyprevious);
 617                 yylastch=yytext;
 618 # ifdef LEXDEBUG
 619 /*              if(debug)putchar('\n'); */
 620 # endif
 621         }
 622
 623 # ifdef LEXDEBUG
 624         fprintf(yyout,"yylook: done loops: %d\n",testbreak);
 625         fprintf(yyout,"yylook: return <void>\n");
 626 # endif
 627 }
 628
 629
 630 yyback(p, m)
 631         int *p;
 632 {
 633         if (p==0) return(0);
 634         while (*p)
 635         {
 636                 if (*p++ == m)
 637                 {
 638                         return(1);
 639                 }
 640         }
 641         return(0);
 642 }
 643         /* the following are only used in the lex library */
 644 yyinput()
 645 {
 646         int out=input();
 647
 648 #ifdef YYDEBUG
 649         fprintf(yyout,"yylook:   input ");
 650         printchar("out",out);
 651 #endif
 652         return(out);
 653 }
 654 yyoutput(c)
 655   int c;
 656 {
 657         output(c);
 658 }
 659 yyunput(c)
 660    int c;
 661 {
 662         unput(c);
 663 }
 664
 665 main()
 666 {
 667         printf("main start\n");
 668         yyparse();
 669         printf("main end\n");
 670         return 0;
 671 }
 672
 673 /* yyerror - issue error message */
 674 yyerror(s)
 675 char *s;
 676 {
 677         printf("[%s]\n", s);
 678 }
 679 short yyexca[] =
 680 {
 681 -1, 1,
 682         0, -1,
 683         -2, 0,
 684 };
 685
 686 # define YYNPROD 15
 687 # define YYLAST 249
 688
 689 short yyact[]=
 690 {
 691   12,   2,   9,   8,  17,  11,  25,  17,  15,  18,
 692   16,  10,  18,  17,  15,   7,  16,  13,  18,   5,
 693    3,   1,   0,  19,  20,   0,   0,  21,  22,  23,
 694   24,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 695    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 696    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 697    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 698    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 699    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 700    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 701    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 702    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 703    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 704    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 705    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 706    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 707    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 708    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 709    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 710    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 711    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 712    0,   0,   0,   0,   0,   0,   0,   6,  14,   0,
 713    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 714    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 715    0,   0,   0,   0,   0,   0,   0,   4,   6
 716 };
 717 short yypact[]=
 718 {
 719 -1000,  -9,-1000,   5,  -7, -59,-1000,-1000,-1000, -40,
 720  -29, -40, -40,-1000,-1000, -40, -40, -40, -40, -38,
 721  -35, -38, -38,-1000,-1000,-1000
 722 };
 723 short yypgo[]=
 724 {
 725    0,  21,  20,  17,  11
 726 };
 727 short yyr1[]=
 728 {
 729    0,   1,   1,   1,   1,   2,   4,   4,   4,   4,
 730    4,   4,   4,   4,   3
 731 };
 732 short yyr2[]=
 733 {
 734    0,   0,   2,   3,   3,   3,   3,   3,   3,   3,
 735    2,   3,   1,   1,   1
 736 };
 737 short yychk[]=
 738 {
 739 -1000,  -1,  10,  -2, 256,  -3, 257,  10,  10,  61,
 740   -4,  45,  40,  -3, 258,  43,  45,  42,  47,  -4,
 741   -4,  -4,  -4,  -4,  -4,  41
 742 };
 743 short yydef[]=
 744 {
 745    1,  -2,   2,   0,   0,   0,  14,   3,   4,   0,
 746    5,   0,   0,  12,  13,   0,   0,   0,   0,  10,
 747    0,   6,   7,   8,   9,  11
 748 };
 749
 750 # define YYFLAG -1000
 751 # define YYERROR goto yyerrlab
 752 # define YYACCEPT return(0)
 753 # define YYABORT return(1)
 754
 755 /*      parser for yacc output  */
 756
 757 #ifdef YYDEBUG
 758 int yydebug = 1; /* 1 for debugging */
 759 #else
 760 int yydebug = 0; /* 1 for debugging */
 761 #endif
 762 YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
 763 int yychar = -1; /* current input token number */
 764 int yynerrs = 0;  /* number of errors */
 765 short yyerrflag = 0;  /* error recovery flag */
 766
 767 yyparse()
 768 {
 769         short yys[YYMAXDEPTH];
 770         short yyj, yym;
 771         register YYSTYPE *yypvt;
 772         register short yystate, *yyps, yyn;
 773         register YYSTYPE *yypv;
 774         register short *yyxi;
 775
 776         yystate = 0;
 777         yychar = -1;
 778         yynerrs = 0;
 779         yyerrflag = 0;
 780         yyps= &yys[-1];
 781         yypv= &yyv[-1];
 782
 783  yystack:    /* put a state and value onto the stack */
 784 #ifdef YYDEBUG
 785          printf("yyparse: yystack\n");
 786 #endif
 787
 788 #ifdef YYDEBUG
 789         printf("yyparse: yystate=%d, ", yystate);
 790         printchar("yychar",yychar);
 791 #endif
 792         if( ++yyps> &yys[YYMAXDEPTH] )
 793         {
 794                 yyerror( "yyparse: yacc stack overflow" );
 795                 return(1);
 796         }
 797         *yyps = yystate;
 798         ++yypv;
 799         *yypv = yyval;
 800
 801  yynewstate:
 802 #ifdef YYDEBUG
 803          printf("yyparse: yynewstate\n");
 804 #endif
 805
 806         yyn = yypact[yystate];
 807
 808         if( yyn<= YYFLAG ) goto yydefault; /* simple state */
 809
 810 #ifdef YYDEBUG
 811          printf("yyparse: yynewstate (1)\n");
 812 #endif
 813
 814         if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0;
 815
 816 #ifdef YYDEBUG
 817
 818         printf("yyparse: yynewstate yyn=%d ",yyn);
 819         printchar("yychar",yychar);
 820 #endif
 821
 822         if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault;
 823
 824 #ifdef YYDEBUG
 825          printf("yyparse: yynewstate (2)\n");
 826 #endif
 827
 828         if( yychk[ yyn=yyact[ yyn ] ] == yychar ) /* valid shift */
 829         {
 830                 yychar = -1;
 831                 yyval = yylval;
 832                 yystate = yyn;
 833
 834 #ifdef YYDEBUG
 835                  printf("yyparse: yynewstate (3)\n");
 836 #endif
 837
 838                 if( yyerrflag > 0 ) --yyerrflag;
 839                 goto yystack;
 840         }
 841
 842  yydefault:
 843 #ifdef YYDEBUG
 844          printf("yyparse: yydefault yystate=%d\n",yystate);
 845 #endif
 846         /* default state action */
 847
 848         if( (yyn=yydef[yystate]) == -2 )
 849         {
 850                 if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0;
 851                 /* look through exception table */
 852
 853                 for( yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate) ; yyxi += 2 ) ; /* VOID */
 854
 855                 while( *(yyxi+=2) >= 0 )
 856                 {
 857                         if( *yyxi == yychar ) break;
 858                 }
 859                 if( (yyn = yyxi[1]) < 0 ) return(0);   /* accept */
 860         }
 861
 862 #ifdef YYDEBUG
 863          printf("yyparse: yyn=%d yyerrflag=%d\n",yyn,yyerrflag);
 864 #endif
 865
 866         if( yyn == 0 ) /* error */
 867         {
 868                 /* error ... attempt to resume parsing */
 869
 870                 switch( yyerrflag ){
 871                 case 0:   /* brand new error */
 872
 873                         yyerror( "yyparse: syntax error" );
 874                 yyerrlab:
 875                         ++yynerrs;
 876
 877                 case 1:
 878                 case 2: /* incompletely recovered error ... try again */
 879
 880                         yyerrflag = 3;
 881
 882                         /* find a state where "error" is a legal shift action */
 883
 884                         while ( yyps >= yys ) {
 885                            yyn = yypact[*yyps] + YYERRCODE;
 886                            if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){
 887                               yystate = yyact[yyn];  /* simulate a shift of "error" */
 888                               goto yystack;
 889                               }
 890                            yyn = yypact[*yyps];
 891
 892                            /* the current yyps has no shift onn "error", pop stack */
 893
 894 #ifdef YYDEBUG
 895                            printf("yyparse: error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
 896 #endif
 897                            --yyps;
 898                            --yypv;
 899                            }
 900
 901                         /* there is no state on the stack with an error shift ... abort */
 902
 903         yyabort:
 904                         return(1);
 905
 906                 case 3:  /* no shift yet; clobber input char */
 907
 908 #ifdef YYDEBUG
 909                         printf("yyparse: error recovery discards char ");
 910                         printchar("yychar",yychar);
 911 #endif
 912
 913                         if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
 914                         yychar = -1;
 915                         goto yynewstate;   /* try again in the same state */
 916
 917                         }
 918
 919         }
 920
 921         /* reduction by production yyn */
 922
 923 #ifdef YYDEBUG
 924                 printf("yyparse: reduce %d\n",yyn);
 925 #endif
 926                 yyps -= yyr2[yyn];
 927                 yypvt = yypv;
 928                 yypv -= yyr2[yyn];
 929                 yyval = yypv[1];
 930                 yym=yyn;
 931                         /* consult goto table to find next state */
 932                 yyn = yyr1[yyn];
 933                 yyj = yypgo[yyn] + *yyps + 1;
 934                 if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
 935
 936                 switch(yym)
 937                 {
 938                         case 4:
 939                         {
 940                                 yyerrok;
 941                         }
 942                         break;
 943                         case 5:
 944                         {
 945                                 printf("[STORE]\n");
 946                         }
 947                         break;
 948                         case 6:
 949                         {
 950                                 printf("[ADD]\n");
 951                         }
 952                         break;
 953                         case 7:
 954                         {
 955                                 printf("[NEG]\n[ADD]\n");
 956                         }
 957                         break;
 958                         case 8:
 959                         {
 960                                 printf("[MUL]\n");
 961                         }
 962                         break;
 963                         case 9:
 964                         {
 965                                 printf("[DIV]\n");
 966                         }
 967                         break;
 968                         case 10:
 969                         {
 970                                 printf("[NEG]\n");
 971                         }
 972                         break;
 973                         case 12:
 974                         {
 975                                 printf("[LOAD]\n");
 976                         }
 977                         break;
 978                         case 13:
 979                         {
 980                                 printf("[PUSH %s]\n", yytext);
 981                         }
 982                         break;
 983                         case 14:
 984                         {
 985                                 printf("[%s]\n", yytext);
 986                         }
 987                         break;
 988                 }
 989
 990         goto yystack;  /* stack new state and value */
 991 }
 992
 993 int yywrap()
 994 {
 995         return 1;
 996 }