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 679 #if YYBTYACC 680 yyps = yyNewState(0); if (yyps == 0) goto yyenomem; 681 yyps->save = 0; 682 #endif /* YYBTYACC */ 683 yym = 0; 684 yyn = 0; 685 yynerrs = 0; 686 yyerrflag = 0; 687 yychar = YYEMPTY; 688 yystate = 0; 689 690 #if YYPURE 691 memset(&yystack, 0, sizeof(yystack)); 692 #endif 693 694 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 695 yystack.s_mark = yystack.s_base; 696 yystack.l_mark = yystack.l_base; 697 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 698 yystack.p_mark = yystack.p_base; 699 #endif 700 yystate = 0; 701 *yystack.s_mark = 0; 702 703 yyloop: 704 if ((yyn = yydefred[yystate]) != 0) goto yyreduce; 705 if (yychar < 0) 706 { 707 #if YYBTYACC 708 do { 709 if (yylvp < yylve) 710 { 711 /* we're currently re-reading tokens */ 712 yylval = *yylvp++; 713 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 714 yylloc = *yylpp++; 715 #endif 716 yychar = *yylexp++; 717 break; 718 } 719 if (yyps->save) 720 { 721 /* in trial mode; save scanner results for future parse attempts */ 722 if (yylvp == yylvlim) 723 { /* Enlarge lexical value queue */ 724 size_t p = (size_t) (yylvp - yylvals); 725 size_t s = (size_t) (yylvlim - yylvals); 726 727 s += YYLVQUEUEGROWTH; 728 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem; 729 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem; 730 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 731 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem; 732 #endif 733 yylvp = yylve = yylvals + p; 734 yylvlim = yylvals + s; 735 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 736 yylpp = yylpe = yylpsns + p; 737 yylplim = yylpsns + s; 738 #endif 739 yylexp = yylexemes + p; 740 } 741 *yylexp = (YYINT) YYLEX; 742 *yylvp++ = yylval; 743 yylve++; 744 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 745 *yylpp++ = yylloc; 746 yylpe++; 747 #endif 748 yychar = *yylexp++; 749 break; 750 } 751 /* normal operation, no conflict encountered */ 752 #endif /* YYBTYACC */ 753 yychar = YYLEX; 754 #if YYBTYACC 755 } while (0); 756 #endif /* YYBTYACC */ 757 if (yychar < 0) yychar = YYEOF; 758 #if YYDEBUG 759 if (yydebug) 760 { 761 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 762 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)", 763 YYDEBUGSTR, yydepth, yystate, yychar, yys); 764 #ifdef YYSTYPE_TOSTRING 765 #if YYBTYACC 766 if (!yytrial) 767 #endif /* YYBTYACC */ 768 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval)); 769 #endif 770 fputc('\n', stderr); 771 } 772 #endif 773 } 774 #if YYBTYACC 775 776 /* Do we have a conflict? */ 777 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 && 778 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 779 { 780 YYINT ctry; 781 782 if (yypath) 783 { 784 YYParseState *save; 785 #if YYDEBUG 786 if (yydebug) 787 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n", 788 YYDEBUGSTR, yydepth, yystate); 789 #endif 790 /* Switch to the next conflict context */ 791 save = yypath; 792 yypath = save->save; 793 save->save = NULL; 794 ctry = save->ctry; 795 if (save->state != yystate) YYABORT; 796 yyFreeState(save); 797 798 } 799 else 800 { 801 802 /* Unresolved conflict - start/continue trial parse */ 803 YYParseState *save; 804 #if YYDEBUG 805 if (yydebug) 806 { 807 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate); 808 if (yyps->save) 809 fputs("ALREADY in conflict, continuing trial parse.\n", stderr); 810 else 811 fputs("Starting trial parse.\n", stderr); 812 } 813 #endif 814 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 815 if (save == NULL) goto yyenomem; 816 save->save = yyps->save; 817 save->state = yystate; 818 save->errflag = yyerrflag; 819 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 820 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 821 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base); 822 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 823 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 824 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 825 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 826 #endif 827 ctry = yytable[yyn]; 828 if (yyctable[ctry] == -1) 829 { 830 #if YYDEBUG 831 if (yydebug && yychar >= YYEOF) 832 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth); 833 #endif 834 ctry++; 835 } 836 save->ctry = ctry; 837 if (yyps->save == NULL) 838 { 839 /* If this is a first conflict in the stack, start saving lexemes */ 840 if (!yylexemes) 841 { 842 yylexemes = malloc((YYLVQUEUEGROWTH) * sizeof(YYINT)); 843 if (yylexemes == NULL) goto yyenomem; 844 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE)); 845 if (yylvals == NULL) goto yyenomem; 846 yylvlim = yylvals + YYLVQUEUEGROWTH; 847 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 848 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE)); 849 if (yylpsns == NULL) goto yyenomem; 850 yylplim = yylpsns + YYLVQUEUEGROWTH; 851 #endif 852 } 853 if (yylvp == yylve) 854 { 855 yylvp = yylve = yylvals; 856 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 857 yylpp = yylpe = yylpsns; 858 #endif 859 yylexp = yylexemes; 860 if (yychar >= YYEOF) 861 { 862 *yylve++ = yylval; 863 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 864 *yylpe++ = yylloc; 865 #endif 866 *yylexp = (YYINT) yychar; 867 yychar = YYEMPTY; 868 } 869 } 870 } 871 if (yychar >= YYEOF) 872 { 873 yylvp--; 874 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 875 yylpp--; 876 #endif 877 yylexp--; 878 yychar = YYEMPTY; 879 } 880 save->lexeme = (int) (yylvp - yylvals); 881 yyps->save = save; 882 } 883 if (yytable[yyn] == ctry) 884 { 885 #if YYDEBUG 886 if (yydebug) 887 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 888 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]); 889 #endif 890 if (yychar < 0) 891 { 892 yylvp++; 893 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 894 yylpp++; 895 #endif 896 yylexp++; 897 } 898 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) 899 goto yyoverflow; 900 yystate = yyctable[ctry]; 901 *++yystack.s_mark = (YYINT) yystate; 902 *++yystack.l_mark = yylval; 903 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 904 *++yystack.p_mark = yylloc; 905 #endif 906 yychar = YYEMPTY; 907 if (yyerrflag > 0) --yyerrflag; 908 goto yyloop; 909 } 910 else 911 { 912 yyn = yyctable[ctry]; 913 goto yyreduce; 914 } 915 } /* End of code dealing with conflicts */ 916 #endif /* YYBTYACC */ 917 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 && 918 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 919 { 920 #if YYDEBUG 921 if (yydebug) 922 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 923 YYDEBUGSTR, yydepth, yystate, yytable[yyn]); 924 #endif 925 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 926 yystate = yytable[yyn]; 927 *++yystack.s_mark = yytable[yyn]; 928 *++yystack.l_mark = yylval; 929 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 930 *++yystack.p_mark = yylloc; 931 #endif 932 yychar = YYEMPTY; 933 if (yyerrflag > 0) --yyerrflag; 934 goto yyloop; 935 } 936 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 && 937 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 938 { 939 yyn = yytable[yyn]; 940 goto yyreduce; 941 } 942 if (yyerrflag != 0) goto yyinrecovery; 943 #if YYBTYACC 944 945 yynewerrflag = 1; 946 goto yyerrhandler; 947 goto yyerrlab; /* redundant goto avoids 'unused label' warning */ 948 949 yyerrlab: 950 /* explicit YYERROR from an action -- pop the rhs of the rule reduced 951 * before looking for error recovery */ 952 yystack.s_mark -= yym; 953 yystate = *yystack.s_mark; 954 yystack.l_mark -= yym; 955 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 956 yystack.p_mark -= yym; 957 #endif 958 959 yynewerrflag = 0; 960 yyerrhandler: 961 while (yyps->save) 962 { 963 int ctry; 964 YYParseState *save = yyps->save; 965 #if YYDEBUG 966 if (yydebug) 967 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n", 968 YYDEBUGSTR, yydepth, yystate, yyps->save->state, 969 (int)(yylvp - yylvals - yyps->save->lexeme)); 970 #endif 971 /* Memorize most forward-looking error state in case it's really an error. */ 972 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals) 973 { 974 /* Free old saved error context state */ 975 if (yyerrctx) yyFreeState(yyerrctx); 976 /* Create and fill out new saved error context state */ 977 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 978 if (yyerrctx == NULL) goto yyenomem; 979 yyerrctx->save = yyps->save; 980 yyerrctx->state = yystate; 981 yyerrctx->errflag = yyerrflag; 982 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 983 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 984 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base); 985 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 986 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 987 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 988 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 989 #endif 990 yyerrctx->lexeme = (int) (yylvp - yylvals); 991 } 992 yylvp = yylvals + save->lexeme; 993 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 994 yylpp = yylpsns + save->lexeme; 995 #endif 996 yylexp = yylexemes + save->lexeme; 997 yychar = YYEMPTY; 998 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 999 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1000 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base); 1001 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1002 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1003 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 1004 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1005 #endif 1006 ctry = ++save->ctry; 1007 yystate = save->state; 1008 /* We tried shift, try reduce now */ 1009 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce; 1010 yyps->save = save->save; 1011 save->save = NULL; 1012 yyFreeState(save); 1013 1014 /* Nothing left on the stack -- error */ 1015 if (!yyps->save) 1016 { 1017 #if YYDEBUG 1018 if (yydebug) 1019 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n", 1020 YYPREFIX, yydepth); 1021 #endif 1022 /* Restore state as it was in the most forward-advanced error */ 1023 yylvp = yylvals + yyerrctx->lexeme; 1024 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1025 yylpp = yylpsns + yyerrctx->lexeme; 1026 #endif 1027 yylexp = yylexemes + yyerrctx->lexeme; 1028 yychar = yylexp[-1]; 1029 yylval = yylvp[-1]; 1030 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1031 yylloc = yylpp[-1]; 1032 #endif 1033 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 1034 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1035 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base); 1036 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1037 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1038 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 1039 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1040 #endif 1041 yystate = yyerrctx->state; 1042 yyFreeState(yyerrctx); 1043 yyerrctx = NULL; 1044 } 1045 yynewerrflag = 1; 1046 } 1047 if (yynewerrflag == 0) goto yyinrecovery; 1048 #endif /* YYBTYACC */ 1049 1050 YYERROR_CALL("syntax error"); 1051 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1052 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */ 1053 #endif 1054 1055 #if !YYBTYACC 1056 goto yyerrlab; /* redundant goto avoids 'unused label' warning */ 1057 yyerrlab: 1058 #endif 1059 ++yynerrs; 1060 1061 yyinrecovery: 1062 if (yyerrflag < 3) 1063 { 1064 yyerrflag = 3; 1065 for (;;) 1066 { 1067 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 && 1068 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE) 1069 { 1070 #if YYDEBUG 1071 if (yydebug) 1072 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n", 1073 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]); 1074 #endif 1075 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1076 yystate = yytable[yyn]; 1077 *++yystack.s_mark = yytable[yyn]; 1078 *++yystack.l_mark = yylval; 1079 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1080 /* lookahead position is error end position */ 1081 yyerror_loc_range[1] = yylloc; 1082 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */ 1083 *++yystack.p_mark = yyloc; 1084 #endif 1085 goto yyloop; 1086 } 1087 else 1088 { 1089 #if YYDEBUG 1090 if (yydebug) 1091 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n", 1092 YYDEBUGSTR, yydepth, *yystack.s_mark); 1093 #endif 1094 if (yystack.s_mark <= yystack.s_base) goto yyabort; 1095 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1096 /* the current TOS position is the error start position */ 1097 yyerror_loc_range[0] = *yystack.p_mark; 1098 #endif 1099 #if defined(YYDESTRUCT_CALL) 1100 #if YYBTYACC 1101 if (!yytrial) 1102 #endif /* YYBTYACC */ 1103 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1104 YYDESTRUCT_CALL("error: discarding state", 1105 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark); 1106 #else 1107 YYDESTRUCT_CALL("error: discarding state", 1108 yystos[*yystack.s_mark], yystack.l_mark); 1109 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1110 #endif /* defined(YYDESTRUCT_CALL) */ 1111 --yystack.s_mark; 1112 --yystack.l_mark; 1113 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1114 --yystack.p_mark; 1115 #endif 1116 } 1117 } 1118 } 1119 else 1120 { 1121 if (yychar == YYEOF) goto yyabort; 1122 #if YYDEBUG 1123 if (yydebug) 1124 { 1125 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 1126 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n", 1127 YYDEBUGSTR, yydepth, yystate, yychar, yys); 1128 } 1129 #endif 1130 #if defined(YYDESTRUCT_CALL) 1131 #if YYBTYACC 1132 if (!yytrial) 1133 #endif /* YYBTYACC */ 1134 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1135 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc); 1136 #else 1137 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval); 1138 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1139 #endif /* defined(YYDESTRUCT_CALL) */ 1140 yychar = YYEMPTY; 1141 goto yyloop; 1142 } 1143 1144 yyreduce: 1145 yym = yylen[yyn]; 1146 #if YYDEBUG 1147 if (yydebug) 1148 { 1149 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)", 1150 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]); 1151 #ifdef YYSTYPE_TOSTRING 1152 #if YYBTYACC 1153 if (!yytrial) 1154 #endif /* YYBTYACC */ 1155 if (yym > 0) 1156 { 1157 int i; 1158 fputc('<', stderr); 1159 for (i = yym; i > 0; i--) 1160 { 1161 if (i != yym) fputs(", ", stderr); 1162 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]], 1163 yystack.l_mark[1-i]), stderr); 1164 } 1165 fputc('>', stderr); 1166 } 1167 #endif 1168 fputc('\n', stderr); 1169 } 1170 #endif 1171 if (yym > 0) 1172 yyval = yystack.l_mark[1-yym]; 1173 else 1174 memset(&yyval, 0, sizeof yyval); 1175 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1176 1177 /* Perform position reduction */ 1178 memset(&yyloc, 0, sizeof(yyloc)); 1179 #if YYBTYACC 1180 if (!yytrial) 1181 #endif /* YYBTYACC */ 1182 { 1183 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym); 1184 /* just in case YYERROR is invoked within the action, save 1185 the start of the rhs as the error start position */ 1186 yyerror_loc_range[0] = yystack.p_mark[1-yym]; 1187 } 1188 #endif 1189 1190 switch (yyn) 1191 { 1192 case 3: 1193 #line 35 "quote_calc.y" 1194 { yyerrok ; } 1195 break; 1196 case 4: 1197 #line 39 "quote_calc.y" 1198 { printf("%d\n",yystack.l_mark[0]);} 1199 break; 1200 case 5: 1201 #line 41 "quote_calc.y" 1202 { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; } 1203 break; 1204 case 6: 1205 #line 45 "quote_calc.y" 1206 { yyval = yystack.l_mark[-1]; } 1207 break; 1208 case 7: 1209 #line 47 "quote_calc.y" 1210 { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; } 1211 break; 1212 case 8: 1213 #line 49 "quote_calc.y" 1214 { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; } 1215 break; 1216 case 9: 1217 #line 51 "quote_calc.y" 1218 { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; } 1219 break; 1220 case 10: 1221 #line 53 "quote_calc.y" 1222 { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; } 1223 break; 1224 case 11: 1225 #line 55 "quote_calc.y" 1226 { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; } 1227 break; 1228 case 12: 1229 #line 57 "quote_calc.y" 1230 { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; } 1231 break; 1232 case 13: 1233 #line 59 "quote_calc.y" 1234 { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; } 1235 break; 1236 case 14: 1237 #line 61 "quote_calc.y" 1238 { yyval = - yystack.l_mark[0]; } 1239 break; 1240 case 15: 1241 #line 63 "quote_calc.y" 1242 { yyval = regs[yystack.l_mark[0]]; } 1243 break; 1244 case 17: 1245 #line 68 "quote_calc.y" 1246 { yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; } 1247 break; 1248 case 18: 1249 #line 70 "quote_calc.y" 1250 { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; } 1251 break; 1252 #line 1253 "quote_calc-s.tab.c" 1253 default: 1254 break; 1255 } 1256 yystack.s_mark -= yym; 1257 yystate = *yystack.s_mark; 1258 yystack.l_mark -= yym; 1259 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1260 yystack.p_mark -= yym; 1261 #endif 1262 yym = yylhs[yyn]; 1263 if (yystate == 0 && yym == 0) 1264 { 1265 #if YYDEBUG 1266 if (yydebug) 1267 { 1268 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1269 #ifdef YYSTYPE_TOSTRING 1270 #if YYBTYACC 1271 if (!yytrial) 1272 #endif /* YYBTYACC */ 1273 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval)); 1274 #endif 1275 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL); 1276 } 1277 #endif 1278 yystate = YYFINAL; 1279 *++yystack.s_mark = YYFINAL; 1280 *++yystack.l_mark = yyval; 1281 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1282 *++yystack.p_mark = yyloc; 1283 #endif 1284 if (yychar < 0) 1285 { 1286 #if YYBTYACC 1287 do { 1288 if (yylvp < yylve) 1289 { 1290 /* we're currently re-reading tokens */ 1291 yylval = *yylvp++; 1292 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1293 yylloc = *yylpp++; 1294 #endif 1295 yychar = *yylexp++; 1296 break; 1297 } 1298 if (yyps->save) 1299 { 1300 /* in trial mode; save scanner results for future parse attempts */ 1301 if (yylvp == yylvlim) 1302 { /* Enlarge lexical value queue */ 1303 size_t p = (size_t) (yylvp - yylvals); 1304 size_t s = (size_t) (yylvlim - yylvals); 1305 1306 s += YYLVQUEUEGROWTH; 1307 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL) 1308 goto yyenomem; 1309 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) 1310 goto yyenomem; 1311 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1312 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) 1313 goto yyenomem; 1314 #endif 1315 yylvp = yylve = yylvals + p; 1316 yylvlim = yylvals + s; 1317 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1318 yylpp = yylpe = yylpsns + p; 1319 yylplim = yylpsns + s; 1320 #endif 1321 yylexp = yylexemes + p; 1322 } 1323 *yylexp = (YYINT) YYLEX; 1324 *yylvp++ = yylval; 1325 yylve++; 1326 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1327 *yylpp++ = yylloc; 1328 yylpe++; 1329 #endif 1330 yychar = *yylexp++; 1331 break; 1332 } 1333 /* normal operation, no conflict encountered */ 1334 #endif /* YYBTYACC */ 1335 yychar = YYLEX; 1336 #if YYBTYACC 1337 } while (0); 1338 #endif /* YYBTYACC */ 1339 if (yychar < 0) yychar = YYEOF; 1340 #if YYDEBUG 1341 if (yydebug) 1342 { 1343 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 1344 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n", 1345 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys); 1346 } 1347 #endif 1348 } 1349 if (yychar == YYEOF) goto yyaccept; 1350 goto yyloop; 1351 } 1352 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 && 1353 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate) 1354 yystate = yytable[yyn]; 1355 else 1356 yystate = yydgoto[yym]; 1357 #if YYDEBUG 1358 if (yydebug) 1359 { 1360 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1361 #ifdef YYSTYPE_TOSTRING 1362 #if YYBTYACC 1363 if (!yytrial) 1364 #endif /* YYBTYACC */ 1365 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval)); 1366 #endif 1367 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate); 1368 } 1369 #endif 1370 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1371 *++yystack.s_mark = (YYINT) yystate; 1372 *++yystack.l_mark = yyval; 1373 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1374 *++yystack.p_mark = yyloc; 1375 #endif 1376 goto yyloop; 1377 #if YYBTYACC 1378 1379 /* Reduction declares that this path is valid. Set yypath and do a full parse */ 1380 yyvalid: 1381 if (yypath) YYABORT; 1382 while (yyps->save) 1383 { 1384 YYParseState *save = yyps->save; 1385 yyps->save = save->save; 1386 save->save = yypath; 1387 yypath = save; 1388 } 1389 #if YYDEBUG 1390 if (yydebug) 1391 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n", 1392 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme)); 1393 #endif 1394 if (yyerrctx) 1395 { 1396 yyFreeState(yyerrctx); 1397 yyerrctx = NULL; 1398 } 1399 yylvp = yylvals + yypath->lexeme; 1400 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1401 yylpp = yylpsns + yypath->lexeme; 1402 #endif 1403 yylexp = yylexemes + yypath->lexeme; 1404 yychar = YYEMPTY; 1405 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 1406 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1407 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base); 1408 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1409 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1410 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 1411 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1412 #endif 1413 yystate = yypath->state; 1414 goto yyloop; 1415 #endif /* YYBTYACC */ 1416 1417 yyoverflow: 1418 YYERROR_CALL("yacc stack overflow"); 1419 #if YYBTYACC 1420 goto yyabort_nomem; 1421 yyenomem: 1422 YYERROR_CALL("memory exhausted"); 1423 yyabort_nomem: 1424 #endif /* YYBTYACC */ 1425 yyresult = 2; 1426 goto yyreturn; 1427 1428 yyabort: 1429 yyresult = 1; 1430 goto yyreturn; 1431 1432 yyaccept: 1433 #if YYBTYACC 1434 if (yyps->save) goto yyvalid; 1435 #endif /* YYBTYACC */ 1436 yyresult = 0; 1437 1438 yyreturn: 1439 #if defined(YYDESTRUCT_CALL) 1440 if (yychar != YYEOF && yychar != YYEMPTY) 1441 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1442 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc); 1443 #else 1444 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval); 1445 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1446 1447 { 1448 YYSTYPE *pv; 1449 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1450 YYLTYPE *pp; 1451 1452 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp) 1453 YYDESTRUCT_CALL("cleanup: discarding state", 1454 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp); 1455 #else 1456 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv) 1457 YYDESTRUCT_CALL("cleanup: discarding state", 1458 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv); 1459 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1460 } 1461 #endif /* defined(YYDESTRUCT_CALL) */ 1462 1463 #if YYBTYACC 1464 if (yyerrctx) 1465 { 1466 yyFreeState(yyerrctx); 1467 yyerrctx = NULL; 1468 } 1469 while (yyps) 1470 { 1471 YYParseState *save = yyps; 1472 yyps = save->save; 1473 save->save = NULL; 1474 yyFreeState(save); 1475 } 1476 while (yypath) 1477 { 1478 YYParseState *save = yypath; 1479 yypath = save->save; 1480 save->save = NULL; 1481 yyFreeState(save); 1482 } 1483 #endif /* YYBTYACC */ 1484 yyfreestack(&yystack); 1485 return (yyresult); 1486 } 1487