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