Cross Reference: /freebsd-10.2-release/contrib/byacc/btyaccpar.c

1/* This file generated automatically using
2 * @Id: skel2c,v 1.3 2014/04/06 19:48:04 tom Exp @
3 */
4
5/* @Id: btyaccpar.skel,v 1.1 2014/04/02 22:44:41 tom Exp @ */
6
7#include "defs.h"
8
9/* If the skeleton is changed, the banner should be changed so that */
10/* the altered version can be easily distinguished from the original. */
11/* */
12/* The #defines included with the banner are there because they are */
13/* useful in subsequent code. The macros #defined in the header or */
14/* the body either are not useful outside of semantic actions or */
15/* are conditional. */
16
17const char *const banner[] =
18{
19 "/* original parser id follows */",
20 "/* yysccsid[] = \"@(#)yaccpar 1.9 (Berkeley) 02/21/93\" */",

21 "/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */",

21 "/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */",

22 "",
23 "#define YYBYACC 1",
24 CONCAT1("#define YYMAJOR ", YYMAJOR),
25 CONCAT1("#define YYMINOR ", YYMINOR),
26#ifdef YYPATCH
27 CONCAT1("#define YYPATCH ", YYPATCH),
28#endif
29 "",
30 "#define YYEMPTY (-1)",
31 "#define yyclearin (yychar = YYEMPTY)",
32 "#define yyerrok (yyerrflag = 0)",
33 "#define YYRECOVERING() (yyerrflag != 0)",
34 "#define YYENOMEM (-2)",
35 "#define YYEOF 0",
36 0
37};
38
39const char *const xdecls[] =
40{
41 "",
42 "extern int YYPARSE_DECL();",
43 0
44};
45
46const char *const tables[] =
47{
48 "extern const YYINT yylhs[];",
49 "extern const YYINT yylen[];",
50 "extern const YYINT yydefred[];",
51 "extern const YYINT yystos[];",
52 "extern const YYINT yydgoto[];",
53 "extern const YYINT yysindex[];",
54 "extern const YYINT yyrindex[];",
55#if defined(YYBTYACC)
56 "#if YYBTYACC",
57 "extern const YYINT yycindex[];",
58 "#endif /* YYBTYACC */",

59#endif /* defined(YYBTYACC) */

60 "extern const YYINT yygindex[];",
61 "extern const YYINT yytable[];",
62 "extern const YYINT yycheck[];",
63#if defined(YYBTYACC)
64 "#if YYBTYACC",
65 "extern const YYINT yyctable[];",
66 "#endif /* YYBTYACC */",

67#endif /* defined(YYBTYACC) */

68 "",
69 "#if YYDEBUG",
70 "extern const char *const yyname[];",
71 "extern const char *const yyrule[];",
72 "#endif",
73 0
74};
75
76const char *const global_vars[] =
77{
78 "",
79 "int yydebug;",
80 "int yynerrs;",
81 0
82};
83
84const char *const impure_vars[] =
85{
86 "",
87 "int yyerrflag;",
88 "int yychar;",
89 "YYSTYPE yyval;",
90 "YYSTYPE yylval;",
91 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
92 "YYLTYPE yyloc; /* position returned by actions */",
93 "YYLTYPE yylloc; /* position from the lexer */",
94 "#endif",
95 0
96};
97
98const char *const hdr_defs[] =
99{
100 "",
101 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
102 "#ifndef YYLLOC_DEFAULT",
103 "#define YYLLOC_DEFAULT(loc, rhs, n) \\",
104 "do \\",
105 "{ \\",
106 " if (n == 0) \\",
107 " { \\",
108 " (loc).first_line = ((rhs)[-1]).last_line; \\",
109 " (loc).first_column = ((rhs)[-1]).last_column; \\",
110 " (loc).last_line = ((rhs)[-1]).last_line; \\",
111 " (loc).last_column = ((rhs)[-1]).last_column; \\",
112 " } \\",
113 " else \\",
114 " { \\",
115 " (loc).first_line = ((rhs)[ 0 ]).first_line; \\",
116 " (loc).first_column = ((rhs)[ 0 ]).first_column; \\",
117 " (loc).last_line = ((rhs)[n-1]).last_line; \\",
118 " (loc).last_column = ((rhs)[n-1]).last_column; \\",
119 " } \\",
120 "} while (0)",
121 "#endif /* YYLLOC_DEFAULT */",
122 "#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */",
123#if defined(YYBTYACC)
124 "#if YYBTYACC",
125 "",
126 "#ifndef YYLVQUEUEGROWTH",
127 "#define YYLVQUEUEGROWTH 32",
128 "#endif",
129 "#endif /* YYBTYACC */",

130#endif /* defined(YYBTYACC) */

131 "",
132 "/* define the initial stack-sizes */",
133 "#ifdef YYSTACKSIZE",
134 "#undef YYMAXDEPTH",
135 "#define YYMAXDEPTH YYSTACKSIZE",
136 "#else",
137 "#ifdef YYMAXDEPTH",
138 "#define YYSTACKSIZE YYMAXDEPTH",
139 "#else",
140 "#define YYSTACKSIZE 10000",
141 "#define YYMAXDEPTH 10000",
142 "#endif",
143 "#endif",
144 "",
145 "#ifndef YYINITSTACKSIZE",
146 "#define YYINITSTACKSIZE 200",
147 "#endif",
148 "",
149 "typedef struct {",
150 " unsigned stacksize;",
151 " short *s_base;",
152 " short *s_mark;",
153 " short *s_last;",
154 " YYSTYPE *l_base;",
155 " YYSTYPE *l_mark;",
156 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
157 " YYLTYPE *p_base;",
158 " YYLTYPE *p_mark;",
159 "#endif",
160 "} YYSTACKDATA;",
161#if defined(YYBTYACC)
162 "#if YYBTYACC",
163 "",
164 "struct YYParseState_s",
165 "{",
166 " struct YYParseState_s *save; /* Previously saved parser state */",
167 " YYSTACKDATA yystack; /* saved parser stack */",
168 " int state; /* saved parser state */",
169 " int errflag; /* saved error recovery status */",
170 " int lexeme; /* saved index of the conflict lexeme in the lexical queue */",
171 " YYINT ctry; /* saved index in yyctable[] for this conflict */",
172 "};",
173 "typedef struct YYParseState_s YYParseState;",
174 "#endif /* YYBTYACC */",

175#endif /* defined(YYBTYACC) */

176 0
177};
178
179const char *const hdr_vars[] =
180{
181 "/* variables for the parser stack */",
182 "static YYSTACKDATA yystack;",
183#if defined(YYBTYACC)
184 "#if YYBTYACC",
185 "",
186 "/* Current parser state */",
187 "static YYParseState *yyps = 0;",
188 "",
189 "/* yypath != NULL: do the full parse, starting at *yypath parser state. */",
190 "static YYParseState *yypath = 0;",
191 "",
192 "/* Base of the lexical value queue */",
193 "static YYSTYPE *yylvals = 0;",
194 "",
195 "/* Current position at lexical value queue */",
196 "static YYSTYPE *yylvp = 0;",
197 "",
198 "/* End position of lexical value queue */",
199 "static YYSTYPE *yylve = 0;",
200 "",
201 "/* The last allocated position at the lexical value queue */",
202 "static YYSTYPE *yylvlim = 0;",
203 "",
204 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
205 "/* Base of the lexical position queue */",
206 "static YYLTYPE *yylpsns = 0;",
207 "",
208 "/* Current position at lexical position queue */",
209 "static YYLTYPE *yylpp = 0;",
210 "",
211 "/* End position of lexical position queue */",
212 "static YYLTYPE *yylpe = 0;",
213 "",
214 "/* The last allocated position at the lexical position queue */",
215 "static YYLTYPE *yylplim = 0;",
216 "#endif",
217 "",
218 "/* Current position at lexical token queue */",
219 "static short *yylexp = 0;",
220 "",
221 "static short *yylexemes = 0;",
222 "#endif /* YYBTYACC */",

223#endif /* defined(YYBTYACC) */

224 0
225};
226
227const char *const body_vars[] =
228{
229 " int yyerrflag;",
230 " int yychar;",
231 " YYSTYPE yyval;",
232 " YYSTYPE yylval;",
233 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
234 " YYLTYPE yyloc; /* position returned by actions */",
235 " YYLTYPE yylloc; /* position from the lexer */",
236 "#endif",
237 "",
238 " /* variables for the parser stack */",
239 " YYSTACKDATA yystack;",
240#if defined(YYBTYACC)
241 "#if YYBTYACC",
242 "",
243 " /* Current parser state */",
244 " static YYParseState *yyps = 0;",
245 "",
246 " /* yypath != NULL: do the full parse, starting at *yypath parser state. */",
247 " static YYParseState *yypath = 0;",
248 "",
249 " /* Base of the lexical value queue */",
250 " static YYSTYPE *yylvals = 0;",
251 "",
252 " /* Current position at lexical value queue */",
253 " static YYSTYPE *yylvp = 0;",
254 "",
255 " /* End position of lexical value queue */",
256 " static YYSTYPE *yylve = 0;",
257 "",
258 " /* The last allocated position at the lexical value queue */",
259 " static YYSTYPE *yylvlim = 0;",
260 "",
261 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
262 " /* Base of the lexical position queue */",
263 " static YYLTYPE *yylpsns = 0;",
264 "",
265 " /* Current position at lexical position queue */",
266 " static YYLTYPE *yylpp = 0;",
267 "",
268 " /* End position of lexical position queue */",
269 " static YYLTYPE *yylpe = 0;",
270 "",
271 " /* The last allocated position at the lexical position queue */",
272 " static YYLTYPE *yylplim = 0;",
273 "#endif",
274 "",
275 " /* Current position at lexical token queue */",
276 " static short *yylexp = 0;",
277 "",
278 " static short *yylexemes = 0;",
279 "#endif /* YYBTYACC */",

280#endif /* defined(YYBTYACC) */

281 0
282};
283
284const char *const body_1[] =
285{
286 "",
287 "/* For use in generated program */",
288 "#define yydepth (int)(yystack.s_mark - yystack.s_base)",
289#if defined(YYBTYACC)
290 "#if YYBTYACC",
291 "#define yytrial (yyps->save)",
292 "#endif /* YYBTYACC */",

293#endif /* defined(YYBTYACC) */

294 "",
295 "#if YYDEBUG",

296 "#include <stdio.h> /* needed for printf */",

297 "#endif",
298 "",

299 "#include <stdlib.h> /* needed for malloc, etc */",
300 "#include <string.h> /* needed for memset */",

301 "",
302 "/* allocate initial stack or double stack size, up to YYMAXDEPTH */",
303 "static int yygrowstack(YYSTACKDATA *data)",
304 "{",
305 " int i;",
306 " unsigned newsize;",
307 " short *newss;",
308 " YYSTYPE *newvs;",
309 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
310 " YYLTYPE *newps;",
311 "#endif",
312 "",
313 " if ((newsize = data->stacksize) == 0)",
314 " newsize = YYINITSTACKSIZE;",
315 " else if (newsize >= YYMAXDEPTH)",
316 " return YYENOMEM;",
317 " else if ((newsize *= 2) > YYMAXDEPTH)",
318 " newsize = YYMAXDEPTH;",
319 "",
320 " i = (int) (data->s_mark - data->s_base);",
321 " newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));",
322 " if (newss == 0)",
323 " return YYENOMEM;",
324 "",
325 " data->s_base = newss;",
326 " data->s_mark = newss + i;",
327 "",
328 " newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));",
329 " if (newvs == 0)",
330 " return YYENOMEM;",
331 "",
332 " data->l_base = newvs;",
333 " data->l_mark = newvs + i;",
334 "",
335 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
336 " newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));",
337 " if (newps == 0)",
338 " return YYENOMEM;",
339 "",
340 " data->p_base = newps;",
341 " data->p_mark = newps + i;",
342 "#endif",
343 "",
344 " data->stacksize = newsize;",
345 " data->s_last = data->s_base + newsize - 1;",
346 "",
347 "#if YYDEBUG",
348 " if (yydebug)",
349 " fprintf(stderr, \"%sdebug: stack size increased to %d\\n\", YYPREFIX, newsize);",
350 "#endif",
351 " return 0;",
352 "}",
353 "",
354 "#if YYPURE || defined(YY_NO_LEAKS)",
355 "static void yyfreestack(YYSTACKDATA *data)",
356 "{",
357 " free(data->s_base);",
358 " free(data->l_base);",
359 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
360 " free(data->p_base);",
361 "#endif",
362 " memset(data, 0, sizeof(*data));",
363 "}",
364 "#else",
365 "#define yyfreestack(data) /* nothing */",
366 "#endif /* YYPURE || defined(YY_NO_LEAKS) */",
367#if defined(YYBTYACC)
368 "#if YYBTYACC",
369 "",
370 "static YYParseState *",
371 "yyNewState(unsigned size)",
372 "{",
373 " YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));",
374 " if (p == NULL) return NULL;",
375 "",
376 " p->yystack.stacksize = size;",
377 " if (size == 0)",
378 " {",
379 " p->yystack.s_base = NULL;",
380 " p->yystack.l_base = NULL;",
381 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
382 " p->yystack.p_base = NULL;",
383 "#endif",
384 " return p;",
385 " }",
386 " p->yystack.s_base = (short *) malloc(size * sizeof(short));",
387 " if (p->yystack.s_base == NULL) return NULL;",
388 " p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));",
389 " if (p->yystack.l_base == NULL) return NULL;",
390 " memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));",
391 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
392 " p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));",
393 " if (p->yystack.p_base == NULL) return NULL;",
394 " memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));",
395 "#endif",
396 "",
397 " return p;",
398 "}",
399 "",
400 "static void",
401 "yyFreeState(YYParseState *p)",
402 "{",
403 " yyfreestack(&p->yystack);",
404 " free(p);",
405 "}",
406 "#endif /* YYBTYACC */",

407#endif /* defined(YYBTYACC) */

408 "",
409 "#define YYABORT goto yyabort",
410 "#define YYREJECT goto yyabort",
411 "#define YYACCEPT goto yyaccept",
412 "#define YYERROR goto yyerrlab",
413#if defined(YYBTYACC)
414 "#if YYBTYACC",
415 "#define YYVALID do { if (yyps->save) goto yyvalid; } while(0)",
416 "#define YYVALID_NESTED do { if (yyps->save && \\",
417 " yyps->save->save == 0) goto yyvalid; } while(0)",
418 "#endif /* YYBTYACC */",

419#endif /* defined(YYBTYACC) */

420 "",
421 "int",
422 "YYPARSE_DECL()",
423 "{",
424 0
425};
426
427const char *const body_2[] =
428{
429 " int yym, yyn, yystate, yyresult;",
430#if defined(YYBTYACC)
431 "#if YYBTYACC",
432 " int yynewerrflag;",
433 " YYParseState *yyerrctx = NULL;",
434 "#endif /* YYBTYACC */",

435#endif /* defined(YYBTYACC) */

436 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
437 " YYLTYPE yyerror_loc_range[2]; /* position of error start & end */",
438 "#endif",
439 "#if YYDEBUG",
440 " const char *yys;",
441 "",
442 " if ((yys = getenv(\"YYDEBUG\")) != 0)",
443 " {",
444 " yyn = *yys;",
445 " if (yyn >= '0' && yyn <= '9')",
446 " yydebug = yyn - '0';",
447 " }",
448 " if (yydebug)",
449 " fprintf(stderr, \"%sdebug[<# of symbols on state stack>]\\n\", YYPREFIX);",
450 "#endif",
451 "",
452#if defined(YYBTYACC)
453 "#if YYBTYACC",
454 " yyps = yyNewState(0); if (yyps == 0) goto yyenomem;",
455 " yyps->save = 0;",
456 "#endif /* YYBTYACC */",

457#endif /* defined(YYBTYACC) */

458 " yynerrs = 0;",
459 " yyerrflag = 0;",
460 " yychar = YYEMPTY;",
461 " yystate = 0;",
462 "",
463 "#if YYPURE",
464 " memset(&yystack, 0, sizeof(yystack));",
465 "#endif",
466 "",
467 " if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;",
468 " yystack.s_mark = yystack.s_base;",
469 " yystack.l_mark = yystack.l_base;",
470 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
471 " yystack.p_mark = yystack.p_base;",
472 "#endif",
473 " yystate = 0;",
474 " *yystack.s_mark = 0;",
475 "",
476 "yyloop:",
477 " if ((yyn = yydefred[yystate]) != 0) goto yyreduce;",
478 " if (yychar < 0)",
479 " {",
480#if defined(YYBTYACC)
481 "#if YYBTYACC",
482 " do {",
483 " if (yylvp < yylve)",
484 " {",
485 " /* we're currently re-reading tokens */",
486 " yylval = *yylvp++;",
487 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
488 " yylloc = *yylpp++;",
489 "#endif",
490 " yychar = *yylexp++;",
491 " break;",
492 " }",
493 " if (yyps->save)",
494 " {",
495 " /* in trial mode; save scanner results for future parse attempts */",
496 " if (yylvp == yylvlim)",
497 " { /* Enlarge lexical value queue */",

498 " int p = yylvp - yylvals;",
499 " int s = yylvlim - yylvals;",

498 " size_t p = (size_t) (yylvp - yylvals);",
499 " size_t s = (size_t) (yylvlim - yylvals);",

500 "",
501 " s += YYLVQUEUEGROWTH;",
502 " if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;",
503 " if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;",
504 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
505 " if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;",
506 "#endif",
507 " yylvp = yylve = yylvals + p;",
508 " yylvlim = yylvals + s;",
509 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
510 " yylpp = yylpe = yylpsns + p;",
511 " yylplim = yylpsns + s;",
512 "#endif",
513 " yylexp = yylexemes + p;",
514 " }",
515 " *yylexp = (short) YYLEX;",
516 " *yylvp++ = yylval;",
517 " yylve++;",
518 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
519 " *yylpp++ = yylloc;",
520 " yylpe++;",
521 "#endif",
522 " yychar = *yylexp++;",
523 " break;",
524 " }",
525 " /* normal operation, no conflict encountered */",
526 "#endif /* YYBTYACC */",

527#endif /* defined(YYBTYACC) */

528 " yychar = YYLEX;",
529#if defined(YYBTYACC)
530 "#if YYBTYACC",
531 " } while (0);",
532 "#endif /* YYBTYACC */",

533#endif /* defined(YYBTYACC) */

534 " if (yychar < 0) yychar = YYEOF;",
535 " /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */",
536 "#if YYDEBUG",
537 " if (yydebug)",
538 " {",
539 " yys = yyname[YYTRANSLATE(yychar)];",
540 " fprintf(stderr, \"%s[%d]: state %d, reading token %d (%s)\",",
541 " YYDEBUGSTR, yydepth, yystate, yychar, yys);",
542 "#ifdef YYSTYPE_TOSTRING",
543#if defined(YYBTYACC)
544 "#if YYBTYACC",
545 " if (!yytrial)",
546 "#endif /* YYBTYACC */",

547#endif /* defined(YYBTYACC) */

548 " fprintf(stderr, \" <%s>\", YYSTYPE_TOSTRING(yychar, yylval));",
549 "#endif",
550 " fputc('\\n', stderr);",
551 " }",
552 "#endif",
553 " }",
554#if defined(YYBTYACC)
555 "#if YYBTYACC",
556 "",
557 " /* Do we have a conflict? */",
558 " if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&",
559 " yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)",
560 " {",
561 " YYINT ctry;",
562 "",
563 " if (yypath)",
564 " {",
565 " YYParseState *save;",
566 "#if YYDEBUG",
567 " if (yydebug)",
568 " fprintf(stderr, \"%s[%d]: CONFLICT in state %d: following successful trial parse\\n\",",
569 " YYDEBUGSTR, yydepth, yystate);",
570 "#endif",
571 " /* Switch to the next conflict context */",
572 " save = yypath;",
573 " yypath = save->save;",
574 " save->save = NULL;",
575 " ctry = save->ctry;",
576 " if (save->state != yystate) YYABORT;",
577 " yyFreeState(save);",
578 "",
579 " }",
580 " else",
581 " {",
582 "",
583 " /* Unresolved conflict - start/continue trial parse */",
584 " YYParseState *save;",
585 "#if YYDEBUG",
586 " if (yydebug)",
587 " {",
588 " fprintf(stderr, \"%s[%d]: CONFLICT in state %d. \", YYDEBUGSTR, yydepth, yystate);",
589 " if (yyps->save)",
590 " fputs(\"ALREADY in conflict, continuing trial parse.\\n\", stderr);",
591 " else",
592 " fputs(\"Starting trial parse.\\n\", stderr);",
593 " }",
594 "#endif",
595 " save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));",
596 " if (save == NULL) goto yyenomem;",
597 " save->save = yyps->save;",
598 " save->state = yystate;",
599 " save->errflag = yyerrflag;",
600 " save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);",

601 " memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));",

601 " memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));",

602 " save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);",

603 " memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",

603 " memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",

604 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
605 " save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);",

606 " memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",

606 " memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",

607 "#endif",
608 " ctry = yytable[yyn];",
609 " if (yyctable[ctry] == -1)",
610 " {",
611 "#if YYDEBUG",
612 " if (yydebug && yychar >= YYEOF)",
613 " fprintf(stderr, \"%s[%d]: backtracking 1 token\\n\", YYDEBUGSTR, yydepth);",
614 "#endif",
615 " ctry++;",
616 " }",
617 " save->ctry = ctry;",
618 " if (yyps->save == NULL)",
619 " {",
620 " /* If this is a first conflict in the stack, start saving lexemes */",
621 " if (!yylexemes)",
622 " {",
623 " yylexemes = (short *) malloc((YYLVQUEUEGROWTH) * sizeof(short));",
624 " if (yylexemes == NULL) goto yyenomem;",
625 " yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));",
626 " if (yylvals == NULL) goto yyenomem;",
627 " yylvlim = yylvals + YYLVQUEUEGROWTH;",
628 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
629 " yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));",
630 " if (yylpsns == NULL) goto yyenomem;",
631 " yylplim = yylpsns + YYLVQUEUEGROWTH;",
632 "#endif",
633 " }",
634 " if (yylvp == yylve)",
635 " {",
636 " yylvp = yylve = yylvals;",
637 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
638 " yylpp = yylpe = yylpsns;",
639 "#endif",
640 " yylexp = yylexemes;",
641 " if (yychar >= YYEOF)",
642 " {",
643 " *yylve++ = yylval;",
644 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
645 " *yylpe++ = yylloc;",
646 "#endif",
647 " *yylexp = (short) yychar;",
648 " yychar = YYEMPTY;",
649 " }",
650 " }",
651 " }",
652 " if (yychar >= YYEOF)",
653 " {",
654 " yylvp--;",
655 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
656 " yylpp--;",
657 "#endif",
658 " yylexp--;",
659 " yychar = YYEMPTY;",
660 " }",

661 " save->lexeme = yylvp - yylvals;",

661 " save->lexeme = (int) (yylvp - yylvals);",

662 " yyps->save = save;",
663 " }",
664 " if (yytable[yyn] == ctry)",
665 " {",
666 "#if YYDEBUG",
667 " if (yydebug)",
668 " fprintf(stderr, \"%s[%d]: state %d, shifting to state %d\\n\",",
669 " YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);",
670 "#endif",
671 " if (yychar < 0)",
672 " {",
673 " yylvp++;",
674 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
675 " yylpp++;",
676 "#endif",
677 " yylexp++;",
678 " }",
679 " if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)",
680 " goto yyoverflow;",
681 " yystate = yyctable[ctry];",
682 " *++yystack.s_mark = (short) yystate;",
683 " *++yystack.l_mark = yylval;",
684 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
685 " *++yystack.p_mark = yylloc;",
686 "#endif",
687 " yychar = YYEMPTY;",
688 " if (yyerrflag > 0) --yyerrflag;",
689 " goto yyloop;",
690 " }",
691 " else",
692 " {",
693 " yyn = yyctable[ctry];",
694 " goto yyreduce;",
695 " }",
696 " } /* End of code dealing with conflicts */",
697 "#endif /* YYBTYACC */",

698#endif /* defined(YYBTYACC) */

699 " if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&",
700 " yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)",
701 " {",
702 "#if YYDEBUG",
703 " if (yydebug)",
704 " fprintf(stderr, \"%s[%d]: state %d, shifting to state %d\\n\",",
705 " YYDEBUGSTR, yydepth, yystate, yytable[yyn]);",
706 "#endif",
707 " if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;",
708 " yystate = yytable[yyn];",
709 " *++yystack.s_mark = yytable[yyn];",
710 " *++yystack.l_mark = yylval;",
711 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
712 " *++yystack.p_mark = yylloc;",
713 "#endif",
714 " yychar = YYEMPTY;",
715 " if (yyerrflag > 0) --yyerrflag;",
716 " goto yyloop;",
717 " }",
718 " if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&",
719 " yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)",
720 " {",
721 " yyn = yytable[yyn];",
722 " goto yyreduce;",
723 " }",
724 " if (yyerrflag != 0) goto yyinrecovery;",
725#if defined(YYBTYACC)
726 "#if YYBTYACC",
727 "",
728 " yynewerrflag = 1;",
729 " goto yyerrhandler;",
730 " goto yyerrlab;",
731 "",
732 "yyerrlab:",
733 " yynewerrflag = 0;",
734 "yyerrhandler:",
735 " while (yyps->save)",
736 " {",
737 " int ctry;",
738 " YYParseState *save = yyps->save;",
739 "#if YYDEBUG",
740 " if (yydebug)",
741 " fprintf(stderr, \"%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\\n\",",
742 " YYDEBUGSTR, yydepth, yystate, yyps->save->state,",
743 " (int)(yylvp - yylvals - yyps->save->lexeme));",
744 "#endif",
745 " /* Memorize most forward-looking error state in case it's really an error. */",
746 " if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)",
747 " {",
748 " /* Free old saved error context state */",
749 " if (yyerrctx) yyFreeState(yyerrctx);",
750 " /* Create and fill out new saved error context state */",
751 " yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));",
752 " if (yyerrctx == NULL) goto yyenomem;",
753 " yyerrctx->save = yyps->save;",
754 " yyerrctx->state = yystate;",
755 " yyerrctx->errflag = yyerrflag;",
756 " yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);",

757 " memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));",

757 " memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));",

758 " yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);",

759 " memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",

759 " memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",

760 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
761 " yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);",

762 " memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",

762 " memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",

763 "#endif",

764 " yyerrctx->lexeme = yylvp - yylvals;",

764 " yyerrctx->lexeme = (int) (yylvp - yylvals);",

765 " }",
766 " yylvp = yylvals + save->lexeme;",
767 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
768 " yylpp = yylpsns + save->lexeme;",
769 "#endif",
770 " yylexp = yylexemes + save->lexeme;",
771 " yychar = YYEMPTY;",
772 " yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);",

773 " memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));",

773 " memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));",

774 " yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);",

775 " memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",

775 " memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",

776 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
777 " yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);",

778 " memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",

778 " memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",

779 "#endif",
780 " ctry = ++save->ctry;",
781 " yystate = save->state;",
782 " /* We tried shift, try reduce now */",
783 " if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;",
784 " yyps->save = save->save;",
785 " save->save = NULL;",
786 " yyFreeState(save);",
787 "",
788 " /* Nothing left on the stack -- error */",
789 " if (!yyps->save)",
790 " {",
791 "#if YYDEBUG",
792 " if (yydebug)",
793 " fprintf(stderr, \"%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\\n\",",
794 " YYPREFIX, yydepth);",
795 "#endif",
796 " /* Restore state as it was in the most forward-advanced error */",
797 " yylvp = yylvals + yyerrctx->lexeme;",
798 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
799 " yylpp = yylpsns + yyerrctx->lexeme;",
800 "#endif",
801 " yylexp = yylexemes + yyerrctx->lexeme;",
802 " yychar = yylexp[-1];",
803 " yylval = yylvp[-1];",
804 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
805 " yylloc = yylpp[-1];",
806 "#endif",
807 " yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);",

808 " memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));",

808 " memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));",

809 " yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);",

810 " memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",

810 " memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",

811 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
812 " yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);",

813 " memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",

813 " memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",

814 "#endif",
815 " yystate = yyerrctx->state;",
816 " yyFreeState(yyerrctx);",
817 " yyerrctx = NULL;",
818 " }",
819 " yynewerrflag = 1;",
820 " }",
821 " if (yynewerrflag == 0) goto yyinrecovery;",
822 "#endif /* YYBTYACC */",

823#endif /* defined(YYBTYACC) */

824 "",
825 " YYERROR_CALL(\"syntax error\");",
826 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
827 " yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */",
828 "#endif",
829 "",
830 "#if !YYBTYACC",
831 " goto yyerrlab;",
832 "yyerrlab:",
833 "#endif",
834 " ++yynerrs;",
835 "",
836 "yyinrecovery:",
837 " if (yyerrflag < 3)",
838 " {",
839 " yyerrflag = 3;",
840 " for (;;)",
841 " {",
842 " if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&",
843 " yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)",
844 " {",
845 "#if YYDEBUG",
846 " if (yydebug)",
847 " fprintf(stderr, \"%s[%d]: state %d, error recovery shifting to state %d\\n\",",
848 " YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);",
849 "#endif",
850 " if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;",
851 " yystate = yytable[yyn];",
852 " *++yystack.s_mark = yytable[yyn];",
853 " *++yystack.l_mark = yylval;",
854 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
855 " /* lookahead position is error end position */",
856 " yyerror_loc_range[1] = yylloc;",
857 " YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */",
858 " *++yystack.p_mark = yyloc;",
859 "#endif",
860 " goto yyloop;",
861 " }",
862 " else",
863 " {",
864 "#if YYDEBUG",
865 " if (yydebug)",
866 " fprintf(stderr, \"%s[%d]: error recovery discarding state %d\\n\",",
867 " YYDEBUGSTR, yydepth, *yystack.s_mark);",
868 "#endif",
869 " if (yystack.s_mark <= yystack.s_base) goto yyabort;",
870 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
871 " /* the current TOS position is the error start position */",
872 " yyerror_loc_range[0] = *yystack.p_mark;",
873 "#endif",
874 "#if defined(YYDESTRUCT_CALL)",
875#if defined(YYBTYACC)
876 "#if YYBTYACC",
877 " if (!yytrial)",
878 "#endif /* YYBTYACC */",

879#endif /* defined(YYBTYACC) */

880 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
881 " YYDESTRUCT_CALL(\"error: discarding state\",",
882 " yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);",
883 "#else",
884 " YYDESTRUCT_CALL(\"error: discarding state\",",
885 " yystos[*yystack.s_mark], yystack.l_mark);",
886 "#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */",
887 "#endif /* defined(YYDESTRUCT_CALL) */",
888 " --yystack.s_mark;",
889 " --yystack.l_mark;",
890 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
891 " --yystack.p_mark;",
892 "#endif",
893 " }",
894 " }",
895 " }",
896 " else",
897 " {",
898 " if (yychar == YYEOF) goto yyabort;",
899 "#if YYDEBUG",
900 " if (yydebug)",
901 " {",
902 " yys = yyname[YYTRANSLATE(yychar)];",
903 " fprintf(stderr, \"%s[%d]: state %d, error recovery discarding token %d (%s)\\n\",",
904 " YYDEBUGSTR, yydepth, yystate, yychar, yys);",
905 " }",
906 "#endif",
907 "#if defined(YYDESTRUCT_CALL)",
908#if defined(YYBTYACC)
909 "#if YYBTYACC",
910 " if (!yytrial)",
911 "#endif /* YYBTYACC */",

912#endif /* defined(YYBTYACC) */

913 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
914 " YYDESTRUCT_CALL(\"error: discarding token\", yychar, &yylval, &yylloc);",
915 "#else",
916 " YYDESTRUCT_CALL(\"error: discarding token\", yychar, &yylval);",
917 "#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */",
918 "#endif /* defined(YYDESTRUCT_CALL) */",
919 " yychar = YYEMPTY;",
920 " goto yyloop;",
921 " }",
922 "",
923 "yyreduce:",
924 " yym = yylen[yyn];",
925 "#if YYDEBUG",
926 " if (yydebug)",
927 " {",
928 " fprintf(stderr, \"%s[%d]: state %d, reducing by rule %d (%s)\",",
929 " YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);",
930 "#ifdef YYSTYPE_TOSTRING",
931#if defined(YYBTYACC)
932 "#if YYBTYACC",
933 " if (!yytrial)",
934 "#endif /* YYBTYACC */",

935#endif /* defined(YYBTYACC) */

936 " if (yym > 0)",
937 " {",
938 " int i;",
939 " fputc('<', stderr);",
940 " for (i = yym; i > 0; i--)",
941 " {",
942 " if (i != yym) fputs(\", \", stderr);",
943 " fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],",
944 " yystack.l_mark[1-i]), stderr);",
945 " }",
946 " fputc('>', stderr);",
947 " }",
948 "#endif",
949 " fputc('\\n', stderr);",
950 " }",
951 "#endif",
952 " if (yym > 0)",
953 " yyval = yystack.l_mark[1-yym];",
954 " else",
955 " memset(&yyval, 0, sizeof yyval);",
956 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
957 "",
958 " /* Perform position reduction */",
959 " memset(&yyloc, 0, sizeof(yyloc));",
960#if defined(YYBTYACC)
961 "#if YYBTYACC",
962 " if (!yytrial)",
963 "#endif /* YYBTYACC */",

964#endif /* defined(YYBTYACC) */

965 " {",
966 " YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);",
967 " /* just in case YYERROR is invoked within the action, save",
968 " the start of the rhs as the error start position */",
969 " yyerror_loc_range[0] = yystack.p_mark[1-yym];",
970 " }",
971 "#endif",
972 "",
973 " switch (yyn)",
974 " {",
975 0
976};
977
978const char *const trailer[] =
979{
980 " default:",
981 " break;",
982 " }",
983 " yystack.s_mark -= yym;",
984 " yystate = *yystack.s_mark;",
985 " yystack.l_mark -= yym;",
986 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
987 " yystack.p_mark -= yym;",
988 "#endif",
989 " yym = yylhs[yyn];",
990 " if (yystate == 0 && yym == 0)",
991 " {",
992 "#if YYDEBUG",
993 " if (yydebug)",
994 " {",
995 " fprintf(stderr, \"%s[%d]: after reduction, \", YYDEBUGSTR, yydepth);",
996 "#ifdef YYSTYPE_TOSTRING",
997#if defined(YYBTYACC)
998 "#if YYBTYACC",
999 " if (!yytrial)",
1000 "#endif /* YYBTYACC */",

1001#endif /* defined(YYBTYACC) */

1002 " fprintf(stderr, \"result is <%s>, \", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));",
1003 "#endif",
1004 " fprintf(stderr, \"shifting from state 0 to final state %d\\n\", YYFINAL);",
1005 " }",
1006 "#endif",
1007 " yystate = YYFINAL;",
1008 " *++yystack.s_mark = YYFINAL;",
1009 " *++yystack.l_mark = yyval;",
1010 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
1011 " *++yystack.p_mark = yyloc;",
1012 "#endif",
1013 " if (yychar < 0)",
1014 " {",
1015#if defined(YYBTYACC)
1016 "#if YYBTYACC",
1017 " do {",
1018 " if (yylvp < yylve)",
1019 " {",
1020 " /* we're currently re-reading tokens */",
1021 " yylval = *yylvp++;",
1022 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
1023 " yylloc = *yylpp++;",
1024 "#endif",
1025 " yychar = *yylexp++;",
1026 " break;",
1027 " }",
1028 " if (yyps->save)",
1029 " {",
1030 " /* in trial mode; save scanner results for future parse attempts */",
1031 " if (yylvp == yylvlim)",
1032 " { /* Enlarge lexical value queue */",

1033 " int p = yylvp - yylvals;",
1034 " int s = yylvlim - yylvals;",

1033 " size_t p = (size_t) (yylvp - yylvals);",
1034 " size_t s = (size_t) (yylvlim - yylvals);",

1035 "",
1036 " s += YYLVQUEUEGROWTH;",
1037 " if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)",
1038 " goto yyenomem;",
1039 " if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)",
1040 " goto yyenomem;",
1041 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
1042 " if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)",
1043 " goto yyenomem;",
1044 "#endif",
1045 " yylvp = yylve = yylvals + p;",
1046 " yylvlim = yylvals + s;",
1047 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
1048 " yylpp = yylpe = yylpsns + p;",
1049 " yylplim = yylpsns + s;",
1050 "#endif",
1051 " yylexp = yylexemes + p;",
1052 " }",
1053 " *yylexp = (short) YYLEX;",
1054 " *yylvp++ = yylval;",
1055 " yylve++;",
1056 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
1057 " *yylpp++ = yylloc;",
1058 " yylpe++;",
1059 "#endif",
1060 " yychar = *yylexp++;",
1061 " break;",
1062 " }",
1063 " /* normal operation, no conflict encountered */",
1064 "#endif /* YYBTYACC */",

1065#endif /* defined(YYBTYACC) */

1066 " yychar = YYLEX;",
1067#if defined(YYBTYACC)
1068 "#if YYBTYACC",
1069 " } while (0);",
1070 "#endif /* YYBTYACC */",

1071#endif /* defined(YYBTYACC) */

1072 " if (yychar < 0) yychar = YYEOF;",
1073 " /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */",
1074 "#if YYDEBUG",
1075 " if (yydebug)",
1076 " {",
1077 " yys = yyname[YYTRANSLATE(yychar)];",
1078 " fprintf(stderr, \"%s[%d]: state %d, reading %d (%s)\\n\",",
1079 " YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);",
1080 " }",
1081 "#endif",
1082 " }",
1083 " if (yychar == YYEOF) goto yyaccept;",
1084 " goto yyloop;",
1085 " }",
1086 " if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&",
1087 " yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)",
1088 " yystate = yytable[yyn];",
1089 " else",
1090 " yystate = yydgoto[yym];",
1091 "#if YYDEBUG",
1092 " if (yydebug)",
1093 " {",
1094 " fprintf(stderr, \"%s[%d]: after reduction, \", YYDEBUGSTR, yydepth);",
1095 "#ifdef YYSTYPE_TOSTRING",
1096#if defined(YYBTYACC)
1097 "#if YYBTYACC",
1098 " if (!yytrial)",
1099 "#endif /* YYBTYACC */",

1100#endif /* defined(YYBTYACC) */

1101 " fprintf(stderr, \"result is <%s>, \", YYSTYPE_TOSTRING(yystos[yystate], yyval));",
1102 "#endif",
1103 " fprintf(stderr, \"shifting from state %d to state %d\\n\", *yystack.s_mark, yystate);",
1104 " }",
1105 "#endif",
1106 " if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;",
1107 " *++yystack.s_mark = (short) yystate;",
1108 " *++yystack.l_mark = yyval;",
1109 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
1110 " *++yystack.p_mark = yyloc;",
1111 "#endif",
1112 " goto yyloop;",
1113#if defined(YYBTYACC)
1114 "#if YYBTYACC",
1115 "",
1116 " /* Reduction declares that this path is valid. Set yypath and do a full parse */",
1117 "yyvalid:",
1118 " if (yypath) YYABORT;",
1119 " while (yyps->save)",
1120 " {",
1121 " YYParseState *save = yyps->save;",
1122 " yyps->save = save->save;",
1123 " save->save = yypath;",
1124 " yypath = save;",
1125 " }",
1126 "#if YYDEBUG",
1127 " if (yydebug)",
1128 " fprintf(stderr, \"%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\\n\",",
1129 " YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));",
1130 "#endif",
1131 " if (yyerrctx)",
1132 " {",
1133 " yyFreeState(yyerrctx);",
1134 " yyerrctx = NULL;",
1135 " }",
1136 " yylvp = yylvals + yypath->lexeme;",
1137 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
1138 " yylpp = yylpsns + yypath->lexeme;",
1139 "#endif",
1140 " yylexp = yylexemes + yypath->lexeme;",
1141 " yychar = YYEMPTY;",
1142 " yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);",

1143 " memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));",

1143 " memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));",

1144 " yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);",

1145 " memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",

1145 " memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",

1146 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
1147 " yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);",

1148 " memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",

1148 " memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",

1149 "#endif",
1150 " yystate = yypath->state;",
1151 " goto yyloop;",
1152 "#endif /* YYBTYACC */",

1153#endif /* defined(YYBTYACC) */

1154 "",
1155 "yyoverflow:",
1156 " YYERROR_CALL(\"yacc stack overflow\");",
1157#if defined(YYBTYACC)
1158 "#if YYBTYACC",
1159 " goto yyabort_nomem;",
1160 "yyenomem:",
1161 " YYERROR_CALL(\"memory exhausted\");",
1162 "yyabort_nomem:",
1163 "#endif /* YYBTYACC */",

1164#endif /* defined(YYBTYACC) */

1165 " yyresult = 2;",
1166 " goto yyreturn;",
1167 "",
1168 "yyabort:",
1169 " yyresult = 1;",
1170 " goto yyreturn;",
1171 "",
1172 "yyaccept:",
1173#if defined(YYBTYACC)
1174 "#if YYBTYACC",
1175 " if (yyps->save) goto yyvalid;",
1176 "#endif /* YYBTYACC */",

1177#endif /* defined(YYBTYACC) */

1178 " yyresult = 0;",
1179 "",
1180 "yyreturn:",
1181 "#if defined(YYDESTRUCT_CALL)",
1182 " if (yychar != YYEOF && yychar != YYEMPTY)",
1183 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
1184 " YYDESTRUCT_CALL(\"cleanup: discarding token\", yychar, &yylval, &yylloc);",
1185 "#else",
1186 " YYDESTRUCT_CALL(\"cleanup: discarding token\", yychar, &yylval);",
1187 "#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */",
1188 "",
1189 " {",
1190 " YYSTYPE *pv;",
1191 "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
1192 " YYLTYPE *pp;",
1193 "",
1194 " for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)",
1195 " YYDESTRUCT_CALL(\"cleanup: discarding state\",",
1196 " yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);",
1197 "#else",
1198 " for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)",
1199 " YYDESTRUCT_CALL(\"cleanup: discarding state\",",
1200 " yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);",
1201 "#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */",
1202 " }",
1203 "#endif /* defined(YYDESTRUCT_CALL) */",
1204 "",
1205#if defined(YYBTYACC)
1206 "#if YYBTYACC",
1207 " if (yyerrctx)",
1208 " {",
1209 " yyFreeState(yyerrctx);",
1210 " yyerrctx = NULL;",
1211 " }",
1212 " while (yyps)",
1213 " {",
1214 " YYParseState *save = yyps;",
1215 " yyps = save->save;",
1216 " save->save = NULL;",
1217 " yyFreeState(save);",
1218 " }",
1219 " while (yypath)",
1220 " {",
1221 " YYParseState *save = yypath;",
1222 " yypath = save->save;",
1223 " save->save = NULL;",
1224 " yyFreeState(save);",
1225 " }",
1226 "#endif /* YYBTYACC */",

1227#endif /* defined(YYBTYACC) */