#include <sys/cdefs.h>
#ifndef lint
#if 0
static char sub_expr_gram_sccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93";
#else
__IDSTRING(sub_expr_gram_rcsid, "$NetBSD: skeleton.c,v 1.14 1997/10/20 03:41:16 lukem Exp $");
#endif
#endif
#define sub_expr_gram_BYACC 1
#define sub_expr_gram_MAJOR 1
#define sub_expr_gram_MINOR 9
#define sub_expr_gram_LEX sub_expr_gram_lex()
#define sub_expr_gram_EMPTY -1
#define sub_expr_gram_clearin (sub_expr_gram_char=(sub_expr_gram_EMPTY))
#define sub_expr_gram_errok (sub_expr_gram_errflag=0)
#define sub_expr_gram_RECOVERING (sub_expr_gram_errflag!=0)
#define sub_expr_gram_PREFIX "sub_expr_gram_"
#line 24 "common/sub/expr_gram.y"

#include <common/ac/stdarg.h>
#include <common/ac/stdio.h>
#include <common/ac/stdlib.h>

#include <common/str.h>
#include <common/sub/expr_gram.h>
#include <common/sub/expr_lex.h>
#include <common/sub/private.h>
#include <common/trace.h>

#ifdef DEBUG
#define sub_expr_gram_DEBUG 1
#endif

#line 50 "common/sub/expr_gram.y"
typedef union
{
        long    lv_number;
} sub_expr_gram_STYPE;
#line 62 "common/sub/expr_gram.y"

static long     result;
static sub_context_ty *scp;


string_ty *
sub_expr_gram(sub_context_ty *p, string_ty *s)
{
    int             bad;
    extern int      sub_expr_gram_parse(void);
#ifdef DEBUG
    extern int      sub_expr_gram_debug;
#endif

    trace(("sub_expr_gram()\n{\n"));
    scp = p;
#ifdef DEBUG
    sub_expr_gram_debug = trace_pretest_;
#endif
    sub_expr_lex_open(s);
    bad = sub_expr_gram_parse();
    sub_expr_lex_close();
    trace(("bad = %d\n", bad));

    scp = 0;
    trace(("}\n"));
    if (bad)
        return 0;
    return str_format("%ld", result);
}


static void
sub_expr_gram_error(char *s)
{
    trace(("sub_expr_gram_error(\"%s\")\n{\n", s));
    sub_context_error_set(scp, s);
    trace(("}\n"));
}

#ifdef DEBUG

/*
 * jiggery-pokery for yacc
 *
 *      Replace all calls to printf with a call to trace_printf.  The
 *      trace_where_ is needed to set the location, and is safe, because
 *      yacc only invokes the printf with an if (be careful, the printf
 *      is not in a compound statement).
 */
#define printf trace_where_, trace_printf

/*
 * jiggery-pokery for bison
 *
 *      Replace all calls to fprintf with a call to sub_expr_gram_debugger.  Ignore
 *      the first argument, it will be ``stderr''.  The trace_where_ is
 *      needed to set the location, and is safe, because bison only
 *      invokes the printf with an if (be careful, the fprintf is not in
 *      a compound statement).
 */
#define fprintf trace_where_, sub_expr_gram_debugger

void
sub_expr_gram_debugger(void *junk, char *fmt, ...)
{
    va_list         ap;
    string_ty       *s;

    va_start(ap, fmt);
    s = str_vformat(fmt, ap);
    va_end(ap);
    trace_printf("%s", s->str_text);
    str_free(s);
}

#endif

