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