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