calc.tab.c revision 277086 
1/* original parser id follows */
2/* yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93" */
3/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
4
5#define YYBYACC 1
6#define YYMAJOR 1
7#define YYMINOR 9
8#define YYCHECK "yyyymmdd"
9
10#define YYEMPTY        (-1)
11#define yyclearin      (yychar = YYEMPTY)
12#define yyerrok        (yyerrflag = 0)
13#define YYRECOVERING() (yyerrflag != 0)
14#define YYENOMEM       (-2)
15#define YYEOF          0
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 0
99
100#line 2 "calc.y"
101# include <stdio.h>
102# include <ctype.h>
103
104int regs[26];
105int base;
106
107extern int yylex(void);
108static void yyerror(const char *s);
109
110#line 111 "calc.tab.c"
111
112#if ! defined(YYSTYPE) && ! defined(YYSTYPE_IS_DECLARED)
113/* Default: YYSTYPE is the semantic value type. */
114typedef int YYSTYPE;
115# define YYSTYPE_IS_DECLARED 1
116#endif
117
118/* compatibility with bison */
119#ifdef YYPARSE_PARAM
120/* compatibility with FreeBSD */
121# ifdef YYPARSE_PARAM_TYPE
122#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
123# else
124#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
125# endif
126#else
127# define YYPARSE_DECL() yyparse(void)
128#endif
129
130/* Parameters sent to lex. */
131#ifdef YYLEX_PARAM
132# define YYLEX_DECL() yylex(void *YYLEX_PARAM)
133# define YYLEX yylex(YYLEX_PARAM)
134#else
135# define YYLEX_DECL() yylex(void)
136# define YYLEX yylex()
137#endif
138
139/* Parameters sent to yyerror. */
140#ifndef YYERROR_DECL
141#define YYERROR_DECL() yyerror(const char *s)
142#endif
143#ifndef YYERROR_CALL
144#define YYERROR_CALL(msg) yyerror(msg)
145#endif
146
147extern int YYPARSE_DECL();
148
149#define DIGIT 257
150#define LETTER 258
151#define UMINUS 259
152#define YYERRCODE 256
153typedef int YYINT;
154static const YYINT calc_lhs[] = {                        -1,
155    0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
156    2,    2,    2,    2,    2,    2,    3,    3,
157};
158static const YYINT calc_len[] = {                         2,
159    0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
160    3,    3,    3,    2,    1,    1,    1,    2,
161};
162static const YYINT calc_defred[] = {                      1,
163    0,    0,   17,    0,    0,    0,    0,    0,    0,    3,
164    0,   15,   14,    0,    2,    0,    0,    0,    0,    0,
165    0,    0,   18,    0,    6,    0,    0,    0,    0,    9,
166   10,   11,
167};
168static const YYINT calc_dgoto[] = {                       1,
169    7,    8,    9,
170};
171static const YYINT calc_sindex[] = {                      0,
172  -40,   -7,    0,  -55,  -38,  -38,    1,  -29, -247,    0,
173  -38,    0,    0,   22,    0,  -38,  -38,  -38,  -38,  -38,
174  -38,  -38,    0,  -29,    0,   51,   60,  -20,  -20,    0,
175    0,    0,
176};
177static const YYINT calc_rindex[] = {                      0,
178    0,    0,    0,    2,    0,    0,    0,    9,   -9,    0,
179    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
180    0,    0,    0,   10,    0,   -6,   14,    5,   13,    0,
181    0,    0,
182};
183static const YYINT calc_gindex[] = {                      0,
184    0,   65,    0,
185};
186#define YYTABLESIZE 220
187static const YYINT calc_table[] = {                       6,
188   16,    6,   10,   13,    5,   11,    5,   22,   17,   23,
189   15,   15,   20,   18,    7,   19,   22,   21,    4,    5,
190    0,   20,    8,   12,    0,    0,   21,   16,   16,    0,
191    0,   16,   16,   16,   13,   16,    0,   16,   15,   15,
192    0,    0,    7,   15,   15,    7,   15,    7,   15,    7,
193    8,   12,    0,    8,   12,    8,    0,    8,   22,   17,
194    0,    0,   25,   20,   18,    0,   19,    0,   21,   13,
195   14,    0,    0,    0,    0,   24,    0,    0,    0,    0,
196   26,   27,   28,   29,   30,   31,   32,   22,   17,    0,
197    0,    0,   20,   18,   16,   19,   22,   21,    0,    0,
198    0,   20,   18,    0,   19,    0,   21,    0,    0,    0,
199    0,    0,    0,    0,   16,    0,    0,   13,    0,    0,
200    0,    0,    0,    0,    0,   15,    0,    0,    7,    0,
201    0,    0,    0,    0,    0,    0,    8,   12,    0,    0,
202    0,    0,    0,    0,    0,   16,    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,    0,    0,    0,    0,    0,
207    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
208    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
209    0,    0,    0,    0,    0,    2,    3,    4,    3,   12,
210};
211static const YYINT calc_check[] = {                      40,
212   10,   40,   10,   10,   45,   61,   45,   37,   38,  257,
213   10,   10,   42,   43,   10,   45,   37,   47,   10,   10,
214   -1,   42,   10,   10,   -1,   -1,   47,   37,   38,   -1,
215   -1,   41,   42,   43,   41,   45,   -1,   47,   37,   38,
216   -1,   -1,   38,   42,   43,   41,   45,   43,   47,   45,
217   38,   38,   -1,   41,   41,   43,   -1,   45,   37,   38,
218   -1,   -1,   41,   42,   43,   -1,   45,   -1,   47,    5,
219    6,   -1,   -1,   -1,   -1,   11,   -1,   -1,   -1,   -1,
220   16,   17,   18,   19,   20,   21,   22,   37,   38,   -1,
221   -1,   -1,   42,   43,  124,   45,   37,   47,   -1,   -1,
222   -1,   42,   43,   -1,   45,   -1,   47,   -1,   -1,   -1,
223   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,   -1,
224   -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,
225   -1,   -1,   -1,   -1,   -1,   -1,  124,  124,   -1,   -1,
226   -1,   -1,   -1,   -1,   -1,  124,   -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,   -1,   -1,   -1,   -1,   -1,
231   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
232   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
233   -1,   -1,   -1,   -1,   -1,  256,  257,  258,  257,  258,
234};
235#define YYFINAL 1
236#ifndef YYDEBUG
237#define YYDEBUG 0
238#endif
239#define YYMAXTOKEN 259
240#define YYUNDFTOKEN 265
241#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
242#if YYDEBUG
243static const char *const calc_name[] = {
244
245"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,
2460,0,0,0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,
2470,0,0,0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2480,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,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,0,0,0,0,0,0,0,0,0,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,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,0,0,0,
2520,0,0,0,0,0,"DIGIT","LETTER","UMINUS",0,0,0,0,0,"illegal-symbol",
253};
254static const char *const calc_rule[] = {
255"$accept : list",
256"list :",
257"list : list stat '\\n'",
258"list : list error '\\n'",
259"stat : expr",
260"stat : LETTER '=' expr",
261"expr : '(' expr ')'",
262"expr : expr '+' expr",
263"expr : expr '-' expr",
264"expr : expr '*' expr",
265"expr : expr '/' expr",
266"expr : expr '%' expr",
267"expr : expr '&' expr",
268"expr : expr '|' expr",
269"expr : '-' expr",
270"expr : LETTER",
271"expr : number",
272"number : DIGIT",
273"number : number DIGIT",
274
275};
276#endif
277
278int      yydebug;
279int      yynerrs;
280
281int      yyerrflag;
282int      yychar;
283YYSTYPE  yyval;
284YYSTYPE  yylval;
285
286/* define the initial stack-sizes */
287#ifdef YYSTACKSIZE
288#undef YYMAXDEPTH
289#define YYMAXDEPTH  YYSTACKSIZE
290#else
291#ifdef YYMAXDEPTH
292#define YYSTACKSIZE YYMAXDEPTH
293#else
294#define YYSTACKSIZE 10000
295#define YYMAXDEPTH  10000
296#endif
297#endif
298
299#define YYINITSTACKSIZE 200
300
301typedef struct {
302    unsigned stacksize;
303    YYINT    *s_base;
304    YYINT    *s_mark;
305    YYINT    *s_last;
306    YYSTYPE  *l_base;
307    YYSTYPE  *l_mark;
308} YYSTACKDATA;
309/* variables for the parser stack */
310static YYSTACKDATA yystack;
311#line 66 "calc.y"
312 /* start of programs */
313
314int
315main (void)
316{
317    while(!feof(stdin)) {
318	yyparse();
319    }
320    return 0;
321}
322
323static void
324yyerror(const char *s)
325{
326    fprintf(stderr, "%s\n", s);
327}
328
329int
330yylex(void)
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 "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    YYINT *newss;
368    YYSTYPE *newvs;
369
370    if ((newsize = data->stacksize) == 0)
371        newsize = YYINITSTACKSIZE;
372    else if (newsize >= YYMAXDEPTH)
373        return YYENOMEM;
374    else if ((newsize *= 2) > YYMAXDEPTH)
375        newsize = YYMAXDEPTH;
376
377    i = (int) (data->s_mark - data->s_base);
378    newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
379    if (newss == 0)
380        return YYENOMEM;
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 YYENOMEM;
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 yym, yyn, yystate;
417#if YYDEBUG
418    const char *yys;
419
420    if ((yys = getenv("YYDEBUG")) != 0)
421    {
422        yyn = *yys;
423        if (yyn >= '0' && yyn <= '9')
424            yydebug = yyn - '0';
425    }
426#endif
427
428    yynerrs = 0;
429    yyerrflag = 0;
430    yychar = YYEMPTY;
431    yystate = 0;
432
433#if YYPURE
434    memset(&yystack, 0, sizeof(yystack));
435#endif
436
437    if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
438    yystack.s_mark = yystack.s_base;
439    yystack.l_mark = yystack.l_base;
440    yystate = 0;
441    *yystack.s_mark = 0;
442
443yyloop:
444    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
445    if (yychar < 0)
446    {
447        if ((yychar = YYLEX) < 0) yychar = YYEOF;
448#if YYDEBUG
449        if (yydebug)
450        {
451            yys = yyname[YYTRANSLATE(yychar)];
452            printf("%sdebug: state %d, reading %d (%s)\n",
453                    YYPREFIX, yystate, yychar, yys);
454        }
455#endif
456    }
457    if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
458            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
459    {
460#if YYDEBUG
461        if (yydebug)
462            printf("%sdebug: state %d, shifting to state %d\n",
463                    YYPREFIX, yystate, yytable[yyn]);
464#endif
465        if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
466        {
467            goto yyoverflow;
468        }
469        yystate = yytable[yyn];
470        *++yystack.s_mark = yytable[yyn];
471        *++yystack.l_mark = yylval;
472        yychar = YYEMPTY;
473        if (yyerrflag > 0)  --yyerrflag;
474        goto yyloop;
475    }
476    if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
477            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
478    {
479        yyn = yytable[yyn];
480        goto yyreduce;
481    }
482    if (yyerrflag) goto yyinrecovery;
483
484    YYERROR_CALL("syntax error");
485
486    goto yyerrlab;
487
488yyerrlab:
489    ++yynerrs;
490
491yyinrecovery:
492    if (yyerrflag < 3)
493    {
494        yyerrflag = 3;
495        for (;;)
496        {
497            if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
498                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
499            {
500#if YYDEBUG
501                if (yydebug)
502                    printf("%sdebug: state %d, error recovery shifting\
503 to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
504#endif
505                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
506                {
507                    goto yyoverflow;
508                }
509                yystate = yytable[yyn];
510                *++yystack.s_mark = yytable[yyn];
511                *++yystack.l_mark = yylval;
512                goto yyloop;
513            }
514            else
515            {
516#if YYDEBUG
517                if (yydebug)
518                    printf("%sdebug: error recovery discarding state %d\n",
519                            YYPREFIX, *yystack.s_mark);
520#endif
521                if (yystack.s_mark <= yystack.s_base) goto yyabort;
522                --yystack.s_mark;
523                --yystack.l_mark;
524            }
525        }
526    }
527    else
528    {
529        if (yychar == YYEOF) goto yyabort;
530#if YYDEBUG
531        if (yydebug)
532        {
533            yys = yyname[YYTRANSLATE(yychar)];
534            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
535                    YYPREFIX, yystate, yychar, yys);
536        }
537#endif
538        yychar = YYEMPTY;
539        goto yyloop;
540    }
541
542yyreduce:
543#if YYDEBUG
544    if (yydebug)
545        printf("%sdebug: state %d, reducing by rule %d (%s)\n",
546                YYPREFIX, yystate, yyn, yyrule[yyn]);
547#endif
548    yym = yylen[yyn];
549    if (yym)
550        yyval = yystack.l_mark[1-yym];
551    else
552        memset(&yyval, 0, sizeof yyval);
553    switch (yyn)
554    {
555case 3:
556#line 28 "calc.y"
557	{  yyerrok ; }
558break;
559case 4:
560#line 32 "calc.y"
561	{  printf("%d\n",yystack.l_mark[0]);}
562break;
563case 5:
564#line 34 "calc.y"
565	{  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
566break;
567case 6:
568#line 38 "calc.y"
569	{  yyval = yystack.l_mark[-1]; }
570break;
571case 7:
572#line 40 "calc.y"
573	{  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
574break;
575case 8:
576#line 42 "calc.y"
577	{  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
578break;
579case 9:
580#line 44 "calc.y"
581	{  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
582break;
583case 10:
584#line 46 "calc.y"
585	{  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
586break;
587case 11:
588#line 48 "calc.y"
589	{  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
590break;
591case 12:
592#line 50 "calc.y"
593	{  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
594break;
595case 13:
596#line 52 "calc.y"
597	{  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
598break;
599case 14:
600#line 54 "calc.y"
601	{  yyval = - yystack.l_mark[0]; }
602break;
603case 15:
604#line 56 "calc.y"
605	{  yyval = regs[yystack.l_mark[0]]; }
606break;
607case 17:
608#line 61 "calc.y"
609	{  yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
610break;
611case 18:
612#line 63 "calc.y"
613	{  yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
614break;
615#line 616 "calc.tab.c"
616    }
617    yystack.s_mark -= yym;
618    yystate = *yystack.s_mark;
619    yystack.l_mark -= yym;
620    yym = yylhs[yyn];
621    if (yystate == 0 && yym == 0)
622    {
623#if YYDEBUG
624        if (yydebug)
625            printf("%sdebug: after reduction, shifting from state 0 to\
626 state %d\n", YYPREFIX, YYFINAL);
627#endif
628        yystate = YYFINAL;
629        *++yystack.s_mark = YYFINAL;
630        *++yystack.l_mark = yyval;
631        if (yychar < 0)
632        {
633            if ((yychar = YYLEX) < 0) yychar = YYEOF;
634#if YYDEBUG
635            if (yydebug)
636            {
637                yys = yyname[YYTRANSLATE(yychar)];
638                printf("%sdebug: state %d, reading %d (%s)\n",
639                        YYPREFIX, YYFINAL, yychar, yys);
640            }
641#endif
642        }
643        if (yychar == YYEOF) goto yyaccept;
644        goto yyloop;
645    }
646    if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
647            yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
648        yystate = yytable[yyn];
649    else
650        yystate = yydgoto[yym];
651#if YYDEBUG
652    if (yydebug)
653        printf("%sdebug: after reduction, shifting from state %d \
654to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
655#endif
656    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
657    {
658        goto yyoverflow;
659    }
660    *++yystack.s_mark = (YYINT) yystate;
661    *++yystack.l_mark = yyval;
662    goto yyloop;
663
664yyoverflow:
665    YYERROR_CALL("yacc stack overflow");
666
667yyabort:
668    yyfreestack(&yystack);
669    return (1);
670
671yyaccept:
672    yyfreestack(&yystack);
673    return (0);
674}
675