contrib/byacc/test/code_error.code.c

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