1/*	$NetBSD: pure_calc.tab.c,v 1.1.1.3 2011/09/10 21:22:03 christos Exp $	*/
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 1
99
100#line 2 "pure_calc.y"
101# include <stdio.h>
102# include <ctype.h>
103
104int regs[26];
105int base;
106
107#line 106 "pure_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(YYSTYPE *yylval, void *YYLEX_PARAM)
128# define YYLEX yylex(&yylval, YYLEX_PARAM)
129#else
130# define YYLEX_DECL() yylex(YYSTYPE *yylval)
131# define YYLEX yylex(&yylval)
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
269/* define the initial stack-sizes */
270#ifdef YYSTACKSIZE
271#undef YYMAXDEPTH
272#define YYMAXDEPTH  YYSTACKSIZE
273#else
274#ifdef YYMAXDEPTH
275#define YYSTACKSIZE YYMAXDEPTH
276#else
277#define YYSTACKSIZE 500
278#define YYMAXDEPTH  500
279#endif
280#endif
281
282#define YYINITSTACKSIZE 500
283
284typedef struct {
285    unsigned stacksize;
286    short    *s_base;
287    short    *s_mark;
288    short    *s_last;
289    YYSTYPE  *l_base;
290    YYSTYPE  *l_mark;
291} YYSTACKDATA;
292#line 63 "pure_calc.y"
293 /* start of programs */
294
295#ifdef YYBYACC
296extern int YYLEX_DECL();
297static void YYERROR_DECL();
298#endif
299
300int
301main (void)
302{
303    while(!feof(stdin)) {
304	yyparse();
305    }
306    return 0;
307}
308
309static void
310yyerror(const char *s)
311{
312    fprintf(stderr, "%s\n", s);
313}
314
315int
316yylex(YYSTYPE *value)
317{
318	/* lexical analysis routine */
319	/* returns LETTER for a lower case letter, yylval = 0 through 25 */
320	/* return DIGIT for a digit, yylval = 0 through 9 */
321	/* all other characters are returned immediately */
322
323    int c;
324
325    while( (c=getchar()) == ' ' )   { /* skip blanks */ }
326
327    /* c is now nonblank */
328
329    if( islower( c )) {
330	*value = c - 'a';
331	return ( LETTER );
332    }
333    if( isdigit( c )) {
334	*value = c - '0';
335	return ( DIGIT );
336    }
337    return( c );
338}
339#line 338 "pure_calc.tab.c"
340
341#if YYDEBUG
342#include <stdio.h>		/* needed for printf */
343#endif
344
345#include <stdlib.h>	/* needed for malloc, etc */
346#include <string.h>	/* needed for memset */
347
348/* allocate initial stack or double stack size, up to YYMAXDEPTH */
349static int yygrowstack(YYSTACKDATA *data)
350{
351    int i;
352    unsigned newsize;
353    short *newss;
354    YYSTYPE *newvs;
355
356    if ((newsize = data->stacksize) == 0)
357        newsize = YYINITSTACKSIZE;
358    else if (newsize >= YYMAXDEPTH)
359        return -1;
360    else if ((newsize *= 2) > YYMAXDEPTH)
361        newsize = YYMAXDEPTH;
362
363    i = data->s_mark - data->s_base;
364    newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
365    if (newss == 0)
366        return -1;
367
368    data->s_base = newss;
369    data->s_mark = newss + i;
370
371    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
372    if (newvs == 0)
373        return -1;
374
375    data->l_base = newvs;
376    data->l_mark = newvs + i;
377
378    data->stacksize = newsize;
379    data->s_last = data->s_base + newsize - 1;
380    return 0;
381}
382
383#if YYPURE || defined(YY_NO_LEAKS)
384static void yyfreestack(YYSTACKDATA *data)
385{
386    free(data->s_base);
387    free(data->l_base);
388    memset(data, 0, sizeof(*data));
389}
390#else
391#define yyfreestack(data) /* nothing */
392#endif
393
394#define YYABORT  goto yyabort
395#define YYREJECT goto yyabort
396#define YYACCEPT goto yyaccept
397#define YYERROR  goto yyerrlab
398
399int
400YYPARSE_DECL()
401{
402    int      yyerrflag;
403    int      yychar;
404    YYSTYPE  yyval;
405    YYSTYPE  yylval;
406
407    /* variables for the parser stack */
408    YYSTACKDATA yystack;
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 "pure_calc.y"
554	{  yyerrok ; }
555break;
556case 4:
557#line 29 "pure_calc.y"
558	{  printf("%d\n",yystack.l_mark[0]);}
559break;
560case 5:
561#line 31 "pure_calc.y"
562	{  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
563break;
564case 6:
565#line 35 "pure_calc.y"
566	{  yyval = yystack.l_mark[-1]; }
567break;
568case 7:
569#line 37 "pure_calc.y"
570	{  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
571break;
572case 8:
573#line 39 "pure_calc.y"
574	{  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
575break;
576case 9:
577#line 41 "pure_calc.y"
578	{  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
579break;
580case 10:
581#line 43 "pure_calc.y"
582	{  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
583break;
584case 11:
585#line 45 "pure_calc.y"
586	{  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
587break;
588case 12:
589#line 47 "pure_calc.y"
590	{  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
591break;
592case 13:
593#line 49 "pure_calc.y"
594	{  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
595break;
596case 14:
597#line 51 "pure_calc.y"
598	{  yyval = - yystack.l_mark[0]; }
599break;
600case 15:
601#line 53 "pure_calc.y"
602	{  yyval = regs[yystack.l_mark[0]]; }
603break;
604case 17:
605#line 58 "pure_calc.y"
606	{  yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
607break;
608case 18:
609#line 60 "pure_calc.y"
610	{  yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
611break;
612#line 611 "pure_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