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 2 7 #define YYMINOR 0 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 27 int regs[26]; 28 int base; 29 30 extern int yylex(void); 31 static void yyerror(const char *s); 32 33 #line 34 "stdin2.calc.c" 34 35 #if ! defined(YYSTYPE) && ! defined(YYSTYPE_IS_DECLARED) 36 /* Default: YYSTYPE is the semantic value type. */ 37 typedef 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)) 63 int 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 74 extern int YYPARSE_DECL(); 75 76 #define DIGIT 257 77 #define LETTER 258 78 #define UMINUS 259 79 #define YYERRCODE 256 80 typedef int YYINT; 81 static 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 }; 85 static 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 }; 89 static 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) 96 static 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 */ 103 static const YYINT yydgoto[] = { 1, 104 7, 8, 9, 105 }; 106 static 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 }; 112 static 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 119 static 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 126 static const YYINT yygindex[] = { 0, 127 0, 65, 0, 128 }; 129 #define YYTABLESIZE 220 130 static 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 }; 154 static 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 179 static 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 212 static 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, 215 0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0, 216 0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 217 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,0,0,0,0,0,0,0,0, 218 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 219 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 220 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 221 0,0,"error","DIGIT","LETTER","UMINUS","$accept","list","stat","expr","number", 222 "illegal-symbol", 223 }; 224 static 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 249 int yydebug; 250 #endif 251 252 int yyerrflag; 253 int yychar; 254 YYSTYPE yyval; 255 YYSTYPE yylval; 256 int yynerrs; 257 258 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 259 YYLTYPE yyloc; /* position returned by actions */ 260 YYLTYPE 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) \ 266 do \ 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 309 typedef 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 323 struct 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 }; 332 typedef struct YYParseState_s YYParseState; 333 #endif /* YYBTYACC */ 334 /* variables for the parser stack */ 335 static YYSTACKDATA yystack; 336 #if YYBTYACC 337 338 /* Current parser state */ 339 static YYParseState *yyps = 0; 340 341 /* yypath != NULL: do the full parse, starting at *yypath parser state. */ 342 static YYParseState *yypath = 0; 343 344 /* Base of the lexical value queue */ 345 static YYSTYPE *yylvals = 0; 346 347 /* Current position at lexical value queue */ 348 static YYSTYPE *yylvp = 0; 349 350 /* End position of lexical value queue */ 351 static YYSTYPE *yylve = 0; 352 353 /* The last allocated position at the lexical value queue */ 354 static YYSTYPE *yylvlim = 0; 355 356 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 357 /* Base of the lexical position queue */ 358 static YYLTYPE *yylpsns = 0; 359 360 /* Current position at lexical position queue */ 361 static YYLTYPE *yylpp = 0; 362 363 /* End position of lexical position queue */ 364 static YYLTYPE *yylpe = 0; 365 366 /* The last allocated position at the lexical position queue */ 367 static YYLTYPE *yylplim = 0; 368 #endif 369 370 /* Current position at lexical token queue */ 371 static YYINT *yylexp = 0; 372 373 static YYINT *yylexemes = 0; 374 #endif /* YYBTYACC */ 375 #line 66 "calc.y" 376 /* start of programs */ 377 378 int 379 main (void) 380 { 381 while(!feof(stdin)) { 382 yyparse(); 383 } 384 return 0; 385 } 386 387 static void 388 yyerror(const char *s) 389 { 390 fprintf(stderr, "%s\n", s); 391 } 392 393 int 394 yylex(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 "stdin2.calc.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 */ 433 static 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 == NULL) 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 == NULL) 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 == NULL) 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) 485 static 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 499 static YYParseState * 500 yyNewState(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 529 static void 530 yyFreeState(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 547 int 548 YYPARSE_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")) != NULL) 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 is set below */ 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 598 yyloop: 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 844 yyerrlab: 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; 855 yyerrhandler: 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 */ 952 yyerrlab: 953 #endif 954 ++yynerrs; 955 956 yyinrecovery: 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 1039 yyreduce: 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 { 1087 case 3: 1088 #line 28 "calc.y" 1089 { yyerrok ; } 1090 #line 1091 "stdin2.calc.c" 1091 break; 1092 case 4: 1093 #line 32 "calc.y" 1094 { printf("%d\n",yystack.l_mark[0]);} 1095 #line 1096 "stdin2.calc.c" 1096 break; 1097 case 5: 1098 #line 34 "calc.y" 1099 { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; } 1100 #line 1101 "stdin2.calc.c" 1101 break; 1102 case 6: 1103 #line 38 "calc.y" 1104 { yyval = yystack.l_mark[-1]; } 1105 #line 1106 "stdin2.calc.c" 1106 break; 1107 case 7: 1108 #line 40 "calc.y" 1109 { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; } 1110 #line 1111 "stdin2.calc.c" 1111 break; 1112 case 8: 1113 #line 42 "calc.y" 1114 { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; } 1115 #line 1116 "stdin2.calc.c" 1116 break; 1117 case 9: 1118 #line 44 "calc.y" 1119 { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; } 1120 #line 1121 "stdin2.calc.c" 1121 break; 1122 case 10: 1123 #line 46 "calc.y" 1124 { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; } 1125 #line 1126 "stdin2.calc.c" 1126 break; 1127 case 11: 1128 #line 48 "calc.y" 1129 { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; } 1130 #line 1131 "stdin2.calc.c" 1131 break; 1132 case 12: 1133 #line 50 "calc.y" 1134 { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; } 1135 #line 1136 "stdin2.calc.c" 1136 break; 1137 case 13: 1138 #line 52 "calc.y" 1139 { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; } 1140 #line 1141 "stdin2.calc.c" 1141 break; 1142 case 14: 1143 #line 54 "calc.y" 1144 { yyval = - yystack.l_mark[0]; } 1145 #line 1146 "stdin2.calc.c" 1146 break; 1147 case 15: 1148 #line 56 "calc.y" 1149 { yyval = regs[yystack.l_mark[0]]; } 1150 #line 1151 "stdin2.calc.c" 1151 break; 1152 case 17: 1153 #line 61 "calc.y" 1154 { yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; } 1155 #line 1156 "stdin2.calc.c" 1156 break; 1157 case 18: 1158 #line 63 "calc.y" 1159 { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; } 1160 #line 1161 "stdin2.calc.c" 1161 break; 1162 #line 1163 "stdin2.calc.c" 1163 default: 1164 break; 1165 } 1166 yystack.s_mark -= yym; 1167 yystate = *yystack.s_mark; 1168 yystack.l_mark -= yym; 1169 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1170 yystack.p_mark -= yym; 1171 #endif 1172 yym = yylhs[yyn]; 1173 if (yystate == 0 && yym == 0) 1174 { 1175 #if YYDEBUG 1176 if (yydebug) 1177 { 1178 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1179 #ifdef YYSTYPE_TOSTRING 1180 #if YYBTYACC 1181 if (!yytrial) 1182 #endif /* YYBTYACC */ 1183 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval)); 1184 #endif 1185 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL); 1186 } 1187 #endif 1188 yystate = YYFINAL; 1189 *++yystack.s_mark = YYFINAL; 1190 *++yystack.l_mark = yyval; 1191 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1192 *++yystack.p_mark = yyloc; 1193 #endif 1194 if (yychar < 0) 1195 { 1196 #if YYBTYACC 1197 do { 1198 if (yylvp < yylve) 1199 { 1200 /* we're currently re-reading tokens */ 1201 yylval = *yylvp++; 1202 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1203 yylloc = *yylpp++; 1204 #endif 1205 yychar = *yylexp++; 1206 break; 1207 } 1208 if (yyps->save) 1209 { 1210 /* in trial mode; save scanner results for future parse attempts */ 1211 if (yylvp == yylvlim) 1212 { /* Enlarge lexical value queue */ 1213 size_t p = (size_t) (yylvp - yylvals); 1214 size_t s = (size_t) (yylvlim - yylvals); 1215 1216 s += YYLVQUEUEGROWTH; 1217 if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) 1218 goto yyenomem; 1219 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) 1220 goto yyenomem; 1221 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1222 if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) 1223 goto yyenomem; 1224 #endif 1225 yylvp = yylve = yylvals + p; 1226 yylvlim = yylvals + s; 1227 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1228 yylpp = yylpe = yylpsns + p; 1229 yylplim = yylpsns + s; 1230 #endif 1231 yylexp = yylexemes + p; 1232 } 1233 *yylexp = (YYINT) YYLEX; 1234 *yylvp++ = yylval; 1235 yylve++; 1236 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1237 *yylpp++ = yylloc; 1238 yylpe++; 1239 #endif 1240 yychar = *yylexp++; 1241 break; 1242 } 1243 /* normal operation, no conflict encountered */ 1244 #endif /* YYBTYACC */ 1245 yychar = YYLEX; 1246 #if YYBTYACC 1247 } while (0); 1248 #endif /* YYBTYACC */ 1249 if (yychar < 0) yychar = YYEOF; 1250 #if YYDEBUG 1251 if (yydebug) 1252 { 1253 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 1254 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n", 1255 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys); 1256 } 1257 #endif 1258 } 1259 if (yychar == YYEOF) goto yyaccept; 1260 goto yyloop; 1261 } 1262 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 && 1263 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate) 1264 yystate = yytable[yyn]; 1265 else 1266 yystate = yydgoto[yym]; 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[yystate], yyval)); 1276 #endif 1277 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate); 1278 } 1279 #endif 1280 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1281 *++yystack.s_mark = (YYINT) yystate; 1282 *++yystack.l_mark = yyval; 1283 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1284 *++yystack.p_mark = yyloc; 1285 #endif 1286 goto yyloop; 1287 #if YYBTYACC 1288 1289 /* Reduction declares that this path is valid. Set yypath and do a full parse */ 1290 yyvalid: 1291 if (yypath) YYABORT; 1292 while (yyps->save) 1293 { 1294 YYParseState *save = yyps->save; 1295 yyps->save = save->save; 1296 save->save = yypath; 1297 yypath = save; 1298 } 1299 #if YYDEBUG 1300 if (yydebug) 1301 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n", 1302 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme)); 1303 #endif 1304 if (yyerrctx) 1305 { 1306 yyFreeState(yyerrctx); 1307 yyerrctx = NULL; 1308 } 1309 yylvp = yylvals + yypath->lexeme; 1310 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1311 yylpp = yylpsns + yypath->lexeme; 1312 #endif 1313 yylexp = yylexemes + yypath->lexeme; 1314 yychar = YYEMPTY; 1315 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 1316 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1317 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base); 1318 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1319 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1320 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 1321 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1322 #endif 1323 yystate = yypath->state; 1324 goto yyloop; 1325 #endif /* YYBTYACC */ 1326 1327 yyoverflow: 1328 YYERROR_CALL("yacc stack overflow"); 1329 #if YYBTYACC 1330 goto yyabort_nomem; 1331 yyenomem: 1332 YYERROR_CALL("memory exhausted"); 1333 yyabort_nomem: 1334 #endif /* YYBTYACC */ 1335 yyresult = 2; 1336 goto yyreturn; 1337 1338 yyabort: 1339 yyresult = 1; 1340 goto yyreturn; 1341 1342 yyaccept: 1343 #if YYBTYACC 1344 if (yyps->save) goto yyvalid; 1345 #endif /* YYBTYACC */ 1346 yyresult = 0; 1347 1348 yyreturn: 1349 #if defined(YYDESTRUCT_CALL) 1350 if (yychar != YYEOF && yychar != YYEMPTY) 1351 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1352 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc); 1353 #else 1354 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval); 1355 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1356 1357 { 1358 YYSTYPE *pv; 1359 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1360 YYLTYPE *pp; 1361 1362 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp) 1363 YYDESTRUCT_CALL("cleanup: discarding state", 1364 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp); 1365 #else 1366 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv) 1367 YYDESTRUCT_CALL("cleanup: discarding state", 1368 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv); 1369 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1370 } 1371 #endif /* defined(YYDESTRUCT_CALL) */ 1372 1373 #if YYBTYACC 1374 if (yyerrctx) 1375 { 1376 yyFreeState(yyerrctx); 1377 yyerrctx = NULL; 1378 } 1379 while (yyps) 1380 { 1381 YYParseState *save = yyps; 1382 yyps = save->save; 1383 save->save = NULL; 1384 yyFreeState(save); 1385 } 1386 while (yypath) 1387 { 1388 YYParseState *save = yypath; 1389 yypath = save->save; 1390 save->save = NULL; 1391 yyFreeState(save); 1392 } 1393 #endif /* YYBTYACC */ 1394 yyfreestack(&yystack); 1395 return (yyresult); 1396 } 1397