#line 120 "y.tab.c"
#define DIV 257
#define JUNK 258
#define LP 259
#define MINUS 260
#define MUL 261
#define NUMBER 262
#define PLUS 263
#define RP 264
#define UNARY 265
#define sub_expr_gram_ERRCODE 256
short sub_expr_gram_lhs[] = {                                        -1,
    0,    1,    1,    1,    1,    1,    1,    1,
};
short sub_expr_gram_len[] = {                                         2,
    1,    3,    1,    2,    3,    3,    3,    3,
};
short sub_expr_gram_defred[] = {                                      0,
    0,    0,    3,    0,    0,    0,    4,    0,    0,    0,
    0,    2,    8,    0,    7,    0,
};
short sub_expr_gram_dgoto[] = {                                       4,
    5,
};
short sub_expr_gram_sindex[] = {                                   -236,
 -236, -236,    0,    0, -241, -253,    0, -236, -236, -236,
 -236,    0,    0, -240,    0, -240,
};
short sub_expr_gram_rindex[] = {                                      0,
    0,    0,    0,    0,    2,    0,    0,    0,    0,    0,
    0,    0,    0,    1,    0,    3,
};
short sub_expr_gram_gindex[] = {                                      0,
    4,
};
#define sub_expr_gram_TABLESIZE 267
short sub_expr_gram_table[] = {                                       0,
    6,    1,    5,    8,    6,    7,    9,   10,    0,   11,
   12,   13,   14,   15,   16,    8,    8,    0,    9,   10,
   10,   11,    1,    2,    0,    3,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    6,    0,    5,    6,    6,    5,    5,
};
short sub_expr_gram_check[] = {                                      -1,
    0,    0,    0,  257,    1,    2,  260,  261,   -1,  263,
  264,    8,    9,   10,   11,  257,  257,   -1,  260,  261,
  261,  263,  259,  260,   -1,  262,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  260,   -1,  260,  263,  264,  263,  264,
};
#define sub_expr_gram_FINAL 4
#ifndef sub_expr_gram_DEBUG
#define sub_expr_gram_DEBUG 0
#endif
#define sub_expr_gram_MAXTOKEN 265
#if sub_expr_gram_DEBUG
char *sub_expr_gram_name[] = {
"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,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"DIV","JUNK","LP","MINUS","MUL",
"NUMBER","PLUS","RP","UNARY",
};
char *sub_expr_gram_rule[] = {
"$accept : grammar",
"grammar : expr",
"expr : LP expr RP",
"expr : NUMBER",
"expr : MINUS expr",
"expr : expr PLUS expr",
"expr : expr MINUS expr",
"expr : expr MUL expr",
"expr : expr DIV expr",
};
#endif
#ifdef sub_expr_gram_STACKSIZE
#undef sub_expr_gram_MAXDEPTH
#define sub_expr_gram_MAXDEPTH sub_expr_gram_STACKSIZE
#else
#ifdef sub_expr_gram_MAXDEPTH
#define sub_expr_gram_STACKSIZE sub_expr_gram_MAXDEPTH
#else
#define sub_expr_gram_STACKSIZE 10000
#define sub_expr_gram_MAXDEPTH 10000
#endif
#endif
#define sub_expr_gram_INITSTACKSIZE 200
int sub_expr_gram_debug;
int sub_expr_gram_nerrs;
int sub_expr_gram_errflag;
int sub_expr_gram_char;
short *sub_expr_gram_ssp;
sub_expr_gram_STYPE *sub_expr_gram_vsp;
sub_expr_gram_STYPE sub_expr_gram_val;
sub_expr_gram_STYPE sub_expr_gram_lval;
short *sub_expr_gram_ss;
short *sub_expr_gram_sslim;
sub_expr_gram_STYPE *sub_expr_gram_vs;
int sub_expr_gram_stacksize;
/* allocate initial stack or double stack size, up to sub_expr_gram_MAXDEPTH */
int sub_expr_gram_parse __P((void));
static int sub_expr_gram_growstack __P((void));
static int sub_expr_gram_growstack()
{
    int newsize, i;
    short *newss;
    sub_expr_gram_STYPE *newvs;

    if ((newsize = sub_expr_gram_stacksize) == 0)
        newsize = sub_expr_gram_INITSTACKSIZE;
    else if (newsize >= sub_expr_gram_MAXDEPTH)
        return -1;
    else if ((newsize *= 2) > sub_expr_gram_MAXDEPTH)
        newsize = sub_expr_gram_MAXDEPTH;
    i = sub_expr_gram_ssp - sub_expr_gram_ss;
    if ((newss = (short *)realloc(sub_expr_gram_ss, newsize * sizeof *newss)) == NULL)
        return -1;
    sub_expr_gram_ss = newss;
    sub_expr_gram_ssp = newss + i;
    if ((newvs = (sub_expr_gram_STYPE *)realloc(sub_expr_gram_vs, newsize * sizeof *newvs)) == NULL)
        return -1;
    sub_expr_gram_vs = newvs;
    sub_expr_gram_vsp = newvs + i;
    sub_expr_gram_stacksize = newsize;
    sub_expr_gram_sslim = sub_expr_gram_ss + newsize - 1;
    return 0;
}

