1/* This file generated automatically using
2 * @Id: skel2c,v 1.3 2014/04/06 19:48:04 tom Exp @
3 */
4
5/* @Id: yaccpar.skel,v 1.5 2014/04/07 21:51:00 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) */",
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 YYINT yylhs[];",
49    "extern YYINT yylen[];",
50    "extern YYINT yydefred[];",
51    "extern YYINT yydgoto[];",
52    "extern YYINT yysindex[];",
53    "extern YYINT yyrindex[];",
54    "extern YYINT yygindex[];",
55    "extern YYINT yytable[];",
56    "extern YYINT yycheck[];",
57    "",
58    "#if YYDEBUG",
59    "extern char *yyname[];",
60    "extern char *yyrule[];",
61    "#endif",
62    0
63};
64
65const char *const global_vars[] =
66{
67    "",
68    "int      yydebug;",
69    "int      yynerrs;",
70    0
71};
72
73const char *const impure_vars[] =
74{
75    "",
76    "int      yyerrflag;",
77    "int      yychar;",
78    "YYSTYPE  yyval;",
79    "YYSTYPE  yylval;",
80    0
81};
82
83const char *const hdr_defs[] =
84{
85    "",
86    "/* define the initial stack-sizes */",
87    "#ifdef YYSTACKSIZE",
88    "#undef YYMAXDEPTH",
89    "#define YYMAXDEPTH  YYSTACKSIZE",
90    "#else",
91    "#ifdef YYMAXDEPTH",
92    "#define YYSTACKSIZE YYMAXDEPTH",
93    "#else",
94    "#define YYSTACKSIZE 10000",
95    "#define YYMAXDEPTH  10000",
96    "#endif",
97    "#endif",
98    "",
99    "#define YYINITSTACKSIZE 200",
100    "",
101    "typedef struct {",
102    "    unsigned stacksize;",
103    "    YYINT    *s_base;",
104    "    YYINT    *s_mark;",
105    "    YYINT    *s_last;",
106    "    YYSTYPE  *l_base;",
107    "    YYSTYPE  *l_mark;",
108    "} YYSTACKDATA;",
109    0
110};
111
112const char *const hdr_vars[] =
113{
114    "/* variables for the parser stack */",
115    "static YYSTACKDATA yystack;",
116    0
117};
118
119const char *const body_vars[] =
120{
121    "    int      yyerrflag;",
122    "    int      yychar;",
123    "    YYSTYPE  yyval;",
124    "    YYSTYPE  yylval;",
125    "",
126    "    /* variables for the parser stack */",
127    "    YYSTACKDATA yystack;",
128    0
129};
130
131const char *const body_1[] =
132{
133    "",
134    "#if YYDEBUG",
135    "#include <stdio.h>		/* needed for printf */",
136    "#endif",
137    "",
138    "#include <stdlib.h>	/* needed for malloc, etc */",
139    "#include <string.h>	/* needed for memset */",
140    "",
141    "/* allocate initial stack or double stack size, up to YYMAXDEPTH */",
142    "static int yygrowstack(YYSTACKDATA *data)",
143    "{",
144    "    int i;",
145    "    unsigned newsize;",
146    "    YYINT *newss;",
147    "    YYSTYPE *newvs;",
148    "",
149    "    if ((newsize = data->stacksize) == 0)",
150    "        newsize = YYINITSTACKSIZE;",
151    "    else if (newsize >= YYMAXDEPTH)",
152    "        return YYENOMEM;",
153    "    else if ((newsize *= 2) > YYMAXDEPTH)",
154    "        newsize = YYMAXDEPTH;",
155    "",
156    "    i = (int) (data->s_mark - data->s_base);",
157    "    newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));",
158    "    if (newss == 0)",
159    "        return YYENOMEM;",
160    "",
161    "    data->s_base = newss;",
162    "    data->s_mark = newss + i;",
163    "",
164    "    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));",
165    "    if (newvs == 0)",
166    "        return YYENOMEM;",
167    "",
168    "    data->l_base = newvs;",
169    "    data->l_mark = newvs + i;",
170    "",
171    "    data->stacksize = newsize;",
172    "    data->s_last = data->s_base + newsize - 1;",
173    "    return 0;",
174    "}",
175    "",
176    "#if YYPURE || defined(YY_NO_LEAKS)",
177    "static void yyfreestack(YYSTACKDATA *data)",
178    "{",
179    "    free(data->s_base);",
180    "    free(data->l_base);",
181    "    memset(data, 0, sizeof(*data));",
182    "}",
183    "#else",
184    "#define yyfreestack(data) /* nothing */",
185    "#endif",
186    "",
187    "#define YYABORT  goto yyabort",
188    "#define YYREJECT goto yyabort",
189    "#define YYACCEPT goto yyaccept",
190    "#define YYERROR  goto yyerrlab",
191    "",
192    "int",
193    "YYPARSE_DECL()",
194    "{",
195    0
196};
197
198const char *const body_2[] =
199{
200    "    int yym, yyn, yystate;",
201    "#if YYDEBUG",
202    "    const char *yys;",
203    "",
204    "    if ((yys = getenv(\"YYDEBUG\")) != 0)",
205    "    {",
206    "        yyn = *yys;",
207    "        if (yyn >= '0' && yyn <= '9')",
208    "            yydebug = yyn - '0';",
209    "    }",
210    "#endif",
211    "",
212    "    yynerrs = 0;",
213    "    yyerrflag = 0;",
214    "    yychar = YYEMPTY;",
215    "    yystate = 0;",
216    "",
217    "#if YYPURE",
218    "    memset(&yystack, 0, sizeof(yystack));",
219    "#endif",
220    "",
221    "    if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;",
222    "    yystack.s_mark = yystack.s_base;",
223    "    yystack.l_mark = yystack.l_base;",
224    "    yystate = 0;",
225    "    *yystack.s_mark = 0;",
226    "",
227    "yyloop:",
228    "    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;",
229    "    if (yychar < 0)",
230    "    {",
231    "        if ((yychar = YYLEX) < 0) yychar = YYEOF;",
232    "#if YYDEBUG",
233    "        if (yydebug)",
234    "        {",
235    "            yys = yyname[YYTRANSLATE(yychar)];",
236    "            printf(\"%sdebug: state %d, reading %d (%s)\\n\",",
237    "                    YYPREFIX, yystate, yychar, yys);",
238    "        }",
239    "#endif",
240    "    }",
241    "    if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&",
242    "            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)",
243    "    {",
244    "#if YYDEBUG",
245    "        if (yydebug)",
246    "            printf(\"%sdebug: state %d, shifting to state %d\\n\",",
247    "                    YYPREFIX, yystate, yytable[yyn]);",
248    "#endif",
249    "        if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)",
250    "        {",
251    "            goto yyoverflow;",
252    "        }",
253    "        yystate = yytable[yyn];",
254    "        *++yystack.s_mark = yytable[yyn];",
255    "        *++yystack.l_mark = yylval;",
256    "        yychar = YYEMPTY;",
257    "        if (yyerrflag > 0)  --yyerrflag;",
258    "        goto yyloop;",
259    "    }",
260    "    if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&",
261    "            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)",
262    "    {",
263    "        yyn = yytable[yyn];",
264    "        goto yyreduce;",
265    "    }",
266    "    if (yyerrflag) goto yyinrecovery;",
267    "",
268    "    YYERROR_CALL(\"syntax error\");",
269    "",
270    "    goto yyerrlab;",
271    "",
272    "yyerrlab:",
273    "    ++yynerrs;",
274    "",
275    "yyinrecovery:",
276    "    if (yyerrflag < 3)",
277    "    {",
278    "        yyerrflag = 3;",
279    "        for (;;)",
280    "        {",
281    "            if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&",
282    "                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)",
283    "            {",
284    "#if YYDEBUG",
285    "                if (yydebug)",
286    "                    printf(\"%sdebug: state %d, error recovery shifting\\",
287    " to state %d\\n\", YYPREFIX, *yystack.s_mark, yytable[yyn]);",
288    "#endif",
289    "                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)",
290    "                {",
291    "                    goto yyoverflow;",
292    "                }",
293    "                yystate = yytable[yyn];",
294    "                *++yystack.s_mark = yytable[yyn];",
295    "                *++yystack.l_mark = yylval;",
296    "                goto yyloop;",
297    "            }",
298    "            else",
299    "            {",
300    "#if YYDEBUG",
301    "                if (yydebug)",
302    "                    printf(\"%sdebug: error recovery discarding state %d\\n\",",
303    "                            YYPREFIX, *yystack.s_mark);",
304    "#endif",
305    "                if (yystack.s_mark <= yystack.s_base) goto yyabort;",
306    "                --yystack.s_mark;",
307    "                --yystack.l_mark;",
308    "            }",
309    "        }",
310    "    }",
311    "    else",
312    "    {",
313    "        if (yychar == YYEOF) goto yyabort;",
314    "#if YYDEBUG",
315    "        if (yydebug)",
316    "        {",
317    "            yys = yyname[YYTRANSLATE(yychar)];",
318    "            printf(\"%sdebug: state %d, error recovery discards token %d (%s)\\n\",",
319    "                    YYPREFIX, yystate, yychar, yys);",
320    "        }",
321    "#endif",
322    "        yychar = YYEMPTY;",
323    "        goto yyloop;",
324    "    }",
325    "",
326    "yyreduce:",
327    "#if YYDEBUG",
328    "    if (yydebug)",
329    "        printf(\"%sdebug: state %d, reducing by rule %d (%s)\\n\",",
330    "                YYPREFIX, yystate, yyn, yyrule[yyn]);",
331    "#endif",
332    "    yym = yylen[yyn];",
333    "    if (yym)",
334    "        yyval = yystack.l_mark[1-yym];",
335    "    else",
336    "        memset(&yyval, 0, sizeof yyval);",
337    "    switch (yyn)",
338    "    {",
339    0
340};
341
342const char *const trailer[] =
343{
344    "    }",
345    "    yystack.s_mark -= yym;",
346    "    yystate = *yystack.s_mark;",
347    "    yystack.l_mark -= yym;",
348    "    yym = yylhs[yyn];",
349    "    if (yystate == 0 && yym == 0)",
350    "    {",
351    "#if YYDEBUG",
352    "        if (yydebug)",
353    "            printf(\"%sdebug: after reduction, shifting from state 0 to\\",
354    " state %d\\n\", YYPREFIX, YYFINAL);",
355    "#endif",
356    "        yystate = YYFINAL;",
357    "        *++yystack.s_mark = YYFINAL;",
358    "        *++yystack.l_mark = yyval;",
359    "        if (yychar < 0)",
360    "        {",
361    "            if ((yychar = YYLEX) < 0) yychar = YYEOF;",
362    "#if YYDEBUG",
363    "            if (yydebug)",
364    "            {",
365    "                yys = yyname[YYTRANSLATE(yychar)];",
366    "                printf(\"%sdebug: state %d, reading %d (%s)\\n\",",
367    "                        YYPREFIX, YYFINAL, yychar, yys);",
368    "            }",
369    "#endif",
370    "        }",
371    "        if (yychar == YYEOF) goto yyaccept;",
372    "        goto yyloop;",
373    "    }",
374    "    if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&",
375    "            yyn <= YYTABLESIZE && yycheck[yyn] == yystate)",
376    "        yystate = yytable[yyn];",
377    "    else",
378    "        yystate = yydgoto[yym];",
379    "#if YYDEBUG",
380    "    if (yydebug)",
381    "        printf(\"%sdebug: after reduction, shifting from state %d \\",
382    "to state %d\\n\", YYPREFIX, *yystack.s_mark, yystate);",
383    "#endif",
384    "    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)",
385    "    {",
386    "        goto yyoverflow;",
387    "    }",
388    "    *++yystack.s_mark = (YYINT) yystate;",
389    "    *++yystack.l_mark = yyval;",
390    "    goto yyloop;",
391    "",
392    "yyoverflow:",
393    "    YYERROR_CALL(\"yacc stack overflow\");",
394    "",
395    "yyabort:",
396    "    yyfreestack(&yystack);",
397    "    return (1);",
398    "",
399    "yyaccept:",
400    "    yyfreestack(&yystack);",
401    "    return (0);",
402    "}",
403    0
404};
405
406void
407write_section(FILE * fp, const char *const section[])
408{
409    int i;
410    const char *s;
411
412    for (i = 0; (s = section[i]) != 0; ++i)
413    {
414	if (fp == code_file)
415	    ++outline;
416	fprintf(fp, "%s\n", s);
417    }
418}
419