1/*	$NetBSD$	*/
2
3#ifndef lint
4static const char yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93";
5#endif
6
7#define YYBYACC 1
8#define YYMAJOR 1
9#define YYMINOR 9
10
11#define YYEMPTY        (-1)
12#define yyclearin      (yychar = YYEMPTY)
13#define yyerrok        (yyerrflag = 0)
14#define YYRECOVERING() (yyerrflag != 0)
15
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#line 103 "calc2.tab.c"
105
106#ifndef YYSTYPE
107typedef int YYSTYPE;
108#endif
109
110/* compatibility with bison */
111#ifdef YYPARSE_PARAM
112/* compatibility with FreeBSD */
113# ifdef YYPARSE_PARAM_TYPE
114#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
115# else
116#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
117# endif
118#else
119# define YYPARSE_DECL() yyparse(int  regs[26], int * base)
120#endif
121
122/* Parameters sent to lex. */
123#ifdef YYLEX_PARAM
124# define YYLEX_DECL() yylex(void *YYLEX_PARAM)
125# define YYLEX yylex(YYLEX_PARAM)
126#else
127# define YYLEX_DECL() yylex(int * base)
128# define YYLEX yylex(base)
129#endif
130
131/* Parameters sent to yyerror. */
132#define YYERROR_DECL() yyerror(int  regs[26], int * base, const char *s)
133#define YYERROR_CALL(msg) yyerror(regs, base, msg)
134
135extern int YYPARSE_DECL();
136
137#define DIGIT 257
138#define LETTER 258
139#define UMINUS 259
140#define YYERRCODE 256
141static const short calc2_lhs[] = {                       -1,
142    0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
143    2,    2,    2,    2,    2,    2,    3,    3,
144};
145static const short calc2_len[] = {                        2,
146    0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
147    3,    3,    3,    2,    1,    1,    1,    2,
148};
149static const short calc2_defred[] = {                     1,
150    0,    0,   17,    0,    0,    0,    0,    0,    0,    3,
151    0,   15,   14,    0,    2,    0,    0,    0,    0,    0,
152    0,    0,   18,    0,    6,    0,    0,    0,    0,    9,
153   10,   11,
154};
155static const short calc2_dgoto[] = {                      1,
156    7,    8,    9,
157};
158static const short calc2_sindex[] = {                     0,
159  -40,   -7,    0,  -55,  -38,  -38,    1,  -29, -247,    0,
160  -38,    0,    0,   22,    0,  -38,  -38,  -38,  -38,  -38,
161  -38,  -38,    0,  -29,    0,   51,   60,  -20,  -20,    0,
162    0,    0,
163};
164static const short calc2_rindex[] = {                     0,
165    0,    0,    0,    2,    0,    0,    0,    9,   -9,    0,
166    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
167    0,    0,    0,   10,    0,   -6,   14,    5,   13,    0,
168    0,    0,
169};
170static const short calc2_gindex[] = {                     0,
171    0,   65,    0,
172};
173#define YYTABLESIZE 220
174static const short calc2_table[] = {                      6,
175   16,    6,   10,   13,    5,   11,    5,   22,   17,   23,
176   15,   15,   20,   18,    7,   19,   22,   21,    4,    5,
177    0,   20,    8,   12,    0,    0,   21,   16,   16,    0,
178    0,   16,   16,   16,   13,   16,    0,   16,   15,   15,
179    0,    0,    7,   15,   15,    7,   15,    7,   15,    7,
180    8,   12,    0,    8,   12,    8,    0,    8,   22,   17,
181    0,    0,   25,   20,   18,    0,   19,    0,   21,   13,
182   14,    0,    0,    0,    0,   24,    0,    0,    0,    0,
183   26,   27,   28,   29,   30,   31,   32,   22,   17,    0,
184    0,    0,   20,   18,   16,   19,   22,   21,    0,    0,
185    0,   20,   18,    0,   19,    0,   21,    0,    0,    0,
186    0,    0,    0,    0,   16,    0,    0,   13,    0,    0,
187    0,    0,    0,    0,    0,   15,    0,    0,    7,    0,
188    0,    0,    0,    0,    0,    0,    8,   12,    0,    0,
189    0,    0,    0,    0,    0,   16,    0,    0,    0,    0,
190    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
191    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
192    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
193    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
194    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
195    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
196    0,    0,    0,    0,    0,    2,    3,    4,    3,   12,
197};
198static const short calc2_check[] = {                     40,
199   10,   40,   10,   10,   45,   61,   45,   37,   38,  257,
200   10,   10,   42,   43,   10,   45,   37,   47,   10,   10,
201   -1,   42,   10,   10,   -1,   -1,   47,   37,   38,   -1,
202   -1,   41,   42,   43,   41,   45,   -1,   47,   37,   38,
203   -1,   -1,   38,   42,   43,   41,   45,   43,   47,   45,
204   38,   38,   -1,   41,   41,   43,   -1,   45,   37,   38,
205   -1,   -1,   41,   42,   43,   -1,   45,   -1,   47,    5,
206    6,   -1,   -1,   -1,   -1,   11,   -1,   -1,   -1,   -1,
207   16,   17,   18,   19,   20,   21,   22,   37,   38,   -1,
208   -1,   -1,   42,   43,  124,   45,   37,   47,   -1,   -1,
209   -1,   42,   43,   -1,   45,   -1,   47,   -1,   -1,   -1,
210   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,   -1,
211   -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,
212   -1,   -1,   -1,   -1,   -1,   -1,  124,  124,   -1,   -1,
213   -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,   -1,   -1,
214   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
215   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
216   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
217   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
218   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
219   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
220   -1,   -1,   -1,   -1,   -1,  256,  257,  258,  257,  258,
221};
222#define YYFINAL 1
223#ifndef YYDEBUG
224#define YYDEBUG 0
225#endif
226#define YYMAXTOKEN 259
227#if YYDEBUG
228static const char *yyname[] = {
229
230"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,
2310,0,0,0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,
2320,0,0,0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2330,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,0,0,0,0,0,
2340,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2350,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2360,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2370,0,0,0,0,0,"DIGIT","LETTER","UMINUS",
238};
239static const char *yyrule[] = {
240"$accept : list",
241"list :",
242"list : list stat '\\n'",
243"list : list error '\\n'",
244"stat : expr",
245"stat : LETTER '=' expr",
246"expr : '(' expr ')'",
247"expr : expr '+' expr",
248"expr : expr '-' expr",
249"expr : expr '*' expr",
250"expr : expr '/' expr",
251"expr : expr '%' expr",
252"expr : expr '&' expr",
253"expr : expr '|' expr",
254"expr : '-' expr",
255"expr : LETTER",
256"expr : number",
257"number : DIGIT",
258"number : number DIGIT",
259
260};
261#endif
262
263int      yydebug;
264int      yynerrs;
265
266int      yyerrflag;
267int      yychar;
268YYSTYPE  yyval;
269YYSTYPE  yylval;
270
271/* define the initial stack-sizes */
272#ifdef YYSTACKSIZE
273#undef YYMAXDEPTH
274#define YYMAXDEPTH  YYSTACKSIZE
275#else
276#ifdef YYMAXDEPTH
277#define YYSTACKSIZE YYMAXDEPTH
278#else
279#define YYSTACKSIZE 500
280#define YYMAXDEPTH  500
281#endif
282#endif
283
284#define YYINITSTACKSIZE 500
285
286typedef struct {
287    unsigned stacksize;
288    short    *s_base;
289    short    *s_mark;
290    short    *s_last;
291    YYSTYPE  *l_base;
292    YYSTYPE  *l_mark;
293} YYSTACKDATA;
294/* variables for the parser stack */
295static YYSTACKDATA yystack;
296#line 65 "calc2.y"
297 /* start of programs */
298
299#ifdef YYBYACC
300extern int YYLEX_DECL();
301static void YYERROR_DECL();
302#endif
303
304int
305main (void)
306{
307    int regs[26];
308    int base = 10;
309
310    while(!feof(stdin)) {
311	yyparse(regs, &base);
312    }
313    return 0;
314}
315
316static void
317YYERROR_DECL()
318{
319    fprintf(stderr, "%s\n", s);
320}
321
322int
323yylex(int *base)
324{
325	/* lexical analysis routine */
326	/* returns LETTER for a lower case letter, yylval = 0 through 25 */
327	/* return DIGIT for a digit, yylval = 0 through 9 */
328	/* all other characters are returned immediately */
329
330    int c;
331
332    while( (c=getchar()) == ' ' )   { /* skip blanks */ }
333
334    /* c is now nonblank */
335
336    if( islower( c )) {
337	yylval = c - 'a';
338	return ( LETTER );
339    }
340    if( isdigit( c )) {
341	yylval = (c - '0') % (*base);
342	return ( DIGIT );
343    }
344    return( c );
345}
346#line 345 "calc2.tab.c"
347
348#if YYDEBUG
349#include <stdio.h>		/* needed for printf */
350#endif
351
352#include <stdlib.h>	/* needed for malloc, etc */
353#include <string.h>	/* needed for memset */
354
355/* allocate initial stack or double stack size, up to YYMAXDEPTH */
356static int yygrowstack(YYSTACKDATA *data)
357{
358    int i;
359    unsigned newsize;
360    short *newss;
361    YYSTYPE *newvs;
362
363    if ((newsize = data->stacksize) == 0)
364        newsize = YYINITSTACKSIZE;
365    else if (newsize >= YYMAXDEPTH)
366        return -1;
367    else if ((newsize *= 2) > YYMAXDEPTH)
368        newsize = YYMAXDEPTH;
369
370    i = data->s_mark - data->s_base;
371    newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
372    if (newss == 0)
373        return -1;
374
375    data->s_base = newss;
376    data->s_mark = newss + i;
377
378    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
379    if (newvs == 0)
380        return -1;
381
382    data->l_base = newvs;
383    data->l_mark = newvs + i;
384
385    data->stacksize = newsize;
386    data->s_last = data->s_base + newsize - 1;
387    return 0;
388}
389
390#if YYPURE || defined(YY_NO_LEAKS)
391static void yyfreestack(YYSTACKDATA *data)
392{
393    free(data->s_base);
394    free(data->l_base);
395    memset(data, 0, sizeof(*data));
396}
397#else
398#define yyfreestack(data) /* nothing */
399#endif
400
401#define YYABORT  goto yyabort
402#define YYREJECT goto yyabort
403#define YYACCEPT goto yyaccept
404#define YYERROR  goto yyerrlab
405
406int
407YYPARSE_DECL()
408{
409    int yym, yyn, yystate;
410#if YYDEBUG
411    const char *yys;
412
413    if ((yys = getenv("YYDEBUG")) != 0)
414    {
415        yyn = *yys;
416        if (yyn >= '0' && yyn <= '9')
417            yydebug = yyn - '0';
418    }
419#endif
420
421    yynerrs = 0;
422    yyerrflag = 0;
423    yychar = YYEMPTY;
424    yystate = 0;
425
426#if YYPURE
427    memset(&yystack, 0, sizeof(yystack));
428#endif
429
430    if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
431    yystack.s_mark = yystack.s_base;
432    yystack.l_mark = yystack.l_base;
433    yystate = 0;
434    *yystack.s_mark = 0;
435
436yyloop:
437    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
438    if (yychar < 0)
439    {
440        if ((yychar = YYLEX) < 0) yychar = 0;
441#if YYDEBUG
442        if (yydebug)
443        {
444            yys = 0;
445            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
446            if (!yys) yys = "illegal-symbol";
447            printf("%sdebug: state %d, reading %d (%s)\n",
448                    YYPREFIX, yystate, yychar, yys);
449        }
450#endif
451    }
452    if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
453            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
454    {
455#if YYDEBUG
456        if (yydebug)
457            printf("%sdebug: state %d, shifting to state %d\n",
458                    YYPREFIX, yystate, yytable[yyn]);
459#endif
460        if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
461        {
462            goto yyoverflow;
463        }
464        yystate = yytable[yyn];
465        *++yystack.s_mark = yytable[yyn];
466        *++yystack.l_mark = yylval;
467        yychar = YYEMPTY;
468        if (yyerrflag > 0)  --yyerrflag;
469        goto yyloop;
470    }
471    if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
472            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
473    {
474        yyn = yytable[yyn];
475        goto yyreduce;
476    }
477    if (yyerrflag) goto yyinrecovery;
478
479    yyerror(regs, base, "syntax error");
480
481    goto yyerrlab;
482
483yyerrlab:
484    ++yynerrs;
485
486yyinrecovery:
487    if (yyerrflag < 3)
488    {
489        yyerrflag = 3;
490        for (;;)
491        {
492            if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
493                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
494            {
495#if YYDEBUG
496                if (yydebug)
497                    printf("%sdebug: state %d, error recovery shifting\
498 to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
499#endif
500                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
501                {
502                    goto yyoverflow;
503                }
504                yystate = yytable[yyn];
505                *++yystack.s_mark = yytable[yyn];
506                *++yystack.l_mark = yylval;
507                goto yyloop;
508            }
509            else
510            {
511#if YYDEBUG
512                if (yydebug)
513                    printf("%sdebug: error recovery discarding state %d\n",
514                            YYPREFIX, *yystack.s_mark);
515#endif
516                if (yystack.s_mark <= yystack.s_base) goto yyabort;
517                --yystack.s_mark;
518                --yystack.l_mark;
519            }
520        }
521    }
522    else
523    {
524        if (yychar == 0) goto yyabort;
525#if YYDEBUG
526        if (yydebug)
527        {
528            yys = 0;
529            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
530            if (!yys) yys = "illegal-symbol";
531            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
532                    YYPREFIX, yystate, yychar, yys);
533        }
534#endif
535        yychar = YYEMPTY;
536        goto yyloop;
537    }
538
539yyreduce:
540#if YYDEBUG
541    if (yydebug)
542        printf("%sdebug: state %d, reducing by rule %d (%s)\n",
543                YYPREFIX, yystate, yyn, yyrule[yyn]);
544#endif
545    yym = yylen[yyn];
546    if (yym)
547        yyval = yystack.l_mark[1-yym];
548    else
549        memset(&yyval, 0, sizeof yyval);
550    switch (yyn)
551    {
552case 3:
553#line 27 "calc2.y"
554	{  yyerrok ; }
555break;
556case 4:
557#line 31 "calc2.y"
558	{  printf("%d\n",yystack.l_mark[0]);}
559break;
560case 5:
561#line 33 "calc2.y"
562	{  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
563break;
564case 6:
565#line 37 "calc2.y"
566	{  yyval = yystack.l_mark[-1]; }
567break;
568case 7:
569#line 39 "calc2.y"
570	{  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
571break;
572case 8:
573#line 41 "calc2.y"
574	{  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
575break;
576case 9:
577#line 43 "calc2.y"
578	{  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
579break;
580case 10:
581#line 45 "calc2.y"
582	{  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
583break;
584case 11:
585#line 47 "calc2.y"
586	{  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
587break;
588case 12:
589#line 49 "calc2.y"
590	{  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
591break;
592case 13:
593#line 51 "calc2.y"
594	{  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
595break;
596case 14:
597#line 53 "calc2.y"
598	{  yyval = - yystack.l_mark[0]; }
599break;
600case 15:
601#line 55 "calc2.y"
602	{  yyval = regs[yystack.l_mark[0]]; }
603break;
604case 17:
605#line 60 "calc2.y"
606	{  yyval = yystack.l_mark[0]; (*base) = (yystack.l_mark[0]==0) ? 8 : 10; }
607break;
608case 18:
609#line 62 "calc2.y"
610	{  yyval = (*base) * yystack.l_mark[-1] + yystack.l_mark[0]; }
611break;
612#line 611 "calc2.tab.c"
613    }
614    yystack.s_mark -= yym;
615    yystate = *yystack.s_mark;
616    yystack.l_mark -= yym;
617    yym = yylhs[yyn];
618    if (yystate == 0 && yym == 0)
619    {
620#if YYDEBUG
621        if (yydebug)
622            printf("%sdebug: after reduction, shifting from state 0 to\
623 state %d\n", YYPREFIX, YYFINAL);
624#endif
625        yystate = YYFINAL;
626        *++yystack.s_mark = YYFINAL;
627        *++yystack.l_mark = yyval;
628        if (yychar < 0)
629        {
630            if ((yychar = YYLEX) < 0) yychar = 0;
631#if YYDEBUG
632            if (yydebug)
633            {
634                yys = 0;
635                if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
636                if (!yys) yys = "illegal-symbol";
637                printf("%sdebug: state %d, reading %d (%s)\n",
638                        YYPREFIX, YYFINAL, yychar, yys);
639            }
640#endif
641        }
642        if (yychar == 0) goto yyaccept;
643        goto yyloop;
644    }
645    if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
646            yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
647        yystate = yytable[yyn];
648    else
649        yystate = yydgoto[yym];
650#if YYDEBUG
651    if (yydebug)
652        printf("%sdebug: after reduction, shifting from state %d \
653to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
654#endif
655    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
656    {
657        goto yyoverflow;
658    }
659    *++yystack.s_mark = (short) yystate;
660    *++yystack.l_mark = yyval;
661    goto yyloop;
662
663yyoverflow:
664    yyerror(regs, base, "yacc stack overflow");
665
666yyabort:
667    yyfreestack(&yystack);
668    return (1);
669
670yyaccept:
671    yyfreestack(&yystack);
672    return (0);
673}
674