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