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