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