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