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