| # define ID 257 |
| # define CON 258 |
| # define UNARYMINUS 259 |
| #define yyclearin yychar = -1 |
| #define yyerrok yyerrflag = 0 |
| extern int yychar; |
| extern short yyerrflag; |
| #ifndef YYMAXDEPTH |
| #define YYMAXDEPTH 150 |
| #endif |
| #ifndef YYSTYPE |
| #define YYSTYPE int |
| #endif |
| YYSTYPE yylval, yyval; |
| # define YYERRCODE 256 |
| |
| |
| |
| #include <stdio.h> |
| |
| # define U(x) x |
| # define NLSTATE yyprevious=YYNEWLINE |
| # define BEGIN yybgin = yysvec + 1 + |
| # define INITIAL 0 |
| # define YYLERR yysvec |
| # define YYSTATE (yyestate-yysvec-1) |
| # define YYOPTIM 1 |
| # define YYLMAX 200 |
| # define output(c) (void)putc(c,yyout) |
| # define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):getc(yyin))==10?(yylineno++,yytchar):yytchar)==EOF?0:yytchar) |
| # define unput(c) {yytchar= (c);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;} |
| # define yymore() (yymorfg=1) |
| # define ECHO fprintf(yyout, "%s",yytext) |
| # define REJECT { nstr = yyreject(); goto yyfussy;} |
| int yyleng; extern char yytext[]; |
| int yymorfg; |
| extern char *yysptr, yysbuf[]; |
| int yytchar; |
| FILE *yyin = NULL, *yyout = NULL; |
| extern int yylineno; |
| struct yysvf { |
| struct yywork *yystoff; |
| struct yysvf *yyother; |
| int *yystops;}; |
| struct yysvf *yyestate; |
| extern struct yysvf yysvec[], *yybgin; |
| # define YYNEWLINE 10 |
| yylex(){ |
| int nstr; extern int yyprevious; |
| while((nstr = yylook()) >= 0) |
| yyfussy: switch(nstr){ |
| case 0: |
| if(yywrap()) return(0); break; |
| case 1: |
| return ID; |
| break; |
| case 2: |
| return CON; |
| break; |
| case 3: |
| ; |
| break; |
| case 4: |
| return yytext[0]; |
| break; |
| case -1: |
| break; |
| default: |
| fprintf(yyout,"bad switch yylook %d",nstr); |
| } return(0); } |
| /* end of yylex */ |
| int yyvstop[] ={ |
| 0, |
| |
| 4, |
| 0, |
| |
| 3, |
| 4, |
| 0, |
| |
| 2, |
| 4, |
| 0, |
| |
| 1, |
| 4, |
| 0, |
| |
| 2, |
| 0, |
| |
| 1, |
| 0, |
| 0}; |
| # define YYTYPE char |
| struct yywork { YYTYPE verify, advance; } yycrank[] ={ |
| 0,0, 0,0, 1,3, 0,0, |
| 0,0, 0,0, 0,0, 0,0, |
| 0,0, 0,0, 1,4, 1,3, |
| 0,0, 0,0, 0,0, 0,0, |
| 0,0, 0,0, 0,0, 0,0, |
| 0,0, 0,0, 0,0, 0,0, |
| 0,0, 0,0, 0,0, 0,0, |
| 0,0, 0,0, 0,0, 0,0, |
| 0,0, 0,0, 0,0, 0,0, |
| 0,0, 0,0, 0,0, 0,0, |
| 0,0, 0,0, 0,0, 0,0, |
| 0,0, 0,0, 0,0, 0,0, |
| 0,0, 1,5, 5,7, 5,7, |
| 5,7, 5,7, 5,7, 5,7, |
| 5,7, 5,7, 5,7, 5,7, |
| 0,0, 0,0, 0,0, 0,0, |
| 0,0, 0,0, 1,6, 6,8, |
| 6,8, 6,8, 6,8, 6,8, |
| 6,8, 6,8, 6,8, 6,8, |
| 6,8, 0,0, 0,0, 0,0, |
| 0,0, 0,0, 0,0, 0,0, |
| 6,8, 6,8, 6,8, 6,8, |
| 6,8, 6,8, 6,8, 6,8, |
| 6,8, 6,8, 6,8, 6,8, |
| 6,8, 6,8, 6,8, 6,8, |
| 6,8, 6,8, 6,8, 6,8, |
| 6,8, 6,8, 6,8, 6,8, |
| 6,8, 6,8, 0,0, 0,0, |
| 0,0, 0,0, 6,8, 0,0, |
| 6,8, 6,8, 6,8, 6,8, |
| 6,8, 6,8, 6,8, 6,8, |
| 6,8, 6,8, 6,8, 6,8, |
| 6,8, 6,8, 6,8, 6,8, |
| 6,8, 6,8, 6,8, 6,8, |
| 6,8, 6,8, 6,8, 6,8, |
| 6,8, 6,8, 0,0, 0,0, |
| 0,0}; |
| struct yysvf yysvec[] ={ |
| 0, 0, 0, |
| yycrank+-1, 0, 0, |
| yycrank+0, yysvec+1, 0, |
| yycrank+0, 0, yyvstop+1, |
| yycrank+0, 0, yyvstop+3, |
| yycrank+2, 0, yyvstop+6, |
| yycrank+19, 0, yyvstop+9, |
| yycrank+0, yysvec+5, yyvstop+12, |
| yycrank+0, yysvec+6, yyvstop+14, |
| 0, 0, 0}; |
| struct yywork *yytop = yycrank+141; |
| struct yysvf *yybgin = yysvec+1; |
| char yymatch[] ={ |
| 00 ,01 ,01 ,01 ,01 ,01 ,01 ,01 , |
| 01 ,011 ,012 ,01 ,01 ,01 ,01 ,01 , |
| 01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 , |
| 01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 , |
| 011 ,01 ,01 ,01 ,01 ,01 ,01 ,01 , |
| 01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 , |
| '0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' , |
| '0' ,'0' ,01 ,01 ,01 ,01 ,01 ,01 , |
| 01 ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' , |
| 'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' , |
| 'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' , |
| 'A' ,'A' ,'A' ,01 ,01 ,01 ,01 ,'A' , |
| 01 ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' , |
| 'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' , |
| 'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' , |
| 'A' ,'A' ,'A' ,01 ,01 ,01 ,01 ,01 , |
| 0}; |
| char yyextra[] ={ |
| 0,0,0,0,0,0,0,0, |
| 0}; |
| /* ncform 4.1 83/08/11 */ |
| |
| int yylineno =1; |
| # define YYU(x) x |
| # define NLSTATE yyprevious=YYNEWLINE |
| char yytext[YYLMAX]; |
| struct yysvf *yylstate [YYLMAX], **yylsp, **yyolsp; |
| char yysbuf[YYLMAX]; |
| char *yysptr = yysbuf; |
| int *yyfnd; |
| extern struct yysvf *yyestate; |
| int yyprevious = YYNEWLINE; |
| yylook(){ |
| register struct yysvf *yystate, **lsp; |
| register struct yywork *yyt; |
| struct yysvf *yyz; |
| int yych; |
| struct yywork *yyr; |
| # ifdef LEXDEBUG |
| int debug; |
| # endif |
| char *yylastch; |
| /* start off machines */ |
| # ifdef LEXDEBUG |
| debug = 0; |
| # endif |
| if (!yymorfg) |
| yylastch = yytext; |
| else { |
| yymorfg=0; |
| yylastch = yytext+yyleng; |
| } |
| for(;;){ |
| lsp = yylstate; |
| yyestate = yystate = yybgin; |
| if (yyprevious==YYNEWLINE) yystate++; |
| for (;;){ |
| # ifdef LEXDEBUG |
| if(debug)fprintf(yyout,"state %d\n",yystate-yysvec-1); |
| # endif |
| yyt = yystate->yystoff; |
| if(yyt == yycrank){ /* may not be any transitions */ |
| yyz = yystate->yyother; |
| if(yyz == 0)break; |
| if(yyz->yystoff == yycrank)break; |
| } |
| *yylastch++ = yych = input(); |
| tryagain: |
| # ifdef LEXDEBUG |
| if(debug){ |
| fprintf(yyout,"char "); |
| allprint(yych); |
| putchar('\n'); |
| } |
| # endif |
| yyr = yyt; |
| if ( yyt > yycrank){ |
| yyt = yyr + yych; |
| if (yyt <= yytop && yyt->verify+yysvec == yystate){ |
| if(yyt->advance+yysvec == YYLERR) /* error transitions */ |
| {unput(*--yylastch);break;} |
| *lsp++ = yystate = yyt->advance+yysvec; |
| goto contin; |
| } |
| } |
| # ifdef YYOPTIM |
| else if(yyt < yycrank) { /* r < yycrank */ |
| yyt = yyr = yycrank+(yycrank-yyt); |
| # ifdef LEXDEBUG |
| if(debug)fprintf(yyout,"compressed state\n"); |
| # endif |
| yyt = yyt + yych; |
| if(yyt <= yytop && yyt->verify+yysvec == yystate){ |
| if(yyt->advance+yysvec == YYLERR) /* error transitions */ |
| {unput(*--yylastch);break;} |
| *lsp++ = yystate = yyt->advance+yysvec; |
| goto contin; |
| } |
| yyt = yyr + YYU(yymatch[yych]); |
| # ifdef LEXDEBUG |
| if(debug){ |
| fprintf(yyout,"try fall back character "); |
| allprint(YYU(yymatch[yych])); |
| putchar('\n'); |
| } |
| # endif |
| if(yyt <= yytop && yyt->verify+yysvec == yystate){ |
| if(yyt->advance+yysvec == YYLERR) /* error transition */ |
| {unput(*--yylastch);break;} |
| *lsp++ = yystate = yyt->advance+yysvec; |
| goto contin; |
| } |
| } |
| if ((yystate = yystate->yyother) && (yyt= yystate->yystoff) != yycrank){ |
| # ifdef LEXDEBUG |
| if(debug)fprintf(yyout,"fall back to state %d\n",yystate-yysvec-1); |
| # endif |
| goto tryagain; |
| } |
| # endif |
| else |
| {unput(*--yylastch);break;} |
| contin: |
| # ifdef LEXDEBUG |
| if(debug){ |
| fprintf(yyout,"state %d char ",yystate-yysvec-1); |
| allprint(yych); |
| putchar('\n'); |
| } |
| # endif |
| ; |
| } |
| # ifdef LEXDEBUG |
| if(debug){ |
| fprintf(yyout,"stopped at %d with ",*(lsp-1)-yysvec-1); |
| allprint(yych); |
| putchar('\n'); |
| } |
| # endif |
| while (lsp-- > yylstate){ |
| *yylastch-- = 0; |
| if (*lsp != 0 && (yyfnd= (*lsp)->yystops) && *yyfnd > 0){ |
| yyolsp = lsp; |
| if(yyextra[*yyfnd]){ /* must backup */ |
| while(yyback((*lsp)->yystops,-*yyfnd) != 1 && lsp > yylstate){ |
| lsp--; |
| unput(*yylastch--); |
| } |
| } |
| yyprevious = YYU(*yylastch); |
| yylsp = lsp; |
| yyleng = yylastch-yytext+1; |
| yytext[yyleng] = 0; |
| # ifdef LEXDEBUG |
| if(debug){ |
| fprintf(yyout,"\nmatch "); |
| sprint(yytext); |
| fprintf(yyout," action %d\n",*yyfnd); |
| } |
| # endif |
| return(*yyfnd++); |
| } |
| unput(*yylastch); |
| } |
| if (yytext[0] == 0 /* && feof(yyin) */) |
| { |
| yysptr=yysbuf; |
| return(0); |
| } |
| yyprevious = yytext[0] = input(); |
| if (yyprevious>0) |
| output(yyprevious); |
| yylastch=yytext; |
| # ifdef LEXDEBUG |
| if(debug)putchar('\n'); |
| # endif |
| } |
| } |
| yyback(p, m) |
| int *p; |
| { |
| if (p==0) return(0); |
| while (*p) |
| { |
| if (*p++ == m) |
| return(1); |
| } |
| return(0); |
| } |
| /* the following are only used in the lex library */ |
| yyinput(){ |
| return(input()); |
| } |
| yyoutput(c) |
| int c; { |
| output(c); |
| } |
| yyunput(c) |
| int c; { |
| unput(c); |
| } |
| |
| main() { |
| yyin = stdin; yyout = stdout; |
| yyparse(); |
| return 0; |
| } |
| |
| /* yyerror - issue error message */ |
| yyerror(s) char *s; { |
| printf("%s\n", s); |
| } |
| short yyexca[] ={ |
| -1, 1, |
| 0, -1, |
| -2, 0, |
| }; |
| # define YYNPROD 15 |
| # define YYLAST 249 |
| short yyact[]={ |
| |
| 12, 2, 9, 8, 17, 11, 25, 17, 15, 18, |
| 16, 10, 18, 17, 15, 7, 16, 13, 18, 5, |
| 3, 1, 0, 19, 20, 0, 0, 21, 22, 23, |
| 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 6, 14, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 4, 6 }; |
| short yypact[]={ |
| |
| -1000, -9,-1000, 5, -7, -59,-1000,-1000,-1000, -40, |
| -29, -40, -40,-1000,-1000, -40, -40, -40, -40, -38, |
| -35, -38, -38,-1000,-1000,-1000 }; |
| short yypgo[]={ |
| |
| 0, 21, 20, 17, 11 }; |
| short yyr1[]={ |
| |
| 0, 1, 1, 1, 1, 2, 4, 4, 4, 4, |
| 4, 4, 4, 4, 3 }; |
| short yyr2[]={ |
| |
| 0, 0, 2, 3, 3, 3, 3, 3, 3, 3, |
| 2, 3, 1, 1, 1 }; |
| short yychk[]={ |
| |
| -1000, -1, 10, -2, 256, -3, 257, 10, 10, 61, |
| -4, 45, 40, -3, 258, 43, 45, 42, 47, -4, |
| -4, -4, -4, -4, -4, 41 }; |
| short yydef[]={ |
| |
| 1, -2, 2, 0, 0, 0, 14, 3, 4, 0, |
| 5, 0, 0, 12, 13, 0, 0, 0, 0, 10, |
| 0, 6, 7, 8, 9, 11 }; |
| #ifndef lint |
| #endif |
| |
| # define YYFLAG -1000 |
| # define YYERROR goto yyerrlab |
| # define YYACCEPT return(0) |
| # define YYABORT return(1) |
| |
| /* parser for yacc output */ |
| |
| #ifdef YYDEBUG |
| int yydebug = 0; /* 1 for debugging */ |
| #endif |
| YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */ |
| int yychar = -1; /* current input token number */ |
| int yynerrs = 0; /* number of errors */ |
| short yyerrflag = 0; /* error recovery flag */ |
| |
| yyparse() { |
| |
| short yys[YYMAXDEPTH]; |
| short yyj, yym; |
| register YYSTYPE *yypvt; |
| register short yystate, *yyps, yyn; |
| register YYSTYPE *yypv; |
| register short *yyxi; |
| |
| yystate = 0; |
| yychar = -1; |
| yynerrs = 0; |
| yyerrflag = 0; |
| yyps= &yys[-1]; |
| yypv= &yyv[-1]; |
| |
| yystack: /* put a state and value onto the stack */ |
| |
| #ifdef YYDEBUG |
| if( yydebug ) printf( "state %d, char 0%o\n", yystate, yychar ); |
| #endif |
| if( ++yyps> &yys[YYMAXDEPTH-1] ) { yyerror( "yacc stack overflow" ); return(1); } |
| *yyps = yystate; |
| ++yypv; |
| *yypv = yyval; |
| |
| yynewstate: |
| |
| yyn = yypact[yystate]; |
| |
| if( yyn<= YYFLAG ) goto yydefault; /* simple state */ |
| |
| if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0; |
| if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault; |
| |
| if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */ |
| yychar = -1; |
| yyval = yylval; |
| yystate = yyn; |
| if( yyerrflag > 0 ) --yyerrflag; |
| goto yystack; |
| } |
| |
| yydefault: |
| /* default state action */ |
| |
| if( (yyn=yydef[yystate]) == -2 ) { |
| if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0; |
| /* look through exception table */ |
| |
| for( yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate) ; yyxi += 2 ) ; /* VOID */ |
| |
| while( *(yyxi+=2) >= 0 ){ |
| if( *yyxi == yychar ) break; |
| } |
| if( (yyn = yyxi[1]) < 0 ) return(0); /* accept */ |
| } |
| |
| if( yyn == 0 ){ /* error */ |
| /* error ... attempt to resume parsing */ |
| |
| switch( yyerrflag ){ |
| |
| case 0: /* brand new error */ |
| |
| yyerror( "syntax error" ); |
| yyerrlab: |
| ++yynerrs; |
| |
| case 1: |
| case 2: /* incompletely recovered error ... try again */ |
| |
| yyerrflag = 3; |
| |
| /* find a state where "error" is a legal shift action */ |
| |
| while ( yyps >= yys ) { |
| yyn = yypact[*yyps] + YYERRCODE; |
| if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){ |
| yystate = yyact[yyn]; /* simulate a shift of "error" */ |
| goto yystack; |
| } |
| yyn = yypact[*yyps]; |
| |
| /* the current yyps has no shift onn "error", pop stack */ |
| |
| #ifdef YYDEBUG |
| if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] ); |
| #endif |
| --yyps; |
| --yypv; |
| } |
| |
| /* there is no state on the stack with an error shift ... abort */ |
| |
| yyabort: |
| return(1); |
| |
| |
| case 3: /* no shift yet; clobber input char */ |
| |
| #ifdef YYDEBUG |
| if( yydebug ) printf( "error recovery discards char %d\n", yychar ); |
| #endif |
| |
| if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */ |
| yychar = -1; |
| goto yynewstate; /* try again in the same state */ |
| |
| } |
| |
| } |
| |
| /* reduction by production yyn */ |
| |
| #ifdef YYDEBUG |
| if( yydebug ) printf("reduce %d\n",yyn); |
| #endif |
| yyps -= yyr2[yyn]; |
| yypvt = yypv; |
| yypv -= yyr2[yyn]; |
| yyval = yypv[1]; |
| yym=yyn; |
| /* consult goto table to find next state */ |
| yyn = yyr1[yyn]; |
| yyj = yypgo[yyn] + *yyps + 1; |
| if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]]; |
| switch(yym){ |
| |
| case 4: |
| { yyerrok; } break; |
| case 5: |
| { printf("store\n"); } break; |
| case 6: |
| { printf("add\n"); } break; |
| case 7: |
| { printf("negate\nadd\n"); } break; |
| case 8: |
| { printf("multiply\n"); } break; |
| case 9: |
| { printf("divide\n"); } break; |
| case 10: |
| { printf("negate\n"); } break; |
| case 12: |
| { printf("load\n"); } break; |
| case 13: |
| { printf("push %s\n", yytext); } break; |
| case 14: |
| { printf("%s\n", yytext); } break; |
| } |
| goto yystack; /* stack new state and value */ |
| |
| } |
| int yywrap() { return 1; } |