1 /* $NetBSD: calc1.tab.c,v 1.1.1.3 2016/01/09 21:59:47 christos Exp $ */ 2 3 /* original parser id follows */ 4 /* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ 5 /* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */ 6 7 #define YYBYACC 1 8 #define YYMAJOR 1 9 #define YYMINOR 9 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 0 20 #define YYDEBUGSTR 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 0 121 122 #line 2 "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 131 typedef struct interval 132 { 133 double lo, hi; 134 } 135 INTERVAL; 136 137 INTERVAL vmul(double, double, INTERVAL); 138 INTERVAL vdiv(double, double, INTERVAL); 139 140 extern int yylex(void); 141 static void yyerror(const char *s); 142 143 int dcheck(INTERVAL); 144 145 double dreg[26]; 146 INTERVAL vreg[26]; 147 148 #line 31 "calc1.y" 149 #ifdef YYSTYPE 150 #undef YYSTYPE_IS_DECLARED 151 #define YYSTYPE_IS_DECLARED 1 152 #endif 153 #ifndef YYSTYPE_IS_DECLARED 154 #define YYSTYPE_IS_DECLARED 1 155 typedef union 156 { 157 int ival; 158 double dval; 159 INTERVAL vval; 160 } YYSTYPE; 161 #endif /* !YYSTYPE_IS_DECLARED */ 162 #line 161 "calc1.tab.c" 163 164 /* compatibility with bison */ 165 #ifdef YYPARSE_PARAM 166 /* compatibility with FreeBSD */ 167 # ifdef YYPARSE_PARAM_TYPE 168 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM) 169 # else 170 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM) 171 # endif 172 #else 173 # define YYPARSE_DECL() yyparse(void) 174 #endif 175 176 /* Parameters sent to lex. */ 177 #ifdef YYLEX_PARAM 178 # define YYLEX_DECL() yylex(void *YYLEX_PARAM) 179 # define YYLEX yylex(YYLEX_PARAM) 180 #else 181 # define YYLEX_DECL() yylex(void) 182 # define YYLEX yylex() 183 #endif 184 185 /* Parameters sent to yyerror. */ 186 #ifndef YYERROR_DECL 187 #define YYERROR_DECL() yyerror(const char *s) 188 #endif 189 #ifndef YYERROR_CALL 190 #define YYERROR_CALL(msg) yyerror(msg) 191 #endif 192 193 extern int YYPARSE_DECL(); 194 195 #define DREG 257 196 #define VREG 258 197 #define CONST 259 198 #define UMINUS 260 199 #define YYERRCODE 256 200 typedef short YYINT; 201 static const YYINT calc1_lhs[] = { -1, 202 3, 3, 0, 0, 0, 0, 0, 1, 1, 1, 203 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 204 2, 2, 2, 2, 2, 2, 2, 2, 205 }; 206 static const YYINT calc1_len[] = { 2, 207 0, 2, 2, 2, 4, 4, 2, 1, 1, 3, 208 3, 3, 3, 2, 3, 1, 5, 1, 3, 3, 209 3, 3, 3, 3, 3, 3, 2, 3, 210 }; 211 static const YYINT calc1_defred[] = { 0, 212 0, 0, 0, 8, 0, 0, 0, 0, 0, 7, 213 0, 0, 9, 18, 14, 27, 0, 0, 0, 0, 214 0, 0, 3, 0, 0, 0, 0, 4, 0, 0, 215 0, 0, 0, 15, 0, 28, 0, 0, 0, 0, 216 12, 24, 13, 26, 0, 0, 23, 25, 14, 0, 217 0, 0, 0, 0, 5, 6, 0, 0, 0, 12, 218 13, 17, 219 }; 220 static const YYINT calc1_stos[] = { 0, 221 256, 257, 258, 259, 45, 40, 262, 263, 264, 10, 222 61, 61, 257, 258, 263, 264, 263, 264, 43, 45, 223 42, 47, 10, 43, 45, 42, 47, 10, 45, 40, 224 263, 263, 264, 41, 44, 41, 263, 264, 263, 264, 225 263, 264, 263, 264, 264, 264, 264, 264, 263, 263, 226 43, 45, 42, 47, 10, 10, 263, 263, 263, 263, 227 263, 41, 228 }; 229 static const YYINT calc1_dgoto[] = { 7, 230 32, 9, 0, 231 }; 232 static 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 }; 241 static 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 251 static 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 261 static const YYINT calc1_gindex[] = { 0, 262 4, 124, 0, 263 }; 264 #define YYTABLESIZE 225 265 static 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 }; 290 static 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 316 static 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 350 static 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, 353 0,0,0,0,0,0,"'('","')'","'*'","'+'","','","'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,0,0, 354 0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 355 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 356 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,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 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 358 0,0,0,0,0,0,0,0,0,0,0,0,0,0,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 }; 362 static 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 396 int yydebug; 397 int yynerrs; 398 399 int yyerrflag; 400 int yychar; 401 YYSTYPE yyval; 402 YYSTYPE yylval; 403 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 404 YYLTYPE yyloc; /* position returned by actions */ 405 YYLTYPE 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) \ 411 do \ 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 454 typedef struct { 455 unsigned stacksize; 456 short *s_base; 457 short *s_mark; 458 short *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 468 struct 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 }; 477 typedef struct YYParseState_s YYParseState; 478 #endif /* YYBTYACC */ 479 /* variables for the parser stack */ 480 static YYSTACKDATA yystack; 481 #if YYBTYACC 482 483 /* Current parser state */ 484 static YYParseState *yyps = 0; 485 486 /* yypath != NULL: do the full parse, starting at *yypath parser state. */ 487 static YYParseState *yypath = 0; 488 489 /* Base of the lexical value queue */ 490 static YYSTYPE *yylvals = 0; 491 492 /* Current position at lexical value queue */ 493 static YYSTYPE *yylvp = 0; 494 495 /* End position of lexical value queue */ 496 static YYSTYPE *yylve = 0; 497 498 /* The last allocated position at the lexical value queue */ 499 static YYSTYPE *yylvlim = 0; 500 501 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 502 /* Base of the lexical position queue */ 503 static YYLTYPE *yylpsns = 0; 504 505 /* Current position at lexical position queue */ 506 static YYLTYPE *yylpp = 0; 507 508 /* End position of lexical position queue */ 509 static YYLTYPE *yylpe = 0; 510 511 /* The last allocated position at the lexical position queue */ 512 static YYLTYPE *yylplim = 0; 513 #endif 514 515 /* Current position at lexical token queue */ 516 static short *yylexp = 0; 517 518 static short *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 527 static void 528 yyerror(const char *s) 529 { 530 fprintf(stderr, "%s\n", s); 531 } 532 533 int 534 yylex(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 594 static INTERVAL 595 hilo(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 629 INTERVAL 630 vmul(double a, double b, INTERVAL v) 631 { 632 return (hilo(a * v.hi, a * v.lo, b * v.hi, b * v.lo)); 633 } 634 635 int 636 dcheck(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 646 INTERVAL 647 vdiv(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 650 "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 */ 667 static int yygrowstack(YYSTACKDATA *data) 668 { 669 int i; 670 unsigned newsize; 671 short *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 = (short *)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) 719 static 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 733 static YYParseState * 734 yyNewState(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 = (short *) malloc(size * sizeof(short)); 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 763 static void 764 yyFreeState(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 781 int 782 YYPARSE_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 yynerrs = 0; 810 yyerrflag = 0; 811 yychar = YYEMPTY; 812 yystate = 0; 813 814 #if YYPURE 815 memset(&yystack, 0, sizeof(yystack)); 816 #endif 817 818 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 819 yystack.s_mark = yystack.s_base; 820 yystack.l_mark = yystack.l_base; 821 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 822 yystack.p_mark = yystack.p_base; 823 #endif 824 yystate = 0; 825 *yystack.s_mark = 0; 826 827 yyloop: 828 if ((yyn = yydefred[yystate]) != 0) goto yyreduce; 829 if (yychar < 0) 830 { 831 #if YYBTYACC 832 do { 833 if (yylvp < yylve) 834 { 835 /* we're currently re-reading tokens */ 836 yylval = *yylvp++; 837 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 838 yylloc = *yylpp++; 839 #endif 840 yychar = *yylexp++; 841 break; 842 } 843 if (yyps->save) 844 { 845 /* in trial mode; save scanner results for future parse attempts */ 846 if (yylvp == yylvlim) 847 { /* Enlarge lexical value queue */ 848 size_t p = (size_t) (yylvp - yylvals); 849 size_t s = (size_t) (yylvlim - yylvals); 850 851 s += YYLVQUEUEGROWTH; 852 if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; 853 if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem; 854 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 855 if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem; 856 #endif 857 yylvp = yylve = yylvals + p; 858 yylvlim = yylvals + s; 859 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 860 yylpp = yylpe = yylpsns + p; 861 yylplim = yylpsns + s; 862 #endif 863 yylexp = yylexemes + p; 864 } 865 *yylexp = (short) YYLEX; 866 *yylvp++ = yylval; 867 yylve++; 868 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 869 *yylpp++ = yylloc; 870 yylpe++; 871 #endif 872 yychar = *yylexp++; 873 break; 874 } 875 /* normal operation, no conflict encountered */ 876 #endif /* YYBTYACC */ 877 yychar = YYLEX; 878 #if YYBTYACC 879 } while (0); 880 #endif /* YYBTYACC */ 881 if (yychar < 0) yychar = YYEOF; 882 /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */ 883 #if YYDEBUG 884 if (yydebug) 885 { 886 yys = yyname[YYTRANSLATE(yychar)]; 887 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)", 888 YYDEBUGSTR, yydepth, yystate, yychar, yys); 889 #ifdef YYSTYPE_TOSTRING 890 #if YYBTYACC 891 if (!yytrial) 892 #endif /* YYBTYACC */ 893 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval)); 894 #endif 895 fputc('\n', stderr); 896 } 897 #endif 898 } 899 #if YYBTYACC 900 901 /* Do we have a conflict? */ 902 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 && 903 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 904 { 905 YYINT ctry; 906 907 if (yypath) 908 { 909 YYParseState *save; 910 #if YYDEBUG 911 if (yydebug) 912 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n", 913 YYDEBUGSTR, yydepth, yystate); 914 #endif 915 /* Switch to the next conflict context */ 916 save = yypath; 917 yypath = save->save; 918 save->save = NULL; 919 ctry = save->ctry; 920 if (save->state != yystate) YYABORT; 921 yyFreeState(save); 922 923 } 924 else 925 { 926 927 /* Unresolved conflict - start/continue trial parse */ 928 YYParseState *save; 929 #if YYDEBUG 930 if (yydebug) 931 { 932 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate); 933 if (yyps->save) 934 fputs("ALREADY in conflict, continuing trial parse.\n", stderr); 935 else 936 fputs("Starting trial parse.\n", stderr); 937 } 938 #endif 939 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 940 if (save == NULL) goto yyenomem; 941 save->save = yyps->save; 942 save->state = yystate; 943 save->errflag = yyerrflag; 944 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 945 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 946 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base); 947 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 948 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 949 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 950 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 951 #endif 952 ctry = yytable[yyn]; 953 if (yyctable[ctry] == -1) 954 { 955 #if YYDEBUG 956 if (yydebug && yychar >= YYEOF) 957 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth); 958 #endif 959 ctry++; 960 } 961 save->ctry = ctry; 962 if (yyps->save == NULL) 963 { 964 /* If this is a first conflict in the stack, start saving lexemes */ 965 if (!yylexemes) 966 { 967 yylexemes = (short *) malloc((YYLVQUEUEGROWTH) * sizeof(short)); 968 if (yylexemes == NULL) goto yyenomem; 969 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE)); 970 if (yylvals == NULL) goto yyenomem; 971 yylvlim = yylvals + YYLVQUEUEGROWTH; 972 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 973 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE)); 974 if (yylpsns == NULL) goto yyenomem; 975 yylplim = yylpsns + YYLVQUEUEGROWTH; 976 #endif 977 } 978 if (yylvp == yylve) 979 { 980 yylvp = yylve = yylvals; 981 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 982 yylpp = yylpe = yylpsns; 983 #endif 984 yylexp = yylexemes; 985 if (yychar >= YYEOF) 986 { 987 *yylve++ = yylval; 988 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 989 *yylpe++ = yylloc; 990 #endif 991 *yylexp = (short) yychar; 992 yychar = YYEMPTY; 993 } 994 } 995 } 996 if (yychar >= YYEOF) 997 { 998 yylvp--; 999 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1000 yylpp--; 1001 #endif 1002 yylexp--; 1003 yychar = YYEMPTY; 1004 } 1005 save->lexeme = (int) (yylvp - yylvals); 1006 yyps->save = save; 1007 } 1008 if (yytable[yyn] == ctry) 1009 { 1010 #if YYDEBUG 1011 if (yydebug) 1012 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 1013 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]); 1014 #endif 1015 if (yychar < 0) 1016 { 1017 yylvp++; 1018 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1019 yylpp++; 1020 #endif 1021 yylexp++; 1022 } 1023 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) 1024 goto yyoverflow; 1025 yystate = yyctable[ctry]; 1026 *++yystack.s_mark = (short) yystate; 1027 *++yystack.l_mark = yylval; 1028 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1029 *++yystack.p_mark = yylloc; 1030 #endif 1031 yychar = YYEMPTY; 1032 if (yyerrflag > 0) --yyerrflag; 1033 goto yyloop; 1034 } 1035 else 1036 { 1037 yyn = yyctable[ctry]; 1038 goto yyreduce; 1039 } 1040 } /* End of code dealing with conflicts */ 1041 #endif /* YYBTYACC */ 1042 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 && 1043 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 1044 { 1045 #if YYDEBUG 1046 if (yydebug) 1047 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 1048 YYDEBUGSTR, yydepth, yystate, yytable[yyn]); 1049 #endif 1050 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1051 yystate = yytable[yyn]; 1052 *++yystack.s_mark = yytable[yyn]; 1053 *++yystack.l_mark = yylval; 1054 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1055 *++yystack.p_mark = yylloc; 1056 #endif 1057 yychar = YYEMPTY; 1058 if (yyerrflag > 0) --yyerrflag; 1059 goto yyloop; 1060 } 1061 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 && 1062 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 1063 { 1064 yyn = yytable[yyn]; 1065 goto yyreduce; 1066 } 1067 if (yyerrflag != 0) goto yyinrecovery; 1068 #if YYBTYACC 1069 1070 yynewerrflag = 1; 1071 goto yyerrhandler; 1072 goto yyerrlab; 1073 1074 yyerrlab: 1075 yynewerrflag = 0; 1076 yyerrhandler: 1077 while (yyps->save) 1078 { 1079 int ctry; 1080 YYParseState *save = yyps->save; 1081 #if YYDEBUG 1082 if (yydebug) 1083 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n", 1084 YYDEBUGSTR, yydepth, yystate, yyps->save->state, 1085 (int)(yylvp - yylvals - yyps->save->lexeme)); 1086 #endif 1087 /* Memorize most forward-looking error state in case it's really an error. */ 1088 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals) 1089 { 1090 /* Free old saved error context state */ 1091 if (yyerrctx) yyFreeState(yyerrctx); 1092 /* Create and fill out new saved error context state */ 1093 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 1094 if (yyerrctx == NULL) goto yyenomem; 1095 yyerrctx->save = yyps->save; 1096 yyerrctx->state = yystate; 1097 yyerrctx->errflag = yyerrflag; 1098 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 1099 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 1100 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base); 1101 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1102 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1103 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 1104 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1105 #endif 1106 yyerrctx->lexeme = (int) (yylvp - yylvals); 1107 } 1108 yylvp = yylvals + save->lexeme; 1109 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1110 yylpp = yylpsns + save->lexeme; 1111 #endif 1112 yylexp = yylexemes + save->lexeme; 1113 yychar = YYEMPTY; 1114 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 1115 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 1116 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base); 1117 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1118 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1119 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 1120 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1121 #endif 1122 ctry = ++save->ctry; 1123 yystate = save->state; 1124 /* We tried shift, try reduce now */ 1125 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce; 1126 yyps->save = save->save; 1127 save->save = NULL; 1128 yyFreeState(save); 1129 1130 /* Nothing left on the stack -- error */ 1131 if (!yyps->save) 1132 { 1133 #if YYDEBUG 1134 if (yydebug) 1135 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n", 1136 YYPREFIX, yydepth); 1137 #endif 1138 /* Restore state as it was in the most forward-advanced error */ 1139 yylvp = yylvals + yyerrctx->lexeme; 1140 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1141 yylpp = yylpsns + yyerrctx->lexeme; 1142 #endif 1143 yylexp = yylexemes + yyerrctx->lexeme; 1144 yychar = yylexp[-1]; 1145 yylval = yylvp[-1]; 1146 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1147 yylloc = yylpp[-1]; 1148 #endif 1149 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 1150 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 1151 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base); 1152 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1153 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1154 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 1155 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1156 #endif 1157 yystate = yyerrctx->state; 1158 yyFreeState(yyerrctx); 1159 yyerrctx = NULL; 1160 } 1161 yynewerrflag = 1; 1162 } 1163 if (yynewerrflag == 0) goto yyinrecovery; 1164 #endif /* YYBTYACC */ 1165 1166 YYERROR_CALL("syntax error"); 1167 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1168 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */ 1169 #endif 1170 1171 #if !YYBTYACC 1172 goto yyerrlab; 1173 yyerrlab: 1174 #endif 1175 ++yynerrs; 1176 1177 yyinrecovery: 1178 if (yyerrflag < 3) 1179 { 1180 yyerrflag = 3; 1181 for (;;) 1182 { 1183 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 && 1184 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE) 1185 { 1186 #if YYDEBUG 1187 if (yydebug) 1188 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n", 1189 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]); 1190 #endif 1191 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1192 yystate = yytable[yyn]; 1193 *++yystack.s_mark = yytable[yyn]; 1194 *++yystack.l_mark = yylval; 1195 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1196 /* lookahead position is error end position */ 1197 yyerror_loc_range[1] = yylloc; 1198 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */ 1199 *++yystack.p_mark = yyloc; 1200 #endif 1201 goto yyloop; 1202 } 1203 else 1204 { 1205 #if YYDEBUG 1206 if (yydebug) 1207 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n", 1208 YYDEBUGSTR, yydepth, *yystack.s_mark); 1209 #endif 1210 if (yystack.s_mark <= yystack.s_base) goto yyabort; 1211 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1212 /* the current TOS position is the error start position */ 1213 yyerror_loc_range[0] = *yystack.p_mark; 1214 #endif 1215 #if defined(YYDESTRUCT_CALL) 1216 #if YYBTYACC 1217 if (!yytrial) 1218 #endif /* YYBTYACC */ 1219 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1220 YYDESTRUCT_CALL("error: discarding state", 1221 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark); 1222 #else 1223 YYDESTRUCT_CALL("error: discarding state", 1224 yystos[*yystack.s_mark], yystack.l_mark); 1225 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1226 #endif /* defined(YYDESTRUCT_CALL) */ 1227 --yystack.s_mark; 1228 --yystack.l_mark; 1229 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1230 --yystack.p_mark; 1231 #endif 1232 } 1233 } 1234 } 1235 else 1236 { 1237 if (yychar == YYEOF) goto yyabort; 1238 #if YYDEBUG 1239 if (yydebug) 1240 { 1241 yys = yyname[YYTRANSLATE(yychar)]; 1242 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n", 1243 YYDEBUGSTR, yydepth, yystate, yychar, yys); 1244 } 1245 #endif 1246 #if defined(YYDESTRUCT_CALL) 1247 #if YYBTYACC 1248 if (!yytrial) 1249 #endif /* YYBTYACC */ 1250 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1251 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc); 1252 #else 1253 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval); 1254 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1255 #endif /* defined(YYDESTRUCT_CALL) */ 1256 yychar = YYEMPTY; 1257 goto yyloop; 1258 } 1259 1260 yyreduce: 1261 yym = yylen[yyn]; 1262 #if YYDEBUG 1263 if (yydebug) 1264 { 1265 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)", 1266 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]); 1267 #ifdef YYSTYPE_TOSTRING 1268 #if YYBTYACC 1269 if (!yytrial) 1270 #endif /* YYBTYACC */ 1271 if (yym > 0) 1272 { 1273 int i; 1274 fputc('<', stderr); 1275 for (i = yym; i > 0; i--) 1276 { 1277 if (i != yym) fputs(", ", stderr); 1278 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]], 1279 yystack.l_mark[1-i]), stderr); 1280 } 1281 fputc('>', stderr); 1282 } 1283 #endif 1284 fputc('\n', stderr); 1285 } 1286 #endif 1287 if (yym > 0) 1288 yyval = yystack.l_mark[1-yym]; 1289 else 1290 memset(&yyval, 0, sizeof yyval); 1291 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1292 1293 /* Perform position reduction */ 1294 memset(&yyloc, 0, sizeof(yyloc)); 1295 #if YYBTYACC 1296 if (!yytrial) 1297 #endif /* YYBTYACC */ 1298 { 1299 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym); 1300 /* just in case YYERROR is invoked within the action, save 1301 the start of the rhs as the error start position */ 1302 yyerror_loc_range[0] = yystack.p_mark[1-yym]; 1303 } 1304 #endif 1305 1306 switch (yyn) 1307 { 1308 case 3: 1309 #line 57 "calc1.y" 1310 { 1311 (void) printf("%15.8f\n", yystack.l_mark[-1].dval); 1312 } 1313 break; 1314 case 4: 1315 #line 61 "calc1.y" 1316 { 1317 (void) printf("(%15.8f, %15.8f)\n", yystack.l_mark[-1].vval.lo, yystack.l_mark[-1].vval.hi); 1318 } 1319 break; 1320 case 5: 1321 #line 65 "calc1.y" 1322 { 1323 dreg[yystack.l_mark[-3].ival] = yystack.l_mark[-1].dval; 1324 } 1325 break; 1326 case 6: 1327 #line 69 "calc1.y" 1328 { 1329 vreg[yystack.l_mark[-3].ival] = yystack.l_mark[-1].vval; 1330 } 1331 break; 1332 case 7: 1333 #line 73 "calc1.y" 1334 { 1335 yyerrok; 1336 } 1337 break; 1338 case 9: 1339 #line 80 "calc1.y" 1340 { 1341 yyval.dval = dreg[yystack.l_mark[0].ival]; 1342 } 1343 break; 1344 case 10: 1345 #line 84 "calc1.y" 1346 { 1347 yyval.dval = yystack.l_mark[-2].dval + yystack.l_mark[0].dval; 1348 } 1349 break; 1350 case 11: 1351 #line 88 "calc1.y" 1352 { 1353 yyval.dval = yystack.l_mark[-2].dval - yystack.l_mark[0].dval; 1354 } 1355 break; 1356 case 12: 1357 #line 92 "calc1.y" 1358 { 1359 yyval.dval = yystack.l_mark[-2].dval * yystack.l_mark[0].dval; 1360 } 1361 break; 1362 case 13: 1363 #line 96 "calc1.y" 1364 { 1365 yyval.dval = yystack.l_mark[-2].dval / yystack.l_mark[0].dval; 1366 } 1367 break; 1368 case 14: 1369 #line 100 "calc1.y" 1370 { 1371 yyval.dval = -yystack.l_mark[0].dval; 1372 } 1373 break; 1374 case 15: 1375 #line 104 "calc1.y" 1376 { 1377 yyval.dval = yystack.l_mark[-1].dval; 1378 } 1379 break; 1380 case 16: 1381 #line 110 "calc1.y" 1382 { 1383 yyval.vval.hi = yyval.vval.lo = yystack.l_mark[0].dval; 1384 } 1385 break; 1386 case 17: 1387 #line 114 "calc1.y" 1388 { 1389 yyval.vval.lo = yystack.l_mark[-3].dval; 1390 yyval.vval.hi = yystack.l_mark[-1].dval; 1391 if ( yyval.vval.lo > yyval.vval.hi ) 1392 { 1393 (void) printf("interval out of order\n"); 1394 YYERROR; 1395 } 1396 } 1397 break; 1398 case 18: 1399 #line 124 "calc1.y" 1400 { 1401 yyval.vval = vreg[yystack.l_mark[0].ival]; 1402 } 1403 break; 1404 case 19: 1405 #line 128 "calc1.y" 1406 { 1407 yyval.vval.hi = yystack.l_mark[-2].vval.hi + yystack.l_mark[0].vval.hi; 1408 yyval.vval.lo = yystack.l_mark[-2].vval.lo + yystack.l_mark[0].vval.lo; 1409 } 1410 break; 1411 case 20: 1412 #line 133 "calc1.y" 1413 { 1414 yyval.vval.hi = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.hi; 1415 yyval.vval.lo = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.lo; 1416 } 1417 break; 1418 case 21: 1419 #line 138 "calc1.y" 1420 { 1421 yyval.vval.hi = yystack.l_mark[-2].vval.hi - yystack.l_mark[0].vval.lo; 1422 yyval.vval.lo = yystack.l_mark[-2].vval.lo - yystack.l_mark[0].vval.hi; 1423 } 1424 break; 1425 case 22: 1426 #line 143 "calc1.y" 1427 { 1428 yyval.vval.hi = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.lo; 1429 yyval.vval.lo = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.hi; 1430 } 1431 break; 1432 case 23: 1433 #line 148 "calc1.y" 1434 { 1435 yyval.vval = vmul( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval ); 1436 } 1437 break; 1438 case 24: 1439 #line 152 "calc1.y" 1440 { 1441 yyval.vval = vmul (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval ); 1442 } 1443 break; 1444 case 25: 1445 #line 156 "calc1.y" 1446 { 1447 if (dcheck(yystack.l_mark[0].vval)) YYERROR; 1448 yyval.vval = vdiv ( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval ); 1449 } 1450 break; 1451 case 26: 1452 #line 161 "calc1.y" 1453 { 1454 if (dcheck ( yystack.l_mark[0].vval )) YYERROR; 1455 yyval.vval = vdiv (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval ); 1456 } 1457 break; 1458 case 27: 1459 #line 166 "calc1.y" 1460 { 1461 yyval.vval.hi = -yystack.l_mark[0].vval.lo; 1462 yyval.vval.lo = -yystack.l_mark[0].vval.hi; 1463 } 1464 break; 1465 case 28: 1466 #line 171 "calc1.y" 1467 { 1468 yyval.vval = yystack.l_mark[-1].vval; 1469 } 1470 break; 1471 #line 1470 "calc1.tab.c" 1472 default: 1473 break; 1474 } 1475 yystack.s_mark -= yym; 1476 yystate = *yystack.s_mark; 1477 yystack.l_mark -= yym; 1478 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1479 yystack.p_mark -= yym; 1480 #endif 1481 yym = yylhs[yyn]; 1482 if (yystate == 0 && yym == 0) 1483 { 1484 #if YYDEBUG 1485 if (yydebug) 1486 { 1487 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1488 #ifdef YYSTYPE_TOSTRING 1489 #if YYBTYACC 1490 if (!yytrial) 1491 #endif /* YYBTYACC */ 1492 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval)); 1493 #endif 1494 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL); 1495 } 1496 #endif 1497 yystate = YYFINAL; 1498 *++yystack.s_mark = YYFINAL; 1499 *++yystack.l_mark = yyval; 1500 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1501 *++yystack.p_mark = yyloc; 1502 #endif 1503 if (yychar < 0) 1504 { 1505 #if YYBTYACC 1506 do { 1507 if (yylvp < yylve) 1508 { 1509 /* we're currently re-reading tokens */ 1510 yylval = *yylvp++; 1511 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1512 yylloc = *yylpp++; 1513 #endif 1514 yychar = *yylexp++; 1515 break; 1516 } 1517 if (yyps->save) 1518 { 1519 /* in trial mode; save scanner results for future parse attempts */ 1520 if (yylvp == yylvlim) 1521 { /* Enlarge lexical value queue */ 1522 size_t p = (size_t) (yylvp - yylvals); 1523 size_t s = (size_t) (yylvlim - yylvals); 1524 1525 s += YYLVQUEUEGROWTH; 1526 if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) 1527 goto yyenomem; 1528 if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) 1529 goto yyenomem; 1530 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1531 if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) 1532 goto yyenomem; 1533 #endif 1534 yylvp = yylve = yylvals + p; 1535 yylvlim = yylvals + s; 1536 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1537 yylpp = yylpe = yylpsns + p; 1538 yylplim = yylpsns + s; 1539 #endif 1540 yylexp = yylexemes + p; 1541 } 1542 *yylexp = (short) YYLEX; 1543 *yylvp++ = yylval; 1544 yylve++; 1545 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1546 *yylpp++ = yylloc; 1547 yylpe++; 1548 #endif 1549 yychar = *yylexp++; 1550 break; 1551 } 1552 /* normal operation, no conflict encountered */ 1553 #endif /* YYBTYACC */ 1554 yychar = YYLEX; 1555 #if YYBTYACC 1556 } while (0); 1557 #endif /* YYBTYACC */ 1558 if (yychar < 0) yychar = YYEOF; 1559 /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */ 1560 #if YYDEBUG 1561 if (yydebug) 1562 { 1563 yys = yyname[YYTRANSLATE(yychar)]; 1564 fprintf(stderr, "%s[%d]: state %d, reading %d (%s)\n", 1565 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys); 1566 } 1567 #endif 1568 } 1569 if (yychar == YYEOF) goto yyaccept; 1570 goto yyloop; 1571 } 1572 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 && 1573 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate) 1574 yystate = yytable[yyn]; 1575 else 1576 yystate = yydgoto[yym]; 1577 #if YYDEBUG 1578 if (yydebug) 1579 { 1580 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1581 #ifdef YYSTYPE_TOSTRING 1582 #if YYBTYACC 1583 if (!yytrial) 1584 #endif /* YYBTYACC */ 1585 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval)); 1586 #endif 1587 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate); 1588 } 1589 #endif 1590 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1591 *++yystack.s_mark = (short) yystate; 1592 *++yystack.l_mark = yyval; 1593 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1594 *++yystack.p_mark = yyloc; 1595 #endif 1596 goto yyloop; 1597 #if YYBTYACC 1598 1599 /* Reduction declares that this path is valid. Set yypath and do a full parse */ 1600 yyvalid: 1601 if (yypath) YYABORT; 1602 while (yyps->save) 1603 { 1604 YYParseState *save = yyps->save; 1605 yyps->save = save->save; 1606 save->save = yypath; 1607 yypath = save; 1608 } 1609 #if YYDEBUG 1610 if (yydebug) 1611 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n", 1612 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme)); 1613 #endif 1614 if (yyerrctx) 1615 { 1616 yyFreeState(yyerrctx); 1617 yyerrctx = NULL; 1618 } 1619 yylvp = yylvals + yypath->lexeme; 1620 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1621 yylpp = yylpsns + yypath->lexeme; 1622 #endif 1623 yylexp = yylexemes + yypath->lexeme; 1624 yychar = YYEMPTY; 1625 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 1626 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 1627 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base); 1628 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1629 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1630 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 1631 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1632 #endif 1633 yystate = yypath->state; 1634 goto yyloop; 1635 #endif /* YYBTYACC */ 1636 1637 yyoverflow: 1638 YYERROR_CALL("yacc stack overflow"); 1639 #if YYBTYACC 1640 goto yyabort_nomem; 1641 yyenomem: 1642 YYERROR_CALL("memory exhausted"); 1643 yyabort_nomem: 1644 #endif /* YYBTYACC */ 1645 yyresult = 2; 1646 goto yyreturn; 1647 1648 yyabort: 1649 yyresult = 1; 1650 goto yyreturn; 1651 1652 yyaccept: 1653 #if YYBTYACC 1654 if (yyps->save) goto yyvalid; 1655 #endif /* YYBTYACC */ 1656 yyresult = 0; 1657 1658 yyreturn: 1659 #if defined(YYDESTRUCT_CALL) 1660 if (yychar != YYEOF && yychar != YYEMPTY) 1661 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1662 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc); 1663 #else 1664 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval); 1665 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1666 1667 { 1668 YYSTYPE *pv; 1669 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1670 YYLTYPE *pp; 1671 1672 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp) 1673 YYDESTRUCT_CALL("cleanup: discarding state", 1674 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp); 1675 #else 1676 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv) 1677 YYDESTRUCT_CALL("cleanup: discarding state", 1678 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv); 1679 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1680 } 1681 #endif /* defined(YYDESTRUCT_CALL) */ 1682 1683 #if YYBTYACC 1684 if (yyerrctx) 1685 { 1686 yyFreeState(yyerrctx); 1687 yyerrctx = NULL; 1688 } 1689 while (yyps) 1690 { 1691 YYParseState *save = yyps; 1692 yyps = save->save; 1693 save->save = NULL; 1694 yyFreeState(save); 1695 } 1696 while (yypath) 1697 { 1698 YYParseState *save = yypath; 1699 yypath = save->save; 1700 save->save = NULL; 1701 yyFreeState(save); 1702 } 1703 #endif /* YYBTYACC */ 1704 yyfreestack(&yystack); 1705 return (yyresult); 1706 } 1707