1 /* original parser id follows */ 2 /* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ 3 /* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */ 4 5 #define YYBYACC 1 6 #define YYMAJOR 1 7 #define YYMINOR 9 8 #define YYCHECK "yyyymmdd" 9 10 #define YYEMPTY (-1) 11 #define yyclearin (yychar = YYEMPTY) 12 #define yyerrok (yyerrflag = 0) 13 #define YYRECOVERING() (yyerrflag != 0) 14 #define YYENOMEM (-2) 15 #define YYEOF 0 16 #undef YYBTYACC 17 #define YYBTYACC 0 18 #define YYDEBUGSTR YYPREFIX "debug" 19 20 #ifndef yyparse 21 #define yyparse calc_parse 22 #endif /* yyparse */ 23 24 #ifndef yylex 25 #define yylex calc_lex 26 #endif /* yylex */ 27 28 #ifndef yyerror 29 #define yyerror calc_error 30 #endif /* yyerror */ 31 32 #ifndef yychar 33 #define yychar calc_char 34 #endif /* yychar */ 35 36 #ifndef yyval 37 #define yyval calc_val 38 #endif /* yyval */ 39 40 #ifndef yylval 41 #define yylval calc_lval 42 #endif /* yylval */ 43 44 #ifndef yydebug 45 #define yydebug calc_debug 46 #endif /* yydebug */ 47 48 #ifndef yynerrs 49 #define yynerrs calc_nerrs 50 #endif /* yynerrs */ 51 52 #ifndef yyerrflag 53 #define yyerrflag calc_errflag 54 #endif /* yyerrflag */ 55 56 #ifndef yylhs 57 #define yylhs calc_lhs 58 #endif /* yylhs */ 59 60 #ifndef yylen 61 #define yylen calc_len 62 #endif /* yylen */ 63 64 #ifndef yydefred 65 #define yydefred calc_defred 66 #endif /* yydefred */ 67 68 #ifndef yystos 69 #define yystos calc_stos 70 #endif /* yystos */ 71 72 #ifndef yydgoto 73 #define yydgoto calc_dgoto 74 #endif /* yydgoto */ 75 76 #ifndef yysindex 77 #define yysindex calc_sindex 78 #endif /* yysindex */ 79 80 #ifndef yyrindex 81 #define yyrindex calc_rindex 82 #endif /* yyrindex */ 83 84 #ifndef yygindex 85 #define yygindex calc_gindex 86 #endif /* yygindex */ 87 88 #ifndef yytable 89 #define yytable calc_table 90 #endif /* yytable */ 91 92 #ifndef yycheck 93 #define yycheck calc_check 94 #endif /* yycheck */ 95 96 #ifndef yyname 97 #define yyname calc_name 98 #endif /* yyname */ 99 100 #ifndef yyrule 101 #define yyrule calc_rule 102 #endif /* yyrule */ 103 104 #if YYBTYACC 105 106 #ifndef yycindex 107 #define yycindex calc_cindex 108 #endif /* yycindex */ 109 110 #ifndef yyctable 111 #define yyctable calc_ctable 112 #endif /* yyctable */ 113 114 #endif /* YYBTYACC */ 115 116 #define YYPREFIX "calc_" 117 118 #define YYPURE 0 119 120 #line 2 "calc.y" 121 # include <stdio.h> 122 # include <ctype.h> 123 124 int regs[26]; 125 int base; 126 127 extern int yylex(void); 128 static void yyerror(const char *s); 129 130 #line 131 "calc.tab.c" 131 132 #if ! defined(YYSTYPE) && ! defined(YYSTYPE_IS_DECLARED) 133 /* Default: YYSTYPE is the semantic value type. */ 134 typedef int YYSTYPE; 135 # define YYSTYPE_IS_DECLARED 1 136 #endif 137 138 /* compatibility with bison */ 139 #ifdef YYPARSE_PARAM 140 /* compatibility with FreeBSD */ 141 # ifdef YYPARSE_PARAM_TYPE 142 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM) 143 # else 144 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM) 145 # endif 146 #else 147 # define YYPARSE_DECL() yyparse(void) 148 #endif 149 150 /* Parameters sent to lex. */ 151 #ifdef YYLEX_PARAM 152 # define YYLEX_DECL() yylex(void *YYLEX_PARAM) 153 # define YYLEX yylex(YYLEX_PARAM) 154 #else 155 # define YYLEX_DECL() yylex(void) 156 # define YYLEX yylex() 157 #endif 158 159 /* Parameters sent to yyerror. */ 160 #ifndef YYERROR_DECL 161 #define YYERROR_DECL() yyerror(const char *s) 162 #endif 163 #ifndef YYERROR_CALL 164 #define YYERROR_CALL(msg) yyerror(msg) 165 #endif 166 167 extern int YYPARSE_DECL(); 168 169 #define DIGIT 257 170 #define LETTER 258 171 #define UMINUS 259 172 #define YYERRCODE 256 173 typedef short YYINT; 174 static const YYINT calc_lhs[] = { -1, 175 0, 0, 0, 1, 1, 2, 2, 2, 2, 2, 176 2, 2, 2, 2, 2, 2, 3, 3, 177 }; 178 static const YYINT calc_len[] = { 2, 179 0, 3, 3, 1, 3, 3, 3, 3, 3, 3, 180 3, 3, 3, 2, 1, 1, 1, 2, 181 }; 182 static const YYINT calc_defred[] = { 1, 183 0, 0, 17, 0, 0, 0, 0, 0, 0, 3, 184 0, 15, 14, 0, 2, 0, 0, 0, 0, 0, 185 0, 0, 18, 0, 6, 0, 0, 0, 0, 9, 186 10, 11, 187 }; 188 static const YYINT calc_stos[] = { 0, 189 261, 256, 257, 258, 45, 40, 262, 263, 264, 10, 190 61, 258, 263, 263, 10, 124, 38, 43, 45, 42, 191 47, 37, 257, 263, 41, 263, 263, 263, 263, 263, 192 263, 263, 193 }; 194 static const YYINT calc_dgoto[] = { 1, 195 7, 8, 9, 196 }; 197 static const YYINT calc_sindex[] = { 0, 198 -40, -7, 0, -55, -38, -38, 1, -29, -247, 0, 199 -38, 0, 0, 22, 0, -38, -38, -38, -38, -38, 200 -38, -38, 0, -29, 0, 51, 60, -20, -20, 0, 201 0, 0, 202 }; 203 static const YYINT calc_rindex[] = { 0, 204 0, 0, 0, 2, 0, 0, 0, 9, -9, 0, 205 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 206 0, 0, 0, 10, 0, -6, 14, 5, 13, 0, 207 0, 0, 208 }; 209 #if YYBTYACC 210 static const YYINT calc_cindex[] = { 0, 211 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 212 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 213 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 214 0, 0, 215 }; 216 #endif 217 static const YYINT calc_gindex[] = { 0, 218 0, 65, 0, 219 }; 220 #define YYTABLESIZE 220 221 static const YYINT calc_table[] = { 6, 222 16, 6, 10, 13, 5, 11, 5, 22, 17, 23, 223 15, 15, 20, 18, 7, 19, 22, 21, 4, 5, 224 0, 20, 8, 12, 0, 0, 21, 16, 16, 0, 225 0, 16, 16, 16, 13, 16, 0, 16, 15, 15, 226 0, 0, 7, 15, 15, 7, 15, 7, 15, 7, 227 8, 12, 0, 8, 12, 8, 0, 8, 22, 17, 228 0, 0, 25, 20, 18, 0, 19, 0, 21, 13, 229 14, 0, 0, 0, 0, 24, 0, 0, 0, 0, 230 26, 27, 28, 29, 30, 31, 32, 22, 17, 0, 231 0, 0, 20, 18, 16, 19, 22, 21, 0, 0, 232 0, 20, 18, 0, 19, 0, 21, 0, 0, 0, 233 0, 0, 0, 0, 16, 0, 0, 13, 0, 0, 234 0, 0, 0, 0, 0, 15, 0, 0, 7, 0, 235 0, 0, 0, 0, 0, 0, 8, 12, 0, 0, 236 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 237 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 238 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 239 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 240 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 241 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 242 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 243 0, 0, 0, 0, 0, 2, 3, 4, 3, 12, 244 }; 245 static const YYINT calc_check[] = { 40, 246 10, 40, 10, 10, 45, 61, 45, 37, 38, 257, 247 10, 10, 42, 43, 10, 45, 37, 47, 10, 10, 248 -1, 42, 10, 10, -1, -1, 47, 37, 38, -1, 249 -1, 41, 42, 43, 41, 45, -1, 47, 37, 38, 250 -1, -1, 38, 42, 43, 41, 45, 43, 47, 45, 251 38, 38, -1, 41, 41, 43, -1, 45, 37, 38, 252 -1, -1, 41, 42, 43, -1, 45, -1, 47, 5, 253 6, -1, -1, -1, -1, 11, -1, -1, -1, -1, 254 16, 17, 18, 19, 20, 21, 22, 37, 38, -1, 255 -1, -1, 42, 43, 124, 45, 37, 47, -1, -1, 256 -1, 42, 43, -1, 45, -1, 47, -1, -1, -1, 257 -1, -1, -1, -1, 124, -1, -1, 124, -1, -1, 258 -1, -1, -1, -1, -1, 124, -1, -1, 124, -1, 259 -1, -1, -1, -1, -1, -1, 124, 124, -1, -1, 260 -1, -1, -1, -1, -1, 124, -1, -1, -1, -1, 261 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 262 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 263 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 264 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 265 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 266 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 267 -1, -1, -1, -1, -1, 256, 257, 258, 257, 258, 268 }; 269 #define YYFINAL 1 270 #ifndef YYDEBUG 271 #define YYDEBUG 0 272 #endif 273 #define YYMAXTOKEN 259 274 #define YYUNDFTOKEN 265 275 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a)) 276 #if YYDEBUG 277 static const char *const calc_name[] = { 278 279 "$end",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 280 0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0, 281 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, 282 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, 283 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, 284 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, 285 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, 286 0,0,"error","DIGIT","LETTER","UMINUS","$accept","list","stat","expr","number", 287 "illegal-symbol", 288 }; 289 static const char *const calc_rule[] = { 290 "$accept : list", 291 "list :", 292 "list : list stat '\\n'", 293 "list : list error '\\n'", 294 "stat : expr", 295 "stat : LETTER '=' expr", 296 "expr : '(' expr ')'", 297 "expr : expr '+' expr", 298 "expr : expr '-' expr", 299 "expr : expr '*' expr", 300 "expr : expr '/' expr", 301 "expr : expr '%' expr", 302 "expr : expr '&' expr", 303 "expr : expr '|' expr", 304 "expr : '-' expr", 305 "expr : LETTER", 306 "expr : number", 307 "number : DIGIT", 308 "number : number DIGIT", 309 310 }; 311 #endif 312 313 int yydebug; 314 int yynerrs; 315 316 int yyerrflag; 317 int yychar; 318 YYSTYPE yyval; 319 YYSTYPE yylval; 320 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 321 YYLTYPE yyloc; /* position returned by actions */ 322 YYLTYPE yylloc; /* position from the lexer */ 323 #endif 324 325 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 326 #ifndef YYLLOC_DEFAULT 327 #define YYLLOC_DEFAULT(loc, rhs, n) \ 328 do \ 329 { \ 330 if (n == 0) \ 331 { \ 332 (loc).first_line = ((rhs)[-1]).last_line; \ 333 (loc).first_column = ((rhs)[-1]).last_column; \ 334 (loc).last_line = ((rhs)[-1]).last_line; \ 335 (loc).last_column = ((rhs)[-1]).last_column; \ 336 } \ 337 else \ 338 { \ 339 (loc).first_line = ((rhs)[ 0 ]).first_line; \ 340 (loc).first_column = ((rhs)[ 0 ]).first_column; \ 341 (loc).last_line = ((rhs)[n-1]).last_line; \ 342 (loc).last_column = ((rhs)[n-1]).last_column; \ 343 } \ 344 } while (0) 345 #endif /* YYLLOC_DEFAULT */ 346 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 347 #if YYBTYACC 348 349 #ifndef YYLVQUEUEGROWTH 350 #define YYLVQUEUEGROWTH 32 351 #endif 352 #endif /* YYBTYACC */ 353 354 /* define the initial stack-sizes */ 355 #ifdef YYSTACKSIZE 356 #undef YYMAXDEPTH 357 #define YYMAXDEPTH YYSTACKSIZE 358 #else 359 #ifdef YYMAXDEPTH 360 #define YYSTACKSIZE YYMAXDEPTH 361 #else 362 #define YYSTACKSIZE 10000 363 #define YYMAXDEPTH 10000 364 #endif 365 #endif 366 367 #ifndef YYINITSTACKSIZE 368 #define YYINITSTACKSIZE 200 369 #endif 370 371 typedef struct { 372 unsigned stacksize; 373 short *s_base; 374 short *s_mark; 375 short *s_last; 376 YYSTYPE *l_base; 377 YYSTYPE *l_mark; 378 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 379 YYLTYPE *p_base; 380 YYLTYPE *p_mark; 381 #endif 382 } YYSTACKDATA; 383 #if YYBTYACC 384 385 struct YYParseState_s 386 { 387 struct YYParseState_s *save; /* Previously saved parser state */ 388 YYSTACKDATA yystack; /* saved parser stack */ 389 int state; /* saved parser state */ 390 int errflag; /* saved error recovery status */ 391 int lexeme; /* saved index of the conflict lexeme in the lexical queue */ 392 YYINT ctry; /* saved index in yyctable[] for this conflict */ 393 }; 394 typedef struct YYParseState_s YYParseState; 395 #endif /* YYBTYACC */ 396 /* variables for the parser stack */ 397 static YYSTACKDATA yystack; 398 #if YYBTYACC 399 400 /* Current parser state */ 401 static YYParseState *yyps = 0; 402 403 /* yypath != NULL: do the full parse, starting at *yypath parser state. */ 404 static YYParseState *yypath = 0; 405 406 /* Base of the lexical value queue */ 407 static YYSTYPE *yylvals = 0; 408 409 /* Current position at lexical value queue */ 410 static YYSTYPE *yylvp = 0; 411 412 /* End position of lexical value queue */ 413 static YYSTYPE *yylve = 0; 414 415 /* The last allocated position at the lexical value queue */ 416 static YYSTYPE *yylvlim = 0; 417 418 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 419 /* Base of the lexical position queue */ 420 static YYLTYPE *yylpsns = 0; 421 422 /* Current position at lexical position queue */ 423 static YYLTYPE *yylpp = 0; 424 425 /* End position of lexical position queue */ 426 static YYLTYPE *yylpe = 0; 427 428 /* The last allocated position at the lexical position queue */ 429 static YYLTYPE *yylplim = 0; 430 #endif 431 432 /* Current position at lexical token queue */ 433 static short *yylexp = 0; 434 435 static short *yylexemes = 0; 436 #endif /* YYBTYACC */ 437 #line 66 "calc.y" 438 /* start of programs */ 439 440 int 441 main (void) 442 { 443 while(!feof(stdin)) { 444 yyparse(); 445 } 446 return 0; 447 } 448 449 static void 450 yyerror(const char *s) 451 { 452 fprintf(stderr, "%s\n", s); 453 } 454 455 int 456 yylex(void) 457 { 458 /* lexical analysis routine */ 459 /* returns LETTER for a lower case letter, yylval = 0 through 25 */ 460 /* return DIGIT for a digit, yylval = 0 through 9 */ 461 /* all other characters are returned immediately */ 462 463 int c; 464 465 while( (c=getchar()) == ' ' ) { /* skip blanks */ } 466 467 /* c is now nonblank */ 468 469 if( islower( c )) { 470 yylval = c - 'a'; 471 return ( LETTER ); 472 } 473 if( isdigit( c )) { 474 yylval = c - '0'; 475 return ( DIGIT ); 476 } 477 return( c ); 478 } 479 #line 480 "calc.tab.c" 480 481 /* For use in generated program */ 482 #define yydepth (int)(yystack.s_mark - yystack.s_base) 483 #if YYBTYACC 484 #define yytrial (yyps->save) 485 #endif /* YYBTYACC */ 486 487 #if YYDEBUG 488 #include <stdio.h> /* needed for printf */ 489 #endif 490 491 #include <stdlib.h> /* needed for malloc, etc */ 492 #include <string.h> /* needed for memset */ 493 494 /* allocate initial stack or double stack size, up to YYMAXDEPTH */ 495 static int yygrowstack(YYSTACKDATA *data) 496 { 497 int i; 498 unsigned newsize; 499 short *newss; 500 YYSTYPE *newvs; 501 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 502 YYLTYPE *newps; 503 #endif 504 505 if ((newsize = data->stacksize) == 0) 506 newsize = YYINITSTACKSIZE; 507 else if (newsize >= YYMAXDEPTH) 508 return YYENOMEM; 509 else if ((newsize *= 2) > YYMAXDEPTH) 510 newsize = YYMAXDEPTH; 511 512 i = (int) (data->s_mark - data->s_base); 513 newss = (short *)realloc(data->s_base, newsize * sizeof(*newss)); 514 if (newss == 0) 515 return YYENOMEM; 516 517 data->s_base = newss; 518 data->s_mark = newss + i; 519 520 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs)); 521 if (newvs == 0) 522 return YYENOMEM; 523 524 data->l_base = newvs; 525 data->l_mark = newvs + i; 526 527 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 528 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps)); 529 if (newps == 0) 530 return YYENOMEM; 531 532 data->p_base = newps; 533 data->p_mark = newps + i; 534 #endif 535 536 data->stacksize = newsize; 537 data->s_last = data->s_base + newsize - 1; 538 539 #if YYDEBUG 540 if (yydebug) 541 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize); 542 #endif 543 return 0; 544 } 545 546 #if YYPURE || defined(YY_NO_LEAKS) 547 static void yyfreestack(YYSTACKDATA *data) 548 { 549 free(data->s_base); 550 free(data->l_base); 551 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 552 free(data->p_base); 553 #endif 554 memset(data, 0, sizeof(*data)); 555 } 556 #else 557 #define yyfreestack(data) /* nothing */ 558 #endif /* YYPURE || defined(YY_NO_LEAKS) */ 559 #if YYBTYACC 560 561 static YYParseState * 562 yyNewState(unsigned size) 563 { 564 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState)); 565 if (p == NULL) return NULL; 566 567 p->yystack.stacksize = size; 568 if (size == 0) 569 { 570 p->yystack.s_base = NULL; 571 p->yystack.l_base = NULL; 572 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 573 p->yystack.p_base = NULL; 574 #endif 575 return p; 576 } 577 p->yystack.s_base = (short *) malloc(size * sizeof(short)); 578 if (p->yystack.s_base == NULL) return NULL; 579 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE)); 580 if (p->yystack.l_base == NULL) return NULL; 581 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE)); 582 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 583 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE)); 584 if (p->yystack.p_base == NULL) return NULL; 585 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE)); 586 #endif 587 588 return p; 589 } 590 591 static void 592 yyFreeState(YYParseState *p) 593 { 594 yyfreestack(&p->yystack); 595 free(p); 596 } 597 #endif /* YYBTYACC */ 598 599 #define YYABORT goto yyabort 600 #define YYREJECT goto yyabort 601 #define YYACCEPT goto yyaccept 602 #define YYERROR goto yyerrlab 603 #if YYBTYACC 604 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0) 605 #define YYVALID_NESTED do { if (yyps->save && \ 606 yyps->save->save == 0) goto yyvalid; } while(0) 607 #endif /* YYBTYACC */ 608 609 int 610 YYPARSE_DECL() 611 { 612 int yym, yyn, yystate, yyresult; 613 #if YYBTYACC 614 int yynewerrflag; 615 YYParseState *yyerrctx = NULL; 616 #endif /* YYBTYACC */ 617 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 618 YYLTYPE yyerror_loc_range[2]; /* position of error start & end */ 619 #endif 620 #if YYDEBUG 621 const char *yys; 622 623 if ((yys = getenv("YYDEBUG")) != 0) 624 { 625 yyn = *yys; 626 if (yyn >= '0' && yyn <= '9') 627 yydebug = yyn - '0'; 628 } 629 if (yydebug) 630 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX); 631 #endif 632 633 #if YYBTYACC 634 yyps = yyNewState(0); if (yyps == 0) goto yyenomem; 635 yyps->save = 0; 636 #endif /* YYBTYACC */ 637 yynerrs = 0; 638 yyerrflag = 0; 639 yychar = YYEMPTY; 640 yystate = 0; 641 642 #if YYPURE 643 memset(&yystack, 0, sizeof(yystack)); 644 #endif 645 646 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 647 yystack.s_mark = yystack.s_base; 648 yystack.l_mark = yystack.l_base; 649 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 650 yystack.p_mark = yystack.p_base; 651 #endif 652 yystate = 0; 653 *yystack.s_mark = 0; 654 655 yyloop: 656 if ((yyn = yydefred[yystate]) != 0) goto yyreduce; 657 if (yychar < 0) 658 { 659 #if YYBTYACC 660 do { 661 if (yylvp < yylve) 662 { 663 /* we're currently re-reading tokens */ 664 yylval = *yylvp++; 665 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 666 yylloc = *yylpp++; 667 #endif 668 yychar = *yylexp++; 669 break; 670 } 671 if (yyps->save) 672 { 673 /* in trial mode; save scanner results for future parse attempts */ 674 if (yylvp == yylvlim) 675 { /* Enlarge lexical value queue */ 676 int p = yylvp - yylvals; 677 int s = yylvlim - yylvals; 678 679 s += YYLVQUEUEGROWTH; 680 if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; 681 if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem; 682 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 683 if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem; 684 #endif 685 yylvp = yylve = yylvals + p; 686 yylvlim = yylvals + s; 687 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 688 yylpp = yylpe = yylpsns + p; 689 yylplim = yylpsns + s; 690 #endif 691 yylexp = yylexemes + p; 692 } 693 *yylexp = (short) YYLEX; 694 *yylvp++ = yylval; 695 yylve++; 696 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 697 *yylpp++ = yylloc; 698 yylpe++; 699 #endif 700 yychar = *yylexp++; 701 break; 702 } 703 /* normal operation, no conflict encountered */ 704 #endif /* YYBTYACC */ 705 yychar = YYLEX; 706 #if YYBTYACC 707 } while (0); 708 #endif /* YYBTYACC */ 709 if (yychar < 0) yychar = YYEOF; 710 /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */ 711 #if YYDEBUG 712 if (yydebug) 713 { 714 yys = yyname[YYTRANSLATE(yychar)]; 715 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)", 716 YYDEBUGSTR, yydepth, yystate, yychar, yys); 717 #ifdef YYSTYPE_TOSTRING 718 #if YYBTYACC 719 if (!yytrial) 720 #endif /* YYBTYACC */ 721 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval)); 722 #endif 723 fputc('\n', stderr); 724 } 725 #endif 726 } 727 #if YYBTYACC 728 729 /* Do we have a conflict? */ 730 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 && 731 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 732 { 733 YYINT ctry; 734 735 if (yypath) 736 { 737 YYParseState *save; 738 #if YYDEBUG 739 if (yydebug) 740 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n", 741 YYDEBUGSTR, yydepth, yystate); 742 #endif 743 /* Switch to the next conflict context */ 744 save = yypath; 745 yypath = save->save; 746 save->save = NULL; 747 ctry = save->ctry; 748 if (save->state != yystate) YYABORT; 749 yyFreeState(save); 750 751 } 752 else 753 { 754 755 /* Unresolved conflict - start/continue trial parse */ 756 YYParseState *save; 757 #if YYDEBUG 758 if (yydebug) 759 { 760 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate); 761 if (yyps->save) 762 fputs("ALREADY in conflict, continuing trial parse.\n", stderr); 763 else 764 fputs("Starting trial parse.\n", stderr); 765 } 766 #endif 767 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 768 if (save == NULL) goto yyenomem; 769 save->save = yyps->save; 770 save->state = yystate; 771 save->errflag = yyerrflag; 772 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 773 memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 774 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base); 775 memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 776 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 777 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 778 memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 779 #endif 780 ctry = yytable[yyn]; 781 if (yyctable[ctry] == -1) 782 { 783 #if YYDEBUG 784 if (yydebug && yychar >= YYEOF) 785 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth); 786 #endif 787 ctry++; 788 } 789 save->ctry = ctry; 790 if (yyps->save == NULL) 791 { 792 /* If this is a first conflict in the stack, start saving lexemes */ 793 if (!yylexemes) 794 { 795 yylexemes = (short *) malloc((YYLVQUEUEGROWTH) * sizeof(short)); 796 if (yylexemes == NULL) goto yyenomem; 797 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE)); 798 if (yylvals == NULL) goto yyenomem; 799 yylvlim = yylvals + YYLVQUEUEGROWTH; 800 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 801 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE)); 802 if (yylpsns == NULL) goto yyenomem; 803 yylplim = yylpsns + YYLVQUEUEGROWTH; 804 #endif 805 } 806 if (yylvp == yylve) 807 { 808 yylvp = yylve = yylvals; 809 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 810 yylpp = yylpe = yylpsns; 811 #endif 812 yylexp = yylexemes; 813 if (yychar >= YYEOF) 814 { 815 *yylve++ = yylval; 816 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 817 *yylpe++ = yylloc; 818 #endif 819 *yylexp = (short) yychar; 820 yychar = YYEMPTY; 821 } 822 } 823 } 824 if (yychar >= YYEOF) 825 { 826 yylvp--; 827 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 828 yylpp--; 829 #endif 830 yylexp--; 831 yychar = YYEMPTY; 832 } 833 save->lexeme = yylvp - yylvals; 834 yyps->save = save; 835 } 836 if (yytable[yyn] == ctry) 837 { 838 #if YYDEBUG 839 if (yydebug) 840 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 841 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]); 842 #endif 843 if (yychar < 0) 844 { 845 yylvp++; 846 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 847 yylpp++; 848 #endif 849 yylexp++; 850 } 851 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) 852 goto yyoverflow; 853 yystate = yyctable[ctry]; 854 *++yystack.s_mark = (short) yystate; 855 *++yystack.l_mark = yylval; 856 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 857 *++yystack.p_mark = yylloc; 858 #endif 859 yychar = YYEMPTY; 860 if (yyerrflag > 0) --yyerrflag; 861 goto yyloop; 862 } 863 else 864 { 865 yyn = yyctable[ctry]; 866 goto yyreduce; 867 } 868 } /* End of code dealing with conflicts */ 869 #endif /* YYBTYACC */ 870 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 && 871 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 872 { 873 #if YYDEBUG 874 if (yydebug) 875 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 876 YYDEBUGSTR, yydepth, yystate, yytable[yyn]); 877 #endif 878 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 879 yystate = yytable[yyn]; 880 *++yystack.s_mark = yytable[yyn]; 881 *++yystack.l_mark = yylval; 882 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 883 *++yystack.p_mark = yylloc; 884 #endif 885 yychar = YYEMPTY; 886 if (yyerrflag > 0) --yyerrflag; 887 goto yyloop; 888 } 889 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 && 890 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 891 { 892 yyn = yytable[yyn]; 893 goto yyreduce; 894 } 895 if (yyerrflag != 0) goto yyinrecovery; 896 #if YYBTYACC 897 898 yynewerrflag = 1; 899 goto yyerrhandler; 900 goto yyerrlab; 901 902 yyerrlab: 903 yynewerrflag = 0; 904 yyerrhandler: 905 while (yyps->save) 906 { 907 int ctry; 908 YYParseState *save = yyps->save; 909 #if YYDEBUG 910 if (yydebug) 911 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n", 912 YYDEBUGSTR, yydepth, yystate, yyps->save->state, 913 (int)(yylvp - yylvals - yyps->save->lexeme)); 914 #endif 915 /* Memorize most forward-looking error state in case it's really an error. */ 916 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals) 917 { 918 /* Free old saved error context state */ 919 if (yyerrctx) yyFreeState(yyerrctx); 920 /* Create and fill out new saved error context state */ 921 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 922 if (yyerrctx == NULL) goto yyenomem; 923 yyerrctx->save = yyps->save; 924 yyerrctx->state = yystate; 925 yyerrctx->errflag = yyerrflag; 926 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 927 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 928 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base); 929 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 930 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 931 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 932 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 933 #endif 934 yyerrctx->lexeme = yylvp - yylvals; 935 } 936 yylvp = yylvals + save->lexeme; 937 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 938 yylpp = yylpsns + save->lexeme; 939 #endif 940 yylexp = yylexemes + save->lexeme; 941 yychar = YYEMPTY; 942 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 943 memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 944 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base); 945 memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 946 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 947 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 948 memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 949 #endif 950 ctry = ++save->ctry; 951 yystate = save->state; 952 /* We tried shift, try reduce now */ 953 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce; 954 yyps->save = save->save; 955 save->save = NULL; 956 yyFreeState(save); 957 958 /* Nothing left on the stack -- error */ 959 if (!yyps->save) 960 { 961 #if YYDEBUG 962 if (yydebug) 963 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n", 964 YYPREFIX, yydepth); 965 #endif 966 /* Restore state as it was in the most forward-advanced error */ 967 yylvp = yylvals + yyerrctx->lexeme; 968 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 969 yylpp = yylpsns + yyerrctx->lexeme; 970 #endif 971 yylexp = yylexemes + yyerrctx->lexeme; 972 yychar = yylexp[-1]; 973 yylval = yylvp[-1]; 974 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 975 yylloc = yylpp[-1]; 976 #endif 977 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 978 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 979 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base); 980 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 981 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 982 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 983 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 984 #endif 985 yystate = yyerrctx->state; 986 yyFreeState(yyerrctx); 987 yyerrctx = NULL; 988 } 989 yynewerrflag = 1; 990 } 991 if (yynewerrflag == 0) goto yyinrecovery; 992 #endif /* YYBTYACC */ 993 994 YYERROR_CALL("syntax error"); 995 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 996 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */ 997 #endif 998 999 #if !YYBTYACC 1000 goto yyerrlab; 1001 yyerrlab: 1002 #endif 1003 ++yynerrs; 1004 1005 yyinrecovery: 1006 if (yyerrflag < 3) 1007 { 1008 yyerrflag = 3; 1009 for (;;) 1010 { 1011 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 && 1012 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE) 1013 { 1014 #if YYDEBUG 1015 if (yydebug) 1016 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n", 1017 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]); 1018 #endif 1019 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1020 yystate = yytable[yyn]; 1021 *++yystack.s_mark = yytable[yyn]; 1022 *++yystack.l_mark = yylval; 1023 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1024 /* lookahead position is error end position */ 1025 yyerror_loc_range[1] = yylloc; 1026 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */ 1027 *++yystack.p_mark = yyloc; 1028 #endif 1029 goto yyloop; 1030 } 1031 else 1032 { 1033 #if YYDEBUG 1034 if (yydebug) 1035 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n", 1036 YYDEBUGSTR, yydepth, *yystack.s_mark); 1037 #endif 1038 if (yystack.s_mark <= yystack.s_base) goto yyabort; 1039 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1040 /* the current TOS position is the error start position */ 1041 yyerror_loc_range[0] = *yystack.p_mark; 1042 #endif 1043 #if defined(YYDESTRUCT_CALL) 1044 #if YYBTYACC 1045 if (!yytrial) 1046 #endif /* YYBTYACC */ 1047 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1048 YYDESTRUCT_CALL("error: discarding state", 1049 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark); 1050 #else 1051 YYDESTRUCT_CALL("error: discarding state", 1052 yystos[*yystack.s_mark], yystack.l_mark); 1053 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1054 #endif /* defined(YYDESTRUCT_CALL) */ 1055 --yystack.s_mark; 1056 --yystack.l_mark; 1057 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1058 --yystack.p_mark; 1059 #endif 1060 } 1061 } 1062 } 1063 else 1064 { 1065 if (yychar == YYEOF) goto yyabort; 1066 #if YYDEBUG 1067 if (yydebug) 1068 { 1069 yys = yyname[YYTRANSLATE(yychar)]; 1070 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n", 1071 YYDEBUGSTR, yydepth, yystate, yychar, yys); 1072 } 1073 #endif 1074 #if defined(YYDESTRUCT_CALL) 1075 #if YYBTYACC 1076 if (!yytrial) 1077 #endif /* YYBTYACC */ 1078 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1079 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc); 1080 #else 1081 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval); 1082 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1083 #endif /* defined(YYDESTRUCT_CALL) */ 1084 yychar = YYEMPTY; 1085 goto yyloop; 1086 } 1087 1088 yyreduce: 1089 yym = yylen[yyn]; 1090 #if YYDEBUG 1091 if (yydebug) 1092 { 1093 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)", 1094 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]); 1095 #ifdef YYSTYPE_TOSTRING 1096 #if YYBTYACC 1097 if (!yytrial) 1098 #endif /* YYBTYACC */ 1099 if (yym > 0) 1100 { 1101 int i; 1102 fputc('<', stderr); 1103 for (i = yym; i > 0; i--) 1104 { 1105 if (i != yym) fputs(", ", stderr); 1106 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]], 1107 yystack.l_mark[1-i]), stderr); 1108 } 1109 fputc('>', stderr); 1110 } 1111 #endif 1112 fputc('\n', stderr); 1113 } 1114 #endif 1115 if (yym > 0) 1116 yyval = yystack.l_mark[1-yym]; 1117 else 1118 memset(&yyval, 0, sizeof yyval); 1119 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1120 1121 /* Perform position reduction */ 1122 memset(&yyloc, 0, sizeof(yyloc)); 1123 #if YYBTYACC 1124 if (!yytrial) 1125 #endif /* YYBTYACC */ 1126 { 1127 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym); 1128 /* just in case YYERROR is invoked within the action, save 1129 the start of the rhs as the error start position */ 1130 yyerror_loc_range[0] = yystack.p_mark[1-yym]; 1131 } 1132 #endif 1133 1134 switch (yyn) 1135 { 1136 case 3: 1137 #line 28 "calc.y" 1138 { yyerrok ; } 1139 break; 1140 case 4: 1141 #line 32 "calc.y" 1142 { printf("%d\n",yystack.l_mark[0]);} 1143 break; 1144 case 5: 1145 #line 34 "calc.y" 1146 { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; } 1147 break; 1148 case 6: 1149 #line 38 "calc.y" 1150 { yyval = yystack.l_mark[-1]; } 1151 break; 1152 case 7: 1153 #line 40 "calc.y" 1154 { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; } 1155 break; 1156 case 8: 1157 #line 42 "calc.y" 1158 { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; } 1159 break; 1160 case 9: 1161 #line 44 "calc.y" 1162 { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; } 1163 break; 1164 case 10: 1165 #line 46 "calc.y" 1166 { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; } 1167 break; 1168 case 11: 1169 #line 48 "calc.y" 1170 { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; } 1171 break; 1172 case 12: 1173 #line 50 "calc.y" 1174 { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; } 1175 break; 1176 case 13: 1177 #line 52 "calc.y" 1178 { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; } 1179 break; 1180 case 14: 1181 #line 54 "calc.y" 1182 { yyval = - yystack.l_mark[0]; } 1183 break; 1184 case 15: 1185 #line 56 "calc.y" 1186 { yyval = regs[yystack.l_mark[0]]; } 1187 break; 1188 case 17: 1189 #line 61 "calc.y" 1190 { yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; } 1191 break; 1192 case 18: 1193 #line 63 "calc.y" 1194 { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; } 1195 break; 1196 #line 1197 "calc.tab.c" 1197 default: 1198 break; 1199 } 1200 yystack.s_mark -= yym; 1201 yystate = *yystack.s_mark; 1202 yystack.l_mark -= yym; 1203 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1204 yystack.p_mark -= yym; 1205 #endif 1206 yym = yylhs[yyn]; 1207 if (yystate == 0 && yym == 0) 1208 { 1209 #if YYDEBUG 1210 if (yydebug) 1211 { 1212 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1213 #ifdef YYSTYPE_TOSTRING 1214 #if YYBTYACC 1215 if (!yytrial) 1216 #endif /* YYBTYACC */ 1217 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval)); 1218 #endif 1219 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL); 1220 } 1221 #endif 1222 yystate = YYFINAL; 1223 *++yystack.s_mark = YYFINAL; 1224 *++yystack.l_mark = yyval; 1225 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1226 *++yystack.p_mark = yyloc; 1227 #endif 1228 if (yychar < 0) 1229 { 1230 #if YYBTYACC 1231 do { 1232 if (yylvp < yylve) 1233 { 1234 /* we're currently re-reading tokens */ 1235 yylval = *yylvp++; 1236 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1237 yylloc = *yylpp++; 1238 #endif 1239 yychar = *yylexp++; 1240 break; 1241 } 1242 if (yyps->save) 1243 { 1244 /* in trial mode; save scanner results for future parse attempts */ 1245 if (yylvp == yylvlim) 1246 { /* Enlarge lexical value queue */ 1247 int p = yylvp - yylvals; 1248 int s = yylvlim - yylvals; 1249 1250 s += YYLVQUEUEGROWTH; 1251 if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) 1252 goto yyenomem; 1253 if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) 1254 goto yyenomem; 1255 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1256 if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) 1257 goto yyenomem; 1258 #endif 1259 yylvp = yylve = yylvals + p; 1260 yylvlim = yylvals + s; 1261 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1262 yylpp = yylpe = yylpsns + p; 1263 yylplim = yylpsns + s; 1264 #endif 1265 yylexp = yylexemes + p; 1266 } 1267 *yylexp = (short) YYLEX; 1268 *yylvp++ = yylval; 1269 yylve++; 1270 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1271 *yylpp++ = yylloc; 1272 yylpe++; 1273 #endif 1274 yychar = *yylexp++; 1275 break; 1276 } 1277 /* normal operation, no conflict encountered */ 1278 #endif /* YYBTYACC */ 1279 yychar = YYLEX; 1280 #if YYBTYACC 1281 } while (0); 1282 #endif /* YYBTYACC */ 1283 if (yychar < 0) yychar = YYEOF; 1284 /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */ 1285 #if YYDEBUG 1286 if (yydebug) 1287 { 1288 yys = yyname[YYTRANSLATE(yychar)]; 1289 fprintf(stderr, "%s[%d]: state %d, reading %d (%s)\n", 1290 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys); 1291 } 1292 #endif 1293 } 1294 if (yychar == YYEOF) goto yyaccept; 1295 goto yyloop; 1296 } 1297 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 && 1298 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate) 1299 yystate = yytable[yyn]; 1300 else 1301 yystate = yydgoto[yym]; 1302 #if YYDEBUG 1303 if (yydebug) 1304 { 1305 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1306 #ifdef YYSTYPE_TOSTRING 1307 #if YYBTYACC 1308 if (!yytrial) 1309 #endif /* YYBTYACC */ 1310 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval)); 1311 #endif 1312 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate); 1313 } 1314 #endif 1315 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1316 *++yystack.s_mark = (short) yystate; 1317 *++yystack.l_mark = yyval; 1318 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1319 *++yystack.p_mark = yyloc; 1320 #endif 1321 goto yyloop; 1322 #if YYBTYACC 1323 1324 /* Reduction declares that this path is valid. Set yypath and do a full parse */ 1325 yyvalid: 1326 if (yypath) YYABORT; 1327 while (yyps->save) 1328 { 1329 YYParseState *save = yyps->save; 1330 yyps->save = save->save; 1331 save->save = yypath; 1332 yypath = save; 1333 } 1334 #if YYDEBUG 1335 if (yydebug) 1336 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n", 1337 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme)); 1338 #endif 1339 if (yyerrctx) 1340 { 1341 yyFreeState(yyerrctx); 1342 yyerrctx = NULL; 1343 } 1344 yylvp = yylvals + yypath->lexeme; 1345 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1346 yylpp = yylpsns + yypath->lexeme; 1347 #endif 1348 yylexp = yylexemes + yypath->lexeme; 1349 yychar = YYEMPTY; 1350 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 1351 memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 1352 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base); 1353 memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1354 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1355 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 1356 memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1357 #endif 1358 yystate = yypath->state; 1359 goto yyloop; 1360 #endif /* YYBTYACC */ 1361 1362 yyoverflow: 1363 YYERROR_CALL("yacc stack overflow"); 1364 #if YYBTYACC 1365 goto yyabort_nomem; 1366 yyenomem: 1367 YYERROR_CALL("memory exhausted"); 1368 yyabort_nomem: 1369 #endif /* YYBTYACC */ 1370 yyresult = 2; 1371 goto yyreturn; 1372 1373 yyabort: 1374 yyresult = 1; 1375 goto yyreturn; 1376 1377 yyaccept: 1378 #if YYBTYACC 1379 if (yyps->save) goto yyvalid; 1380 #endif /* YYBTYACC */ 1381 yyresult = 0; 1382 1383 yyreturn: 1384 #if defined(YYDESTRUCT_CALL) 1385 if (yychar != YYEOF && yychar != YYEMPTY) 1386 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1387 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc); 1388 #else 1389 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval); 1390 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1391 1392 { 1393 YYSTYPE *pv; 1394 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1395 YYLTYPE *pp; 1396 1397 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp) 1398 YYDESTRUCT_CALL("cleanup: discarding state", 1399 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp); 1400 #else 1401 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv) 1402 YYDESTRUCT_CALL("cleanup: discarding state", 1403 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv); 1404 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1405 } 1406 #endif /* defined(YYDESTRUCT_CALL) */ 1407 1408 #if YYBTYACC 1409 if (yyerrctx) 1410 { 1411 yyFreeState(yyerrctx); 1412 yyerrctx = NULL; 1413 } 1414 while (yyps) 1415 { 1416 YYParseState *save = yyps; 1417 yyps = save->save; 1418 save->save = NULL; 1419 yyFreeState(save); 1420 } 1421 while (yypath) 1422 { 1423 YYParseState *save = yypath; 1424 yypath = save->save; 1425 save->save = NULL; 1426 yyFreeState(save); 1427 } 1428 #endif /* YYBTYACC */ 1429 yyfreestack(&yystack); 1430 return (yyresult); 1431 } 1432