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