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