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