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