#define sub_expr_gram_ABORT goto sub_expr_gram_abort
#define sub_expr_gram_REJECT goto sub_expr_gram_abort
#define sub_expr_gram_ACCEPT goto sub_expr_gram_accept
#define sub_expr_gram_ERROR goto sub_expr_gram_errlab
int
sub_expr_gram_parse()
{
    int sub_expr_gram_m, sub_expr_gram_n, sub_expr_gram_state;
#if sub_expr_gram_DEBUG
    char *sub_expr_gram_s;

    if ((sub_expr_gram_s = getenv("sub_expr_gram_DEBUG")) != NULL)
    {
        sub_expr_gram_n = *sub_expr_gram_s;
        if (sub_expr_gram_n >= '0' && sub_expr_gram_n <= '9')
            sub_expr_gram_debug = sub_expr_gram_n - '0';
    }
#endif

    sub_expr_gram_nerrs = 0;
    sub_expr_gram_errflag = 0;
    sub_expr_gram_char = (-1);

    if (sub_expr_gram_ss == NULL && sub_expr_gram_growstack()) goto sub_expr_gram_overflow;
    sub_expr_gram_ssp = sub_expr_gram_ss;
    sub_expr_gram_vsp = sub_expr_gram_vs;
    *sub_expr_gram_ssp = sub_expr_gram_state = 0;

sub_expr_gram_loop:
    if ((sub_expr_gram_n = sub_expr_gram_defred[sub_expr_gram_state]) != 0) goto sub_expr_gram_reduce;
    if (sub_expr_gram_char < 0)
    {
        if ((sub_expr_gram_char = sub_expr_gram_lex()) < 0) sub_expr_gram_char = 0;
#if sub_expr_gram_DEBUG
        if (sub_expr_gram_debug)
        {
            sub_expr_gram_s = 0;
            if (sub_expr_gram_char <= sub_expr_gram_MAXTOKEN) sub_expr_gram_s = sub_expr_gram_name[sub_expr_gram_char];
            if (!sub_expr_gram_s) sub_expr_gram_s = "illegal-symbol";
            printf("%sdebug: state %d, reading %d (%s)\n",
                    sub_expr_gram_PREFIX, sub_expr_gram_state, sub_expr_gram_char, sub_expr_gram_s);
        }
#endif
    }
    if ((sub_expr_gram_n = sub_expr_gram_sindex[sub_expr_gram_state]) && (sub_expr_gram_n += sub_expr_gram_char) >= 0 &&
            sub_expr_gram_n <= sub_expr_gram_TABLESIZE && sub_expr_gram_check[sub_expr_gram_n] == sub_expr_gram_char)
    {
#if sub_expr_gram_DEBUG
        if (sub_expr_gram_debug)
            printf("%sdebug: state %d, shifting to state %d\n",
                    sub_expr_gram_PREFIX, sub_expr_gram_state, sub_expr_gram_table[sub_expr_gram_n]);
#endif
        if (sub_expr_gram_ssp >= sub_expr_gram_sslim && sub_expr_gram_growstack())
        {
            goto sub_expr_gram_overflow;
        }
        *++sub_expr_gram_ssp = sub_expr_gram_state = sub_expr_gram_table[sub_expr_gram_n];
        *++sub_expr_gram_vsp = sub_expr_gram_lval;
        sub_expr_gram_char = (-1);
        if (sub_expr_gram_errflag > 0)  --sub_expr_gram_errflag;
        goto sub_expr_gram_loop;
    }
    if ((sub_expr_gram_n = sub_expr_gram_rindex[sub_expr_gram_state]) && (sub_expr_gram_n += sub_expr_gram_char) >= 0 &&
            sub_expr_gram_n <= sub_expr_gram_TABLESIZE && sub_expr_gram_check[sub_expr_gram_n] == sub_expr_gram_char)
    {
        sub_expr_gram_n = sub_expr_gram_table[sub_expr_gram_n];
        goto sub_expr_gram_reduce;
    }
    if (sub_expr_gram_errflag) goto sub_expr_gram_inrecovery;
    goto sub_expr_gram_newerror;
sub_expr_gram_newerror:
    sub_expr_gram_error("syntax error");
    goto sub_expr_gram_errlab;
sub_expr_gram_errlab:
    ++sub_expr_gram_nerrs;
sub_expr_gram_inrecovery:
    if (sub_expr_gram_errflag < 3)
    {
        sub_expr_gram_errflag = 3;
        for (;;)
        {
            if ((sub_expr_gram_n = sub_expr_gram_sindex[*sub_expr_gram_ssp]) && (sub_expr_gram_n += sub_expr_gram_ERRCODE) >= 0 &&
                    sub_expr_gram_n <= sub_expr_gram_TABLESIZE && sub_expr_gram_check[sub_expr_gram_n] == sub_expr_gram_ERRCODE)
            {
#if sub_expr_gram_DEBUG
                if (sub_expr_gram_debug)
                    printf("%sdebug: state %d, error recovery shifting\
 to state %d\n", sub_expr_gram_PREFIX, *sub_expr_gram_ssp, sub_expr_gram_table[sub_expr_gram_n]);
#endif
                if (sub_expr_gram_ssp >= sub_expr_gram_sslim && sub_expr_gram_growstack())
                {
                    goto sub_expr_gram_overflow;
                }
                *++sub_expr_gram_ssp = sub_expr_gram_state = sub_expr_gram_table[sub_expr_gram_n];
                *++sub_expr_gram_vsp = sub_expr_gram_lval;
                goto sub_expr_gram_loop;
            }
            else
            {
#if sub_expr_gram_DEBUG
                if (sub_expr_gram_debug)
                    printf("%sdebug: error recovery discarding state %d\n",
                            sub_expr_gram_PREFIX, *sub_expr_gram_ssp);
#endif
                if (sub_expr_gram_ssp <= sub_expr_gram_ss) goto sub_expr_gram_abort;
                --sub_expr_gram_ssp;
                --sub_expr_gram_vsp;
            }
        }
    }
    else
    {
        if (sub_expr_gram_char == 0) goto sub_expr_gram_abort;
#if sub_expr_gram_DEBUG
        if (sub_expr_gram_debug)
        {
            sub_expr_gram_s = 0;
            if (sub_expr_gram_char <= sub_expr_gram_MAXTOKEN) sub_expr_gram_s = sub_expr_gram_name[sub_expr_gram_char];
            if (!sub_expr_gram_s) sub_expr_gram_s = "illegal-symbol";
            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
                    sub_expr_gram_PREFIX, sub_expr_gram_state, sub_expr_gram_char, sub_expr_gram_s);
        }
#endif
        sub_expr_gram_char = (-1);
        goto sub_expr_gram_loop;
    }
