/*
* Delete the whole thing
*/
void delete_ef_solver(ef_solver_t *solver) {
if (solver->exists_context != NULL) {
delete_context(solver->exists_context);
safe_free(solver->exists_context);
solver->exists_context = NULL;
}
if (solver->forall_context != NULL) {
delete_context(solver->forall_context);
safe_free(solver->forall_context);
solver->forall_context = NULL;
}
if (solver->exists_model != NULL) {
yices_free_model(solver->exists_model);
solver->exists_model = NULL;
}
safe_free(solver->evalue);
safe_free(solver->uvalue);
solver->evalue = NULL;
solver->uvalue = NULL;
if (solver->full_model != NULL) {
yices_free_model(solver->full_model);
solver->full_model = NULL;
}
yices_delete_term_vector(&solver->implicant);
delete_ivector(&solver->evalue_aux);
delete_ivector(&solver->uvalue_aux);
delete_ivector(&solver->all_vars);
delete_ivector(&solver->all_values);
}
/*
* Run a test:
* - show the constraint
* - check feasibility
* - print the result
*/
static void run_test(int_constraint_t *cnstr) {
ivector_t v;
bool feasible;
init_ivector(&v, 10);
printf("Constraint: ");
show_constraint(stdout, cnstr);
show_fixed_vars(stdout, cnstr);
feasible = int_constraint_is_feasible(cnstr, &v);
if (feasible) {
printf("Feasible\n");
} else {
printf("Not feasible\n");
printf("conflict vars: ");
show_varnames(stdout, v.data, v.size);
}
show_constraint_details(stdout, cnstr);
if (feasible) {
test_periods_and_phases(cnstr);
}
fflush(stdout);
delete_ivector(&v);
}
static void check_propagation(test_bench_t *bench) {
equality_queue_t *queue;
ivector_t expl;
uint32_t i, n;
int32_t x, y;
init_ivector(&expl, 10);
queue = &bench->equeue;
n = queue->top;
for (i=0; i<n; i++) {
x = queue->data[i].lhs;
y = queue->data[i].rhs;
if (x >= 0) {
assert(y >= 0);
offset_manager_explain_equality(&bench->manager, x, y, &expl);
check_equality(bench, x, y, &expl);
if (bench->show_details) {
printf("Explanation for x%"PRId32" == x%"PRId32":\n", x, y);
print_poly_def(bench->ptable, x);
print_poly_def(bench->ptable, y);
print_explanation(bench, &expl);
}
ivector_reset(&expl);
}
}
delete_ivector(&expl);
}
/*
* Check that s and c are equal
*/
static void check_equal_sets(bset_t *s, cset_t *c) {
ivector_t aux;
uint32_t i, n;
n = s->card;
for (i=0; i<n; i++) {
if (! cset_member(c, s->data[i])) {
goto bug;
}
}
init_ivector(&aux, 10);
cset_extract(c, &aux);
n = aux.size;
for (i=0; i<n; i++) {
if (! bset_member(s, aux.data[i])) {
goto bug;
}
}
delete_ivector(&aux);
return;
bug:
printf("*** BUG ***\n");
printf(" bset: ");
show_bset(s);
printf("\n");
printf(" cset: ");
show_cset(c);
printf("\n");
printf("should be equal\b");
fflush(stdout);
exit(1);
}
/*
* Test the period/phase computation
*/
static void test_periods_and_phases(int_constraint_t *cnstr) {
ivector_t v;
rational_t *p, *q;
uint32_t i, n;
int32_t x;
init_ivector(&v, 10);
n = int_constraint_num_terms(cnstr);
for (i=0; i<n; i++) {
ivector_reset(&v);
int_constraint_period_of_var(cnstr, i, &v);
x = int_constraint_get_var(cnstr, i);
p = int_constraint_period(cnstr);
q = int_constraint_phase(cnstr);
printf("Variable %s: period = ", var[x].name);
q_print(stdout, p);
printf(", phase = ");
q_print(stdout, q);
printf("\n");
printf(" antecedents: ");
show_varnames(stdout, v.data, v.size);
check_period_and_phase(cnstr, i, p, q);
}
delete_ivector(&v);
}
/*
* Print model, including the aliased terms
* - one line per term
* - if model->has_alias is true, then the value of all terms in
* the alias table is displayed
* - if model->has_alias is false, then this is the same as model_print
*/
void model_pp_full(yices_pp_t *printer, model_t *model) {
evaluator_t eval;
ivector_t v;
term_t *a;
uint32_t n;
if (model->has_alias && model->alias_map != NULL) {
init_evaluator(&eval, model);
// collect all terms that have a value
init_ivector(&v, 0);
model_collect_terms(model, true, model->terms, term_to_print, &v);
n = v.size;
a = v.data;
eval_pp_bool_assignments(printer, &eval, a, n);
eval_pp_arithmetic_assignments(printer, &eval, a, n);
eval_pp_bitvector_assignments(printer, &eval, a, n);
eval_pp_constant_assignments(printer, &eval, a, n);
eval_pp_tuple_assignments(printer, &eval, a, n);
eval_pp_function_assignments(printer, &eval, a, n);
vtbl_pp_queued_functions(printer, &model->vtbl, true);
delete_evaluator(&eval);
delete_ivector(&v);
} else {
model_pp(printer, model);
}
}
/*
* Undo assert_var/keep record poly
* - stop on the top-most 'INCREASE_DLEVEL'
*/
static void op_stack_backtrack(test_bench_t *bench) {
op_stack_t *stack;
ivector_t saved_polys;
uint32_t i;
int32_t id;
stack = &bench->stack;
init_ivector(&saved_polys, 10);
i = stack->top;
for (;;) {
assert(i > 0);
i --;
switch (stack->data[i].tag) {
case RECORD_POLY:
id = stack->data[i].arg.rec_id;
ivector_push(&saved_polys, id);
break;
case ASSERT_EQ: // undo
case PROPAGATE: // undo
break;
case INCREASE_DLEVEL:
goto done;
case PUSH:
default:
assert(false);
break;
}
}
done:
stack->top = i;
if (bench->conflict) {
// check whether the conflict equality has been removed
assert(bench->conflict_eq >= 0);
if (i <= bench->conflict_eq) {
bench->conflict_eq = -1;
bench->conflict = false;
bench->mngr_conflict = false;
printf("---> Conflict resolved\n");
fflush(stdout);
}
}
// redo the record poly operations
i = saved_polys.size;
while (i > 0) {
i --;
id = saved_polys.data[i];
push_record_poly(stack, id);
}
delete_ivector(&saved_polys);
}
static void test_propagate(test_bench_t *bench) {
ivector_t expl;
printf("[%"PRIu32"]: TEST_PROPAGATE: decision level = %"PRIu32", base level = %"PRIu32"\n", ctr, bench->decision_level, bench->base_level);
push_propagate(&bench->stack);
normalize_all(bench);
if (bench->show_details) {
printf("Active polys\n");
print_active_polys(bench);
printf("Assertions\n");
print_all_equalities(bench);
printf("Normal forms\n");
print_normal_forms(bench);
}
if (bench->conflict) {
printf("Expected result: conflict\n\n");
} else {
printf("Expected classes\n");
print_expected_classes(bench);
}
if (offset_manager_propagate(&bench->manager)) {
bench->mngr_conflict = false;
printf("Propagated classes\n");
print_infered_classes(bench);
check_propagation(bench);
check_all_propagated(bench);
if (bench->conflict) {
printf("BUG: conflict expected\n");
fflush(stdout);
exit(1);
}
} else {
bench->mngr_conflict = true;
printf("Conflict\n");
init_ivector(&expl, 10);
offset_manager_explain_conflict(&bench->manager, &expl);
print_explanation(bench, &expl);
check_conflict(bench, &expl);
delete_ivector(&expl);
if (! bench->conflict) {
printf("BUG: conflict unexpected\n");
fflush(stdout);
exit(1);
}
}
ctr ++;
}
/*
* Delete the store
*/
static void delete_type_store(type_store_t *store) {
uint32_t i, n;
n = store->ntypes;
for (i=0; i<n; i++) {
delete_ivector(store->terms + i);
}
safe_free(store->type);
safe_free(store->terms);
store->type = NULL;
store->terms = NULL;
}
/*
* Delete all allocated memory
*/
void delete_epartition_manager(epartition_manager_t *m) {
safe_free(m->label);
safe_free(m->next);
safe_free(m->root);
safe_free(m->subclass);
delete_ivector(&m->buffer);
safe_free(m->empty);
m->label = NULL;
m->next = NULL;
m->root = NULL;
m->subclass = NULL;
m->empty = NULL;
}
static void show_cset(cset_t *c) {
ivector_t aux;
uint32_t i, n;
init_ivector(&aux, 10);
cset_extract(c, &aux);
int_array_sort(aux.data, aux.size);
printf("{");
n = aux.size;
for (i=0; i<n; i++) {
printf(" %"PRIu32, aux.data[i]);
}
printf(" }");
delete_ivector(&aux);
}
/*
* Print the model->map table
*/
void model_pp(yices_pp_t *printer, model_t *model) {
ivector_t v;
term_t *a;
uint32_t n;
init_ivector(&v, 0);
model_collect_terms(model, false, model->terms, term_to_print, &v);
n = v.size;
a = v.data;
model_pp_bool_assignments(printer, model, a, n);
model_pp_arithmetic_assignments(printer, model, a, n);
model_pp_bitvector_assignments(printer, model, a, n);
model_pp_constant_assignments(printer, model, a, n);
model_pp_tuple_assignments(printer, model, a, n);
model_pp_function_assignments(printer, model, a, n);
vtbl_pp_queued_functions(printer, &model->vtbl, true);
delete_ivector(&v);
}
/*
* Get explanation for t1 == t2
*/
static void test_eq_explanation(eterm_t t1, eterm_t t2) {
ivector_t v;
uint32_t i, n;
int32_t x1, x2;
init_ivector(&v, 10);
x1 = var_of_term(t1);
x2 = var_of_term(t2);
offset_manager_explain_equality(&mngr, x1, x2, &v);
printf("---> Explanation:");
n = v.size;
for (i=0; i<n; i++) {
printf(" eq[%"PRId32"]", v.data[i]);
}
printf("\n\n");
delete_ivector(&v);
}
/*
* Delete
*/
void delete_flattener(flattener_t *flat) {
delete_int_queue(&flat->queue);
delete_int_hset(&flat->cache);
delete_ivector(&flat->resu);
}
static int build_instance(char *filename, smt_core_t *core) {
int l, n, c_idx, literal, nvars, nclauses;
char *s;
FILE *f;
ivector_t buffer;
f = fopen(filename, "r");
if (f == NULL) {
perror(filename);
return OPEN_ERROR;
}
s = fgets(line, MAX_LINE, f);
l = 1; /* line number */
if (s == NULL) {
fprintf(stderr, "%s: empty file\n", filename);
fclose(f);
return FORMAT_ERROR;
}
/* skip empty and comment lines */
while (*s == 'c' || *s == '\n') {
s = fgets(line, MAX_LINE, f);
l ++;
if (s == NULL) {
fprintf(stderr, "Format error: file %s, line %d\n", filename, l);
fclose(f);
return FORMAT_ERROR;
}
}
/* read problem size */
n = sscanf(s, "p cnf %d %d", &nvars, &nclauses);
if (n != 2 || nvars < 0 || nclauses < 0) {
fprintf(stderr, "Format error: file %s, line %d\n", filename, l);
fclose(f);
return FORMAT_ERROR;
}
/* initialize core for nvars */
init_sat_solver(core, nvars);
/* initialize the clause buffer */
init_ivector(&buffer, 10);
/* now read the clauses and translate them */
c_idx = 0;
while (c_idx < nclauses) {
for (;;) {
literal = read_literal(f, nvars);
if (literal < 0) break;
ivector_push(&buffer, literal);
}
if (literal != END_OF_CLAUSE) {
fprintf(stderr, "Format error: file %s\n", filename);
fclose(f);
return FORMAT_ERROR;
}
add_clause(core, buffer.size, buffer.data);
c_idx ++;
ivector_reset(&buffer);
}
delete_ivector(&buffer);
fclose(f);
return 0;
}
void clause_db_destruct(clause_db_t* db) {
delete_ivector(&db->clauses);
safe_free(db->memory);
}
