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