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