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