Home | History | Annotate | Line # | Download | only in yacc
err_syntax18.tab.c revision 1.4.8.1 
      1 /*	$NetBSD: err_syntax18.tab.c,v 1.4.8.1 2025/08/02 05:20:59 perseant 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"
    103 int yylex(void);
    104 static 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. */
    109 typedef 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 
    142 extern int YYPARSE_DECL();
    143 
    144 #define YYERRCODE 256
    145 typedef int YYINT;
    146 static const YYINT err_syntax18_lhs[] = {                -1,
    147     0,
    148 };
    149 static const YYINT err_syntax18_len[] = {                 2,
    150     3,
    151 };
    152 static const YYINT err_syntax18_defred[] = {              0,
    153     0,    0,    0,    1,
    154 };
    155 static const YYINT err_syntax18_dgoto[] = {               2,
    156 };
    157 static const YYINT err_syntax18_sindex[] = {            -40,
    158   -40,    0,  -39,    0,
    159 };
    160 static const YYINT err_syntax18_rindex[] = {              0,
    161     0,    0,    0,    0,
    162 };
    163 static const YYINT err_syntax18_gindex[] = {              2,
    164 };
    165 #define YYTABLESIZE 3
    166 static const YYINT err_syntax18_table[] = {               1,
    167     0,    4,    3,
    168 };
    169 static 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
    180 static 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,
    183 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,
    184 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,0,
    185 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,0,
    186 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,0,
    187 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,0,
    188 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,"illegal-symbol",
    189 };
    190 static const char *const err_syntax18_rule[] = {
    191 "$accept : expr",
    192 "expr : '(' expr ')'",
    193 
    194 };
    195 #endif
    196 
    197 #if YYDEBUG
    198 int      yydebug;
    199 #endif
    200 
    201 int      yyerrflag;
    202 int      yychar;
    203 YYSTYPE  yyval;
    204 YYSTYPE  yylval;
    205 int      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 
    222 typedef 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 */
    231 static YYSTACKDATA yystack;
    232 #line 13 "err_syntax18.y"
    233 
    234 #include <stdio.h>
    235 
    236 int
    237 main(void)
    238 {
    239     printf("yyparse() = %d\n", yyparse());
    240     return 0;
    241 }
    242 
    243 int
    244 yylex(void)
    245 {
    246     return -1;
    247 }
    248 
    249 static void
    250 yyerror(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 */
    264 static 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)
    299 static 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 
    314 int
    315 YYPARSE_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 is set below */
    330     /* yyn is set below */
    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 
    346 yyloop:
    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 */
    388 yyerrlab:
    389     ++yynerrs;
    390 
    391 yyinrecovery:
    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 
    439 yyreduce:
    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     {
    453 case 1:
    454 #line 9 "err_syntax18.y"
    455 	{  yyval = yystack.l_mark[1]; }
    456 #line 455 "err_syntax18.tab.c"
    457 break;
    458 #line 457 "err_syntax18.tab.c"
    459     }
    460     yystack.s_mark -= yym;
    461     yystate = *yystack.s_mark;
    462     yystack.l_mark -= yym;
    463     yym = yylhs[yyn];
    464     if (yystate == 0 && yym == 0)
    465     {
    466 #if YYDEBUG
    467         if (yydebug)
    468             printf("%sdebug: after reduction, shifting from state 0 to\
    469  state %d\n", YYPREFIX, YYFINAL);
    470 #endif
    471         yystate = YYFINAL;
    472         *++yystack.s_mark = YYFINAL;
    473         *++yystack.l_mark = yyval;
    474         if (yychar < 0)
    475         {
    476             yychar = YYLEX;
    477             if (yychar < 0) yychar = YYEOF;
    478 #if YYDEBUG
    479             if (yydebug)
    480             {
    481                 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
    482                 printf("%sdebug: state %d, reading %d (%s)\n",
    483                         YYPREFIX, YYFINAL, yychar, yys);
    484             }
    485 #endif
    486         }
    487         if (yychar == YYEOF) goto yyaccept;
    488         goto yyloop;
    489     }
    490     if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
    491             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
    492         yystate = yytable[yyn];
    493     else
    494         yystate = yydgoto[yym];
    495 #if YYDEBUG
    496     if (yydebug)
    497         printf("%sdebug: after reduction, shifting from state %d \
    498 to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
    499 #endif
    500     if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
    501     *++yystack.s_mark = (YYINT) yystate;
    502     *++yystack.l_mark = yyval;
    503     goto yyloop;
    504 
    505 yyoverflow:
    506     YYERROR_CALL("yacc stack overflow");
    507 
    508 yyabort:
    509     yyfreestack(&yystack);
    510     return (1);
    511 
    512 yyaccept:
    513     yyfreestack(&yystack);
    514     return (0);
    515 }
    516