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