tools/regression/usr.bin/yacc/regress.03.out

   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 #define YYPATCH 20140101
   9
  10 #define YYEMPTY        (-1)
  11 #define yyclearin      (yychar = YYEMPTY)
  12 #define yyerrok        (yyerrflag = 0)
  13 #define YYRECOVERING() (yyerrflag != 0)
  14
  15 #define YYPREFIX "yy"
  16
  17 #define YYPURE 1
  18
  19 #line 9 "calc3.y"
  20 # include <stdio.h>
  21 # include <ctype.h>
  22
  23 #ifdef YYBISON
  24 #define YYSTYPE int
  25 #define YYLEX_PARAM base
  26 #define YYLEX_DECL() yylex(YYSTYPE *yylval, int *YYLEX_PARAM)
  27 #define YYERROR_DECL() yyerror(int regs[26], int *base, const char *s)
  28 int YYLEX_DECL();
  29 static void YYERROR_DECL();
  30 #endif
  31
  32 #line 32 "/dev/stdout"
  33
  34 #ifndef YYSTYPE
  35 typedef int YYSTYPE;
  36 #endif
  37
  38 /* compatibility with bison */
  39 #ifdef YYPARSE_PARAM
  40 /* compatibility with FreeBSD */
  41 # ifdef YYPARSE_PARAM_TYPE
  42 #  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
  43 # else
  44 #  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
  45 # endif
  46 #else
  47 # define YYPARSE_DECL() yyparse(int  regs[26], int * base)
  48 #endif
  49
  50 /* Parameters sent to lex. */
  51 #ifdef YYLEX_PARAM
  52 # ifdef YYLEX_PARAM_TYPE
  53 #  define YYLEX_DECL() yylex(YYSTYPE *yylval, YYLEX_PARAM_TYPE YYLEX_PARAM)
  54 # else
  55 #  define YYLEX_DECL() yylex(YYSTYPE *yylval, void * YYLEX_PARAM)
  56 # endif
  57 # define YYLEX yylex(&yylval, YYLEX_PARAM)
  58 #else
  59 # define YYLEX_DECL() yylex(YYSTYPE *yylval, int * base)
  60 # define YYLEX yylex(&yylval, base)
  61 #endif
  62
  63 /* Parameters sent to yyerror. */
  64 #ifndef YYERROR_DECL
  65 #define YYERROR_DECL() yyerror(int  regs[26], int * base, const char *s)
  66 #endif
  67 #ifndef YYERROR_CALL
  68 #define YYERROR_CALL(msg) yyerror(regs, base, msg)
  69 #endif
  70
  71 extern int YYPARSE_DECL();
  72
  73 #define DIGIT 257
  74 #define LETTER 258
  75 #define UMINUS 259
  76 #define YYERRCODE 256
  77 static const short yylhs[] = {                           -1,
  78     0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
  79     2,    2,    2,    2,    2,    2,    3,    3,
  80 };
  81 static const short yylen[] = {                            2,
  82     0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
  83     3,    3,    3,    2,    1,    1,    1,    2,
  84 };
  85 static const short yydefred[] = {                         1,
  86     0,    0,   17,    0,    0,    0,    0,    0,    0,    3,
  87     0,   15,   14,    0,    2,    0,    0,    0,    0,    0,
  88     0,    0,   18,    0,    6,    0,    0,    0,    0,    9,
  89    10,   11,
  90 };
  91 static const short yydgoto[] = {                          1,
  92     7,    8,    9,
  93 };
  94 static const short yysindex[] = {                         0,
  95   -40,   -7,    0,  -55,  -38,  -38,    1,  -29, -247,    0,
  96   -38,    0,    0,   22,    0,  -38,  -38,  -38,  -38,  -38,
  97   -38,  -38,    0,  -29,    0,   51,   60,  -20,  -20,    0,
  98     0,    0,
  99 };
 100 static const short yyrindex[] = {                         0,
 101     0,    0,    0,    2,    0,    0,    0,    9,   -9,    0,
 102     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 103     0,    0,    0,   10,    0,   -6,   14,    5,   13,    0,
 104     0,    0,
 105 };
 106 static const short yygindex[] = {                         0,
 107     0,   65,    0,
 108 };
 109 #define YYTABLESIZE 220
 110 static const short yytable[] = {                          6,
 111    16,    6,   10,   13,    5,   11,    5,   22,   17,   23,
 112    15,   15,   20,   18,    7,   19,   22,   21,    4,    5,
 113     0,   20,    8,   12,    0,    0,   21,   16,   16,    0,
 114     0,   16,   16,   16,   13,   16,    0,   16,   15,   15,
 115     0,    0,    7,   15,   15,    7,   15,    7,   15,    7,
 116     8,   12,    0,    8,   12,    8,    0,    8,   22,   17,
 117     0,    0,   25,   20,   18,    0,   19,    0,   21,   13,
 118    14,    0,    0,    0,    0,   24,    0,    0,    0,    0,
 119    26,   27,   28,   29,   30,   31,   32,   22,   17,    0,
 120     0,    0,   20,   18,   16,   19,   22,   21,    0,    0,
 121     0,   20,   18,    0,   19,    0,   21,    0,    0,    0,
 122     0,    0,    0,    0,   16,    0,    0,   13,    0,    0,
 123     0,    0,    0,    0,    0,   15,    0,    0,    7,    0,
 124     0,    0,    0,    0,    0,    0,    8,   12,    0,    0,
 125     0,    0,    0,    0,    0,   16,    0,    0,    0,    0,
 126     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 127     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 128     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 129     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 130     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 131     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 132     0,    0,    0,    0,    0,    2,    3,    4,    3,   12,
 133 };
 134 static const short yycheck[] = {                         40,
 135    10,   40,   10,   10,   45,   61,   45,   37,   38,  257,
 136    10,   10,   42,   43,   10,   45,   37,   47,   10,   10,
 137    -1,   42,   10,   10,   -1,   -1,   47,   37,   38,   -1,
 138    -1,   41,   42,   43,   41,   45,   -1,   47,   37,   38,
 139    -1,   -1,   38,   42,   43,   41,   45,   43,   47,   45,
 140    38,   38,   -1,   41,   41,   43,   -1,   45,   37,   38,
 141    -1,   -1,   41,   42,   43,   -1,   45,   -1,   47,    5,
 142     6,   -1,   -1,   -1,   -1,   11,   -1,   -1,   -1,   -1,
 143    16,   17,   18,   19,   20,   21,   22,   37,   38,   -1,
 144    -1,   -1,   42,   43,  124,   45,   37,   47,   -1,   -1,
 145    -1,   42,   43,   -1,   45,   -1,   47,   -1,   -1,   -1,
 146    -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,   -1,
 147    -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,
 148    -1,   -1,   -1,   -1,   -1,   -1,  124,  124,   -1,   -1,
 149    -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,   -1,   -1,
 150    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 151    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 152    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 153    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 154    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 155    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 156    -1,   -1,   -1,   -1,   -1,  256,  257,  258,  257,  258,
 157 };
 158 #define YYFINAL 1
 159 #ifndef YYDEBUG
 160 #define YYDEBUG 0
 161 #endif
 162 #define YYMAXTOKEN 259
 163 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? (YYMAXTOKEN + 1) : (a))
 164 #if YYDEBUG
 165 static const char *yyname[] = {
 166
 167 "end-of-file",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 168 0,0,0,0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,
 169 0,0,0,0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 170 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,0,0,0,0,0,
 171 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 172 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 173 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 174 0,0,0,0,0,0,"DIGIT","LETTER","UMINUS","illegal-symbol",
 175 };
 176 static const char *yyrule[] = {
 177 "$accept : list",
 178 "list :",
 179 "list : list stat '\\n'",
 180 "list : list error '\\n'",
 181 "stat : expr",
 182 "stat : LETTER '=' expr",
 183 "expr : '(' expr ')'",
 184 "expr : expr '+' expr",
 185 "expr : expr '-' expr",
 186 "expr : expr '*' expr",
 187 "expr : expr '/' expr",
 188 "expr : expr '%' expr",
 189 "expr : expr '&' expr",
 190 "expr : expr '|' expr",
 191 "expr : '-' expr",
 192 "expr : LETTER",
 193 "expr : number",
 194 "number : DIGIT",
 195 "number : number DIGIT",
 196
 197 };
 198 #endif
 199
 200 int      yydebug;
 201 int      yynerrs;
 202
 203 /* define the initial stack-sizes */
 204 #ifdef YYSTACKSIZE
 205 #undef YYMAXDEPTH
 206 #define YYMAXDEPTH  YYSTACKSIZE
 207 #else
 208 #ifdef YYMAXDEPTH
 209 #define YYSTACKSIZE YYMAXDEPTH
 210 #else
 211 #define YYSTACKSIZE 10000
 212 #define YYMAXDEPTH  10000
 213 #endif
 214 #endif
 215
 216 #define YYINITSTACKSIZE 200
 217
 218 typedef struct {
 219     unsigned stacksize;
 220     short    *s_base;
 221     short    *s_mark;
 222     short    *s_last;
 223     YYSTYPE  *l_base;
 224     YYSTYPE  *l_mark;
 225 } YYSTACKDATA;
 226 #line 76 "calc3.y"
 227  /* start of programs */
 228
 229 #ifdef YYBYACC
 230 extern int YYLEX_DECL();
 231 #endif
 232
 233 int
 234 main (void)
 235 {
 236     int regs[26];
 237     int base = 10;
 238
 239     while(!feof(stdin)) {
 240         yyparse(regs, &base);
 241     }
 242     return 0;
 243 }
 244
 245 static void
 246 YYERROR_DECL()
 247 {
 248     fprintf(stderr, "%s\n", s);
 249 }
 250
 251 int
 252 YYLEX_DECL()
 253 {
 254         /* lexical analysis routine */
 255         /* returns LETTER for a lower case letter, yylval = 0 through 25 */
 256         /* return DIGIT for a digit, yylval = 0 through 9 */
 257         /* all other characters are returned immediately */
 258
 259     int c;
 260
 261     while( (c=getchar()) == ' ' )   { /* skip blanks */ }
 262
 263     /* c is now nonblank */
 264
 265     if( islower( c )) {
 266         *yylval = (c - 'a');
 267         return ( LETTER );
 268     }
 269     if( isdigit( c )) {
 270         *yylval = (c - '0') % (*base);
 271         return ( DIGIT );
 272     }
 273     return( c );
 274 }
 275 #line 274 "/dev/stdout"
 276
 277 #if YYDEBUG
 278 #include <stdio.h>              /* needed for printf */
 279 #endif
 280
 281 #include <stdlib.h>     /* needed for malloc, etc */
 282 #include <string.h>     /* needed for memset */
 283
 284 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
 285 static int yygrowstack(YYSTACKDATA *data)
 286 {
 287     int i;
 288     unsigned newsize;
 289     short *newss;
 290     YYSTYPE *newvs;
 291
 292     if ((newsize = data->stacksize) == 0)
 293         newsize = YYINITSTACKSIZE;
 294     else if (newsize >= YYMAXDEPTH)
 295         return -1;
 296     else if ((newsize *= 2) > YYMAXDEPTH)
 297         newsize = YYMAXDEPTH;
 298
 299     i = (int) (data->s_mark - data->s_base);
 300     newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
 301     if (newss == 0)
 302         return -1;
 303
 304     data->s_base = newss;
 305     data->s_mark = newss + i;
 306
 307     newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
 308     if (newvs == 0)
 309         return -1;
 310
 311     data->l_base = newvs;
 312     data->l_mark = newvs + i;
 313
 314     data->stacksize = newsize;
 315     data->s_last = data->s_base + newsize - 1;
 316     return 0;
 317 }
 318
 319 #if YYPURE || defined(YY_NO_LEAKS)
 320 static void yyfreestack(YYSTACKDATA *data)
 321 {
 322     free(data->s_base);
 323     free(data->l_base);
 324     memset(data, 0, sizeof(*data));
 325 }
 326 #else
 327 #define yyfreestack(data) /* nothing */
 328 #endif
 329
 330 #define YYABORT  goto yyabort
 331 #define YYREJECT goto yyabort
 332 #define YYACCEPT goto yyaccept
 333 #define YYERROR  goto yyerrlab
 334
 335 int
 336 YYPARSE_DECL()
 337 {
 338     int      yyerrflag;
 339     int      yychar;
 340     YYSTYPE  yyval;
 341     YYSTYPE  yylval;
 342
 343     /* variables for the parser stack */
 344     YYSTACKDATA yystack;
 345     int yym, yyn, yystate;
 346 #if YYDEBUG
 347     const char *yys;
 348
 349     if ((yys = getenv("YYDEBUG")) != 0)
 350     {
 351         yyn = *yys;
 352         if (yyn >= '0' && yyn <= '9')
 353             yydebug = yyn - '0';
 354     }
 355 #endif
 356
 357     yynerrs = 0;
 358     yyerrflag = 0;
 359     yychar = YYEMPTY;
 360     yystate = 0;
 361
 362 #if YYPURE
 363     memset(&yystack, 0, sizeof(yystack));
 364 #endif
 365
 366     if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
 367     yystack.s_mark = yystack.s_base;
 368     yystack.l_mark = yystack.l_base;
 369     yystate = 0;
 370     *yystack.s_mark = 0;
 371
 372 yyloop:
 373     if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
 374     if (yychar < 0)
 375     {
 376         if ((yychar = YYLEX) < 0) yychar = 0;
 377 #if YYDEBUG
 378         if (yydebug)
 379         {
 380             yys = yyname[YYTRANSLATE(yychar)];
 381             printf("%sdebug: state %d, reading %d (%s)\n",
 382                     YYPREFIX, yystate, yychar, yys);
 383         }
 384 #endif
 385     }
 386     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
 387             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 388     {
 389 #if YYDEBUG
 390         if (yydebug)
 391             printf("%sdebug: state %d, shifting to state %d\n",
 392                     YYPREFIX, yystate, yytable[yyn]);
 393 #endif
 394         if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
 395         {
 396             goto yyoverflow;
 397         }
 398         yystate = yytable[yyn];
 399         *++yystack.s_mark = yytable[yyn];
 400         *++yystack.l_mark = yylval;
 401         yychar = YYEMPTY;
 402         if (yyerrflag > 0)  --yyerrflag;
 403         goto yyloop;
 404     }
 405     if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
 406             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 407     {
 408         yyn = yytable[yyn];
 409         goto yyreduce;
 410     }
 411     if (yyerrflag) goto yyinrecovery;
 412
 413     yyerror(regs, base, "syntax error");
 414
 415     goto yyerrlab;
 416
 417 yyerrlab:
 418     ++yynerrs;
 419
 420 yyinrecovery:
 421     if (yyerrflag < 3)
 422     {
 423         yyerrflag = 3;
 424         for (;;)
 425         {
 426             if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
 427                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
 428             {
 429 #if YYDEBUG
 430                 if (yydebug)
 431                     printf("%sdebug: state %d, error recovery shifting\
 432  to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
 433 #endif
 434                 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
 435                 {
 436                     goto yyoverflow;
 437                 }
 438                 yystate = yytable[yyn];
 439                 *++yystack.s_mark = yytable[yyn];
 440                 *++yystack.l_mark = yylval;
 441                 goto yyloop;
 442             }
 443             else
 444             {
 445 #if YYDEBUG
 446                 if (yydebug)
 447                     printf("%sdebug: error recovery discarding state %d\n",
 448                             YYPREFIX, *yystack.s_mark);
 449 #endif
 450                 if (yystack.s_mark <= yystack.s_base) goto yyabort;
 451                 --yystack.s_mark;
 452                 --yystack.l_mark;
 453             }
 454         }
 455     }
 456     else
 457     {
 458         if (yychar == 0) goto yyabort;
 459 #if YYDEBUG
 460         if (yydebug)
 461         {
 462             yys = yyname[YYTRANSLATE(yychar)];
 463             printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
 464                     YYPREFIX, yystate, yychar, yys);
 465         }
 466 #endif
 467         yychar = YYEMPTY;
 468         goto yyloop;
 469     }
 470
 471 yyreduce:
 472 #if YYDEBUG
 473     if (yydebug)
 474         printf("%sdebug: state %d, reducing by rule %d (%s)\n",
 475                 YYPREFIX, yystate, yyn, yyrule[yyn]);
 476 #endif
 477     yym = yylen[yyn];
 478     if (yym)
 479         yyval = yystack.l_mark[1-yym];
 480     else
 481         memset(&yyval, 0, sizeof yyval);
 482     switch (yyn)
 483     {
 484 case 3:
 485 #line 38 "calc3.y"
 486         {  yyerrok ; }
 487 break;
 488 case 4:
 489 #line 42 "calc3.y"
 490         {  printf("%d\n",yystack.l_mark[0]);}
 491 break;
 492 case 5:
 493 #line 44 "calc3.y"
 494         {  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
 495 break;
 496 case 6:
 497 #line 48 "calc3.y"
 498         {  yyval = yystack.l_mark[-1]; }
 499 break;
 500 case 7:
 501 #line 50 "calc3.y"
 502         {  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
 503 break;
 504 case 8:
 505 #line 52 "calc3.y"
 506         {  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
 507 break;
 508 case 9:
 509 #line 54 "calc3.y"
 510         {  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
 511 break;
 512 case 10:
 513 #line 56 "calc3.y"
 514         {  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
 515 break;
 516 case 11:
 517 #line 58 "calc3.y"
 518         {  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
 519 break;
 520 case 12:
 521 #line 60 "calc3.y"
 522         {  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
 523 break;
 524 case 13:
 525 #line 62 "calc3.y"
 526         {  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
 527 break;
 528 case 14:
 529 #line 64 "calc3.y"
 530         {  yyval = - yystack.l_mark[0]; }
 531 break;
 532 case 15:
 533 #line 66 "calc3.y"
 534         {  yyval = regs[yystack.l_mark[0]]; }
 535 break;
 536 case 17:
 537 #line 71 "calc3.y"
 538         {  yyval = yystack.l_mark[0]; (*base) = (yystack.l_mark[0]==0) ? 8 : 10; }
 539 break;
 540 case 18:
 541 #line 73 "calc3.y"
 542         {  yyval = (*base) * yystack.l_mark[-1] + yystack.l_mark[0]; }
 543 break;
 544 #line 543 "/dev/stdout"
 545     }
 546     yystack.s_mark -= yym;
 547     yystate = *yystack.s_mark;
 548     yystack.l_mark -= yym;
 549     yym = yylhs[yyn];
 550     if (yystate == 0 && yym == 0)
 551     {
 552 #if YYDEBUG
 553         if (yydebug)
 554             printf("%sdebug: after reduction, shifting from state 0 to\
 555  state %d\n", YYPREFIX, YYFINAL);
 556 #endif
 557         yystate = YYFINAL;
 558         *++yystack.s_mark = YYFINAL;
 559         *++yystack.l_mark = yyval;
 560         if (yychar < 0)
 561         {
 562             if ((yychar = YYLEX) < 0) yychar = 0;
 563 #if YYDEBUG
 564             if (yydebug)
 565             {
 566                 yys = yyname[YYTRANSLATE(yychar)];
 567                 printf("%sdebug: state %d, reading %d (%s)\n",
 568                         YYPREFIX, YYFINAL, yychar, yys);
 569             }
 570 #endif
 571         }
 572         if (yychar == 0) goto yyaccept;
 573         goto yyloop;
 574     }
 575     if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
 576             yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
 577         yystate = yytable[yyn];
 578     else
 579         yystate = yydgoto[yym];
 580 #if YYDEBUG
 581     if (yydebug)
 582         printf("%sdebug: after reduction, shifting from state %d \
 583 to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
 584 #endif
 585     if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
 586     {
 587         goto yyoverflow;
 588     }
 589     *++yystack.s_mark = (short) yystate;
 590     *++yystack.l_mark = yyval;
 591     goto yyloop;
 592
 593 yyoverflow:
 594     yyerror(regs, base, "yacc stack overflow");
 595
 596 yyabort:
 597     yyfreestack(&yystack);
 598     return (1);
 599
 600 yyaccept:
 601     yyfreestack(&yystack);
 602     return (0);
 603 }