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