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

   1 /*      $NetBSD$        */
   2 #ifndef lint
   3 /* static const char yysccsid[] = "@(#)yaccpar  1.9 (Berkeley) 02/21/93"; */
   4 static char rcsid[] = "$NetBSD: error.tab.c,v 1.4 1997/01/09 20:23:30 tls Exp $";
   5 #endif
   6
   7 #include <stdlib.h>
   8 #include <string.h>
   9
  10 #define YYBYACC 1
  11 #define YYMAJOR 1
  12 #define YYMINOR 9
  13
  14 #define YYEMPTY        (-1)
  15 #define yyclearin      (yychar = YYEMPTY)
  16 #define yyerrok        (yyerrflag = 0)
  17 #define YYRECOVERING() (yyerrflag != 0)
  18
  19 /* compatibility with bison */
  20 #ifdef YYPARSE_PARAM
  21 /* compatibility with FreeBSD */
  22 #ifdef YYPARSE_PARAM_TYPE
  23 #define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
  24 #else
  25 #define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
  26 #endif
  27 #else
  28 #define YYPARSE_DECL() yyparse(void)
  29 #endif /* YYPARSE_PARAM */
  30
  31 extern int YYPARSE_DECL();
  32
  33 static int yygrowstack(void);
  34 #define yyparse    error_parse
  35 #define yylex      error_lex
  36 #define yyerror    error_error
  37 #define yychar     error_char
  38 #define yyval      error_val
  39 #define yylval     error_lval
  40 #define yydebug    error_debug
  41 #define yynerrs    error_nerrs
  42 #define yyerrflag  error_errflag
  43 #define yyss       error_ss
  44 #define yyssp      error_ssp
  45 #define yyvs       error_vs
  46 #define yyvsp      error_vsp
  47 #define yylhs      error_lhs
  48 #define yylen      error_len
  49 #define yydefred   error_defred
  50 #define yydgoto    error_dgoto
  51 #define yysindex   error_sindex
  52 #define yyrindex   error_rindex
  53 #define yygindex   error_gindex
  54 #define yytable    error_table
  55 #define yycheck    error_check
  56 #define yyname     error_name
  57 #define yyrule     error_rule
  58 #define YYPREFIX "error_"
  59 #define YYERRCODE 256
  60 static const short error_lhs[] = {                       -1,
  61     0,
  62 };
  63 static const short error_len[] = {                        2,
  64     1,
  65 };
  66 static const short error_defred[] = {                     0,
  67     1,    0,
  68 };
  69 static const short error_dgoto[] = {                      2,
  70 };
  71 static const short error_sindex[] = {                  -256,
  72     0,    0,
  73 };
  74 static const short error_rindex[] = {                     0,
  75     0,    0,
  76 };
  77 static const short error_gindex[] = {                     0,
  78 };
  79 #define YYTABLESIZE 0
  80 static const short error_table[] = {                      1,
  81 };
  82 static const short error_check[] = {                    256,
  83 };
  84 #define YYFINAL 2
  85 #ifndef YYDEBUG
  86 #define YYDEBUG 0
  87 #endif
  88 #define YYMAXTOKEN 0
  89 #if YYDEBUG
  90 static const char *error_name[] = {
  91
  92 "end-of-file",
  93 };
  94 static const char *error_rule[] = {
  95 "$accept : S",
  96 "S : error",
  97
  98 };
  99 #endif
 100 #ifndef YYSTYPE
 101 typedef int YYSTYPE;
 102 #endif
 103 #if YYDEBUG
 104 #include <stdio.h>
 105 #endif
 106
 107 /* define the initial stack-sizes */
 108 #ifdef YYSTACKSIZE
 109 #undef YYMAXDEPTH
 110 #define YYMAXDEPTH  YYSTACKSIZE
 111 #else
 112 #ifdef YYMAXDEPTH
 113 #define YYSTACKSIZE YYMAXDEPTH
 114 #else
 115 #define YYSTACKSIZE 500
 116 #define YYMAXDEPTH  500
 117 #endif
 118 #endif
 119
 120 #define YYINITSTACKSIZE 500
 121
 122 int      yydebug;
 123 int      yynerrs;
 124 int      yyerrflag;
 125 int      yychar;
 126 short   *yyssp;
 127 YYSTYPE *yyvsp;
 128 YYSTYPE  yyval;
 129 YYSTYPE  yylval;
 130
 131 /* variables for the parser stack */
 132 static short   *yyss;
 133 static short   *yysslim;
 134 static YYSTYPE *yyvs;
 135 static unsigned yystacksize;
 136 #line 4 "error.y"
 137 main(){printf("yyparse() = %d\n",yyparse());}
 138 yylex(){return-1;}
 139 yyerror(s)char*s;{printf("%s\n",s);}
 140 #line 139 "error.tab.c"
 141 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
 142 static int yygrowstack(void)
 143 {
 144     int i;
 145     unsigned newsize;
 146     short *newss;
 147     YYSTYPE *newvs;
 148
 149     if ((newsize = yystacksize) == 0)
 150         newsize = YYINITSTACKSIZE;
 151     else if (newsize >= YYMAXDEPTH)
 152         return -1;
 153     else if ((newsize *= 2) > YYMAXDEPTH)
 154         newsize = YYMAXDEPTH;
 155
 156     i = yyssp - yyss;
 157     newss = (yyss != 0)
 158           ? (short *)realloc(yyss, newsize * sizeof(*newss))
 159           : (short *)malloc(newsize * sizeof(*newss));
 160     if (newss == 0)
 161         return -1;
 162
 163     yyss  = newss;
 164     yyssp = newss + i;
 165     newvs = (yyvs != 0)
 166           ? (YYSTYPE *)realloc(yyvs, newsize * sizeof(*newvs))
 167           : (YYSTYPE *)malloc(newsize * sizeof(*newvs));
 168     if (newvs == 0)
 169         return -1;
 170
 171     yyvs = newvs;
 172     yyvsp = newvs + i;
 173     yystacksize = newsize;
 174     yysslim = yyss + newsize - 1;
 175     return 0;
 176 }
 177
 178 #define YYABORT  goto yyabort
 179 #define YYREJECT goto yyabort
 180 #define YYACCEPT goto yyaccept
 181 #define YYERROR  goto yyerrlab
 182
 183 int
 184 YYPARSE_DECL()
 185 {
 186     int yym, yyn, yystate;
 187 #if YYDEBUG
 188     const char *yys;
 189
 190     if ((yys = getenv("YYDEBUG")) != 0)
 191     {
 192         yyn = *yys;
 193         if (yyn >= '0' && yyn <= '9')
 194             yydebug = yyn - '0';
 195     }
 196 #endif
 197
 198     yynerrs = 0;
 199     yyerrflag = 0;
 200     yychar = YYEMPTY;
 201     yystate = 0;
 202
 203     if (yyss == NULL && yygrowstack()) goto yyoverflow;
 204     yyssp = yyss;
 205     yyvsp = yyvs;
 206     yystate = 0;
 207     *yyssp = 0;
 208
 209 yyloop:
 210     if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
 211     if (yychar < 0)
 212     {
 213         if ((yychar = yylex()) < 0) yychar = 0;
 214 #if YYDEBUG
 215         if (yydebug)
 216         {
 217             yys = 0;
 218             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 219             if (!yys) yys = "illegal-symbol";
 220             printf("%sdebug: state %d, reading %d (%s)\n",
 221                     YYPREFIX, yystate, yychar, yys);
 222         }
 223 #endif
 224     }
 225     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
 226             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 227     {
 228 #if YYDEBUG
 229         if (yydebug)
 230             printf("%sdebug: state %d, shifting to state %d\n",
 231                     YYPREFIX, yystate, yytable[yyn]);
 232 #endif
 233         if (yyssp >= yysslim && yygrowstack())
 234         {
 235             goto yyoverflow;
 236         }
 237         yystate = yytable[yyn];
 238         *++yyssp = yytable[yyn];
 239         *++yyvsp = yylval;
 240         yychar = YYEMPTY;
 241         if (yyerrflag > 0)  --yyerrflag;
 242         goto yyloop;
 243     }
 244     if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
 245             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 246     {
 247         yyn = yytable[yyn];
 248         goto yyreduce;
 249     }
 250     if (yyerrflag) goto yyinrecovery;
 251
 252     yyerror("syntax error");
 253
 254     goto yyerrlab;
 255
 256 yyerrlab:
 257     ++yynerrs;
 258
 259 yyinrecovery:
 260     if (yyerrflag < 3)
 261     {
 262         yyerrflag = 3;
 263         for (;;)
 264         {
 265             if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
 266                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
 267             {
 268 #if YYDEBUG
 269                 if (yydebug)
 270                     printf("%sdebug: state %d, error recovery shifting\
 271  to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
 272 #endif
 273                 if (yyssp >= yysslim && yygrowstack())
 274                 {
 275                     goto yyoverflow;
 276                 }
 277                 yystate = yytable[yyn];
 278                 *++yyssp = yytable[yyn];
 279                 *++yyvsp = yylval;
 280                 goto yyloop;
 281             }
 282             else
 283             {
 284 #if YYDEBUG
 285                 if (yydebug)
 286                     printf("%sdebug: error recovery discarding state %d\n",
 287                             YYPREFIX, *yyssp);
 288 #endif
 289                 if (yyssp <= yyss) goto yyabort;
 290                 --yyssp;
 291                 --yyvsp;
 292             }
 293         }
 294     }
 295     else
 296     {
 297         if (yychar == 0) goto yyabort;
 298 #if YYDEBUG
 299         if (yydebug)
 300         {
 301             yys = 0;
 302             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 303             if (!yys) yys = "illegal-symbol";
 304             printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
 305                     YYPREFIX, yystate, yychar, yys);
 306         }
 307 #endif
 308         yychar = YYEMPTY;
 309         goto yyloop;
 310     }
 311
 312 yyreduce:
 313 #if YYDEBUG
 314     if (yydebug)
 315         printf("%sdebug: state %d, reducing by rule %d (%s)\n",
 316                 YYPREFIX, yystate, yyn, yyrule[yyn]);
 317 #endif
 318     yym = yylen[yyn];
 319     if (yym)
 320         yyval = yyvsp[1-yym];
 321     else
 322         memset(&yyval, 0, sizeof yyval);
 323     switch (yyn)
 324     {
 325     }
 326     yyssp -= yym;
 327     yystate = *yyssp;
 328     yyvsp -= yym;
 329     yym = yylhs[yyn];
 330     if (yystate == 0 && yym == 0)
 331     {
 332 #if YYDEBUG
 333         if (yydebug)
 334             printf("%sdebug: after reduction, shifting from state 0 to\
 335  state %d\n", YYPREFIX, YYFINAL);
 336 #endif
 337         yystate = YYFINAL;
 338         *++yyssp = YYFINAL;
 339         *++yyvsp = yyval;
 340         if (yychar < 0)
 341         {
 342             if ((yychar = yylex()) < 0) yychar = 0;
 343 #if YYDEBUG
 344             if (yydebug)
 345             {
 346                 yys = 0;
 347                 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 348                 if (!yys) yys = "illegal-symbol";
 349                 printf("%sdebug: state %d, reading %d (%s)\n",
 350                         YYPREFIX, YYFINAL, yychar, yys);
 351             }
 352 #endif
 353         }
 354         if (yychar == 0) goto yyaccept;
 355         goto yyloop;
 356     }
 357     if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
 358             yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
 359         yystate = yytable[yyn];
 360     else
 361         yystate = yydgoto[yym];
 362 #if YYDEBUG
 363     if (yydebug)
 364         printf("%sdebug: after reduction, shifting from state %d \
 365 to state %d\n", YYPREFIX, *yyssp, yystate);
 366 #endif
 367     if (yyssp >= yysslim && yygrowstack())
 368     {
 369         goto yyoverflow;
 370     }
 371     *++yyssp = (short) yystate;
 372     *++yyvsp = yyval;
 373     goto yyloop;
 374
 375 yyoverflow:
 376     yyerror("yacc stack overflow");
 377
 378 yyabort:
 379     return (1);
 380
 381 yyaccept:
 382     return (0);
 383 }