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