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