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