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