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