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