calc3.tab.c revision 1.2
1/* $NetBSD: calc3.tab.c,v 1.2 2017/02/11 19:33:12 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 681#if YYBTYACC 682 yyps = yyNewState(0); if (yyps == 0) goto yyenomem; 683 yyps->save = 0; 684#endif /* YYBTYACC */ 685 yym = 0; 686 yyn = 0; 687 yynerrs = 0; 688 yyerrflag = 0; 689 yychar = YYEMPTY; 690 yystate = 0; 691 692#if YYPURE 693 memset(&yystack, 0, sizeof(yystack)); 694#endif 695 696 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 697 yystack.s_mark = yystack.s_base; 698 yystack.l_mark = yystack.l_base; 699#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 700 yystack.p_mark = yystack.p_base; 701#endif 702 yystate = 0; 703 *yystack.s_mark = 0; 704 705yyloop: 706 if ((yyn = yydefred[yystate]) != 0) goto yyreduce; 707 if (yychar < 0) 708 { 709#if YYBTYACC 710 do { 711 if (yylvp < yylve) 712 { 713 /* we're currently re-reading tokens */ 714 yylval = *yylvp++; 715#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 716 yylloc = *yylpp++; 717#endif 718 yychar = *yylexp++; 719 break; 720 } 721 if (yyps->save) 722 { 723 /* in trial mode; save scanner results for future parse attempts */ 724 if (yylvp == yylvlim) 725 { /* Enlarge lexical value queue */ 726 size_t p = (size_t) (yylvp - yylvals); 727 size_t s = (size_t) (yylvlim - yylvals); 728 729 s += YYLVQUEUEGROWTH; 730 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem; 731 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem; 732#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 733 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem; 734#endif 735 yylvp = yylve = yylvals + p; 736 yylvlim = yylvals + s; 737#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 738 yylpp = yylpe = yylpsns + p; 739 yylplim = yylpsns + s; 740#endif 741 yylexp = yylexemes + p; 742 } 743 *yylexp = (YYINT) YYLEX; 744 *yylvp++ = yylval; 745 yylve++; 746#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 747 *yylpp++ = yylloc; 748 yylpe++; 749#endif 750 yychar = *yylexp++; 751 break; 752 } 753 /* normal operation, no conflict encountered */ 754#endif /* YYBTYACC */ 755 yychar = YYLEX; 756#if YYBTYACC 757 } while (0); 758#endif /* YYBTYACC */ 759 if (yychar < 0) yychar = YYEOF; 760#if YYDEBUG 761 if (yydebug) 762 { 763 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 764 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)", 765 YYDEBUGSTR, yydepth, yystate, yychar, yys); 766#ifdef YYSTYPE_TOSTRING 767#if YYBTYACC 768 if (!yytrial) 769#endif /* YYBTYACC */ 770 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval)); 771#endif 772 fputc('\n', stderr); 773 } 774#endif 775 } 776#if YYBTYACC 777 778 /* Do we have a conflict? */ 779 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 && 780 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 781 { 782 YYINT ctry; 783 784 if (yypath) 785 { 786 YYParseState *save; 787#if YYDEBUG 788 if (yydebug) 789 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n", 790 YYDEBUGSTR, yydepth, yystate); 791#endif 792 /* Switch to the next conflict context */ 793 save = yypath; 794 yypath = save->save; 795 save->save = NULL; 796 ctry = save->ctry; 797 if (save->state != yystate) YYABORT; 798 yyFreeState(save); 799 800 } 801 else 802 { 803 804 /* Unresolved conflict - start/continue trial parse */ 805 YYParseState *save; 806#if YYDEBUG 807 if (yydebug) 808 { 809 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate); 810 if (yyps->save) 811 fputs("ALREADY in conflict, continuing trial parse.\n", stderr); 812 else 813 fputs("Starting trial parse.\n", stderr); 814 } 815#endif 816 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 817 if (save == NULL) goto yyenomem; 818 save->save = yyps->save; 819 save->state = yystate; 820 save->errflag = yyerrflag; 821 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 822 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 823 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base); 824 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 825#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 826 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 827 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 828#endif 829 ctry = yytable[yyn]; 830 if (yyctable[ctry] == -1) 831 { 832#if YYDEBUG 833 if (yydebug && yychar >= YYEOF) 834 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth); 835#endif 836 ctry++; 837 } 838 save->ctry = ctry; 839 if (yyps->save == NULL) 840 { 841 /* If this is a first conflict in the stack, start saving lexemes */ 842 if (!yylexemes) 843 { 844 yylexemes = malloc((YYLVQUEUEGROWTH) * sizeof(YYINT)); 845 if (yylexemes == NULL) goto yyenomem; 846 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE)); 847 if (yylvals == NULL) goto yyenomem; 848 yylvlim = yylvals + YYLVQUEUEGROWTH; 849#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 850 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE)); 851 if (yylpsns == NULL) goto yyenomem; 852 yylplim = yylpsns + YYLVQUEUEGROWTH; 853#endif 854 } 855 if (yylvp == yylve) 856 { 857 yylvp = yylve = yylvals; 858#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 859 yylpp = yylpe = yylpsns; 860#endif 861 yylexp = yylexemes; 862 if (yychar >= YYEOF) 863 { 864 *yylve++ = yylval; 865#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 866 *yylpe++ = yylloc; 867#endif 868 *yylexp = (YYINT) yychar; 869 yychar = YYEMPTY; 870 } 871 } 872 } 873 if (yychar >= YYEOF) 874 { 875 yylvp--; 876#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 877 yylpp--; 878#endif 879 yylexp--; 880 yychar = YYEMPTY; 881 } 882 save->lexeme = (int) (yylvp - yylvals); 883 yyps->save = save; 884 } 885 if (yytable[yyn] == ctry) 886 { 887#if YYDEBUG 888 if (yydebug) 889 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 890 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]); 891#endif 892 if (yychar < 0) 893 { 894 yylvp++; 895#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 896 yylpp++; 897#endif 898 yylexp++; 899 } 900 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) 901 goto yyoverflow; 902 yystate = yyctable[ctry]; 903 *++yystack.s_mark = (YYINT) yystate; 904 *++yystack.l_mark = yylval; 905#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 906 *++yystack.p_mark = yylloc; 907#endif 908 yychar = YYEMPTY; 909 if (yyerrflag > 0) --yyerrflag; 910 goto yyloop; 911 } 912 else 913 { 914 yyn = yyctable[ctry]; 915 goto yyreduce; 916 } 917 } /* End of code dealing with conflicts */ 918#endif /* YYBTYACC */ 919 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 && 920 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 921 { 922#if YYDEBUG 923 if (yydebug) 924 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 925 YYDEBUGSTR, yydepth, yystate, yytable[yyn]); 926#endif 927 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 928 yystate = yytable[yyn]; 929 *++yystack.s_mark = yytable[yyn]; 930 *++yystack.l_mark = yylval; 931#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 932 *++yystack.p_mark = yylloc; 933#endif 934 yychar = YYEMPTY; 935 if (yyerrflag > 0) --yyerrflag; 936 goto yyloop; 937 } 938 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 && 939 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 940 { 941 yyn = yytable[yyn]; 942 goto yyreduce; 943 } 944 if (yyerrflag != 0) goto yyinrecovery; 945#if YYBTYACC 946 947 yynewerrflag = 1; 948 goto yyerrhandler; 949 goto yyerrlab; /* redundant goto avoids 'unused label' warning */ 950 951yyerrlab: 952 /* explicit YYERROR from an action -- pop the rhs of the rule reduced 953 * before looking for error recovery */ 954 yystack.s_mark -= yym; 955 yystate = *yystack.s_mark; 956 yystack.l_mark -= yym; 957#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 958 yystack.p_mark -= yym; 959#endif 960 961 yynewerrflag = 0; 962yyerrhandler: 963 while (yyps->save) 964 { 965 int ctry; 966 YYParseState *save = yyps->save; 967#if YYDEBUG 968 if (yydebug) 969 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n", 970 YYDEBUGSTR, yydepth, yystate, yyps->save->state, 971 (int)(yylvp - yylvals - yyps->save->lexeme)); 972#endif 973 /* Memorize most forward-looking error state in case it's really an error. */ 974 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals) 975 { 976 /* Free old saved error context state */ 977 if (yyerrctx) yyFreeState(yyerrctx); 978 /* Create and fill out new saved error context state */ 979 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 980 if (yyerrctx == NULL) goto yyenomem; 981 yyerrctx->save = yyps->save; 982 yyerrctx->state = yystate; 983 yyerrctx->errflag = yyerrflag; 984 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 985 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 986 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base); 987 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 988#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 989 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 990 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 991#endif 992 yyerrctx->lexeme = (int) (yylvp - yylvals); 993 } 994 yylvp = yylvals + save->lexeme; 995#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 996 yylpp = yylpsns + save->lexeme; 997#endif 998 yylexp = yylexemes + save->lexeme; 999 yychar = YYEMPTY; 1000 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 1001 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1002 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base); 1003 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1004#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1005 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 1006 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1007#endif 1008 ctry = ++save->ctry; 1009 yystate = save->state; 1010 /* We tried shift, try reduce now */ 1011 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce; 1012 yyps->save = save->save; 1013 save->save = NULL; 1014 yyFreeState(save); 1015 1016 /* Nothing left on the stack -- error */ 1017 if (!yyps->save) 1018 { 1019#if YYDEBUG 1020 if (yydebug) 1021 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n", 1022 YYPREFIX, yydepth); 1023#endif 1024 /* Restore state as it was in the most forward-advanced error */ 1025 yylvp = yylvals + yyerrctx->lexeme; 1026#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1027 yylpp = yylpsns + yyerrctx->lexeme; 1028#endif 1029 yylexp = yylexemes + yyerrctx->lexeme; 1030 yychar = yylexp[-1]; 1031 yylval = yylvp[-1]; 1032#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1033 yylloc = yylpp[-1]; 1034#endif 1035 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 1036 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1037 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base); 1038 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1039#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1040 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 1041 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1042#endif 1043 yystate = yyerrctx->state; 1044 yyFreeState(yyerrctx); 1045 yyerrctx = NULL; 1046 } 1047 yynewerrflag = 1; 1048 } 1049 if (yynewerrflag == 0) goto yyinrecovery; 1050#endif /* YYBTYACC */ 1051 1052 YYERROR_CALL("syntax error"); 1053#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1054 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */ 1055#endif 1056 1057#if !YYBTYACC 1058 goto yyerrlab; /* redundant goto avoids 'unused label' warning */ 1059yyerrlab: 1060#endif 1061 ++yynerrs; 1062 1063yyinrecovery: 1064 if (yyerrflag < 3) 1065 { 1066 yyerrflag = 3; 1067 for (;;) 1068 { 1069 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 && 1070 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE) 1071 { 1072#if YYDEBUG 1073 if (yydebug) 1074 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n", 1075 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]); 1076#endif 1077 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1078 yystate = yytable[yyn]; 1079 *++yystack.s_mark = yytable[yyn]; 1080 *++yystack.l_mark = yylval; 1081#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1082 /* lookahead position is error end position */ 1083 yyerror_loc_range[1] = yylloc; 1084 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */ 1085 *++yystack.p_mark = yyloc; 1086#endif 1087 goto yyloop; 1088 } 1089 else 1090 { 1091#if YYDEBUG 1092 if (yydebug) 1093 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n", 1094 YYDEBUGSTR, yydepth, *yystack.s_mark); 1095#endif 1096 if (yystack.s_mark <= yystack.s_base) goto yyabort; 1097#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1098 /* the current TOS position is the error start position */ 1099 yyerror_loc_range[0] = *yystack.p_mark; 1100#endif 1101#if defined(YYDESTRUCT_CALL) 1102#if YYBTYACC 1103 if (!yytrial) 1104#endif /* YYBTYACC */ 1105#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1106 YYDESTRUCT_CALL("error: discarding state", 1107 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark); 1108#else 1109 YYDESTRUCT_CALL("error: discarding state", 1110 yystos[*yystack.s_mark], yystack.l_mark); 1111#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1112#endif /* defined(YYDESTRUCT_CALL) */ 1113 --yystack.s_mark; 1114 --yystack.l_mark; 1115#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1116 --yystack.p_mark; 1117#endif 1118 } 1119 } 1120 } 1121 else 1122 { 1123 if (yychar == YYEOF) goto yyabort; 1124#if YYDEBUG 1125 if (yydebug) 1126 { 1127 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 1128 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n", 1129 YYDEBUGSTR, yydepth, yystate, yychar, yys); 1130 } 1131#endif 1132#if defined(YYDESTRUCT_CALL) 1133#if YYBTYACC 1134 if (!yytrial) 1135#endif /* YYBTYACC */ 1136#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1137 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc); 1138#else 1139 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval); 1140#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1141#endif /* defined(YYDESTRUCT_CALL) */ 1142 yychar = YYEMPTY; 1143 goto yyloop; 1144 } 1145 1146yyreduce: 1147 yym = yylen[yyn]; 1148#if YYDEBUG 1149 if (yydebug) 1150 { 1151 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)", 1152 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]); 1153#ifdef YYSTYPE_TOSTRING 1154#if YYBTYACC 1155 if (!yytrial) 1156#endif /* YYBTYACC */ 1157 if (yym > 0) 1158 { 1159 int i; 1160 fputc('<', stderr); 1161 for (i = yym; i > 0; i--) 1162 { 1163 if (i != yym) fputs(", ", stderr); 1164 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]], 1165 yystack.l_mark[1-i]), stderr); 1166 } 1167 fputc('>', stderr); 1168 } 1169#endif 1170 fputc('\n', stderr); 1171 } 1172#endif 1173 if (yym > 0) 1174 yyval = yystack.l_mark[1-yym]; 1175 else 1176 memset(&yyval, 0, sizeof yyval); 1177#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1178 1179 /* Perform position reduction */ 1180 memset(&yyloc, 0, sizeof(yyloc)); 1181#if YYBTYACC 1182 if (!yytrial) 1183#endif /* YYBTYACC */ 1184 { 1185 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym); 1186 /* just in case YYERROR is invoked within the action, save 1187 the start of the rhs as the error start position */ 1188 yyerror_loc_range[0] = yystack.p_mark[1-yym]; 1189 } 1190#endif 1191 1192 switch (yyn) 1193 { 1194case 3: 1195#line 38 "calc3.y" 1196 { yyerrok ; } 1197break; 1198case 4: 1199#line 42 "calc3.y" 1200 { printf("%d\n",yystack.l_mark[0]);} 1201break; 1202case 5: 1203#line 44 "calc3.y" 1204 { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; } 1205break; 1206case 6: 1207#line 48 "calc3.y" 1208 { yyval = yystack.l_mark[-1]; } 1209break; 1210case 7: 1211#line 50 "calc3.y" 1212 { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; } 1213break; 1214case 8: 1215#line 52 "calc3.y" 1216 { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; } 1217break; 1218case 9: 1219#line 54 "calc3.y" 1220 { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; } 1221break; 1222case 10: 1223#line 56 "calc3.y" 1224 { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; } 1225break; 1226case 11: 1227#line 58 "calc3.y" 1228 { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; } 1229break; 1230case 12: 1231#line 60 "calc3.y" 1232 { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; } 1233break; 1234case 13: 1235#line 62 "calc3.y" 1236 { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; } 1237break; 1238case 14: 1239#line 64 "calc3.y" 1240 { yyval = - yystack.l_mark[0]; } 1241break; 1242case 15: 1243#line 66 "calc3.y" 1244 { yyval = regs[yystack.l_mark[0]]; } 1245break; 1246case 17: 1247#line 71 "calc3.y" 1248 { yyval = yystack.l_mark[0]; (*base) = (yystack.l_mark[0]==0) ? 8 : 10; } 1249break; 1250case 18: 1251#line 73 "calc3.y" 1252 { yyval = (*base) * yystack.l_mark[-1] + yystack.l_mark[0]; } 1253break; 1254#line 1253 "calc3.tab.c" 1255 default: 1256 break; 1257 } 1258 yystack.s_mark -= yym; 1259 yystate = *yystack.s_mark; 1260 yystack.l_mark -= yym; 1261#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1262 yystack.p_mark -= yym; 1263#endif 1264 yym = yylhs[yyn]; 1265 if (yystate == 0 && yym == 0) 1266 { 1267#if YYDEBUG 1268 if (yydebug) 1269 { 1270 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1271#ifdef YYSTYPE_TOSTRING 1272#if YYBTYACC 1273 if (!yytrial) 1274#endif /* YYBTYACC */ 1275 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval)); 1276#endif 1277 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL); 1278 } 1279#endif 1280 yystate = YYFINAL; 1281 *++yystack.s_mark = YYFINAL; 1282 *++yystack.l_mark = yyval; 1283#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1284 *++yystack.p_mark = yyloc; 1285#endif 1286 if (yychar < 0) 1287 { 1288#if YYBTYACC 1289 do { 1290 if (yylvp < yylve) 1291 { 1292 /* we're currently re-reading tokens */ 1293 yylval = *yylvp++; 1294#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1295 yylloc = *yylpp++; 1296#endif 1297 yychar = *yylexp++; 1298 break; 1299 } 1300 if (yyps->save) 1301 { 1302 /* in trial mode; save scanner results for future parse attempts */ 1303 if (yylvp == yylvlim) 1304 { /* Enlarge lexical value queue */ 1305 size_t p = (size_t) (yylvp - yylvals); 1306 size_t s = (size_t) (yylvlim - yylvals); 1307 1308 s += YYLVQUEUEGROWTH; 1309 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL) 1310 goto yyenomem; 1311 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) 1312 goto yyenomem; 1313#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1314 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) 1315 goto yyenomem; 1316#endif 1317 yylvp = yylve = yylvals + p; 1318 yylvlim = yylvals + s; 1319#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1320 yylpp = yylpe = yylpsns + p; 1321 yylplim = yylpsns + s; 1322#endif 1323 yylexp = yylexemes + p; 1324 } 1325 *yylexp = (YYINT) YYLEX; 1326 *yylvp++ = yylval; 1327 yylve++; 1328#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1329 *yylpp++ = yylloc; 1330 yylpe++; 1331#endif 1332 yychar = *yylexp++; 1333 break; 1334 } 1335 /* normal operation, no conflict encountered */ 1336#endif /* YYBTYACC */ 1337 yychar = YYLEX; 1338#if YYBTYACC 1339 } while (0); 1340#endif /* YYBTYACC */ 1341 if (yychar < 0) yychar = YYEOF; 1342#if YYDEBUG 1343 if (yydebug) 1344 { 1345 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 1346 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n", 1347 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys); 1348 } 1349#endif 1350 } 1351 if (yychar == YYEOF) goto yyaccept; 1352 goto yyloop; 1353 } 1354 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 && 1355 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate) 1356 yystate = yytable[yyn]; 1357 else 1358 yystate = yydgoto[yym]; 1359#if YYDEBUG 1360 if (yydebug) 1361 { 1362 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1363#ifdef YYSTYPE_TOSTRING 1364#if YYBTYACC 1365 if (!yytrial) 1366#endif /* YYBTYACC */ 1367 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval)); 1368#endif 1369 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate); 1370 } 1371#endif 1372 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1373 *++yystack.s_mark = (YYINT) yystate; 1374 *++yystack.l_mark = yyval; 1375#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1376 *++yystack.p_mark = yyloc; 1377#endif 1378 goto yyloop; 1379#if YYBTYACC 1380 1381 /* Reduction declares that this path is valid. Set yypath and do a full parse */ 1382yyvalid: 1383 if (yypath) YYABORT; 1384 while (yyps->save) 1385 { 1386 YYParseState *save = yyps->save; 1387 yyps->save = save->save; 1388 save->save = yypath; 1389 yypath = save; 1390 } 1391#if YYDEBUG 1392 if (yydebug) 1393 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n", 1394 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme)); 1395#endif 1396 if (yyerrctx) 1397 { 1398 yyFreeState(yyerrctx); 1399 yyerrctx = NULL; 1400 } 1401 yylvp = yylvals + yypath->lexeme; 1402#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1403 yylpp = yylpsns + yypath->lexeme; 1404#endif 1405 yylexp = yylexemes + yypath->lexeme; 1406 yychar = YYEMPTY; 1407 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 1408 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1409 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base); 1410 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1411#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1412 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 1413 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1414#endif 1415 yystate = yypath->state; 1416 goto yyloop; 1417#endif /* YYBTYACC */ 1418 1419yyoverflow: 1420 YYERROR_CALL("yacc stack overflow"); 1421#if YYBTYACC 1422 goto yyabort_nomem; 1423yyenomem: 1424 YYERROR_CALL("memory exhausted"); 1425yyabort_nomem: 1426#endif /* YYBTYACC */ 1427 yyresult = 2; 1428 goto yyreturn; 1429 1430yyabort: 1431 yyresult = 1; 1432 goto yyreturn; 1433 1434yyaccept: 1435#if YYBTYACC 1436 if (yyps->save) goto yyvalid; 1437#endif /* YYBTYACC */ 1438 yyresult = 0; 1439 1440yyreturn: 1441#if defined(YYDESTRUCT_CALL) 1442 if (yychar != YYEOF && yychar != YYEMPTY) 1443#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1444 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc); 1445#else 1446 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval); 1447#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1448 1449 { 1450 YYSTYPE *pv; 1451#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1452 YYLTYPE *pp; 1453 1454 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp) 1455 YYDESTRUCT_CALL("cleanup: discarding state", 1456 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp); 1457#else 1458 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv) 1459 YYDESTRUCT_CALL("cleanup: discarding state", 1460 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv); 1461#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1462 } 1463#endif /* defined(YYDESTRUCT_CALL) */ 1464 1465#if YYBTYACC 1466 if (yyerrctx) 1467 { 1468 yyFreeState(yyerrctx); 1469 yyerrctx = NULL; 1470 } 1471 while (yyps) 1472 { 1473 YYParseState *save = yyps; 1474 yyps = save->save; 1475 save->save = NULL; 1476 yyFreeState(save); 1477 } 1478 while (yypath) 1479 { 1480 YYParseState *save = yypath; 1481 yypath = save->save; 1482 save->save = NULL; 1483 yyFreeState(save); 1484 } 1485#endif /* YYBTYACC */ 1486 yyfreestack(&yystack); 1487 return (yyresult); 1488} 1489