source4/heimdal/lib/hx509/sel-gram.c

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