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