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