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_code_provides_parse
19#endif /* yyparse */
20
21#ifndef yylex
22#define yylex      calc_code_provides_lex
23#endif /* yylex */
24
25#ifndef yyerror
26#define yyerror    calc_code_provides_error
27#endif /* yyerror */
28
29#ifndef yychar
30#define yychar     calc_code_provides_char
31#endif /* yychar */
32
33#ifndef yyval
34#define yyval      calc_code_provides_val
35#endif /* yyval */
36
37#ifndef yylval
38#define yylval     calc_code_provides_lval
39#endif /* yylval */
40
41#ifndef yydebug
42#define yydebug    calc_code_provides_debug
43#endif /* yydebug */
44
45#ifndef yynerrs
46#define yynerrs    calc_code_provides_nerrs
47#endif /* yynerrs */
48
49#ifndef yyerrflag
50#define yyerrflag  calc_code_provides_errflag
51#endif /* yyerrflag */
52
53#ifndef yylhs
54#define yylhs      calc_code_provides_lhs
55#endif /* yylhs */
56
57#ifndef yylen
58#define yylen      calc_code_provides_len
59#endif /* yylen */
60
61#ifndef yydefred
62#define yydefred   calc_code_provides_defred
63#endif /* yydefred */
64
65#ifndef yydgoto
66#define yydgoto    calc_code_provides_dgoto
67#endif /* yydgoto */
68
69#ifndef yysindex
70#define yysindex   calc_code_provides_sindex
71#endif /* yysindex */
72
73#ifndef yyrindex
74#define yyrindex   calc_code_provides_rindex
75#endif /* yyrindex */
76
77#ifndef yygindex
78#define yygindex   calc_code_provides_gindex
79#endif /* yygindex */
80
81#ifndef yytable
82#define yytable    calc_code_provides_table
83#endif /* yytable */
84
85#ifndef yycheck
86#define yycheck    calc_code_provides_check
87#endif /* yycheck */
88
89#ifndef yyname
90#define yyname     calc_code_provides_name
91#endif /* yyname */
92
93#ifndef yyrule
94#define yyrule     calc_code_provides_rule
95#endif /* yyrule */
96#define YYPREFIX "calc_code_provides_"
97
98#define YYPURE 0
99
100#line 5 "calc_code_provides.y"
101# include <stdio.h>
102# include <ctype.h>
103
104int regs[26];
105int base;
106
107extern int yylex(void);
108static void yyerror(const char *s);
109
110#line 111 "calc_code_provides.tab.c"
111
112#if ! defined(YYSTYPE) && ! defined(YYSTYPE_IS_DECLARED)
113/* Default: YYSTYPE is the semantic value type. */
114typedef int YYSTYPE;
115# define YYSTYPE_IS_DECLARED 1
116#endif
117
118/* compatibility with bison */
119#ifdef YYPARSE_PARAM
120/* compatibility with FreeBSD */
121# ifdef YYPARSE_PARAM_TYPE
122#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
123# else
124#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
125# endif
126#else
127# define YYPARSE_DECL() yyparse(void)
128#endif
129
130/* Parameters sent to lex. */
131#ifdef YYLEX_PARAM
132# define YYLEX_DECL() yylex(void *YYLEX_PARAM)
133# define YYLEX yylex(YYLEX_PARAM)
134#else
135# define YYLEX_DECL() yylex(void)
136# define YYLEX yylex()
137#endif
138
139/* Parameters sent to yyerror. */
140#ifndef YYERROR_DECL
141#define YYERROR_DECL() yyerror(const char *s)
142#endif
143#ifndef YYERROR_CALL
144#define YYERROR_CALL(msg) yyerror(msg)
145#endif
146
147extern int YYPARSE_DECL();
148
149#define DIGIT 257
150#define LETTER 258
151#define UMINUS 259
152#define YYERRCODE 256
153typedef int YYINT;
154static const YYINT calc_code_provides_lhs[] = {          -1,
155    0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
156    2,    2,    2,    2,    2,    2,    3,    3,
157};
158static const YYINT calc_code_provides_len[] = {           2,
159    0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
160    3,    3,    3,    2,    1,    1,    1,    2,
161};
162static const YYINT calc_code_provides_defred[] = {        1,
163    0,    0,   17,    0,    0,    0,    0,    0,    0,    3,
164    0,   15,   14,    0,    2,    0,    0,    0,    0,    0,
165    0,    0,   18,    0,    6,    0,    0,    0,    0,    9,
166   10,   11,
167};
168static const YYINT calc_code_provides_dgoto[] = {         1,
169    7,    8,    9,
170};
171static const YYINT calc_code_provides_sindex[] = {        0,
172  -40,   -7,    0,  -55,  -38,  -38,    1,  -29, -247,    0,
173  -38,    0,    0,   22,    0,  -38,  -38,  -38,  -38,  -38,
174  -38,  -38,    0,  -29,    0,   51,   60,  -20,  -20,    0,
175    0,    0,
176};
177static const YYINT calc_code_provides_rindex[] = {        0,
178    0,    0,    0,    2,    0,    0,    0,    9,   -9,    0,
179    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
180    0,    0,    0,   10,    0,   -6,   14,    5,   13,    0,
181    0,    0,
182};
183static const YYINT calc_code_provides_gindex[] = {        0,
184    0,   65,    0,
185};
186#define YYTABLESIZE 220
187static const YYINT calc_code_provides_table[] = {         6,
188   16,    6,   10,   13,    5,   11,    5,   22,   17,   23,
189   15,   15,   20,   18,    7,   19,   22,   21,    4,    5,
190    0,   20,    8,   12,    0,    0,   21,   16,   16,    0,
191    0,   16,   16,   16,   13,   16,    0,   16,   15,   15,
192    0,    0,    7,   15,   15,    7,   15,    7,   15,    7,
193    8,   12,    0,    8,   12,    8,    0,    8,   22,   17,
194    0,    0,   25,   20,   18,    0,   19,    0,   21,   13,
195   14,    0,    0,    0,    0,   24,    0,    0,    0,    0,
196   26,   27,   28,   29,   30,   31,   32,   22,   17,    0,
197    0,    0,   20,   18,   16,   19,   22,   21,    0,    0,
198    0,   20,   18,    0,   19,    0,   21,    0,    0,    0,
199    0,    0,    0,    0,   16,    0,    0,   13,    0,    0,
200    0,    0,    0,    0,    0,   15,    0,    0,    7,    0,
201    0,    0,    0,    0,    0,    0,    8,   12,    0,    0,
202    0,    0,    0,    0,    0,   16,    0,    0,    0,    0,
203    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
204    0,    0,    0,    0,    0,    0,    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,    2,    3,    4,    3,   12,
210};
211static const YYINT calc_code_provides_check[] = {        40,
212   10,   40,   10,   10,   45,   61,   45,   37,   38,  257,
213   10,   10,   42,   43,   10,   45,   37,   47,   10,   10,
214   -1,   42,   10,   10,   -1,   -1,   47,   37,   38,   -1,
215   -1,   41,   42,   43,   41,   45,   -1,   47,   37,   38,
216   -1,   -1,   38,   42,   43,   41,   45,   43,   47,   45,
217   38,   38,   -1,   41,   41,   43,   -1,   45,   37,   38,
218   -1,   -1,   41,   42,   43,   -1,   45,   -1,   47,    5,
219    6,   -1,   -1,   -1,   -1,   11,   -1,   -1,   -1,   -1,
220   16,   17,   18,   19,   20,   21,   22,   37,   38,   -1,
221   -1,   -1,   42,   43,  124,   45,   37,   47,   -1,   -1,
222   -1,   42,   43,   -1,   45,   -1,   47,   -1,   -1,   -1,
223   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,   -1,
224   -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,
225   -1,   -1,   -1,   -1,   -1,   -1,  124,  124,   -1,   -1,
226   -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,   -1,   -1,
227   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
228   -1,   -1,   -1,   -1,   -1,   -1,   -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,  256,  257,  258,  257,  258,
234};
235#define YYFINAL 1
236#ifndef YYDEBUG
237#define YYDEBUG 0
238#endif
239#define YYMAXTOKEN 259
240#define YYUNDFTOKEN 265
241#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
242#if YYDEBUG
243static const char *const calc_code_provides_name[] = {
244
245"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,
2460,0,0,0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,
2470,0,0,0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,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,0,0,0,0,0,0,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,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,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,"DIGIT","LETTER","UMINUS",0,0,0,0,0,"illegal-symbol",
253};
254static const char *const calc_code_provides_rule[] = {
255"$accept : list",
256"list :",
257"list : list stat '\\n'",
258"list : list error '\\n'",
259"stat : expr",
260"stat : LETTER '=' expr",
261"expr : '(' expr ')'",
262"expr : expr '+' expr",
263"expr : 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",
270"expr : LETTER",
271"expr : number",
272"number : DIGIT",
273"number : number DIGIT",
274
275};
276#endif
277
278#if YYDEBUG
279int      yydebug;
280#endif
281
282int      yyerrflag;
283int      yychar;
284YYSTYPE  yyval;
285YYSTYPE  yylval;
286int      yynerrs;
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
314/* %code "provides" block start */
315#line 1 "calc_code_provides.y"
316/* CODE-PROVIDES */
317#line 2 "calc_code_provides.y"
318/* CODE-PROVIDES2 */
319/* %code "provides" block end */
320#line 321 "calc_code_provides.tab.c"
321#line 69 "calc_code_provides.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_provides.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_provides.y"
564	{  yyerrok ; }
565break;
566case 4:
567#line 35 "calc_code_provides.y"
568	{  printf("%d\n",yystack.l_mark[0]);}
569break;
570case 5:
571#line 37 "calc_code_provides.y"
572	{  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
573break;
574case 6:
575#line 41 "calc_code_provides.y"
576	{  yyval = yystack.l_mark[-1]; }
577break;
578case 7:
579#line 43 "calc_code_provides.y"
580	{  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
581break;
582case 8:
583#line 45 "calc_code_provides.y"
584	{  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
585break;
586case 9:
587#line 47 "calc_code_provides.y"
588	{  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
589break;
590case 10:
591#line 49 "calc_code_provides.y"
592	{  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
593break;
594case 11:
595#line 51 "calc_code_provides.y"
596	{  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
597break;
598case 12:
599#line 53 "calc_code_provides.y"
600	{  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
601break;
602case 13:
603#line 55 "calc_code_provides.y"
604	{  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
605break;
606case 14:
607#line 57 "calc_code_provides.y"
608	{  yyval = - yystack.l_mark[0]; }
609break;
610case 15:
611#line 59 "calc_code_provides.y"
612	{  yyval = regs[yystack.l_mark[0]]; }
613break;
614case 17:
615#line 64 "calc_code_provides.y"
616	{  yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
617break;
618case 18:
619#line 66 "calc_code_provides.y"
620	{  yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
621break;
622#line 623 "calc_code_provides.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