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