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