1#ifndef lint
2static const char yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93";
3#endif
4
5#define YYBYACC 1
6#define YYMAJOR 1
7#define YYMINOR 9
8
9#define YYEMPTY        (-1)
10#define yyclearin      (yychar = YYEMPTY)
11#define yyerrok        (yyerrflag = 0)
12#define YYRECOVERING() (yyerrflag != 0)
13
14
15#ifndef yyparse
16#define yyparse    calc_parse
17#endif /* yyparse */
18
19#ifndef yylex
20#define yylex      calc_lex
21#endif /* yylex */
22
23#ifndef yyerror
24#define yyerror    calc_error
25#endif /* yyerror */
26
27#ifndef yychar
28#define yychar     calc_char
29#endif /* yychar */
30
31#ifndef yyval
32#define yyval      calc_val
33#endif /* yyval */
34
35#ifndef yylval
36#define yylval     calc_lval
37#endif /* yylval */
38
39#ifndef yydebug
40#define yydebug    calc_debug
41#endif /* yydebug */
42
43#ifndef yynerrs
44#define yynerrs    calc_nerrs
45#endif /* yynerrs */
46
47#ifndef yyerrflag
48#define yyerrflag  calc_errflag
49#endif /* yyerrflag */
50
51#ifndef yylhs
52#define yylhs      calc_lhs
53#endif /* yylhs */
54
55#ifndef yylen
56#define yylen      calc_len
57#endif /* yylen */
58
59#ifndef yydefred
60#define yydefred   calc_defred
61#endif /* yydefred */
62
63#ifndef yydgoto
64#define yydgoto    calc_dgoto
65#endif /* yydgoto */
66
67#ifndef yysindex
68#define yysindex   calc_sindex
69#endif /* yysindex */
70
71#ifndef yyrindex
72#define yyrindex   calc_rindex
73#endif /* yyrindex */
74
75#ifndef yygindex
76#define yygindex   calc_gindex
77#endif /* yygindex */
78
79#ifndef yytable
80#define yytable    calc_table
81#endif /* yytable */
82
83#ifndef yycheck
84#define yycheck    calc_check
85#endif /* yycheck */
86
87#ifndef yyname
88#define yyname     calc_name
89#endif /* yyname */
90
91#ifndef yyrule
92#define yyrule     calc_rule
93#endif /* yyrule */
94#define YYPREFIX "calc_"
95
96#define YYPURE 0
97
98#line 2 "calc.y"
99# include <stdio.h>
100# include <ctype.h>
101
102int regs[26];
103int base;
104
105extern int yylex(void);
106static void yyerror(const char *s);
107
108#line 109 "calc.tab.c"
109
110#ifndef YYSTYPE
111typedef int YYSTYPE;
112#endif
113
114/* compatibility with bison */
115#ifdef YYPARSE_PARAM
116/* compatibility with FreeBSD */
117# ifdef YYPARSE_PARAM_TYPE
118#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
119# else
120#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
121# endif
122#else
123# define YYPARSE_DECL() yyparse(void)
124#endif
125
126/* Parameters sent to lex. */
127#ifdef YYLEX_PARAM
128# define YYLEX_DECL() yylex(void *YYLEX_PARAM)
129# define YYLEX yylex(YYLEX_PARAM)
130#else
131# define YYLEX_DECL() yylex(void)
132# define YYLEX yylex()
133#endif
134
135/* Parameters sent to yyerror. */
136#ifndef YYERROR_DECL
137#define YYERROR_DECL() yyerror(const char *s)
138#endif
139#ifndef YYERROR_CALL
140#define YYERROR_CALL(msg) yyerror(msg)
141#endif
142
143extern int YYPARSE_DECL();
144
145#define DIGIT 257
146#define LETTER 258
147#define UMINUS 259
148#define YYERRCODE 256
149static const short calc_lhs[] = {                        -1,
150    0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
151    2,    2,    2,    2,    2,    2,    3,    3,
152};
153static const short calc_len[] = {                         2,
154    0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
155    3,    3,    3,    2,    1,    1,    1,    2,
156};
157static const short calc_defred[] = {                      1,
158    0,    0,   17,    0,    0,    0,    0,    0,    0,    3,
159    0,   15,   14,    0,    2,    0,    0,    0,    0,    0,
160    0,    0,   18,    0,    6,    0,    0,    0,    0,    9,
161   10,   11,
162};
163static const short calc_dgoto[] = {                       1,
164    7,    8,    9,
165};
166static const short calc_sindex[] = {                      0,
167  -40,   -7,    0,  -55,  -38,  -38,    1,  -29, -247,    0,
168  -38,    0,    0,   22,    0,  -38,  -38,  -38,  -38,  -38,
169  -38,  -38,    0,  -29,    0,   51,   60,  -20,  -20,    0,
170    0,    0,
171};
172static const short calc_rindex[] = {                      0,
173    0,    0,    0,    2,    0,    0,    0,    9,   -9,    0,
174    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
175    0,    0,    0,   10,    0,   -6,   14,    5,   13,    0,
176    0,    0,
177};
178static const short calc_gindex[] = {                      0,
179    0,   65,    0,
180};
181#define YYTABLESIZE 220
182static const short calc_table[] = {                       6,
183   16,    6,   10,   13,    5,   11,    5,   22,   17,   23,
184   15,   15,   20,   18,    7,   19,   22,   21,    4,    5,
185    0,   20,    8,   12,    0,    0,   21,   16,   16,    0,
186    0,   16,   16,   16,   13,   16,    0,   16,   15,   15,
187    0,    0,    7,   15,   15,    7,   15,    7,   15,    7,
188    8,   12,    0,    8,   12,    8,    0,    8,   22,   17,
189    0,    0,   25,   20,   18,    0,   19,    0,   21,   13,
190   14,    0,    0,    0,    0,   24,    0,    0,    0,    0,
191   26,   27,   28,   29,   30,   31,   32,   22,   17,    0,
192    0,    0,   20,   18,   16,   19,   22,   21,    0,    0,
193    0,   20,   18,    0,   19,    0,   21,    0,    0,    0,
194    0,    0,    0,    0,   16,    0,    0,   13,    0,    0,
195    0,    0,    0,    0,    0,   15,    0,    0,    7,    0,
196    0,    0,    0,    0,    0,    0,    8,   12,    0,    0,
197    0,    0,    0,    0,    0,   16,    0,    0,    0,    0,
198    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
199    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
200    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
201    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
202    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
203    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
204    0,    0,    0,    0,    0,    2,    3,    4,    3,   12,
205};
206static const short calc_check[] = {                      40,
207   10,   40,   10,   10,   45,   61,   45,   37,   38,  257,
208   10,   10,   42,   43,   10,   45,   37,   47,   10,   10,
209   -1,   42,   10,   10,   -1,   -1,   47,   37,   38,   -1,
210   -1,   41,   42,   43,   41,   45,   -1,   47,   37,   38,
211   -1,   -1,   38,   42,   43,   41,   45,   43,   47,   45,
212   38,   38,   -1,   41,   41,   43,   -1,   45,   37,   38,
213   -1,   -1,   41,   42,   43,   -1,   45,   -1,   47,    5,
214    6,   -1,   -1,   -1,   -1,   11,   -1,   -1,   -1,   -1,
215   16,   17,   18,   19,   20,   21,   22,   37,   38,   -1,
216   -1,   -1,   42,   43,  124,   45,   37,   47,   -1,   -1,
217   -1,   42,   43,   -1,   45,   -1,   47,   -1,   -1,   -1,
218   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,   -1,
219   -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,
220   -1,   -1,   -1,   -1,   -1,   -1,  124,  124,   -1,   -1,
221   -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,   -1,   -1,
222   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
223   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
224   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
225   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
226   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
227   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
228   -1,   -1,   -1,   -1,   -1,  256,  257,  258,  257,  258,
229};
230#define YYFINAL 1
231#ifndef YYDEBUG
232#define YYDEBUG 0
233#endif
234#define YYMAXTOKEN 259
235#if YYDEBUG
236static const char *yyname[] = {
237
238"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,
2390,0,0,0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,
2400,0,0,0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2410,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,0,0,0,0,0,
2420,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2430,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2440,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2450,0,0,0,0,0,"DIGIT","LETTER","UMINUS",
246};
247static const char *yyrule[] = {
248"$accept : list",
249"list :",
250"list : list stat '\\n'",
251"list : list error '\\n'",
252"stat : expr",
253"stat : LETTER '=' expr",
254"expr : '(' expr ')'",
255"expr : expr '+' expr",
256"expr : expr '-' expr",
257"expr : expr '*' expr",
258"expr : expr '/' expr",
259"expr : expr '%' expr",
260"expr : expr '&' expr",
261"expr : expr '|' expr",
262"expr : '-' expr",
263"expr : LETTER",
264"expr : number",
265"number : DIGIT",
266"number : number DIGIT",
267
268};
269#endif
270
271int      yydebug;
272int      yynerrs;
273
274int      yyerrflag;
275int      yychar;
276YYSTYPE  yyval;
277YYSTYPE  yylval;
278
279/* define the initial stack-sizes */
280#ifdef YYSTACKSIZE
281#undef YYMAXDEPTH
282#define YYMAXDEPTH  YYSTACKSIZE
283#else
284#ifdef YYMAXDEPTH
285#define YYSTACKSIZE YYMAXDEPTH
286#else
287#define YYSTACKSIZE 500
288#define YYMAXDEPTH  500
289#endif
290#endif
291
292#define YYINITSTACKSIZE 500
293
294typedef struct {
295    unsigned stacksize;
296    short    *s_base;
297    short    *s_mark;
298    short    *s_last;
299    YYSTYPE  *l_base;
300    YYSTYPE  *l_mark;
301} YYSTACKDATA;
302/* variables for the parser stack */
303static YYSTACKDATA yystack;
304#line 66 "calc.y"
305 /* start of programs */
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 347 "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 = (int) (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 28 "calc.y"
554	{  yyerrok ; }
555break;
556case 4:
557#line 32 "calc.y"
558	{  printf("%d\n",yystack.l_mark[0]);}
559break;
560case 5:
561#line 34 "calc.y"
562	{  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
563break;
564case 6:
565#line 38 "calc.y"
566	{  yyval = yystack.l_mark[-1]; }
567break;
568case 7:
569#line 40 "calc.y"
570	{  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
571break;
572case 8:
573#line 42 "calc.y"
574	{  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
575break;
576case 9:
577#line 44 "calc.y"
578	{  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
579break;
580case 10:
581#line 46 "calc.y"
582	{  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
583break;
584case 11:
585#line 48 "calc.y"
586	{  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
587break;
588case 12:
589#line 50 "calc.y"
590	{  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
591break;
592case 13:
593#line 52 "calc.y"
594	{  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
595break;
596case 14:
597#line 54 "calc.y"
598	{  yyval = - yystack.l_mark[0]; }
599break;
600case 15:
601#line 56 "calc.y"
602	{  yyval = regs[yystack.l_mark[0]]; }
603break;
604case 17:
605#line 61 "calc.y"
606	{  yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
607break;
608case 18:
609#line 63 "calc.y"
610	{  yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
611break;
612#line 613 "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