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

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