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