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