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