contrib/byacc/test/btyacc/calc1.tab.c

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