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