1 /* original parser id follows */ 2 /* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ 3 /* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */ 4 5 #define YYBYACC 1 6 #define YYMAJOR 2 7 #define YYMINOR 0 8 #define YYCHECK "yyyymmdd" 9 10 #define YYEMPTY (-1) 11 #define yyclearin (yychar = YYEMPTY) 12 #define yyerrok (yyerrflag = 0) 13 #define YYRECOVERING() (yyerrflag != 0) 14 #define YYENOMEM (-2) 15 #define YYEOF 0 16 #undef YYBTYACC 17 #define YYBTYACC 0 18 #define YYDEBUGSTR YYPREFIX "debug" 19 20 #ifndef yyparse 21 #define yyparse calc_parse 22 #endif /* yyparse */ 23 24 #ifndef yylex 25 #define yylex calc_lex 26 #endif /* yylex */ 27 28 #ifndef yyerror 29 #define yyerror calc_error 30 #endif /* yyerror */ 31 32 #ifndef yychar 33 #define yychar calc_char 34 #endif /* yychar */ 35 36 #ifndef yyval 37 #define yyval calc_val 38 #endif /* yyval */ 39 40 #ifndef yylval 41 #define yylval calc_lval 42 #endif /* yylval */ 43 44 #ifndef yydebug 45 #define yydebug calc_debug 46 #endif /* yydebug */ 47 48 #ifndef yynerrs 49 #define yynerrs calc_nerrs 50 #endif /* yynerrs */ 51 52 #ifndef yyerrflag 53 #define yyerrflag calc_errflag 54 #endif /* yyerrflag */ 55 56 #ifndef yylhs 57 #define yylhs calc_lhs 58 #endif /* yylhs */ 59 60 #ifndef yylen 61 #define yylen calc_len 62 #endif /* yylen */ 63 64 #ifndef yydefred 65 #define yydefred calc_defred 66 #endif /* yydefred */ 67 68 #ifndef yystos 69 #define yystos calc_stos 70 #endif /* yystos */ 71 72 #ifndef yydgoto 73 #define yydgoto calc_dgoto 74 #endif /* yydgoto */ 75 76 #ifndef yysindex 77 #define yysindex calc_sindex 78 #endif /* yysindex */ 79 80 #ifndef yyrindex 81 #define yyrindex calc_rindex 82 #endif /* yyrindex */ 83 84 #ifndef yygindex 85 #define yygindex calc_gindex 86 #endif /* yygindex */ 87 88 #ifndef yytable 89 #define yytable calc_table 90 #endif /* yytable */ 91 92 #ifndef yycheck 93 #define yycheck calc_check 94 #endif /* yycheck */ 95 96 #ifndef yyname 97 #define yyname calc_name 98 #endif /* yyname */ 99 100 #ifndef yyrule 101 #define yyrule calc_rule 102 #endif /* yyrule */ 103 104 #if YYBTYACC 105 106 #ifndef yycindex 107 #define yycindex calc_cindex 108 #endif /* yycindex */ 109 110 #ifndef yyctable 111 #define yyctable calc_ctable 112 #endif /* yyctable */ 113 114 #endif /* YYBTYACC */ 115 116 #define YYPREFIX "calc_" 117 118 #define YYPURE 0 119 120 #line 2 "calc.y" 121 # include <stdio.h> 122 # include <ctype.h> 123 124 int regs[26]; 125 int base; 126 127 extern int yylex(void); 128 static void yyerror(const char *s); 129 130 #line 131 "calc.tab.c" 131 132 #if ! defined(YYSTYPE) && ! defined(YYSTYPE_IS_DECLARED) 133 /* Default: YYSTYPE is the semantic value type. */ 134 typedef int YYSTYPE; 135 # define YYSTYPE_IS_DECLARED 1 136 #endif 137 138 /* compatibility with bison */ 139 #ifdef YYPARSE_PARAM 140 /* compatibility with FreeBSD */ 141 # ifdef YYPARSE_PARAM_TYPE 142 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM) 143 # else 144 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM) 145 # endif 146 #else 147 # define YYPARSE_DECL() yyparse(void) 148 #endif 149 150 /* Parameters sent to lex. */ 151 #ifdef YYLEX_PARAM 152 # define YYLEX_DECL() yylex(void *YYLEX_PARAM) 153 # define YYLEX yylex(YYLEX_PARAM) 154 #else 155 # define YYLEX_DECL() yylex(void) 156 # define YYLEX yylex() 157 #endif 158 159 /* Parameters sent to yyerror. */ 160 #ifndef YYERROR_DECL 161 #define YYERROR_DECL() yyerror(const char *s) 162 #endif 163 #ifndef YYERROR_CALL 164 #define YYERROR_CALL(msg) yyerror(msg) 165 #endif 166 167 extern int YYPARSE_DECL(); 168 169 #define DIGIT 257 170 #define LETTER 258 171 #define UMINUS 259 172 #define YYERRCODE 256 173 typedef int YYINT; 174 static const YYINT calc_lhs[] = { -1, 175 0, 0, 0, 1, 1, 2, 2, 2, 2, 2, 176 2, 2, 2, 2, 2, 2, 3, 3, 177 }; 178 static const YYINT calc_len[] = { 2, 179 0, 3, 3, 1, 3, 3, 3, 3, 3, 3, 180 3, 3, 3, 2, 1, 1, 1, 2, 181 }; 182 static const YYINT calc_defred[] = { 1, 183 0, 0, 17, 0, 0, 0, 0, 0, 0, 3, 184 0, 15, 14, 0, 2, 0, 0, 0, 0, 0, 185 0, 0, 18, 0, 6, 0, 0, 0, 0, 9, 186 10, 11, 187 }; 188 #if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING) 189 static const YYINT calc_stos[] = { 0, 190 261, 256, 257, 258, 45, 40, 262, 263, 264, 10, 191 61, 258, 263, 263, 10, 124, 38, 43, 45, 42, 192 47, 37, 257, 263, 41, 263, 263, 263, 263, 263, 193 263, 263, 194 }; 195 #endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */ 196 static const YYINT calc_dgoto[] = { 1, 197 7, 8, 9, 198 }; 199 static const YYINT calc_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 calc_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 calc_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 calc_gindex[] = { 0, 220 0, 65, 0, 221 }; 222 #define YYTABLESIZE 220 223 static const YYINT calc_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 calc_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 calc_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 calc_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 calc_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 #if YYDEBUG 342 int yydebug; 343 #endif 344 345 int yyerrflag; 346 int yychar; 347 YYSTYPE yyval; 348 YYSTYPE yylval; 349 int yynerrs; 350 351 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 352 YYLTYPE yyloc; /* position returned by actions */ 353 YYLTYPE yylloc; /* position from the lexer */ 354 #endif 355 356 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 357 #ifndef YYLLOC_DEFAULT 358 #define YYLLOC_DEFAULT(loc, rhs, n) \ 359 do \ 360 { \ 361 if (n == 0) \ 362 { \ 363 (loc).first_line = YYRHSLOC(rhs, 0).last_line; \ 364 (loc).first_column = YYRHSLOC(rhs, 0).last_column; \ 365 (loc).last_line = YYRHSLOC(rhs, 0).last_line; \ 366 (loc).last_column = YYRHSLOC(rhs, 0).last_column; \ 367 } \ 368 else \ 369 { \ 370 (loc).first_line = YYRHSLOC(rhs, 1).first_line; \ 371 (loc).first_column = YYRHSLOC(rhs, 1).first_column; \ 372 (loc).last_line = YYRHSLOC(rhs, n).last_line; \ 373 (loc).last_column = YYRHSLOC(rhs, n).last_column; \ 374 } \ 375 } while (0) 376 #endif /* YYLLOC_DEFAULT */ 377 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 378 #if YYBTYACC 379 380 #ifndef YYLVQUEUEGROWTH 381 #define YYLVQUEUEGROWTH 32 382 #endif 383 #endif /* YYBTYACC */ 384 385 /* define the initial stack-sizes */ 386 #ifdef YYSTACKSIZE 387 #undef YYMAXDEPTH 388 #define YYMAXDEPTH YYSTACKSIZE 389 #else 390 #ifdef YYMAXDEPTH 391 #define YYSTACKSIZE YYMAXDEPTH 392 #else 393 #define YYSTACKSIZE 10000 394 #define YYMAXDEPTH 10000 395 #endif 396 #endif 397 398 #ifndef YYINITSTACKSIZE 399 #define YYINITSTACKSIZE 200 400 #endif 401 402 typedef struct { 403 unsigned stacksize; 404 YYINT *s_base; 405 YYINT *s_mark; 406 YYINT *s_last; 407 YYSTYPE *l_base; 408 YYSTYPE *l_mark; 409 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 410 YYLTYPE *p_base; 411 YYLTYPE *p_mark; 412 #endif 413 } YYSTACKDATA; 414 #if YYBTYACC 415 416 struct YYParseState_s 417 { 418 struct YYParseState_s *save; /* Previously saved parser state */ 419 YYSTACKDATA yystack; /* saved parser stack */ 420 int state; /* saved parser state */ 421 int errflag; /* saved error recovery status */ 422 int lexeme; /* saved index of the conflict lexeme in the lexical queue */ 423 YYINT ctry; /* saved index in yyctable[] for this conflict */ 424 }; 425 typedef struct YYParseState_s YYParseState; 426 #endif /* YYBTYACC */ 427 /* variables for the parser stack */ 428 static YYSTACKDATA yystack; 429 #if YYBTYACC 430 431 /* Current parser state */ 432 static YYParseState *yyps = 0; 433 434 /* yypath != NULL: do the full parse, starting at *yypath parser state. */ 435 static YYParseState *yypath = 0; 436 437 /* Base of the lexical value queue */ 438 static YYSTYPE *yylvals = 0; 439 440 /* Current position at lexical value queue */ 441 static YYSTYPE *yylvp = 0; 442 443 /* End position of lexical value queue */ 444 static YYSTYPE *yylve = 0; 445 446 /* The last allocated position at the lexical value queue */ 447 static YYSTYPE *yylvlim = 0; 448 449 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 450 /* Base of the lexical position queue */ 451 static YYLTYPE *yylpsns = 0; 452 453 /* Current position at lexical position queue */ 454 static YYLTYPE *yylpp = 0; 455 456 /* End position of lexical position queue */ 457 static YYLTYPE *yylpe = 0; 458 459 /* The last allocated position at the lexical position queue */ 460 static YYLTYPE *yylplim = 0; 461 #endif 462 463 /* Current position at lexical token queue */ 464 static YYINT *yylexp = 0; 465 466 static YYINT *yylexemes = 0; 467 #endif /* YYBTYACC */ 468 #line 66 "calc.y" 469 /* start of programs */ 470 471 int 472 main (void) 473 { 474 while(!feof(stdin)) { 475 yyparse(); 476 } 477 return 0; 478 } 479 480 static void 481 yyerror(const char *s) 482 { 483 fprintf(stderr, "%s\n", s); 484 } 485 486 int 487 yylex(void) 488 { 489 /* lexical analysis routine */ 490 /* returns LETTER for a lower case letter, yylval = 0 through 25 */ 491 /* return DIGIT for a digit, yylval = 0 through 9 */ 492 /* all other characters are returned immediately */ 493 494 int c; 495 496 while( (c=getchar()) == ' ' ) { /* skip blanks */ } 497 498 /* c is now nonblank */ 499 500 if( islower( c )) { 501 yylval = c - 'a'; 502 return ( LETTER ); 503 } 504 if( isdigit( c )) { 505 yylval = c - '0'; 506 return ( DIGIT ); 507 } 508 return( c ); 509 } 510 #line 511 "calc.tab.c" 511 512 /* For use in generated program */ 513 #define yydepth (int)(yystack.s_mark - yystack.s_base) 514 #if YYBTYACC 515 #define yytrial (yyps->save) 516 #endif /* YYBTYACC */ 517 518 #if YYDEBUG 519 #include <stdio.h> /* needed for printf */ 520 #endif 521 522 #include <stdlib.h> /* needed for malloc, etc */ 523 #include <string.h> /* needed for memset */ 524 525 /* allocate initial stack or double stack size, up to YYMAXDEPTH */ 526 static int yygrowstack(YYSTACKDATA *data) 527 { 528 int i; 529 unsigned newsize; 530 YYINT *newss; 531 YYSTYPE *newvs; 532 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 533 YYLTYPE *newps; 534 #endif 535 536 if ((newsize = data->stacksize) == 0) 537 newsize = YYINITSTACKSIZE; 538 else if (newsize >= YYMAXDEPTH) 539 return YYENOMEM; 540 else if ((newsize *= 2) > YYMAXDEPTH) 541 newsize = YYMAXDEPTH; 542 543 i = (int) (data->s_mark - data->s_base); 544 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss)); 545 if (newss == NULL) 546 return YYENOMEM; 547 548 data->s_base = newss; 549 data->s_mark = newss + i; 550 551 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs)); 552 if (newvs == NULL) 553 return YYENOMEM; 554 555 data->l_base = newvs; 556 data->l_mark = newvs + i; 557 558 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 559 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps)); 560 if (newps == NULL) 561 return YYENOMEM; 562 563 data->p_base = newps; 564 data->p_mark = newps + i; 565 #endif 566 567 data->stacksize = newsize; 568 data->s_last = data->s_base + newsize - 1; 569 570 #if YYDEBUG 571 if (yydebug) 572 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize); 573 #endif 574 return 0; 575 } 576 577 #if YYPURE || defined(YY_NO_LEAKS) 578 static void yyfreestack(YYSTACKDATA *data) 579 { 580 free(data->s_base); 581 free(data->l_base); 582 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 583 free(data->p_base); 584 #endif 585 memset(data, 0, sizeof(*data)); 586 } 587 #else 588 #define yyfreestack(data) /* nothing */ 589 #endif /* YYPURE || defined(YY_NO_LEAKS) */ 590 #if YYBTYACC 591 592 static YYParseState * 593 yyNewState(unsigned size) 594 { 595 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState)); 596 if (p == NULL) return NULL; 597 598 p->yystack.stacksize = size; 599 if (size == 0) 600 { 601 p->yystack.s_base = NULL; 602 p->yystack.l_base = NULL; 603 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 604 p->yystack.p_base = NULL; 605 #endif 606 return p; 607 } 608 p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT)); 609 if (p->yystack.s_base == NULL) return NULL; 610 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE)); 611 if (p->yystack.l_base == NULL) return NULL; 612 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE)); 613 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 614 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE)); 615 if (p->yystack.p_base == NULL) return NULL; 616 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE)); 617 #endif 618 619 return p; 620 } 621 622 static void 623 yyFreeState(YYParseState *p) 624 { 625 yyfreestack(&p->yystack); 626 free(p); 627 } 628 #endif /* YYBTYACC */ 629 630 #define YYABORT goto yyabort 631 #define YYREJECT goto yyabort 632 #define YYACCEPT goto yyaccept 633 #define YYERROR goto yyerrlab 634 #if YYBTYACC 635 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0) 636 #define YYVALID_NESTED do { if (yyps->save && \ 637 yyps->save->save == 0) goto yyvalid; } while(0) 638 #endif /* YYBTYACC */ 639 640 int 641 YYPARSE_DECL() 642 { 643 int yym, yyn, yystate, yyresult; 644 #if YYBTYACC 645 int yynewerrflag; 646 YYParseState *yyerrctx = NULL; 647 #endif /* YYBTYACC */ 648 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 649 YYLTYPE yyerror_loc_range[3]; /* position of error start/end (0 unused) */ 650 #endif 651 #if YYDEBUG 652 const char *yys; 653 654 if ((yys = getenv("YYDEBUG")) != NULL) 655 { 656 yyn = *yys; 657 if (yyn >= '0' && yyn <= '9') 658 yydebug = yyn - '0'; 659 } 660 if (yydebug) 661 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX); 662 #endif 663 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 664 memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range)); 665 #endif 666 667 #if YYBTYACC 668 yyps = yyNewState(0); if (yyps == 0) goto yyenomem; 669 yyps->save = 0; 670 #endif /* YYBTYACC */ 671 yym = 0; 672 /* yyn is set below */ 673 yynerrs = 0; 674 yyerrflag = 0; 675 yychar = YYEMPTY; 676 yystate = 0; 677 678 #if YYPURE 679 memset(&yystack, 0, sizeof(yystack)); 680 #endif 681 682 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 683 yystack.s_mark = yystack.s_base; 684 yystack.l_mark = yystack.l_base; 685 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 686 yystack.p_mark = yystack.p_base; 687 #endif 688 yystate = 0; 689 *yystack.s_mark = 0; 690 691 yyloop: 692 if ((yyn = yydefred[yystate]) != 0) goto yyreduce; 693 if (yychar < 0) 694 { 695 #if YYBTYACC 696 do { 697 if (yylvp < yylve) 698 { 699 /* we're currently re-reading tokens */ 700 yylval = *yylvp++; 701 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 702 yylloc = *yylpp++; 703 #endif 704 yychar = *yylexp++; 705 break; 706 } 707 if (yyps->save) 708 { 709 /* in trial mode; save scanner results for future parse attempts */ 710 if (yylvp == yylvlim) 711 { /* Enlarge lexical value queue */ 712 size_t p = (size_t) (yylvp - yylvals); 713 size_t s = (size_t) (yylvlim - yylvals); 714 715 s += YYLVQUEUEGROWTH; 716 if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem; 717 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem; 718 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 719 if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem; 720 #endif 721 yylvp = yylve = yylvals + p; 722 yylvlim = yylvals + s; 723 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 724 yylpp = yylpe = yylpsns + p; 725 yylplim = yylpsns + s; 726 #endif 727 yylexp = yylexemes + p; 728 } 729 *yylexp = (YYINT) YYLEX; 730 *yylvp++ = yylval; 731 yylve++; 732 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 733 *yylpp++ = yylloc; 734 yylpe++; 735 #endif 736 yychar = *yylexp++; 737 break; 738 } 739 /* normal operation, no conflict encountered */ 740 #endif /* YYBTYACC */ 741 yychar = YYLEX; 742 #if YYBTYACC 743 } while (0); 744 #endif /* YYBTYACC */ 745 if (yychar < 0) yychar = YYEOF; 746 #if YYDEBUG 747 if (yydebug) 748 { 749 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 750 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)", 751 YYDEBUGSTR, yydepth, yystate, yychar, yys); 752 #ifdef YYSTYPE_TOSTRING 753 #if YYBTYACC 754 if (!yytrial) 755 #endif /* YYBTYACC */ 756 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval)); 757 #endif 758 fputc('\n', stderr); 759 } 760 #endif 761 } 762 #if YYBTYACC 763 764 /* Do we have a conflict? */ 765 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 && 766 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 767 { 768 YYINT ctry; 769 770 if (yypath) 771 { 772 YYParseState *save; 773 #if YYDEBUG 774 if (yydebug) 775 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n", 776 YYDEBUGSTR, yydepth, yystate); 777 #endif 778 /* Switch to the next conflict context */ 779 save = yypath; 780 yypath = save->save; 781 save->save = NULL; 782 ctry = save->ctry; 783 if (save->state != yystate) YYABORT; 784 yyFreeState(save); 785 786 } 787 else 788 { 789 790 /* Unresolved conflict - start/continue trial parse */ 791 YYParseState *save; 792 #if YYDEBUG 793 if (yydebug) 794 { 795 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate); 796 if (yyps->save) 797 fputs("ALREADY in conflict, continuing trial parse.\n", stderr); 798 else 799 fputs("Starting trial parse.\n", stderr); 800 } 801 #endif 802 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 803 if (save == NULL) goto yyenomem; 804 save->save = yyps->save; 805 save->state = yystate; 806 save->errflag = yyerrflag; 807 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 808 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 809 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base); 810 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 811 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 812 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 813 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 814 #endif 815 ctry = yytable[yyn]; 816 if (yyctable[ctry] == -1) 817 { 818 #if YYDEBUG 819 if (yydebug && yychar >= YYEOF) 820 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth); 821 #endif 822 ctry++; 823 } 824 save->ctry = ctry; 825 if (yyps->save == NULL) 826 { 827 /* If this is a first conflict in the stack, start saving lexemes */ 828 if (!yylexemes) 829 { 830 yylexemes = (YYINT *) malloc((YYLVQUEUEGROWTH) * sizeof(YYINT)); 831 if (yylexemes == NULL) goto yyenomem; 832 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE)); 833 if (yylvals == NULL) goto yyenomem; 834 yylvlim = yylvals + YYLVQUEUEGROWTH; 835 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 836 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE)); 837 if (yylpsns == NULL) goto yyenomem; 838 yylplim = yylpsns + YYLVQUEUEGROWTH; 839 #endif 840 } 841 if (yylvp == yylve) 842 { 843 yylvp = yylve = yylvals; 844 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 845 yylpp = yylpe = yylpsns; 846 #endif 847 yylexp = yylexemes; 848 if (yychar >= YYEOF) 849 { 850 *yylve++ = yylval; 851 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 852 *yylpe++ = yylloc; 853 #endif 854 *yylexp = (YYINT) yychar; 855 yychar = YYEMPTY; 856 } 857 } 858 } 859 if (yychar >= YYEOF) 860 { 861 yylvp--; 862 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 863 yylpp--; 864 #endif 865 yylexp--; 866 yychar = YYEMPTY; 867 } 868 save->lexeme = (int) (yylvp - yylvals); 869 yyps->save = save; 870 } 871 if (yytable[yyn] == ctry) 872 { 873 #if YYDEBUG 874 if (yydebug) 875 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 876 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]); 877 #endif 878 if (yychar < 0) 879 { 880 yylvp++; 881 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 882 yylpp++; 883 #endif 884 yylexp++; 885 } 886 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) 887 goto yyoverflow; 888 yystate = yyctable[ctry]; 889 *++yystack.s_mark = (YYINT) yystate; 890 *++yystack.l_mark = yylval; 891 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 892 *++yystack.p_mark = yylloc; 893 #endif 894 yychar = YYEMPTY; 895 if (yyerrflag > 0) --yyerrflag; 896 goto yyloop; 897 } 898 else 899 { 900 yyn = yyctable[ctry]; 901 goto yyreduce; 902 } 903 } /* End of code dealing with conflicts */ 904 #endif /* YYBTYACC */ 905 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 && 906 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 907 { 908 #if YYDEBUG 909 if (yydebug) 910 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 911 YYDEBUGSTR, yydepth, yystate, yytable[yyn]); 912 #endif 913 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 914 yystate = yytable[yyn]; 915 *++yystack.s_mark = yytable[yyn]; 916 *++yystack.l_mark = yylval; 917 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 918 *++yystack.p_mark = yylloc; 919 #endif 920 yychar = YYEMPTY; 921 if (yyerrflag > 0) --yyerrflag; 922 goto yyloop; 923 } 924 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 && 925 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 926 { 927 yyn = yytable[yyn]; 928 goto yyreduce; 929 } 930 if (yyerrflag != 0) goto yyinrecovery; 931 #if YYBTYACC 932 933 yynewerrflag = 1; 934 goto yyerrhandler; 935 goto yyerrlab; /* redundant goto avoids 'unused label' warning */ 936 937 yyerrlab: 938 /* explicit YYERROR from an action -- pop the rhs of the rule reduced 939 * before looking for error recovery */ 940 yystack.s_mark -= yym; 941 yystate = *yystack.s_mark; 942 yystack.l_mark -= yym; 943 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 944 yystack.p_mark -= yym; 945 #endif 946 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(YYINT)); 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(YYINT)); 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(YYINT)); 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[1] = yylloc; /* lookahead position is error start position */ 1041 #endif 1042 1043 #if !YYBTYACC 1044 goto yyerrlab; /* redundant goto avoids 'unused label' warning */ 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[2] = 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[1] = *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 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 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[-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[1] = yystack.p_mark[1-yym]; 1175 } 1176 #endif 1177 1178 switch (yyn) 1179 { 1180 case 3: 1181 #line 28 "calc.y" 1182 { yyerrok ; } 1183 #line 1184 "calc.tab.c" 1184 break; 1185 case 4: 1186 #line 32 "calc.y" 1187 { printf("%d\n",yystack.l_mark[0]);} 1188 #line 1189 "calc.tab.c" 1189 break; 1190 case 5: 1191 #line 34 "calc.y" 1192 { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; } 1193 #line 1194 "calc.tab.c" 1194 break; 1195 case 6: 1196 #line 38 "calc.y" 1197 { yyval = yystack.l_mark[-1]; } 1198 #line 1199 "calc.tab.c" 1199 break; 1200 case 7: 1201 #line 40 "calc.y" 1202 { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; } 1203 #line 1204 "calc.tab.c" 1204 break; 1205 case 8: 1206 #line 42 "calc.y" 1207 { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; } 1208 #line 1209 "calc.tab.c" 1209 break; 1210 case 9: 1211 #line 44 "calc.y" 1212 { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; } 1213 #line 1214 "calc.tab.c" 1214 break; 1215 case 10: 1216 #line 46 "calc.y" 1217 { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; } 1218 #line 1219 "calc.tab.c" 1219 break; 1220 case 11: 1221 #line 48 "calc.y" 1222 { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; } 1223 #line 1224 "calc.tab.c" 1224 break; 1225 case 12: 1226 #line 50 "calc.y" 1227 { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; } 1228 #line 1229 "calc.tab.c" 1229 break; 1230 case 13: 1231 #line 52 "calc.y" 1232 { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; } 1233 #line 1234 "calc.tab.c" 1234 break; 1235 case 14: 1236 #line 54 "calc.y" 1237 { yyval = - yystack.l_mark[0]; } 1238 #line 1239 "calc.tab.c" 1239 break; 1240 case 15: 1241 #line 56 "calc.y" 1242 { yyval = regs[yystack.l_mark[0]]; } 1243 #line 1244 "calc.tab.c" 1244 break; 1245 case 17: 1246 #line 61 "calc.y" 1247 { yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; } 1248 #line 1249 "calc.tab.c" 1249 break; 1250 case 18: 1251 #line 63 "calc.y" 1252 { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; } 1253 #line 1254 "calc.tab.c" 1254 break; 1255 #line 1256 "calc.tab.c" 1256 default: 1257 break; 1258 } 1259 yystack.s_mark -= yym; 1260 yystate = *yystack.s_mark; 1261 yystack.l_mark -= yym; 1262 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1263 yystack.p_mark -= yym; 1264 #endif 1265 yym = yylhs[yyn]; 1266 if (yystate == 0 && yym == 0) 1267 { 1268 #if YYDEBUG 1269 if (yydebug) 1270 { 1271 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1272 #ifdef YYSTYPE_TOSTRING 1273 #if YYBTYACC 1274 if (!yytrial) 1275 #endif /* YYBTYACC */ 1276 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval)); 1277 #endif 1278 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL); 1279 } 1280 #endif 1281 yystate = YYFINAL; 1282 *++yystack.s_mark = YYFINAL; 1283 *++yystack.l_mark = yyval; 1284 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1285 *++yystack.p_mark = yyloc; 1286 #endif 1287 if (yychar < 0) 1288 { 1289 #if YYBTYACC 1290 do { 1291 if (yylvp < yylve) 1292 { 1293 /* we're currently re-reading tokens */ 1294 yylval = *yylvp++; 1295 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1296 yylloc = *yylpp++; 1297 #endif 1298 yychar = *yylexp++; 1299 break; 1300 } 1301 if (yyps->save) 1302 { 1303 /* in trial mode; save scanner results for future parse attempts */ 1304 if (yylvp == yylvlim) 1305 { /* Enlarge lexical value queue */ 1306 size_t p = (size_t) (yylvp - yylvals); 1307 size_t s = (size_t) (yylvlim - yylvals); 1308 1309 s += YYLVQUEUEGROWTH; 1310 if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) 1311 goto yyenomem; 1312 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) 1313 goto yyenomem; 1314 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1315 if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) 1316 goto yyenomem; 1317 #endif 1318 yylvp = yylve = yylvals + p; 1319 yylvlim = yylvals + s; 1320 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1321 yylpp = yylpe = yylpsns + p; 1322 yylplim = yylpsns + s; 1323 #endif 1324 yylexp = yylexemes + p; 1325 } 1326 *yylexp = (YYINT) YYLEX; 1327 *yylvp++ = yylval; 1328 yylve++; 1329 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1330 *yylpp++ = yylloc; 1331 yylpe++; 1332 #endif 1333 yychar = *yylexp++; 1334 break; 1335 } 1336 /* normal operation, no conflict encountered */ 1337 #endif /* YYBTYACC */ 1338 yychar = YYLEX; 1339 #if YYBTYACC 1340 } while (0); 1341 #endif /* YYBTYACC */ 1342 if (yychar < 0) yychar = YYEOF; 1343 #if YYDEBUG 1344 if (yydebug) 1345 { 1346 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 1347 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n", 1348 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys); 1349 } 1350 #endif 1351 } 1352 if (yychar == YYEOF) goto yyaccept; 1353 goto yyloop; 1354 } 1355 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 && 1356 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate) 1357 yystate = yytable[yyn]; 1358 else 1359 yystate = yydgoto[yym]; 1360 #if YYDEBUG 1361 if (yydebug) 1362 { 1363 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1364 #ifdef YYSTYPE_TOSTRING 1365 #if YYBTYACC 1366 if (!yytrial) 1367 #endif /* YYBTYACC */ 1368 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval)); 1369 #endif 1370 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate); 1371 } 1372 #endif 1373 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1374 *++yystack.s_mark = (YYINT) yystate; 1375 *++yystack.l_mark = yyval; 1376 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1377 *++yystack.p_mark = yyloc; 1378 #endif 1379 goto yyloop; 1380 #if YYBTYACC 1381 1382 /* Reduction declares that this path is valid. Set yypath and do a full parse */ 1383 yyvalid: 1384 if (yypath) YYABORT; 1385 while (yyps->save) 1386 { 1387 YYParseState *save = yyps->save; 1388 yyps->save = save->save; 1389 save->save = yypath; 1390 yypath = save; 1391 } 1392 #if YYDEBUG 1393 if (yydebug) 1394 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n", 1395 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme)); 1396 #endif 1397 if (yyerrctx) 1398 { 1399 yyFreeState(yyerrctx); 1400 yyerrctx = NULL; 1401 } 1402 yylvp = yylvals + yypath->lexeme; 1403 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1404 yylpp = yylpsns + yypath->lexeme; 1405 #endif 1406 yylexp = yylexemes + yypath->lexeme; 1407 yychar = YYEMPTY; 1408 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 1409 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1410 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base); 1411 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1412 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1413 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 1414 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1415 #endif 1416 yystate = yypath->state; 1417 goto yyloop; 1418 #endif /* YYBTYACC */ 1419 1420 yyoverflow: 1421 YYERROR_CALL("yacc stack overflow"); 1422 #if YYBTYACC 1423 goto yyabort_nomem; 1424 yyenomem: 1425 YYERROR_CALL("memory exhausted"); 1426 yyabort_nomem: 1427 #endif /* YYBTYACC */ 1428 yyresult = 2; 1429 goto yyreturn; 1430 1431 yyabort: 1432 yyresult = 1; 1433 goto yyreturn; 1434 1435 yyaccept: 1436 #if YYBTYACC 1437 if (yyps->save) goto yyvalid; 1438 #endif /* YYBTYACC */ 1439 yyresult = 0; 1440 1441 yyreturn: 1442 #if defined(YYDESTRUCT_CALL) 1443 if (yychar != YYEOF && yychar != YYEMPTY) 1444 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1445 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc); 1446 #else 1447 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval); 1448 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1449 1450 { 1451 YYSTYPE *pv; 1452 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1453 YYLTYPE *pp; 1454 1455 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp) 1456 YYDESTRUCT_CALL("cleanup: discarding state", 1457 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp); 1458 #else 1459 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv) 1460 YYDESTRUCT_CALL("cleanup: discarding state", 1461 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv); 1462 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1463 } 1464 #endif /* defined(YYDESTRUCT_CALL) */ 1465 1466 #if YYBTYACC 1467 if (yyerrctx) 1468 { 1469 yyFreeState(yyerrctx); 1470 yyerrctx = NULL; 1471 } 1472 while (yyps) 1473 { 1474 YYParseState *save = yyps; 1475 yyps = save->save; 1476 save->save = NULL; 1477 yyFreeState(save); 1478 } 1479 while (yypath) 1480 { 1481 YYParseState *save = yypath; 1482 yypath = save->save; 1483 save->save = NULL; 1484 yyFreeState(save); 1485 } 1486 #endif /* YYBTYACC */ 1487 yyfreestack(&yystack); 1488 return (yyresult); 1489 } 1490