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