1 /* $NetBSD: calc.tab.c,v 1.6 2024/09/14 21:29:03 christos Exp $ */ 2 3 /* original parser id follows */ 4 /* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ 5 /* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */ 6 7 #define YYBYACC 1 8 #define YYMAJOR 2 9 #define YYMINOR 0 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 0 121 122 #line 2 "calc.y" 123 # include <stdio.h> 124 # include <ctype.h> 125 126 int regs[26]; 127 int base; 128 129 extern int yylex(void); 130 static void yyerror(const char *s); 131 132 #line 131 "calc.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(void) 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(void) 158 # define YYLEX yylex() 159 #endif 160 161 /* Parameters sent to yyerror. */ 162 #ifndef YYERROR_DECL 163 #define YYERROR_DECL() yyerror(const char *s) 164 #endif 165 #ifndef YYERROR_CALL 166 #define YYERROR_CALL(msg) yyerror(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 calc_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 calc_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 calc_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 calc_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 calc_dgoto[] = { 1, 199 7, 8, 9, 200 }; 201 static const YYINT calc_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 calc_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 calc_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 calc_gindex[] = { 0, 222 0, 65, 0, 223 }; 224 #define YYTABLESIZE 220 225 static const YYINT calc_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 calc_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 calc_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 calc_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 calc_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 66 "calc.y" 471 /* start of programs */ 472 473 int 474 main (void) 475 { 476 while(!feof(stdin)) { 477 yyparse(); 478 } 479 return 0; 480 } 481 482 static void 483 yyerror(const char *s) 484 { 485 fprintf(stderr, "%s\n", s); 486 } 487 488 int 489 yylex(void) 490 { 491 /* lexical analysis routine */ 492 /* returns LETTER for a lower case letter, yylval = 0 through 25 */ 493 /* return DIGIT for a digit, yylval = 0 through 9 */ 494 /* all other characters are returned immediately */ 495 496 int c; 497 498 while( (c=getchar()) == ' ' ) { /* skip blanks */ } 499 500 /* c is now nonblank */ 501 502 if( islower( c )) { 503 yylval = c - 'a'; 504 return ( LETTER ); 505 } 506 if( isdigit( c )) { 507 yylval = c - '0'; 508 return ( DIGIT ); 509 } 510 return( c ); 511 } 512 #line 511 "calc.tab.c" 513 514 /* For use in generated program */ 515 #define yydepth (int)(yystack.s_mark - yystack.s_base) 516 #if YYBTYACC 517 #define yytrial (yyps->save) 518 #endif /* YYBTYACC */ 519 520 #if YYDEBUG 521 #include <stdio.h> /* needed for printf */ 522 #endif 523 524 #include <stdlib.h> /* needed for malloc, etc */ 525 #include <string.h> /* needed for memset */ 526 527 /* allocate initial stack or double stack size, up to YYMAXDEPTH */ 528 static int yygrowstack(YYSTACKDATA *data) 529 { 530 int i; 531 unsigned newsize; 532 YYINT *newss; 533 YYSTYPE *newvs; 534 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 535 YYLTYPE *newps; 536 #endif 537 538 if ((newsize = data->stacksize) == 0) 539 newsize = YYINITSTACKSIZE; 540 else if (newsize >= YYMAXDEPTH) 541 return YYENOMEM; 542 else if ((newsize *= 2) > YYMAXDEPTH) 543 newsize = YYMAXDEPTH; 544 545 i = (int) (data->s_mark - data->s_base); 546 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss)); 547 if (newss == 0) 548 return YYENOMEM; 549 550 data->s_base = newss; 551 data->s_mark = newss + i; 552 553 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs)); 554 if (newvs == 0) 555 return YYENOMEM; 556 557 data->l_base = newvs; 558 data->l_mark = newvs + i; 559 560 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 561 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps)); 562 if (newps == 0) 563 return YYENOMEM; 564 565 data->p_base = newps; 566 data->p_mark = newps + i; 567 #endif 568 569 data->stacksize = newsize; 570 data->s_last = data->s_base + newsize - 1; 571 572 #if YYDEBUG 573 if (yydebug) 574 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize); 575 #endif 576 return 0; 577 } 578 579 #if YYPURE || defined(YY_NO_LEAKS) 580 static void yyfreestack(YYSTACKDATA *data) 581 { 582 free(data->s_base); 583 free(data->l_base); 584 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 585 free(data->p_base); 586 #endif 587 memset(data, 0, sizeof(*data)); 588 } 589 #else 590 #define yyfreestack(data) /* nothing */ 591 #endif /* YYPURE || defined(YY_NO_LEAKS) */ 592 #if YYBTYACC 593 594 static YYParseState * 595 yyNewState(unsigned size) 596 { 597 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState)); 598 if (p == NULL) return NULL; 599 600 p->yystack.stacksize = size; 601 if (size == 0) 602 { 603 p->yystack.s_base = NULL; 604 p->yystack.l_base = NULL; 605 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 606 p->yystack.p_base = NULL; 607 #endif 608 return p; 609 } 610 p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT)); 611 if (p->yystack.s_base == NULL) return NULL; 612 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE)); 613 if (p->yystack.l_base == NULL) return NULL; 614 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE)); 615 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 616 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE)); 617 if (p->yystack.p_base == NULL) return NULL; 618 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE)); 619 #endif 620 621 return p; 622 } 623 624 static void 625 yyFreeState(YYParseState *p) 626 { 627 yyfreestack(&p->yystack); 628 free(p); 629 } 630 #endif /* YYBTYACC */ 631 632 #define YYABORT goto yyabort 633 #define YYREJECT goto yyabort 634 #define YYACCEPT goto yyaccept 635 #define YYERROR goto yyerrlab 636 #if YYBTYACC 637 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0) 638 #define YYVALID_NESTED do { if (yyps->save && \ 639 yyps->save->save == 0) goto yyvalid; } while(0) 640 #endif /* YYBTYACC */ 641 642 int 643 YYPARSE_DECL() 644 { 645 int yym, yyn, yystate, yyresult; 646 #if YYBTYACC 647 int yynewerrflag; 648 YYParseState *yyerrctx = NULL; 649 #endif /* YYBTYACC */ 650 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 651 YYLTYPE yyerror_loc_range[3]; /* position of error start/end (0 unused) */ 652 #endif 653 #if YYDEBUG 654 const char *yys; 655 656 if ((yys = getenv("YYDEBUG")) != 0) 657 { 658 yyn = *yys; 659 if (yyn >= '0' && yyn <= '9') 660 yydebug = yyn - '0'; 661 } 662 if (yydebug) 663 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX); 664 #endif 665 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 666 memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range)); 667 #endif 668 669 #if YYBTYACC 670 yyps = yyNewState(0); if (yyps == 0) goto yyenomem; 671 yyps->save = 0; 672 #endif /* YYBTYACC */ 673 yym = 0; 674 /* yyn is set below */ 675 yynerrs = 0; 676 yyerrflag = 0; 677 yychar = YYEMPTY; 678 yystate = 0; 679 680 #if YYPURE 681 memset(&yystack, 0, sizeof(yystack)); 682 #endif 683 684 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 685 yystack.s_mark = yystack.s_base; 686 yystack.l_mark = yystack.l_base; 687 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 688 yystack.p_mark = yystack.p_base; 689 #endif 690 yystate = 0; 691 *yystack.s_mark = 0; 692 693 yyloop: 694 if ((yyn = yydefred[yystate]) != 0) goto yyreduce; 695 if (yychar < 0) 696 { 697 #if YYBTYACC 698 do { 699 if (yylvp < yylve) 700 { 701 /* we're currently re-reading tokens */ 702 yylval = *yylvp++; 703 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 704 yylloc = *yylpp++; 705 #endif 706 yychar = *yylexp++; 707 break; 708 } 709 if (yyps->save) 710 { 711 /* in trial mode; save scanner results for future parse attempts */ 712 if (yylvp == yylvlim) 713 { /* Enlarge lexical value queue */ 714 size_t p = (size_t) (yylvp - yylvals); 715 size_t s = (size_t) (yylvlim - yylvals); 716 717 s += YYLVQUEUEGROWTH; 718 if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem; 719 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem; 720 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 721 if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem; 722 #endif 723 yylvp = yylve = yylvals + p; 724 yylvlim = yylvals + s; 725 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 726 yylpp = yylpe = yylpsns + p; 727 yylplim = yylpsns + s; 728 #endif 729 yylexp = yylexemes + p; 730 } 731 *yylexp = (YYINT) YYLEX; 732 *yylvp++ = yylval; 733 yylve++; 734 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 735 *yylpp++ = yylloc; 736 yylpe++; 737 #endif 738 yychar = *yylexp++; 739 break; 740 } 741 /* normal operation, no conflict encountered */ 742 #endif /* YYBTYACC */ 743 yychar = YYLEX; 744 #if YYBTYACC 745 } while (0); 746 #endif /* YYBTYACC */ 747 if (yychar < 0) yychar = YYEOF; 748 #if YYDEBUG 749 if (yydebug) 750 { 751 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 752 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)", 753 YYDEBUGSTR, yydepth, yystate, yychar, yys); 754 #ifdef YYSTYPE_TOSTRING 755 #if YYBTYACC 756 if (!yytrial) 757 #endif /* YYBTYACC */ 758 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval)); 759 #endif 760 fputc('\n', stderr); 761 } 762 #endif 763 } 764 #if YYBTYACC 765 766 /* Do we have a conflict? */ 767 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 && 768 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 769 { 770 YYINT ctry; 771 772 if (yypath) 773 { 774 YYParseState *save; 775 #if YYDEBUG 776 if (yydebug) 777 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n", 778 YYDEBUGSTR, yydepth, yystate); 779 #endif 780 /* Switch to the next conflict context */ 781 save = yypath; 782 yypath = save->save; 783 save->save = NULL; 784 ctry = save->ctry; 785 if (save->state != yystate) YYABORT; 786 yyFreeState(save); 787 788 } 789 else 790 { 791 792 /* Unresolved conflict - start/continue trial parse */ 793 YYParseState *save; 794 #if YYDEBUG 795 if (yydebug) 796 { 797 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate); 798 if (yyps->save) 799 fputs("ALREADY in conflict, continuing trial parse.\n", stderr); 800 else 801 fputs("Starting trial parse.\n", stderr); 802 } 803 #endif 804 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 805 if (save == NULL) goto yyenomem; 806 save->save = yyps->save; 807 save->state = yystate; 808 save->errflag = yyerrflag; 809 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 810 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 811 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base); 812 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 813 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 814 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 815 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 816 #endif 817 ctry = yytable[yyn]; 818 if (yyctable[ctry] == -1) 819 { 820 #if YYDEBUG 821 if (yydebug && yychar >= YYEOF) 822 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth); 823 #endif 824 ctry++; 825 } 826 save->ctry = ctry; 827 if (yyps->save == NULL) 828 { 829 /* If this is a first conflict in the stack, start saving lexemes */ 830 if (!yylexemes) 831 { 832 yylexemes = (YYINT *) malloc((YYLVQUEUEGROWTH) * sizeof(YYINT)); 833 if (yylexemes == NULL) goto yyenomem; 834 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE)); 835 if (yylvals == NULL) goto yyenomem; 836 yylvlim = yylvals + YYLVQUEUEGROWTH; 837 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 838 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE)); 839 if (yylpsns == NULL) goto yyenomem; 840 yylplim = yylpsns + YYLVQUEUEGROWTH; 841 #endif 842 } 843 if (yylvp == yylve) 844 { 845 yylvp = yylve = yylvals; 846 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 847 yylpp = yylpe = yylpsns; 848 #endif 849 yylexp = yylexemes; 850 if (yychar >= YYEOF) 851 { 852 *yylve++ = yylval; 853 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 854 *yylpe++ = yylloc; 855 #endif 856 *yylexp = (YYINT) yychar; 857 yychar = YYEMPTY; 858 } 859 } 860 } 861 if (yychar >= YYEOF) 862 { 863 yylvp--; 864 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 865 yylpp--; 866 #endif 867 yylexp--; 868 yychar = YYEMPTY; 869 } 870 save->lexeme = (int) (yylvp - yylvals); 871 yyps->save = save; 872 } 873 if (yytable[yyn] == ctry) 874 { 875 #if YYDEBUG 876 if (yydebug) 877 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 878 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]); 879 #endif 880 if (yychar < 0) 881 { 882 yylvp++; 883 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 884 yylpp++; 885 #endif 886 yylexp++; 887 } 888 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) 889 goto yyoverflow; 890 yystate = yyctable[ctry]; 891 *++yystack.s_mark = (YYINT) yystate; 892 *++yystack.l_mark = yylval; 893 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 894 *++yystack.p_mark = yylloc; 895 #endif 896 yychar = YYEMPTY; 897 if (yyerrflag > 0) --yyerrflag; 898 goto yyloop; 899 } 900 else 901 { 902 yyn = yyctable[ctry]; 903 goto yyreduce; 904 } 905 } /* End of code dealing with conflicts */ 906 #endif /* YYBTYACC */ 907 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 && 908 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 909 { 910 #if YYDEBUG 911 if (yydebug) 912 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 913 YYDEBUGSTR, yydepth, yystate, yytable[yyn]); 914 #endif 915 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 916 yystate = yytable[yyn]; 917 *++yystack.s_mark = yytable[yyn]; 918 *++yystack.l_mark = yylval; 919 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 920 *++yystack.p_mark = yylloc; 921 #endif 922 yychar = YYEMPTY; 923 if (yyerrflag > 0) --yyerrflag; 924 goto yyloop; 925 } 926 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 && 927 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 928 { 929 yyn = yytable[yyn]; 930 goto yyreduce; 931 } 932 if (yyerrflag != 0) goto yyinrecovery; 933 #if YYBTYACC 934 935 yynewerrflag = 1; 936 goto yyerrhandler; 937 goto yyerrlab; /* redundant goto avoids 'unused label' warning */ 938 939 yyerrlab: 940 /* explicit YYERROR from an action -- pop the rhs of the rule reduced 941 * before looking for error recovery */ 942 yystack.s_mark -= yym; 943 yystate = *yystack.s_mark; 944 yystack.l_mark -= yym; 945 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 946 yystack.p_mark -= yym; 947 #endif 948 949 yynewerrflag = 0; 950 yyerrhandler: 951 while (yyps->save) 952 { 953 int ctry; 954 YYParseState *save = yyps->save; 955 #if YYDEBUG 956 if (yydebug) 957 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n", 958 YYDEBUGSTR, yydepth, yystate, yyps->save->state, 959 (int)(yylvp - yylvals - yyps->save->lexeme)); 960 #endif 961 /* Memorize most forward-looking error state in case it's really an error. */ 962 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals) 963 { 964 /* Free old saved error context state */ 965 if (yyerrctx) yyFreeState(yyerrctx); 966 /* Create and fill out new saved error context state */ 967 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 968 if (yyerrctx == NULL) goto yyenomem; 969 yyerrctx->save = yyps->save; 970 yyerrctx->state = yystate; 971 yyerrctx->errflag = yyerrflag; 972 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 973 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 974 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base); 975 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 976 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 977 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 978 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 979 #endif 980 yyerrctx->lexeme = (int) (yylvp - yylvals); 981 } 982 yylvp = yylvals + save->lexeme; 983 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 984 yylpp = yylpsns + save->lexeme; 985 #endif 986 yylexp = yylexemes + save->lexeme; 987 yychar = YYEMPTY; 988 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 989 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 990 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base); 991 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 992 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 993 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 994 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 995 #endif 996 ctry = ++save->ctry; 997 yystate = save->state; 998 /* We tried shift, try reduce now */ 999 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce; 1000 yyps->save = save->save; 1001 save->save = NULL; 1002 yyFreeState(save); 1003 1004 /* Nothing left on the stack -- error */ 1005 if (!yyps->save) 1006 { 1007 #if YYDEBUG 1008 if (yydebug) 1009 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n", 1010 YYPREFIX, yydepth); 1011 #endif 1012 /* Restore state as it was in the most forward-advanced error */ 1013 yylvp = yylvals + yyerrctx->lexeme; 1014 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1015 yylpp = yylpsns + yyerrctx->lexeme; 1016 #endif 1017 yylexp = yylexemes + yyerrctx->lexeme; 1018 yychar = yylexp[-1]; 1019 yylval = yylvp[-1]; 1020 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1021 yylloc = yylpp[-1]; 1022 #endif 1023 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 1024 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1025 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base); 1026 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1027 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1028 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 1029 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1030 #endif 1031 yystate = yyerrctx->state; 1032 yyFreeState(yyerrctx); 1033 yyerrctx = NULL; 1034 } 1035 yynewerrflag = 1; 1036 } 1037 if (yynewerrflag == 0) goto yyinrecovery; 1038 #endif /* YYBTYACC */ 1039 1040 YYERROR_CALL("syntax error"); 1041 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1042 yyerror_loc_range[1] = yylloc; /* lookahead position is error start position */ 1043 #endif 1044 1045 #if !YYBTYACC 1046 goto yyerrlab; /* redundant goto avoids 'unused label' warning */ 1047 yyerrlab: 1048 #endif 1049 ++yynerrs; 1050 1051 yyinrecovery: 1052 if (yyerrflag < 3) 1053 { 1054 yyerrflag = 3; 1055 for (;;) 1056 { 1057 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 && 1058 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE) 1059 { 1060 #if YYDEBUG 1061 if (yydebug) 1062 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n", 1063 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]); 1064 #endif 1065 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1066 yystate = yytable[yyn]; 1067 *++yystack.s_mark = yytable[yyn]; 1068 *++yystack.l_mark = yylval; 1069 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1070 /* lookahead position is error end position */ 1071 yyerror_loc_range[2] = yylloc; 1072 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */ 1073 *++yystack.p_mark = yyloc; 1074 #endif 1075 goto yyloop; 1076 } 1077 else 1078 { 1079 #if YYDEBUG 1080 if (yydebug) 1081 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n", 1082 YYDEBUGSTR, yydepth, *yystack.s_mark); 1083 #endif 1084 if (yystack.s_mark <= yystack.s_base) goto yyabort; 1085 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1086 /* the current TOS position is the error start position */ 1087 yyerror_loc_range[1] = *yystack.p_mark; 1088 #endif 1089 #if defined(YYDESTRUCT_CALL) 1090 #if YYBTYACC 1091 if (!yytrial) 1092 #endif /* YYBTYACC */ 1093 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1094 YYDESTRUCT_CALL("error: discarding state", 1095 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark); 1096 #else 1097 YYDESTRUCT_CALL("error: discarding state", 1098 yystos[*yystack.s_mark], yystack.l_mark); 1099 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1100 #endif /* defined(YYDESTRUCT_CALL) */ 1101 --yystack.s_mark; 1102 --yystack.l_mark; 1103 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1104 --yystack.p_mark; 1105 #endif 1106 } 1107 } 1108 } 1109 else 1110 { 1111 if (yychar == YYEOF) goto yyabort; 1112 #if YYDEBUG 1113 if (yydebug) 1114 { 1115 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 1116 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n", 1117 YYDEBUGSTR, yydepth, yystate, yychar, yys); 1118 } 1119 #endif 1120 #if defined(YYDESTRUCT_CALL) 1121 #if YYBTYACC 1122 if (!yytrial) 1123 #endif /* YYBTYACC */ 1124 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1125 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc); 1126 #else 1127 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval); 1128 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1129 #endif /* defined(YYDESTRUCT_CALL) */ 1130 yychar = YYEMPTY; 1131 goto yyloop; 1132 } 1133 1134 yyreduce: 1135 yym = yylen[yyn]; 1136 #if YYDEBUG 1137 if (yydebug) 1138 { 1139 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)", 1140 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]); 1141 #ifdef YYSTYPE_TOSTRING 1142 #if YYBTYACC 1143 if (!yytrial) 1144 #endif /* YYBTYACC */ 1145 if (yym > 0) 1146 { 1147 int i; 1148 fputc('<', stderr); 1149 for (i = yym; i > 0; i--) 1150 { 1151 if (i != yym) fputs(", ", stderr); 1152 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]], 1153 yystack.l_mark[1-i]), stderr); 1154 } 1155 fputc('>', stderr); 1156 } 1157 #endif 1158 fputc('\n', stderr); 1159 } 1160 #endif 1161 if (yym > 0) 1162 yyval = yystack.l_mark[1-yym]; 1163 else 1164 memset(&yyval, 0, sizeof yyval); 1165 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1166 1167 /* Perform position reduction */ 1168 memset(&yyloc, 0, sizeof(yyloc)); 1169 #if YYBTYACC 1170 if (!yytrial) 1171 #endif /* YYBTYACC */ 1172 { 1173 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[-yym], yym); 1174 /* just in case YYERROR is invoked within the action, save 1175 the start of the rhs as the error start position */ 1176 yyerror_loc_range[1] = yystack.p_mark[1-yym]; 1177 } 1178 #endif 1179 1180 switch (yyn) 1181 { 1182 case 3: 1183 #line 28 "calc.y" 1184 { yyerrok ; } 1185 #line 1184 "calc.tab.c" 1186 break; 1187 case 4: 1188 #line 32 "calc.y" 1189 { printf("%d\n",yystack.l_mark[0]);} 1190 #line 1189 "calc.tab.c" 1191 break; 1192 case 5: 1193 #line 34 "calc.y" 1194 { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; } 1195 #line 1194 "calc.tab.c" 1196 break; 1197 case 6: 1198 #line 38 "calc.y" 1199 { yyval = yystack.l_mark[-1]; } 1200 #line 1199 "calc.tab.c" 1201 break; 1202 case 7: 1203 #line 40 "calc.y" 1204 { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; } 1205 #line 1204 "calc.tab.c" 1206 break; 1207 case 8: 1208 #line 42 "calc.y" 1209 { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; } 1210 #line 1209 "calc.tab.c" 1211 break; 1212 case 9: 1213 #line 44 "calc.y" 1214 { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; } 1215 #line 1214 "calc.tab.c" 1216 break; 1217 case 10: 1218 #line 46 "calc.y" 1219 { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; } 1220 #line 1219 "calc.tab.c" 1221 break; 1222 case 11: 1223 #line 48 "calc.y" 1224 { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; } 1225 #line 1224 "calc.tab.c" 1226 break; 1227 case 12: 1228 #line 50 "calc.y" 1229 { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; } 1230 #line 1229 "calc.tab.c" 1231 break; 1232 case 13: 1233 #line 52 "calc.y" 1234 { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; } 1235 #line 1234 "calc.tab.c" 1236 break; 1237 case 14: 1238 #line 54 "calc.y" 1239 { yyval = - yystack.l_mark[0]; } 1240 #line 1239 "calc.tab.c" 1241 break; 1242 case 15: 1243 #line 56 "calc.y" 1244 { yyval = regs[yystack.l_mark[0]]; } 1245 #line 1244 "calc.tab.c" 1246 break; 1247 case 17: 1248 #line 61 "calc.y" 1249 { yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; } 1250 #line 1249 "calc.tab.c" 1251 break; 1252 case 18: 1253 #line 63 "calc.y" 1254 { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; } 1255 #line 1254 "calc.tab.c" 1256 break; 1257 #line 1256 "calc.tab.c" 1258 default: 1259 break; 1260 } 1261 yystack.s_mark -= yym; 1262 yystate = *yystack.s_mark; 1263 yystack.l_mark -= yym; 1264 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1265 yystack.p_mark -= yym; 1266 #endif 1267 yym = yylhs[yyn]; 1268 if (yystate == 0 && yym == 0) 1269 { 1270 #if YYDEBUG 1271 if (yydebug) 1272 { 1273 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1274 #ifdef YYSTYPE_TOSTRING 1275 #if YYBTYACC 1276 if (!yytrial) 1277 #endif /* YYBTYACC */ 1278 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval)); 1279 #endif 1280 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL); 1281 } 1282 #endif 1283 yystate = YYFINAL; 1284 *++yystack.s_mark = YYFINAL; 1285 *++yystack.l_mark = yyval; 1286 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1287 *++yystack.p_mark = yyloc; 1288 #endif 1289 if (yychar < 0) 1290 { 1291 #if YYBTYACC 1292 do { 1293 if (yylvp < yylve) 1294 { 1295 /* we're currently re-reading tokens */ 1296 yylval = *yylvp++; 1297 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1298 yylloc = *yylpp++; 1299 #endif 1300 yychar = *yylexp++; 1301 break; 1302 } 1303 if (yyps->save) 1304 { 1305 /* in trial mode; save scanner results for future parse attempts */ 1306 if (yylvp == yylvlim) 1307 { /* Enlarge lexical value queue */ 1308 size_t p = (size_t) (yylvp - yylvals); 1309 size_t s = (size_t) (yylvlim - yylvals); 1310 1311 s += YYLVQUEUEGROWTH; 1312 if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) 1313 goto yyenomem; 1314 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) 1315 goto yyenomem; 1316 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1317 if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) 1318 goto yyenomem; 1319 #endif 1320 yylvp = yylve = yylvals + p; 1321 yylvlim = yylvals + s; 1322 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1323 yylpp = yylpe = yylpsns + p; 1324 yylplim = yylpsns + s; 1325 #endif 1326 yylexp = yylexemes + p; 1327 } 1328 *yylexp = (YYINT) YYLEX; 1329 *yylvp++ = yylval; 1330 yylve++; 1331 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1332 *yylpp++ = yylloc; 1333 yylpe++; 1334 #endif 1335 yychar = *yylexp++; 1336 break; 1337 } 1338 /* normal operation, no conflict encountered */ 1339 #endif /* YYBTYACC */ 1340 yychar = YYLEX; 1341 #if YYBTYACC 1342 } while (0); 1343 #endif /* YYBTYACC */ 1344 if (yychar < 0) yychar = YYEOF; 1345 #if YYDEBUG 1346 if (yydebug) 1347 { 1348 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 1349 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n", 1350 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys); 1351 } 1352 #endif 1353 } 1354 if (yychar == YYEOF) goto yyaccept; 1355 goto yyloop; 1356 } 1357 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 && 1358 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate) 1359 yystate = yytable[yyn]; 1360 else 1361 yystate = yydgoto[yym]; 1362 #if YYDEBUG 1363 if (yydebug) 1364 { 1365 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1366 #ifdef YYSTYPE_TOSTRING 1367 #if YYBTYACC 1368 if (!yytrial) 1369 #endif /* YYBTYACC */ 1370 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval)); 1371 #endif 1372 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate); 1373 } 1374 #endif 1375 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1376 *++yystack.s_mark = (YYINT) yystate; 1377 *++yystack.l_mark = yyval; 1378 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1379 *++yystack.p_mark = yyloc; 1380 #endif 1381 goto yyloop; 1382 #if YYBTYACC 1383 1384 /* Reduction declares that this path is valid. Set yypath and do a full parse */ 1385 yyvalid: 1386 if (yypath) YYABORT; 1387 while (yyps->save) 1388 { 1389 YYParseState *save = yyps->save; 1390 yyps->save = save->save; 1391 save->save = yypath; 1392 yypath = save; 1393 } 1394 #if YYDEBUG 1395 if (yydebug) 1396 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n", 1397 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme)); 1398 #endif 1399 if (yyerrctx) 1400 { 1401 yyFreeState(yyerrctx); 1402 yyerrctx = NULL; 1403 } 1404 yylvp = yylvals + yypath->lexeme; 1405 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1406 yylpp = yylpsns + yypath->lexeme; 1407 #endif 1408 yylexp = yylexemes + yypath->lexeme; 1409 yychar = YYEMPTY; 1410 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 1411 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1412 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base); 1413 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1414 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1415 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 1416 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1417 #endif 1418 yystate = yypath->state; 1419 goto yyloop; 1420 #endif /* YYBTYACC */ 1421 1422 yyoverflow: 1423 YYERROR_CALL("yacc stack overflow"); 1424 #if YYBTYACC 1425 goto yyabort_nomem; 1426 yyenomem: 1427 YYERROR_CALL("memory exhausted"); 1428 yyabort_nomem: 1429 #endif /* YYBTYACC */ 1430 yyresult = 2; 1431 goto yyreturn; 1432 1433 yyabort: 1434 yyresult = 1; 1435 goto yyreturn; 1436 1437 yyaccept: 1438 #if YYBTYACC 1439 if (yyps->save) goto yyvalid; 1440 #endif /* YYBTYACC */ 1441 yyresult = 0; 1442 1443 yyreturn: 1444 #if defined(YYDESTRUCT_CALL) 1445 if (yychar != YYEOF && yychar != YYEMPTY) 1446 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1447 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc); 1448 #else 1449 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval); 1450 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1451 1452 { 1453 YYSTYPE *pv; 1454 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1455 YYLTYPE *pp; 1456 1457 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp) 1458 YYDESTRUCT_CALL("cleanup: discarding state", 1459 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp); 1460 #else 1461 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv) 1462 YYDESTRUCT_CALL("cleanup: discarding state", 1463 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv); 1464 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1465 } 1466 #endif /* defined(YYDESTRUCT_CALL) */ 1467 1468 #if YYBTYACC 1469 if (yyerrctx) 1470 { 1471 yyFreeState(yyerrctx); 1472 yyerrctx = NULL; 1473 } 1474 while (yyps) 1475 { 1476 YYParseState *save = yyps; 1477 yyps = save->save; 1478 save->save = NULL; 1479 yyFreeState(save); 1480 } 1481 while (yypath) 1482 { 1483 YYParseState *save = yypath; 1484 yypath = save->save; 1485 save->save = NULL; 1486 yyFreeState(save); 1487 } 1488 #endif /* YYBTYACC */ 1489 yyfreestack(&yystack); 1490 return (yyresult); 1491 } 1492