bool func_ift(cell_t **cp, type_rep_t t) {
cell_t *c = clear_ptr(*cp, 3);
alt_set_t alt_set = 0;
if(!reduce_arg(c, 0, &alt_set, T_INT)) goto fail;
clear_flags(c);
if(c->arg[0]->val[0] > 1) goto fail;
if(is_var(c->arg[0])) {
drop(c->arg[0]); // need to add assertions
cell_t *res = id(c->arg[1]);
res->alt = id(c->arg[2]);
store_lazy(cp, c, res); // ***
} else if(c->arg[0]->val[0]) {
drop(c->arg[0]);
drop(c->arg[2]);
store_lazy(cp, c, c->arg[1]);
} else {
drop(c->arg[0]);
drop(c->arg[1]);
store_lazy(cp, c, c->arg[2]);
}
return false;
fail:
fail(cp);
return false;
}
bool reduce_args(unsigned sz, expr*const* as, expr_ref_vector& result) {
expr_ref tmp(m);
for (unsigned i = 0; i < sz; ++i) {
if (!reduce_arg(as[i], tmp)) return false;
result.push_back(tmp);
}
return true;
}
bool func_compose(cell_t **cp, type_rep_t t) {
cell_t *const c = clear_ptr(*cp, 3);
alt_set_t alt_set = 0;
if(!(reduce_arg(c, 0, &alt_set, T_LIST) &&
reduce_arg(c, 1, &alt_set, T_LIST))) goto fail;
clear_flags(c);
cell_t *res = compose_nd(ref(c->arg[0]), ref(c->arg[1]));
res->alt_set = alt_set_ref(alt_set);
drop(res->alt);
res->alt = c->alt;
store_reduced(cp, res);
return true;
fail:
fail(cp);
return false;
}
bool func_quote(cell_t **cp, type_rep_t t) {
cell_t *c = clear_ptr(*cp, 3);
cell_t res = { .size = 2, .ptr = {ref(c->arg[0])} };
store_reduced(cp, &res);
return true;
}
cell_t *build_quote(cell_t *x) {
return build11(func_quote, x);
}
bool func_popr(cell_t **cp, type_rep_t t) {
cell_t *c = clear_ptr(*cp, 3);
cell_t *d = c->arg[1];
alt_set_t alt_set = 0;
if(!reduce_arg(c, 0, &alt_set, T_LIST)) goto fail;
clear_flags(c);
cell_t *p = c->arg[0];
if(list_size(p) == 0) goto fail;
if(is_placeholder(p->ptr[0])) {
++p->size;
cell_t *h = expand_inplace_dep(p->ptr[0], 1); // *** no shift here
p->ptr[0] = h->arg[closure_in(h)] = dep(ref(h));
p->ptr[1] = h;
}
if(d) {
drop(c);
d->func = func_id;
d->arg[0] = ref(p->ptr[0]);
d->arg[1] = (cell_t *)alt_set_ref(alt_set);
c->arg[1] = p->ptr[0];
}
/* drop the right list element */
cell_t *res = closure_alloc(closure_args(p)-1);
int elems = list_size(res);
res->type = T_LIST;
int i;
for(i = 0; i < elems; ++i)
res->ptr[i] = ref(p->ptr[i+1]);
res->alt_set = alt_set_ref(alt_set);
res->alt = c->alt;
store_reduced(cp, res);
return true;
fail:
if(d) {
drop(c);
store_fail(d, d->alt);
}
c->arg[1] = 0;
fail(cp);
return false;
}
br_status reduce_app(func_decl * f, unsigned num, expr * const * args, expr_ref & result, proof_ref & result_pr) {
expr_ref a0(m), a1(m);
expr_ref_vector _args(m);
if (m.is_eq(f) && reduce_arg(args[0], a0) && reduce_arg(args[1], a1)) {
result = m.mk_eq(a0, a1);
return BR_DONE;
}
else if (m.is_distinct(f) && reduce_args(num, args, _args)) {
result = m.mk_distinct(_args.size(), _args.c_ptr());
return BR_DONE;
}
else if (m_dt.is_recognizer(f) && reduce_arg(args[0], a0)) {
unsigned idx = m_dt.get_recognizer_constructor_idx(f);
a1 = m_bv.mk_numeral(rational(idx), get_sort(a0));
result = m.mk_eq(a0, a1);
return BR_DONE;
}
else {
check_for_fd(num, args);
return BR_FAILED;
}
}
/* should probably cut them, or hide select */
bool func_select(cell_t **cp, type_rep_t t) {
cell_t *c = *cp;
cell_t *p;
alt_set_t alt_set = 0;
if(reduce_arg(c, 0, &alt_set, t)) {
clear_flags(c);
p = c->arg[0];
} else if(reduce_arg(c, 1, &alt_set, t)) {
clear_flags(c);
drop(c->arg[0]);
p = c->arg[1];
c->func = func_id;
c->size = 1;
c->arg[0] = p;
} else goto fail;
store_reduced(cp, ref(p));
return true;
fail:
fail(cp);
return false;
}
bool func_op2(cell_t **cp, type_rep_t t, intptr_t (*op)(intptr_t, intptr_t)) {
cell_t *res = 0;
cell_t *const c = clear_ptr(*cp, 3);
alt_set_t alt_set = 0;
if(t == T_ANY || t == T_INT) t = T_INT;
else goto fail;
if(!reduce_arg(c, 0, &alt_set, t) ||
!reduce_arg(c, 1, &alt_set, t)) goto fail;
clear_flags(c);
cell_t *p = c->arg[0], *q = c->arg[1];
res = is_var(p) || is_var(q) ? var(t) : _op2(op, p, q);
res->alt = c->alt;
res->alt_set = alt_set_ref(alt_set);
store_reduced(cp, res);
return true;
fail:
drop(res);
fail(cp);
return false;
}
bool func_assert(cell_t **cp, type_rep_t t) {
cell_t *c = clear_ptr(*cp, 3);
alt_set_t alt_set = 0;
if(!reduce_arg(c, 1, &alt_set, T_INT)) goto fail;
clear_flags(c);
cell_t *p = c->arg[1];
if(!(is_var(p) || p->val[0])) goto fail;
c->func = func_id;
c->size = 1;
c->arg[1] = (cell_t *)alt_set_ref(alt_set);
drop(p);
return false;
fail:
fail(cp);
return false;
}
bool func_cut(cell_t **cp, type_rep_t t) {
cell_t *c = *cp;
alt_set_t alt_set = 0;
if(!reduce_arg(c, 0, &alt_set, t)) goto fail;
clear_flags(c);
cell_t *p = c->arg[0];
bool v = is_var(p);
cell_t *alt = p->alt;
p->alt = 0;
store_reduced(cp, ref(p));
if(v) trace_expand_select(c, alt, t);
drop(alt);
return true;
fail:
fail(cp);
return false;
}
bool func_pushl(cell_t **cp, type_rep_t t) {
cell_t *c = clear_ptr(*cp, 3);
alt_set_t alt_set = 0;
if(!reduce_arg(c, 1, &alt_set, T_LIST)) goto fail;
clear_flags(c);
cell_t *q = c->arg[1];
bool rvar = is_var(q);
cell_t *res = pushl_nd(ref(c->arg[0]), ref(q));
if(rvar) res->type |= T_VAR;
drop(res->alt);
res->alt = c->alt;
res->alt_set = alt_set_ref(alt_set);
store_reduced(cp, res);
return true;
fail:
fail(cp);
return false;
}
/*
bool type_check(cell_t **cp, type_t type) {
cell_t *c = clear_ptr(*cp, 3);
if(!reduce(&c->arg[0], type)) goto fail;
c->alt = closure_split1(c, 0);
cell_t *p = get(c->arg[0]);
if(!((p->type == type) ||
is_var(p))) goto fail;
store_reduced(c, mod_alt(c->arg[0], c->alt,
c->arg[0]->alt_set));
return true;
fail:
fail(cp);
return false;
}
*/
bool func_id(cell_t **cp, type_rep_t t) {
cell_t *c = clear_ptr(*cp, 3);
alt_set_t alt_set = (alt_set_t)c->arg[1];
if(alt_set || c->alt) {
if(!reduce_arg(c, 0, &alt_set, t)) goto fail;
clear_flags(c);
cell_t *p = c->arg[0];
if(p->alt) alt_set_ref(alt_set);
store_reduced(cp, mod_alt(ref(p), c->alt, alt_set));
alt_set_drop(alt_set);
return true;
} else {
cell_t *p = ref(c->arg[0]);
drop(c);
*cp = p;
return false;
}
fail:
fail(cp);
return false;
}
bool func_pushr(cell_t **cp, type_rep_t t) {
cell_t *c = clear_ptr(*cp, 3);
alt_set_t alt_set = 0;
if(!reduce_arg(c, 0, &alt_set, T_LIST)) goto fail;
clear_flags(c);
cell_t *p = c->arg[0];
int n = list_size(p);
cell_t *res = expand(ref(p), 1);
memmove(res->ptr+1, res->ptr, sizeof(cell_t *)*n);
res->ptr[0] = ref(c->arg[1]);
res->alt_set = alt_set_ref(alt_set);
drop(res->alt);
res->alt = c->alt;
store_reduced(cp, res);
return true;
fail:
fail(cp);
return false;
}
