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