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