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