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