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