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