decision_proceduret::resultt smt1_dect::read_result_z3(std::istream &in)
{
std::string line;
decision_proceduret::resultt res = D_ERROR;
smt1_prop.reset_assignment();
typedef hash_map_cont<std::string, std::string, string_hash> valuest;
valuest values;
while(str_getline(in, line))
{
if(line=="sat")
res = D_SATISFIABLE;
else if(line=="unsat")
res = D_UNSATISFIABLE;
else
{
std::size_t pos=line.find(" -> ");
if(pos!=std::string::npos)
values[std::string(line, 0, pos)]=
std::string(line, pos+4, std::string::npos);
}
}
for(identifier_mapt::iterator
it=identifier_map.begin();
it!=identifier_map.end();
it++)
{
it->second.value.make_nil();
std::string conv_id=convert_identifier(it->first);
std::string value=values[conv_id];
if(value=="") continue;
// std::cout << it->first << " := " << value << std::endl;
exprt e;
if(string_to_expr_z3(it->second.type, value, e))
{
// std::cout << "E: " << e << std::endl;
it->second.value=e;
}
else
set_value(it->second, value);
}
// Booleans
for(unsigned v=0; v<smt1_prop.no_variables(); v++)
{
std::string value=values["B"+i2string(v)];
if(value=="") continue;
smt1_prop.set_assignment(literalt(v, false), value=="true");
}
return res;
}
decision_proceduret::resultt smt1_dect::read_result_boolector(std::istream &in)
{
std::string line;
str_getline(in, line);
if(line=="sat")
{
smt1_prop.reset_assignment();
typedef hash_map_cont<std::string, std::string, string_hash> valuest;
valuest values;
while(str_getline(in, line))
{
std::size_t pos=line.find(' ');
if(pos!=std::string::npos)
values[std::string(line, 0, pos)]=
std::string(line, pos+1, std::string::npos);
}
// Theory variables
for(identifier_mapt::iterator
it=identifier_map.begin();
it!=identifier_map.end();
it++)
{
it->second.value.make_nil();
std::string conv_id=convert_identifier(it->first);
std::string value=values[conv_id];
if(value=="") continue;
set_value(it->second, value);
}
// Booleans
for(unsigned v=0; v<smt1_prop.no_variables(); v++)
{
std::string value=values["B"+i2string(v)];
if(value=="") continue;
smt1_prop.set_assignment(literalt(v, false), value=="1");
}
return D_SATISFIABLE;
}
else if(line=="unsat")
return D_UNSATISFIABLE;
else
error("Unexpected result from SMT-Solver: "+line);
return D_ERROR;
}
decision_proceduret::resultt smt1_dect::read_result_z3(std::istream &in)
{
std::string line;
decision_proceduret::resultt res = D_ERROR;
boolean_assignment.clear();
boolean_assignment.resize(no_boolean_variables, false);
typedef std::unordered_map<std::string, std::string, string_hash> valuest;
valuest values;
while(std::getline(in, line))
{
if(line=="sat")
res = D_SATISFIABLE;
else if(line=="unsat")
res = D_UNSATISFIABLE;
else
{
std::size_t pos=line.find(" -> ");
if(pos!=std::string::npos)
values[std::string(line, 0, pos)]=
std::string(line, pos+4, std::string::npos);
}
}
for(identifier_mapt::iterator
it=identifier_map.begin();
it!=identifier_map.end();
it++)
{
it->second.value.make_nil();
std::string conv_id=convert_identifier(it->first);
std::string value=values[conv_id];
if(value=="") continue;
exprt e;
if(string_to_expr_z3(it->second.type, value, e))
it->second.value=e;
else
set_value(it->second, "", value);
}
// Booleans
for(unsigned v=0; v<no_boolean_variables; v++)
{
std::string value=values["B"+std::to_string(v)];
if(value=="") continue;
boolean_assignment[v]=(value=="true");
}
return res;
}
decision_proceduret::resultt smt2_dect::read_result(std::istream &in)
{
std::string line;
decision_proceduret::resultt res=resultt::D_ERROR;
boolean_assignment.clear();
boolean_assignment.resize(no_boolean_variables, false);
typedef std::unordered_map<irep_idt, irept, irep_id_hash> valuest;
valuest values;
while(in)
{
irept parsed=smt2irep(in);
if(parsed.id()=="sat")
res=resultt::D_SATISFIABLE;
else if(parsed.id()=="unsat")
res=resultt::D_UNSATISFIABLE;
else if(parsed.id()=="" &&
parsed.get_sub().size()==1 &&
parsed.get_sub().front().get_sub().size()==2)
{
const irept &s0=parsed.get_sub().front().get_sub()[0];
const irept &s1=parsed.get_sub().front().get_sub()[1];
// Examples:
// ( (B0 true) )
// ( (|__CPROVER_pipe_count#1| (_ bv0 32)) )
values[s0.id()]=s1;
}
else if(parsed.id()=="" &&
parsed.get_sub().size()==2 &&
parsed.get_sub().front().id()=="error")
{
// We ignore errors after UNSAT because get-value after check-sat
// returns unsat will give an error.
if(res!=resultt::D_UNSATISFIABLE)
{
error() << "SMT2 solver returned error message:\n"
<< "\t\"" << parsed.get_sub()[1].id() <<"\"" << eom;
return decision_proceduret::resultt::D_ERROR;
}
}
}
for(identifier_mapt::iterator
it=identifier_map.begin();
it!=identifier_map.end();
it++)
{
std::string conv_id=convert_identifier(it->first);
const irept &value=values[conv_id];
it->second.value=parse_rec(value, it->second.type);
}
// Booleans
for(unsigned v=0; v<no_boolean_variables; v++)
{
const irept &value=values["B"+std::to_string(v)];
boolean_assignment[v]=(value.id()==ID_true);
}
return res;
}
decision_proceduret::resultt smt1_dect::read_result_cvc3(std::istream &in)
{
std::string line;
decision_proceduret::resultt res = D_ERROR;
smt1_prop.reset_assignment();
typedef hash_map_cont<std::string, std::string, string_hash> valuest;
valuest values;
while(str_getline(in, line))
{
if(line=="sat")
res = D_SATISFIABLE;
else if(line=="unsat")
res = D_UNSATISFIABLE;
else if(line.find("Current scope level")!=std::string::npos ||
line.find("Variable Assignment")!=std::string::npos)
; //ignore
else
{
assert(line.substr(0,13)==" :assumption");
std::size_t pos=line.find('(');
if(pos!=std::string::npos)
{
std::string var;
std::string val;
if(line[pos+1]=='=')
{
std::string ops = line.substr(pos+3, line.length()-pos-4);
std::size_t blank=ops.find(' ');
var = ops.substr(0, blank);
val = ops.substr(blank+1, ops.length()-blank);
if((var.length()>=4 && var.substr(0,4)=="cvc3") ||
(val.length()>=4 && val.substr(0,4)=="cvc3") ||
var==val)
continue;
else if((var.substr(0,9)=="array_of'") ||
(var.substr(0,2)=="bv" && val.substr(0,2)!="bv"))
{
std::string t=var; var=val; val=t;
}
}
else if(line.substr(pos+1,3)=="not")
{
var = line.substr(pos+5, line.length()-pos-6);
val = "false";
}
else
{
var = line.substr(pos+1, line.length()-pos-2);
assert(var.find(' ')==std::string::npos);
val = "true";
}
values[var]=val;
}
}
}
for(identifier_mapt::iterator
it=identifier_map.begin();
it!=identifier_map.end();
it++)
{
it->second.value.make_nil();
std::string conv_id=convert_identifier(it->first);
std::string value=values[conv_id];
if(value=="") continue;
if(value.substr(0,2)=="bv")
{
std::string v=value.substr(2, value.find('[')-2);
size_t p = value.find('[')+1;
std::string w=value.substr(p, value.find(']')-p);
std::string binary=integer2binary(string2integer(v,10),
string2integer(w,10).to_ulong());
set_value(it->second, "", binary);
}
else if(value=="false")
it->second.value.make_false();
else if(value=="true")
it->second.value.make_true();
else if(value.substr(0,8)=="array_of")
{
// We assume that array_of has only concrete arguments...
irep_idt id(value);
array_of_mapt::const_iterator fit=array_of_map.begin();
while(fit!=array_of_map.end() && fit->second!=id) fit++;
if(fit!=array_of_map.end())
it->second.value = fit->first;
}
else
set_value(it->second, "", value);
}
// Booleans
for(unsigned v=0; v<smt1_prop.no_variables(); v++)
{
std::string value=values["B"+i2string(v)];
if(value=="") continue;
smt1_prop.set_assignment(literalt(v, false), value=="true");
}
return res;
}
decision_proceduret::resultt smt1_dect::read_result_mathsat(std::istream &in)
{
std::string line;
decision_proceduret::resultt res = D_ERROR;
smt1_prop.reset_assignment();
typedef hash_map_cont<std::string, valuet, string_hash> valuest;
valuest values;
while(str_getline(in, line))
{
if(line=="sat")
res=D_SATISFIABLE;
else if(line=="unsat")
res=D_UNSATISFIABLE;
else if(line.size()>=1 && line[0]=='(')
{
// (= c_h39__h39___CPROVER_malloc_size_h39_35_h39_1 bv0[64])
// (= (select __h64_0 bv0[32]) bv5[8])
std::size_t pos1=line.find(' ');
std::size_t pos2=line.rfind(' ');
if(pos1!=std::string::npos &&
pos2!=std::string::npos &&
pos1!=pos2)
{
std::string id=std::string(line, pos1+1, pos2-pos1-1);
std::string value=std::string(line, pos2+1, line.size()-pos2-2);
if(has_prefix(id, "(select "))
{
#if 0
std::size_t pos3=id.rfind(' ');
std::string index=std::string(pos3+1, id.size()-pos3-1);
id=std::string(id, 8, pos3-8);
#endif
}
else
values[id].value=value;
}
}
}
for(identifier_mapt::iterator
it=identifier_map.begin();
it!=identifier_map.end();
it++)
{
it->second.value.make_nil();
std::string conv_id=convert_identifier(it->first);
std::string value=mathsat_value(values[conv_id].value);
if(value!="")
set_value(it->second, "", value);
}
// Booleans
for(unsigned v=0; v<smt1_prop.no_variables(); v++)
{
std::string value=values["B"+i2string(v)].value;
if(value=="") continue;
smt1_prop.set_assignment(literalt(v, false), value=="true");
}
return res;
}
decision_proceduret::resultt smt1_dect::read_result_boolector(std::istream &in)
{
std::string line;
str_getline(in, line);
if(line=="sat")
{
smt1_prop.reset_assignment();
typedef hash_map_cont<std::string, valuet, string_hash> valuest;
valuest values;
while(str_getline(in, line))
{
std::size_t pos=line.find(' ');
if(pos!=std::string::npos && pos!=0)
{
std::string id=std::string(line, 0, pos);
std::string value=std::string(line, pos+1, std::string::npos);
// Boolector offers array values as follows:
//
// ID[INDEX] VALUE
//
// There may be more than one line per ID
if(id!="" && id[id.size()-1]==']') // array?
{
std::size_t pos2=id.find('[');
if(pos2!=std::string::npos)
{
std::string new_id=std::string(id, 0, pos2);
std::string index=std::string(id, pos2+1, id.size()-pos2-2);
values[new_id].index_value_map[index]=value;
}
}
else
values[id].value=value;
}
}
// Theory variables
for(identifier_mapt::iterator
it=identifier_map.begin();
it!=identifier_map.end();
it++)
{
it->second.value.make_nil();
std::string conv_id=convert_identifier(it->first);
const valuet &v=values[conv_id];
for(valuet::index_value_mapt::const_iterator
i_it=v.index_value_map.begin(); i_it!=v.index_value_map.end(); i_it++)
set_value(it->second, i_it->first, i_it->second);
if(v.value!="") set_value(it->second, "", v.value);
}
// Booleans
for(unsigned v=0; v<smt1_prop.no_variables(); v++)
{
std::string value=values["B"+i2string(v)].value;
if(value=="") continue;
smt1_prop.set_assignment(literalt(v, false), value=="1");
}
return D_SATISFIABLE;
}
else if(line=="unsat")
return D_UNSATISFIABLE;
else
error("Unexpected result from SMT-Solver: "+line);
return D_ERROR;
}
void dplib_convt::convert_dplib_expr(const exprt &expr)
{
if(expr.id()==ID_symbol)
{
convert_identifier(expr.get_string(ID_identifier));
}
else if(expr.id()==ID_nondet_symbol)
{
convert_identifier("nondet$"+expr.get_string(ID_identifier));
}
else if(expr.id()==ID_typecast)
{
assert(expr.operands().size()==1);
const exprt &op=expr.op0();
if(expr.type().id()==ID_bool)
{
if(op.type().id()==ID_signedbv ||
op.type().id()==ID_unsignedbv ||
op.type().id()==ID_pointer)
{
convert_dplib_expr(op);
dplib_prop.out << "/=";
convert_dplib_expr(gen_zero(op.type()));
}
else
{
throw "TODO typecast1 "+op.type().id_string()+" -> bool";
}
}
else if(expr.type().id()==ID_signedbv ||
expr.type().id()==ID_unsignedbv)
{
unsigned to_width=unsafe_string2unsigned(id2string(expr.type().get(ID_width)));
if(op.type().id()==ID_signedbv)
{
unsigned from_width=unsafe_string2unsigned(id2string(op.type().get(ID_width)));
if(from_width==to_width)
convert_dplib_expr(op);
else if(from_width<to_width)
{
dplib_prop.out << "SX(";
convert_dplib_expr(op);
dplib_prop.out << ", " << to_width << ")";
}
else
{
dplib_prop.out << "(";
convert_dplib_expr(op);
dplib_prop.out << ")[" << (to_width-1) << ":0]";
}
}
else if(op.type().id()==ID_unsignedbv)
{
unsigned from_width=unsafe_string2unsigned(id2string(op.type().get(ID_width)));
if(from_width==to_width)
convert_dplib_expr(op);
else if(from_width<to_width)
{
dplib_prop.out << "(0bin";
for(unsigned i=from_width; i<to_width; i++)
dplib_prop.out << "0";
dplib_prop.out << " @ ";
dplib_prop.out << "(";
convert_dplib_expr(op);
dplib_prop.out << "))";
}
else
{
dplib_prop.out << "(";
convert_dplib_expr(op);
dplib_prop.out << ")[" << (to_width-1) << ":0]";
}
}
else if(op.type().id()==ID_bool)
{
if(to_width>1)
{
dplib_prop.out << "(0bin";
for(unsigned i=1; i<to_width; i++)
dplib_prop.out << "0";
dplib_prop.out << " @ ";
dplib_prop.out << "IF ";
convert_dplib_expr(op);
dplib_prop.out << " THEN 0bin1 ELSE 0bin0 ENDIF)";
}
else
{
dplib_prop.out << "IF ";
convert_dplib_expr(op);
dplib_prop.out << " THEN 0bin1 ELSE 0bin0 ENDIF";
}
}
else
{
throw "TODO typecast2 "+op.type().id_string()+
" -> "+expr.type().id_string();
}
}
else if(expr.type().id()==ID_pointer)
{
if(op.type().id()==ID_pointer)
{
convert_dplib_expr(op);
}
else
throw "TODO typecast3 "+op.type().id_string()+" -> pointer";
}
else
throw "TODO typecast4 ? -> "+expr.type().id_string();
}
else if(expr.id()==ID_struct)
{
dplib_prop.out << "(# ";
const struct_typet &struct_type=to_struct_type(expr.type());
const struct_typet::componentst &components=
struct_type.components();
assert(components.size()==expr.operands().size());
unsigned i=0;
for(struct_typet::componentst::const_iterator
it=components.begin();
it!=components.end();
it++, i++)
{
if(i!=0) dplib_prop.out << ", ";
dplib_prop.out << it->get(ID_name);
dplib_prop.out << ":=";
convert_dplib_expr(expr.operands()[i]);
}
dplib_prop.out << " #)";
}
else if(expr.id()==ID_constant)
{
if(expr.type().id()==ID_unsignedbv ||
expr.type().id()==ID_signedbv ||
expr.type().id()==ID_bv)
{
dplib_prop.out << "0bin" << expr.get(ID_value);
}
else if(expr.type().id()==ID_pointer)
{
const irep_idt &value=expr.get(ID_value);
if(value=="NULL")
{
dplib_prop.out << "(# object:="
<< pointer_logic.get_null_object()
<< ", offset:="
<< bin_zero(config.ansi_c.pointer_width) << " #)";
}
else
throw "unknown pointer constant: "+id2string(value);
}
else if(expr.type().id()==ID_bool)
{
if(expr.is_true())
dplib_prop.out << "TRUE";
else if(expr.is_false())
dplib_prop.out << "FALSE";
else
throw "unknown boolean constant";
}
else if(expr.type().id()==ID_array)
{
dplib_prop.out << "ARRAY (i: " << array_index_type() << "):";
assert(!expr.operands().empty());
unsigned i=0;
forall_operands(it, expr)
{
if(i==0)
dplib_prop.out << "\n IF ";
else
dplib_prop.out << "\n ELSIF ";
dplib_prop.out << "i=" << array_index(i) << " THEN ";
convert_array_value(*it);
i++;
}
dplib_prop.out << "\n ELSE ";
convert_dplib_expr(expr.op0());
dplib_prop.out << "\n ENDIF";
}
else if(expr.type().id()==ID_integer ||
decision_proceduret::resultt smt2_dect::read_result_mathsat(std::istream &in)
{
std::string line;
decision_proceduret::resultt res=D_ERROR;
smt2_prop.reset_assignment();
typedef hash_map_cont<std::string, std::string, string_hash> valuest;
valuest values;
while(str_getline(in, line))
{
if(line=="sat")
res=D_SATISFIABLE;
else if(line=="unsat")
res=D_UNSATISFIABLE;
else if(line.size()>=2 && line[0]=='(')
{
// ( (B0 true) )
std::size_t pos1=line.find('(', 1);
std::size_t pos2=line.find(' ', pos1);
std::size_t pos3=line.find(')', pos2);
if(pos1!=std::string::npos &&
pos2!=std::string::npos &&
pos3!=std::string::npos)
{
std::string id=std::string(line, pos1+1, pos2-pos1-1);
std::string value=std::string(line, pos2+1, pos3-pos2-1);
values[id]=value;
}
}
}
for(identifier_mapt::iterator
it=identifier_map.begin();
it!=identifier_map.end();
it++)
{
it->second.value.make_nil();
std::string conv_id=convert_identifier(it->first);
std::string value=values[conv_id];
if(value=="") continue;
if (value.substr(0, 5) == "(_ bv") {
// value is "(_ bvDECIMAL_VALUE SIZE"
// convert to binary
value = value.substr(5);
size_t pos = value.find(' ');
std::string v = value.substr(0, pos);
std::string w = value.substr(pos+1);
value = integer2binary(string2integer(v, 10),
string2integer(w, 10).to_ulong());
}
set_value(it->second, value);
}
// Booleans
for(unsigned v=0; v<smt2_prop.no_variables(); v++)
{
std::string value=values["B"+i2string(v)];
if(value=="") continue;
smt2_prop.set_assignment(literalt(v, false), value=="true");
}
return res;
}
