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