bvt boolbvt::convert_array_of(const array_of_exprt &expr)
{
if(expr.type().id()!=ID_array)
throw "array_of must be array-typed";
const array_typet &array_type=to_array_type(expr.type());
if(is_unbounded_array(array_type))
return conversion_failed(expr);
std::size_t width=boolbv_width(array_type);
if(width==0)
{
// A zero-length array is acceptable;
// an element with unknown size is not.
if(boolbv_width(array_type.subtype())==0)
return conversion_failed(expr);
else
return bvt();
}
const exprt &array_size=array_type.size();
mp_integer size;
if(to_integer(array_size, size))
return conversion_failed(expr);
const bvt &tmp=convert_bv(expr.op0());
bvt bv;
bv.resize(width);
if(size*tmp.size()!=width)
throw "convert_array_of: unexpected operand width";
std::size_t offset=0;
for(mp_integer i=0; i<size; i=i+1)
{
for(std::size_t j=0; j<tmp.size(); j++, offset++)
bv[offset]=tmp[j];
}
assert(offset==bv.size());
return bv;
}
void arrayst::add_array_constraints_array_of(
const index_sett &index_set,
const array_of_exprt &expr)
{
// we got x=array_of[v]
// get other array index applications
// and add constraint x[i]=v
for(index_sett::const_iterator
it=index_set.begin();
it!=index_set.end();
it++)
{
index_exprt index_expr;
index_expr.type()=ns.follow(expr.type()).subtype();
index_expr.array()=expr;
index_expr.index()=*it;
assert(base_type_eq(index_expr.type(), expr.op0().type(), ns));
// add constraint
set_to_true(equality_exprt(index_expr, expr.op0()));
}
}