test/btyacc/btyacc_calc1.tab.c

   1 /* original parser id follows */
   2 /* yysccsid[] = "@(#)yaccpar    1.9 (Berkeley) 02/21/93" */
   3 /* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
   4
   5 #define YYBYACC 1
   6 #define YYMAJOR 1
   7 #define YYMINOR 9
   8 #define YYCHECK "yyyymmdd"
   9
  10 #define YYEMPTY        (-1)
  11 #define yyclearin      (yychar = YYEMPTY)
  12 #define yyerrok        (yyerrflag = 0)
  13 #define YYRECOVERING() (yyerrflag != 0)
  14 #define YYENOMEM       (-2)
  15 #define YYEOF          0
  16 #undef YYBTYACC
  17 #define YYBTYACC 1
  18 #define YYDEBUGSTR (yytrial ? YYPREFIX "debug(trial)" : YYPREFIX "debug")
  19
  20 #ifndef yyparse
  21 #define yyparse    calc1_parse
  22 #endif /* yyparse */
  23
  24 #ifndef yylex
  25 #define yylex      calc1_lex
  26 #endif /* yylex */
  27
  28 #ifndef yyerror
  29 #define yyerror    calc1_error
  30 #endif /* yyerror */
  31
  32 #ifndef yychar
  33 #define yychar     calc1_char
  34 #endif /* yychar */
  35
  36 #ifndef yyval
  37 #define yyval      calc1_val
  38 #endif /* yyval */
  39
  40 #ifndef yylval
  41 #define yylval     calc1_lval
  42 #endif /* yylval */
  43
  44 #ifndef yydebug
  45 #define yydebug    calc1_debug
  46 #endif /* yydebug */
  47
  48 #ifndef yynerrs
  49 #define yynerrs    calc1_nerrs
  50 #endif /* yynerrs */
  51
  52 #ifndef yyerrflag
  53 #define yyerrflag  calc1_errflag
  54 #endif /* yyerrflag */
  55
  56 #ifndef yylhs
  57 #define yylhs      calc1_lhs
  58 #endif /* yylhs */
  59
  60 #ifndef yylen
  61 #define yylen      calc1_len
  62 #endif /* yylen */
  63
  64 #ifndef yydefred
  65 #define yydefred   calc1_defred
  66 #endif /* yydefred */
  67
  68 #ifndef yystos
  69 #define yystos     calc1_stos
  70 #endif /* yystos */
  71
  72 #ifndef yydgoto
  73 #define yydgoto    calc1_dgoto
  74 #endif /* yydgoto */
  75
  76 #ifndef yysindex
  77 #define yysindex   calc1_sindex
  78 #endif /* yysindex */
  79
  80 #ifndef yyrindex
  81 #define yyrindex   calc1_rindex
  82 #endif /* yyrindex */
  83
  84 #ifndef yygindex
  85 #define yygindex   calc1_gindex
  86 #endif /* yygindex */
  87
  88 #ifndef yytable
  89 #define yytable    calc1_table
  90 #endif /* yytable */
  91
  92 #ifndef yycheck
  93 #define yycheck    calc1_check
  94 #endif /* yycheck */
  95
  96 #ifndef yyname
  97 #define yyname     calc1_name
  98 #endif /* yyname */
  99
 100 #ifndef yyrule
 101 #define yyrule     calc1_rule
 102 #endif /* yyrule */
 103
 104 #if YYBTYACC
 105
 106 #ifndef yycindex
 107 #define yycindex   calc1_cindex
 108 #endif /* yycindex */
 109
 110 #ifndef yyctable
 111 #define yyctable   calc1_ctable
 112 #endif /* yyctable */
 113
 114 #endif /* YYBTYACC */
 115
 116 #define YYPREFIX "calc1_"
 117
 118 #define YYPURE 1
 119
 120 #line 3 "btyacc_calc1.y"
 121
 122 /* http://dinosaur.compilertools.net/yacc/index.html */
 123
 124 #include <stdlib.h>
 125 #include <stdio.h>
 126 #include <ctype.h>
 127 #include <math.h>
 128
 129 typedef struct interval
 130 {
 131     double lo, hi;
 132 }
 133 INTERVAL;
 134
 135 INTERVAL vmul(double, double, INTERVAL);
 136 INTERVAL vdiv(double, double, INTERVAL);
 137
 138 int dcheck(INTERVAL);
 139
 140 double dreg[26];
 141 INTERVAL vreg[26];
 142
 143 #ifdef YYSTYPE
 144 #undef  YYSTYPE_IS_DECLARED
 145 #define YYSTYPE_IS_DECLARED 1
 146 #endif
 147 #ifndef YYSTYPE_IS_DECLARED
 148 #define YYSTYPE_IS_DECLARED 1
 149 #line 29 "btyacc_calc1.y"
 150 typedef union
 151 {
 152         int ival;
 153         double dval;
 154         INTERVAL vval;
 155 } YYSTYPE;
 156 #endif /* !YYSTYPE_IS_DECLARED */
 157 #line 158 "btyacc_calc1.tab.c"
 158
 159 /* compatibility with bison */
 160 #ifdef YYPARSE_PARAM
 161 /* compatibility with FreeBSD */
 162 # ifdef YYPARSE_PARAM_TYPE
 163 #  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
 164 # else
 165 #  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
 166 # endif
 167 #else
 168 # define YYPARSE_DECL() yyparse(void)
 169 #endif
 170
 171 /* Parameters sent to lex. */
 172 #ifdef YYLEX_PARAM
 173 # ifdef YYLEX_PARAM_TYPE
 174 #  define YYLEX_DECL() yylex(YYSTYPE *yylval, YYLEX_PARAM_TYPE YYLEX_PARAM)
 175 # else
 176 #  define YYLEX_DECL() yylex(YYSTYPE *yylval, void * YYLEX_PARAM)
 177 # endif
 178 # define YYLEX yylex(&yylval, YYLEX_PARAM)
 179 #else
 180 # define YYLEX_DECL() yylex(YYSTYPE *yylval)
 181 # define YYLEX yylex(&yylval)
 182 #endif
 183
 184 /* Parameters sent to yyerror. */
 185 #ifndef YYERROR_DECL
 186 #define YYERROR_DECL() yyerror(const char *s)
 187 #endif
 188 #ifndef YYERROR_CALL
 189 #define YYERROR_CALL(msg) yyerror(msg)
 190 #endif
 191
 192 extern int YYPARSE_DECL();
 193
 194 #define DREG 257
 195 #define VREG 258
 196 #define CONST 259
 197 #define UMINUS 260
 198 #define YYERRCODE 256
 199 typedef short YYINT;
 200 static const YYINT calc1_lhs[] = {                       -1,
 201     0,    0,    0,    3,    3,    3,    3,    1,    1,    1,
 202     1,    1,    1,    1,    1,    2,    2,    2,    2,    2,
 203     2,    2,    2,    2,    2,    2,    2,    2,
 204 };
 205 static const YYINT calc1_len[] = {                        2,
 206     0,    3,    3,    1,    1,    3,    3,    1,    1,    3,
 207     3,    3,    3,    2,    3,    1,    5,    1,    3,    3,
 208     3,    3,    3,    3,    3,    3,    2,    3,
 209 };
 210 static const YYINT calc1_defred[] = {                     1,
 211     0,    0,    0,    0,    8,    0,    0,    0,    0,    0,
 212     3,    0,    0,    9,   18,    0,   27,    0,    0,    0,
 213     0,    0,    0,    0,    0,    0,    0,    2,    0,    0,
 214     0,    0,    0,   15,    0,   28,    0,    0,    0,    0,
 215     0,   24,    0,   26,    0,    0,   23,   25,   14,    0,
 216     0,    0,    0,    0,    0,    0,    0,   12,   13,   17,
 217 };
 218 #if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING)
 219 static const YYINT calc1_stos[] = {                       0,
 220   262,  256,  257,  258,  259,   45,   40,  263,  264,  265,
 221    10,   61,   61,  257,  258,  263,  264,  263,  264,   43,
 222    45,   42,   47,   43,   45,   42,   47,   10,   45,   40,
 223   263,  263,  264,   41,   44,   41,  263,  264,  263,  264,
 224   263,  264,  263,  264,  264,  264,  264,  264,  263,  263,
 225    43,   45,   42,   47,  263,  263,  263,  263,  263,   41,
 226 };
 227 #endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */
 228 static const YYINT calc1_dgoto[] = {                      1,
 229    32,    9,   10,
 230 };
 231 static const YYINT calc1_sindex[] = {                     0,
 232   -40,   -9,  -59,  -54,    0,  -37,  -37,    0,   82,    4,
 233     0,  -34,  -37,    0,    0,    0,    0,  -31,  -25,  -37,
 234   -37,  -37,  -37,  -37,  -37,  -37,  -37,    0,  -34,  -34,
 235   132,    0,   82,    0,  -34,    0,    0,  -12,    0,  -12,
 236     0,    0,    0,    0,  -12,  -12,    0,    0,    0,  112,
 237   -34,  -34,  -34,  -34,  119,  -11,  -11,    0,    0,    0,
 238 };
 239 static const YYINT calc1_rindex[] = {                     0,
 240     0,    0,   51,   58,    0,    0,    0,    0,   11,    0,
 241     0,    0,    0,    0,    0,  -16,    0,    0,    0,    0,
 242     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 243    19,    9,   27,    0,    0,    0,   -5,   41,   -4,   77,
 244    -2,    0,    8,    0,   78,   85,    0,    0,    0,    0,
 245     0,    0,    0,    0,    0,   92,   99,    0,    0,    0,
 246 };
 247 #if YYBTYACC
 248 static const YYINT calc1_cindex[] = {                     0,
 249     0,    0,    0,    0,    0,    0,    0,   65,    0,    0,
 250     0,    0,    0,    0,    0,    2,    0,  126,    0,    0,
 251     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 252     0,  138,    0,    0,    0,    0,   17,    0,   24,    0,
 253    31,    0,   38,    0,    0,    0,    0,    0,    0,    0,
 254     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 255 };
 256 #endif
 257 static const YYINT calc1_gindex[] = {                     0,
 258     3,  125,    0,
 259 };
 260 #define YYTABLESIZE 225
 261 static const YYINT calc1_table[] = {                      7,
 262    11,   12,    7,    8,    6,   30,   13,    6,   16,   18,
 263    29,   14,   35,   28,   31,   36,   26,   24,   16,   25,
 264     5,   27,   37,   39,   41,   43,   20,   14,    6,   26,
 265    53,   49,   50,   23,   27,   54,    7,   55,   10,   11,
 266    26,   12,   14,   14,   14,    0,   14,   29,   14,   16,
 267    20,   13,    0,   56,   57,   58,   59,   20,    6,   20,
 268     9,   20,    0,    9,   23,    6,   23,   18,   23,    0,
 269     9,   26,   26,   26,   11,   26,    0,   26,   29,   29,
 270    29,   20,   29,   20,   29,   20,   22,   19,    0,    0,
 271     0,    0,    9,    9,   21,    9,    0,    9,    0,   18,
 272    18,   10,   18,    0,   18,    0,    6,    0,   11,    3,
 273     0,    9,    0,    0,    0,    0,    0,   22,   19,   22,
 274    19,   22,   19,   26,   24,   21,   25,   21,   27,   21,
 275    17,   19,   10,    0,   10,    0,   10,   33,    0,   11,
 276     0,   11,    0,   11,   38,   40,   42,   44,   45,   46,
 277    47,   48,   34,   53,   51,    0,   52,    0,   54,   60,
 278    53,   51,    0,   52,    0,   54,   18,    6,    0,    0,
 279     3,    0,    9,   53,   51,    0,   52,    0,   54,    6,
 280     0,    0,    3,    0,    9,    0,    0,    0,    0,    0,
 281     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 282     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 283     0,    0,    0,    0,    0,    2,    3,    4,    5,   14,
 284    15,    5,   14,    0,    5,
 285 };
 286 static const YYINT calc1_check[] = {                     40,
 287    10,   61,   40,    1,   45,   40,   61,   45,    6,    7,
 288    45,   10,   44,   10,   12,   41,   42,   43,   10,   45,
 289    10,   47,   20,   21,   22,   23,   10,   44,   10,   42,
 290    42,   29,   30,   10,   47,   47,   10,   35,   44,   44,
 291    10,   44,   41,   42,   43,   -1,   45,   10,   47,   41,
 292    10,   44,   -1,   51,   52,   53,   54,   41,   42,   43,
 293    10,   45,   -1,   47,   41,   42,   43,   10,   45,   -1,
 294    47,   41,   42,   43,   10,   45,   -1,   47,   41,   42,
 295    43,   41,   45,   43,   47,   45,   10,   10,   -1,   -1,
 296    -1,   -1,   42,   43,   10,   45,   -1,   47,   -1,   42,
 297    43,   10,   45,   -1,   47,   -1,   42,   43,   10,   45,
 298    -1,   47,   -1,   -1,   -1,   -1,   -1,   41,   41,   43,
 299    43,   45,   45,   42,   43,   41,   45,   43,   47,   45,
 300     6,    7,   41,   -1,   43,   -1,   45,   13,   -1,   41,
 301    -1,   43,   -1,   45,   20,   21,   22,   23,   24,   25,
 302    26,   27,   41,   42,   43,   -1,   45,   -1,   47,   41,
 303    42,   43,   -1,   45,   -1,   47,   41,   42,   43,   -1,
 304    45,   -1,   47,   42,   43,   -1,   45,   -1,   47,   42,
 305    43,   -1,   45,   -1,   47,   -1,   -1,   -1,   -1,   -1,
 306    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 307    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 308    -1,   -1,   -1,   -1,   -1,  256,  257,  258,  259,  257,
 309   258,  259,  257,   -1,  259,
 310 };
 311 #if YYBTYACC
 312 static const YYINT calc1_ctable[] = {                    20,
 313    16,   -1,   21,   16,   -1,   22,   16,   -1,   23,   16,
 314    -1,    4,   16,   -1,   14,   16,   -1,   34,   16,   -1,
 315    10,   16,   -1,   11,   16,   -1,   12,   16,   -1,   13,
 316    16,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 317    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 318    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 319    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 320    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 321    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 322    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 323    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 324    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 325    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 326    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 327    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 328    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 329    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 330    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 331    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 332    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 333    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 334    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 335    -1,   -1,   -1,   -1,
 336 };
 337 #endif
 338 #define YYFINAL 1
 339 #ifndef YYDEBUG
 340 #define YYDEBUG 0
 341 #endif
 342 #define YYMAXTOKEN 260
 343 #define YYUNDFTOKEN 266
 344 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
 345 #if YYDEBUG
 346 static const char *const calc1_name[] = {
 347
 348 "$end",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,0,0,0,
 349 0,0,0,0,0,0,"'('","')'","'*'","'+'","','","'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,0,0,
 350 0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 351 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 352 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 353 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 354 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 355 "error","DREG","VREG","CONST","UMINUS","$accept","lines","dexp","vexp","line",
 356 "illegal-symbol",
 357 };
 358 static const char *const calc1_rule[] = {
 359 "$accept : lines",
 360 "lines :",
 361 "lines : lines line '\\n'",
 362 "lines : lines error '\\n'",
 363 "line : dexp",
 364 "line : vexp",
 365 "line : DREG '=' dexp",
 366 "line : VREG '=' vexp",
 367 "dexp : CONST",
 368 "dexp : DREG",
 369 "dexp : dexp '+' dexp",
 370 "dexp : dexp '-' dexp",
 371 "dexp : dexp '*' dexp",
 372 "dexp : dexp '/' dexp",
 373 "dexp : '-' dexp",
 374 "dexp : '(' dexp ')'",
 375 "vexp : dexp",
 376 "vexp : '(' dexp ',' dexp ')'",
 377 "vexp : VREG",
 378 "vexp : vexp '+' vexp",
 379 "vexp : dexp '+' vexp",
 380 "vexp : vexp '-' vexp",
 381 "vexp : dexp '-' vexp",
 382 "vexp : vexp '*' vexp",
 383 "vexp : dexp '*' vexp",
 384 "vexp : vexp '/' vexp",
 385 "vexp : dexp '/' vexp",
 386 "vexp : '-' vexp",
 387 "vexp : '(' vexp ')'",
 388
 389 };
 390 #endif
 391
 392 int      yydebug;
 393 int      yynerrs;
 394
 395 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 396 #ifndef YYLLOC_DEFAULT
 397 #define YYLLOC_DEFAULT(loc, rhs, n) \
 398 do \
 399 { \
 400     if (n == 0) \
 401     { \
 402         (loc).first_line   = ((rhs)[-1]).last_line; \
 403         (loc).first_column = ((rhs)[-1]).last_column; \
 404         (loc).last_line    = ((rhs)[-1]).last_line; \
 405         (loc).last_column  = ((rhs)[-1]).last_column; \
 406     } \
 407     else \
 408     { \
 409         (loc).first_line   = ((rhs)[ 0 ]).first_line; \
 410         (loc).first_column = ((rhs)[ 0 ]).first_column; \
 411         (loc).last_line    = ((rhs)[n-1]).last_line; \
 412         (loc).last_column  = ((rhs)[n-1]).last_column; \
 413     } \
 414 } while (0)
 415 #endif /* YYLLOC_DEFAULT */
 416 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
 417 #if YYBTYACC
 418
 419 #ifndef YYLVQUEUEGROWTH
 420 #define YYLVQUEUEGROWTH 32
 421 #endif
 422 #endif /* YYBTYACC */
 423
 424 /* define the initial stack-sizes */
 425 #ifdef YYSTACKSIZE
 426 #undef YYMAXDEPTH
 427 #define YYMAXDEPTH  YYSTACKSIZE
 428 #else
 429 #ifdef YYMAXDEPTH
 430 #define YYSTACKSIZE YYMAXDEPTH
 431 #else
 432 #define YYSTACKSIZE 10000
 433 #define YYMAXDEPTH  10000
 434 #endif
 435 #endif
 436
 437 #ifndef YYINITSTACKSIZE
 438 #define YYINITSTACKSIZE 200
 439 #endif
 440
 441 typedef struct {
 442     unsigned stacksize;
 443     YYINT    *s_base;
 444     YYINT    *s_mark;
 445     YYINT    *s_last;
 446     YYSTYPE  *l_base;
 447     YYSTYPE  *l_mark;
 448 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 449     YYLTYPE  *p_base;
 450     YYLTYPE  *p_mark;
 451 #endif
 452 } YYSTACKDATA;
 453 #if YYBTYACC
 454
 455 struct YYParseState_s
 456 {
 457     struct YYParseState_s *save;    /* Previously saved parser state */
 458     YYSTACKDATA            yystack; /* saved parser stack */
 459     int                    state;   /* saved parser state */
 460     int                    errflag; /* saved error recovery status */
 461     int                    lexeme;  /* saved index of the conflict lexeme in the lexical queue */
 462     YYINT                  ctry;    /* saved index in yyctable[] for this conflict */
 463 };
 464 typedef struct YYParseState_s YYParseState;
 465 #endif /* YYBTYACC */
 466 #line 174 "btyacc_calc1.y"
 467         /* beginning of subroutines section */
 468
 469 int
 470 main (void)
 471 {
 472     while(!feof(stdin)) {
 473         yyparse();
 474     }
 475     return 0;
 476 }
 477
 478 #define BSZ 50                  /* buffer size for floating point numbers */
 479
 480 static void
 481 YYERROR_DECL()
 482 {
 483     fprintf(stderr, "%s\n", s);
 484 }
 485
 486         /* lexical analysis */
 487
 488 static int
 489 YYLEX_DECL()
 490 {
 491     int c;
 492
 493     while ((c = getchar()) == ' ')
 494     {                           /* skip over blanks */
 495     }
 496
 497     if (isupper(c))
 498     {
 499 #if YYPURE
 500         (*yylval).ival = c - 'A';
 501 #else
 502         yylval.ival = c - 'A';
 503 #endif
 504         return (VREG);
 505     }
 506     if (islower(c))
 507     {
 508 #if YYPURE
 509         (*yylval).ival = c - 'a';
 510 #else
 511         yylval.ival = c - 'a';
 512 #endif
 513         return (DREG);
 514     }
 515
 516     if (isdigit(c) || c == '.')
 517     {
 518         /* gobble up digits, points, exponents */
 519         char buf[BSZ + 1], *cp = buf;
 520         int dot = 0, expr = 0;
 521
 522         for (; (cp - buf) < BSZ; ++cp, c = getchar())
 523         {
 524
 525             *cp = (char) c;
 526             if (isdigit(c))
 527                 continue;
 528             if (c == '.')
 529             {
 530                 if (dot++ || expr)
 531                     return ('.');       /* will cause syntax error */
 532                 continue;
 533             }
 534
 535             if (c == 'e')
 536             {
 537                 if (expr++)
 538                     return ('e');       /*  will  cause  syntax  error  */
 539                 continue;
 540             }
 541
 542             /*  end  of  number  */
 543             break;
 544         }
 545         *cp = '\0';
 546
 547         if ((cp - buf) >= BSZ)
 548             printf("constant  too  long:  truncated\n");
 549         else
 550             ungetc(c, stdin);   /*  push  back  last  char  read  */
 551 #if YYPURE
 552         (*yylval).dval = atof(buf);
 553 #else
 554         yylval.dval = atof(buf);
 555 #endif
 556         return (CONST);
 557     }
 558     return (c);
 559 }
 560
 561 static INTERVAL
 562 hilo(double a, double b, double c, double d)
 563 {
 564     /*  returns  the  smallest  interval  containing  a,  b,  c,  and  d  */
 565     /*  used  by  *,  /  routines  */
 566     INTERVAL v;
 567
 568     if (a > b)
 569     {
 570         v.hi = a;
 571         v.lo = b;
 572     }
 573     else
 574     {
 575         v.hi = b;
 576         v.lo = a;
 577     }
 578
 579     if (c > d)
 580     {
 581         if (c > v.hi)
 582             v.hi = c;
 583         if (d < v.lo)
 584             v.lo = d;
 585     }
 586     else
 587     {
 588         if (d > v.hi)
 589             v.hi = d;
 590         if (c < v.lo)
 591             v.lo = c;
 592     }
 593     return (v);
 594 }
 595
 596 INTERVAL
 597 vmul(double a, double b, INTERVAL v)
 598 {
 599     return (hilo(a * v.hi, a * v.lo, b * v.hi, b * v.lo));
 600 }
 601
 602 int
 603 dcheck(INTERVAL v)
 604 {
 605     if (v.hi >= 0. && v.lo <= 0.)
 606     {
 607         printf("divisor  interval  contains  0.\n");
 608         return (1);
 609     }
 610     return (0);
 611 }
 612
 613 INTERVAL
 614 vdiv(double a, double b, INTERVAL v)
 615 {
 616     return (hilo(a / v.hi, a / v.lo, b / v.hi, b / v.lo));
 617 }
 618 #line 619 "btyacc_calc1.tab.c"
 619
 620 /* For use in generated program */
 621 #define yydepth (int)(yystack.s_mark - yystack.s_base)
 622 #if YYBTYACC
 623 #define yytrial (yyps->save)
 624 #endif /* YYBTYACC */
 625
 626 #if YYDEBUG
 627 #include <stdio.h>      /* needed for printf */
 628 #endif
 629
 630 #include <stdlib.h>     /* needed for malloc, etc */
 631 #include <string.h>     /* needed for memset */
 632
 633 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
 634 static int yygrowstack(YYSTACKDATA *data)
 635 {
 636     int i;
 637     unsigned newsize;
 638     YYINT *newss;
 639     YYSTYPE *newvs;
 640 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 641     YYLTYPE *newps;
 642 #endif
 643
 644     if ((newsize = data->stacksize) == 0)
 645         newsize = YYINITSTACKSIZE;
 646     else if (newsize >= YYMAXDEPTH)
 647         return YYENOMEM;
 648     else if ((newsize *= 2) > YYMAXDEPTH)
 649         newsize = YYMAXDEPTH;
 650
 651     i = (int) (data->s_mark - data->s_base);
 652     newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
 653     if (newss == 0)
 654         return YYENOMEM;
 655
 656     data->s_base = newss;
 657     data->s_mark = newss + i;
 658
 659     newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
 660     if (newvs == 0)
 661         return YYENOMEM;
 662
 663     data->l_base = newvs;
 664     data->l_mark = newvs + i;
 665
 666 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 667     newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
 668     if (newps == 0)
 669         return YYENOMEM;
 670
 671     data->p_base = newps;
 672     data->p_mark = newps + i;
 673 #endif
 674
 675     data->stacksize = newsize;
 676     data->s_last = data->s_base + newsize - 1;
 677
 678 #if YYDEBUG
 679     if (yydebug)
 680         fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
 681 #endif
 682     return 0;
 683 }
 684
 685 #if YYPURE || defined(YY_NO_LEAKS)
 686 static void yyfreestack(YYSTACKDATA *data)
 687 {
 688     free(data->s_base);
 689     free(data->l_base);
 690 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 691     free(data->p_base);
 692 #endif
 693     memset(data, 0, sizeof(*data));
 694 }
 695 #else
 696 #define yyfreestack(data) /* nothing */
 697 #endif /* YYPURE || defined(YY_NO_LEAKS) */
 698 #if YYBTYACC
 699
 700 static YYParseState *
 701 yyNewState(unsigned size)
 702 {
 703     YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
 704     if (p == NULL) return NULL;
 705
 706     p->yystack.stacksize = size;
 707     if (size == 0)
 708     {
 709         p->yystack.s_base = NULL;
 710         p->yystack.l_base = NULL;
 711 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 712         p->yystack.p_base = NULL;
 713 #endif
 714         return p;
 715     }
 716     p->yystack.s_base    = (YYINT *) malloc(size * sizeof(YYINT));
 717     if (p->yystack.s_base == NULL) return NULL;
 718     p->yystack.l_base    = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
 719     if (p->yystack.l_base == NULL) return NULL;
 720     memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
 721 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 722     p->yystack.p_base    = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
 723     if (p->yystack.p_base == NULL) return NULL;
 724     memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
 725 #endif
 726
 727     return p;
 728 }
 729
 730 static void
 731 yyFreeState(YYParseState *p)
 732 {
 733     yyfreestack(&p->yystack);
 734     free(p);
 735 }
 736 #endif /* YYBTYACC */
 737
 738 #define YYABORT  goto yyabort
 739 #define YYREJECT goto yyabort
 740 #define YYACCEPT goto yyaccept
 741 #define YYERROR  goto yyerrlab
 742 #if YYBTYACC
 743 #define YYVALID        do { if (yyps->save)            goto yyvalid; } while(0)
 744 #define YYVALID_NESTED do { if (yyps->save && \
 745                                 yyps->save->save == 0) goto yyvalid; } while(0)
 746 #endif /* YYBTYACC */
 747
 748 int
 749 YYPARSE_DECL()
 750 {
 751     int      yyerrflag;
 752     int      yychar;
 753     YYSTYPE  yyval;
 754     YYSTYPE  yylval;
 755 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 756     YYLTYPE  yyloc; /* position returned by actions */
 757     YYLTYPE  yylloc; /* position from the lexer */
 758 #endif
 759
 760     /* variables for the parser stack */
 761     YYSTACKDATA yystack;
 762 #if YYBTYACC
 763
 764     /* Current parser state */
 765     static YYParseState *yyps = 0;
 766
 767     /* yypath != NULL: do the full parse, starting at *yypath parser state. */
 768     static YYParseState *yypath = 0;
 769
 770     /* Base of the lexical value queue */
 771     static YYSTYPE *yylvals = 0;
 772
 773     /* Current position at lexical value queue */
 774     static YYSTYPE *yylvp = 0;
 775
 776     /* End position of lexical value queue */
 777     static YYSTYPE *yylve = 0;
 778
 779     /* The last allocated position at the lexical value queue */
 780     static YYSTYPE *yylvlim = 0;
 781
 782 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 783     /* Base of the lexical position queue */
 784     static YYLTYPE *yylpsns = 0;
 785
 786     /* Current position at lexical position queue */
 787     static YYLTYPE *yylpp = 0;
 788
 789     /* End position of lexical position queue */
 790     static YYLTYPE *yylpe = 0;
 791
 792     /* The last allocated position at the lexical position queue */
 793     static YYLTYPE *yylplim = 0;
 794 #endif
 795
 796     /* Current position at lexical token queue */
 797     static YYINT  *yylexp = 0;
 798
 799     static YYINT  *yylexemes = 0;
 800 #endif /* YYBTYACC */
 801     int yym, yyn, yystate, yyresult;
 802 #if YYBTYACC
 803     int yynewerrflag;
 804     YYParseState *yyerrctx = NULL;
 805 #endif /* YYBTYACC */
 806 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 807     YYLTYPE  yyerror_loc_range[2]; /* position of error start & end */
 808 #endif
 809 #if YYDEBUG
 810     const char *yys;
 811
 812     if ((yys = getenv("YYDEBUG")) != 0)
 813     {
 814         yyn = *yys;
 815         if (yyn >= '0' && yyn <= '9')
 816             yydebug = yyn - '0';
 817     }
 818     if (yydebug)
 819         fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
 820 #endif
 821
 822 #if YYBTYACC
 823     yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
 824     yyps->save = 0;
 825 #endif /* YYBTYACC */
 826     yym = 0;
 827     yyn = 0;
 828     yynerrs = 0;
 829     yyerrflag = 0;
 830     yychar = YYEMPTY;
 831     yystate = 0;
 832
 833 #if YYPURE
 834     memset(&yystack, 0, sizeof(yystack));
 835 #endif
 836
 837     if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
 838     yystack.s_mark = yystack.s_base;
 839     yystack.l_mark = yystack.l_base;
 840 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 841     yystack.p_mark = yystack.p_base;
 842 #endif
 843     yystate = 0;
 844     *yystack.s_mark = 0;
 845
 846 yyloop:
 847     if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
 848     if (yychar < 0)
 849     {
 850 #if YYBTYACC
 851         do {
 852         if (yylvp < yylve)
 853         {
 854             /* we're currently re-reading tokens */
 855             yylval = *yylvp++;
 856 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 857             yylloc = *yylpp++;
 858 #endif
 859             yychar = *yylexp++;
 860             break;
 861         }
 862         if (yyps->save)
 863         {
 864             /* in trial mode; save scanner results for future parse attempts */
 865             if (yylvp == yylvlim)
 866             {   /* Enlarge lexical value queue */
 867                 size_t p = (size_t) (yylvp - yylvals);
 868                 size_t s = (size_t) (yylvlim - yylvals);
 869
 870                 s += YYLVQUEUEGROWTH;
 871                 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;
 872                 if ((yylvals   = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
 873 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 874                 if ((yylpsns   = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
 875 #endif
 876                 yylvp   = yylve = yylvals + p;
 877                 yylvlim = yylvals + s;
 878 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 879                 yylpp   = yylpe = yylpsns + p;
 880                 yylplim = yylpsns + s;
 881 #endif
 882                 yylexp  = yylexemes + p;
 883             }
 884             *yylexp = (YYINT) YYLEX;
 885             *yylvp++ = yylval;
 886             yylve++;
 887 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 888             *yylpp++ = yylloc;
 889             yylpe++;
 890 #endif
 891             yychar = *yylexp++;
 892             break;
 893         }
 894         /* normal operation, no conflict encountered */
 895 #endif /* YYBTYACC */
 896         yychar = YYLEX;
 897 #if YYBTYACC
 898         } while (0);
 899 #endif /* YYBTYACC */
 900         if (yychar < 0) yychar = YYEOF;
 901 #if YYDEBUG
 902         if (yydebug)
 903         {
 904             if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
 905             fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
 906                             YYDEBUGSTR, yydepth, yystate, yychar, yys);
 907 #ifdef YYSTYPE_TOSTRING
 908 #if YYBTYACC
 909             if (!yytrial)
 910 #endif /* YYBTYACC */
 911                 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
 912 #endif
 913             fputc('\n', stderr);
 914         }
 915 #endif
 916     }
 917 #if YYBTYACC
 918
 919     /* Do we have a conflict? */
 920     if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
 921         yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
 922     {
 923         YYINT ctry;
 924
 925         if (yypath)
 926         {
 927             YYParseState *save;
 928 #if YYDEBUG
 929             if (yydebug)
 930                 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
 931                                 YYDEBUGSTR, yydepth, yystate);
 932 #endif
 933             /* Switch to the next conflict context */
 934             save = yypath;
 935             yypath = save->save;
 936             save->save = NULL;
 937             ctry = save->ctry;
 938             if (save->state != yystate) YYABORT;
 939             yyFreeState(save);
 940
 941         }
 942         else
 943         {
 944
 945             /* Unresolved conflict - start/continue trial parse */
 946             YYParseState *save;
 947 #if YYDEBUG
 948             if (yydebug)
 949             {
 950                 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
 951                 if (yyps->save)
 952                     fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
 953                 else
 954                     fputs("Starting trial parse.\n", stderr);
 955             }
 956 #endif
 957             save                  = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
 958             if (save == NULL) goto yyenomem;
 959             save->save            = yyps->save;
 960             save->state           = yystate;
 961             save->errflag         = yyerrflag;
 962             save->yystack.s_mark  = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
 963             memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
 964             save->yystack.l_mark  = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
 965             memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
 966 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 967             save->yystack.p_mark  = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
 968             memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
 969 #endif
 970             ctry                  = yytable[yyn];
 971             if (yyctable[ctry] == -1)
 972             {
 973 #if YYDEBUG
 974                 if (yydebug && yychar >= YYEOF)
 975                     fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
 976 #endif
 977                 ctry++;
 978             }
 979             save->ctry = ctry;
 980             if (yyps->save == NULL)
 981             {
 982                 /* If this is a first conflict in the stack, start saving lexemes */
 983                 if (!yylexemes)
 984                 {
 985                     yylexemes = malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));
 986                     if (yylexemes == NULL) goto yyenomem;
 987                     yylvals   = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
 988                     if (yylvals == NULL) goto yyenomem;
 989                     yylvlim   = yylvals + YYLVQUEUEGROWTH;
 990 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 991                     yylpsns   = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
 992                     if (yylpsns == NULL) goto yyenomem;
 993                     yylplim   = yylpsns + YYLVQUEUEGROWTH;
 994 #endif
 995                 }
 996                 if (yylvp == yylve)
 997                 {
 998                     yylvp  = yylve = yylvals;
 999 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1000                     yylpp  = yylpe = yylpsns;
1001 #endif
1002                     yylexp = yylexemes;
1003                     if (yychar >= YYEOF)
1004                     {
1005                         *yylve++ = yylval;
1006 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1007                         *yylpe++ = yylloc;
1008 #endif
1009                         *yylexp  = (YYINT) yychar;
1010                         yychar   = YYEMPTY;
1011                     }
1012                 }
1013             }
1014             if (yychar >= YYEOF)
1015             {
1016                 yylvp--;
1017 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1018                 yylpp--;
1019 #endif
1020                 yylexp--;
1021                 yychar = YYEMPTY;
1022             }
1023             save->lexeme = (int) (yylvp - yylvals);
1024             yyps->save   = save;
1025         }
1026         if (yytable[yyn] == ctry)
1027         {
1028 #if YYDEBUG
1029             if (yydebug)
1030                 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
1031                                 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
1032 #endif
1033             if (yychar < 0)
1034             {
1035                 yylvp++;
1036 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1037                 yylpp++;
1038 #endif
1039                 yylexp++;
1040             }
1041             if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
1042                 goto yyoverflow;
1043             yystate = yyctable[ctry];
1044             *++yystack.s_mark = (YYINT) yystate;
1045             *++yystack.l_mark = yylval;
1046 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1047             *++yystack.p_mark = yylloc;
1048 #endif
1049             yychar  = YYEMPTY;
1050             if (yyerrflag > 0) --yyerrflag;
1051             goto yyloop;
1052         }
1053         else
1054         {
1055             yyn = yyctable[ctry];
1056             goto yyreduce;
1057         }
1058     } /* End of code dealing with conflicts */
1059 #endif /* YYBTYACC */
1060     if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
1061             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
1062     {
1063 #if YYDEBUG
1064         if (yydebug)
1065             fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
1066                             YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
1067 #endif
1068         if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1069         yystate = yytable[yyn];
1070         *++yystack.s_mark = yytable[yyn];
1071         *++yystack.l_mark = yylval;
1072 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1073         *++yystack.p_mark = yylloc;
1074 #endif
1075         yychar = YYEMPTY;
1076         if (yyerrflag > 0)  --yyerrflag;
1077         goto yyloop;
1078     }
1079     if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
1080             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
1081     {
1082         yyn = yytable[yyn];
1083         goto yyreduce;
1084     }
1085     if (yyerrflag != 0) goto yyinrecovery;
1086 #if YYBTYACC
1087
1088     yynewerrflag = 1;
1089     goto yyerrhandler;
1090     goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1091
1092 yyerrlab:
1093     /* explicit YYERROR from an action -- pop the rhs of the rule reduced
1094      * before looking for error recovery */
1095     yystack.s_mark -= yym;
1096     yystate = *yystack.s_mark;
1097     yystack.l_mark -= yym;
1098 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1099     yystack.p_mark -= yym;
1100 #endif
1101
1102     yynewerrflag = 0;
1103 yyerrhandler:
1104     while (yyps->save)
1105     {
1106         int ctry;
1107         YYParseState *save = yyps->save;
1108 #if YYDEBUG
1109         if (yydebug)
1110             fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
1111                             YYDEBUGSTR, yydepth, yystate, yyps->save->state,
1112                     (int)(yylvp - yylvals - yyps->save->lexeme));
1113 #endif
1114         /* Memorize most forward-looking error state in case it's really an error. */
1115         if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
1116         {
1117             /* Free old saved error context state */
1118             if (yyerrctx) yyFreeState(yyerrctx);
1119             /* Create and fill out new saved error context state */
1120             yyerrctx                 = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
1121             if (yyerrctx == NULL) goto yyenomem;
1122             yyerrctx->save           = yyps->save;
1123             yyerrctx->state          = yystate;
1124             yyerrctx->errflag        = yyerrflag;
1125             yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
1126             memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1127             yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
1128             memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1129 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1130             yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
1131             memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1132 #endif
1133             yyerrctx->lexeme         = (int) (yylvp - yylvals);
1134         }
1135         yylvp          = yylvals   + save->lexeme;
1136 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1137         yylpp          = yylpsns   + save->lexeme;
1138 #endif
1139         yylexp         = yylexemes + save->lexeme;
1140         yychar         = YYEMPTY;
1141         yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
1142         memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1143         yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
1144         memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1145 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1146         yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
1147         memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1148 #endif
1149         ctry           = ++save->ctry;
1150         yystate        = save->state;
1151         /* We tried shift, try reduce now */
1152         if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
1153         yyps->save     = save->save;
1154         save->save     = NULL;
1155         yyFreeState(save);
1156
1157         /* Nothing left on the stack -- error */
1158         if (!yyps->save)
1159         {
1160 #if YYDEBUG
1161             if (yydebug)
1162                 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1163                                 YYPREFIX, yydepth);
1164 #endif
1165             /* Restore state as it was in the most forward-advanced error */
1166             yylvp          = yylvals   + yyerrctx->lexeme;
1167 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1168             yylpp          = yylpsns   + yyerrctx->lexeme;
1169 #endif
1170             yylexp         = yylexemes + yyerrctx->lexeme;
1171             yychar         = yylexp[-1];
1172             yylval         = yylvp[-1];
1173 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1174             yylloc         = yylpp[-1];
1175 #endif
1176             yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1177             memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1178             yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1179             memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1180 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1181             yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1182             memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1183 #endif
1184             yystate        = yyerrctx->state;
1185             yyFreeState(yyerrctx);
1186             yyerrctx       = NULL;
1187         }
1188         yynewerrflag = 1;
1189     }
1190     if (yynewerrflag == 0) goto yyinrecovery;
1191 #endif /* YYBTYACC */
1192
1193     YYERROR_CALL("syntax error");
1194 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1195     yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */
1196 #endif
1197
1198 #if !YYBTYACC
1199     goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1200 yyerrlab:
1201 #endif
1202     ++yynerrs;
1203
1204 yyinrecovery:
1205     if (yyerrflag < 3)
1206     {
1207         yyerrflag = 3;
1208         for (;;)
1209         {
1210             if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1211                     yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1212             {
1213 #if YYDEBUG
1214                 if (yydebug)
1215                     fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1216                                     YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1217 #endif
1218                 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1219                 yystate = yytable[yyn];
1220                 *++yystack.s_mark = yytable[yyn];
1221                 *++yystack.l_mark = yylval;
1222 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1223                 /* lookahead position is error end position */
1224                 yyerror_loc_range[1] = yylloc;
1225                 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1226                 *++yystack.p_mark = yyloc;
1227 #endif
1228                 goto yyloop;
1229             }
1230             else
1231             {
1232 #if YYDEBUG
1233                 if (yydebug)
1234                     fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1235                                     YYDEBUGSTR, yydepth, *yystack.s_mark);
1236 #endif
1237                 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1238 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1239                 /* the current TOS position is the error start position */
1240                 yyerror_loc_range[0] = *yystack.p_mark;
1241 #endif
1242 #if defined(YYDESTRUCT_CALL)
1243 #if YYBTYACC
1244                 if (!yytrial)
1245 #endif /* YYBTYACC */
1246 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1247                     YYDESTRUCT_CALL("error: discarding state",
1248                                     yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1249 #else
1250                     YYDESTRUCT_CALL("error: discarding state",
1251                                     yystos[*yystack.s_mark], yystack.l_mark);
1252 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1253 #endif /* defined(YYDESTRUCT_CALL) */
1254                 --yystack.s_mark;
1255                 --yystack.l_mark;
1256 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1257                 --yystack.p_mark;
1258 #endif
1259             }
1260         }
1261     }
1262     else
1263     {
1264         if (yychar == YYEOF) goto yyabort;
1265 #if YYDEBUG
1266         if (yydebug)
1267         {
1268             if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1269             fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1270                             YYDEBUGSTR, yydepth, yystate, yychar, yys);
1271         }
1272 #endif
1273 #if defined(YYDESTRUCT_CALL)
1274 #if YYBTYACC
1275         if (!yytrial)
1276 #endif /* YYBTYACC */
1277 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1278             YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1279 #else
1280             YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1281 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1282 #endif /* defined(YYDESTRUCT_CALL) */
1283         yychar = YYEMPTY;
1284         goto yyloop;
1285     }
1286
1287 yyreduce:
1288     yym = yylen[yyn];
1289 #if YYDEBUG
1290     if (yydebug)
1291     {
1292         fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1293                         YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1294 #ifdef YYSTYPE_TOSTRING
1295 #if YYBTYACC
1296         if (!yytrial)
1297 #endif /* YYBTYACC */
1298             if (yym > 0)
1299             {
1300                 int i;
1301                 fputc('<', stderr);
1302                 for (i = yym; i > 0; i--)
1303                 {
1304                     if (i != yym) fputs(", ", stderr);
1305                     fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1306                                            yystack.l_mark[1-i]), stderr);
1307                 }
1308                 fputc('>', stderr);
1309             }
1310 #endif
1311         fputc('\n', stderr);
1312     }
1313 #endif
1314     if (yym > 0)
1315         yyval = yystack.l_mark[1-yym];
1316     else
1317         memset(&yyval, 0, sizeof yyval);
1318 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1319
1320     /* Perform position reduction */
1321     memset(&yyloc, 0, sizeof(yyloc));
1322 #if YYBTYACC
1323     if (!yytrial)
1324 #endif /* YYBTYACC */
1325     {
1326         YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);
1327         /* just in case YYERROR is invoked within the action, save
1328            the start of the rhs as the error start position */
1329         yyerror_loc_range[0] = yystack.p_mark[1-yym];
1330     }
1331 #endif
1332
1333     switch (yyn)
1334     {
1335 case 2:
1336 #line 51 "btyacc_calc1.y"
1337 {YYVALID;}
1338 break;
1339 case 3:
1340 #line 52 "btyacc_calc1.y"
1341 {YYVALID;}  if (!yytrial)
1342 #line 53 "btyacc_calc1.y"
1343 {
1344                 yyerrok;
1345         }
1346 break;
1347 case 4:
1348   if (!yytrial)
1349 #line 59 "btyacc_calc1.y"
1350         {
1351                 (void) printf("%15.8f\n", yystack.l_mark[0].dval);
1352         }
1353 break;
1354 case 5:
1355   if (!yytrial)
1356 #line 63 "btyacc_calc1.y"
1357         {
1358                 (void) printf("(%15.8f, %15.8f)\n", yystack.l_mark[0].vval.lo, yystack.l_mark[0].vval.hi);
1359         }
1360 break;
1361 case 6:
1362   if (!yytrial)
1363 #line 67 "btyacc_calc1.y"
1364         {
1365                 dreg[yystack.l_mark[-2].ival] = yystack.l_mark[0].dval;
1366         }
1367 break;
1368 case 7:
1369   if (!yytrial)
1370 #line 71 "btyacc_calc1.y"
1371         {
1372                 vreg[yystack.l_mark[-2].ival] = yystack.l_mark[0].vval;
1373         }
1374 break;
1375 case 9:
1376   if (!yytrial)
1377 #line 78 "btyacc_calc1.y"
1378         {
1379                 yyval.dval = dreg[yystack.l_mark[0].ival];
1380         }
1381 break;
1382 case 10:
1383   if (!yytrial)
1384 #line 82 "btyacc_calc1.y"
1385         {
1386                 yyval.dval = yystack.l_mark[-2].dval + yystack.l_mark[0].dval;
1387         }
1388 break;
1389 case 11:
1390   if (!yytrial)
1391 #line 86 "btyacc_calc1.y"
1392         {
1393                 yyval.dval = yystack.l_mark[-2].dval - yystack.l_mark[0].dval;
1394         }
1395 break;
1396 case 12:
1397   if (!yytrial)
1398 #line 90 "btyacc_calc1.y"
1399         {
1400                 yyval.dval = yystack.l_mark[-2].dval * yystack.l_mark[0].dval;
1401         }
1402 break;
1403 case 13:
1404   if (!yytrial)
1405 #line 94 "btyacc_calc1.y"
1406         {
1407                 yyval.dval = yystack.l_mark[-2].dval / yystack.l_mark[0].dval;
1408         }
1409 break;
1410 case 14:
1411   if (!yytrial)
1412 #line 98 "btyacc_calc1.y"
1413         {
1414                 yyval.dval = -yystack.l_mark[0].dval;
1415         }
1416 break;
1417 case 15:
1418   if (!yytrial)
1419 #line 102 "btyacc_calc1.y"
1420         {
1421                 yyval.dval = yystack.l_mark[-1].dval;
1422         }
1423 break;
1424 case 16:
1425   if (!yytrial)
1426 #line 108 "btyacc_calc1.y"
1427         {
1428                 yyval.vval.hi = yyval.vval.lo = yystack.l_mark[0].dval;
1429         }
1430 break;
1431 case 17:
1432   if (!yytrial)
1433 #line 112 "btyacc_calc1.y"
1434         {
1435                 yyval.vval.lo = yystack.l_mark[-3].dval;
1436                 yyval.vval.hi = yystack.l_mark[-1].dval;
1437                 if ( yyval.vval.lo > yyval.vval.hi )
1438                 {
1439                         (void) printf("interval out of order\n");
1440                         YYERROR;
1441                 }
1442         }
1443 break;
1444 case 18:
1445   if (!yytrial)
1446 #line 122 "btyacc_calc1.y"
1447         {
1448                 yyval.vval = vreg[yystack.l_mark[0].ival];
1449         }
1450 break;
1451 case 19:
1452   if (!yytrial)
1453 #line 126 "btyacc_calc1.y"
1454         {
1455                 yyval.vval.hi = yystack.l_mark[-2].vval.hi + yystack.l_mark[0].vval.hi;
1456                 yyval.vval.lo = yystack.l_mark[-2].vval.lo + yystack.l_mark[0].vval.lo;
1457         }
1458 break;
1459 case 20:
1460   if (!yytrial)
1461 #line 131 "btyacc_calc1.y"
1462         {
1463                 yyval.vval.hi = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.hi;
1464                 yyval.vval.lo = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.lo;
1465         }
1466 break;
1467 case 21:
1468   if (!yytrial)
1469 #line 136 "btyacc_calc1.y"
1470         {
1471                 yyval.vval.hi = yystack.l_mark[-2].vval.hi - yystack.l_mark[0].vval.lo;
1472                 yyval.vval.lo = yystack.l_mark[-2].vval.lo - yystack.l_mark[0].vval.hi;
1473         }
1474 break;
1475 case 22:
1476   if (!yytrial)
1477 #line 141 "btyacc_calc1.y"
1478         {
1479                 yyval.vval.hi = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.lo;
1480                 yyval.vval.lo = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.hi;
1481         }
1482 break;
1483 case 23:
1484   if (!yytrial)
1485 #line 146 "btyacc_calc1.y"
1486         {
1487                 yyval.vval = vmul( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval );
1488         }
1489 break;
1490 case 24:
1491   if (!yytrial)
1492 #line 150 "btyacc_calc1.y"
1493         {
1494                 yyval.vval = vmul (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval );
1495         }
1496 break;
1497 case 25:
1498   if (!yytrial)
1499 #line 154 "btyacc_calc1.y"
1500         {
1501                 if (dcheck(yystack.l_mark[0].vval)) YYERROR;
1502                 yyval.vval = vdiv ( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval );
1503         }
1504 break;
1505 case 26:
1506   if (!yytrial)
1507 #line 159 "btyacc_calc1.y"
1508         {
1509                 if (dcheck ( yystack.l_mark[0].vval )) YYERROR;
1510                 yyval.vval = vdiv (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval );
1511         }
1512 break;
1513 case 27:
1514   if (!yytrial)
1515 #line 164 "btyacc_calc1.y"
1516         {
1517                 yyval.vval.hi = -yystack.l_mark[0].vval.lo;
1518                 yyval.vval.lo = -yystack.l_mark[0].vval.hi;
1519         }
1520 break;
1521 case 28:
1522   if (!yytrial)
1523 #line 169 "btyacc_calc1.y"
1524         {
1525                 yyval.vval = yystack.l_mark[-1].vval;
1526         }
1527 break;
1528 #line 1529 "btyacc_calc1.tab.c"
1529     default:
1530         break;
1531     }
1532     yystack.s_mark -= yym;
1533     yystate = *yystack.s_mark;
1534     yystack.l_mark -= yym;
1535 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1536     yystack.p_mark -= yym;
1537 #endif
1538     yym = yylhs[yyn];
1539     if (yystate == 0 && yym == 0)
1540     {
1541 #if YYDEBUG
1542         if (yydebug)
1543         {
1544             fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1545 #ifdef YYSTYPE_TOSTRING
1546 #if YYBTYACC
1547             if (!yytrial)
1548 #endif /* YYBTYACC */
1549                 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1550 #endif
1551             fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1552         }
1553 #endif
1554         yystate = YYFINAL;
1555         *++yystack.s_mark = YYFINAL;
1556         *++yystack.l_mark = yyval;
1557 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1558         *++yystack.p_mark = yyloc;
1559 #endif
1560         if (yychar < 0)
1561         {
1562 #if YYBTYACC
1563             do {
1564             if (yylvp < yylve)
1565             {
1566                 /* we're currently re-reading tokens */
1567                 yylval = *yylvp++;
1568 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1569                 yylloc = *yylpp++;
1570 #endif
1571                 yychar = *yylexp++;
1572                 break;
1573             }
1574             if (yyps->save)
1575             {
1576                 /* in trial mode; save scanner results for future parse attempts */
1577                 if (yylvp == yylvlim)
1578                 {   /* Enlarge lexical value queue */
1579                     size_t p = (size_t) (yylvp - yylvals);
1580                     size_t s = (size_t) (yylvlim - yylvals);
1581
1582                     s += YYLVQUEUEGROWTH;
1583                     if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL)
1584                         goto yyenomem;
1585                     if ((yylvals   = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1586                         goto yyenomem;
1587 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1588                     if ((yylpsns   = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1589                         goto yyenomem;
1590 #endif
1591                     yylvp   = yylve = yylvals + p;
1592                     yylvlim = yylvals + s;
1593 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1594                     yylpp   = yylpe = yylpsns + p;
1595                     yylplim = yylpsns + s;
1596 #endif
1597                     yylexp  = yylexemes + p;
1598                 }
1599                 *yylexp = (YYINT) YYLEX;
1600                 *yylvp++ = yylval;
1601                 yylve++;
1602 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1603                 *yylpp++ = yylloc;
1604                 yylpe++;
1605 #endif
1606                 yychar = *yylexp++;
1607                 break;
1608             }
1609             /* normal operation, no conflict encountered */
1610 #endif /* YYBTYACC */
1611             yychar = YYLEX;
1612 #if YYBTYACC
1613             } while (0);
1614 #endif /* YYBTYACC */
1615             if (yychar < 0) yychar = YYEOF;
1616 #if YYDEBUG
1617             if (yydebug)
1618             {
1619                 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1620                 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
1621                                 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1622             }
1623 #endif
1624         }
1625         if (yychar == YYEOF) goto yyaccept;
1626         goto yyloop;
1627     }
1628     if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1629             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1630         yystate = yytable[yyn];
1631     else
1632         yystate = yydgoto[yym];
1633 #if YYDEBUG
1634     if (yydebug)
1635     {
1636         fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1637 #ifdef YYSTYPE_TOSTRING
1638 #if YYBTYACC
1639         if (!yytrial)
1640 #endif /* YYBTYACC */
1641             fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1642 #endif
1643         fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1644     }
1645 #endif
1646     if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1647     *++yystack.s_mark = (YYINT) yystate;
1648     *++yystack.l_mark = yyval;
1649 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1650     *++yystack.p_mark = yyloc;
1651 #endif
1652     goto yyloop;
1653 #if YYBTYACC
1654
1655     /* Reduction declares that this path is valid. Set yypath and do a full parse */
1656 yyvalid:
1657     if (yypath) YYABORT;
1658     while (yyps->save)
1659     {
1660         YYParseState *save = yyps->save;
1661         yyps->save = save->save;
1662         save->save = yypath;
1663         yypath = save;
1664     }
1665 #if YYDEBUG
1666     if (yydebug)
1667         fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1668                         YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1669 #endif
1670     if (yyerrctx)
1671     {
1672         yyFreeState(yyerrctx);
1673         yyerrctx = NULL;
1674     }
1675     yylvp          = yylvals + yypath->lexeme;
1676 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1677     yylpp          = yylpsns + yypath->lexeme;
1678 #endif
1679     yylexp         = yylexemes + yypath->lexeme;
1680     yychar         = YYEMPTY;
1681     yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1682     memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1683     yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1684     memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1685 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1686     yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1687     memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1688 #endif
1689     yystate        = yypath->state;
1690     goto yyloop;
1691 #endif /* YYBTYACC */
1692
1693 yyoverflow:
1694     YYERROR_CALL("yacc stack overflow");
1695 #if YYBTYACC
1696     goto yyabort_nomem;
1697 yyenomem:
1698     YYERROR_CALL("memory exhausted");
1699 yyabort_nomem:
1700 #endif /* YYBTYACC */
1701     yyresult = 2;
1702     goto yyreturn;
1703
1704 yyabort:
1705     yyresult = 1;
1706     goto yyreturn;
1707
1708 yyaccept:
1709 #if YYBTYACC
1710     if (yyps->save) goto yyvalid;
1711 #endif /* YYBTYACC */
1712     yyresult = 0;
1713
1714 yyreturn:
1715 #if defined(YYDESTRUCT_CALL)
1716     if (yychar != YYEOF && yychar != YYEMPTY)
1717 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1718         YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1719 #else
1720         YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1721 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1722
1723     {
1724         YYSTYPE *pv;
1725 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1726         YYLTYPE *pp;
1727
1728         for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1729              YYDESTRUCT_CALL("cleanup: discarding state",
1730                              yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1731 #else
1732         for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1733              YYDESTRUCT_CALL("cleanup: discarding state",
1734                              yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1735 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1736     }
1737 #endif /* defined(YYDESTRUCT_CALL) */
1738
1739 #if YYBTYACC
1740     if (yyerrctx)
1741     {
1742         yyFreeState(yyerrctx);
1743         yyerrctx = NULL;
1744     }
1745     while (yyps)
1746     {
1747         YYParseState *save = yyps;
1748         yyps = save->save;
1749         save->save = NULL;
1750         yyFreeState(save);
1751     }
1752     while (yypath)
1753     {
1754         YYParseState *save = yypath;
1755         yypath = save->save;
1756         save->save = NULL;
1757         yyFreeState(save);
1758     }
1759 #endif /* YYBTYACC */
1760     yyfreestack(&yystack);
1761     return (yyresult);
1762 }