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