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