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