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