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