sub_expr_gram_reduce:
#if sub_expr_gram_DEBUG
    if (sub_expr_gram_debug)
        printf("%sdebug: state %d, reducing by rule %d (%s)\n",
                sub_expr_gram_PREFIX, sub_expr_gram_state, sub_expr_gram_n, sub_expr_gram_rule[sub_expr_gram_n]);
#endif
    sub_expr_gram_m = sub_expr_gram_len[sub_expr_gram_n];
    sub_expr_gram_val = sub_expr_gram_vsp[1-sub_expr_gram_m];
    switch (sub_expr_gram_n)
    {
case 1:
#line 146 "common/sub/expr_gram.y"
{ result = sub_expr_gram_vsp[0].lv_number; }
break;
case 2:
#line 151 "common/sub/expr_gram.y"
{ sub_expr_gram_val.lv_number = sub_expr_gram_vsp[-1].lv_number; trace(("$$ = %ld;\n", sub_expr_gram_val.lv_number)); }
break;
case 3:
#line 153 "common/sub/expr_gram.y"
{ sub_expr_gram_val.lv_number = sub_expr_gram_vsp[0].lv_number; trace(("$$ = %ld;\n", sub_expr_gram_val.lv_number)); }
break;
case 4:
#line 156 "common/sub/expr_gram.y"
{ sub_expr_gram_val.lv_number = -sub_expr_gram_vsp[0].lv_number; trace(("$$ = %ld;\n", sub_expr_gram_val.lv_number)); }
break;
case 5:
#line 158 "common/sub/expr_gram.y"
{ sub_expr_gram_val.lv_number = sub_expr_gram_vsp[-2].lv_number + sub_expr_gram_vsp[0].lv_number; trace(("$$ = %ld;\n", sub_expr_gram_val.lv_number)); }
break;
case 6:
#line 160 "common/sub/expr_gram.y"
{ sub_expr_gram_val.lv_number = sub_expr_gram_vsp[-2].lv_number - sub_expr_gram_vsp[0].lv_number; trace(("$$ = %ld;\n", sub_expr_gram_val.lv_number)); }
break;
case 7:
#line 162 "common/sub/expr_gram.y"
{ sub_expr_gram_val.lv_number = sub_expr_gram_vsp[-2].lv_number * sub_expr_gram_vsp[0].lv_number; trace(("$$ = %ld;\n", sub_expr_gram_val.lv_number)); }
break;
case 8:
#line 164 "common/sub/expr_gram.y"
{ sub_expr_gram_val.lv_number = sub_expr_gram_vsp[0].lv_number ? sub_expr_gram_vsp[-2].lv_number / sub_expr_gram_vsp[0].lv_number : 0; trace(("$$ = %ld;\n", sub_expr_gram_val.lv_number)); }
break;
#line 463 "y.tab.c"
    }
    sub_expr_gram_ssp -= sub_expr_gram_m;
    sub_expr_gram_state = *sub_expr_gram_ssp;
    sub_expr_gram_vsp -= sub_expr_gram_m;
    sub_expr_gram_m = sub_expr_gram_lhs[sub_expr_gram_n];
    if (sub_expr_gram_state == 0 && sub_expr_gram_m == 0)
    {
#if sub_expr_gram_DEBUG
        if (sub_expr_gram_debug)
            printf("%sdebug: after reduction, shifting from state 0 to\
 state %d\n", sub_expr_gram_PREFIX, sub_expr_gram_FINAL);
#endif
        sub_expr_gram_state = sub_expr_gram_FINAL;
        *++sub_expr_gram_ssp = sub_expr_gram_FINAL;
        *++sub_expr_gram_vsp = sub_expr_gram_val;
        if (sub_expr_gram_char < 0)
        {
            if ((sub_expr_gram_char = sub_expr_gram_lex()) < 0) sub_expr_gram_char = 0;
#if sub_expr_gram_DEBUG
            if (sub_expr_gram_debug)
            {
                sub_expr_gram_s = 0;
                if (sub_expr_gram_char <= sub_expr_gram_MAXTOKEN) sub_expr_gram_s = sub_expr_gram_name[sub_expr_gram_char];
                if (!sub_expr_gram_s) sub_expr_gram_s = "illegal-symbol";
                printf("%sdebug: state %d, reading %d (%s)\n",
                        sub_expr_gram_PREFIX, sub_expr_gram_FINAL, sub_expr_gram_char, sub_expr_gram_s);
            }
#endif
        }
        if (sub_expr_gram_char == 0) goto sub_expr_gram_accept;
        goto sub_expr_gram_loop;
    }
    if ((sub_expr_gram_n = sub_expr_gram_gindex[sub_expr_gram_m]) && (sub_expr_gram_n += sub_expr_gram_state) >= 0 &&
            sub_expr_gram_n <= sub_expr_gram_TABLESIZE && sub_expr_gram_check[sub_expr_gram_n] == sub_expr_gram_state)
        sub_expr_gram_state = sub_expr_gram_table[sub_expr_gram_n];
    else
        sub_expr_gram_state = sub_expr_gram_dgoto[sub_expr_gram_m];
#if sub_expr_gram_DEBUG
    if (sub_expr_gram_debug)
        printf("%sdebug: after reduction, shifting from state %d \
to state %d\n", sub_expr_gram_PREFIX, *sub_expr_gram_ssp, sub_expr_gram_state);
#endif
    if (sub_expr_gram_ssp >= sub_expr_gram_sslim && sub_expr_gram_growstack())
    {
        goto sub_expr_gram_overflow;
    }
    *++sub_expr_gram_ssp = sub_expr_gram_state;
    *++sub_expr_gram_vsp = sub_expr_gram_val;
    goto sub_expr_gram_loop;
sub_expr_gram_overflow:
    sub_expr_gram_error("yacc stack overflow");
sub_expr_gram_abort:
    return (1);
sub_expr_gram_accept:
    return (0);
}