void modelchecker_smvt::instantiate_expression(exprt &expr)
{
Forall_operands(it, expr)
instantiate_expression(*it);
if(expr.id()==ID_predicate_symbol)
{
unsigned p=atoi(expr.get(ID_identifier).c_str());
expr.id(ID_symbol);
expr.set(ID_identifier, variable_names[p]);
}
else if(expr.id()==ID_predicate_next_symbol)
{
unsigned p=atoi(expr.get(ID_identifier).c_str());
expr.id(ID_next_symbol);
expr.set(ID_identifier, variable_names[p]);
}
else if(expr.id()==ID_nondet_symbol)
{
nondet_symbolst::const_iterator it=
nondet_symbols.find(
static_cast<const exprt &>(expr.find("expression")));
if(it==nondet_symbols.end())
throw "failed to find nondet_symbol";
typet type=expr.type();
expr=exprt(ID_symbol, type);
expr.set(ID_identifier, it->second);
}
}
/// automated variable renaming
/// \par parameters: expression, old name, new name
/// \return modifies the expression returns false iff something was renamed
bool rename(exprt &expr, const irep_idt &old_name,
const irep_idt &new_name)
{
bool result=true;
if(expr.id()==ID_symbol)
{
if(expr.get(ID_identifier)==old_name)
{
expr.set(ID_identifier, new_name);
result=false;
}
}
else
{
if(expr.id()==ID_address_of)
{
// TODO
}
else
Forall_operands(it, expr)
if(!rename(*it, old_name, new_name))
result=false;
}
return result;
}
void cpp_typecheckt::find_constructor(
const typet &start_dest_type,
exprt &constructor_expr)
{
constructor_expr.make_nil();
source_locationt source_location=start_dest_type.source_location();
typet dest_type(start_dest_type);
follow_symbol(dest_type);
if(dest_type.id()!=ID_struct)
return;
const struct_typet::componentst &components=
to_struct_type(dest_type).components();
for(struct_typet::componentst::const_iterator
it=components.begin();
it!=components.end();
it++)
{
const struct_typet::componentt &component=*it;
const typet &type=component.type();
if(type.find(ID_return_type).id()==ID_constructor)
{
const irept::subt ¶meters=
type.find(ID_parameters).get_sub();
namespacet ns(symbol_table);
if(parameters.size()==1)
{
const exprt ¶meter=(exprt &)parameters.front();
const typet &arg_type=parameter.type();
if(arg_type.id()==ID_pointer &&
type_eq(arg_type.subtype(), dest_type, ns))
{
// found!
const irep_idt &identifier=
component.get(ID_name);
if(identifier=="")
throw "constructor without identifier";
constructor_expr=exprt(ID_symbol, type);
constructor_expr.set(ID_identifier, identifier);
constructor_expr.add_source_location()=source_location;
return;
}
}
}
}
}
void termination_baset::remove_ssa_ids(exprt &expr) const
{
if(expr.id()==ID_symbol)
{
irep_idt ident=expr.get(ID_identifier);
ident = id2string(ident).substr(0, id2string(ident).rfind('@'));
ident = id2string(ident).substr(0, id2string(ident).rfind('!'));
expr.set(ID_identifier, ident);
}
Forall_operands(it, expr)
remove_ssa_ids(*it);
}
static void adjust_pred_index(exprt& expr,
const predicatest& all_preds,
const predicatest& passive_preds)
{
Forall_operands(it, expr)
adjust_pred_index(*it, all_preds, passive_preds);
if(expr.id()==ID_predicate_symbol)
{
unsigned p=safe_str2unsigned(expr.get(ID_identifier).c_str());
if(p >= passive_preds.size())
{
bool found=passive_preds.find(all_preds[p], p);
assert(found);
expr.id(ID_predicate_passive_symbol);
expr.set(ID_identifier, p);
}
}
}
void make_it_a_predicate(
const predicatest &predicates,
exprt &expr,
const namespacet &ns)
{
bool negation;
canonicalize(expr, negation, ns);
// see if we have it
unsigned nr;
if(predicates.find(expr, nr))
{
// yes, we do!
// see if it is a constant
if(predicates[nr].is_true())
expr.make_true();
else if(predicates[nr].is_false())
expr.make_false();
else
{
expr=exprt(ID_predicate_symbol, typet(ID_bool));
expr.set(ID_identifier, nr);
}
if(negation)
expr.make_not();
}
else
{
// nah, we don't
// make it nondeterministic choice
exprt tmp(ID_nondet_symbol, typet(ID_bool));
tmp.add(ID_expression).swap(expr);
expr.swap(tmp);
}
}
void c_typecastt::implicit_typecast_followed(
exprt &expr,
const typet &src_type,
const typet &dest_type)
{
if(dest_type.id()==ID_union)
// do transparent union
if(dest_type.id()==ID_union &&
dest_type.get_bool(ID_C_transparent_union) &&
src_type.id()!=ID_union)
{
// The argument corresponding to a transparent union type can be of any
// type in the union; no explicit cast is required.
// Check union members.
const union_typet &dest_union_type=to_union_type(dest_type);
for(union_typet::componentst::const_iterator
it=dest_union_type.components().begin();
it!=dest_union_type.components().end();
it++)
{
if(!check_c_implicit_typecast(src_type, it->type()))
{
// build union constructor
exprt union_expr(ID_union, dest_union_type);
union_expr.move_to_operands(expr);
union_expr.set(ID_component_name, it->get_name());
expr=union_expr;
return; // ok
}
}
}
if(dest_type.id()==ID_pointer)
{
// special case: 0 == NULL
if(expr.is_zero() && (
src_type.id()==ID_unsignedbv ||
src_type.id()==ID_signedbv ||
src_type.id()==ID_natural ||
src_type.id()==ID_integer))
{
expr=exprt(ID_constant, dest_type);
expr.set(ID_value, ID_NULL);
return; // ok
}
if(src_type.id()==ID_pointer ||
src_type.id()==ID_array)
{
// we are quite generous about pointers
const typet &src_sub=ns.follow(src_type.subtype());
const typet &dest_sub=ns.follow(dest_type.subtype());
if(is_void_pointer(src_type) ||
is_void_pointer(dest_type))
{
// from/to void is always good
}
else if(src_sub.id()==ID_code &&
dest_sub.id()==ID_code)
{
// very generous:
// between any two function pointers it's ok
}
else if(base_type_eq(src_type.subtype(), dest_type.subtype(), ns))
{
// ok
}
else if((is_number(src_sub) || src_sub.id()==ID_c_enum) &&
(is_number(dest_sub) || dest_sub.id()==ID_c_enum))
{
// Also generous: between any to scalar types it's ok.
// We should probably check the size.
}
else
warnings.push_back("incompatible pointer types");
// check qualifiers
/*
if(src_type.subtype().get_bool(ID_C_constant) &&
!dest_type.subtype().get_bool(ID_C_constant))
warnings.push_back("disregarding const");
*/
if(src_type.subtype().get_bool(ID_C_volatile) &&
!dest_type.subtype().get_bool(ID_C_volatile))
warnings.push_back("disregarding volatile");
if(src_type==dest_type)
{
expr.type()=src_type; // because of qualifiers
}
else
do_typecast(expr, dest_type);
return; // ok
}
}
if(check_c_implicit_typecast(src_type, dest_type))
errors.push_back("implicit conversion not permitted");
else if(src_type!=dest_type)
do_typecast(expr, dest_type);
}