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