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
288#if YYDEBUG
289int      yydebug;
290#endif
291
292/* define the initial stack-sizes */
293#ifdef YYSTACKSIZE
294#undef YYMAXDEPTH
295#define YYMAXDEPTH  YYSTACKSIZE
296#else
297#ifdef YYMAXDEPTH
298#define YYSTACKSIZE YYMAXDEPTH
299#else
300#define YYSTACKSIZE 10000
301#define YYMAXDEPTH  10000
302#endif
303#endif
304
305#define YYINITSTACKSIZE 200
306
307typedef struct {
308    unsigned stacksize;
309    YYINT    *s_base;
310    YYINT    *s_mark;
311    YYINT    *s_last;
312    YYSTYPE  *l_base;
313    YYSTYPE  *l_mark;
314} YYSTACKDATA;
315#line 72 "pure_calc.y"
316 /* start of programs */
317
318#ifdef YYBYACC
319static int YYLEX_DECL();
320#endif
321
322int
323main (void)
324{
325    while(!feof(stdin)) {
326	yyparse();
327    }
328    return 0;
329}
330
331static void
332YYERROR_DECL()
333{
334    fprintf(stderr, "%s\n", s);
335}
336
337int
338YYLEX_DECL()
339{
340	/* lexical analysis routine */
341	/* returns LETTER for a lower case letter, yylval = 0 through 25 */
342	/* return DIGIT for a digit, yylval = 0 through 9 */
343	/* all other characters are returned immediately */
344
345    int c;
346
347    while( (c=getchar()) == ' ' )   { /* skip blanks */ }
348
349    /* c is now nonblank */
350
351    if( islower( c )) {
352	*yylval = c - 'a';
353	return ( LETTER );
354    }
355    if( isdigit( c )) {
356	*yylval = c - '0';
357	return ( DIGIT );
358    }
359    return( c );
360}
361#line 362 "pure_calc.tab.c"
362
363#if YYDEBUG
364#include <stdio.h>	/* needed for printf */
365#endif
366
367#include <stdlib.h>	/* needed for malloc, etc */
368#include <string.h>	/* needed for memset */
369
370/* allocate initial stack or double stack size, up to YYMAXDEPTH */
371static int yygrowstack(YYSTACKDATA *data)
372{
373    int i;
374    unsigned newsize;
375    YYINT *newss;
376    YYSTYPE *newvs;
377
378    if ((newsize = data->stacksize) == 0)
379        newsize = YYINITSTACKSIZE;
380    else if (newsize >= YYMAXDEPTH)
381        return YYENOMEM;
382    else if ((newsize *= 2) > YYMAXDEPTH)
383        newsize = YYMAXDEPTH;
384
385    i = (int) (data->s_mark - data->s_base);
386    newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
387    if (newss == 0)
388        return YYENOMEM;
389
390    data->s_base = newss;
391    data->s_mark = newss + i;
392
393    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
394    if (newvs == 0)
395        return YYENOMEM;
396
397    data->l_base = newvs;
398    data->l_mark = newvs + i;
399
400    data->stacksize = newsize;
401    data->s_last = data->s_base + newsize - 1;
402    return 0;
403}
404
405#if YYPURE || defined(YY_NO_LEAKS)
406static void yyfreestack(YYSTACKDATA *data)
407{
408    free(data->s_base);
409    free(data->l_base);
410    memset(data, 0, sizeof(*data));
411}
412#else
413#define yyfreestack(data) /* nothing */
414#endif
415
416#define YYABORT  goto yyabort
417#define YYREJECT goto yyabort
418#define YYACCEPT goto yyaccept
419#define YYERROR  goto yyerrlab
420
421int
422YYPARSE_DECL()
423{
424    int      yyerrflag;
425    int      yychar;
426    YYSTYPE  yyval;
427    YYSTYPE  yylval;
428    int      yynerrs;
429
430    /* variables for the parser stack */
431    YYSTACKDATA yystack;
432    int yym, yyn, yystate;
433#if YYDEBUG
434    const char *yys;
435
436    if ((yys = getenv("YYDEBUG")) != 0)
437    {
438        yyn = *yys;
439        if (yyn >= '0' && yyn <= '9')
440            yydebug = yyn - '0';
441    }
442#endif
443
444    memset(&yyval,  0, sizeof(yyval));
445    memset(&yylval, 0, sizeof(yylval));
446
447    yym = 0;
448    yyn = 0;
449    yynerrs = 0;
450    yyerrflag = 0;
451    yychar = YYEMPTY;
452    yystate = 0;
453
454#if YYPURE
455    memset(&yystack, 0, sizeof(yystack));
456#endif
457
458    if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
459    yystack.s_mark = yystack.s_base;
460    yystack.l_mark = yystack.l_base;
461    yystate = 0;
462    *yystack.s_mark = 0;
463
464yyloop:
465    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
466    if (yychar < 0)
467    {
468        yychar = YYLEX;
469        if (yychar < 0) yychar = YYEOF;
470#if YYDEBUG
471        if (yydebug)
472        {
473            if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
474            printf("%sdebug: state %d, reading %d (%s)\n",
475                    YYPREFIX, yystate, yychar, yys);
476        }
477#endif
478    }
479    if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
480            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
481    {
482#if YYDEBUG
483        if (yydebug)
484            printf("%sdebug: state %d, shifting to state %d\n",
485                    YYPREFIX, yystate, yytable[yyn]);
486#endif
487        if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
488        yystate = yytable[yyn];
489        *++yystack.s_mark = yytable[yyn];
490        *++yystack.l_mark = yylval;
491        yychar = YYEMPTY;
492        if (yyerrflag > 0)  --yyerrflag;
493        goto yyloop;
494    }
495    if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
496            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
497    {
498        yyn = yytable[yyn];
499        goto yyreduce;
500    }
501    if (yyerrflag != 0) goto yyinrecovery;
502
503    YYERROR_CALL("syntax error");
504
505    goto yyerrlab; /* redundant goto avoids 'unused label' warning */
506yyerrlab:
507    ++yynerrs;
508
509yyinrecovery:
510    if (yyerrflag < 3)
511    {
512        yyerrflag = 3;
513        for (;;)
514        {
515            if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
516                    yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
517            {
518#if YYDEBUG
519                if (yydebug)
520                    printf("%sdebug: state %d, error recovery shifting\
521 to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
522#endif
523                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
524                yystate = yytable[yyn];
525                *++yystack.s_mark = yytable[yyn];
526                *++yystack.l_mark = yylval;
527                goto yyloop;
528            }
529            else
530            {
531#if YYDEBUG
532                if (yydebug)
533                    printf("%sdebug: error recovery discarding state %d\n",
534                            YYPREFIX, *yystack.s_mark);
535#endif
536                if (yystack.s_mark <= yystack.s_base) goto yyabort;
537                --yystack.s_mark;
538                --yystack.l_mark;
539            }
540        }
541    }
542    else
543    {
544        if (yychar == YYEOF) goto yyabort;
545#if YYDEBUG
546        if (yydebug)
547        {
548            if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
549            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
550                    YYPREFIX, yystate, yychar, yys);
551        }
552#endif
553        yychar = YYEMPTY;
554        goto yyloop;
555    }
556
557yyreduce:
558#if YYDEBUG
559    if (yydebug)
560        printf("%sdebug: state %d, reducing by rule %d (%s)\n",
561                YYPREFIX, yystate, yyn, yyrule[yyn]);
562#endif
563    yym = yylen[yyn];
564    if (yym > 0)
565        yyval = yystack.l_mark[1-yym];
566    else
567        memset(&yyval, 0, sizeof yyval);
568
569    switch (yyn)
570    {
571case 3:
572#line 34 "pure_calc.y"
573	{  yyerrok ; }
574break;
575case 4:
576#line 38 "pure_calc.y"
577	{  printf("%d\n",yystack.l_mark[0]);}
578break;
579case 5:
580#line 40 "pure_calc.y"
581	{  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
582break;
583case 6:
584#line 44 "pure_calc.y"
585	{  yyval = yystack.l_mark[-1]; }
586break;
587case 7:
588#line 46 "pure_calc.y"
589	{  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
590break;
591case 8:
592#line 48 "pure_calc.y"
593	{  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
594break;
595case 9:
596#line 50 "pure_calc.y"
597	{  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
598break;
599case 10:
600#line 52 "pure_calc.y"
601	{  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
602break;
603case 11:
604#line 54 "pure_calc.y"
605	{  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
606break;
607case 12:
608#line 56 "pure_calc.y"
609	{  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
610break;
611case 13:
612#line 58 "pure_calc.y"
613	{  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
614break;
615case 14:
616#line 60 "pure_calc.y"
617	{  yyval = - yystack.l_mark[0]; }
618break;
619case 15:
620#line 62 "pure_calc.y"
621	{  yyval = regs[yystack.l_mark[0]]; }
622break;
623case 17:
624#line 67 "pure_calc.y"
625	{  yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
626break;
627case 18:
628#line 69 "pure_calc.y"
629	{  yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
630break;
631#line 632 "pure_calc.tab.c"
632    }
633    yystack.s_mark -= yym;
634    yystate = *yystack.s_mark;
635    yystack.l_mark -= yym;
636    yym = yylhs[yyn];
637    if (yystate == 0 && yym == 0)
638    {
639#if YYDEBUG
640        if (yydebug)
641            printf("%sdebug: after reduction, shifting from state 0 to\
642 state %d\n", YYPREFIX, YYFINAL);
643#endif
644        yystate = YYFINAL;
645        *++yystack.s_mark = YYFINAL;
646        *++yystack.l_mark = yyval;
647        if (yychar < 0)
648        {
649            yychar = YYLEX;
650            if (yychar < 0) yychar = YYEOF;
651#if YYDEBUG
652            if (yydebug)
653            {
654                if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
655                printf("%sdebug: state %d, reading %d (%s)\n",
656                        YYPREFIX, YYFINAL, yychar, yys);
657            }
658#endif
659        }
660        if (yychar == YYEOF) goto yyaccept;
661        goto yyloop;
662    }
663    if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
664            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
665        yystate = yytable[yyn];
666    else
667        yystate = yydgoto[yym];
668#if YYDEBUG
669    if (yydebug)
670        printf("%sdebug: after reduction, shifting from state %d \
671to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
672#endif
673    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
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