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