external/bsd/byacc/dist/test/code_error.code.c

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