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