Home | History | Annotate | Line # | Download | only in yacc
calc1.tab.c revision 1.5 
      1 /*	$NetBSD: calc1.tab.c,v 1.5 2024/09/14 21:29:04 christos Exp $	*/
      2 
      3 /* original parser id follows */
      4 /* yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93" */
      5 /* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
      6 
      7 #define YYBYACC 1
      8 #define YYMAJOR 2
      9 #define YYMINOR 0
     10 #define YYCHECK "yyyymmdd"
     11 
     12 #define YYEMPTY        (-1)
     13 #define yyclearin      (yychar = YYEMPTY)
     14 #define yyerrok        (yyerrflag = 0)
     15 #define YYRECOVERING() (yyerrflag != 0)
     16 #define YYENOMEM       (-2)
     17 #define YYEOF          0
     18 
     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 YYSTYPE
    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 int 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 #if YYDEBUG
    329 int      yydebug;
    330 #endif
    331 
    332 int      yyerrflag;
    333 int      yychar;
    334 YYSTYPE  yyval;
    335 YYSTYPE  yylval;
    336 int      yynerrs;
    337 
    338 /* define the initial stack-sizes */
    339 #ifdef YYSTACKSIZE
    340 #undef YYMAXDEPTH
    341 #define YYMAXDEPTH  YYSTACKSIZE
    342 #else
    343 #ifdef YYMAXDEPTH
    344 #define YYSTACKSIZE YYMAXDEPTH
    345 #else
    346 #define YYSTACKSIZE 10000
    347 #define YYMAXDEPTH  10000
    348 #endif
    349 #endif
    350 
    351 #define YYINITSTACKSIZE 200
    352 
    353 typedef struct {
    354     unsigned stacksize;
    355     YYINT    *s_base;
    356     YYINT    *s_mark;
    357     YYINT    *s_last;
    358     YYSTYPE  *l_base;
    359     YYSTYPE  *l_mark;
    360 } YYSTACKDATA;
    361 /* variables for the parser stack */
    362 static YYSTACKDATA yystack;
    363 #line 176 "calc1.y"
    364 	/* beginning of subroutines section */
    365 
    366 #define BSZ 50			/* buffer size for floating point numbers */
    367 
    368 	/* lexical analysis */
    369 
    370 static void
    371 yyerror(const char *s)
    372 {
    373     fprintf(stderr, "%s\n", s);
    374 }
    375 
    376 int
    377 yylex(void)
    378 {
    379     int c;
    380 
    381     while ((c = getchar()) == ' ')
    382     {				/* skip over blanks */
    383     }
    384 
    385     if (isupper(c))
    386     {
    387 	yylval.ival = c - 'A';
    388 	return (VREG);
    389     }
    390     if (islower(c))
    391     {
    392 	yylval.ival = c - 'a';
    393 	return (DREG);
    394     }
    395 
    396     if (isdigit(c) || c == '.')
    397     {
    398 	/* gobble up digits, points, exponents */
    399 	char buf[BSZ + 1], *cp = buf;
    400 	int dot = 0, expr = 0;
    401 
    402 	for (; (cp - buf) < BSZ; ++cp, c = getchar())
    403 	{
    404 
    405 	    *cp = (char) c;
    406 	    if (isdigit(c))
    407 		continue;
    408 	    if (c == '.')
    409 	    {
    410 		if (dot++ || expr)
    411 		    return ('.');	/* will cause syntax error */
    412 		continue;
    413 	    }
    414 
    415 	    if (c == 'e')
    416 	    {
    417 		if (expr++)
    418 		    return ('e');	/*  will  cause  syntax  error  */
    419 		continue;
    420 	    }
    421 
    422 	    /*  end  of  number  */
    423 	    break;
    424 	}
    425 	*cp = '\0';
    426 
    427 	if ((cp - buf) >= BSZ)
    428 	    printf("constant  too  long:  truncated\n");
    429 	else
    430 	    ungetc(c, stdin);	/*  push  back  last  char  read  */
    431 	yylval.dval = atof(buf);
    432 	return (CONST);
    433     }
    434     return (c);
    435 }
    436 
    437 static INTERVAL
    438 hilo(double a, double b, double c, double d)
    439 {
    440     /*  returns  the  smallest  interval  containing  a,  b,  c,  and  d  */
    441     /*  used  by  *,  /  routines  */
    442     INTERVAL v;
    443 
    444     if (a > b)
    445     {
    446 	v.hi = a;
    447 	v.lo = b;
    448     }
    449     else
    450     {
    451 	v.hi = b;
    452 	v.lo = a;
    453     }
    454 
    455     if (c > d)
    456     {
    457 	if (c > v.hi)
    458 	    v.hi = c;
    459 	if (d < v.lo)
    460 	    v.lo = d;
    461     }
    462     else
    463     {
    464 	if (d > v.hi)
    465 	    v.hi = d;
    466 	if (c < v.lo)
    467 	    v.lo = c;
    468     }
    469     return (v);
    470 }
    471 
    472 INTERVAL
    473 vmul(double a, double b, INTERVAL v)
    474 {
    475     return (hilo(a * v.hi, a * v.lo, b * v.hi, b * v.lo));
    476 }
    477 
    478 int
    479 dcheck(INTERVAL v)
    480 {
    481     if (v.hi >= 0. && v.lo <= 0.)
    482     {
    483 	printf("divisor  interval  contains  0.\n");
    484 	return (1);
    485     }
    486     return (0);
    487 }
    488 
    489 INTERVAL
    490 vdiv(double a, double b, INTERVAL v)
    491 {
    492     return (hilo(a / v.hi, a / v.lo, b / v.hi, b / v.lo));
    493 }
    494 #line 493 "calc1.tab.c"
    495 
    496 #if YYDEBUG
    497 #include <stdio.h>	/* needed for printf */
    498 #endif
    499 
    500 #include <stdlib.h>	/* needed for malloc, etc */
    501 #include <string.h>	/* needed for memset */
    502 
    503 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
    504 static int yygrowstack(YYSTACKDATA *data)
    505 {
    506     int i;
    507     unsigned newsize;
    508     YYINT *newss;
    509     YYSTYPE *newvs;
    510 
    511     if ((newsize = data->stacksize) == 0)
    512         newsize = YYINITSTACKSIZE;
    513     else if (newsize >= YYMAXDEPTH)
    514         return YYENOMEM;
    515     else if ((newsize *= 2) > YYMAXDEPTH)
    516         newsize = YYMAXDEPTH;
    517 
    518     i = (int) (data->s_mark - data->s_base);
    519     newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
    520     if (newss == 0)
    521         return YYENOMEM;
    522 
    523     data->s_base = newss;
    524     data->s_mark = newss + i;
    525 
    526     newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
    527     if (newvs == 0)
    528         return YYENOMEM;
    529 
    530     data->l_base = newvs;
    531     data->l_mark = newvs + i;
    532 
    533     data->stacksize = newsize;
    534     data->s_last = data->s_base + newsize - 1;
    535     return 0;
    536 }
    537 
    538 #if YYPURE || defined(YY_NO_LEAKS)
    539 static void yyfreestack(YYSTACKDATA *data)
    540 {
    541     free(data->s_base);
    542     free(data->l_base);
    543     memset(data, 0, sizeof(*data));
    544 }
    545 #else
    546 #define yyfreestack(data) /* nothing */
    547 #endif
    548 
    549 #define YYABORT  goto yyabort
    550 #define YYREJECT goto yyabort
    551 #define YYACCEPT goto yyaccept
    552 #define YYERROR  goto yyerrlab
    553 
    554 int
    555 YYPARSE_DECL()
    556 {
    557     int yym, yyn, yystate;
    558 #if YYDEBUG
    559     const char *yys;
    560 
    561     if ((yys = getenv("YYDEBUG")) != 0)
    562     {
    563         yyn = *yys;
    564         if (yyn >= '0' && yyn <= '9')
    565             yydebug = yyn - '0';
    566     }
    567 #endif
    568 
    569     /* yym is set below */
    570     /* yyn is set below */
    571     yynerrs = 0;
    572     yyerrflag = 0;
    573     yychar = YYEMPTY;
    574     yystate = 0;
    575 
    576 #if YYPURE
    577     memset(&yystack, 0, sizeof(yystack));
    578 #endif
    579 
    580     if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
    581     yystack.s_mark = yystack.s_base;
    582     yystack.l_mark = yystack.l_base;
    583     yystate = 0;
    584     *yystack.s_mark = 0;
    585 
    586 yyloop:
    587     if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
    588     if (yychar < 0)
    589     {
    590         yychar = YYLEX;
    591         if (yychar < 0) yychar = YYEOF;
    592 #if YYDEBUG
    593         if (yydebug)
    594         {
    595             if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
    596             printf("%sdebug: state %d, reading %d (%s)\n",
    597                     YYPREFIX, yystate, yychar, yys);
    598         }
    599 #endif
    600     }
    601     if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
    602             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
    603     {
    604 #if YYDEBUG
    605         if (yydebug)
    606             printf("%sdebug: state %d, shifting to state %d\n",
    607                     YYPREFIX, yystate, yytable[yyn]);
    608 #endif
    609         if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
    610         yystate = yytable[yyn];
    611         *++yystack.s_mark = yytable[yyn];
    612         *++yystack.l_mark = yylval;
    613         yychar = YYEMPTY;
    614         if (yyerrflag > 0)  --yyerrflag;
    615         goto yyloop;
    616     }
    617     if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
    618             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
    619     {
    620         yyn = yytable[yyn];
    621         goto yyreduce;
    622     }
    623     if (yyerrflag != 0) goto yyinrecovery;
    624 
    625     YYERROR_CALL("syntax error");
    626 
    627     goto yyerrlab; /* redundant goto avoids 'unused label' warning */
    628 yyerrlab:
    629     ++yynerrs;
    630 
    631 yyinrecovery:
    632     if (yyerrflag < 3)
    633     {
    634         yyerrflag = 3;
    635         for (;;)
    636         {
    637             if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
    638                     yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
    639             {
    640 #if YYDEBUG
    641                 if (yydebug)
    642                     printf("%sdebug: state %d, error recovery shifting\
    643  to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
    644 #endif
    645                 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
    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             if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
    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 > 0)
    687         yyval = yystack.l_mark[1-yym];
    688     else
    689         memset(&yyval, 0, sizeof yyval);
    690 
    691     switch (yyn)
    692     {
    693 case 3:
    694 #line 57 "calc1.y"
    695 	{
    696 		(void) printf("%15.8f\n", yystack.l_mark[-1].dval);
    697 	}
    698 #line 697 "calc1.tab.c"
    699 break;
    700 case 4:
    701 #line 61 "calc1.y"
    702 	{
    703 		(void) printf("(%15.8f, %15.8f)\n", yystack.l_mark[-1].vval.lo, yystack.l_mark[-1].vval.hi);
    704 	}
    705 #line 704 "calc1.tab.c"
    706 break;
    707 case 5:
    708 #line 65 "calc1.y"
    709 	{
    710 		dreg[yystack.l_mark[-3].ival] = yystack.l_mark[-1].dval;
    711 	}
    712 #line 711 "calc1.tab.c"
    713 break;
    714 case 6:
    715 #line 69 "calc1.y"
    716 	{
    717 		vreg[yystack.l_mark[-3].ival] = yystack.l_mark[-1].vval;
    718 	}
    719 #line 718 "calc1.tab.c"
    720 break;
    721 case 7:
    722 #line 73 "calc1.y"
    723 	{
    724 		yyerrok;
    725 	}
    726 #line 725 "calc1.tab.c"
    727 break;
    728 case 9:
    729 #line 80 "calc1.y"
    730 	{
    731 		yyval.dval = dreg[yystack.l_mark[0].ival];
    732 	}
    733 #line 732 "calc1.tab.c"
    734 break;
    735 case 10:
    736 #line 84 "calc1.y"
    737 	{
    738 		yyval.dval = yystack.l_mark[-2].dval + yystack.l_mark[0].dval;
    739 	}
    740 #line 739 "calc1.tab.c"
    741 break;
    742 case 11:
    743 #line 88 "calc1.y"
    744 	{
    745 		yyval.dval = yystack.l_mark[-2].dval - yystack.l_mark[0].dval;
    746 	}
    747 #line 746 "calc1.tab.c"
    748 break;
    749 case 12:
    750 #line 92 "calc1.y"
    751 	{
    752 		yyval.dval = yystack.l_mark[-2].dval * yystack.l_mark[0].dval;
    753 	}
    754 #line 753 "calc1.tab.c"
    755 break;
    756 case 13:
    757 #line 96 "calc1.y"
    758 	{
    759 		yyval.dval = yystack.l_mark[-2].dval / yystack.l_mark[0].dval;
    760 	}
    761 #line 760 "calc1.tab.c"
    762 break;
    763 case 14:
    764 #line 100 "calc1.y"
    765 	{
    766 		yyval.dval = -yystack.l_mark[0].dval;
    767 	}
    768 #line 767 "calc1.tab.c"
    769 break;
    770 case 15:
    771 #line 104 "calc1.y"
    772 	{
    773 		yyval.dval = yystack.l_mark[-1].dval;
    774 	}
    775 #line 774 "calc1.tab.c"
    776 break;
    777 case 16:
    778 #line 110 "calc1.y"
    779 	{
    780 		yyval.vval.hi = yyval.vval.lo = yystack.l_mark[0].dval;
    781 	}
    782 #line 781 "calc1.tab.c"
    783 break;
    784 case 17:
    785 #line 114 "calc1.y"
    786 	{
    787 		yyval.vval.lo = yystack.l_mark[-3].dval;
    788 		yyval.vval.hi = yystack.l_mark[-1].dval;
    789 		if ( yyval.vval.lo > yyval.vval.hi )
    790 		{
    791 			(void) printf("interval out of order\n");
    792 			YYERROR;
    793 		}
    794 	}
    795 #line 794 "calc1.tab.c"
    796 break;
    797 case 18:
    798 #line 124 "calc1.y"
    799 	{
    800 		yyval.vval = vreg[yystack.l_mark[0].ival];
    801 	}
    802 #line 801 "calc1.tab.c"
    803 break;
    804 case 19:
    805 #line 128 "calc1.y"
    806 	{
    807 		yyval.vval.hi = yystack.l_mark[-2].vval.hi + yystack.l_mark[0].vval.hi;
    808 		yyval.vval.lo = yystack.l_mark[-2].vval.lo + yystack.l_mark[0].vval.lo;
    809 	}
    810 #line 809 "calc1.tab.c"
    811 break;
    812 case 20:
    813 #line 133 "calc1.y"
    814 	{
    815 		yyval.vval.hi = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.hi;
    816 		yyval.vval.lo = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.lo;
    817 	}
    818 #line 817 "calc1.tab.c"
    819 break;
    820 case 21:
    821 #line 138 "calc1.y"
    822 	{
    823 		yyval.vval.hi = yystack.l_mark[-2].vval.hi - yystack.l_mark[0].vval.lo;
    824 		yyval.vval.lo = yystack.l_mark[-2].vval.lo - yystack.l_mark[0].vval.hi;
    825 	}
    826 #line 825 "calc1.tab.c"
    827 break;
    828 case 22:
    829 #line 143 "calc1.y"
    830 	{
    831 		yyval.vval.hi = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.lo;
    832 		yyval.vval.lo = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.hi;
    833 	}
    834 #line 833 "calc1.tab.c"
    835 break;
    836 case 23:
    837 #line 148 "calc1.y"
    838 	{
    839 		yyval.vval = vmul( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval );
    840 	}
    841 #line 840 "calc1.tab.c"
    842 break;
    843 case 24:
    844 #line 152 "calc1.y"
    845 	{
    846 		yyval.vval = vmul (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval );
    847 	}
    848 #line 847 "calc1.tab.c"
    849 break;
    850 case 25:
    851 #line 156 "calc1.y"
    852 	{
    853 		if (dcheck(yystack.l_mark[0].vval)) YYERROR;
    854 		yyval.vval = vdiv ( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval );
    855 	}
    856 #line 855 "calc1.tab.c"
    857 break;
    858 case 26:
    859 #line 161 "calc1.y"
    860 	{
    861 		if (dcheck ( yystack.l_mark[0].vval )) YYERROR;
    862 		yyval.vval = vdiv (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval );
    863 	}
    864 #line 863 "calc1.tab.c"
    865 break;
    866 case 27:
    867 #line 166 "calc1.y"
    868 	{
    869 		yyval.vval.hi = -yystack.l_mark[0].vval.lo;
    870 		yyval.vval.lo = -yystack.l_mark[0].vval.hi;
    871 	}
    872 #line 871 "calc1.tab.c"
    873 break;
    874 case 28:
    875 #line 171 "calc1.y"
    876 	{
    877 		yyval.vval = yystack.l_mark[-1].vval;
    878 	}
    879 #line 878 "calc1.tab.c"
    880 break;
    881 #line 880 "calc1.tab.c"
    882     }
    883     yystack.s_mark -= yym;
    884     yystate = *yystack.s_mark;
    885     yystack.l_mark -= yym;
    886     yym = yylhs[yyn];
    887     if (yystate == 0 && yym == 0)
    888     {
    889 #if YYDEBUG
    890         if (yydebug)
    891             printf("%sdebug: after reduction, shifting from state 0 to\
    892  state %d\n", YYPREFIX, YYFINAL);
    893 #endif
    894         yystate = YYFINAL;
    895         *++yystack.s_mark = YYFINAL;
    896         *++yystack.l_mark = yyval;
    897         if (yychar < 0)
    898         {
    899             yychar = YYLEX;
    900             if (yychar < 0) yychar = YYEOF;
    901 #if YYDEBUG
    902             if (yydebug)
    903             {
    904                 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
    905                 printf("%sdebug: state %d, reading %d (%s)\n",
    906                         YYPREFIX, YYFINAL, yychar, yys);
    907             }
    908 #endif
    909         }
    910         if (yychar == YYEOF) goto yyaccept;
    911         goto yyloop;
    912     }
    913     if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
    914             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
    915         yystate = yytable[yyn];
    916     else
    917         yystate = yydgoto[yym];
    918 #if YYDEBUG
    919     if (yydebug)
    920         printf("%sdebug: after reduction, shifting from state %d \
    921 to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
    922 #endif
    923     if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
    924     *++yystack.s_mark = (YYINT) yystate;
    925     *++yystack.l_mark = yyval;
    926     goto yyloop;
    927 
    928 yyoverflow:
    929     YYERROR_CALL("yacc stack overflow");
    930 
    931 yyabort:
    932     yyfreestack(&yystack);
    933     return (1);
    934 
    935 yyaccept:
    936     yyfreestack(&yystack);
    937     return (0);
    938 }
    939