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