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