1 /* $NetBSD: pure_calc.tab.c,v 1.1.1.3 2016/01/09 21:59:46 christos Exp $ */ 2 3 /* original parser id follows */ 4 /* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ 5 /* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */ 6 7 #define YYBYACC 1 8 #define YYMAJOR 1 9 #define YYMINOR 9 10 #define YYCHECK "yyyymmdd" 11 12 #define YYEMPTY (-1) 13 #define yyclearin (yychar = YYEMPTY) 14 #define yyerrok (yyerrflag = 0) 15 #define YYRECOVERING() (yyerrflag != 0) 16 #define YYENOMEM (-2) 17 #define YYEOF 0 18 #undef YYBTYACC 19 #define YYBTYACC 0 20 #define YYDEBUGSTR YYPREFIX "debug" 21 22 #ifndef yyparse 23 #define yyparse calc_parse 24 #endif /* yyparse */ 25 26 #ifndef yylex 27 #define yylex calc_lex 28 #endif /* yylex */ 29 30 #ifndef yyerror 31 #define yyerror calc_error 32 #endif /* yyerror */ 33 34 #ifndef yychar 35 #define yychar calc_char 36 #endif /* yychar */ 37 38 #ifndef yyval 39 #define yyval calc_val 40 #endif /* yyval */ 41 42 #ifndef yylval 43 #define yylval calc_lval 44 #endif /* yylval */ 45 46 #ifndef yydebug 47 #define yydebug calc_debug 48 #endif /* yydebug */ 49 50 #ifndef yynerrs 51 #define yynerrs calc_nerrs 52 #endif /* yynerrs */ 53 54 #ifndef yyerrflag 55 #define yyerrflag calc_errflag 56 #endif /* yyerrflag */ 57 58 #ifndef yylhs 59 #define yylhs calc_lhs 60 #endif /* yylhs */ 61 62 #ifndef yylen 63 #define yylen calc_len 64 #endif /* yylen */ 65 66 #ifndef yydefred 67 #define yydefred calc_defred 68 #endif /* yydefred */ 69 70 #ifndef yystos 71 #define yystos calc_stos 72 #endif /* yystos */ 73 74 #ifndef yydgoto 75 #define yydgoto calc_dgoto 76 #endif /* yydgoto */ 77 78 #ifndef yysindex 79 #define yysindex calc_sindex 80 #endif /* yysindex */ 81 82 #ifndef yyrindex 83 #define yyrindex calc_rindex 84 #endif /* yyrindex */ 85 86 #ifndef yygindex 87 #define yygindex calc_gindex 88 #endif /* yygindex */ 89 90 #ifndef yytable 91 #define yytable calc_table 92 #endif /* yytable */ 93 94 #ifndef yycheck 95 #define yycheck calc_check 96 #endif /* yycheck */ 97 98 #ifndef yyname 99 #define yyname calc_name 100 #endif /* yyname */ 101 102 #ifndef yyrule 103 #define yyrule calc_rule 104 #endif /* yyrule */ 105 106 #if YYBTYACC 107 108 #ifndef yycindex 109 #define yycindex calc_cindex 110 #endif /* yycindex */ 111 112 #ifndef yyctable 113 #define yyctable calc_ctable 114 #endif /* yyctable */ 115 116 #endif /* YYBTYACC */ 117 118 #define YYPREFIX "calc_" 119 120 #define YYPURE 1 121 122 #line 2 "pure_calc.y" 123 # include <stdio.h> 124 # include <ctype.h> 125 126 int regs[26]; 127 int base; 128 129 #ifdef YYBISON 130 #define YYSTYPE int 131 #define YYLEX_PARAM &yylval 132 #define YYLEX_DECL() yylex(YYSTYPE *yylval) 133 #define YYERROR_DECL() yyerror(const char *s) 134 int YYLEX_DECL(); 135 static void YYERROR_DECL(); 136 #endif 137 138 #line 137 "pure_calc.tab.c" 139 140 #if ! defined(YYSTYPE) && ! defined(YYSTYPE_IS_DECLARED) 141 /* Default: YYSTYPE is the semantic value type. */ 142 typedef int YYSTYPE; 143 # define YYSTYPE_IS_DECLARED 1 144 #endif 145 146 /* compatibility with bison */ 147 #ifdef YYPARSE_PARAM 148 /* compatibility with FreeBSD */ 149 # ifdef YYPARSE_PARAM_TYPE 150 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM) 151 # else 152 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM) 153 # endif 154 #else 155 # define YYPARSE_DECL() yyparse(void) 156 #endif 157 158 /* Parameters sent to lex. */ 159 #ifdef YYLEX_PARAM 160 # ifdef YYLEX_PARAM_TYPE 161 # define YYLEX_DECL() yylex(YYSTYPE *yylval, YYLEX_PARAM_TYPE YYLEX_PARAM) 162 # else 163 # define YYLEX_DECL() yylex(YYSTYPE *yylval, void * YYLEX_PARAM) 164 # endif 165 # define YYLEX yylex(&yylval, YYLEX_PARAM) 166 #else 167 # define YYLEX_DECL() yylex(YYSTYPE *yylval) 168 # define YYLEX yylex(&yylval) 169 #endif 170 171 /* Parameters sent to yyerror. */ 172 #ifndef YYERROR_DECL 173 #define YYERROR_DECL() yyerror(const char *s) 174 #endif 175 #ifndef YYERROR_CALL 176 #define YYERROR_CALL(msg) yyerror(msg) 177 #endif 178 179 extern int YYPARSE_DECL(); 180 181 #define DIGIT 257 182 #define LETTER 258 183 #define UMINUS 259 184 #define YYERRCODE 256 185 typedef short YYINT; 186 static const YYINT calc_lhs[] = { -1, 187 0, 0, 0, 1, 1, 2, 2, 2, 2, 2, 188 2, 2, 2, 2, 2, 2, 3, 3, 189 }; 190 static const YYINT calc_len[] = { 2, 191 0, 3, 3, 1, 3, 3, 3, 3, 3, 3, 192 3, 3, 3, 2, 1, 1, 1, 2, 193 }; 194 static const YYINT calc_defred[] = { 1, 195 0, 0, 17, 0, 0, 0, 0, 0, 0, 3, 196 0, 15, 14, 0, 2, 0, 0, 0, 0, 0, 197 0, 0, 18, 0, 6, 0, 0, 0, 0, 9, 198 10, 11, 199 }; 200 static const YYINT calc_stos[] = { 0, 201 261, 256, 257, 258, 45, 40, 262, 263, 264, 10, 202 61, 258, 263, 263, 10, 124, 38, 43, 45, 42, 203 47, 37, 257, 263, 41, 263, 263, 263, 263, 263, 204 263, 263, 205 }; 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 short *s_base; 403 short *s_mark; 404 short *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 470 "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 short *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 = (short *)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 = (short *) malloc(size * sizeof(short)); 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 short *yylexp = 0; 651 652 static short *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 yynerrs = 0; 680 yyerrflag = 0; 681 yychar = YYEMPTY; 682 yystate = 0; 683 684 #if YYPURE 685 memset(&yystack, 0, sizeof(yystack)); 686 #endif 687 688 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 689 yystack.s_mark = yystack.s_base; 690 yystack.l_mark = yystack.l_base; 691 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 692 yystack.p_mark = yystack.p_base; 693 #endif 694 yystate = 0; 695 *yystack.s_mark = 0; 696 697 yyloop: 698 if ((yyn = yydefred[yystate]) != 0) goto yyreduce; 699 if (yychar < 0) 700 { 701 #if YYBTYACC 702 do { 703 if (yylvp < yylve) 704 { 705 /* we're currently re-reading tokens */ 706 yylval = *yylvp++; 707 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 708 yylloc = *yylpp++; 709 #endif 710 yychar = *yylexp++; 711 break; 712 } 713 if (yyps->save) 714 { 715 /* in trial mode; save scanner results for future parse attempts */ 716 if (yylvp == yylvlim) 717 { /* Enlarge lexical value queue */ 718 size_t p = (size_t) (yylvp - yylvals); 719 size_t s = (size_t) (yylvlim - yylvals); 720 721 s += YYLVQUEUEGROWTH; 722 if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; 723 if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem; 724 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 725 if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem; 726 #endif 727 yylvp = yylve = yylvals + p; 728 yylvlim = yylvals + s; 729 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 730 yylpp = yylpe = yylpsns + p; 731 yylplim = yylpsns + s; 732 #endif 733 yylexp = yylexemes + p; 734 } 735 *yylexp = (short) YYLEX; 736 *yylvp++ = yylval; 737 yylve++; 738 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 739 *yylpp++ = yylloc; 740 yylpe++; 741 #endif 742 yychar = *yylexp++; 743 break; 744 } 745 /* normal operation, no conflict encountered */ 746 #endif /* YYBTYACC */ 747 yychar = YYLEX; 748 #if YYBTYACC 749 } while (0); 750 #endif /* YYBTYACC */ 751 if (yychar < 0) yychar = YYEOF; 752 /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */ 753 #if YYDEBUG 754 if (yydebug) 755 { 756 yys = yyname[YYTRANSLATE(yychar)]; 757 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)", 758 YYDEBUGSTR, yydepth, yystate, yychar, yys); 759 #ifdef YYSTYPE_TOSTRING 760 #if YYBTYACC 761 if (!yytrial) 762 #endif /* YYBTYACC */ 763 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval)); 764 #endif 765 fputc('\n', stderr); 766 } 767 #endif 768 } 769 #if YYBTYACC 770 771 /* Do we have a conflict? */ 772 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 && 773 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 774 { 775 YYINT ctry; 776 777 if (yypath) 778 { 779 YYParseState *save; 780 #if YYDEBUG 781 if (yydebug) 782 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n", 783 YYDEBUGSTR, yydepth, yystate); 784 #endif 785 /* Switch to the next conflict context */ 786 save = yypath; 787 yypath = save->save; 788 save->save = NULL; 789 ctry = save->ctry; 790 if (save->state != yystate) YYABORT; 791 yyFreeState(save); 792 793 } 794 else 795 { 796 797 /* Unresolved conflict - start/continue trial parse */ 798 YYParseState *save; 799 #if YYDEBUG 800 if (yydebug) 801 { 802 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate); 803 if (yyps->save) 804 fputs("ALREADY in conflict, continuing trial parse.\n", stderr); 805 else 806 fputs("Starting trial parse.\n", stderr); 807 } 808 #endif 809 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 810 if (save == NULL) goto yyenomem; 811 save->save = yyps->save; 812 save->state = yystate; 813 save->errflag = yyerrflag; 814 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 815 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 816 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base); 817 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 818 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 819 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 820 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 821 #endif 822 ctry = yytable[yyn]; 823 if (yyctable[ctry] == -1) 824 { 825 #if YYDEBUG 826 if (yydebug && yychar >= YYEOF) 827 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth); 828 #endif 829 ctry++; 830 } 831 save->ctry = ctry; 832 if (yyps->save == NULL) 833 { 834 /* If this is a first conflict in the stack, start saving lexemes */ 835 if (!yylexemes) 836 { 837 yylexemes = (short *) malloc((YYLVQUEUEGROWTH) * sizeof(short)); 838 if (yylexemes == NULL) goto yyenomem; 839 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE)); 840 if (yylvals == NULL) goto yyenomem; 841 yylvlim = yylvals + YYLVQUEUEGROWTH; 842 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 843 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE)); 844 if (yylpsns == NULL) goto yyenomem; 845 yylplim = yylpsns + YYLVQUEUEGROWTH; 846 #endif 847 } 848 if (yylvp == yylve) 849 { 850 yylvp = yylve = yylvals; 851 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 852 yylpp = yylpe = yylpsns; 853 #endif 854 yylexp = yylexemes; 855 if (yychar >= YYEOF) 856 { 857 *yylve++ = yylval; 858 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 859 *yylpe++ = yylloc; 860 #endif 861 *yylexp = (short) yychar; 862 yychar = YYEMPTY; 863 } 864 } 865 } 866 if (yychar >= YYEOF) 867 { 868 yylvp--; 869 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 870 yylpp--; 871 #endif 872 yylexp--; 873 yychar = YYEMPTY; 874 } 875 save->lexeme = (int) (yylvp - yylvals); 876 yyps->save = save; 877 } 878 if (yytable[yyn] == ctry) 879 { 880 #if YYDEBUG 881 if (yydebug) 882 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 883 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]); 884 #endif 885 if (yychar < 0) 886 { 887 yylvp++; 888 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 889 yylpp++; 890 #endif 891 yylexp++; 892 } 893 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) 894 goto yyoverflow; 895 yystate = yyctable[ctry]; 896 *++yystack.s_mark = (short) yystate; 897 *++yystack.l_mark = yylval; 898 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 899 *++yystack.p_mark = yylloc; 900 #endif 901 yychar = YYEMPTY; 902 if (yyerrflag > 0) --yyerrflag; 903 goto yyloop; 904 } 905 else 906 { 907 yyn = yyctable[ctry]; 908 goto yyreduce; 909 } 910 } /* End of code dealing with conflicts */ 911 #endif /* YYBTYACC */ 912 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 && 913 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 914 { 915 #if YYDEBUG 916 if (yydebug) 917 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 918 YYDEBUGSTR, yydepth, yystate, yytable[yyn]); 919 #endif 920 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 921 yystate = yytable[yyn]; 922 *++yystack.s_mark = yytable[yyn]; 923 *++yystack.l_mark = yylval; 924 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 925 *++yystack.p_mark = yylloc; 926 #endif 927 yychar = YYEMPTY; 928 if (yyerrflag > 0) --yyerrflag; 929 goto yyloop; 930 } 931 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 && 932 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 933 { 934 yyn = yytable[yyn]; 935 goto yyreduce; 936 } 937 if (yyerrflag != 0) goto yyinrecovery; 938 #if YYBTYACC 939 940 yynewerrflag = 1; 941 goto yyerrhandler; 942 goto yyerrlab; 943 944 yyerrlab: 945 yynewerrflag = 0; 946 yyerrhandler: 947 while (yyps->save) 948 { 949 int ctry; 950 YYParseState *save = yyps->save; 951 #if YYDEBUG 952 if (yydebug) 953 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n", 954 YYDEBUGSTR, yydepth, yystate, yyps->save->state, 955 (int)(yylvp - yylvals - yyps->save->lexeme)); 956 #endif 957 /* Memorize most forward-looking error state in case it's really an error. */ 958 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals) 959 { 960 /* Free old saved error context state */ 961 if (yyerrctx) yyFreeState(yyerrctx); 962 /* Create and fill out new saved error context state */ 963 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 964 if (yyerrctx == NULL) goto yyenomem; 965 yyerrctx->save = yyps->save; 966 yyerrctx->state = yystate; 967 yyerrctx->errflag = yyerrflag; 968 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 969 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 970 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base); 971 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 972 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 973 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 974 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 975 #endif 976 yyerrctx->lexeme = (int) (yylvp - yylvals); 977 } 978 yylvp = yylvals + save->lexeme; 979 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 980 yylpp = yylpsns + save->lexeme; 981 #endif 982 yylexp = yylexemes + save->lexeme; 983 yychar = YYEMPTY; 984 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 985 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 986 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base); 987 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 988 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 989 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 990 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 991 #endif 992 ctry = ++save->ctry; 993 yystate = save->state; 994 /* We tried shift, try reduce now */ 995 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce; 996 yyps->save = save->save; 997 save->save = NULL; 998 yyFreeState(save); 999 1000 /* Nothing left on the stack -- error */ 1001 if (!yyps->save) 1002 { 1003 #if YYDEBUG 1004 if (yydebug) 1005 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n", 1006 YYPREFIX, yydepth); 1007 #endif 1008 /* Restore state as it was in the most forward-advanced error */ 1009 yylvp = yylvals + yyerrctx->lexeme; 1010 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1011 yylpp = yylpsns + yyerrctx->lexeme; 1012 #endif 1013 yylexp = yylexemes + yyerrctx->lexeme; 1014 yychar = yylexp[-1]; 1015 yylval = yylvp[-1]; 1016 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1017 yylloc = yylpp[-1]; 1018 #endif 1019 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 1020 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 1021 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base); 1022 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1023 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1024 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 1025 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1026 #endif 1027 yystate = yyerrctx->state; 1028 yyFreeState(yyerrctx); 1029 yyerrctx = NULL; 1030 } 1031 yynewerrflag = 1; 1032 } 1033 if (yynewerrflag == 0) goto yyinrecovery; 1034 #endif /* YYBTYACC */ 1035 1036 YYERROR_CALL("syntax error"); 1037 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1038 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */ 1039 #endif 1040 1041 #if !YYBTYACC 1042 goto yyerrlab; 1043 yyerrlab: 1044 #endif 1045 ++yynerrs; 1046 1047 yyinrecovery: 1048 if (yyerrflag < 3) 1049 { 1050 yyerrflag = 3; 1051 for (;;) 1052 { 1053 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 && 1054 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE) 1055 { 1056 #if YYDEBUG 1057 if (yydebug) 1058 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n", 1059 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]); 1060 #endif 1061 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1062 yystate = yytable[yyn]; 1063 *++yystack.s_mark = yytable[yyn]; 1064 *++yystack.l_mark = yylval; 1065 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1066 /* lookahead position is error end position */ 1067 yyerror_loc_range[1] = yylloc; 1068 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */ 1069 *++yystack.p_mark = yyloc; 1070 #endif 1071 goto yyloop; 1072 } 1073 else 1074 { 1075 #if YYDEBUG 1076 if (yydebug) 1077 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n", 1078 YYDEBUGSTR, yydepth, *yystack.s_mark); 1079 #endif 1080 if (yystack.s_mark <= yystack.s_base) goto yyabort; 1081 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1082 /* the current TOS position is the error start position */ 1083 yyerror_loc_range[0] = *yystack.p_mark; 1084 #endif 1085 #if defined(YYDESTRUCT_CALL) 1086 #if YYBTYACC 1087 if (!yytrial) 1088 #endif /* YYBTYACC */ 1089 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1090 YYDESTRUCT_CALL("error: discarding state", 1091 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark); 1092 #else 1093 YYDESTRUCT_CALL("error: discarding state", 1094 yystos[*yystack.s_mark], yystack.l_mark); 1095 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1096 #endif /* defined(YYDESTRUCT_CALL) */ 1097 --yystack.s_mark; 1098 --yystack.l_mark; 1099 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1100 --yystack.p_mark; 1101 #endif 1102 } 1103 } 1104 } 1105 else 1106 { 1107 if (yychar == YYEOF) goto yyabort; 1108 #if YYDEBUG 1109 if (yydebug) 1110 { 1111 yys = yyname[YYTRANSLATE(yychar)]; 1112 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n", 1113 YYDEBUGSTR, yydepth, yystate, yychar, yys); 1114 } 1115 #endif 1116 #if defined(YYDESTRUCT_CALL) 1117 #if YYBTYACC 1118 if (!yytrial) 1119 #endif /* YYBTYACC */ 1120 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1121 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc); 1122 #else 1123 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval); 1124 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1125 #endif /* defined(YYDESTRUCT_CALL) */ 1126 yychar = YYEMPTY; 1127 goto yyloop; 1128 } 1129 1130 yyreduce: 1131 yym = yylen[yyn]; 1132 #if YYDEBUG 1133 if (yydebug) 1134 { 1135 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)", 1136 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]); 1137 #ifdef YYSTYPE_TOSTRING 1138 #if YYBTYACC 1139 if (!yytrial) 1140 #endif /* YYBTYACC */ 1141 if (yym > 0) 1142 { 1143 int i; 1144 fputc('<', stderr); 1145 for (i = yym; i > 0; i--) 1146 { 1147 if (i != yym) fputs(", ", stderr); 1148 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]], 1149 yystack.l_mark[1-i]), stderr); 1150 } 1151 fputc('>', stderr); 1152 } 1153 #endif 1154 fputc('\n', stderr); 1155 } 1156 #endif 1157 if (yym > 0) 1158 yyval = yystack.l_mark[1-yym]; 1159 else 1160 memset(&yyval, 0, sizeof yyval); 1161 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1162 1163 /* Perform position reduction */ 1164 memset(&yyloc, 0, sizeof(yyloc)); 1165 #if YYBTYACC 1166 if (!yytrial) 1167 #endif /* YYBTYACC */ 1168 { 1169 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym); 1170 /* just in case YYERROR is invoked within the action, save 1171 the start of the rhs as the error start position */ 1172 yyerror_loc_range[0] = yystack.p_mark[1-yym]; 1173 } 1174 #endif 1175 1176 switch (yyn) 1177 { 1178 case 3: 1179 #line 34 "pure_calc.y" 1180 { yyerrok ; } 1181 break; 1182 case 4: 1183 #line 38 "pure_calc.y" 1184 { printf("%d\n",yystack.l_mark[0]);} 1185 break; 1186 case 5: 1187 #line 40 "pure_calc.y" 1188 { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; } 1189 break; 1190 case 6: 1191 #line 44 "pure_calc.y" 1192 { yyval = yystack.l_mark[-1]; } 1193 break; 1194 case 7: 1195 #line 46 "pure_calc.y" 1196 { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; } 1197 break; 1198 case 8: 1199 #line 48 "pure_calc.y" 1200 { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; } 1201 break; 1202 case 9: 1203 #line 50 "pure_calc.y" 1204 { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; } 1205 break; 1206 case 10: 1207 #line 52 "pure_calc.y" 1208 { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; } 1209 break; 1210 case 11: 1211 #line 54 "pure_calc.y" 1212 { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; } 1213 break; 1214 case 12: 1215 #line 56 "pure_calc.y" 1216 { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; } 1217 break; 1218 case 13: 1219 #line 58 "pure_calc.y" 1220 { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; } 1221 break; 1222 case 14: 1223 #line 60 "pure_calc.y" 1224 { yyval = - yystack.l_mark[0]; } 1225 break; 1226 case 15: 1227 #line 62 "pure_calc.y" 1228 { yyval = regs[yystack.l_mark[0]]; } 1229 break; 1230 case 17: 1231 #line 67 "pure_calc.y" 1232 { yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; } 1233 break; 1234 case 18: 1235 #line 69 "pure_calc.y" 1236 { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; } 1237 break; 1238 #line 1237 "pure_calc.tab.c" 1239 default: 1240 break; 1241 } 1242 yystack.s_mark -= yym; 1243 yystate = *yystack.s_mark; 1244 yystack.l_mark -= yym; 1245 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1246 yystack.p_mark -= yym; 1247 #endif 1248 yym = yylhs[yyn]; 1249 if (yystate == 0 && yym == 0) 1250 { 1251 #if YYDEBUG 1252 if (yydebug) 1253 { 1254 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1255 #ifdef YYSTYPE_TOSTRING 1256 #if YYBTYACC 1257 if (!yytrial) 1258 #endif /* YYBTYACC */ 1259 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval)); 1260 #endif 1261 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL); 1262 } 1263 #endif 1264 yystate = YYFINAL; 1265 *++yystack.s_mark = YYFINAL; 1266 *++yystack.l_mark = yyval; 1267 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1268 *++yystack.p_mark = yyloc; 1269 #endif 1270 if (yychar < 0) 1271 { 1272 #if YYBTYACC 1273 do { 1274 if (yylvp < yylve) 1275 { 1276 /* we're currently re-reading tokens */ 1277 yylval = *yylvp++; 1278 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1279 yylloc = *yylpp++; 1280 #endif 1281 yychar = *yylexp++; 1282 break; 1283 } 1284 if (yyps->save) 1285 { 1286 /* in trial mode; save scanner results for future parse attempts */ 1287 if (yylvp == yylvlim) 1288 { /* Enlarge lexical value queue */ 1289 size_t p = (size_t) (yylvp - yylvals); 1290 size_t s = (size_t) (yylvlim - yylvals); 1291 1292 s += YYLVQUEUEGROWTH; 1293 if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) 1294 goto yyenomem; 1295 if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) 1296 goto yyenomem; 1297 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1298 if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) 1299 goto yyenomem; 1300 #endif 1301 yylvp = yylve = yylvals + p; 1302 yylvlim = yylvals + s; 1303 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1304 yylpp = yylpe = yylpsns + p; 1305 yylplim = yylpsns + s; 1306 #endif 1307 yylexp = yylexemes + p; 1308 } 1309 *yylexp = (short) YYLEX; 1310 *yylvp++ = yylval; 1311 yylve++; 1312 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1313 *yylpp++ = yylloc; 1314 yylpe++; 1315 #endif 1316 yychar = *yylexp++; 1317 break; 1318 } 1319 /* normal operation, no conflict encountered */ 1320 #endif /* YYBTYACC */ 1321 yychar = YYLEX; 1322 #if YYBTYACC 1323 } while (0); 1324 #endif /* YYBTYACC */ 1325 if (yychar < 0) yychar = YYEOF; 1326 /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */ 1327 #if YYDEBUG 1328 if (yydebug) 1329 { 1330 yys = yyname[YYTRANSLATE(yychar)]; 1331 fprintf(stderr, "%s[%d]: state %d, reading %d (%s)\n", 1332 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys); 1333 } 1334 #endif 1335 } 1336 if (yychar == YYEOF) goto yyaccept; 1337 goto yyloop; 1338 } 1339 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 && 1340 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate) 1341 yystate = yytable[yyn]; 1342 else 1343 yystate = yydgoto[yym]; 1344 #if YYDEBUG 1345 if (yydebug) 1346 { 1347 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1348 #ifdef YYSTYPE_TOSTRING 1349 #if YYBTYACC 1350 if (!yytrial) 1351 #endif /* YYBTYACC */ 1352 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval)); 1353 #endif 1354 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate); 1355 } 1356 #endif 1357 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1358 *++yystack.s_mark = (short) yystate; 1359 *++yystack.l_mark = yyval; 1360 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1361 *++yystack.p_mark = yyloc; 1362 #endif 1363 goto yyloop; 1364 #if YYBTYACC 1365 1366 /* Reduction declares that this path is valid. Set yypath and do a full parse */ 1367 yyvalid: 1368 if (yypath) YYABORT; 1369 while (yyps->save) 1370 { 1371 YYParseState *save = yyps->save; 1372 yyps->save = save->save; 1373 save->save = yypath; 1374 yypath = save; 1375 } 1376 #if YYDEBUG 1377 if (yydebug) 1378 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n", 1379 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme)); 1380 #endif 1381 if (yyerrctx) 1382 { 1383 yyFreeState(yyerrctx); 1384 yyerrctx = NULL; 1385 } 1386 yylvp = yylvals + yypath->lexeme; 1387 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1388 yylpp = yylpsns + yypath->lexeme; 1389 #endif 1390 yylexp = yylexemes + yypath->lexeme; 1391 yychar = YYEMPTY; 1392 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 1393 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 1394 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base); 1395 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1396 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1397 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 1398 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1399 #endif 1400 yystate = yypath->state; 1401 goto yyloop; 1402 #endif /* YYBTYACC */ 1403 1404 yyoverflow: 1405 YYERROR_CALL("yacc stack overflow"); 1406 #if YYBTYACC 1407 goto yyabort_nomem; 1408 yyenomem: 1409 YYERROR_CALL("memory exhausted"); 1410 yyabort_nomem: 1411 #endif /* YYBTYACC */ 1412 yyresult = 2; 1413 goto yyreturn; 1414 1415 yyabort: 1416 yyresult = 1; 1417 goto yyreturn; 1418 1419 yyaccept: 1420 #if YYBTYACC 1421 if (yyps->save) goto yyvalid; 1422 #endif /* YYBTYACC */ 1423 yyresult = 0; 1424 1425 yyreturn: 1426 #if defined(YYDESTRUCT_CALL) 1427 if (yychar != YYEOF && yychar != YYEMPTY) 1428 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1429 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc); 1430 #else 1431 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval); 1432 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1433 1434 { 1435 YYSTYPE *pv; 1436 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1437 YYLTYPE *pp; 1438 1439 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp) 1440 YYDESTRUCT_CALL("cleanup: discarding state", 1441 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp); 1442 #else 1443 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv) 1444 YYDESTRUCT_CALL("cleanup: discarding state", 1445 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv); 1446 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1447 } 1448 #endif /* defined(YYDESTRUCT_CALL) */ 1449 1450 #if YYBTYACC 1451 if (yyerrctx) 1452 { 1453 yyFreeState(yyerrctx); 1454 yyerrctx = NULL; 1455 } 1456 while (yyps) 1457 { 1458 YYParseState *save = yyps; 1459 yyps = save->save; 1460 save->save = NULL; 1461 yyFreeState(save); 1462 } 1463 while (yypath) 1464 { 1465 YYParseState *save = yypath; 1466 yypath = save->save; 1467 save->save = NULL; 1468 yyFreeState(save); 1469 } 1470 #endif /* YYBTYACC */ 1471 yyfreestack(&yystack); 1472 return (yyresult); 1473 } 1474