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