external/bsd/byacc/dist/test/error.tab.c

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