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