usr.bin/yacc/test/error.tab.c

   1 #ifndef lint
   2 /*static char yysccsid[] = "from: @(#)yaccpar   1.9 (Berkeley) 02/21/93";*/
   3 static char rcsid[] = "$NetBSD: error.tab.c,v 1.3 1993/08/01 18:00:46 mycroft Exp $";
   4 #endif
   5 #define YYBYACC 1
   6 #define YYMAJOR 1
   7 #define YYMINOR 9
   8 #define yyclearin (yychar=(-1))
   9 #define yyerrok (yyerrflag=0)
  10 #define YYRECOVERING (yyerrflag!=0)
  11 #define YYPREFIX "yy"
  12 #define YYERRCODE 256
  13 short yylhs[] = {                                        -1,
  14     0,
  15 };
  16 short yylen[] = {                                         2,
  17     1,
  18 };
  19 short yydefred[] = {                                      0,
  20     1,    0,
  21 };
  22 short yydgoto[] = {                                       2,
  23 };
  24 short yysindex[] = {                                   -256,
  25     0,    0,
  26 };
  27 short yyrindex[] = {                                      0,
  28     0,    0,
  29 };
  30 short yygindex[] = {                                      0,
  31 };
  32 #define YYTABLESIZE 0
  33 short yytable[] = {                                       1,
  34 };
  35 short yycheck[] = {                                     256,
  36 };
  37 #define YYFINAL 2
  38 #ifndef YYDEBUG
  39 #define YYDEBUG 0
  40 #endif
  41 #define YYMAXTOKEN 0
  42 #if YYDEBUG
  43 char *yyname[] = {
  44 "end-of-file",
  45 };
  46 char *yyrule[] = {
  47 "$accept : S",
  48 "S : error",
  49 };
  50 #endif
  51 #ifndef YYSTYPE
  52 typedef int YYSTYPE;
  53 #endif
  54 #ifdef YYSTACKSIZE
  55 #undef YYMAXDEPTH
  56 #define YYMAXDEPTH YYSTACKSIZE
  57 #else
  58 #ifdef YYMAXDEPTH
  59 #define YYSTACKSIZE YYMAXDEPTH
  60 #else
  61 #define YYSTACKSIZE 500
  62 #define YYMAXDEPTH 500
  63 #endif
  64 #endif
  65 int yydebug;
  66 int yynerrs;
  67 int yyerrflag;
  68 int yychar;
  69 short *yyssp;
  70 YYSTYPE *yyvsp;
  71 YYSTYPE yyval;
  72 YYSTYPE yylval;
  73 short yyss[YYSTACKSIZE];
  74 YYSTYPE yyvs[YYSTACKSIZE];
  75 #define yystacksize YYSTACKSIZE
  76 #line 4 "error.y"
  77 main(){printf("yyparse() = %d\n",yyparse());}
  78 yylex(){return-1;}
  79 yyerror(s)char*s;{printf("%s\n",s);}
  80 #line 80 "error.tab.c"
  81 #define YYABORT goto yyabort
  82 #define YYREJECT goto yyabort
  83 #define YYACCEPT goto yyaccept
  84 #define YYERROR goto yyerrlab
  85 int
  86 yyparse()
  87 {
  88     register int yym, yyn, yystate;
  89 #if YYDEBUG
  90     register char *yys;
  91     extern char *getenv();
  92
  93     if (yys = getenv("YYDEBUG"))
  94     {
  95         yyn = *yys;
  96         if (yyn >= '0' && yyn <= '9')
  97             yydebug = yyn - '0';
  98     }
  99 #endif
 100
 101     yynerrs = 0;
 102     yyerrflag = 0;
 103     yychar = (-1);
 104
 105     yyssp = yyss;
 106     yyvsp = yyvs;
 107     *yyssp = yystate = 0;
 108
 109 yyloop:
 110     if (yyn = yydefred[yystate]) goto yyreduce;
 111     if (yychar < 0)
 112     {
 113         if ((yychar = yylex()) < 0) yychar = 0;
 114 #if YYDEBUG
 115         if (yydebug)
 116         {
 117             yys = 0;
 118             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 119             if (!yys) yys = "illegal-symbol";
 120             printf("%sdebug: state %d, reading %d (%s)\n",
 121                     YYPREFIX, yystate, yychar, yys);
 122         }
 123 #endif
 124     }
 125     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
 126             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 127     {
 128 #if YYDEBUG
 129         if (yydebug)
 130             printf("%sdebug: state %d, shifting to state %d\n",
 131                     YYPREFIX, yystate, yytable[yyn]);
 132 #endif
 133         if (yyssp >= yyss + yystacksize - 1)
 134         {
 135             goto yyoverflow;
 136         }
 137         *++yyssp = yystate = yytable[yyn];
 138         *++yyvsp = yylval;
 139         yychar = (-1);
 140         if (yyerrflag > 0)  --yyerrflag;
 141         goto yyloop;
 142     }
 143     if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
 144             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 145     {
 146         yyn = yytable[yyn];
 147         goto yyreduce;
 148     }
 149     if (yyerrflag) goto yyinrecovery;
 150 #ifdef lint
 151     goto yynewerror;
 152 #endif
 153 yynewerror:
 154     yyerror("syntax error");
 155 #ifdef lint
 156     goto yyerrlab;
 157 #endif
 158 yyerrlab:
 159     ++yynerrs;
 160 yyinrecovery:
 161     if (yyerrflag < 3)
 162     {
 163         yyerrflag = 3;
 164         for (;;)
 165         {
 166             if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
 167                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
 168             {
 169 #if YYDEBUG
 170                 if (yydebug)
 171                     printf("%sdebug: state %d, error recovery shifting\
 172  to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
 173 #endif
 174                 if (yyssp >= yyss + yystacksize - 1)
 175                 {
 176                     goto yyoverflow;
 177                 }
 178                 *++yyssp = yystate = yytable[yyn];
 179                 *++yyvsp = yylval;
 180                 goto yyloop;
 181             }
 182             else
 183             {
 184 #if YYDEBUG
 185                 if (yydebug)
 186                     printf("%sdebug: error recovery discarding state %d\n",
 187                             YYPREFIX, *yyssp);
 188 #endif
 189                 if (yyssp <= yyss) goto yyabort;
 190                 --yyssp;
 191                 --yyvsp;
 192             }
 193         }
 194     }
 195     else
 196     {
 197         if (yychar == 0) goto yyabort;
 198 #if YYDEBUG
 199         if (yydebug)
 200         {
 201             yys = 0;
 202             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 203             if (!yys) yys = "illegal-symbol";
 204             printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
 205                     YYPREFIX, yystate, yychar, yys);
 206         }
 207 #endif
 208         yychar = (-1);
 209         goto yyloop;
 210     }
 211 yyreduce:
 212 #if YYDEBUG
 213     if (yydebug)
 214         printf("%sdebug: state %d, reducing by rule %d (%s)\n",
 215                 YYPREFIX, yystate, yyn, yyrule[yyn]);
 216 #endif
 217     yym = yylen[yyn];
 218     yyval = yyvsp[1-yym];
 219     switch (yyn)
 220     {
 221     }
 222     yyssp -= yym;
 223     yystate = *yyssp;
 224     yyvsp -= yym;
 225     yym = yylhs[yyn];
 226     if (yystate == 0 && yym == 0)
 227     {
 228 #if YYDEBUG
 229         if (yydebug)
 230             printf("%sdebug: after reduction, shifting from state 0 to\
 231  state %d\n", YYPREFIX, YYFINAL);
 232 #endif
 233         yystate = YYFINAL;
 234         *++yyssp = YYFINAL;
 235         *++yyvsp = yyval;
 236         if (yychar < 0)
 237         {
 238             if ((yychar = yylex()) < 0) yychar = 0;
 239 #if YYDEBUG
 240             if (yydebug)
 241             {
 242                 yys = 0;
 243                 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 244                 if (!yys) yys = "illegal-symbol";
 245                 printf("%sdebug: state %d, reading %d (%s)\n",
 246                         YYPREFIX, YYFINAL, yychar, yys);
 247             }
 248 #endif
 249         }
 250         if (yychar == 0) goto yyaccept;
 251         goto yyloop;
 252     }
 253     if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
 254             yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
 255         yystate = yytable[yyn];
 256     else
 257         yystate = yydgoto[yym];
 258 #if YYDEBUG
 259     if (yydebug)
 260         printf("%sdebug: after reduction, shifting from state %d \
 261 to state %d\n", YYPREFIX, *yyssp, yystate);
 262 #endif
 263     if (yyssp >= yyss + yystacksize - 1)
 264     {
 265         goto yyoverflow;
 266     }
 267     *++yyssp = yystate;
 268     *++yyvsp = yyval;
 269     goto yyloop;
 270 yyoverflow:
 271     yyerror("yacc stack overflow");
 272 yyabort:
 273     return (1);
 274 yyaccept:
 275     return (0);
 276 }