1/*	$NetBSD: calc_code_imports.tab.c,v 1.1.1.1 2021/02/20 20:30:08 christos Exp $	*/
2
3/* original parser id follows */
4/* yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93" */
5/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
6
7#define YYBYACC 1
8#define YYMAJOR 2
9#define YYMINOR 0
10#define YYCHECK "yyyymmdd"
11
12#define YYEMPTY        (-1)
13#define yyclearin      (yychar = YYEMPTY)
14#define yyerrok        (yyerrflag = 0)
15#define YYRECOVERING() (yyerrflag != 0)
16#define YYENOMEM       (-2)
17#define YYEOF          0
18
19#ifndef yyparse
20#define yyparse    calc_code_imports_parse
21#endif /* yyparse */
22
23#ifndef yylex
24#define yylex      calc_code_imports_lex
25#endif /* yylex */
26
27#ifndef yyerror
28#define yyerror    calc_code_imports_error
29#endif /* yyerror */
30
31#ifndef yychar
32#define yychar     calc_code_imports_char
33#endif /* yychar */
34
35#ifndef yyval
36#define yyval      calc_code_imports_val
37#endif /* yyval */
38
39#ifndef yylval
40#define yylval     calc_code_imports_lval
41#endif /* yylval */
42
43#ifndef yydebug
44#define yydebug    calc_code_imports_debug
45#endif /* yydebug */
46
47#ifndef yynerrs
48#define yynerrs    calc_code_imports_nerrs
49#endif /* yynerrs */
50
51#ifndef yyerrflag
52#define yyerrflag  calc_code_imports_errflag
53#endif /* yyerrflag */
54
55#ifndef yylhs
56#define yylhs      calc_code_imports_lhs
57#endif /* yylhs */
58
59#ifndef yylen
60#define yylen      calc_code_imports_len
61#endif /* yylen */
62
63#ifndef yydefred
64#define yydefred   calc_code_imports_defred
65#endif /* yydefred */
66
67#ifndef yydgoto
68#define yydgoto    calc_code_imports_dgoto
69#endif /* yydgoto */
70
71#ifndef yysindex
72#define yysindex   calc_code_imports_sindex
73#endif /* yysindex */
74
75#ifndef yyrindex
76#define yyrindex   calc_code_imports_rindex
77#endif /* yyrindex */
78
79#ifndef yygindex
80#define yygindex   calc_code_imports_gindex
81#endif /* yygindex */
82
83#ifndef yytable
84#define yytable    calc_code_imports_table
85#endif /* yytable */
86
87#ifndef yycheck
88#define yycheck    calc_code_imports_check
89#endif /* yycheck */
90
91#ifndef yyname
92#define yyname     calc_code_imports_name
93#endif /* yyname */
94
95#ifndef yyrule
96#define yyrule     calc_code_imports_rule
97#endif /* yyrule */
98#define YYPREFIX "calc_code_imports_"
99
100#define YYPURE 0
101
102#line 5 "calc_code_imports.y"
103# include <stdio.h>
104# include <ctype.h>
105
106int regs[26];
107int base;
108
109extern int yylex(void);
110static void yyerror(const char *s);
111
112#line 111 "calc_code_imports.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(void)
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(void)
138# define YYLEX yylex()
139#endif
140
141/* Parameters sent to yyerror. */
142#ifndef YYERROR_DECL
143#define YYERROR_DECL() yyerror(const char *s)
144#endif
145#ifndef YYERROR_CALL
146#define YYERROR_CALL(msg) yyerror(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 short YYINT;
156static const YYINT calc_code_imports_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 calc_code_imports_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 calc_code_imports_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 calc_code_imports_dgoto[] = {          1,
171    7,    8,    9,
172};
173static const YYINT calc_code_imports_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 calc_code_imports_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 calc_code_imports_gindex[] = {         0,
186    0,   65,    0,
187};
188#define YYTABLESIZE 220
189static const YYINT calc_code_imports_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 calc_code_imports_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 calc_code_imports_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 calc_code_imports_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
280#if YYDEBUG
281int      yydebug;
282#endif
283
284int      yyerrflag;
285int      yychar;
286YYSTYPE  yyval;
287YYSTYPE  yylval;
288int      yynerrs;
289
290/* define the initial stack-sizes */
291#ifdef YYSTACKSIZE
292#undef YYMAXDEPTH
293#define YYMAXDEPTH  YYSTACKSIZE
294#else
295#ifdef YYMAXDEPTH
296#define YYSTACKSIZE YYMAXDEPTH
297#else
298#define YYSTACKSIZE 10000
299#define YYMAXDEPTH  10000
300#endif
301#endif
302
303#define YYINITSTACKSIZE 200
304
305typedef struct {
306    unsigned stacksize;
307    YYINT    *s_base;
308    YYINT    *s_mark;
309    YYINT    *s_last;
310    YYSTYPE  *l_base;
311    YYSTYPE  *l_mark;
312} YYSTACKDATA;
313/* variables for the parser stack */
314static YYSTACKDATA yystack;
315#line 69 "calc_code_imports.y"
316 /* start of programs */
317
318int
319main (void)
320{
321    while(!feof(stdin)) {
322	yyparse();
323    }
324    return 0;
325}
326
327static void
328yyerror(const char *s)
329{
330    fprintf(stderr, "%s\n", s);
331}
332
333int
334yylex(void)
335{
336	/* lexical analysis routine */
337	/* returns LETTER for a lower case letter, yylval = 0 through 25 */
338	/* return DIGIT for a digit, yylval = 0 through 9 */
339	/* all other characters are returned immediately */
340
341    int c;
342
343    while( (c=getchar()) == ' ' )   { /* skip blanks */ }
344
345    /* c is now nonblank */
346
347    if( islower( c )) {
348	yylval = c - 'a';
349	return ( LETTER );
350    }
351    if( isdigit( c )) {
352	yylval = c - '0';
353	return ( DIGIT );
354    }
355    return( c );
356}
357#line 356 "calc_code_imports.tab.c"
358
359#if YYDEBUG
360#include <stdio.h>	/* needed for printf */
361#endif
362
363#include <stdlib.h>	/* needed for malloc, etc */
364#include <string.h>	/* needed for memset */
365
366/* allocate initial stack or double stack size, up to YYMAXDEPTH */
367static int yygrowstack(YYSTACKDATA *data)
368{
369    int i;
370    unsigned newsize;
371    YYINT *newss;
372    YYSTYPE *newvs;
373
374    if ((newsize = data->stacksize) == 0)
375        newsize = YYINITSTACKSIZE;
376    else if (newsize >= YYMAXDEPTH)
377        return YYENOMEM;
378    else if ((newsize *= 2) > YYMAXDEPTH)
379        newsize = YYMAXDEPTH;
380
381    i = (int) (data->s_mark - data->s_base);
382    newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
383    if (newss == 0)
384        return YYENOMEM;
385
386    data->s_base = newss;
387    data->s_mark = newss + i;
388
389    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
390    if (newvs == 0)
391        return YYENOMEM;
392
393    data->l_base = newvs;
394    data->l_mark = newvs + i;
395
396    data->stacksize = newsize;
397    data->s_last = data->s_base + newsize - 1;
398    return 0;
399}
400
401#if YYPURE || defined(YY_NO_LEAKS)
402static void yyfreestack(YYSTACKDATA *data)
403{
404    free(data->s_base);
405    free(data->l_base);
406    memset(data, 0, sizeof(*data));
407}
408#else
409#define yyfreestack(data) /* nothing */
410#endif
411
412#define YYABORT  goto yyabort
413#define YYREJECT goto yyabort
414#define YYACCEPT goto yyaccept
415#define YYERROR  goto yyerrlab
416
417int
418YYPARSE_DECL()
419{
420    int yym, yyn, yystate;
421#if YYDEBUG
422    const char *yys;
423
424    if ((yys = getenv("YYDEBUG")) != 0)
425    {
426        yyn = *yys;
427        if (yyn >= '0' && yyn <= '9')
428            yydebug = yyn - '0';
429    }
430#endif
431
432    yym = 0;
433    yyn = 0;
434    yynerrs = 0;
435    yyerrflag = 0;
436    yychar = YYEMPTY;
437    yystate = 0;
438
439#if YYPURE
440    memset(&yystack, 0, sizeof(yystack));
441#endif
442
443    if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
444    yystack.s_mark = yystack.s_base;
445    yystack.l_mark = yystack.l_base;
446    yystate = 0;
447    *yystack.s_mark = 0;
448
449yyloop:
450    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
451    if (yychar < 0)
452    {
453        yychar = YYLEX;
454        if (yychar < 0) yychar = YYEOF;
455#if YYDEBUG
456        if (yydebug)
457        {
458            if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
459            printf("%sdebug: state %d, reading %d (%s)\n",
460                    YYPREFIX, yystate, yychar, yys);
461        }
462#endif
463    }
464    if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
465            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
466    {
467#if YYDEBUG
468        if (yydebug)
469            printf("%sdebug: state %d, shifting to state %d\n",
470                    YYPREFIX, yystate, yytable[yyn]);
471#endif
472        if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
473        yystate = yytable[yyn];
474        *++yystack.s_mark = yytable[yyn];
475        *++yystack.l_mark = yylval;
476        yychar = YYEMPTY;
477        if (yyerrflag > 0)  --yyerrflag;
478        goto yyloop;
479    }
480    if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
481            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
482    {
483        yyn = yytable[yyn];
484        goto yyreduce;
485    }
486    if (yyerrflag != 0) goto yyinrecovery;
487
488    YYERROR_CALL("syntax error");
489
490    goto yyerrlab; /* redundant goto avoids 'unused label' warning */
491yyerrlab:
492    ++yynerrs;
493
494yyinrecovery:
495    if (yyerrflag < 3)
496    {
497        yyerrflag = 3;
498        for (;;)
499        {
500            if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
501                    yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
502            {
503#if YYDEBUG
504                if (yydebug)
505                    printf("%sdebug: state %d, error recovery shifting\
506 to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
507#endif
508                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
509                yystate = yytable[yyn];
510                *++yystack.s_mark = yytable[yyn];
511                *++yystack.l_mark = yylval;
512                goto yyloop;
513            }
514            else
515            {
516#if YYDEBUG
517                if (yydebug)
518                    printf("%sdebug: error recovery discarding state %d\n",
519                            YYPREFIX, *yystack.s_mark);
520#endif
521                if (yystack.s_mark <= yystack.s_base) goto yyabort;
522                --yystack.s_mark;
523                --yystack.l_mark;
524            }
525        }
526    }
527    else
528    {
529        if (yychar == YYEOF) goto yyabort;
530#if YYDEBUG
531        if (yydebug)
532        {
533            if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
534            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
535                    YYPREFIX, yystate, yychar, yys);
536        }
537#endif
538        yychar = YYEMPTY;
539        goto yyloop;
540    }
541
542yyreduce:
543#if YYDEBUG
544    if (yydebug)
545        printf("%sdebug: state %d, reducing by rule %d (%s)\n",
546                YYPREFIX, yystate, yyn, yyrule[yyn]);
547#endif
548    yym = yylen[yyn];
549    if (yym > 0)
550        yyval = yystack.l_mark[1-yym];
551    else
552        memset(&yyval, 0, sizeof yyval);
553
554    switch (yyn)
555    {
556case 3:
557#line 31 "calc_code_imports.y"
558	{  yyerrok ; }
559break;
560case 4:
561#line 35 "calc_code_imports.y"
562	{  printf("%d\n",yystack.l_mark[0]);}
563break;
564case 5:
565#line 37 "calc_code_imports.y"
566	{  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
567break;
568case 6:
569#line 41 "calc_code_imports.y"
570	{  yyval = yystack.l_mark[-1]; }
571break;
572case 7:
573#line 43 "calc_code_imports.y"
574	{  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
575break;
576case 8:
577#line 45 "calc_code_imports.y"
578	{  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
579break;
580case 9:
581#line 47 "calc_code_imports.y"
582	{  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
583break;
584case 10:
585#line 49 "calc_code_imports.y"
586	{  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
587break;
588case 11:
589#line 51 "calc_code_imports.y"
590	{  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
591break;
592case 12:
593#line 53 "calc_code_imports.y"
594	{  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
595break;
596case 13:
597#line 55 "calc_code_imports.y"
598	{  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
599break;
600case 14:
601#line 57 "calc_code_imports.y"
602	{  yyval = - yystack.l_mark[0]; }
603break;
604case 15:
605#line 59 "calc_code_imports.y"
606	{  yyval = regs[yystack.l_mark[0]]; }
607break;
608case 17:
609#line 64 "calc_code_imports.y"
610	{  yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
611break;
612case 18:
613#line 66 "calc_code_imports.y"
614	{  yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
615break;
616#line 615 "calc_code_imports.tab.c"
617    }
618    yystack.s_mark -= yym;
619    yystate = *yystack.s_mark;
620    yystack.l_mark -= yym;
621    yym = yylhs[yyn];
622    if (yystate == 0 && yym == 0)
623    {
624#if YYDEBUG
625        if (yydebug)
626            printf("%sdebug: after reduction, shifting from state 0 to\
627 state %d\n", YYPREFIX, YYFINAL);
628#endif
629        yystate = YYFINAL;
630        *++yystack.s_mark = YYFINAL;
631        *++yystack.l_mark = yyval;
632        if (yychar < 0)
633        {
634            yychar = YYLEX;
635            if (yychar < 0) yychar = YYEOF;
636#if YYDEBUG
637            if (yydebug)
638            {
639                if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
640                printf("%sdebug: state %d, reading %d (%s)\n",
641                        YYPREFIX, YYFINAL, yychar, yys);
642            }
643#endif
644        }
645        if (yychar == YYEOF) goto yyaccept;
646        goto yyloop;
647    }
648    if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
649            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
650        yystate = yytable[yyn];
651    else
652        yystate = yydgoto[yym];
653#if YYDEBUG
654    if (yydebug)
655        printf("%sdebug: after reduction, shifting from state %d \
656to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
657#endif
658    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
659    *++yystack.s_mark = (YYINT) yystate;
660    *++yystack.l_mark = yyval;
661    goto yyloop;
662
663yyoverflow:
664    YYERROR_CALL("yacc stack overflow");
665
666yyabort:
667    yyfreestack(&yystack);
668    return (1);
669
670yyaccept:
671    yyfreestack(&yystack);
672    return (0);
673}
674