1/*	$NetBSD: code_error.code.c,v 1.4 2021/02/20 22:57:57 christos Exp $	*/
2
3/* original parser id follows */
4/* yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93" */
5/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
6
7#define YYBYACC 1
8#define YYMAJOR 2
9#define YYMINOR 0
10#define YYCHECK "yyyymmdd"
11
12#define YYEMPTY        (-1)
13#define yyclearin      (yychar = YYEMPTY)
14#define yyerrok        (yyerrflag = 0)
15#define YYRECOVERING() (yyerrflag != 0)
16#define YYENOMEM       (-2)
17#define YYEOF          0
18
19#ifndef yyparse
20#define yyparse    error_parse
21#endif /* yyparse */
22
23#ifndef yylex
24#define yylex      error_lex
25#endif /* yylex */
26
27#ifndef yyerror
28#define yyerror    error_error
29#endif /* yyerror */
30
31#ifndef yychar
32#define yychar     error_char
33#endif /* yychar */
34
35#ifndef yyval
36#define yyval      error_val
37#endif /* yyval */
38
39#ifndef yylval
40#define yylval     error_lval
41#endif /* yylval */
42
43#ifndef yydebug
44#define yydebug    error_debug
45#endif /* yydebug */
46
47#ifndef yynerrs
48#define yynerrs    error_nerrs
49#endif /* yynerrs */
50
51#ifndef yyerrflag
52#define yyerrflag  error_errflag
53#endif /* yyerrflag */
54
55#ifndef yylhs
56#define yylhs      error_lhs
57#endif /* yylhs */
58
59#ifndef yylen
60#define yylen      error_len
61#endif /* yylen */
62
63#ifndef yydefred
64#define yydefred   error_defred
65#endif /* yydefred */
66
67#ifndef yydgoto
68#define yydgoto    error_dgoto
69#endif /* yydgoto */
70
71#ifndef yysindex
72#define yysindex   error_sindex
73#endif /* yysindex */
74
75#ifndef yyrindex
76#define yyrindex   error_rindex
77#endif /* yyrindex */
78
79#ifndef yygindex
80#define yygindex   error_gindex
81#endif /* yygindex */
82
83#ifndef yytable
84#define yytable    error_table
85#endif /* yytable */
86
87#ifndef yycheck
88#define yycheck    error_check
89#endif /* yycheck */
90
91#ifndef yyname
92#define yyname     error_name
93#endif /* yyname */
94
95#ifndef yyrule
96#define yyrule     error_rule
97#endif /* yyrule */
98#define YYPREFIX "error_"
99
100#define YYPURE 0
101
102#line 2 "code_error.y"
103
104#ifdef YYBISON
105int yylex(void);
106static void yyerror(const char *);
107#endif
108
109#line 108 "code_error.code.c"
110
111#if ! defined(YYSTYPE) && ! defined(YYSTYPE_IS_DECLARED)
112/* Default: YYSTYPE is the semantic value type. */
113typedef int YYSTYPE;
114# define YYSTYPE_IS_DECLARED 1
115#endif
116
117/* compatibility with bison */
118#ifdef YYPARSE_PARAM
119/* compatibility with FreeBSD */
120# ifdef YYPARSE_PARAM_TYPE
121#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
122# else
123#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
124# endif
125#else
126# define YYPARSE_DECL() yyparse(void)
127#endif
128
129/* Parameters sent to lex. */
130#ifdef YYLEX_PARAM
131# define YYLEX_DECL() yylex(void *YYLEX_PARAM)
132# define YYLEX yylex(YYLEX_PARAM)
133#else
134# define YYLEX_DECL() yylex(void)
135# define YYLEX yylex()
136#endif
137
138/* Parameters sent to yyerror. */
139#ifndef YYERROR_DECL
140#define YYERROR_DECL() yyerror(const char *s)
141#endif
142#ifndef YYERROR_CALL
143#define YYERROR_CALL(msg) yyerror(msg)
144#endif
145
146#define YYERRCODE 256
147#define YYTABLESIZE 0
148#define YYFINAL 2
149#ifndef YYDEBUG
150#define YYDEBUG 0
151#endif
152#define YYMAXTOKEN 256
153#define YYUNDFTOKEN 259
154#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
155
156extern int YYPARSE_DECL();
157typedef short YYINT;
158extern YYINT yylhs[];
159extern YYINT yylen[];
160extern YYINT yydefred[];
161extern YYINT yydgoto[];
162extern YYINT yysindex[];
163extern YYINT yyrindex[];
164extern YYINT yygindex[];
165extern YYINT yytable[];
166extern YYINT yycheck[];
167
168#if YYDEBUG || defined(yytname)
169extern char *yyname[];
170#endif
171#if YYDEBUG
172extern char *yyrule[];
173#endif
174
175#if YYDEBUG
176int      yydebug;
177#endif
178
179int      yyerrflag;
180int      yychar;
181YYSTYPE  yyval;
182YYSTYPE  yylval;
183int      yynerrs;
184
185/* define the initial stack-sizes */
186#ifdef YYSTACKSIZE
187#undef YYMAXDEPTH
188#define YYMAXDEPTH  YYSTACKSIZE
189#else
190#ifdef YYMAXDEPTH
191#define YYSTACKSIZE YYMAXDEPTH
192#else
193#define YYSTACKSIZE 10000
194#define YYMAXDEPTH  10000
195#endif
196#endif
197
198#define YYINITSTACKSIZE 200
199
200typedef struct {
201    unsigned stacksize;
202    YYINT    *s_base;
203    YYINT    *s_mark;
204    YYINT    *s_last;
205    YYSTYPE  *l_base;
206    YYSTYPE  *l_mark;
207} YYSTACKDATA;
208/* variables for the parser stack */
209static YYSTACKDATA yystack;
210#line 12 "code_error.y"
211
212#include <stdio.h>
213
214#ifdef YYBYACC
215extern int YYLEX_DECL();
216#endif
217
218int
219main(void)
220{
221    printf("yyparse() = %d\n", yyparse());
222    return 0;
223}
224
225int
226yylex(void)
227{
228    return -1;
229}
230
231static void
232yyerror(const char* s)
233{
234    printf("%s\n", s);
235}
236#line 235 "code_error.code.c"
237
238#if YYDEBUG
239#include <stdio.h>	/* needed for printf */
240#endif
241
242#include <stdlib.h>	/* needed for malloc, etc */
243#include <string.h>	/* needed for memset */
244
245/* allocate initial stack or double stack size, up to YYMAXDEPTH */
246static int yygrowstack(YYSTACKDATA *data)
247{
248    int i;
249    unsigned newsize;
250    YYINT *newss;
251    YYSTYPE *newvs;
252
253    if ((newsize = data->stacksize) == 0)
254        newsize = YYINITSTACKSIZE;
255    else if (newsize >= YYMAXDEPTH)
256        return YYENOMEM;
257    else if ((newsize *= 2) > YYMAXDEPTH)
258        newsize = YYMAXDEPTH;
259
260    i = (int) (data->s_mark - data->s_base);
261    newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
262    if (newss == 0)
263        return YYENOMEM;
264
265    data->s_base = newss;
266    data->s_mark = newss + i;
267
268    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
269    if (newvs == 0)
270        return YYENOMEM;
271
272    data->l_base = newvs;
273    data->l_mark = newvs + i;
274
275    data->stacksize = newsize;
276    data->s_last = data->s_base + newsize - 1;
277    return 0;
278}
279
280#if YYPURE || defined(YY_NO_LEAKS)
281static void yyfreestack(YYSTACKDATA *data)
282{
283    free(data->s_base);
284    free(data->l_base);
285    memset(data, 0, sizeof(*data));
286}
287#else
288#define yyfreestack(data) /* nothing */
289#endif
290
291#define YYABORT  goto yyabort
292#define YYREJECT goto yyabort
293#define YYACCEPT goto yyaccept
294#define YYERROR  goto yyerrlab
295
296int
297YYPARSE_DECL()
298{
299    int yym, yyn, yystate;
300#if YYDEBUG
301    const char *yys;
302
303    if ((yys = getenv("YYDEBUG")) != 0)
304    {
305        yyn = *yys;
306        if (yyn >= '0' && yyn <= '9')
307            yydebug = yyn - '0';
308    }
309#endif
310
311    yym = 0;
312    yyn = 0;
313    yynerrs = 0;
314    yyerrflag = 0;
315    yychar = YYEMPTY;
316    yystate = 0;
317
318#if YYPURE
319    memset(&yystack, 0, sizeof(yystack));
320#endif
321
322    if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
323    yystack.s_mark = yystack.s_base;
324    yystack.l_mark = yystack.l_base;
325    yystate = 0;
326    *yystack.s_mark = 0;
327
328yyloop:
329    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
330    if (yychar < 0)
331    {
332        yychar = YYLEX;
333        if (yychar < 0) yychar = YYEOF;
334#if YYDEBUG
335        if (yydebug)
336        {
337            if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
338            printf("%sdebug: state %d, reading %d (%s)\n",
339                    YYPREFIX, yystate, yychar, yys);
340        }
341#endif
342    }
343    if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
344            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
345    {
346#if YYDEBUG
347        if (yydebug)
348            printf("%sdebug: state %d, shifting to state %d\n",
349                    YYPREFIX, yystate, yytable[yyn]);
350#endif
351        if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
352        yystate = yytable[yyn];
353        *++yystack.s_mark = yytable[yyn];
354        *++yystack.l_mark = yylval;
355        yychar = YYEMPTY;
356        if (yyerrflag > 0)  --yyerrflag;
357        goto yyloop;
358    }
359    if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
360            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
361    {
362        yyn = yytable[yyn];
363        goto yyreduce;
364    }
365    if (yyerrflag != 0) goto yyinrecovery;
366
367    YYERROR_CALL("syntax error");
368
369    goto yyerrlab; /* redundant goto avoids 'unused label' warning */
370yyerrlab:
371    ++yynerrs;
372
373yyinrecovery:
374    if (yyerrflag < 3)
375    {
376        yyerrflag = 3;
377        for (;;)
378        {
379            if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
380                    yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
381            {
382#if YYDEBUG
383                if (yydebug)
384                    printf("%sdebug: state %d, error recovery shifting\
385 to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
386#endif
387                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
388                yystate = yytable[yyn];
389                *++yystack.s_mark = yytable[yyn];
390                *++yystack.l_mark = yylval;
391                goto yyloop;
392            }
393            else
394            {
395#if YYDEBUG
396                if (yydebug)
397                    printf("%sdebug: error recovery discarding state %d\n",
398                            YYPREFIX, *yystack.s_mark);
399#endif
400                if (yystack.s_mark <= yystack.s_base) goto yyabort;
401                --yystack.s_mark;
402                --yystack.l_mark;
403            }
404        }
405    }
406    else
407    {
408        if (yychar == YYEOF) goto yyabort;
409#if YYDEBUG
410        if (yydebug)
411        {
412            if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
413            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
414                    YYPREFIX, yystate, yychar, yys);
415        }
416#endif
417        yychar = YYEMPTY;
418        goto yyloop;
419    }
420
421yyreduce:
422#if YYDEBUG
423    if (yydebug)
424        printf("%sdebug: state %d, reducing by rule %d (%s)\n",
425                YYPREFIX, yystate, yyn, yyrule[yyn]);
426#endif
427    yym = yylen[yyn];
428    if (yym > 0)
429        yyval = yystack.l_mark[1-yym];
430    else
431        memset(&yyval, 0, sizeof yyval);
432
433    switch (yyn)
434    {
435    }
436    yystack.s_mark -= yym;
437    yystate = *yystack.s_mark;
438    yystack.l_mark -= yym;
439    yym = yylhs[yyn];
440    if (yystate == 0 && yym == 0)
441    {
442#if YYDEBUG
443        if (yydebug)
444            printf("%sdebug: after reduction, shifting from state 0 to\
445 state %d\n", YYPREFIX, YYFINAL);
446#endif
447        yystate = YYFINAL;
448        *++yystack.s_mark = YYFINAL;
449        *++yystack.l_mark = yyval;
450        if (yychar < 0)
451        {
452            yychar = YYLEX;
453            if (yychar < 0) yychar = YYEOF;
454#if YYDEBUG
455            if (yydebug)
456            {
457                if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
458                printf("%sdebug: state %d, reading %d (%s)\n",
459                        YYPREFIX, YYFINAL, yychar, yys);
460            }
461#endif
462        }
463        if (yychar == YYEOF) goto yyaccept;
464        goto yyloop;
465    }
466    if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
467            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
468        yystate = yytable[yyn];
469    else
470        yystate = yydgoto[yym];
471#if YYDEBUG
472    if (yydebug)
473        printf("%sdebug: after reduction, shifting from state %d \
474to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
475#endif
476    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
477    *++yystack.s_mark = (YYINT) yystate;
478    *++yystack.l_mark = yyval;
479    goto yyloop;
480
481yyoverflow:
482    YYERROR_CALL("yacc stack overflow");
483
484yyabort:
485    yyfreestack(&yystack);
486    return (1);
487
488yyaccept:
489    yyfreestack(&yystack);
490    return (0);
491}
492