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