be_ptr bmc_tableau_memoization_lookup(hash_ptr tableau_ltl_hash,
node_ptr key)
{
nusmv_assert(tableau_ltl_hash != (hash_ptr) NULL);
return (be_ptr) find_assoc(tableau_ltl_hash, key);
}
boolean SymbLayer_is_variable_in_layer(SymbLayer_ptr self, node_ptr name)
{
SYMB_LAYER_CHECK_INSTANCE(self);
/* Must be a symbol in this layer and a variable in the cache */
return (Nil != find_assoc(self->symbol2position, name) &&
SymbCache_is_symbol_var(self->cache, name));
}
/**Function********************************************************************
Synopsis [Convert an internal minisat literal into a cnf literal]
Description [The variable in the literal has to be created by
sat_minisat_cnfLiteral2minisatLiteral only.
First, the function obtains the minisat variable from the literal,
obtains associated cnf variable (there must already be the association),
and then converts it in cnf literal (adjust the sign)]
SideEffects []
SeeAlso [sat_minisat_cnfLiteral2minisatLiteral]
******************************************************************************/
int sat_minisat_minisatLiteral2cnfLiteral(SatMinisat_ptr self, int minisatLiteral)
{
int minisatVar = abs(minisatLiteral);
int cnfVar = NODE_TO_INT(find_assoc(self->minisatVar2cnfVar,
NODE_FROM_INT(minisatVar)));
#if 0
We cannot check that cnfVar != Nil, since some internal variables
can be used as group id-s.
We cannnot check that internal variable is a group id, because
some groups may be deleted and their id-s are removed from the list
'existing group'.
/* cnf var is Nill only if the corresponding internal var represents
a group id, otherwise is always greater then 0 */
nusmv_assert( ((int) Nil != cnfVar) ||
sat_solver_BelongToList(SAT_SOLVER(self)->existingGroups,
(lsGeneric)minisatVar) );
#endif
return minisatLiteral > 0 ? cnfVar : - cnfVar;
}
void Be_Cnf_RemoveDuplicateLiterals(Be_Cnf_ptr self)
{
int i, j;
Siter iter;
int * clause = (int *)NULL;
hash_ptr lits = (hash_ptr)NULL;
nusmv_assert(self != NULL);
lits = new_assoc();
for (iter = Slist_first(Be_Cnf_GetClausesList(self));
!Siter_is_end(iter);
iter = Siter_next(iter)) {
clause = (int*) Siter_element(iter);
i = 0;
while (clause[i] != 0) {
if (Nil != find_assoc(lits, NODE_FROM_INT(clause[i]))) {
j = i+1;
while (clause[j] != 0) {
clause[j-1] = clause[j];
j++;
}
}
else {
insert_assoc(lits, NODE_FROM_INT(clause[i]), NODE_FROM_INT(1));
}
i++;
}
/* this clear the hash */
clear_assoc(lits);
}
free_assoc(lits);
}
/**Function********************************************************************
Synopsis [Convert a cnf literal into an internal literal used by minisat]
Description [The literal may not be 0 (because 0 cannot have sign).
First, the function obtains the cnf variable (removes the sign),
obtains associated internal var through hash table(creates if necessary
an internal variable)
and then converts it in minisat literal (just adjust the sign).
If necessary a new minisat variable is created.]
SideEffects []
SeeAlso [sat_minisat_minisatLiteral2cnfLiteral]
******************************************************************************/
int sat_minisat_cnfLiteral2minisatLiteral(SatMinisat_ptr self, int cnfLiteral)
{
int cnfVar = abs(cnfLiteral);
int minisatVar;
SAT_MINISAT_CHECK_INSTANCE(self);
nusmv_assert(cnfVar > 0);
minisatVar = NODE_TO_INT(find_assoc(self->cnfVar2minisatVar,
NODE_FROM_INT(cnfVar)));
if (0 == minisatVar) {
/* create a new internal var and associate with cnf */
minisatVar = MiniSat_New_Variable(self->minisatSolver);
insert_assoc(self->cnfVar2minisatVar,
NODE_FROM_INT(cnfVar), NODE_FROM_INT(minisatVar));
insert_assoc(self->minisatVar2cnfVar,
NODE_FROM_INT(minisatVar), NODE_FROM_INT(cnfVar));
}
return cnfLiteral > 0 ? minisatVar : - minisatVar;
}
boolean SymbLayer_is_symbol_in_layer(SymbLayer_ptr self, node_ptr name)
{
SYMB_LAYER_CHECK_INSTANCE(self);
return (Nil != find_assoc(self->symbol2position, name));
}
Trace_ptr
Bmc_fill_trace_from_cnf_model(const BeEnc_ptr be_enc,
const Slist_ptr cnf_model,
int k, Trace_ptr trace)
{
TraceIter first;
/* local refs */
const NuSMVEnv_ptr env = EnvObject_get_environment(ENV_OBJECT(be_enc));
const ExprMgr_ptr exprs = EXPR_MGR(NuSMVEnv_get_value(env, ENV_EXPR_MANAGER));
const BoolEnc_ptr bool_enc = \
BoolEncClient_get_bool_enc(BOOL_ENC_CLIENT(be_enc));
const NodeMgr_ptr nodemgr =
NODE_MGR(NuSMVEnv_get_value(env, ENV_NODE_MGR));
const Be_Manager_ptr be_mgr = BeEnc_get_be_manager(be_enc);
const SymbTable_ptr st = BaseEnc_get_symb_table(BASE_ENC(be_enc));
hash_ptr tvar_2_bval = new_assoc();
hash_ptr time_2_step = new_assoc();
Siter genLiteral;
nusmv_ptrint cnfLiteral;
nusmv_ptrint beLiteral;
int i;
TRACE_CHECK_INSTANCE(trace);
nusmv_assert(Trace_is_empty(trace));
first = Trace_first_iter(trace);
/* phase 0: setup trace iterators for all times */
insert_assoc(time_2_step, NODE_FROM_INT(0), (node_ptr)(first));
for (i = 1; i <= k; ++ i) {
TraceIter step = Trace_append_step(trace);
insert_assoc(time_2_step, NODE_FROM_INT(i), (node_ptr)(step));
}
/* phase 1: we consider only the cnf variables corresponding to BE
variables in the range [0, k].
Thus we ignore the cnf variables that are not corresponding to
the encoding of the:
- model variables;
- encoding variables (sub formulas, loop variables, ...)
*/
SLIST_FOREACH(cnf_model, genLiteral) {
int var_idx, ut_index, vtime;
node_ptr var, key;
cnfLiteral = (nusmv_ptrint) Siter_element(genLiteral);
beLiteral = (nusmv_ptrint) Be_CnfLiteral2BeLiteral(be_mgr, cnfLiteral);
/* if there is no corresponding rbc variable skip this */
if (0 == beLiteral) continue;
/* get timed var */
var_idx = Be_BeLiteral2BeIndex(be_mgr, beLiteral);
ut_index = BeEnc_index_to_untimed_index(be_enc, var_idx);
vtime = BeEnc_index_to_time(be_enc, var_idx);
var = BeEnc_index_to_name(be_enc, ut_index);
/* needed to adapt to new trace timing format, input is stored
in the next step */
if (SymbTable_is_symbol_input_var(st, var)) { ++ vtime; }
if (vtime > k) continue;
/* if it's a bit get/create a BitValues structure for
the scalar variable which this bit belongs */
if (BoolEnc_is_var_bit(bool_enc, var)) {
node_ptr scalar_var = BoolEnc_get_scalar_var_from_bit(bool_enc, var);
BitValues_ptr bv;
key = find_node(nodemgr, ATTIME, scalar_var, NODE_FROM_INT(vtime));
bv = BIT_VALUES(find_assoc(tvar_2_bval, key));
if (BIT_VALUES(NULL) == bv) {
bv = BitValues_create(bool_enc, scalar_var);
insert_assoc(tvar_2_bval, key, (node_ptr)(bv));
}
/* set the bit value */
BitValues_set(bv, BoolEnc_get_index_from_bit(bool_enc, var),
(beLiteral >= 0) ? BIT_VALUE_TRUE : BIT_VALUE_FALSE);
}
else { /* boolean variables do not require any further processing */
TraceIter timed_step = (-1 != vtime) /* frozenvars */
? TRACE_ITER(find_assoc(time_2_step, NODE_FROM_INT(vtime)))
: first ;
nusmv_assert(TRACE_END_ITER != timed_step);
Trace_step_put_value(trace, timed_step, var, beLiteral >= 0
? ExprMgr_true(exprs) : ExprMgr_false(exprs));
}
} /* SLIST_FOREACH (phase 1) */
int trace_explainer_action(const TracePlugin_ptr self)
{
const Trace_ptr trace = self->trace;
const SymbTable_ptr symb_table = Trace_get_symb_table(trace);
const NuSMVEnv_ptr env = EnvObject_get_environment(ENV_OBJECT(symb_table));
TraceIter start_iter;
TraceIter stop_iter;
TraceIter step;
TraceIteratorType input_iter_type;
TraceIteratorType state_iter_type;
TraceIteratorType combo_iter_type;
hash_ptr changed_states;
int i;
OStream_ptr out = TraceOpt_output_stream(self->opt);
start_iter = (0 != TraceOpt_from_here(self->opt))
? trace_ith_iter(trace, TraceOpt_from_here(self->opt))
: trace_first_iter(trace);
stop_iter = (0 != TraceOpt_to_here(self->opt))
? trace_ith_iter(trace, 1 + TraceOpt_to_here(self->opt))
: TRACE_END_ITER;
input_iter_type = TraceOpt_show_defines(self->opt)
? TRACE_ITER_I_SYMBOLS : TRACE_ITER_I_VARS;
state_iter_type = TraceOpt_show_defines(self->opt)
? TRACE_ITER_SF_SYMBOLS : TRACE_ITER_SF_VARS;
combo_iter_type = TraceOpt_show_defines(self->opt)
? (TraceOpt_show_defines_with_next(self->opt)
? TRACE_ITER_COMBINATORIAL
: TRACE_ITER_SI_DEFINES)
: TRACE_ITER_NONE;
OStream_printf(out, "Trace Description: %s \n", Trace_get_desc(trace));
OStream_printf(out, "Trace Type: %s \n", TraceType_to_string(env, Trace_get_type(trace)));
/* indent */
OStream_inc_indent_size(out);
changed_states = new_assoc();
nusmv_assert(changed_states != (hash_ptr)NULL);
i = MAX(1, TraceOpt_from_here(self->opt)); step = start_iter;
while (stop_iter != step) {
TraceStepIter iter;
node_ptr symb;
node_ptr val;
boolean input_header = false;
/* lazy defines evaluation */
if (TraceOpt_show_defines(self->opt)) {
trace_step_evaluate_defines(trace, step);
}
/* COMBINATORIAL SECTION (optional) */
TRACE_STEP_FOREACH(trace, step, combo_iter_type, iter, symb, val) {
/* skip non-visible symbols */
if (!trace_plugin_is_visible_symbol(self, symb)) continue;
/* if required, print only symbols with changed values */
if (TRACE_EXPLAINER(self)->changes_only) {
if (val == find_assoc(changed_states, symb)) { continue; }
insert_assoc(changed_states, symb, val);
}
TracePlugin_print_assignment(self, symb, val);
} /* foreach SI_DEFINES */
/* INPUT SECTION (optional) */
TRACE_STEP_FOREACH(trace, step, input_iter_type, iter, symb, val) {
if (false == input_header) {
OStream_printf(out, "-> Input: %d.%d <-\n", Trace_get_id(trace), i);
input_header = true;
}
/* skip non-visible symbols */
if (!trace_plugin_is_visible_symbol(self, symb)) continue;
/* if required, print only symbols with changed values */
if (TRACE_EXPLAINER(self)->changes_only) {
if (val == find_assoc(changed_states, symb)) { continue; }
insert_assoc(changed_states, symb, val);
}
TracePlugin_print_assignment(self, symb, val);
} /* foreach I_SYMBOLS */
if (Trace_step_is_loopback(trace, step)) {
OStream_printf(out, "-- Loop starts here\n");
}
/* STATE SECTION (mandatory) */
OStream_printf(out, "-> State: %d.%d <-\n", Trace_get_id(trace), i);
TRACE_STEP_FOREACH(trace, step, state_iter_type, iter, symb, val) {
/* skip non-visible symbols */
if (!trace_plugin_is_visible_symbol(self, symb)) continue;
/* if required, print only symbols with changed values */
if (TRACE_EXPLAINER(self)->changes_only) {
if (val == find_assoc(changed_states, symb)) { continue; }
insert_assoc(changed_states, symb, val);
}
TracePlugin_print_assignment(self, symb, val);
} /* foreach SF_SYMBOLS */
++ i; step = TraceIter_get_next(step);
} /* while */
free_assoc(changed_states);
/* deindent */
OStream_dec_indent_size(out);
return 0;
}
/**Function********************************************************************
Synopsis [Inline caching private service]
Description []
SideEffects []
SeeAlso []
******************************************************************************/
InlineResult_ptr rbc_inlining_cache_lookup_result(Rbc_t* f)
{ return INLINE_RESULT(find_assoc(inlining_cache, (node_ptr) f)); }
/**Function********************************************************************
Synopsis [Looks up in the wff2nff memoization hash for
the given entry]
Description [Looks up in the wff2nff memoization hash for
the given entry]
SideEffects []
SeeAlso []
******************************************************************************/
static node_ptr w2w_wff2nnf_hash_lookup_entry(node_ptr wff, boolean polarity)
{
nusmv_assert(wff2nnf_hash != (hash_ptr) NULL);
return find_assoc(wff2nnf_hash, find_node(CONS, wff, (node_ptr) polarity));
}
