1/* $NetBSD$ */ 2 3#ifndef lint 4static const char yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93"; 5#endif 6 7#define YYBYACC 1 8#define YYMAJOR 1 9#define YYMINOR 9 10 11#define YYEMPTY (-1) 12#define yyclearin (yychar = YYEMPTY) 13#define yyerrok (yyerrflag = 0) 14#define YYRECOVERING() (yyerrflag != 0) 15 16 17#define YYPURE 0 18 19#line 2 "code_calc.y" 20# include <stdio.h> 21# include <ctype.h> 22 23int regs[26]; 24int base; 25 26#line 25 "code_calc.code.c" 27 28#ifndef YYSTYPE 29typedef int YYSTYPE; 30#endif 31 32/* compatibility with bison */ 33#ifdef YYPARSE_PARAM 34/* compatibility with FreeBSD */ 35# ifdef YYPARSE_PARAM_TYPE 36# define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM) 37# else 38# define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM) 39# endif 40#else 41# define YYPARSE_DECL() yyparse(void) 42#endif 43 44/* Parameters sent to lex. */ 45#ifdef YYLEX_PARAM 46# define YYLEX_DECL() yylex(void *YYLEX_PARAM) 47# define YYLEX yylex(YYLEX_PARAM) 48#else 49# define YYLEX_DECL() yylex(void) 50# define YYLEX yylex() 51#endif 52 53/* Parameters sent to yyerror. */ 54#define YYERROR_DECL() yyerror(const char *s) 55#define YYERROR_CALL(msg) yyerror(msg) 56 57extern int YYPARSE_DECL(); 58 59#define DIGIT 257 60#define LETTER 258 61#define UMINUS 259 62#define YYERRCODE 256 63#define YYTABLESIZE 220 64#define YYFINAL 1 65#ifndef YYDEBUG 66#define YYDEBUG 0 67#endif 68#define YYMAXTOKEN 259 69 70#ifndef yyparse 71#define yyparse calc_parse 72#endif /* yyparse */ 73 74#ifndef yylex 75#define yylex calc_lex 76#endif /* yylex */ 77 78#ifndef yyerror 79#define yyerror calc_error 80#endif /* yyerror */ 81 82#ifndef yychar 83#define yychar calc_char 84#endif /* yychar */ 85 86#ifndef yyval 87#define yyval calc_val 88#endif /* yyval */ 89 90#ifndef yylval 91#define yylval calc_lval 92#endif /* yylval */ 93 94#ifndef yydebug 95#define yydebug calc_debug 96#endif /* yydebug */ 97 98#ifndef yynerrs 99#define yynerrs calc_nerrs 100#endif /* yynerrs */ 101 102#ifndef yyerrflag 103#define yyerrflag calc_errflag 104#endif /* yyerrflag */ 105 106#ifndef yylhs 107#define yylhs calc_lhs 108#endif /* yylhs */ 109 110#ifndef yylen 111#define yylen calc_len 112#endif /* yylen */ 113 114#ifndef yydefred 115#define yydefred calc_defred 116#endif /* yydefred */ 117 118#ifndef yydgoto 119#define yydgoto calc_dgoto 120#endif /* yydgoto */ 121 122#ifndef yysindex 123#define yysindex calc_sindex 124#endif /* yysindex */ 125 126#ifndef yyrindex 127#define yyrindex calc_rindex 128#endif /* yyrindex */ 129 130#ifndef yygindex 131#define yygindex calc_gindex 132#endif /* yygindex */ 133 134#ifndef yytable 135#define yytable calc_table 136#endif /* yytable */ 137 138#ifndef yycheck 139#define yycheck calc_check 140#endif /* yycheck */ 141 142#ifndef yyname 143#define yyname calc_name 144#endif /* yyname */ 145 146#ifndef yyrule 147#define yyrule calc_rule 148#endif /* yyrule */ 149#define YYPREFIX "calc_" 150 151extern int YYPARSE_DECL(); 152extern short yylhs[]; 153extern short yylen[]; 154extern short yydefred[]; 155extern short yydgoto[]; 156extern short yysindex[]; 157extern short yyrindex[]; 158extern short yygindex[]; 159extern short yytable[]; 160extern short yycheck[]; 161 162#if YYDEBUG 163extern char *yyname[]; 164extern char *yyrule[]; 165#endif 166 167int yydebug; 168int yynerrs; 169 170int yyerrflag; 171int yychar; 172YYSTYPE yyval; 173YYSTYPE yylval; 174 175/* define the initial stack-sizes */ 176#ifdef YYSTACKSIZE 177#undef YYMAXDEPTH 178#define YYMAXDEPTH YYSTACKSIZE 179#else 180#ifdef YYMAXDEPTH 181#define YYSTACKSIZE YYMAXDEPTH 182#else 183#define YYSTACKSIZE 500 184#define YYMAXDEPTH 500 185#endif 186#endif 187 188#define YYINITSTACKSIZE 500 189 190typedef struct { 191 unsigned stacksize; 192 short *s_base; 193 short *s_mark; 194 short *s_last; 195 YYSTYPE *l_base; 196 YYSTYPE *l_mark; 197} YYSTACKDATA; 198/* variables for the parser stack */ 199static YYSTACKDATA yystack; 200#line 63 "code_calc.y" 201 /* start of programs */ 202 203#ifdef YYBYACC 204extern int YYLEX_DECL(); 205static void YYERROR_DECL(); 206#endif 207 208int 209main (void) 210{ 211 while(!feof(stdin)) { 212 yyparse(); 213 } 214 return 0; 215} 216 217static void 218yyerror(const char *s) 219{ 220 fprintf(stderr, "%s\n", s); 221} 222 223int 224yylex(void) { 225 /* lexical analysis routine */ 226 /* returns LETTER for a lower case letter, yylval = 0 through 25 */ 227 /* return DIGIT for a digit, yylval = 0 through 9 */ 228 /* all other characters are returned immediately */ 229 230 int c; 231 232 while( (c=getchar()) == ' ' ) { /* skip blanks */ } 233 234 /* c is now nonblank */ 235 236 if( islower( c )) { 237 yylval = c - 'a'; 238 return ( LETTER ); 239 } 240 if( isdigit( c )) { 241 yylval = c - '0'; 242 return ( DIGIT ); 243 } 244 return( c ); 245} 246#line 245 "code_calc.code.c" 247 248#if YYDEBUG 249#include <stdio.h> /* needed for printf */ 250#endif 251 252#include <stdlib.h> /* needed for malloc, etc */ 253#include <string.h> /* needed for memset */ 254 255/* allocate initial stack or double stack size, up to YYMAXDEPTH */ 256static int yygrowstack(YYSTACKDATA *data) 257{ 258 int i; 259 unsigned newsize; 260 short *newss; 261 YYSTYPE *newvs; 262 263 if ((newsize = data->stacksize) == 0) 264 newsize = YYINITSTACKSIZE; 265 else if (newsize >= YYMAXDEPTH) 266 return -1; 267 else if ((newsize *= 2) > YYMAXDEPTH) 268 newsize = YYMAXDEPTH; 269 270 i = data->s_mark - data->s_base; 271 newss = (short *)realloc(data->s_base, newsize * sizeof(*newss)); 272 if (newss == 0) 273 return -1; 274 275 data->s_base = newss; 276 data->s_mark = newss + i; 277 278 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs)); 279 if (newvs == 0) 280 return -1; 281 282 data->l_base = newvs; 283 data->l_mark = newvs + i; 284 285 data->stacksize = newsize; 286 data->s_last = data->s_base + newsize - 1; 287 return 0; 288} 289 290#if YYPURE || defined(YY_NO_LEAKS) 291static void yyfreestack(YYSTACKDATA *data) 292{ 293 free(data->s_base); 294 free(data->l_base); 295 memset(data, 0, sizeof(*data)); 296} 297#else 298#define yyfreestack(data) /* nothing */ 299#endif 300 301#define YYABORT goto yyabort 302#define YYREJECT goto yyabort 303#define YYACCEPT goto yyaccept 304#define YYERROR goto yyerrlab 305 306int 307YYPARSE_DECL() 308{ 309 int yym, yyn, yystate; 310#if YYDEBUG 311 const char *yys; 312 313 if ((yys = getenv("YYDEBUG")) != 0) 314 { 315 yyn = *yys; 316 if (yyn >= '0' && yyn <= '9') 317 yydebug = yyn - '0'; 318 } 319#endif 320 321 yynerrs = 0; 322 yyerrflag = 0; 323 yychar = YYEMPTY; 324 yystate = 0; 325 326#if YYPURE 327 memset(&yystack, 0, sizeof(yystack)); 328#endif 329 330 if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow; 331 yystack.s_mark = yystack.s_base; 332 yystack.l_mark = yystack.l_base; 333 yystate = 0; 334 *yystack.s_mark = 0; 335 336yyloop: 337 if ((yyn = yydefred[yystate]) != 0) goto yyreduce; 338 if (yychar < 0) 339 { 340 if ((yychar = YYLEX) < 0) yychar = 0; 341#if YYDEBUG 342 if (yydebug) 343 { 344 yys = 0; 345 if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; 346 if (!yys) yys = "illegal-symbol"; 347 printf("%sdebug: state %d, reading %d (%s)\n", 348 YYPREFIX, yystate, yychar, yys); 349 } 350#endif 351 } 352 if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 && 353 yyn <= YYTABLESIZE && yycheck[yyn] == yychar) 354 { 355#if YYDEBUG 356 if (yydebug) 357 printf("%sdebug: state %d, shifting to state %d\n", 358 YYPREFIX, yystate, yytable[yyn]); 359#endif 360 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack)) 361 { 362 goto yyoverflow; 363 } 364 yystate = yytable[yyn]; 365 *++yystack.s_mark = yytable[yyn]; 366 *++yystack.l_mark = yylval; 367 yychar = YYEMPTY; 368 if (yyerrflag > 0) --yyerrflag; 369 goto yyloop; 370 } 371 if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 && 372 yyn <= YYTABLESIZE && yycheck[yyn] == yychar) 373 { 374 yyn = yytable[yyn]; 375 goto yyreduce; 376 } 377 if (yyerrflag) goto yyinrecovery; 378 379 yyerror("syntax error"); 380 381 goto yyerrlab; 382 383yyerrlab: 384 ++yynerrs; 385 386yyinrecovery: 387 if (yyerrflag < 3) 388 { 389 yyerrflag = 3; 390 for (;;) 391 { 392 if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 && 393 yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE) 394 { 395#if YYDEBUG 396 if (yydebug) 397 printf("%sdebug: state %d, error recovery shifting\ 398 to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]); 399#endif 400 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack)) 401 { 402 goto yyoverflow; 403 } 404 yystate = yytable[yyn]; 405 *++yystack.s_mark = yytable[yyn]; 406 *++yystack.l_mark = yylval; 407 goto yyloop; 408 } 409 else 410 { 411#if YYDEBUG 412 if (yydebug) 413 printf("%sdebug: error recovery discarding state %d\n", 414 YYPREFIX, *yystack.s_mark); 415#endif 416 if (yystack.s_mark <= yystack.s_base) goto yyabort; 417 --yystack.s_mark; 418 --yystack.l_mark; 419 } 420 } 421 } 422 else 423 { 424 if (yychar == 0) goto yyabort; 425#if YYDEBUG 426 if (yydebug) 427 { 428 yys = 0; 429 if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; 430 if (!yys) yys = "illegal-symbol"; 431 printf("%sdebug: state %d, error recovery discards token %d (%s)\n", 432 YYPREFIX, yystate, yychar, yys); 433 } 434#endif 435 yychar = YYEMPTY; 436 goto yyloop; 437 } 438 439yyreduce: 440#if YYDEBUG 441 if (yydebug) 442 printf("%sdebug: state %d, reducing by rule %d (%s)\n", 443 YYPREFIX, yystate, yyn, yyrule[yyn]); 444#endif 445 yym = yylen[yyn]; 446 if (yym) 447 yyval = yystack.l_mark[1-yym]; 448 else 449 memset(&yyval, 0, sizeof yyval); 450 switch (yyn) 451 { 452case 3: 453#line 25 "code_calc.y" 454 { yyerrok ; } 455break; 456case 4: 457#line 29 "code_calc.y" 458 { printf("%d\n",yystack.l_mark[0]);} 459break; 460case 5: 461#line 31 "code_calc.y" 462 { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; } 463break; 464case 6: 465#line 35 "code_calc.y" 466 { yyval = yystack.l_mark[-1]; } 467break; 468case 7: 469#line 37 "code_calc.y" 470 { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; } 471break; 472case 8: 473#line 39 "code_calc.y" 474 { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; } 475break; 476case 9: 477#line 41 "code_calc.y" 478 { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; } 479break; 480case 10: 481#line 43 "code_calc.y" 482 { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; } 483break; 484case 11: 485#line 45 "code_calc.y" 486 { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; } 487break; 488case 12: 489#line 47 "code_calc.y" 490 { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; } 491break; 492case 13: 493#line 49 "code_calc.y" 494 { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; } 495break; 496case 14: 497#line 51 "code_calc.y" 498 { yyval = - yystack.l_mark[0]; } 499break; 500case 15: 501#line 53 "code_calc.y" 502 { yyval = regs[yystack.l_mark[0]]; } 503break; 504case 17: 505#line 58 "code_calc.y" 506 { yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; } 507break; 508case 18: 509#line 60 "code_calc.y" 510 { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; } 511break; 512#line 511 "code_calc.code.c" 513 } 514 yystack.s_mark -= yym; 515 yystate = *yystack.s_mark; 516 yystack.l_mark -= yym; 517 yym = yylhs[yyn]; 518 if (yystate == 0 && yym == 0) 519 { 520#if YYDEBUG 521 if (yydebug) 522 printf("%sdebug: after reduction, shifting from state 0 to\ 523 state %d\n", YYPREFIX, YYFINAL); 524#endif 525 yystate = YYFINAL; 526 *++yystack.s_mark = YYFINAL; 527 *++yystack.l_mark = yyval; 528 if (yychar < 0) 529 { 530 if ((yychar = YYLEX) < 0) yychar = 0; 531#if YYDEBUG 532 if (yydebug) 533 { 534 yys = 0; 535 if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; 536 if (!yys) yys = "illegal-symbol"; 537 printf("%sdebug: state %d, reading %d (%s)\n", 538 YYPREFIX, YYFINAL, yychar, yys); 539 } 540#endif 541 } 542 if (yychar == 0) goto yyaccept; 543 goto yyloop; 544 } 545 if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 && 546 yyn <= YYTABLESIZE && yycheck[yyn] == yystate) 547 yystate = yytable[yyn]; 548 else 549 yystate = yydgoto[yym]; 550#if YYDEBUG 551 if (yydebug) 552 printf("%sdebug: after reduction, shifting from state %d \ 553to state %d\n", YYPREFIX, *yystack.s_mark, yystate); 554#endif 555 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack)) 556 { 557 goto yyoverflow; 558 } 559 *++yystack.s_mark = (short) yystate; 560 *++yystack.l_mark = yyval; 561 goto yyloop; 562 563yyoverflow: 564 yyerror("yacc stack overflow"); 565 566yyabort: 567 yyfreestack(&yystack); 568 return (1); 569 570yyaccept: 571 yyfreestack(&yystack); 572 return (0); 573} 574