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 17 /* %code "top" block start */ 18 #line 1 "calc_code_top.y" 19 /* CODE-TOP */ 20 #line 2 "calc_code_top.y" 21 /* CODE-TOP2 */ 22 /* %code "top" block end */ 23 #line 24 "calc_code_top.tab.c" 24 #undef YYBTYACC 25 #define YYBTYACC 0 26 #define YYDEBUGSTR YYPREFIX "debug" 27 28 #ifndef yyparse 29 #define yyparse calc_code_top_parse 30 #endif /* yyparse */ 31 32 #ifndef yylex 33 #define yylex calc_code_top_lex 34 #endif /* yylex */ 35 36 #ifndef yyerror 37 #define yyerror calc_code_top_error 38 #endif /* yyerror */ 39 40 #ifndef yychar 41 #define yychar calc_code_top_char 42 #endif /* yychar */ 43 44 #ifndef yyval 45 #define yyval calc_code_top_val 46 #endif /* yyval */ 47 48 #ifndef yylval 49 #define yylval calc_code_top_lval 50 #endif /* yylval */ 51 52 #ifndef yydebug 53 #define yydebug calc_code_top_debug 54 #endif /* yydebug */ 55 56 #ifndef yynerrs 57 #define yynerrs calc_code_top_nerrs 58 #endif /* yynerrs */ 59 60 #ifndef yyerrflag 61 #define yyerrflag calc_code_top_errflag 62 #endif /* yyerrflag */ 63 64 #ifndef yylhs 65 #define yylhs calc_code_top_lhs 66 #endif /* yylhs */ 67 68 #ifndef yylen 69 #define yylen calc_code_top_len 70 #endif /* yylen */ 71 72 #ifndef yydefred 73 #define yydefred calc_code_top_defred 74 #endif /* yydefred */ 75 76 #ifndef yystos 77 #define yystos calc_code_top_stos 78 #endif /* yystos */ 79 80 #ifndef yydgoto 81 #define yydgoto calc_code_top_dgoto 82 #endif /* yydgoto */ 83 84 #ifndef yysindex 85 #define yysindex calc_code_top_sindex 86 #endif /* yysindex */ 87 88 #ifndef yyrindex 89 #define yyrindex calc_code_top_rindex 90 #endif /* yyrindex */ 91 92 #ifndef yygindex 93 #define yygindex calc_code_top_gindex 94 #endif /* yygindex */ 95 96 #ifndef yytable 97 #define yytable calc_code_top_table 98 #endif /* yytable */ 99 100 #ifndef yycheck 101 #define yycheck calc_code_top_check 102 #endif /* yycheck */ 103 104 #ifndef yyname 105 #define yyname calc_code_top_name 106 #endif /* yyname */ 107 108 #ifndef yyrule 109 #define yyrule calc_code_top_rule 110 #endif /* yyrule */ 111 112 #if YYBTYACC 113 114 #ifndef yycindex 115 #define yycindex calc_code_top_cindex 116 #endif /* yycindex */ 117 118 #ifndef yyctable 119 #define yyctable calc_code_top_ctable 120 #endif /* yyctable */ 121 122 #endif /* YYBTYACC */ 123 124 #define YYPREFIX "calc_code_top_" 125 126 #define YYPURE 0 127 128 #line 5 "calc_code_top.y" 129 # include <stdio.h> 130 # include <ctype.h> 131 132 int regs[26]; 133 int base; 134 135 extern int yylex(void); 136 static void yyerror(const char *s); 137 138 #line 139 "calc_code_top.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 # define YYLEX_DECL() yylex(void *YYLEX_PARAM) 161 # define YYLEX yylex(YYLEX_PARAM) 162 #else 163 # define YYLEX_DECL() yylex(void) 164 # define YYLEX yylex() 165 #endif 166 167 /* Parameters sent to yyerror. */ 168 #ifndef YYERROR_DECL 169 #define YYERROR_DECL() yyerror(const char *s) 170 #endif 171 #ifndef YYERROR_CALL 172 #define YYERROR_CALL(msg) yyerror(msg) 173 #endif 174 175 extern int YYPARSE_DECL(); 176 177 #define DIGIT 257 178 #define LETTER 258 179 #define UMINUS 259 180 #define YYERRCODE 256 181 typedef int YYINT; 182 static const YYINT calc_code_top_lhs[] = { -1, 183 0, 0, 0, 1, 1, 2, 2, 2, 2, 2, 184 2, 2, 2, 2, 2, 2, 3, 3, 185 }; 186 static const YYINT calc_code_top_len[] = { 2, 187 0, 3, 3, 1, 3, 3, 3, 3, 3, 3, 188 3, 3, 3, 2, 1, 1, 1, 2, 189 }; 190 static const YYINT calc_code_top_defred[] = { 1, 191 0, 0, 17, 0, 0, 0, 0, 0, 0, 3, 192 0, 15, 14, 0, 2, 0, 0, 0, 0, 0, 193 0, 0, 18, 0, 6, 0, 0, 0, 0, 9, 194 10, 11, 195 }; 196 #if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING) 197 static const YYINT calc_code_top_stos[] = { 0, 198 261, 256, 257, 258, 45, 40, 262, 263, 264, 10, 199 61, 258, 263, 263, 10, 124, 38, 43, 45, 42, 200 47, 37, 257, 263, 41, 263, 263, 263, 263, 263, 201 263, 263, 202 }; 203 #endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */ 204 static const YYINT calc_code_top_dgoto[] = { 1, 205 7, 8, 9, 206 }; 207 static const YYINT calc_code_top_sindex[] = { 0, 208 -40, -7, 0, -55, -38, -38, 1, -29, -247, 0, 209 -38, 0, 0, 22, 0, -38, -38, -38, -38, -38, 210 -38, -38, 0, -29, 0, 51, 60, -20, -20, 0, 211 0, 0, 212 }; 213 static const YYINT calc_code_top_rindex[] = { 0, 214 0, 0, 0, 2, 0, 0, 0, 9, -9, 0, 215 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 216 0, 0, 0, 10, 0, -6, 14, 5, 13, 0, 217 0, 0, 218 }; 219 #if YYBTYACC 220 static const YYINT calc_code_top_cindex[] = { 0, 221 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 222 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 223 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 224 0, 0, 225 }; 226 #endif 227 static const YYINT calc_code_top_gindex[] = { 0, 228 0, 65, 0, 229 }; 230 #define YYTABLESIZE 220 231 static const YYINT calc_code_top_table[] = { 6, 232 16, 6, 10, 13, 5, 11, 5, 22, 17, 23, 233 15, 15, 20, 18, 7, 19, 22, 21, 4, 5, 234 0, 20, 8, 12, 0, 0, 21, 16, 16, 0, 235 0, 16, 16, 16, 13, 16, 0, 16, 15, 15, 236 0, 0, 7, 15, 15, 7, 15, 7, 15, 7, 237 8, 12, 0, 8, 12, 8, 0, 8, 22, 17, 238 0, 0, 25, 20, 18, 0, 19, 0, 21, 13, 239 14, 0, 0, 0, 0, 24, 0, 0, 0, 0, 240 26, 27, 28, 29, 30, 31, 32, 22, 17, 0, 241 0, 0, 20, 18, 16, 19, 22, 21, 0, 0, 242 0, 20, 18, 0, 19, 0, 21, 0, 0, 0, 243 0, 0, 0, 0, 16, 0, 0, 13, 0, 0, 244 0, 0, 0, 0, 0, 15, 0, 0, 7, 0, 245 0, 0, 0, 0, 0, 0, 8, 12, 0, 0, 246 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 247 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 248 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 249 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 250 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 251 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 252 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 253 0, 0, 0, 0, 0, 2, 3, 4, 3, 12, 254 }; 255 static const YYINT calc_code_top_check[] = { 40, 256 10, 40, 10, 10, 45, 61, 45, 37, 38, 257, 257 10, 10, 42, 43, 10, 45, 37, 47, 10, 10, 258 -1, 42, 10, 10, -1, -1, 47, 37, 38, -1, 259 -1, 41, 42, 43, 41, 45, -1, 47, 37, 38, 260 -1, -1, 38, 42, 43, 41, 45, 43, 47, 45, 261 38, 38, -1, 41, 41, 43, -1, 45, 37, 38, 262 -1, -1, 41, 42, 43, -1, 45, -1, 47, 5, 263 6, -1, -1, -1, -1, 11, -1, -1, -1, -1, 264 16, 17, 18, 19, 20, 21, 22, 37, 38, -1, 265 -1, -1, 42, 43, 124, 45, 37, 47, -1, -1, 266 -1, 42, 43, -1, 45, -1, 47, -1, -1, -1, 267 -1, -1, -1, -1, 124, -1, -1, 124, -1, -1, 268 -1, -1, -1, -1, -1, 124, -1, -1, 124, -1, 269 -1, -1, -1, -1, -1, -1, 124, 124, -1, -1, 270 -1, -1, -1, -1, -1, 124, -1, -1, -1, -1, 271 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 272 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 273 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 274 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 275 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 276 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 277 -1, -1, -1, -1, -1, 256, 257, 258, 257, 258, 278 }; 279 #if YYBTYACC 280 static const YYINT calc_code_top_ctable[] = { -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, -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, 303 }; 304 #endif 305 #define YYFINAL 1 306 #ifndef YYDEBUG 307 #define YYDEBUG 0 308 #endif 309 #define YYMAXTOKEN 259 310 #define YYUNDFTOKEN 265 311 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a)) 312 #if YYDEBUG 313 static const char *const calc_code_top_name[] = { 314 315 "$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, 316 0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0, 317 0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,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,0,0,0,0,0,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,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,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,"error","DIGIT","LETTER","UMINUS","$accept","list","stat","expr","number", 323 "illegal-symbol", 324 }; 325 static const char *const calc_code_top_rule[] = { 326 "$accept : list", 327 "list :", 328 "list : list stat '\\n'", 329 "list : list error '\\n'", 330 "stat : expr", 331 "stat : LETTER '=' expr", 332 "expr : '(' expr ')'", 333 "expr : expr '+' expr", 334 "expr : 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", 341 "expr : LETTER", 342 "expr : number", 343 "number : DIGIT", 344 "number : number DIGIT", 345 346 }; 347 #endif 348 349 #if YYDEBUG 350 int yydebug; 351 #endif 352 353 int yyerrflag; 354 int yychar; 355 YYSTYPE yyval; 356 YYSTYPE yylval; 357 int yynerrs; 358 359 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 360 YYLTYPE yyloc; /* position returned by actions */ 361 YYLTYPE yylloc; /* position from the lexer */ 362 #endif 363 364 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 365 #ifndef YYLLOC_DEFAULT 366 #define YYLLOC_DEFAULT(loc, rhs, n) \ 367 do \ 368 { \ 369 if (n == 0) \ 370 { \ 371 (loc).first_line = YYRHSLOC(rhs, 0).last_line; \ 372 (loc).first_column = YYRHSLOC(rhs, 0).last_column; \ 373 (loc).last_line = YYRHSLOC(rhs, 0).last_line; \ 374 (loc).last_column = YYRHSLOC(rhs, 0).last_column; \ 375 } \ 376 else \ 377 { \ 378 (loc).first_line = YYRHSLOC(rhs, 1).first_line; \ 379 (loc).first_column = YYRHSLOC(rhs, 1).first_column; \ 380 (loc).last_line = YYRHSLOC(rhs, n).last_line; \ 381 (loc).last_column = YYRHSLOC(rhs, n).last_column; \ 382 } \ 383 } while (0) 384 #endif /* YYLLOC_DEFAULT */ 385 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 386 #if YYBTYACC 387 388 #ifndef YYLVQUEUEGROWTH 389 #define YYLVQUEUEGROWTH 32 390 #endif 391 #endif /* YYBTYACC */ 392 393 /* define the initial stack-sizes */ 394 #ifdef YYSTACKSIZE 395 #undef YYMAXDEPTH 396 #define YYMAXDEPTH YYSTACKSIZE 397 #else 398 #ifdef YYMAXDEPTH 399 #define YYSTACKSIZE YYMAXDEPTH 400 #else 401 #define YYSTACKSIZE 10000 402 #define YYMAXDEPTH 10000 403 #endif 404 #endif 405 406 #ifndef YYINITSTACKSIZE 407 #define YYINITSTACKSIZE 200 408 #endif 409 410 typedef struct { 411 unsigned stacksize; 412 YYINT *s_base; 413 YYINT *s_mark; 414 YYINT *s_last; 415 YYSTYPE *l_base; 416 YYSTYPE *l_mark; 417 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 418 YYLTYPE *p_base; 419 YYLTYPE *p_mark; 420 #endif 421 } YYSTACKDATA; 422 #if YYBTYACC 423 424 struct YYParseState_s 425 { 426 struct YYParseState_s *save; /* Previously saved parser state */ 427 YYSTACKDATA yystack; /* saved parser stack */ 428 int state; /* saved parser state */ 429 int errflag; /* saved error recovery status */ 430 int lexeme; /* saved index of the conflict lexeme in the lexical queue */ 431 YYINT ctry; /* saved index in yyctable[] for this conflict */ 432 }; 433 typedef struct YYParseState_s YYParseState; 434 #endif /* YYBTYACC */ 435 /* variables for the parser stack */ 436 static YYSTACKDATA yystack; 437 #if YYBTYACC 438 439 /* Current parser state */ 440 static YYParseState *yyps = 0; 441 442 /* yypath != NULL: do the full parse, starting at *yypath parser state. */ 443 static YYParseState *yypath = 0; 444 445 /* Base of the lexical value queue */ 446 static YYSTYPE *yylvals = 0; 447 448 /* Current position at lexical value queue */ 449 static YYSTYPE *yylvp = 0; 450 451 /* End position of lexical value queue */ 452 static YYSTYPE *yylve = 0; 453 454 /* The last allocated position at the lexical value queue */ 455 static YYSTYPE *yylvlim = 0; 456 457 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 458 /* Base of the lexical position queue */ 459 static YYLTYPE *yylpsns = 0; 460 461 /* Current position at lexical position queue */ 462 static YYLTYPE *yylpp = 0; 463 464 /* End position of lexical position queue */ 465 static YYLTYPE *yylpe = 0; 466 467 /* The last allocated position at the lexical position queue */ 468 static YYLTYPE *yylplim = 0; 469 #endif 470 471 /* Current position at lexical token queue */ 472 static YYINT *yylexp = 0; 473 474 static YYINT *yylexemes = 0; 475 #endif /* YYBTYACC */ 476 #line 69 "calc_code_top.y" 477 /* start of programs */ 478 479 int 480 main (void) 481 { 482 while(!feof(stdin)) { 483 yyparse(); 484 } 485 return 0; 486 } 487 488 static void 489 yyerror(const char *s) 490 { 491 fprintf(stderr, "%s\n", s); 492 } 493 494 int 495 yylex(void) 496 { 497 /* lexical analysis routine */ 498 /* returns LETTER for a lower case letter, yylval = 0 through 25 */ 499 /* return DIGIT for a digit, yylval = 0 through 9 */ 500 /* all other characters are returned immediately */ 501 502 int c; 503 504 while( (c=getchar()) == ' ' ) { /* skip blanks */ } 505 506 /* c is now nonblank */ 507 508 if( islower( c )) { 509 yylval = c - 'a'; 510 return ( LETTER ); 511 } 512 if( isdigit( c )) { 513 yylval = c - '0'; 514 return ( DIGIT ); 515 } 516 return( c ); 517 } 518 #line 519 "calc_code_top.tab.c" 519 520 /* For use in generated program */ 521 #define yydepth (int)(yystack.s_mark - yystack.s_base) 522 #if YYBTYACC 523 #define yytrial (yyps->save) 524 #endif /* YYBTYACC */ 525 526 #if YYDEBUG 527 #include <stdio.h> /* needed for printf */ 528 #endif 529 530 #include <stdlib.h> /* needed for malloc, etc */ 531 #include <string.h> /* needed for memset */ 532 533 /* allocate initial stack or double stack size, up to YYMAXDEPTH */ 534 static int yygrowstack(YYSTACKDATA *data) 535 { 536 int i; 537 unsigned newsize; 538 YYINT *newss; 539 YYSTYPE *newvs; 540 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 541 YYLTYPE *newps; 542 #endif 543 544 if ((newsize = data->stacksize) == 0) 545 newsize = YYINITSTACKSIZE; 546 else if (newsize >= YYMAXDEPTH) 547 return YYENOMEM; 548 else if ((newsize *= 2) > YYMAXDEPTH) 549 newsize = YYMAXDEPTH; 550 551 i = (int) (data->s_mark - data->s_base); 552 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss)); 553 if (newss == NULL) 554 return YYENOMEM; 555 556 data->s_base = newss; 557 data->s_mark = newss + i; 558 559 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs)); 560 if (newvs == NULL) 561 return YYENOMEM; 562 563 data->l_base = newvs; 564 data->l_mark = newvs + i; 565 566 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 567 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps)); 568 if (newps == NULL) 569 return YYENOMEM; 570 571 data->p_base = newps; 572 data->p_mark = newps + i; 573 #endif 574 575 data->stacksize = newsize; 576 data->s_last = data->s_base + newsize - 1; 577 578 #if YYDEBUG 579 if (yydebug) 580 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize); 581 #endif 582 return 0; 583 } 584 585 #if YYPURE || defined(YY_NO_LEAKS) 586 static void yyfreestack(YYSTACKDATA *data) 587 { 588 free(data->s_base); 589 free(data->l_base); 590 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 591 free(data->p_base); 592 #endif 593 memset(data, 0, sizeof(*data)); 594 } 595 #else 596 #define yyfreestack(data) /* nothing */ 597 #endif /* YYPURE || defined(YY_NO_LEAKS) */ 598 #if YYBTYACC 599 600 static YYParseState * 601 yyNewState(unsigned size) 602 { 603 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState)); 604 if (p == NULL) return NULL; 605 606 p->yystack.stacksize = size; 607 if (size == 0) 608 { 609 p->yystack.s_base = NULL; 610 p->yystack.l_base = NULL; 611 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 612 p->yystack.p_base = NULL; 613 #endif 614 return p; 615 } 616 p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT)); 617 if (p->yystack.s_base == NULL) return NULL; 618 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE)); 619 if (p->yystack.l_base == NULL) return NULL; 620 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE)); 621 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 622 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE)); 623 if (p->yystack.p_base == NULL) return NULL; 624 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE)); 625 #endif 626 627 return p; 628 } 629 630 static void 631 yyFreeState(YYParseState *p) 632 { 633 yyfreestack(&p->yystack); 634 free(p); 635 } 636 #endif /* YYBTYACC */ 637 638 #define YYABORT goto yyabort 639 #define YYREJECT goto yyabort 640 #define YYACCEPT goto yyaccept 641 #define YYERROR goto yyerrlab 642 #if YYBTYACC 643 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0) 644 #define YYVALID_NESTED do { if (yyps->save && \ 645 yyps->save->save == 0) goto yyvalid; } while(0) 646 #endif /* YYBTYACC */ 647 648 int 649 YYPARSE_DECL() 650 { 651 int yym, yyn, yystate, yyresult; 652 #if YYBTYACC 653 int yynewerrflag; 654 YYParseState *yyerrctx = NULL; 655 #endif /* YYBTYACC */ 656 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 657 YYLTYPE yyerror_loc_range[3]; /* position of error start/end (0 unused) */ 658 #endif 659 #if YYDEBUG 660 const char *yys; 661 662 if ((yys = getenv("YYDEBUG")) != NULL) 663 { 664 yyn = *yys; 665 if (yyn >= '0' && yyn <= '9') 666 yydebug = yyn - '0'; 667 } 668 if (yydebug) 669 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX); 670 #endif 671 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 672 memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range)); 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 = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem; 725 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem; 726 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 727 if ((yylpsns = (YYLTYPE *)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 = (YYINT *) 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[1] = 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[2] = 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[1] = *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[-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[1] = yystack.p_mark[1-yym]; 1183 } 1184 #endif 1185 1186 switch (yyn) 1187 { 1188 case 3: 1189 #line 31 "calc_code_top.y" 1190 { yyerrok ; } 1191 break; 1192 case 4: 1193 #line 35 "calc_code_top.y" 1194 { printf("%d\n",yystack.l_mark[0]);} 1195 break; 1196 case 5: 1197 #line 37 "calc_code_top.y" 1198 { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; } 1199 break; 1200 case 6: 1201 #line 41 "calc_code_top.y" 1202 { yyval = yystack.l_mark[-1]; } 1203 break; 1204 case 7: 1205 #line 43 "calc_code_top.y" 1206 { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; } 1207 break; 1208 case 8: 1209 #line 45 "calc_code_top.y" 1210 { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; } 1211 break; 1212 case 9: 1213 #line 47 "calc_code_top.y" 1214 { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; } 1215 break; 1216 case 10: 1217 #line 49 "calc_code_top.y" 1218 { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; } 1219 break; 1220 case 11: 1221 #line 51 "calc_code_top.y" 1222 { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; } 1223 break; 1224 case 12: 1225 #line 53 "calc_code_top.y" 1226 { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; } 1227 break; 1228 case 13: 1229 #line 55 "calc_code_top.y" 1230 { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; } 1231 break; 1232 case 14: 1233 #line 57 "calc_code_top.y" 1234 { yyval = - yystack.l_mark[0]; } 1235 break; 1236 case 15: 1237 #line 59 "calc_code_top.y" 1238 { yyval = regs[yystack.l_mark[0]]; } 1239 break; 1240 case 17: 1241 #line 64 "calc_code_top.y" 1242 { yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; } 1243 break; 1244 case 18: 1245 #line 66 "calc_code_top.y" 1246 { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; } 1247 break; 1248 #line 1249 "calc_code_top.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 = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) 1304 goto yyenomem; 1305 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) 1306 goto yyenomem; 1307 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1308 if ((yylpsns = (YYLTYPE *)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