pure_calc.tab.c revision 277086 
1/* original parser id follows */
2/* yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93" */
3/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
4
5#define YYBYACC 1
6#define YYMAJOR 1
7#define YYMINOR 9
8#define YYCHECK "yyyymmdd"
9
10#define YYEMPTY        (-1)
11#define yyclearin      (yychar = YYEMPTY)
12#define yyerrok        (yyerrflag = 0)
13#define YYRECOVERING() (yyerrflag != 0)
14#define YYENOMEM       (-2)
15#define YYEOF          0
16
17#ifndef yyparse
18#define yyparse    calc_parse
19#endif /* yyparse */
20
21#ifndef yylex
22#define yylex      calc_lex
23#endif /* yylex */
24
25#ifndef yyerror
26#define yyerror    calc_error
27#endif /* yyerror */
28
29#ifndef yychar
30#define yychar     calc_char
31#endif /* yychar */
32
33#ifndef yyval
34#define yyval      calc_val
35#endif /* yyval */
36
37#ifndef yylval
38#define yylval     calc_lval
39#endif /* yylval */
40
41#ifndef yydebug
42#define yydebug    calc_debug
43#endif /* yydebug */
44
45#ifndef yynerrs
46#define yynerrs    calc_nerrs
47#endif /* yynerrs */
48
49#ifndef yyerrflag
50#define yyerrflag  calc_errflag
51#endif /* yyerrflag */
52
53#ifndef yylhs
54#define yylhs      calc_lhs
55#endif /* yylhs */
56
57#ifndef yylen
58#define yylen      calc_len
59#endif /* yylen */
60
61#ifndef yydefred
62#define yydefred   calc_defred
63#endif /* yydefred */
64
65#ifndef yydgoto
66#define yydgoto    calc_dgoto
67#endif /* yydgoto */
68
69#ifndef yysindex
70#define yysindex   calc_sindex
71#endif /* yysindex */
72
73#ifndef yyrindex
74#define yyrindex   calc_rindex
75#endif /* yyrindex */
76
77#ifndef yygindex
78#define yygindex   calc_gindex
79#endif /* yygindex */
80
81#ifndef yytable
82#define yytable    calc_table
83#endif /* yytable */
84
85#ifndef yycheck
86#define yycheck    calc_check
87#endif /* yycheck */
88
89#ifndef yyname
90#define yyname     calc_name
91#endif /* yyname */
92
93#ifndef yyrule
94#define yyrule     calc_rule
95#endif /* yyrule */
96#define YYPREFIX "calc_"
97
98#define YYPURE 1
99
100#line 2 "pure_calc.y"
101# include <stdio.h>
102# include <ctype.h>
103
104int regs[26];
105int base;
106
107#ifdef YYBISON
108#define YYSTYPE int
109#define YYLEX_PARAM &yylval
110#define YYLEX_DECL() yylex(YYSTYPE *yylval)
111#define YYERROR_DECL() yyerror(const char *s)
112int YYLEX_DECL();
113static void YYERROR_DECL();
114#endif
115
116#line 117 "pure_calc.tab.c"
117
118#if ! defined(YYSTYPE) && ! defined(YYSTYPE_IS_DECLARED)
119/* Default: YYSTYPE is the semantic value type. */
120typedef int YYSTYPE;
121# define YYSTYPE_IS_DECLARED 1
122#endif
123
124/* compatibility with bison */
125#ifdef YYPARSE_PARAM
126/* compatibility with FreeBSD */
127# ifdef YYPARSE_PARAM_TYPE
128#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
129# else
130#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
131# endif
132#else
133# define YYPARSE_DECL() yyparse(void)
134#endif
135
136/* Parameters sent to lex. */
137#ifdef YYLEX_PARAM
138# ifdef YYLEX_PARAM_TYPE
139#  define YYLEX_DECL() yylex(YYSTYPE *yylval, YYLEX_PARAM_TYPE YYLEX_PARAM)
140# else
141#  define YYLEX_DECL() yylex(YYSTYPE *yylval, void * YYLEX_PARAM)
142# endif
143# define YYLEX yylex(&yylval, YYLEX_PARAM)
144#else
145# define YYLEX_DECL() yylex(YYSTYPE *yylval)
146# define YYLEX yylex(&yylval)
147#endif
148
149/* Parameters sent to yyerror. */
150#ifndef YYERROR_DECL
151#define YYERROR_DECL() yyerror(const char *s)
152#endif
153#ifndef YYERROR_CALL
154#define YYERROR_CALL(msg) yyerror(msg)
155#endif
156
157extern int YYPARSE_DECL();
158
159#define DIGIT 257
160#define LETTER 258
161#define UMINUS 259
162#define YYERRCODE 256
163typedef int YYINT;
164static const YYINT calc_lhs[] = {                        -1,
165    0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
166    2,    2,    2,    2,    2,    2,    3,    3,
167};
168static const YYINT calc_len[] = {                         2,
169    0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
170    3,    3,    3,    2,    1,    1,    1,    2,
171};
172static const YYINT calc_defred[] = {                      1,
173    0,    0,   17,    0,    0,    0,    0,    0,    0,    3,
174    0,   15,   14,    0,    2,    0,    0,    0,    0,    0,
175    0,    0,   18,    0,    6,    0,    0,    0,    0,    9,
176   10,   11,
177};
178static const YYINT calc_dgoto[] = {                       1,
179    7,    8,    9,
180};
181static const YYINT calc_sindex[] = {                      0,
182  -40,   -7,    0,  -55,  -38,  -38,    1,  -29, -247,    0,
183  -38,    0,    0,   22,    0,  -38,  -38,  -38,  -38,  -38,
184  -38,  -38,    0,  -29,    0,   51,   60,  -20,  -20,    0,
185    0,    0,
186};
187static const YYINT calc_rindex[] = {                      0,
188    0,    0,    0,    2,    0,    0,    0,    9,   -9,    0,
189    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
190    0,    0,    0,   10,    0,   -6,   14,    5,   13,    0,
191    0,    0,
192};
193static const YYINT calc_gindex[] = {                      0,
194    0,   65,    0,
195};
196#define YYTABLESIZE 220
197static const YYINT calc_table[] = {                       6,
198   16,    6,   10,   13,    5,   11,    5,   22,   17,   23,
199   15,   15,   20,   18,    7,   19,   22,   21,    4,    5,
200    0,   20,    8,   12,    0,    0,   21,   16,   16,    0,
201    0,   16,   16,   16,   13,   16,    0,   16,   15,   15,
202    0,    0,    7,   15,   15,    7,   15,    7,   15,    7,
203    8,   12,    0,    8,   12,    8,    0,    8,   22,   17,
204    0,    0,   25,   20,   18,    0,   19,    0,   21,   13,
205   14,    0,    0,    0,    0,   24,    0,    0,    0,    0,
206   26,   27,   28,   29,   30,   31,   32,   22,   17,    0,
207    0,    0,   20,   18,   16,   19,   22,   21,    0,    0,
208    0,   20,   18,    0,   19,    0,   21,    0,    0,    0,
209    0,    0,    0,    0,   16,    0,    0,   13,    0,    0,
210    0,    0,    0,    0,    0,   15,    0,    0,    7,    0,
211    0,    0,    0,    0,    0,    0,    8,   12,    0,    0,
212    0,    0,    0,    0,    0,   16,    0,    0,    0,    0,
213    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
214    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
215    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
216    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
217    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
218    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
219    0,    0,    0,    0,    0,    2,    3,    4,    3,   12,
220};
221static const YYINT calc_check[] = {                      40,
222   10,   40,   10,   10,   45,   61,   45,   37,   38,  257,
223   10,   10,   42,   43,   10,   45,   37,   47,   10,   10,
224   -1,   42,   10,   10,   -1,   -1,   47,   37,   38,   -1,
225   -1,   41,   42,   43,   41,   45,   -1,   47,   37,   38,
226   -1,   -1,   38,   42,   43,   41,   45,   43,   47,   45,
227   38,   38,   -1,   41,   41,   43,   -1,   45,   37,   38,
228   -1,   -1,   41,   42,   43,   -1,   45,   -1,   47,    5,
229    6,   -1,   -1,   -1,   -1,   11,   -1,   -1,   -1,   -1,
230   16,   17,   18,   19,   20,   21,   22,   37,   38,   -1,
231   -1,   -1,   42,   43,  124,   45,   37,   47,   -1,   -1,
232   -1,   42,   43,   -1,   45,   -1,   47,   -1,   -1,   -1,
233   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,   -1,
234   -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,
235   -1,   -1,   -1,   -1,   -1,   -1,  124,  124,   -1,   -1,
236   -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,   -1,   -1,
237   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
238   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
239   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
240   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
241   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
242   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
243   -1,   -1,   -1,   -1,   -1,  256,  257,  258,  257,  258,
244};
245#define YYFINAL 1
246#ifndef YYDEBUG
247#define YYDEBUG 0
248#endif
249#define YYMAXTOKEN 259
250#define YYUNDFTOKEN 265
251#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
252#if YYDEBUG
253static const char *const calc_name[] = {
254
255"end-of-file",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2560,0,0,0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,
2570,0,0,0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2580,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,0,0,0,0,0,
2590,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2600,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2610,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2620,0,0,0,0,0,"DIGIT","LETTER","UMINUS",0,0,0,0,0,"illegal-symbol",
263};
264static const char *const calc_rule[] = {
265"$accept : list",
266"list :",
267"list : list stat '\\n'",
268"list : list error '\\n'",
269"stat : expr",
270"stat : LETTER '=' expr",
271"expr : '(' expr ')'",
272"expr : expr '+' expr",
273"expr : expr '-' expr",
274"expr : expr '*' expr",
275"expr : expr '/' expr",
276"expr : expr '%' expr",
277"expr : expr '&' expr",
278"expr : expr '|' expr",
279"expr : '-' expr",
280"expr : LETTER",
281"expr : number",
282"number : DIGIT",
283"number : number DIGIT",
284
285};
286#endif
287
288int      yydebug;
289int      yynerrs;
290
291/* define the initial stack-sizes */
292#ifdef YYSTACKSIZE
293#undef YYMAXDEPTH
294#define YYMAXDEPTH  YYSTACKSIZE
295#else
296#ifdef YYMAXDEPTH
297#define YYSTACKSIZE YYMAXDEPTH
298#else
299#define YYSTACKSIZE 10000
300#define YYMAXDEPTH  10000
301#endif
302#endif
303
304#define YYINITSTACKSIZE 200
305
306typedef struct {
307    unsigned stacksize;
308    YYINT    *s_base;
309    YYINT    *s_mark;
310    YYINT    *s_last;
311    YYSTYPE  *l_base;
312    YYSTYPE  *l_mark;
313} YYSTACKDATA;
314#line 72 "pure_calc.y"
315 /* start of programs */
316
317#ifdef YYBYACC
318static int YYLEX_DECL();
319#endif
320
321int
322main (void)
323{
324    while(!feof(stdin)) {
325	yyparse();
326    }
327    return 0;
328}
329
330static void
331YYERROR_DECL()
332{
333    fprintf(stderr, "%s\n", s);
334}
335
336int
337YYLEX_DECL()
338{
339	/* lexical analysis routine */
340	/* returns LETTER for a lower case letter, yylval = 0 through 25 */
341	/* return DIGIT for a digit, yylval = 0 through 9 */
342	/* all other characters are returned immediately */
343
344    int c;
345
346    while( (c=getchar()) == ' ' )   { /* skip blanks */ }
347
348    /* c is now nonblank */
349
350    if( islower( c )) {
351	*yylval = c - 'a';
352	return ( LETTER );
353    }
354    if( isdigit( c )) {
355	*yylval = c - '0';
356	return ( DIGIT );
357    }
358    return( c );
359}
360#line 361 "pure_calc.tab.c"
361
362#if YYDEBUG
363#include <stdio.h>		/* needed for printf */
364#endif
365
366#include <stdlib.h>	/* needed for malloc, etc */
367#include <string.h>	/* needed for memset */
368
369/* allocate initial stack or double stack size, up to YYMAXDEPTH */
370static int yygrowstack(YYSTACKDATA *data)
371{
372    int i;
373    unsigned newsize;
374    YYINT *newss;
375    YYSTYPE *newvs;
376
377    if ((newsize = data->stacksize) == 0)
378        newsize = YYINITSTACKSIZE;
379    else if (newsize >= YYMAXDEPTH)
380        return YYENOMEM;
381    else if ((newsize *= 2) > YYMAXDEPTH)
382        newsize = YYMAXDEPTH;
383
384    i = (int) (data->s_mark - data->s_base);
385    newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
386    if (newss == 0)
387        return YYENOMEM;
388
389    data->s_base = newss;
390    data->s_mark = newss + i;
391
392    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
393    if (newvs == 0)
394        return YYENOMEM;
395
396    data->l_base = newvs;
397    data->l_mark = newvs + i;
398
399    data->stacksize = newsize;
400    data->s_last = data->s_base + newsize - 1;
401    return 0;
402}
403
404#if YYPURE || defined(YY_NO_LEAKS)
405static void yyfreestack(YYSTACKDATA *data)
406{
407    free(data->s_base);
408    free(data->l_base);
409    memset(data, 0, sizeof(*data));
410}
411#else
412#define yyfreestack(data) /* nothing */
413#endif
414
415#define YYABORT  goto yyabort
416#define YYREJECT goto yyabort
417#define YYACCEPT goto yyaccept
418#define YYERROR  goto yyerrlab
419
420int
421YYPARSE_DECL()
422{
423    int      yyerrflag;
424    int      yychar;
425    YYSTYPE  yyval;
426    YYSTYPE  yylval;
427
428    /* variables for the parser stack */
429    YYSTACKDATA yystack;
430    int yym, yyn, yystate;
431#if YYDEBUG
432    const char *yys;
433
434    if ((yys = getenv("YYDEBUG")) != 0)
435    {
436        yyn = *yys;
437        if (yyn >= '0' && yyn <= '9')
438            yydebug = yyn - '0';
439    }
440#endif
441
442    yynerrs = 0;
443    yyerrflag = 0;
444    yychar = YYEMPTY;
445    yystate = 0;
446
447#if YYPURE
448    memset(&yystack, 0, sizeof(yystack));
449#endif
450
451    if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
452    yystack.s_mark = yystack.s_base;
453    yystack.l_mark = yystack.l_base;
454    yystate = 0;
455    *yystack.s_mark = 0;
456
457yyloop:
458    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
459    if (yychar < 0)
460    {
461        if ((yychar = YYLEX) < 0) yychar = YYEOF;
462#if YYDEBUG
463        if (yydebug)
464        {
465            yys = yyname[YYTRANSLATE(yychar)];
466            printf("%sdebug: state %d, reading %d (%s)\n",
467                    YYPREFIX, yystate, yychar, yys);
468        }
469#endif
470    }
471    if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
472            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
473    {
474#if YYDEBUG
475        if (yydebug)
476            printf("%sdebug: state %d, shifting to state %d\n",
477                    YYPREFIX, yystate, yytable[yyn]);
478#endif
479        if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
480        {
481            goto yyoverflow;
482        }
483        yystate = yytable[yyn];
484        *++yystack.s_mark = yytable[yyn];
485        *++yystack.l_mark = yylval;
486        yychar = YYEMPTY;
487        if (yyerrflag > 0)  --yyerrflag;
488        goto yyloop;
489    }
490    if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
491            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
492    {
493        yyn = yytable[yyn];
494        goto yyreduce;
495    }
496    if (yyerrflag) goto yyinrecovery;
497
498    YYERROR_CALL("syntax error");
499
500    goto yyerrlab;
501
502yyerrlab:
503    ++yynerrs;
504
505yyinrecovery:
506    if (yyerrflag < 3)
507    {
508        yyerrflag = 3;
509        for (;;)
510        {
511            if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
512                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
513            {
514#if YYDEBUG
515                if (yydebug)
516                    printf("%sdebug: state %d, error recovery shifting\
517 to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
518#endif
519                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
520                {
521                    goto yyoverflow;
522                }
523                yystate = yytable[yyn];
524                *++yystack.s_mark = yytable[yyn];
525                *++yystack.l_mark = yylval;
526                goto yyloop;
527            }
528            else
529            {
530#if YYDEBUG
531                if (yydebug)
532                    printf("%sdebug: error recovery discarding state %d\n",
533                            YYPREFIX, *yystack.s_mark);
534#endif
535                if (yystack.s_mark <= yystack.s_base) goto yyabort;
536                --yystack.s_mark;
537                --yystack.l_mark;
538            }
539        }
540    }
541    else
542    {
543        if (yychar == YYEOF) goto yyabort;
544#if YYDEBUG
545        if (yydebug)
546        {
547            yys = yyname[YYTRANSLATE(yychar)];
548            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
549                    YYPREFIX, yystate, yychar, yys);
550        }
551#endif
552        yychar = YYEMPTY;
553        goto yyloop;
554    }
555
556yyreduce:
557#if YYDEBUG
558    if (yydebug)
559        printf("%sdebug: state %d, reducing by rule %d (%s)\n",
560                YYPREFIX, yystate, yyn, yyrule[yyn]);
561#endif
562    yym = yylen[yyn];
563    if (yym)
564        yyval = yystack.l_mark[1-yym];
565    else
566        memset(&yyval, 0, sizeof yyval);
567    switch (yyn)
568    {
569case 3:
570#line 34 "pure_calc.y"
571	{  yyerrok ; }
572break;
573case 4:
574#line 38 "pure_calc.y"
575	{  printf("%d\n",yystack.l_mark[0]);}
576break;
577case 5:
578#line 40 "pure_calc.y"
579	{  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
580break;
581case 6:
582#line 44 "pure_calc.y"
583	{  yyval = yystack.l_mark[-1]; }
584break;
585case 7:
586#line 46 "pure_calc.y"
587	{  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
588break;
589case 8:
590#line 48 "pure_calc.y"
591	{  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
592break;
593case 9:
594#line 50 "pure_calc.y"
595	{  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
596break;
597case 10:
598#line 52 "pure_calc.y"
599	{  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
600break;
601case 11:
602#line 54 "pure_calc.y"
603	{  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
604break;
605case 12:
606#line 56 "pure_calc.y"
607	{  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
608break;
609case 13:
610#line 58 "pure_calc.y"
611	{  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
612break;
613case 14:
614#line 60 "pure_calc.y"
615	{  yyval = - yystack.l_mark[0]; }
616break;
617case 15:
618#line 62 "pure_calc.y"
619	{  yyval = regs[yystack.l_mark[0]]; }
620break;
621case 17:
622#line 67 "pure_calc.y"
623	{  yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
624break;
625case 18:
626#line 69 "pure_calc.y"
627	{  yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
628break;
629#line 630 "pure_calc.tab.c"
630    }
631    yystack.s_mark -= yym;
632    yystate = *yystack.s_mark;
633    yystack.l_mark -= yym;
634    yym = yylhs[yyn];
635    if (yystate == 0 && yym == 0)
636    {
637#if YYDEBUG
638        if (yydebug)
639            printf("%sdebug: after reduction, shifting from state 0 to\
640 state %d\n", YYPREFIX, YYFINAL);
641#endif
642        yystate = YYFINAL;
643        *++yystack.s_mark = YYFINAL;
644        *++yystack.l_mark = yyval;
645        if (yychar < 0)
646        {
647            if ((yychar = YYLEX) < 0) yychar = YYEOF;
648#if YYDEBUG
649            if (yydebug)
650            {
651                yys = yyname[YYTRANSLATE(yychar)];
652                printf("%sdebug: state %d, reading %d (%s)\n",
653                        YYPREFIX, YYFINAL, yychar, yys);
654            }
655#endif
656        }
657        if (yychar == YYEOF) goto yyaccept;
658        goto yyloop;
659    }
660    if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
661            yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
662        yystate = yytable[yyn];
663    else
664        yystate = yydgoto[yym];
665#if YYDEBUG
666    if (yydebug)
667        printf("%sdebug: after reduction, shifting from state %d \
668to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
669#endif
670    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
671    {
672        goto yyoverflow;
673    }
674    *++yystack.s_mark = (YYINT) yystate;
675    *++yystack.l_mark = yyval;
676    goto yyloop;
677
678yyoverflow:
679    YYERROR_CALL("yacc stack overflow");
680
681yyabort:
682    yyfreestack(&yystack);
683    return (1);
684
685yyaccept:
686    yyfreestack(&yystack);
687    return (0);
688}
689