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    memset(&yyval,  0, sizeof(yyval));
443    memset(&yylval, 0, sizeof(yylval));
444
445    yym = 0;
446    yyn = 0;
447    yynerrs = 0;
448    yyerrflag = 0;
449    yychar = YYEMPTY;
450    yystate = 0;
451
452#if YYPURE
453    memset(&yystack, 0, sizeof(yystack));
454#endif
455
456    if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
457    yystack.s_mark = yystack.s_base;
458    yystack.l_mark = yystack.l_base;
459    yystate = 0;
460    *yystack.s_mark = 0;
461
462yyloop:
463    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
464    if (yychar < 0)
465    {
466        yychar = YYLEX;
467        if (yychar < 0) yychar = YYEOF;
468#if YYDEBUG
469        if (yydebug)
470        {
471            if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
472            printf("%sdebug: state %d, reading %d (%s)\n",
473                    YYPREFIX, yystate, yychar, yys);
474        }
475#endif
476    }
477    if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
478            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
479    {
480#if YYDEBUG
481        if (yydebug)
482            printf("%sdebug: state %d, shifting to state %d\n",
483                    YYPREFIX, yystate, yytable[yyn]);
484#endif
485        if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
486        yystate = yytable[yyn];
487        *++yystack.s_mark = yytable[yyn];
488        *++yystack.l_mark = yylval;
489        yychar = YYEMPTY;
490        if (yyerrflag > 0)  --yyerrflag;
491        goto yyloop;
492    }
493    if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
494            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
495    {
496        yyn = yytable[yyn];
497        goto yyreduce;
498    }
499    if (yyerrflag != 0) goto yyinrecovery;
500
501    YYERROR_CALL("syntax error");
502
503    goto yyerrlab; /* redundant goto avoids 'unused label' warning */
504yyerrlab:
505    ++yynerrs;
506
507yyinrecovery:
508    if (yyerrflag < 3)
509    {
510        yyerrflag = 3;
511        for (;;)
512        {
513            if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
514                    yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
515            {
516#if YYDEBUG
517                if (yydebug)
518                    printf("%sdebug: state %d, error recovery shifting\
519 to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
520#endif
521                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
522                yystate = yytable[yyn];
523                *++yystack.s_mark = yytable[yyn];
524                *++yystack.l_mark = yylval;
525                goto yyloop;
526            }
527            else
528            {
529#if YYDEBUG
530                if (yydebug)
531                    printf("%sdebug: error recovery discarding state %d\n",
532                            YYPREFIX, *yystack.s_mark);
533#endif
534                if (yystack.s_mark <= yystack.s_base) goto yyabort;
535                --yystack.s_mark;
536                --yystack.l_mark;
537            }
538        }
539    }
540    else
541    {
542        if (yychar == YYEOF) goto yyabort;
543#if YYDEBUG
544        if (yydebug)
545        {
546            if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
547            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
548                    YYPREFIX, yystate, yychar, yys);
549        }
550#endif
551        yychar = YYEMPTY;
552        goto yyloop;
553    }
554
555yyreduce:
556#if YYDEBUG
557    if (yydebug)
558        printf("%sdebug: state %d, reducing by rule %d (%s)\n",
559                YYPREFIX, yystate, yyn, yyrule[yyn]);
560#endif
561    yym = yylen[yyn];
562    if (yym > 0)
563        yyval = yystack.l_mark[1-yym];
564    else
565        memset(&yyval, 0, sizeof yyval);
566
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            yychar = YYLEX;
648            if (yychar < 0) yychar = YYEOF;
649#if YYDEBUG
650            if (yydebug)
651            {
652                if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
653                printf("%sdebug: state %d, reading %d (%s)\n",
654                        YYPREFIX, YYFINAL, yychar, yys);
655            }
656#endif
657        }
658        if (yychar == YYEOF) goto yyaccept;
659        goto yyloop;
660    }
661    if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
662            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
663        yystate = yytable[yyn];
664    else
665        yystate = yydgoto[yym];
666#if YYDEBUG
667    if (yydebug)
668        printf("%sdebug: after reduction, shifting from state %d \
669to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
670#endif
671    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
672    *++yystack.s_mark = (YYINT) yystate;
673    *++yystack.l_mark = yyval;
674    goto yyloop;
675
676yyoverflow:
677    YYERROR_CALL("yacc stack overflow");
678
679yyabort:
680    yyfreestack(&yystack);
681    return (1);
682
683yyaccept:
684    yyfreestack(&yystack);
685    return (0);
686}
687