1 /* $NetBSD: btyaccpar.c,v 1.2 2015/01/04 01:34:20 christos Exp $ */
2
3 /* This file generated automatically using
4 * @Id: skel2c,v 1.3 2014/04/06 19:48:04 tom Exp @
5 */
6
7 /* @Id: btyaccpar.skel,v 1.1 2014/04/02 22:44:41 tom Exp @ */
8
9 #include "defs.h"
10
11 /* If the skeleton is changed, the banner should be changed so that */
12 /* the altered version can be easily distinguished from the original. */
13 /* */
14 /* The #defines included with the banner are there because they are */
15 /* useful in subsequent code. The macros #defined in the header or */
16 /* the body either are not useful outside of semantic actions or */
17 /* are conditional. */
18
19 const char *const banner[] =
20 {
21 "/* original parser id follows */",
22 "/* yysccsid[] = \"@(#)yaccpar 1.9 (Berkeley) 02/21/93\" */",
23 "/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */",
24 "",
25 "#define YYBYACC 1",
26 CONCAT1("#define YYMAJOR ", YYMAJOR),
27 CONCAT1("#define YYMINOR ", YYMINOR),
28 #ifdef YYPATCH
29 CONCAT1("#define YYPATCH ", YYPATCH),
30 #endif
31 "",
32 "#define YYEMPTY (-1)",
33 "#define yyclearin (yychar = YYEMPTY)",
34 "#define yyerrok (yyerrflag = 0)",
35 "#define YYRECOVERING() (yyerrflag != 0)",
36 "#define YYENOMEM (-2)",
37 "#define YYEOF 0",
38 0
39 };
40
41 const char *const xdecls[] =
42 {
43 "",
44 "extern int YYPARSE_DECL();",
45 0
46 };
47
48 const char *const tables[] =
49 {
50 "extern const YYINT yylhs[];",
51 "extern const YYINT yylen[];",
52 "extern const YYINT yydefred[];",
53 "extern const YYINT yystos[];",
54 "extern const YYINT yydgoto[];",
55 "extern const YYINT yysindex[];",
56 "extern const YYINT yyrindex[];",
57 #if defined(YYBTYACC)
58 "#if YYBTYACC",
59 "extern const YYINT yycindex[];",
60 "#endif /* YYBTYACC */",
61 #endif /* defined(YYBTYACC) */
62 "extern const YYINT yygindex[];",
63 "extern const YYINT yytable[];",
64 "extern const YYINT yycheck[];",
65 #if defined(YYBTYACC)
66 "#if YYBTYACC",
67 "extern const YYINT yyctable[];",
68 "#endif /* YYBTYACC */",
69 #endif /* defined(YYBTYACC) */
70 "",
71 "#if YYDEBUG",
72 "extern const char *const yyname[];",
73 "extern const char *const yyrule[];",
74 "#endif",
75 0
76 };
77
78 const char *const global_vars[] =
79 {
80 "",
81 "int yydebug;",
82 "int yynerrs;",
83 0
84 };
85
86 const char *const impure_vars[] =
87 {
88 "",
89 "int yyerrflag;",
90 "int yychar;",
91 "YYSTYPE yyval;",
92 "YYSTYPE yylval;",
93 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
94 "YYLTYPE yyloc; /* position returned by actions */",
95 "YYLTYPE yylloc; /* position from the lexer */",
96 "#endif",
97 0
98 };
99
100 const char *const hdr_defs[] =
101 {
102 "",
103 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
104 "#ifndef YYLLOC_DEFAULT",
105 "#define YYLLOC_DEFAULT(loc, rhs, n) \\",
106 "do \\",
107 "{ \\",
108 " if (n == 0) \\",
109 " { \\",
110 " (loc).first_line = ((rhs)[-1]).last_line; \\",
111 " (loc).first_column = ((rhs)[-1]).last_column; \\",
112 " (loc).last_line = ((rhs)[-1]).last_line; \\",
113 " (loc).last_column = ((rhs)[-1]).last_column; \\",
114 " } \\",
115 " else \\",
116 " { \\",
117 " (loc).first_line = ((rhs)[ 0 ]).first_line; \\",
118 " (loc).first_column = ((rhs)[ 0 ]).first_column; \\",
119 " (loc).last_line = ((rhs)[n-1]).last_line; \\",
120 " (loc).last_column = ((rhs)[n-1]).last_column; \\",
121 " } \\",
122 "} while (0)",
123 "#endif /* YYLLOC_DEFAULT */",
124 "#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */",
125 #if defined(YYBTYACC)
126 "#if YYBTYACC",
127 "",
128 "#ifndef YYLVQUEUEGROWTH",
129 "#define YYLVQUEUEGROWTH 32",
130 "#endif",
131 "#endif /* YYBTYACC */",
132 #endif /* defined(YYBTYACC) */
133 "",
134 "/* define the initial stack-sizes */",
135 "#ifdef YYSTACKSIZE",
136 "#undef YYMAXDEPTH",
137 "#define YYMAXDEPTH YYSTACKSIZE",
138 "#else",
139 "#ifdef YYMAXDEPTH",
140 "#define YYSTACKSIZE YYMAXDEPTH",
141 "#else",
142 "#define YYSTACKSIZE 10000",
143 "#define YYMAXDEPTH 10000",
144 "#endif",
145 "#endif",
146 "",
147 "#ifndef YYINITSTACKSIZE",
148 "#define YYINITSTACKSIZE 200",
149 "#endif",
150 "",
151 "typedef struct {",
152 " unsigned stacksize;",
153 " short *s_base;",
154 " short *s_mark;",
155 " short *s_last;",
156 " YYSTYPE *l_base;",
157 " YYSTYPE *l_mark;",
158 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
159 " YYLTYPE *p_base;",
160 " YYLTYPE *p_mark;",
161 "#endif",
162 "} YYSTACKDATA;",
163 #if defined(YYBTYACC)
164 "#if YYBTYACC",
165 "",
166 "struct YYParseState_s",
167 "{",
168 " struct YYParseState_s *save; /* Previously saved parser state */",
169 " YYSTACKDATA yystack; /* saved parser stack */",
170 " int state; /* saved parser state */",
171 " int errflag; /* saved error recovery status */",
172 " int lexeme; /* saved index of the conflict lexeme in the lexical queue */",
173 " YYINT ctry; /* saved index in yyctable[] for this conflict */",
174 "};",
175 "typedef struct YYParseState_s YYParseState;",
176 "#endif /* YYBTYACC */",
177 #endif /* defined(YYBTYACC) */
178 0
179 };
180
181 const char *const hdr_vars[] =
182 {
183 "/* variables for the parser stack */",
184 "static YYSTACKDATA yystack;",
185 #if defined(YYBTYACC)
186 "#if YYBTYACC",
187 "",
188 "/* Current parser state */",
189 "static YYParseState *yyps = 0;",
190 "",
191 "/* yypath != NULL: do the full parse, starting at *yypath parser state. */",
192 "static YYParseState *yypath = 0;",
193 "",
194 "/* Base of the lexical value queue */",
195 "static YYSTYPE *yylvals = 0;",
196 "",
197 "/* Current position at lexical value queue */",
198 "static YYSTYPE *yylvp = 0;",
199 "",
200 "/* End position of lexical value queue */",
201 "static YYSTYPE *yylve = 0;",
202 "",
203 "/* The last allocated position at the lexical value queue */",
204 "static YYSTYPE *yylvlim = 0;",
205 "",
206 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
207 "/* Base of the lexical position queue */",
208 "static YYLTYPE *yylpsns = 0;",
209 "",
210 "/* Current position at lexical position queue */",
211 "static YYLTYPE *yylpp = 0;",
212 "",
213 "/* End position of lexical position queue */",
214 "static YYLTYPE *yylpe = 0;",
215 "",
216 "/* The last allocated position at the lexical position queue */",
217 "static YYLTYPE *yylplim = 0;",
218 "#endif",
219 "",
220 "/* Current position at lexical token queue */",
221 "static short *yylexp = 0;",
222 "",
223 "static short *yylexemes = 0;",
224 "#endif /* YYBTYACC */",
225 #endif /* defined(YYBTYACC) */
226 0
227 };
228
229 const char *const body_vars[] =
230 {
231 " int yyerrflag;",
232 " int yychar;",
233 " YYSTYPE yyval;",
234 " YYSTYPE yylval;",
235 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
236 " YYLTYPE yyloc; /* position returned by actions */",
237 " YYLTYPE yylloc; /* position from the lexer */",
238 "#endif",
239 "",
240 " /* variables for the parser stack */",
241 " YYSTACKDATA yystack;",
242 #if defined(YYBTYACC)
243 "#if YYBTYACC",
244 "",
245 " /* Current parser state */",
246 " static YYParseState *yyps = 0;",
247 "",
248 " /* yypath != NULL: do the full parse, starting at *yypath parser state. */",
249 " static YYParseState *yypath = 0;",
250 "",
251 " /* Base of the lexical value queue */",
252 " static YYSTYPE *yylvals = 0;",
253 "",
254 " /* Current position at lexical value queue */",
255 " static YYSTYPE *yylvp = 0;",
256 "",
257 " /* End position of lexical value queue */",
258 " static YYSTYPE *yylve = 0;",
259 "",
260 " /* The last allocated position at the lexical value queue */",
261 " static YYSTYPE *yylvlim = 0;",
262 "",
263 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
264 " /* Base of the lexical position queue */",
265 " static YYLTYPE *yylpsns = 0;",
266 "",
267 " /* Current position at lexical position queue */",
268 " static YYLTYPE *yylpp = 0;",
269 "",
270 " /* End position of lexical position queue */",
271 " static YYLTYPE *yylpe = 0;",
272 "",
273 " /* The last allocated position at the lexical position queue */",
274 " static YYLTYPE *yylplim = 0;",
275 "#endif",
276 "",
277 " /* Current position at lexical token queue */",
278 " static short *yylexp = 0;",
279 "",
280 " static short *yylexemes = 0;",
281 "#endif /* YYBTYACC */",
282 #endif /* defined(YYBTYACC) */
283 0
284 };
285
286 const char *const body_1[] =
287 {
288 "",
289 "/* For use in generated program */",
290 "#define yydepth (int)(yystack.s_mark - yystack.s_base)",
291 #if defined(YYBTYACC)
292 "#if YYBTYACC",
293 "#define yytrial (yyps->save)",
294 "#endif /* YYBTYACC */",
295 #endif /* defined(YYBTYACC) */
296 "",
297 "#if YYDEBUG",
298 "#include <stdio.h> /* needed for printf */",
299 "#endif",
300 "",
301 "#include <stdlib.h> /* needed for malloc, etc */",
302 "#include <string.h> /* needed for memset */",
303 "",
304 "/* allocate initial stack or double stack size, up to YYMAXDEPTH */",
305 "static int yygrowstack(YYSTACKDATA *data)",
306 "{",
307 " int i;",
308 " unsigned newsize;",
309 " short *newss;",
310 " YYSTYPE *newvs;",
311 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
312 " YYLTYPE *newps;",
313 "#endif",
314 "",
315 " if ((newsize = data->stacksize) == 0)",
316 " newsize = YYINITSTACKSIZE;",
317 " else if (newsize >= YYMAXDEPTH)",
318 " return YYENOMEM;",
319 " else if ((newsize *= 2) > YYMAXDEPTH)",
320 " newsize = YYMAXDEPTH;",
321 "",
322 " i = (int) (data->s_mark - data->s_base);",
323 " newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));",
324 " if (newss == 0)",
325 " return YYENOMEM;",
326 "",
327 " data->s_base = newss;",
328 " data->s_mark = newss + i;",
329 "",
330 " newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));",
331 " if (newvs == 0)",
332 " return YYENOMEM;",
333 "",
334 " data->l_base = newvs;",
335 " data->l_mark = newvs + i;",
336 "",
337 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
338 " newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));",
339 " if (newps == 0)",
340 " return YYENOMEM;",
341 "",
342 " data->p_base = newps;",
343 " data->p_mark = newps + i;",
344 "#endif",
345 "",
346 " data->stacksize = newsize;",
347 " data->s_last = data->s_base + newsize - 1;",
348 "",
349 "#if YYDEBUG",
350 " if (yydebug)",
351 " fprintf(stderr, \"%sdebug: stack size increased to %d\\n\", YYPREFIX, newsize);",
352 "#endif",
353 " return 0;",
354 "}",
355 "",
356 "#if YYPURE || defined(YY_NO_LEAKS)",
357 "static void yyfreestack(YYSTACKDATA *data)",
358 "{",
359 " free(data->s_base);",
360 " free(data->l_base);",
361 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
362 " free(data->p_base);",
363 "#endif",
364 " memset(data, 0, sizeof(*data));",
365 "}",
366 "#else",
367 "#define yyfreestack(data) /* nothing */",
368 "#endif /* YYPURE || defined(YY_NO_LEAKS) */",
369 #if defined(YYBTYACC)
370 "#if YYBTYACC",
371 "",
372 "static YYParseState *",
373 "yyNewState(unsigned size)",
374 "{",
375 " YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));",
376 " if (p == NULL) return NULL;",
377 "",
378 " p->yystack.stacksize = size;",
379 " if (size == 0)",
380 " {",
381 " p->yystack.s_base = NULL;",
382 " p->yystack.l_base = NULL;",
383 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
384 " p->yystack.p_base = NULL;",
385 "#endif",
386 " return p;",
387 " }",
388 " p->yystack.s_base = (short *) malloc(size * sizeof(short));",
389 " if (p->yystack.s_base == NULL) return NULL;",
390 " p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));",
391 " if (p->yystack.l_base == NULL) return NULL;",
392 " memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));",
393 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
394 " p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));",
395 " if (p->yystack.p_base == NULL) return NULL;",
396 " memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));",
397 "#endif",
398 "",
399 " return p;",
400 "}",
401 "",
402 "static void",
403 "yyFreeState(YYParseState *p)",
404 "{",
405 " yyfreestack(&p->yystack);",
406 " free(p);",
407 "}",
408 "#endif /* YYBTYACC */",
409 #endif /* defined(YYBTYACC) */
410 "",
411 "#define YYABORT goto yyabort",
412 "#define YYREJECT goto yyabort",
413 "#define YYACCEPT goto yyaccept",
414 "#define YYERROR goto yyerrlab",
415 #if defined(YYBTYACC)
416 "#if YYBTYACC",
417 "#define YYVALID do { if (yyps->save) goto yyvalid; } while(0)",
418 "#define YYVALID_NESTED do { if (yyps->save && \\",
419 " yyps->save->save == 0) goto yyvalid; } while(0)",
420 "#endif /* YYBTYACC */",
421 #endif /* defined(YYBTYACC) */
422 "",
423 "int",
424 "YYPARSE_DECL()",
425 "{",
426 0
427 };
428
429 const char *const body_2[] =
430 {
431 " int yym, yyn, yystate, yyresult;",
432 #if defined(YYBTYACC)
433 "#if YYBTYACC",
434 " int yynewerrflag;",
435 " YYParseState *yyerrctx = NULL;",
436 "#endif /* YYBTYACC */",
437 #endif /* defined(YYBTYACC) */
438 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
439 " YYLTYPE yyerror_loc_range[2]; /* position of error start & end */",
440 "#endif",
441 "#if YYDEBUG",
442 " const char *yys;",
443 "",
444 " if ((yys = getenv(\"YYDEBUG\")) != 0)",
445 " {",
446 " yyn = *yys;",
447 " if (yyn >= '0' && yyn <= '9')",
448 " yydebug = yyn - '0';",
449 " }",
450 " if (yydebug)",
451 " fprintf(stderr, \"%sdebug[<# of symbols on state stack>]\\n\", YYPREFIX);",
452 "#endif",
453 "",
454 0
455 };
456
457 const char *const body_3[] = {
458 #if defined(YYBTYACC)
459 "#if YYBTYACC",
460 " yyps = yyNewState(0); if (yyps == 0) goto yyenomem;",
461 " yyps->save = 0;",
462 "#endif /* YYBTYACC */",
463 #endif /* defined(YYBTYACC) */
464 " yynerrs = 0;",
465 " yyerrflag = 0;",
466 " yychar = YYEMPTY;",
467 " yystate = 0;",
468 "",
469 "#if YYPURE",
470 " memset(&yystack, 0, sizeof(yystack));",
471 "#endif",
472 "",
473 " if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;",
474 " yystack.s_mark = yystack.s_base;",
475 " yystack.l_mark = yystack.l_base;",
476 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
477 " yystack.p_mark = yystack.p_base;",
478 "#endif",
479 " yystate = 0;",
480 " *yystack.s_mark = 0;",
481 "",
482 "yyloop:",
483 " if ((yyn = yydefred[yystate]) != 0) goto yyreduce;",
484 " if (yychar < 0)",
485 " {",
486 #if defined(YYBTYACC)
487 "#if YYBTYACC",
488 " do {",
489 " if (yylvp < yylve)",
490 " {",
491 " /* we're currently re-reading tokens */",
492 " yylval = *yylvp++;",
493 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
494 " yylloc = *yylpp++;",
495 "#endif",
496 " yychar = *yylexp++;",
497 " break;",
498 " }",
499 " if (yyps->save)",
500 " {",
501 " /* in trial mode; save scanner results for future parse attempts */",
502 " if (yylvp == yylvlim)",
503 " { /* Enlarge lexical value queue */",
504 " size_t p = (size_t) (yylvp - yylvals);",
505 " size_t s = (size_t) (yylvlim - yylvals);",
506 "",
507 " s += YYLVQUEUEGROWTH;",
508 " if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;",
509 " if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;",
510 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
511 " if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;",
512 "#endif",
513 " yylvp = yylve = yylvals + p;",
514 " yylvlim = yylvals + s;",
515 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
516 " yylpp = yylpe = yylpsns + p;",
517 " yylplim = yylpsns + s;",
518 "#endif",
519 " yylexp = yylexemes + p;",
520 " }",
521 " *yylexp = (short) YYLEX;",
522 " *yylvp++ = yylval;",
523 " yylve++;",
524 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
525 " *yylpp++ = yylloc;",
526 " yylpe++;",
527 "#endif",
528 " yychar = *yylexp++;",
529 " break;",
530 " }",
531 " /* normal operation, no conflict encountered */",
532 "#endif /* YYBTYACC */",
533 #endif /* defined(YYBTYACC) */
534 " yychar = YYLEX;",
535 #if defined(YYBTYACC)
536 "#if YYBTYACC",
537 " } while (0);",
538 "#endif /* YYBTYACC */",
539 #endif /* defined(YYBTYACC) */
540 " if (yychar < 0) yychar = YYEOF;",
541 " /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */",
542 "#if YYDEBUG",
543 " if (yydebug)",
544 " {",
545 " yys = yyname[YYTRANSLATE(yychar)];",
546 " fprintf(stderr, \"%s[%d]: state %d, reading token %d (%s)\",",
547 " YYDEBUGSTR, yydepth, yystate, yychar, yys);",
548 "#ifdef YYSTYPE_TOSTRING",
549 #if defined(YYBTYACC)
550 "#if YYBTYACC",
551 " if (!yytrial)",
552 "#endif /* YYBTYACC */",
553 #endif /* defined(YYBTYACC) */
554 " fprintf(stderr, \" <%s>\", YYSTYPE_TOSTRING(yychar, yylval));",
555 "#endif",
556 " fputc('\\n', stderr);",
557 " }",
558 "#endif",
559 " }",
560 #if defined(YYBTYACC)
561 "#if YYBTYACC",
562 "",
563 " /* Do we have a conflict? */",
564 " if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&",
565 " yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)",
566 " {",
567 " YYINT ctry;",
568 "",
569 " if (yypath)",
570 " {",
571 " YYParseState *save;",
572 "#if YYDEBUG",
573 " if (yydebug)",
574 " fprintf(stderr, \"%s[%d]: CONFLICT in state %d: following successful trial parse\\n\",",
575 " YYDEBUGSTR, yydepth, yystate);",
576 "#endif",
577 " /* Switch to the next conflict context */",
578 " save = yypath;",
579 " yypath = save->save;",
580 " save->save = NULL;",
581 " ctry = save->ctry;",
582 " if (save->state != yystate) YYABORT;",
583 " yyFreeState(save);",
584 "",
585 " }",
586 " else",
587 " {",
588 "",
589 " /* Unresolved conflict - start/continue trial parse */",
590 " YYParseState *save;",
591 "#if YYDEBUG",
592 " if (yydebug)",
593 " {",
594 " fprintf(stderr, \"%s[%d]: CONFLICT in state %d. \", YYDEBUGSTR, yydepth, yystate);",
595 " if (yyps->save)",
596 " fputs(\"ALREADY in conflict, continuing trial parse.\\n\", stderr);",
597 " else",
598 " fputs(\"Starting trial parse.\\n\", stderr);",
599 " }",
600 "#endif",
601 " save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));",
602 " if (save == NULL) goto yyenomem;",
603 " save->save = yyps->save;",
604 " save->state = yystate;",
605 " save->errflag = yyerrflag;",
606 " save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);",
607 " memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));",
608 " save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);",
609 " memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",
610 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
611 " save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);",
612 " memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",
613 "#endif",
614 " ctry = yytable[yyn];",
615 " if (yyctable[ctry] == -1)",
616 " {",
617 "#if YYDEBUG",
618 " if (yydebug && yychar >= YYEOF)",
619 " fprintf(stderr, \"%s[%d]: backtracking 1 token\\n\", YYDEBUGSTR, yydepth);",
620 "#endif",
621 " ctry++;",
622 " }",
623 " save->ctry = ctry;",
624 " if (yyps->save == NULL)",
625 " {",
626 " /* If this is a first conflict in the stack, start saving lexemes */",
627 " if (!yylexemes)",
628 " {",
629 " yylexemes = (short *) malloc((YYLVQUEUEGROWTH) * sizeof(short));",
630 " if (yylexemes == NULL) goto yyenomem;",
631 " yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));",
632 " if (yylvals == NULL) goto yyenomem;",
633 " yylvlim = yylvals + YYLVQUEUEGROWTH;",
634 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
635 " yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));",
636 " if (yylpsns == NULL) goto yyenomem;",
637 " yylplim = yylpsns + YYLVQUEUEGROWTH;",
638 "#endif",
639 " }",
640 " if (yylvp == yylve)",
641 " {",
642 " yylvp = yylve = yylvals;",
643 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
644 " yylpp = yylpe = yylpsns;",
645 "#endif",
646 " yylexp = yylexemes;",
647 " if (yychar >= YYEOF)",
648 " {",
649 " *yylve++ = yylval;",
650 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
651 " *yylpe++ = yylloc;",
652 "#endif",
653 " *yylexp = (short) yychar;",
654 " yychar = YYEMPTY;",
655 " }",
656 " }",
657 " }",
658 " if (yychar >= YYEOF)",
659 " {",
660 " yylvp--;",
661 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
662 " yylpp--;",
663 "#endif",
664 " yylexp--;",
665 " yychar = YYEMPTY;",
666 " }",
667 " save->lexeme = (int) (yylvp - yylvals);",
668 " yyps->save = save;",
669 " }",
670 " if (yytable[yyn] == ctry)",
671 " {",
672 "#if YYDEBUG",
673 " if (yydebug)",
674 " fprintf(stderr, \"%s[%d]: state %d, shifting to state %d\\n\",",
675 " YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);",
676 "#endif",
677 " if (yychar < 0)",
678 " {",
679 " yylvp++;",
680 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
681 " yylpp++;",
682 "#endif",
683 " yylexp++;",
684 " }",
685 " if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)",
686 " goto yyoverflow;",
687 " yystate = yyctable[ctry];",
688 " *++yystack.s_mark = (short) yystate;",
689 " *++yystack.l_mark = yylval;",
690 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
691 " *++yystack.p_mark = yylloc;",
692 "#endif",
693 " yychar = YYEMPTY;",
694 " if (yyerrflag > 0) --yyerrflag;",
695 " goto yyloop;",
696 " }",
697 " else",
698 " {",
699 " yyn = yyctable[ctry];",
700 " goto yyreduce;",
701 " }",
702 " } /* End of code dealing with conflicts */",
703 "#endif /* YYBTYACC */",
704 #endif /* defined(YYBTYACC) */
705 " if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&",
706 " yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)",
707 " {",
708 "#if YYDEBUG",
709 " if (yydebug)",
710 " fprintf(stderr, \"%s[%d]: state %d, shifting to state %d\\n\",",
711 " YYDEBUGSTR, yydepth, yystate, yytable[yyn]);",
712 "#endif",
713 " if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;",
714 " yystate = yytable[yyn];",
715 " *++yystack.s_mark = yytable[yyn];",
716 " *++yystack.l_mark = yylval;",
717 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
718 " *++yystack.p_mark = yylloc;",
719 "#endif",
720 " yychar = YYEMPTY;",
721 " if (yyerrflag > 0) --yyerrflag;",
722 " goto yyloop;",
723 " }",
724 " if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&",
725 " yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)",
726 " {",
727 " yyn = yytable[yyn];",
728 " goto yyreduce;",
729 " }",
730 " if (yyerrflag != 0) goto yyinrecovery;",
731 #if defined(YYBTYACC)
732 "#if YYBTYACC",
733 "",
734 " yynewerrflag = 1;",
735 " goto yyerrhandler;",
736 " goto yyerrlab;",
737 "",
738 "yyerrlab:",
739 " yynewerrflag = 0;",
740 "yyerrhandler:",
741 " while (yyps->save)",
742 " {",
743 " int ctry;",
744 " YYParseState *save = yyps->save;",
745 "#if YYDEBUG",
746 " if (yydebug)",
747 " fprintf(stderr, \"%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\\n\",",
748 " YYDEBUGSTR, yydepth, yystate, yyps->save->state,",
749 " (int)(yylvp - yylvals - yyps->save->lexeme));",
750 "#endif",
751 " /* Memorize most forward-looking error state in case it's really an error. */",
752 " if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)",
753 " {",
754 " /* Free old saved error context state */",
755 " if (yyerrctx) yyFreeState(yyerrctx);",
756 " /* Create and fill out new saved error context state */",
757 " yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));",
758 " if (yyerrctx == NULL) goto yyenomem;",
759 " yyerrctx->save = yyps->save;",
760 " yyerrctx->state = yystate;",
761 " yyerrctx->errflag = yyerrflag;",
762 " yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);",
763 " memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));",
764 " yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);",
765 " memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",
766 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
767 " yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);",
768 " memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",
769 "#endif",
770 " yyerrctx->lexeme = (int) (yylvp - yylvals);",
771 " }",
772 " yylvp = yylvals + save->lexeme;",
773 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
774 " yylpp = yylpsns + save->lexeme;",
775 "#endif",
776 " yylexp = yylexemes + save->lexeme;",
777 " yychar = YYEMPTY;",
778 " yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);",
779 " memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));",
780 " yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);",
781 " memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",
782 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
783 " yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);",
784 " memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",
785 "#endif",
786 " ctry = ++save->ctry;",
787 " yystate = save->state;",
788 " /* We tried shift, try reduce now */",
789 " if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;",
790 " yyps->save = save->save;",
791 " save->save = NULL;",
792 " yyFreeState(save);",
793 "",
794 " /* Nothing left on the stack -- error */",
795 " if (!yyps->save)",
796 " {",
797 "#if YYDEBUG",
798 " if (yydebug)",
799 " fprintf(stderr, \"%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\\n\",",
800 " YYPREFIX, yydepth);",
801 "#endif",
802 " /* Restore state as it was in the most forward-advanced error */",
803 " yylvp = yylvals + yyerrctx->lexeme;",
804 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
805 " yylpp = yylpsns + yyerrctx->lexeme;",
806 "#endif",
807 " yylexp = yylexemes + yyerrctx->lexeme;",
808 " yychar = yylexp[-1];",
809 " yylval = yylvp[-1];",
810 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
811 " yylloc = yylpp[-1];",
812 "#endif",
813 " yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);",
814 " memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));",
815 " yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);",
816 " memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",
817 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
818 " yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);",
819 " memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",
820 "#endif",
821 " yystate = yyerrctx->state;",
822 " yyFreeState(yyerrctx);",
823 " yyerrctx = NULL;",
824 " }",
825 " yynewerrflag = 1;",
826 " }",
827 " if (yynewerrflag == 0) goto yyinrecovery;",
828 "#endif /* YYBTYACC */",
829 #endif /* defined(YYBTYACC) */
830 "",
831 " YYERROR_CALL(\"syntax error\");",
832 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
833 " yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */",
834 "#endif",
835 "",
836 "#if !YYBTYACC",
837 " goto yyerrlab;",
838 "yyerrlab:",
839 "#endif",
840 " ++yynerrs;",
841 "",
842 "yyinrecovery:",
843 " if (yyerrflag < 3)",
844 " {",
845 " yyerrflag = 3;",
846 " for (;;)",
847 " {",
848 " if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&",
849 " yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)",
850 " {",
851 "#if YYDEBUG",
852 " if (yydebug)",
853 " fprintf(stderr, \"%s[%d]: state %d, error recovery shifting to state %d\\n\",",
854 " YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);",
855 "#endif",
856 " if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;",
857 " yystate = yytable[yyn];",
858 " *++yystack.s_mark = yytable[yyn];",
859 " *++yystack.l_mark = yylval;",
860 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
861 " /* lookahead position is error end position */",
862 " yyerror_loc_range[1] = yylloc;",
863 " YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */",
864 " *++yystack.p_mark = yyloc;",
865 "#endif",
866 " goto yyloop;",
867 " }",
868 " else",
869 " {",
870 "#if YYDEBUG",
871 " if (yydebug)",
872 " fprintf(stderr, \"%s[%d]: error recovery discarding state %d\\n\",",
873 " YYDEBUGSTR, yydepth, *yystack.s_mark);",
874 "#endif",
875 " if (yystack.s_mark <= yystack.s_base) goto yyabort;",
876 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
877 " /* the current TOS position is the error start position */",
878 " yyerror_loc_range[0] = *yystack.p_mark;",
879 "#endif",
880 "#if defined(YYDESTRUCT_CALL)",
881 #if defined(YYBTYACC)
882 "#if YYBTYACC",
883 " if (!yytrial)",
884 "#endif /* YYBTYACC */",
885 #endif /* defined(YYBTYACC) */
886 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
887 " YYDESTRUCT_CALL(\"error: discarding state\",",
888 " yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);",
889 "#else",
890 " YYDESTRUCT_CALL(\"error: discarding state\",",
891 " yystos[*yystack.s_mark], yystack.l_mark);",
892 "#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */",
893 "#endif /* defined(YYDESTRUCT_CALL) */",
894 " --yystack.s_mark;",
895 " --yystack.l_mark;",
896 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
897 " --yystack.p_mark;",
898 "#endif",
899 " }",
900 " }",
901 " }",
902 " else",
903 " {",
904 " if (yychar == YYEOF) goto yyabort;",
905 "#if YYDEBUG",
906 " if (yydebug)",
907 " {",
908 " yys = yyname[YYTRANSLATE(yychar)];",
909 " fprintf(stderr, \"%s[%d]: state %d, error recovery discarding token %d (%s)\\n\",",
910 " YYDEBUGSTR, yydepth, yystate, yychar, yys);",
911 " }",
912 "#endif",
913 "#if defined(YYDESTRUCT_CALL)",
914 #if defined(YYBTYACC)
915 "#if YYBTYACC",
916 " if (!yytrial)",
917 "#endif /* YYBTYACC */",
918 #endif /* defined(YYBTYACC) */
919 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
920 " YYDESTRUCT_CALL(\"error: discarding token\", yychar, &yylval, &yylloc);",
921 "#else",
922 " YYDESTRUCT_CALL(\"error: discarding token\", yychar, &yylval);",
923 "#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */",
924 "#endif /* defined(YYDESTRUCT_CALL) */",
925 " yychar = YYEMPTY;",
926 " goto yyloop;",
927 " }",
928 "",
929 "yyreduce:",
930 " yym = yylen[yyn];",
931 "#if YYDEBUG",
932 " if (yydebug)",
933 " {",
934 " fprintf(stderr, \"%s[%d]: state %d, reducing by rule %d (%s)\",",
935 " YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);",
936 "#ifdef YYSTYPE_TOSTRING",
937 #if defined(YYBTYACC)
938 "#if YYBTYACC",
939 " if (!yytrial)",
940 "#endif /* YYBTYACC */",
941 #endif /* defined(YYBTYACC) */
942 " if (yym > 0)",
943 " {",
944 " int i;",
945 " fputc('<', stderr);",
946 " for (i = yym; i > 0; i--)",
947 " {",
948 " if (i != yym) fputs(\", \", stderr);",
949 " fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],",
950 " yystack.l_mark[1-i]), stderr);",
951 " }",
952 " fputc('>', stderr);",
953 " }",
954 "#endif",
955 " fputc('\\n', stderr);",
956 " }",
957 "#endif",
958 " if (yym > 0)",
959 " yyval = yystack.l_mark[1-yym];",
960 " else",
961 " memset(&yyval, 0, sizeof yyval);",
962 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
963 "",
964 " /* Perform position reduction */",
965 " memset(&yyloc, 0, sizeof(yyloc));",
966 #if defined(YYBTYACC)
967 "#if YYBTYACC",
968 " if (!yytrial)",
969 "#endif /* YYBTYACC */",
970 #endif /* defined(YYBTYACC) */
971 " {",
972 " YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);",
973 " /* just in case YYERROR is invoked within the action, save",
974 " the start of the rhs as the error start position */",
975 " yyerror_loc_range[0] = yystack.p_mark[1-yym];",
976 " }",
977 "#endif",
978 "",
979 " switch (yyn)",
980 " {",
981 0
982 };
983
984 const char *const trailer[] =
985 {
986 " default:",
987 " break;",
988 " }",
989 " yystack.s_mark -= yym;",
990 " yystate = *yystack.s_mark;",
991 " yystack.l_mark -= yym;",
992 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
993 " yystack.p_mark -= yym;",
994 "#endif",
995 " yym = yylhs[yyn];",
996 " if (yystate == 0 && yym == 0)",
997 " {",
998 "#if YYDEBUG",
999 " if (yydebug)",
1000 " {",
1001 " fprintf(stderr, \"%s[%d]: after reduction, \", YYDEBUGSTR, yydepth);",
1002 "#ifdef YYSTYPE_TOSTRING",
1003 #if defined(YYBTYACC)
1004 "#if YYBTYACC",
1005 " if (!yytrial)",
1006 "#endif /* YYBTYACC */",
1007 #endif /* defined(YYBTYACC) */
1008 " fprintf(stderr, \"result is <%s>, \", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));",
1009 "#endif",
1010 " fprintf(stderr, \"shifting from state 0 to final state %d\\n\", YYFINAL);",
1011 " }",
1012 "#endif",
1013 " yystate = YYFINAL;",
1014 " *++yystack.s_mark = YYFINAL;",
1015 " *++yystack.l_mark = yyval;",
1016 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
1017 " *++yystack.p_mark = yyloc;",
1018 "#endif",
1019 " if (yychar < 0)",
1020 " {",
1021 #if defined(YYBTYACC)
1022 "#if YYBTYACC",
1023 " do {",
1024 " if (yylvp < yylve)",
1025 " {",
1026 " /* we're currently re-reading tokens */",
1027 " yylval = *yylvp++;",
1028 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
1029 " yylloc = *yylpp++;",
1030 "#endif",
1031 " yychar = *yylexp++;",
1032 " break;",
1033 " }",
1034 " if (yyps->save)",
1035 " {",
1036 " /* in trial mode; save scanner results for future parse attempts */",
1037 " if (yylvp == yylvlim)",
1038 " { /* Enlarge lexical value queue */",
1039 " size_t p = (size_t) (yylvp - yylvals);",
1040 " size_t s = (size_t) (yylvlim - yylvals);",
1041 "",
1042 " s += YYLVQUEUEGROWTH;",
1043 " if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)",
1044 " goto yyenomem;",
1045 " if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)",
1046 " goto yyenomem;",
1047 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
1048 " if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)",
1049 " goto yyenomem;",
1050 "#endif",
1051 " yylvp = yylve = yylvals + p;",
1052 " yylvlim = yylvals + s;",
1053 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
1054 " yylpp = yylpe = yylpsns + p;",
1055 " yylplim = yylpsns + s;",
1056 "#endif",
1057 " yylexp = yylexemes + p;",
1058 " }",
1059 " *yylexp = (short) YYLEX;",
1060 " *yylvp++ = yylval;",
1061 " yylve++;",
1062 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
1063 " *yylpp++ = yylloc;",
1064 " yylpe++;",
1065 "#endif",
1066 " yychar = *yylexp++;",
1067 " break;",
1068 " }",
1069 " /* normal operation, no conflict encountered */",
1070 "#endif /* YYBTYACC */",
1071 #endif /* defined(YYBTYACC) */
1072 " yychar = YYLEX;",
1073 #if defined(YYBTYACC)
1074 "#if YYBTYACC",
1075 " } while (0);",
1076 "#endif /* YYBTYACC */",
1077 #endif /* defined(YYBTYACC) */
1078 " if (yychar < 0) yychar = YYEOF;",
1079 " /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */",
1080 "#if YYDEBUG",
1081 " if (yydebug)",
1082 " {",
1083 " yys = yyname[YYTRANSLATE(yychar)];",
1084 " fprintf(stderr, \"%s[%d]: state %d, reading %d (%s)\\n\",",
1085 " YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);",
1086 " }",
1087 "#endif",
1088 " }",
1089 " if (yychar == YYEOF) goto yyaccept;",
1090 " goto yyloop;",
1091 " }",
1092 " if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&",
1093 " yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)",
1094 " yystate = yytable[yyn];",
1095 " else",
1096 " yystate = yydgoto[yym];",
1097 "#if YYDEBUG",
1098 " if (yydebug)",
1099 " {",
1100 " fprintf(stderr, \"%s[%d]: after reduction, \", YYDEBUGSTR, yydepth);",
1101 "#ifdef YYSTYPE_TOSTRING",
1102 #if defined(YYBTYACC)
1103 "#if YYBTYACC",
1104 " if (!yytrial)",
1105 "#endif /* YYBTYACC */",
1106 #endif /* defined(YYBTYACC) */
1107 " fprintf(stderr, \"result is <%s>, \", YYSTYPE_TOSTRING(yystos[yystate], yyval));",
1108 "#endif",
1109 " fprintf(stderr, \"shifting from state %d to state %d\\n\", *yystack.s_mark, yystate);",
1110 " }",
1111 "#endif",
1112 " if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;",
1113 " *++yystack.s_mark = (short) yystate;",
1114 " *++yystack.l_mark = yyval;",
1115 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
1116 " *++yystack.p_mark = yyloc;",
1117 "#endif",
1118 " goto yyloop;",
1119 #if defined(YYBTYACC)
1120 "#if YYBTYACC",
1121 "",
1122 " /* Reduction declares that this path is valid. Set yypath and do a full parse */",
1123 "yyvalid:",
1124 " if (yypath) YYABORT;",
1125 " while (yyps->save)",
1126 " {",
1127 " YYParseState *save = yyps->save;",
1128 " yyps->save = save->save;",
1129 " save->save = yypath;",
1130 " yypath = save;",
1131 " }",
1132 "#if YYDEBUG",
1133 " if (yydebug)",
1134 " fprintf(stderr, \"%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\\n\",",
1135 " YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));",
1136 "#endif",
1137 " if (yyerrctx)",
1138 " {",
1139 " yyFreeState(yyerrctx);",
1140 " yyerrctx = NULL;",
1141 " }",
1142 " yylvp = yylvals + yypath->lexeme;",
1143 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
1144 " yylpp = yylpsns + yypath->lexeme;",
1145 "#endif",
1146 " yylexp = yylexemes + yypath->lexeme;",
1147 " yychar = YYEMPTY;",
1148 " yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);",
1149 " memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));",
1150 " yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);",
1151 " memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",
1152 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
1153 " yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);",
1154 " memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",
1155 "#endif",
1156 " yystate = yypath->state;",
1157 " goto yyloop;",
1158 "#endif /* YYBTYACC */",
1159 #endif /* defined(YYBTYACC) */
1160 "",
1161 "yyoverflow:",
1162 " YYERROR_CALL(\"yacc stack overflow\");",
1163 #if defined(YYBTYACC)
1164 "#if YYBTYACC",
1165 " goto yyabort_nomem;",
1166 "yyenomem:",
1167 " YYERROR_CALL(\"memory exhausted\");",
1168 "yyabort_nomem:",
1169 "#endif /* YYBTYACC */",
1170 #endif /* defined(YYBTYACC) */
1171 " yyresult = 2;",
1172 " goto yyreturn;",
1173 "",
1174 "yyabort:",
1175 " yyresult = 1;",
1176 " goto yyreturn;",
1177 "",
1178 "yyaccept:",
1179 #if defined(YYBTYACC)
1180 "#if YYBTYACC",
1181 " if (yyps->save) goto yyvalid;",
1182 "#endif /* YYBTYACC */",
1183 #endif /* defined(YYBTYACC) */
1184 " yyresult = 0;",
1185 "",
1186 "yyreturn:",
1187 "#if defined(YYDESTRUCT_CALL)",
1188 " if (yychar != YYEOF && yychar != YYEMPTY)",
1189 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
1190 " YYDESTRUCT_CALL(\"cleanup: discarding token\", yychar, &yylval, &yylloc);",
1191 "#else",
1192 " YYDESTRUCT_CALL(\"cleanup: discarding token\", yychar, &yylval);",
1193 "#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */",
1194 "",
1195 " {",
1196 " YYSTYPE *pv;",
1197 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
1198 " YYLTYPE *pp;",
1199 "",
1200 " for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)",
1201 " YYDESTRUCT_CALL(\"cleanup: discarding state\",",
1202 " yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);",
1203 "#else",
1204 " for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)",
1205 " YYDESTRUCT_CALL(\"cleanup: discarding state\",",
1206 " yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);",
1207 "#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */",
1208 " }",
1209 "#endif /* defined(YYDESTRUCT_CALL) */",
1210 "",
1211 #if defined(YYBTYACC)
1212 "#if YYBTYACC",
1213 " if (yyerrctx)",
1214 " {",
1215 " yyFreeState(yyerrctx);",
1216 " yyerrctx = NULL;",
1217 " }",
1218 " while (yyps)",
1219 " {",
1220 " YYParseState *save = yyps;",
1221 " yyps = save->save;",
1222 " save->save = NULL;",
1223 " yyFreeState(save);",
1224 " }",
1225 " while (yypath)",
1226 " {",
1227 " YYParseState *save = yypath;",
1228 " yypath = save->save;",
1229 " save->save = NULL;",
1230 " yyFreeState(save);",
1231 " }",
1232 "#endif /* YYBTYACC */",
1233 #endif /* defined(YYBTYACC) */
1234 " yyfreestack(&yystack);",
1235 " return (yyresult);",
1236 "}",
1237 0
1238 };
1239
1240 void
write_section(FILE * fp,const char * const section[])1241 write_section(FILE * fp, const char *const section[])
1242 {
1243 int i;
1244 const char *s;
1245
1246 for (i = 0; (s = section[i]) != 0; ++i)
1247 {
1248 if (fp == code_file)
1249 ++outline;
1250 fprintf(fp, "%s\n", s);
1251 }
1252 }
1253