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