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