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    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 0
99
100#line 2 "calc.y"
101# include <stdio.h>
102# include <ctype.h>
103
104int regs[26];
105int base;
106
107#line 106 "calc.tab.c"
108
109#ifndef YYSTYPE
110typedef int YYSTYPE;
111#endif
112
113/* compatibility with bison */
114#ifdef YYPARSE_PARAM
115/* compatibility with FreeBSD */
116# ifdef YYPARSE_PARAM_TYPE
117#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
118# else
119#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
120# endif
121#else
122# define YYPARSE_DECL() yyparse(void)
123#endif
124
125/* Parameters sent to lex. */
126#ifdef YYLEX_PARAM
127# define YYLEX_DECL() yylex(void *YYLEX_PARAM)
128# define YYLEX yylex(YYLEX_PARAM)
129#else
130# define YYLEX_DECL() yylex(void)
131# define YYLEX yylex()
132#endif
133
134/* Parameters sent to yyerror. */
135#define YYERROR_DECL() yyerror(const char *s)
136#define YYERROR_CALL(msg) yyerror(msg)
137
138extern int YYPARSE_DECL();
139
140#define DIGIT 257
141#define LETTER 258
142#define UMINUS 259
143#define YYERRCODE 256
144static const short calc_lhs[] = {                        -1,
145    0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
146    2,    2,    2,    2,    2,    2,    3,    3,
147};
148static const short calc_len[] = {                         2,
149    0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
150    3,    3,    3,    2,    1,    1,    1,    2,
151};
152static const short calc_defred[] = {                      1,
153    0,    0,   17,    0,    0,    0,    0,    0,    0,    3,
154    0,   15,   14,    0,    2,    0,    0,    0,    0,    0,
155    0,    0,   18,    0,    6,    0,    0,    0,    0,    9,
156   10,   11,
157};
158static const short calc_dgoto[] = {                       1,
159    7,    8,    9,
160};
161static const short calc_sindex[] = {                      0,
162  -40,   -7,    0,  -55,  -38,  -38,    1,  -29, -247,    0,
163  -38,    0,    0,   22,    0,  -38,  -38,  -38,  -38,  -38,
164  -38,  -38,    0,  -29,    0,   51,   60,  -20,  -20,    0,
165    0,    0,
166};
167static const short calc_rindex[] = {                      0,
168    0,    0,    0,    2,    0,    0,    0,    9,   -9,    0,
169    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
170    0,    0,    0,   10,    0,   -6,   14,    5,   13,    0,
171    0,    0,
172};
173static const short calc_gindex[] = {                      0,
174    0,   65,    0,
175};
176#define YYTABLESIZE 220
177static const short calc_table[] = {                       6,
178   16,    6,   10,   13,    5,   11,    5,   22,   17,   23,
179   15,   15,   20,   18,    7,   19,   22,   21,    4,    5,
180    0,   20,    8,   12,    0,    0,   21,   16,   16,    0,
181    0,   16,   16,   16,   13,   16,    0,   16,   15,   15,
182    0,    0,    7,   15,   15,    7,   15,    7,   15,    7,
183    8,   12,    0,    8,   12,    8,    0,    8,   22,   17,
184    0,    0,   25,   20,   18,    0,   19,    0,   21,   13,
185   14,    0,    0,    0,    0,   24,    0,    0,    0,    0,
186   26,   27,   28,   29,   30,   31,   32,   22,   17,    0,
187    0,    0,   20,   18,   16,   19,   22,   21,    0,    0,
188    0,   20,   18,    0,   19,    0,   21,    0,    0,    0,
189    0,    0,    0,    0,   16,    0,    0,   13,    0,    0,
190    0,    0,    0,    0,    0,   15,    0,    0,    7,    0,
191    0,    0,    0,    0,    0,    0,    8,   12,    0,    0,
192    0,    0,    0,    0,    0,   16,    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,    0,    0,    0,    0,    0,
197    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
198    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
199    0,    0,    0,    0,    0,    2,    3,    4,    3,   12,
200};
201static const short calc_check[] = {                      40,
202   10,   40,   10,   10,   45,   61,   45,   37,   38,  257,
203   10,   10,   42,   43,   10,   45,   37,   47,   10,   10,
204   -1,   42,   10,   10,   -1,   -1,   47,   37,   38,   -1,
205   -1,   41,   42,   43,   41,   45,   -1,   47,   37,   38,
206   -1,   -1,   38,   42,   43,   41,   45,   43,   47,   45,
207   38,   38,   -1,   41,   41,   43,   -1,   45,   37,   38,
208   -1,   -1,   41,   42,   43,   -1,   45,   -1,   47,    5,
209    6,   -1,   -1,   -1,   -1,   11,   -1,   -1,   -1,   -1,
210   16,   17,   18,   19,   20,   21,   22,   37,   38,   -1,
211   -1,   -1,   42,   43,  124,   45,   37,   47,   -1,   -1,
212   -1,   42,   43,   -1,   45,   -1,   47,   -1,   -1,   -1,
213   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,   -1,
214   -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,
215   -1,   -1,   -1,   -1,   -1,   -1,  124,  124,   -1,   -1,
216   -1,   -1,   -1,   -1,   -1,  124,   -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,   -1,   -1,   -1,   -1,   -1,
221   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
222   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
223   -1,   -1,   -1,   -1,   -1,  256,  257,  258,  257,  258,
224};
225#define YYFINAL 1
226#ifndef YYDEBUG
227#define YYDEBUG 0
228#endif
229#define YYMAXTOKEN 259
230#if YYDEBUG
231static const char *yyname[] = {
232
233"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,
2340,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,
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,
2370,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2380,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2390,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2400,0,0,0,0,0,"DIGIT","LETTER","UMINUS",
241};
242static const char *yyrule[] = {
243"$accept : list",
244"list :",
245"list : list stat '\\n'",
246"list : list error '\\n'",
247"stat : expr",
248"stat : LETTER '=' expr",
249"expr : '(' expr ')'",
250"expr : expr '+' expr",
251"expr : expr '-' expr",
252"expr : expr '*' expr",
253"expr : expr '/' expr",
254"expr : expr '%' expr",
255"expr : expr '&' expr",
256"expr : expr '|' expr",
257"expr : '-' expr",
258"expr : LETTER",
259"expr : number",
260"number : DIGIT",
261"number : number DIGIT",
262
263};
264#endif
265
266int      yydebug;
267int      yynerrs;
268
269int      yyerrflag;
270int      yychar;
271YYSTYPE  yyval;
272YYSTYPE  yylval;
273
274/* define the initial stack-sizes */
275#ifdef YYSTACKSIZE
276#undef YYMAXDEPTH
277#define YYMAXDEPTH  YYSTACKSIZE
278#else
279#ifdef YYMAXDEPTH
280#define YYSTACKSIZE YYMAXDEPTH
281#else
282#define YYSTACKSIZE 500
283#define YYMAXDEPTH  500
284#endif
285#endif
286
287#define YYINITSTACKSIZE 500
288
289typedef struct {
290    unsigned stacksize;
291    short    *s_base;
292    short    *s_mark;
293    short    *s_last;
294    YYSTYPE  *l_base;
295    YYSTYPE  *l_mark;
296} YYSTACKDATA;
297/* variables for the parser stack */
298static YYSTACKDATA yystack;
299#line 63 "calc.y"
300 /* start of programs */
301
302#ifdef YYBYACC
303extern int YYLEX_DECL();
304static void YYERROR_DECL();
305#endif
306
307int
308main (void)
309{
310    while(!feof(stdin)) {
311	yyparse();
312    }
313    return 0;
314}
315
316static void
317yyerror(const char *s)
318{
319    fprintf(stderr, "%s\n", s);
320}
321
322int
323yylex(void)
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';
342	return ( DIGIT );
343    }
344    return( c );
345}
346#line 345 "calc.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("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 25 "calc.y"
554	{  yyerrok ; }
555break;
556case 4:
557#line 29 "calc.y"
558	{  printf("%d\n",yystack.l_mark[0]);}
559break;
560case 5:
561#line 31 "calc.y"
562	{  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
563break;
564case 6:
565#line 35 "calc.y"
566	{  yyval = yystack.l_mark[-1]; }
567break;
568case 7:
569#line 37 "calc.y"
570	{  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
571break;
572case 8:
573#line 39 "calc.y"
574	{  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
575break;
576case 9:
577#line 41 "calc.y"
578	{  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
579break;
580case 10:
581#line 43 "calc.y"
582	{  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
583break;
584case 11:
585#line 45 "calc.y"
586	{  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
587break;
588case 12:
589#line 47 "calc.y"
590	{  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
591break;
592case 13:
593#line 49 "calc.y"
594	{  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
595break;
596case 14:
597#line 51 "calc.y"
598	{  yyval = - yystack.l_mark[0]; }
599break;
600case 15:
601#line 53 "calc.y"
602	{  yyval = regs[yystack.l_mark[0]]; }
603break;
604case 17:
605#line 58 "calc.y"
606	{  yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
607break;
608case 18:
609#line 60 "calc.y"
610	{  yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
611break;
612#line 611 "calc.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("yacc stack overflow");
665
666yyabort:
667    yyfreestack(&yystack);
668    return (1);
669
670yyaccept:
671    yyfreestack(&yystack);
672    return (0);
673}
674