static int scan_number(Token *tok, Tokenizer *tokz, int c)
{
NPNum num=NUM_INIT;
int e;
if((e=parse_number(&num, tokz, c)))
return e;
if(num.type==NPNUM_INT){
long l;
if((e=num_to_long(&l, &num, TRUE)))
return e;
TOK_SET_LONG(tok, l);
}else if(num.type==NPNUM_FLOAT){
double d;
if((e=num_to_double(&d, &num)))
return e;
TOK_SET_DOUBLE(tok, d);
}else{
return E_TOKZ_NUMFMT;
}
return 0;
}
static int
reduce(struct cparse_params *v, long act)
{
VALUE code;
v->ruleno = -act * 3;
code = rb_catch("racc_jump", reduce0, v->value_v);
v->errstatus = num_to_long(rb_ivar_get(v->parser, id_errstatus));
return NUM2INT(code);
}
static VALUE
reduce0(VALUE val, VALUE data, VALUE self)
{
struct cparse_params *v;
VALUE reduce_to, reduce_len, method_id;
long len;
ID mid;
VALUE tmp, tmp_t = Qundef, tmp_v = Qundef;
long i, k1, k2;
VALUE goto_state;
Data_Get_Struct(data, struct cparse_params, v);
reduce_len = RARRAY_PTR(v->reduce_table)[v->ruleno];
reduce_to = RARRAY_PTR(v->reduce_table)[v->ruleno+1];
method_id = RARRAY_PTR(v->reduce_table)[v->ruleno+2];
len = NUM2LONG(reduce_len);
mid = value_to_id(method_id);
/* call action */
if (len == 0) {
tmp = Qnil;
if (mid != id_noreduce)
tmp_v = rb_ary_new();
if (v->debug)
tmp_t = rb_ary_new();
}
else {
if (mid != id_noreduce) {
tmp_v = GET_TAIL(v->vstack, len);
tmp = RARRAY_PTR(tmp_v)[0];
}
else {
tmp = RARRAY_PTR(v->vstack)[ RARRAY_LEN(v->vstack) - len ];
}
CUT_TAIL(v->vstack, len);
if (v->debug) {
tmp_t = GET_TAIL(v->tstack, len);
CUT_TAIL(v->tstack, len);
}
CUT_TAIL(v->state, len);
}
if (mid != id_noreduce) {
if (v->use_result_var) {
tmp = rb_funcall(v->parser, mid,
3, tmp_v, v->vstack, tmp);
}
else {
tmp = rb_funcall(v->parser, mid,
2, tmp_v, v->vstack);
}
}
/* then push result */
PUSH(v->vstack, tmp);
if (v->debug) {
PUSH(v->tstack, reduce_to);
rb_funcall(v->parser, id_d_reduce,
4, tmp_t, reduce_to, v->tstack, v->vstack);
}
/* calculate transition state */
if (RARRAY_LEN(v->state) == 0)
rb_raise(RaccBug, "state stack unexpectedly empty");
k2 = num_to_long(LAST_I(v->state));
k1 = num_to_long(reduce_to) - v->nt_base;
D_printf("(goto) k1=%ld\n", k1);
D_printf("(goto) k2=%ld\n", k2);
tmp = AREF(v->goto_pointer, k1);
if (NIL_P(tmp)) goto notfound;
i = NUM2LONG(tmp) + k2;
D_printf("(goto) i=%ld\n", i);
if (i < 0) goto notfound;
goto_state = AREF(v->goto_table, i);
if (NIL_P(goto_state)) {
D_puts("(goto) table[i] == nil");
goto notfound;
}
D_printf("(goto) table[i]=%ld (goto_state)\n", NUM2LONG(goto_state));
tmp = AREF(v->goto_check, i);
if (NIL_P(tmp)) {
D_puts("(goto) check[i] == nil");
goto notfound;
}
if (tmp != LONG2NUM(k1)) {
D_puts("(goto) check[i] != table[i]");
goto notfound;
}
D_printf("(goto) check[i]=%ld\n", NUM2LONG(tmp));
D_puts("(goto) found");
transit:
PUSH(v->state, goto_state);
v->curstate = NUM2LONG(goto_state);
return INT2FIX(0);
notfound:
D_puts("(goto) not found: use default");
/* overwrite `goto-state' by default value */
goto_state = AREF(v->goto_default, k1);
goto transit;
}
static void
parse_main(struct cparse_params *v, VALUE tok, VALUE val, int resume)
{
long i; /* table index */
long act; /* action type */
VALUE act_value; /* action type, VALUE version */
int read_next = 1; /* true if we need to read next token */
VALUE tmp;
if (resume)
goto resume;
while (1) {
D_puts("");
D_puts("---- enter new loop ----");
D_puts("");
D_printf("(act) k1=%ld\n", v->curstate);
tmp = AREF(v->action_pointer, v->curstate);
if (NIL_P(tmp)) goto notfound;
D_puts("(act) pointer[k1] ok");
i = NUM2LONG(tmp);
D_printf("read_next=%d\n", read_next);
if (read_next && (v->t != vFINAL_TOKEN)) {
if (v->lex_is_iterator) {
D_puts("resuming...");
if (v->fin) rb_raise(rb_eArgError, "token given after EOF");
v->i = i; /* save i */
return;
resume:
D_puts("resumed");
i = v->i; /* load i */
}
else {
D_puts("next_token");
tmp = rb_funcall(v->parser, id_nexttoken, 0);
extract_user_token(v, tmp, &tok, &val);
}
/* convert token */
v->t = rb_hash_aref(v->token_table, tok);
if (NIL_P(v->t)) {
v->t = vERROR_TOKEN;
}
D_printf("(act) t(k2)=%ld\n", NUM2LONG(v->t));
if (v->debug) {
rb_funcall(v->parser, id_d_read_token,
3, v->t, tok, val);
}
}
read_next = 0;
i += NUM2LONG(v->t);
D_printf("(act) i=%ld\n", i);
if (i < 0) goto notfound;
act_value = AREF(v->action_table, i);
if (NIL_P(act_value)) goto notfound;
act = NUM2LONG(act_value);
D_printf("(act) table[i]=%ld\n", act);
tmp = AREF(v->action_check, i);
if (NIL_P(tmp)) goto notfound;
if (NUM2LONG(tmp) != v->curstate) goto notfound;
D_printf("(act) check[i]=%ld\n", NUM2LONG(tmp));
D_puts("(act) found");
act_fixed:
D_printf("act=%ld\n", act);
goto handle_act;
notfound:
D_puts("(act) not found: use default");
act_value = AREF(v->action_default, v->curstate);
act = NUM2LONG(act_value);
goto act_fixed;
handle_act:
if (act > 0 && act < v->shift_n) {
D_puts("shift");
if (v->errstatus > 0) {
v->errstatus--;
rb_ivar_set(v->parser, id_errstatus, LONG2NUM(v->errstatus));
}
SHIFT(v, act, v->t, val);
read_next = 1;
}
else if (act < 0 && act > -(v->reduce_n)) {
D_puts("reduce");
REDUCE(v, act);
}
else if (act == -(v->reduce_n)) {
goto error;
error_recovered:
; /* goto label requires stmt */
}
else if (act == v->shift_n) {
D_puts("accept");
goto accept;
}
else {
rb_raise(RaccBug, "[Racc Bug] unknown act value %ld", act);
}
if (v->debug) {
rb_funcall(v->parser, id_d_next_state,
2, LONG2NUM(v->curstate), v->state);
}
}
/* not reach */
accept:
if (v->debug) rb_funcall(v->parser, id_d_accept, 0);
v->retval = RARRAY_PTR(v->vstack)[0];
v->fin = CP_FIN_ACCEPT;
return;
error:
D_printf("error detected, status=%ld\n", v->errstatus);
if (v->errstatus == 0) {
v->nerr++;
rb_funcall(v->parser, id_onerror,
3, v->t, val, v->vstack);
}
user_yyerror:
if (v->errstatus == 3) {
if (v->t == vFINAL_TOKEN) {
v->retval = Qfalse;
v->fin = CP_FIN_EOT;
return;
}
read_next = 1;
}
v->errstatus = 3;
rb_ivar_set(v->parser, id_errstatus, LONG2NUM(v->errstatus));
/* check if we can shift/reduce error token */
D_printf("(err) k1=%ld\n", v->curstate);
D_printf("(err) k2=%d (error)\n", ERROR_TOKEN);
while (1) {
tmp = AREF(v->action_pointer, v->curstate);
if (NIL_P(tmp)) goto error_pop;
D_puts("(err) pointer[k1] ok");
i = NUM2LONG(tmp) + ERROR_TOKEN;
D_printf("(err) i=%ld\n", i);
if (i < 0) goto error_pop;
act_value = AREF(v->action_table, i);
if (NIL_P(act_value)) {
D_puts("(err) table[i] == nil");
goto error_pop;
}
act = NUM2LONG(act_value);
D_printf("(err) table[i]=%ld\n", act);
tmp = AREF(v->action_check, i);
if (NIL_P(tmp)) {
D_puts("(err) check[i] == nil");
goto error_pop;
}
if (NUM2LONG(tmp) != v->curstate) {
D_puts("(err) check[i] != k1");
goto error_pop;
}
D_puts("(err) found: can handle error token");
break;
error_pop:
D_puts("(err) act not found: can't handle error token; pop");
if (RARRAY_LEN(v->state) <= 1) {
v->retval = Qnil;
v->fin = CP_FIN_CANTPOP;
return;
}
POP(v->state);
POP(v->vstack);
v->curstate = num_to_long(LAST_I(v->state));
if (v->debug) {
POP(v->tstack);
rb_funcall(v->parser, id_d_e_pop,
3, v->state, v->tstack, v->vstack);
}
}
/* shift/reduce error token */
if (act > 0 && act < v->shift_n) {
D_puts("e shift");
SHIFT(v, act, ERROR_TOKEN, val);
}
else if (act < 0 && act > -(v->reduce_n)) {
D_puts("e reduce");
REDUCE(v, act);
}
else if (act == v->shift_n) {
D_puts("e accept");
goto accept;
}
else {
rb_raise(RaccBug, "[Racc Bug] unknown act value %ld", act);
}
goto error_recovered;
}