contrib/byacc/test/yacc/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
  17 #ifndef yyparse
  18 #define yyparse    calc1_parse
  19 #endif /* yyparse */
  20
  21 #ifndef yylex
  22 #define yylex      calc1_lex
  23 #endif /* yylex */
  24
  25 #ifndef yyerror
  26 #define yyerror    calc1_error
  27 #endif /* yyerror */
  28
  29 #ifndef yychar
  30 #define yychar     calc1_char
  31 #endif /* yychar */
  32
  33 #ifndef yyval
  34 #define yyval      calc1_val
  35 #endif /* yyval */
  36
  37 #ifndef yylval
  38 #define yylval     calc1_lval
  39 #endif /* yylval */
  40
  41 #ifndef yydebug
  42 #define yydebug    calc1_debug
  43 #endif /* yydebug */
  44
  45 #ifndef yynerrs
  46 #define yynerrs    calc1_nerrs
  47 #endif /* yynerrs */
  48
  49 #ifndef yyerrflag
  50 #define yyerrflag  calc1_errflag
  51 #endif /* yyerrflag */
  52
  53 #ifndef yylhs
  54 #define yylhs      calc1_lhs
  55 #endif /* yylhs */
  56
  57 #ifndef yylen
  58 #define yylen      calc1_len
  59 #endif /* yylen */
  60
  61 #ifndef yydefred
  62 #define yydefred   calc1_defred
  63 #endif /* yydefred */
  64
  65 #ifndef yydgoto
  66 #define yydgoto    calc1_dgoto
  67 #endif /* yydgoto */
  68
  69 #ifndef yysindex
  70 #define yysindex   calc1_sindex
  71 #endif /* yysindex */
  72
  73 #ifndef yyrindex
  74 #define yyrindex   calc1_rindex
  75 #endif /* yyrindex */
  76
  77 #ifndef yygindex
  78 #define yygindex   calc1_gindex
  79 #endif /* yygindex */
  80
  81 #ifndef yytable
  82 #define yytable    calc1_table
  83 #endif /* yytable */
  84
  85 #ifndef yycheck
  86 #define yycheck    calc1_check
  87 #endif /* yycheck */
  88
  89 #ifndef yyname
  90 #define yyname     calc1_name
  91 #endif /* yyname */
  92
  93 #ifndef yyrule
  94 #define yyrule     calc1_rule
  95 #endif /* yyrule */
  96 #define YYPREFIX "calc1_"
  97
  98 #define YYPURE 0
  99
 100 #line 2 "calc1.y"
 101
 102 /* http://dinosaur.compilertools.net/yacc/index.html */
 103
 104 #include <stdlib.h>
 105 #include <stdio.h>
 106 #include <ctype.h>
 107 #include <math.h>
 108
 109 typedef struct interval
 110 {
 111     double lo, hi;
 112 }
 113 INTERVAL;
 114
 115 INTERVAL vmul(double, double, INTERVAL);
 116 INTERVAL vdiv(double, double, INTERVAL);
 117
 118 extern int yylex(void);
 119 static void yyerror(const char *s);
 120
 121 int dcheck(INTERVAL);
 122
 123 double dreg[26];
 124 INTERVAL vreg[26];
 125
 126 #line 31 "calc1.y"
 127 #ifdef YYSTYPE
 128 #undef  YYSTYPE_IS_DECLARED
 129 #define YYSTYPE_IS_DECLARED 1
 130 #endif
 131 #ifndef YYSTYPE_IS_DECLARED
 132 #define YYSTYPE_IS_DECLARED 1
 133 typedef union
 134 {
 135         int ival;
 136         double dval;
 137         INTERVAL vval;
 138 } YYSTYPE;
 139 #endif /* !YYSTYPE_IS_DECLARED */
 140 #line 141 "calc1.tab.c"
 141
 142 /* compatibility with bison */
 143 #ifdef YYPARSE_PARAM
 144 /* compatibility with FreeBSD */
 145 # ifdef YYPARSE_PARAM_TYPE
 146 #  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
 147 # else
 148 #  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
 149 # endif
 150 #else
 151 # define YYPARSE_DECL() yyparse(void)
 152 #endif
 153
 154 /* Parameters sent to lex. */
 155 #ifdef YYLEX_PARAM
 156 # define YYLEX_DECL() yylex(void *YYLEX_PARAM)
 157 # define YYLEX yylex(YYLEX_PARAM)
 158 #else
 159 # define YYLEX_DECL() yylex(void)
 160 # define YYLEX yylex()
 161 #endif
 162
 163 /* Parameters sent to yyerror. */
 164 #ifndef YYERROR_DECL
 165 #define YYERROR_DECL() yyerror(const char *s)
 166 #endif
 167 #ifndef YYERROR_CALL
 168 #define YYERROR_CALL(msg) yyerror(msg)
 169 #endif
 170
 171 extern int YYPARSE_DECL();
 172
 173 #define DREG 257
 174 #define VREG 258
 175 #define CONST 259
 176 #define UMINUS 260
 177 #define YYERRCODE 256
 178 typedef int YYINT;
 179 static const YYINT calc1_lhs[] = {                       -1,
 180     3,    3,    0,    0,    0,    0,    0,    1,    1,    1,
 181     1,    1,    1,    1,    1,    2,    2,    2,    2,    2,
 182     2,    2,    2,    2,    2,    2,    2,    2,
 183 };
 184 static const YYINT calc1_len[] = {                        2,
 185     0,    2,    2,    2,    4,    4,    2,    1,    1,    3,
 186     3,    3,    3,    2,    3,    1,    5,    1,    3,    3,
 187     3,    3,    3,    3,    3,    3,    2,    3,
 188 };
 189 static const YYINT calc1_defred[] = {                     0,
 190     0,    0,    0,    8,    0,    0,    0,    0,    0,    7,
 191     0,    0,    9,   18,   14,   27,    0,    0,    0,    0,
 192     0,    0,    3,    0,    0,    0,    0,    4,    0,    0,
 193     0,    0,    0,   15,    0,   28,    0,    0,    0,    0,
 194    12,   24,   13,   26,    0,    0,   23,   25,   14,    0,
 195     0,    0,    0,    0,    5,    6,    0,    0,    0,   12,
 196    13,   17,
 197 };
 198 static const YYINT calc1_dgoto[] = {                      7,
 199    32,    9,    0,
 200 };
 201 static const YYINT calc1_sindex[] = {                   -40,
 202    -8,  -48,  -47,    0,  -37,  -37,    0,    2,   17,    0,
 203   -34,  -37,    0,    0,    0,    0,  -25,   90,  -37,  -37,
 204   -37,  -37,    0,  -37,  -37,  -37,  -37,    0,  -34,  -34,
 205    25,  125,   31,    0,  -34,    0,  -11,   37,  -11,   37,
 206     0,    0,    0,    0,   37,   37,    0,    0,    0,  111,
 207   -34,  -34,  -34,  -34,    0,    0,  118,   69,   69,    0,
 208     0,    0,
 209 };
 210 static const YYINT calc1_rindex[] = {                     0,
 211     0,   38,   44,    0,    0,    0,    0,    0,    0,    0,
 212     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 213     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 214     0,   -9,    0,    0,    0,    0,   51,   -3,   56,   61,
 215     0,    0,    0,    0,   67,   72,    0,    0,    0,    0,
 216     0,    0,    0,    0,    0,    0,    0,   78,   83,    0,
 217     0,    0,
 218 };
 219 static const YYINT calc1_gindex[] = {                     0,
 220     4,  124,    0,
 221 };
 222 #define YYTABLESIZE 225
 223 static const YYINT calc1_table[] = {                      6,
 224    16,   10,    6,    8,    5,   30,   20,    5,   15,   17,
 225    29,   23,   11,   12,   31,   34,   21,   19,   35,   20,
 226     0,   22,   37,   39,   41,   43,   28,    0,    0,    0,
 227    21,   16,   49,   50,   55,   22,    0,   20,   57,   20,
 228    56,   20,    0,   21,   19,    0,   20,    9,   22,    0,
 229     0,    0,    0,   18,   58,   59,   60,   61,   26,   24,
 230    10,   25,    0,   27,    0,   11,   53,   51,    0,   52,
 231    22,   54,   26,   24,    0,   25,   19,   27,   26,    9,
 232     9,   21,    9,   27,    9,   18,   18,   10,   18,    0,
 233    18,   10,   11,   10,   10,   10,   11,    0,   11,   11,
 234    11,   22,    0,   22,    0,   22,    0,   19,    0,   19,
 235    53,   19,   21,    0,   21,   54,   21,    0,   10,    0,
 236    10,    0,   10,   11,    0,   11,    0,   11,   16,   18,
 237    36,   26,   24,    0,   25,   33,   27,    0,    0,    0,
 238     0,    0,   38,   40,   42,   44,    0,   45,   46,   47,
 239    48,   34,   53,   51,    0,   52,    0,   54,   62,   53,
 240    51,    0,   52,    0,   54,    0,   21,   19,    0,   20,
 241     0,   22,    0,    0,    0,    0,    0,    0,    0,    0,
 242     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 243     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 244     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 245     0,    0,    0,    0,    0,    1,    2,    3,    4,   13,
 246    14,    4,   13,    0,    4,
 247 };
 248 static const YYINT calc1_check[] = {                     40,
 249    10,   10,   40,    0,   45,   40,   10,   45,    5,    6,
 250    45,   10,   61,   61,   11,   41,   42,   43,   44,   45,
 251    -1,   47,   19,   20,   21,   22,   10,   -1,   -1,   -1,
 252    42,   41,   29,   30,   10,   47,   -1,   41,   35,   43,
 253    10,   45,   -1,   42,   43,   -1,   45,   10,   47,   -1,
 254    -1,   -1,   -1,   10,   51,   52,   53,   54,   42,   43,
 255    10,   45,   -1,   47,   -1,   10,   42,   43,   -1,   45,
 256    10,   47,   42,   43,   -1,   45,   10,   47,   42,   42,
 257    43,   10,   45,   47,   47,   42,   43,   10,   45,   -1,
 258    47,   41,   10,   43,   44,   45,   41,   -1,   43,   44,
 259    45,   41,   -1,   43,   -1,   45,   -1,   41,   -1,   43,
 260    42,   45,   41,   -1,   43,   47,   45,   -1,   41,   -1,
 261    43,   -1,   45,   41,   -1,   43,   -1,   45,    5,    6,
 262    41,   42,   43,   -1,   45,   12,   47,   -1,   -1,   -1,
 263    -1,   -1,   19,   20,   21,   22,   -1,   24,   25,   26,
 264    27,   41,   42,   43,   -1,   45,   -1,   47,   41,   42,
 265    43,   -1,   45,   -1,   47,   -1,   42,   43,   -1,   45,
 266    -1,   47,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 267    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 268    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 269    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 270    -1,   -1,   -1,   -1,   -1,  256,  257,  258,  259,  257,
 271   258,  259,  257,   -1,  259,
 272 };
 273 #define YYFINAL 7
 274 #ifndef YYDEBUG
 275 #define YYDEBUG 0
 276 #endif
 277 #define YYMAXTOKEN 260
 278 #define YYUNDFTOKEN 266
 279 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
 280 #if YYDEBUG
 281 static const char *const calc1_name[] = {
 282
 283 "end-of-file",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,
 284 0,0,0,0,0,0,0,0,0,"'('","')'","'*'","'+'","','","'-'",0,"'/'",0,0,0,0,0,0,0,0,0,
 285 0,0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 286 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 287 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 288 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 289 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 290 0,0,"DREG","VREG","CONST","UMINUS",0,0,0,0,0,"illegal-symbol",
 291 };
 292 static const char *const calc1_rule[] = {
 293 "$accept : line",
 294 "lines :",
 295 "lines : lines line",
 296 "line : dexp '\\n'",
 297 "line : vexp '\\n'",
 298 "line : DREG '=' dexp '\\n'",
 299 "line : VREG '=' vexp '\\n'",
 300 "line : error '\\n'",
 301 "dexp : CONST",
 302 "dexp : DREG",
 303 "dexp : dexp '+' dexp",
 304 "dexp : dexp '-' dexp",
 305 "dexp : dexp '*' dexp",
 306 "dexp : dexp '/' dexp",
 307 "dexp : '-' dexp",
 308 "dexp : '(' dexp ')'",
 309 "vexp : dexp",
 310 "vexp : '(' dexp ',' dexp ')'",
 311 "vexp : VREG",
 312 "vexp : vexp '+' vexp",
 313 "vexp : dexp '+' vexp",
 314 "vexp : vexp '-' vexp",
 315 "vexp : dexp '-' vexp",
 316 "vexp : vexp '*' vexp",
 317 "vexp : dexp '*' vexp",
 318 "vexp : vexp '/' vexp",
 319 "vexp : dexp '/' vexp",
 320 "vexp : '-' vexp",
 321 "vexp : '(' vexp ')'",
 322
 323 };
 324 #endif
 325
 326 int      yydebug;
 327 int      yynerrs;
 328
 329 int      yyerrflag;
 330 int      yychar;
 331 YYSTYPE  yyval;
 332 YYSTYPE  yylval;
 333
 334 /* define the initial stack-sizes */
 335 #ifdef YYSTACKSIZE
 336 #undef YYMAXDEPTH
 337 #define YYMAXDEPTH  YYSTACKSIZE
 338 #else
 339 #ifdef YYMAXDEPTH
 340 #define YYSTACKSIZE YYMAXDEPTH
 341 #else
 342 #define YYSTACKSIZE 10000
 343 #define YYMAXDEPTH  10000
 344 #endif
 345 #endif
 346
 347 #define YYINITSTACKSIZE 200
 348
 349 typedef struct {
 350     unsigned stacksize;
 351     YYINT    *s_base;
 352     YYINT    *s_mark;
 353     YYINT    *s_last;
 354     YYSTYPE  *l_base;
 355     YYSTYPE  *l_mark;
 356 } YYSTACKDATA;
 357 /* variables for the parser stack */
 358 static YYSTACKDATA yystack;
 359 #line 176 "calc1.y"
 360         /* beginning of subroutines section */
 361
 362 #define BSZ 50                  /* buffer size for floating point numbers */
 363
 364         /* lexical analysis */
 365
 366 static void
 367 yyerror(const char *s)
 368 {
 369     fprintf(stderr, "%s\n", s);
 370 }
 371
 372 int
 373 yylex(void)
 374 {
 375     int c;
 376
 377     while ((c = getchar()) == ' ')
 378     {                           /* skip over blanks */
 379     }
 380
 381     if (isupper(c))
 382     {
 383         yylval.ival = c - 'A';
 384         return (VREG);
 385     }
 386     if (islower(c))
 387     {
 388         yylval.ival = c - 'a';
 389         return (DREG);
 390     }
 391
 392     if (isdigit(c) || c == '.')
 393     {
 394         /* gobble up digits, points, exponents */
 395         char buf[BSZ + 1], *cp = buf;
 396         int dot = 0, expr = 0;
 397
 398         for (; (cp - buf) < BSZ; ++cp, c = getchar())
 399         {
 400
 401             *cp = (char) c;
 402             if (isdigit(c))
 403                 continue;
 404             if (c == '.')
 405             {
 406                 if (dot++ || expr)
 407                     return ('.');       /* will cause syntax error */
 408                 continue;
 409             }
 410
 411             if (c == 'e')
 412             {
 413                 if (expr++)
 414                     return ('e');       /*  will  cause  syntax  error  */
 415                 continue;
 416             }
 417
 418             /*  end  of  number  */
 419             break;
 420         }
 421         *cp = '\0';
 422
 423         if ((cp - buf) >= BSZ)
 424             printf("constant  too  long:  truncated\n");
 425         else
 426             ungetc(c, stdin);   /*  push  back  last  char  read  */
 427         yylval.dval = atof(buf);
 428         return (CONST);
 429     }
 430     return (c);
 431 }
 432
 433 static INTERVAL
 434 hilo(double a, double b, double c, double d)
 435 {
 436     /*  returns  the  smallest  interval  containing  a,  b,  c,  and  d  */
 437     /*  used  by  *,  /  routines  */
 438     INTERVAL v;
 439
 440     if (a > b)
 441     {
 442         v.hi = a;
 443         v.lo = b;
 444     }
 445     else
 446     {
 447         v.hi = b;
 448         v.lo = a;
 449     }
 450
 451     if (c > d)
 452     {
 453         if (c > v.hi)
 454             v.hi = c;
 455         if (d < v.lo)
 456             v.lo = d;
 457     }
 458     else
 459     {
 460         if (d > v.hi)
 461             v.hi = d;
 462         if (c < v.lo)
 463             v.lo = c;
 464     }
 465     return (v);
 466 }
 467
 468 INTERVAL
 469 vmul(double a, double b, INTERVAL v)
 470 {
 471     return (hilo(a * v.hi, a * v.lo, b * v.hi, b * v.lo));
 472 }
 473
 474 int
 475 dcheck(INTERVAL v)
 476 {
 477     if (v.hi >= 0. && v.lo <= 0.)
 478     {
 479         printf("divisor  interval  contains  0.\n");
 480         return (1);
 481     }
 482     return (0);
 483 }
 484
 485 INTERVAL
 486 vdiv(double a, double b, INTERVAL v)
 487 {
 488     return (hilo(a / v.hi, a / v.lo, b / v.hi, b / v.lo));
 489 }
 490 #line 491 "calc1.tab.c"
 491
 492 #if YYDEBUG
 493 #include <stdio.h>              /* needed for printf */
 494 #endif
 495
 496 #include <stdlib.h>     /* needed for malloc, etc */
 497 #include <string.h>     /* needed for memset */
 498
 499 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
 500 static int yygrowstack(YYSTACKDATA *data)
 501 {
 502     int i;
 503     unsigned newsize;
 504     YYINT *newss;
 505     YYSTYPE *newvs;
 506
 507     if ((newsize = data->stacksize) == 0)
 508         newsize = YYINITSTACKSIZE;
 509     else if (newsize >= YYMAXDEPTH)
 510         return YYENOMEM;
 511     else if ((newsize *= 2) > YYMAXDEPTH)
 512         newsize = YYMAXDEPTH;
 513
 514     i = (int) (data->s_mark - data->s_base);
 515     newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
 516     if (newss == 0)
 517         return YYENOMEM;
 518
 519     data->s_base = newss;
 520     data->s_mark = newss + i;
 521
 522     newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
 523     if (newvs == 0)
 524         return YYENOMEM;
 525
 526     data->l_base = newvs;
 527     data->l_mark = newvs + i;
 528
 529     data->stacksize = newsize;
 530     data->s_last = data->s_base + newsize - 1;
 531     return 0;
 532 }
 533
 534 #if YYPURE || defined(YY_NO_LEAKS)
 535 static void yyfreestack(YYSTACKDATA *data)
 536 {
 537     free(data->s_base);
 538     free(data->l_base);
 539     memset(data, 0, sizeof(*data));
 540 }
 541 #else
 542 #define yyfreestack(data) /* nothing */
 543 #endif
 544
 545 #define YYABORT  goto yyabort
 546 #define YYREJECT goto yyabort
 547 #define YYACCEPT goto yyaccept
 548 #define YYERROR  goto yyerrlab
 549
 550 int
 551 YYPARSE_DECL()
 552 {
 553     int yym, yyn, yystate;
 554 #if YYDEBUG
 555     const char *yys;
 556
 557     if ((yys = getenv("YYDEBUG")) != 0)
 558     {
 559         yyn = *yys;
 560         if (yyn >= '0' && yyn <= '9')
 561             yydebug = yyn - '0';
 562     }
 563 #endif
 564
 565     yynerrs = 0;
 566     yyerrflag = 0;
 567     yychar = YYEMPTY;
 568     yystate = 0;
 569
 570 #if YYPURE
 571     memset(&yystack, 0, sizeof(yystack));
 572 #endif
 573
 574     if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
 575     yystack.s_mark = yystack.s_base;
 576     yystack.l_mark = yystack.l_base;
 577     yystate = 0;
 578     *yystack.s_mark = 0;
 579
 580 yyloop:
 581     if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
 582     if (yychar < 0)
 583     {
 584         if ((yychar = YYLEX) < 0) yychar = YYEOF;
 585 #if YYDEBUG
 586         if (yydebug)
 587         {
 588             yys = yyname[YYTRANSLATE(yychar)];
 589             printf("%sdebug: state %d, reading %d (%s)\n",
 590                     YYPREFIX, yystate, yychar, yys);
 591         }
 592 #endif
 593     }
 594     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
 595             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 596     {
 597 #if YYDEBUG
 598         if (yydebug)
 599             printf("%sdebug: state %d, shifting to state %d\n",
 600                     YYPREFIX, yystate, yytable[yyn]);
 601 #endif
 602         if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
 603         {
 604             goto yyoverflow;
 605         }
 606         yystate = yytable[yyn];
 607         *++yystack.s_mark = yytable[yyn];
 608         *++yystack.l_mark = yylval;
 609         yychar = YYEMPTY;
 610         if (yyerrflag > 0)  --yyerrflag;
 611         goto yyloop;
 612     }
 613     if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
 614             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 615     {
 616         yyn = yytable[yyn];
 617         goto yyreduce;
 618     }
 619     if (yyerrflag) goto yyinrecovery;
 620
 621     YYERROR_CALL("syntax error");
 622
 623     goto yyerrlab;
 624
 625 yyerrlab:
 626     ++yynerrs;
 627
 628 yyinrecovery:
 629     if (yyerrflag < 3)
 630     {
 631         yyerrflag = 3;
 632         for (;;)
 633         {
 634             if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
 635                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
 636             {
 637 #if YYDEBUG
 638                 if (yydebug)
 639                     printf("%sdebug: state %d, error recovery shifting\
 640  to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
 641 #endif
 642                 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
 643                 {
 644                     goto yyoverflow;
 645                 }
 646                 yystate = yytable[yyn];
 647                 *++yystack.s_mark = yytable[yyn];
 648                 *++yystack.l_mark = yylval;
 649                 goto yyloop;
 650             }
 651             else
 652             {
 653 #if YYDEBUG
 654                 if (yydebug)
 655                     printf("%sdebug: error recovery discarding state %d\n",
 656                             YYPREFIX, *yystack.s_mark);
 657 #endif
 658                 if (yystack.s_mark <= yystack.s_base) goto yyabort;
 659                 --yystack.s_mark;
 660                 --yystack.l_mark;
 661             }
 662         }
 663     }
 664     else
 665     {
 666         if (yychar == YYEOF) goto yyabort;
 667 #if YYDEBUG
 668         if (yydebug)
 669         {
 670             yys = yyname[YYTRANSLATE(yychar)];
 671             printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
 672                     YYPREFIX, yystate, yychar, yys);
 673         }
 674 #endif
 675         yychar = YYEMPTY;
 676         goto yyloop;
 677     }
 678
 679 yyreduce:
 680 #if YYDEBUG
 681     if (yydebug)
 682         printf("%sdebug: state %d, reducing by rule %d (%s)\n",
 683                 YYPREFIX, yystate, yyn, yyrule[yyn]);
 684 #endif
 685     yym = yylen[yyn];
 686     if (yym)
 687         yyval = yystack.l_mark[1-yym];
 688     else
 689         memset(&yyval, 0, sizeof yyval);
 690     switch (yyn)
 691     {
 692 case 3:
 693 #line 57 "calc1.y"
 694         {
 695                 (void) printf("%15.8f\n", yystack.l_mark[-1].dval);
 696         }
 697 break;
 698 case 4:
 699 #line 61 "calc1.y"
 700         {
 701                 (void) printf("(%15.8f, %15.8f)\n", yystack.l_mark[-1].vval.lo, yystack.l_mark[-1].vval.hi);
 702         }
 703 break;
 704 case 5:
 705 #line 65 "calc1.y"
 706         {
 707                 dreg[yystack.l_mark[-3].ival] = yystack.l_mark[-1].dval;
 708         }
 709 break;
 710 case 6:
 711 #line 69 "calc1.y"
 712         {
 713                 vreg[yystack.l_mark[-3].ival] = yystack.l_mark[-1].vval;
 714         }
 715 break;
 716 case 7:
 717 #line 73 "calc1.y"
 718         {
 719                 yyerrok;
 720         }
 721 break;
 722 case 9:
 723 #line 80 "calc1.y"
 724         {
 725                 yyval.dval = dreg[yystack.l_mark[0].ival];
 726         }
 727 break;
 728 case 10:
 729 #line 84 "calc1.y"
 730         {
 731                 yyval.dval = yystack.l_mark[-2].dval + yystack.l_mark[0].dval;
 732         }
 733 break;
 734 case 11:
 735 #line 88 "calc1.y"
 736         {
 737                 yyval.dval = yystack.l_mark[-2].dval - yystack.l_mark[0].dval;
 738         }
 739 break;
 740 case 12:
 741 #line 92 "calc1.y"
 742         {
 743                 yyval.dval = yystack.l_mark[-2].dval * yystack.l_mark[0].dval;
 744         }
 745 break;
 746 case 13:
 747 #line 96 "calc1.y"
 748         {
 749                 yyval.dval = yystack.l_mark[-2].dval / yystack.l_mark[0].dval;
 750         }
 751 break;
 752 case 14:
 753 #line 100 "calc1.y"
 754         {
 755                 yyval.dval = -yystack.l_mark[0].dval;
 756         }
 757 break;
 758 case 15:
 759 #line 104 "calc1.y"
 760         {
 761                 yyval.dval = yystack.l_mark[-1].dval;
 762         }
 763 break;
 764 case 16:
 765 #line 110 "calc1.y"
 766         {
 767                 yyval.vval.hi = yyval.vval.lo = yystack.l_mark[0].dval;
 768         }
 769 break;
 770 case 17:
 771 #line 114 "calc1.y"
 772         {
 773                 yyval.vval.lo = yystack.l_mark[-3].dval;
 774                 yyval.vval.hi = yystack.l_mark[-1].dval;
 775                 if ( yyval.vval.lo > yyval.vval.hi )
 776                 {
 777                         (void) printf("interval out of order\n");
 778                         YYERROR;
 779                 }
 780         }
 781 break;
 782 case 18:
 783 #line 124 "calc1.y"
 784         {
 785                 yyval.vval = vreg[yystack.l_mark[0].ival];
 786         }
 787 break;
 788 case 19:
 789 #line 128 "calc1.y"
 790         {
 791                 yyval.vval.hi = yystack.l_mark[-2].vval.hi + yystack.l_mark[0].vval.hi;
 792                 yyval.vval.lo = yystack.l_mark[-2].vval.lo + yystack.l_mark[0].vval.lo;
 793         }
 794 break;
 795 case 20:
 796 #line 133 "calc1.y"
 797         {
 798                 yyval.vval.hi = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.hi;
 799                 yyval.vval.lo = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.lo;
 800         }
 801 break;
 802 case 21:
 803 #line 138 "calc1.y"
 804         {
 805                 yyval.vval.hi = yystack.l_mark[-2].vval.hi - yystack.l_mark[0].vval.lo;
 806                 yyval.vval.lo = yystack.l_mark[-2].vval.lo - yystack.l_mark[0].vval.hi;
 807         }
 808 break;
 809 case 22:
 810 #line 143 "calc1.y"
 811         {
 812                 yyval.vval.hi = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.lo;
 813                 yyval.vval.lo = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.hi;
 814         }
 815 break;
 816 case 23:
 817 #line 148 "calc1.y"
 818         {
 819                 yyval.vval = vmul( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval );
 820         }
 821 break;
 822 case 24:
 823 #line 152 "calc1.y"
 824         {
 825                 yyval.vval = vmul (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval );
 826         }
 827 break;
 828 case 25:
 829 #line 156 "calc1.y"
 830         {
 831                 if (dcheck(yystack.l_mark[0].vval)) YYERROR;
 832                 yyval.vval = vdiv ( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval );
 833         }
 834 break;
 835 case 26:
 836 #line 161 "calc1.y"
 837         {
 838                 if (dcheck ( yystack.l_mark[0].vval )) YYERROR;
 839                 yyval.vval = vdiv (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval );
 840         }
 841 break;
 842 case 27:
 843 #line 166 "calc1.y"
 844         {
 845                 yyval.vval.hi = -yystack.l_mark[0].vval.lo;
 846                 yyval.vval.lo = -yystack.l_mark[0].vval.hi;
 847         }
 848 break;
 849 case 28:
 850 #line 171 "calc1.y"
 851         {
 852                 yyval.vval = yystack.l_mark[-1].vval;
 853         }
 854 break;
 855 #line 856 "calc1.tab.c"
 856     }
 857     yystack.s_mark -= yym;
 858     yystate = *yystack.s_mark;
 859     yystack.l_mark -= yym;
 860     yym = yylhs[yyn];
 861     if (yystate == 0 && yym == 0)
 862     {
 863 #if YYDEBUG
 864         if (yydebug)
 865             printf("%sdebug: after reduction, shifting from state 0 to\
 866  state %d\n", YYPREFIX, YYFINAL);
 867 #endif
 868         yystate = YYFINAL;
 869         *++yystack.s_mark = YYFINAL;
 870         *++yystack.l_mark = yyval;
 871         if (yychar < 0)
 872         {
 873             if ((yychar = YYLEX) < 0) yychar = YYEOF;
 874 #if YYDEBUG
 875             if (yydebug)
 876             {
 877                 yys = yyname[YYTRANSLATE(yychar)];
 878                 printf("%sdebug: state %d, reading %d (%s)\n",
 879                         YYPREFIX, YYFINAL, yychar, yys);
 880             }
 881 #endif
 882         }
 883         if (yychar == YYEOF) goto yyaccept;
 884         goto yyloop;
 885     }
 886     if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
 887             yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
 888         yystate = yytable[yyn];
 889     else
 890         yystate = yydgoto[yym];
 891 #if YYDEBUG
 892     if (yydebug)
 893         printf("%sdebug: after reduction, shifting from state %d \
 894 to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
 895 #endif
 896     if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
 897     {
 898         goto yyoverflow;
 899     }
 900     *++yystack.s_mark = (YYINT) yystate;
 901     *++yystack.l_mark = yyval;
 902     goto yyloop;
 903
 904 yyoverflow:
 905     YYERROR_CALL("yacc stack overflow");
 906
 907 yyabort:
 908     yyfreestack(&yystack);
 909     return (1);
 910
 911 yyaccept:
 912     yyfreestack(&yystack);
 913     return (0);
 914 }