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