Home | History | Annotate | Line # | Download | only in yacc
calc1.tab.c revision 1.2.12.1 
      1 /*	$NetBSD: calc1.tab.c,v 1.2.12.1 2019/06/10 21:44:42 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 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 #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 = 0;
    570     yyn = 0;
    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 break;
    699 case 4:
    700 #line 61 "calc1.y"
    701 	{
    702 		(void) printf("(%15.8f, %15.8f)\n", yystack.l_mark[-1].vval.lo, yystack.l_mark[-1].vval.hi);
    703 	}
    704 break;
    705 case 5:
    706 #line 65 "calc1.y"
    707 	{
    708 		dreg[yystack.l_mark[-3].ival] = yystack.l_mark[-1].dval;
    709 	}
    710 break;
    711 case 6:
    712 #line 69 "calc1.y"
    713 	{
    714 		vreg[yystack.l_mark[-3].ival] = yystack.l_mark[-1].vval;
    715 	}
    716 break;
    717 case 7:
    718 #line 73 "calc1.y"
    719 	{
    720 		yyerrok;
    721 	}
    722 break;
    723 case 9:
    724 #line 80 "calc1.y"
    725 	{
    726 		yyval.dval = dreg[yystack.l_mark[0].ival];
    727 	}
    728 break;
    729 case 10:
    730 #line 84 "calc1.y"
    731 	{
    732 		yyval.dval = yystack.l_mark[-2].dval + yystack.l_mark[0].dval;
    733 	}
    734 break;
    735 case 11:
    736 #line 88 "calc1.y"
    737 	{
    738 		yyval.dval = yystack.l_mark[-2].dval - yystack.l_mark[0].dval;
    739 	}
    740 break;
    741 case 12:
    742 #line 92 "calc1.y"
    743 	{
    744 		yyval.dval = yystack.l_mark[-2].dval * yystack.l_mark[0].dval;
    745 	}
    746 break;
    747 case 13:
    748 #line 96 "calc1.y"
    749 	{
    750 		yyval.dval = yystack.l_mark[-2].dval / yystack.l_mark[0].dval;
    751 	}
    752 break;
    753 case 14:
    754 #line 100 "calc1.y"
    755 	{
    756 		yyval.dval = -yystack.l_mark[0].dval;
    757 	}
    758 break;
    759 case 15:
    760 #line 104 "calc1.y"
    761 	{
    762 		yyval.dval = yystack.l_mark[-1].dval;
    763 	}
    764 break;
    765 case 16:
    766 #line 110 "calc1.y"
    767 	{
    768 		yyval.vval.hi = yyval.vval.lo = yystack.l_mark[0].dval;
    769 	}
    770 break;
    771 case 17:
    772 #line 114 "calc1.y"
    773 	{
    774 		yyval.vval.lo = yystack.l_mark[-3].dval;
    775 		yyval.vval.hi = yystack.l_mark[-1].dval;
    776 		if ( yyval.vval.lo > yyval.vval.hi )
    777 		{
    778 			(void) printf("interval out of order\n");
    779 			YYERROR;
    780 		}
    781 	}
    782 break;
    783 case 18:
    784 #line 124 "calc1.y"
    785 	{
    786 		yyval.vval = vreg[yystack.l_mark[0].ival];
    787 	}
    788 break;
    789 case 19:
    790 #line 128 "calc1.y"
    791 	{
    792 		yyval.vval.hi = yystack.l_mark[-2].vval.hi + yystack.l_mark[0].vval.hi;
    793 		yyval.vval.lo = yystack.l_mark[-2].vval.lo + yystack.l_mark[0].vval.lo;
    794 	}
    795 break;
    796 case 20:
    797 #line 133 "calc1.y"
    798 	{
    799 		yyval.vval.hi = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.hi;
    800 		yyval.vval.lo = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.lo;
    801 	}
    802 break;
    803 case 21:
    804 #line 138 "calc1.y"
    805 	{
    806 		yyval.vval.hi = yystack.l_mark[-2].vval.hi - yystack.l_mark[0].vval.lo;
    807 		yyval.vval.lo = yystack.l_mark[-2].vval.lo - yystack.l_mark[0].vval.hi;
    808 	}
    809 break;
    810 case 22:
    811 #line 143 "calc1.y"
    812 	{
    813 		yyval.vval.hi = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.lo;
    814 		yyval.vval.lo = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.hi;
    815 	}
    816 break;
    817 case 23:
    818 #line 148 "calc1.y"
    819 	{
    820 		yyval.vval = vmul( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval );
    821 	}
    822 break;
    823 case 24:
    824 #line 152 "calc1.y"
    825 	{
    826 		yyval.vval = vmul (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval );
    827 	}
    828 break;
    829 case 25:
    830 #line 156 "calc1.y"
    831 	{
    832 		if (dcheck(yystack.l_mark[0].vval)) YYERROR;
    833 		yyval.vval = vdiv ( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval );
    834 	}
    835 break;
    836 case 26:
    837 #line 161 "calc1.y"
    838 	{
    839 		if (dcheck ( yystack.l_mark[0].vval )) YYERROR;
    840 		yyval.vval = vdiv (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval );
    841 	}
    842 break;
    843 case 27:
    844 #line 166 "calc1.y"
    845 	{
    846 		yyval.vval.hi = -yystack.l_mark[0].vval.lo;
    847 		yyval.vval.lo = -yystack.l_mark[0].vval.hi;
    848 	}
    849 break;
    850 case 28:
    851 #line 171 "calc1.y"
    852 	{
    853 		yyval.vval = yystack.l_mark[-1].vval;
    854 	}
    855 break;
    856 #line 855 "calc1.tab.c"
    857     }
    858     yystack.s_mark -= yym;
    859     yystate = *yystack.s_mark;
    860     yystack.l_mark -= yym;
    861     yym = yylhs[yyn];
    862     if (yystate == 0 && yym == 0)
    863     {
    864 #if YYDEBUG
    865         if (yydebug)
    866             printf("%sdebug: after reduction, shifting from state 0 to\
    867  state %d\n", YYPREFIX, YYFINAL);
    868 #endif
    869         yystate = YYFINAL;
    870         *++yystack.s_mark = YYFINAL;
    871         *++yystack.l_mark = yyval;
    872         if (yychar < 0)
    873         {
    874             yychar = YYLEX;
    875             if (yychar < 0) yychar = YYEOF;
    876 #if YYDEBUG
    877             if (yydebug)
    878             {
    879                 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
    880                 printf("%sdebug: state %d, reading %d (%s)\n",
    881                         YYPREFIX, YYFINAL, yychar, yys);
    882             }
    883 #endif
    884         }
    885         if (yychar == YYEOF) goto yyaccept;
    886         goto yyloop;
    887     }
    888     if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
    889             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
    890         yystate = yytable[yyn];
    891     else
    892         yystate = yydgoto[yym];
    893 #if YYDEBUG
    894     if (yydebug)
    895         printf("%sdebug: after reduction, shifting from state %d \
    896 to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
    897 #endif
    898     if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
    899     *++yystack.s_mark = (YYINT) yystate;
    900     *++yystack.l_mark = yyval;
    901     goto yyloop;
    902 
    903 yyoverflow:
    904     YYERROR_CALL("yacc stack overflow");
    905 
    906 yyabort:
    907     yyfreestack(&yystack);
    908     return (1);
    909 
    910 yyaccept:
    911     yyfreestack(&yystack);
    912     return (0);
    913 }
    914