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