1/*	$NetBSD: calc3.tab.c,v 1.1.1.3 2011/09/10 21:22:04 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    calc3_parse
19#endif /* yyparse */
20
21#ifndef yylex
22#define yylex      calc3_lex
23#endif /* yylex */
24
25#ifndef yyerror
26#define yyerror    calc3_error
27#endif /* yyerror */
28
29#ifndef yychar
30#define yychar     calc3_char
31#endif /* yychar */
32
33#ifndef yyval
34#define yyval      calc3_val
35#endif /* yyval */
36
37#ifndef yylval
38#define yylval     calc3_lval
39#endif /* yylval */
40
41#ifndef yydebug
42#define yydebug    calc3_debug
43#endif /* yydebug */
44
45#ifndef yynerrs
46#define yynerrs    calc3_nerrs
47#endif /* yynerrs */
48
49#ifndef yyerrflag
50#define yyerrflag  calc3_errflag
51#endif /* yyerrflag */
52
53#ifndef yylhs
54#define yylhs      calc3_lhs
55#endif /* yylhs */
56
57#ifndef yylen
58#define yylen      calc3_len
59#endif /* yylen */
60
61#ifndef yydefred
62#define yydefred   calc3_defred
63#endif /* yydefred */
64
65#ifndef yydgoto
66#define yydgoto    calc3_dgoto
67#endif /* yydgoto */
68
69#ifndef yysindex
70#define yysindex   calc3_sindex
71#endif /* yysindex */
72
73#ifndef yyrindex
74#define yyrindex   calc3_rindex
75#endif /* yyrindex */
76
77#ifndef yygindex
78#define yygindex   calc3_gindex
79#endif /* yygindex */
80
81#ifndef yytable
82#define yytable    calc3_table
83#endif /* yytable */
84
85#ifndef yycheck
86#define yycheck    calc3_check
87#endif /* yycheck */
88
89#ifndef yyname
90#define yyname     calc3_name
91#endif /* yyname */
92
93#ifndef yyrule
94#define yyrule     calc3_rule
95#endif /* yyrule */
96#define YYPREFIX "calc3_"
97
98#define YYPURE 1
99
100#line 9 "calc3.y"
101# include <stdio.h>
102# include <ctype.h>
103
104#line 103 "calc3.tab.c"
105
106#ifndef YYSTYPE
107typedef int YYSTYPE;
108#endif
109
110/* compatibility with bison */
111#ifdef YYPARSE_PARAM
112/* compatibility with FreeBSD */
113# ifdef YYPARSE_PARAM_TYPE
114#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
115# else
116#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
117# endif
118#else
119# define YYPARSE_DECL() yyparse(int  regs[26], int * base)
120#endif
121
122/* Parameters sent to lex. */
123#ifdef YYLEX_PARAM
124# define YYLEX_DECL() yylex(YYSTYPE *yylval, void *YYLEX_PARAM)
125# define YYLEX yylex(&yylval, YYLEX_PARAM)
126#else
127# define YYLEX_DECL() yylex(YYSTYPE *yylval, int * base)
128# define YYLEX yylex(&yylval, base)
129#endif
130
131/* Parameters sent to yyerror. */
132#define YYERROR_DECL() yyerror(int  regs[26], int * base, const char *s)
133#define YYERROR_CALL(msg) yyerror(regs, base, msg)
134
135extern int YYPARSE_DECL();
136
137#define DIGIT 257
138#define LETTER 258
139#define UMINUS 259
140#define YYERRCODE 256
141static const short calc3_lhs[] = {                       -1,
142    0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
143    2,    2,    2,    2,    2,    2,    3,    3,
144};
145static const short calc3_len[] = {                        2,
146    0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
147    3,    3,    3,    2,    1,    1,    1,    2,
148};
149static const short calc3_defred[] = {                     1,
150    0,    0,   17,    0,    0,    0,    0,    0,    0,    3,
151    0,   15,   14,    0,    2,    0,    0,    0,    0,    0,
152    0,    0,   18,    0,    6,    0,    0,    0,    0,    9,
153   10,   11,
154};
155static const short calc3_dgoto[] = {                      1,
156    7,    8,    9,
157};
158static const short calc3_sindex[] = {                     0,
159  -40,   -7,    0,  -55,  -38,  -38,    1,  -29, -247,    0,
160  -38,    0,    0,   22,    0,  -38,  -38,  -38,  -38,  -38,
161  -38,  -38,    0,  -29,    0,   51,   60,  -20,  -20,    0,
162    0,    0,
163};
164static const short calc3_rindex[] = {                     0,
165    0,    0,    0,    2,    0,    0,    0,    9,   -9,    0,
166    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
167    0,    0,    0,   10,    0,   -6,   14,    5,   13,    0,
168    0,    0,
169};
170static const short calc3_gindex[] = {                     0,
171    0,   65,    0,
172};
173#define YYTABLESIZE 220
174static const short calc3_table[] = {                      6,
175   16,    6,   10,   13,    5,   11,    5,   22,   17,   23,
176   15,   15,   20,   18,    7,   19,   22,   21,    4,    5,
177    0,   20,    8,   12,    0,    0,   21,   16,   16,    0,
178    0,   16,   16,   16,   13,   16,    0,   16,   15,   15,
179    0,    0,    7,   15,   15,    7,   15,    7,   15,    7,
180    8,   12,    0,    8,   12,    8,    0,    8,   22,   17,
181    0,    0,   25,   20,   18,    0,   19,    0,   21,   13,
182   14,    0,    0,    0,    0,   24,    0,    0,    0,    0,
183   26,   27,   28,   29,   30,   31,   32,   22,   17,    0,
184    0,    0,   20,   18,   16,   19,   22,   21,    0,    0,
185    0,   20,   18,    0,   19,    0,   21,    0,    0,    0,
186    0,    0,    0,    0,   16,    0,    0,   13,    0,    0,
187    0,    0,    0,    0,    0,   15,    0,    0,    7,    0,
188    0,    0,    0,    0,    0,    0,    8,   12,    0,    0,
189    0,    0,    0,    0,    0,   16,    0,    0,    0,    0,
190    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
191    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
192    0,    0,    0,    0,    0,    0,    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,    2,    3,    4,    3,   12,
197};
198static const short calc3_check[] = {                     40,
199   10,   40,   10,   10,   45,   61,   45,   37,   38,  257,
200   10,   10,   42,   43,   10,   45,   37,   47,   10,   10,
201   -1,   42,   10,   10,   -1,   -1,   47,   37,   38,   -1,
202   -1,   41,   42,   43,   41,   45,   -1,   47,   37,   38,
203   -1,   -1,   38,   42,   43,   41,   45,   43,   47,   45,
204   38,   38,   -1,   41,   41,   43,   -1,   45,   37,   38,
205   -1,   -1,   41,   42,   43,   -1,   45,   -1,   47,    5,
206    6,   -1,   -1,   -1,   -1,   11,   -1,   -1,   -1,   -1,
207   16,   17,   18,   19,   20,   21,   22,   37,   38,   -1,
208   -1,   -1,   42,   43,  124,   45,   37,   47,   -1,   -1,
209   -1,   42,   43,   -1,   45,   -1,   47,   -1,   -1,   -1,
210   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,   -1,
211   -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,
212   -1,   -1,   -1,   -1,   -1,   -1,  124,  124,   -1,   -1,
213   -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,   -1,   -1,
214   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
215   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
216   -1,   -1,   -1,   -1,   -1,   -1,   -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,  256,  257,  258,  257,  258,
221};
222#define YYFINAL 1
223#ifndef YYDEBUG
224#define YYDEBUG 0
225#endif
226#define YYMAXTOKEN 259
227#if YYDEBUG
228static const char *yyname[] = {
229
230"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,
2310,0,0,0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,
2320,0,0,0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2330,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,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,0,0,0,0,0,0,0,0,0,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,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,0,0,0,
2370,0,0,0,0,0,"DIGIT","LETTER","UMINUS",
238};
239static const char *yyrule[] = {
240"$accept : list",
241"list :",
242"list : list stat '\\n'",
243"list : list error '\\n'",
244"stat : expr",
245"stat : LETTER '=' expr",
246"expr : '(' expr ')'",
247"expr : expr '+' expr",
248"expr : expr '-' expr",
249"expr : expr '*' expr",
250"expr : expr '/' expr",
251"expr : expr '%' expr",
252"expr : expr '&' expr",
253"expr : expr '|' expr",
254"expr : '-' expr",
255"expr : LETTER",
256"expr : number",
257"number : DIGIT",
258"number : number DIGIT",
259
260};
261#endif
262
263int      yydebug;
264int      yynerrs;
265
266/* define the initial stack-sizes */
267#ifdef YYSTACKSIZE
268#undef YYMAXDEPTH
269#define YYMAXDEPTH  YYSTACKSIZE
270#else
271#ifdef YYMAXDEPTH
272#define YYSTACKSIZE YYMAXDEPTH
273#else
274#define YYSTACKSIZE 500
275#define YYMAXDEPTH  500
276#endif
277#endif
278
279#define YYINITSTACKSIZE 500
280
281typedef struct {
282    unsigned stacksize;
283    short    *s_base;
284    short    *s_mark;
285    short    *s_last;
286    YYSTYPE  *l_base;
287    YYSTYPE  *l_mark;
288} YYSTACKDATA;
289#line 67 "calc3.y"
290 /* start of programs */
291
292#ifdef YYBYACC
293extern int YYLEX_DECL();
294static void YYERROR_DECL();
295#endif
296
297int
298main (void)
299{
300    int regs[26];
301    int base = 10;
302
303    while(!feof(stdin)) {
304	yyparse(regs, &base);
305    }
306    return 0;
307}
308
309static void
310YYERROR_DECL()
311{
312    fprintf(stderr, "%s\n", s);
313}
314
315int
316YYLEX_DECL()
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	*yylval = (c - 'a');
331	return ( LETTER );
332    }
333    if( isdigit( c )) {
334	*yylval = (c - '0') % (*base);
335	return ( DIGIT );
336    }
337    return( c );
338}
339#line 338 "calc3.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(regs, base, "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 29 "calc3.y"
554	{  yyerrok ; }
555break;
556case 4:
557#line 33 "calc3.y"
558	{  printf("%d\n",yystack.l_mark[0]);}
559break;
560case 5:
561#line 35 "calc3.y"
562	{  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
563break;
564case 6:
565#line 39 "calc3.y"
566	{  yyval = yystack.l_mark[-1]; }
567break;
568case 7:
569#line 41 "calc3.y"
570	{  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
571break;
572case 8:
573#line 43 "calc3.y"
574	{  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
575break;
576case 9:
577#line 45 "calc3.y"
578	{  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
579break;
580case 10:
581#line 47 "calc3.y"
582	{  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
583break;
584case 11:
585#line 49 "calc3.y"
586	{  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
587break;
588case 12:
589#line 51 "calc3.y"
590	{  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
591break;
592case 13:
593#line 53 "calc3.y"
594	{  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
595break;
596case 14:
597#line 55 "calc3.y"
598	{  yyval = - yystack.l_mark[0]; }
599break;
600case 15:
601#line 57 "calc3.y"
602	{  yyval = regs[yystack.l_mark[0]]; }
603break;
604case 17:
605#line 62 "calc3.y"
606	{  yyval = yystack.l_mark[0]; (*base) = (yystack.l_mark[0]==0) ? 8 : 10; }
607break;
608case 18:
609#line 64 "calc3.y"
610	{  yyval = (*base) * yystack.l_mark[-1] + yystack.l_mark[0]; }
611break;
612#line 611 "calc3.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(regs, base, "yacc stack overflow");
665
666yyabort:
667    yyfreestack(&yystack);
668    return (1);
669
670yyaccept:
671    yyfreestack(&yystack);
672    return (0);
673}
674