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