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