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