std::ostream &operator<<(std::ostream &out, const rationalt &a)
{
std::string d=integer2string(a.get_numerator());
if(a.get_denominator()!=1)
d+="/"+integer2string(a.get_denominator());
return out << d;
}
Writer::Writer(int id):tid(id),server("127.0.0.1"), user("root"), password("admin"), database("music_tdt_pages")
#ifdef DEBUG
,tp(id)
#endif
{
bzero(stime, sizeof(stime));
time(&timep);
p = gmtime(&timep);
/*sprintf(stime, "Last-Modified: %s, %d %s %d %d:%d:%d", Writer::writer_wday[p->tm_wday], p->tm_mday,
Writer::writer_month[p->tm_mon], (1900 + p->tm_year), (p->tm_hour+8), p->tm_min,
p->tm_sec);*/
sprintf(stime, "%s, %d %s %d %d:%d:%d", Writer::writer_wday[p->tm_wday], p->tm_mday,
Writer::writer_month[p->tm_mon], (1900 + p->tm_year), (p->tm_hour+8), p->tm_min,
p->tm_sec);
sqldate = integer2string(1900 + p->tm_year);
if(p->tm_mon < 9)//tm_mon从0开始计数
sqldate += "0";
sqldate += integer2string(p->tm_mon+1);
if(p->tm_mday < 10)
sqldate += "0";
sqldate += integer2string(p->tm_mday);
//for mysql
conn = mysql_init(NULL);
if(!mysql_real_connect(conn, server, user, password, database, 0, NULL, 0))
{
fprintf(stderr, "%s\n", mysql_error(conn));
exit(1);
}
}
bool clang_c_convertert::convert_integer_literal(
const clang::IntegerLiteral &integer_literal,
exprt &dest)
{
typet type;
if(get_type(integer_literal.getType(), type))
return true;
assert(type.is_unsignedbv() || type.is_signedbv());
llvm::APInt val = integer_literal.getValue();
exprt the_val;
if (type.is_unsignedbv())
{
the_val =
constant_exprt(
integer2binary(val.getZExtValue(), bv_width(type)),
integer2string(val.getZExtValue()),
type);
}
else
{
the_val =
constant_exprt(
integer2binary(val.getSExtValue(), bv_width(type)),
integer2string(val.getSExtValue()),
type);
}
dest.swap(the_val);
return false;
}
exprt from_rational(const rationalt &a)
{
std::string d=integer2string(a.numerator);
if(a.denominator!=1) d+="/"+integer2string(a.denominator);
constant_exprt result;
result.type()=rational_typet();
result.set_value(d);
return result;
}
static std::string type_max(const typet &src)
{
if(src.id()==ID_signedbv)
return integer2string(
power(2, to_signedbv_type(src).get_width()-1)-1);
else if(src.id()==ID_unsignedbv)
return integer2string(
power(2, to_unsignedbv_type(src).get_width()-1)-1);
else
assert(false);
}
std::string expr2javat::convert_constant(
const constant_exprt &src,
unsigned &precedence)
{
if(src.type().id()==ID_bool)
{
// Java has built-in Boolean constants, in contrast to C
if(src.is_true())
return "true";
else if(src.is_false())
return "false";
}
else if(src.type().id()==ID_pointer)
{
// Java writes 'null' for the null reference
if(src.is_zero())
return "null";
}
else if(src.type()==java_char_type())
{
std::string dest;
dest.reserve(10);
mp_integer int_value;
to_integer(src, int_value);
dest+='\'';
if(int_value>=' ' && int_value<127)
dest+=(char)(int_value.to_long());
else
{
std::string hex=integer2string(int_value, 16);
while(hex.size()<4) hex='0'+hex;
dest+='\\';
dest+='u';
dest+=hex;
}
dest+='\'';
return dest;
}
else if(src.type()==java_long_type())
{
// long integer literals must have 'L' at the end
mp_integer int_value;
to_integer(src, int_value);
std::string dest=integer2string(int_value);
dest+='L';
return dest;
}
return expr2ct::convert_constant(src, precedence);
}
std::string get_cegis_code_prefix(const size_t num_vars,
const size_t num_consts, const size_t max_solution_size)
{
std::string prefix("#define " CEGIS_PREFIX "number_of_vars ");
prefix+=integer2string(num_vars);
prefix+="\n#define " CEGIS_PREFIX "number_of_consts ";
prefix+=integer2string(num_consts);
prefix+="u\n#define " CEGIS_PREFIX "number_of_ops ";
prefix+=integer2string(num_vars + max_solution_size);
prefix+="u\n#define " CEGIS_PREFIX "max_solution_size ";
prefix+=integer2string(max_solution_size);
return prefix+="u\n";
}
bool Writer::writeHeader(int tid, char* buf, struct page_link* p_pl, char* p_ip, int size) {
//因为这个函数在wirteIt后调用所以类成员变量file已经被封装好
string filename("./Header/");
filename = filename + integer2string(tid) + "/" + file + ".txt";
fstream fp;
fp.open(filename.c_str(), ios_base::out);
if (!fp.is_open()) {
#ifdef DEBUG
tp.print("writerheader:error:writer is trying to write but cannot to open it error:%s\n", strerror(errno));
#endif
return false;
}
//把数据结构写入
fp.write(reinterpret_cast<char *> (p_pl), sizeof(struct page_link));
//把时间写入
fp.write(stime, sizeof(stime));
//把ip地址写入
fp.write(p_ip, size);
fp.flush();
fp.close();//write header ok!
return true;
}
void SingleBuyer::createT1AndT2() {
CryptoPP::ECPPoint pk = shared_signature_b.get_Q();
string x = integer2string(pk.x);
string y = integer2string(pk.y);
base_party.client.createSend(T1, x, y, 20000); // TODO price
if (T1.size() == 0) {
throw ProtocolException("T1 is empty");
}
base_party.client.createSendTransactionToAddress(T2, T1, x, y, seller_address);
base_party.client.getOutputScript(T1_output_script, T1, x, y);
base_party.client.hashForSignature(T2_hash, T2, x, y, T1_output_script);
}
void c_typecheck_baset::typecheck_c_bit_field_type(typet &type)
{
typecheck_type(type.subtype());
exprt &width_expr=static_cast<exprt &>(type.add(ID_size));
typecheck_expr(width_expr);
make_constant_index(width_expr);
mp_integer i;
if(to_integer(width_expr, i))
{
err_location(type);
throw "failed to convert bit field width";
}
if(i<0)
{
err_location(type);
throw "bit field width is negative";
}
const typet &base_type=follow(type.subtype());
if(base_type.id()==ID_bool)
{
if(i>1)
{
err_location(type);
throw "bit field width too large";
}
// We don't use bool, as it's really a byte long.
type.id(ID_unsignedbv);
type.set(ID_width, integer2long(i));
}
else if(base_type.id()==ID_signedbv ||
base_type.id()==ID_unsignedbv ||
base_type.id()==ID_c_enum)
{
unsigned width=base_type.get_int(ID_width);
if(i>width)
{
err_location(type);
throw "bit field width too large";
}
typet tmp(base_type);
type.swap(tmp);
type.set(ID_width, integer2string(i));
}
else
{
err_location(type);
str << "bit field with non-integer type: "
<< to_string(base_type);
throw 0;
}
}
std::string format_constantt::operator()(const exprt &expr)
{
if(expr.is_constant())
{
if(expr.type().id()==ID_natural ||
expr.type().id()==ID_integer ||
expr.type().id()==ID_unsignedbv ||
expr.type().id()==ID_signedbv)
{
mp_integer i;
if(to_integer(expr, i)) return "(number conversion failed)";
return integer2string(i);
}
else if(expr.type().id()==ID_fixedbv)
{
return fixedbvt(expr).format(*this);
}
else if(expr.type().id()==ID_floatbv)
{
return ieee_floatt(expr).format(*this);
}
}
else if(expr.id()==ID_string_constant)
return expr.get_string(ID_value);
return "(format-constant failed: "+expr.id_string()+")";
}
// TODO change name
void SingleSeller::verifyT2Signature() {
Transaction res;
base_party.client.getSignedTransaction(
res,
T2,
integer2string(shared_signature_s.get_Q().x),
integer2string(shared_signature_s.get_Q().y),
integer2string(shared_signature_s.get_r()),
integer2string(shared_signature_s.get_s()),
T1_output_script
);
if (res.size() == 0) {
throw ProtocolException("verify T2 signature in bitcoinj failed");
}
T2 = res;
}
std::string bv_arithmetict::format(const format_spect &format_spec) const
{
std::string result;
result=integer2string(value);
return result;
}
exprt from_integer(
const mp_integer &int_value,
const typet &type)
{
exprt expr;
expr.clear();
expr.type()=type;
expr.id("constant");
const irep_idt &type_id=type.id();
if(type_id=="integer")
{
expr.value(integer2string(int_value));
return expr;
}
else if(type_id=="natural")
{
if(int_value<0) { expr.make_nil(); return expr; }
expr.value(integer2string(int_value));
return expr;
}
else if(type_id=="unsignedbv" || type_id=="signedbv")
{
expr.value(integer2binary(int_value, bv_width(type)));
return expr;
}
else if(type_id=="bool")
{
if(int_value==0)
{
expr.make_false();
return expr;
}
else if(int_value==1)
{
expr.make_true();
return expr;
}
}
expr.make_nil();
return expr;
}
std::string inv_object_storet::build_string(const exprt &expr) const
{
// we ignore some casts
if(expr.id()==ID_typecast)
{
assert(expr.operands().size()==1);
if(expr.type().id()==ID_signedbv ||
expr.type().id()==ID_unsignedbv)
{
if(expr.op0().type().id()==ID_signedbv ||
expr.op0().type().id()==ID_unsignedbv)
{
if(to_bitvector_type(expr.type()).get_width()>=
to_bitvector_type(expr.op0().type()).get_width())
return build_string(expr.op0());
}
else if(expr.op0().type().id()==ID_bool)
{
return build_string(expr.op0());
}
}
}
// we always track constants, but make sure they are uniquely
// represented
if(expr.is_constant())
{
// NULL?
if(expr.type().id()==ID_pointer)
if(expr.get(ID_value)==ID_NULL)
return "0";
mp_integer i;
if(!to_integer(expr, i))
return integer2string(i);
}
// we also like "address_of" and "reference_to"
// if the object is constant
if(is_constant_address(expr))
return from_expr(ns, "", expr);
if(expr.id()==ID_member)
{
assert(expr.operands().size()==1);
return build_string(expr.op0())+"."+expr.get_string(ID_component_name);
}
if(expr.id()==ID_symbol)
return expr.get_string(ID_identifier);
return "";
}
exprt concatenate_array_id(
const exprt &array, const mp_integer &index,
const typet &type)
{
std::string a, identifier;
a = array.get_string(ID_identifier);
identifier=a+"["+integer2string(index)+"]";
symbol_exprt new_expr(identifier, type);
return new_expr;
}
void Writer::fill_filename(struct page_link pl) {
file = "";
char* str = newStrChangeC(pl._host_addr, '/', '_', 256);
file += str;
file += "_" + integer2string(pl._portnumber) + "_";
delete str;
str = newStrChangeC(pl._host_file, '/', '_', 1024);
file += str;
delete str;
}
void cpp_typecheckt::typecheck_enum_body(symbolt &enum_symbol)
{
typet &type=enum_symbol.type;
exprt &body=static_cast<exprt &>(type.add(ID_body));
irept::subt &components=body.get_sub();
typet enum_type(ID_symbol);
enum_type.set(ID_identifier, enum_symbol.name);
mp_integer i=0;
Forall_irep(it, components)
{
const irep_idt &name=it->get(ID_name);
if(it->find(ID_value).is_not_nil())
{
exprt &value=static_cast<exprt &>(it->add(ID_value));
typecheck_expr(value);
make_constant_index(value);
if(to_integer(value, i))
throw "failed to produce integer for enum";
}
exprt final_value(ID_constant, enum_type);
final_value.set(ID_value, integer2string(i));
symbolt symbol;
symbol.name=id2string(enum_symbol.name)+"::"+id2string(name);
symbol.base_name=name;
symbol.value.swap(final_value);
symbol.location=static_cast<const locationt &>(it->find(ID_C_location));
symbol.mode=ID_cpp;
symbol.module=module;
symbol.type=enum_type;
symbol.is_type=false;
symbol.is_macro=true;
symbolt *new_symbol;
if(symbol_table.move(symbol, new_symbol))
throw "cpp_typecheckt::typecheck_enum_body: symbol_table.move() failed";
cpp_idt &scope_identifier=
cpp_scopes.put_into_scope(*new_symbol);
scope_identifier.id_class=cpp_idt::SYMBOL;
++i;
}
}
bool clang_c_convertert::convert_character_literal(
const clang::CharacterLiteral &char_literal,
exprt &dest)
{
typet type;
if(get_type(char_literal.getType(), type))
return true;
dest =
constant_exprt(
integer2binary(char_literal.getValue(), bv_width(type)),
integer2string(char_literal.getValue()),
type);
return false;
}
exprt concatenate_array_id(
const exprt &array, const exprt &index,
const typet &type)
{
std::string a, idx, identifier;
a = array.get_string(ID_identifier);
if (index.id()==ID_typecast)
idx = index.op0().get_string(ID_value);
else
idx = index.get_string(ID_value);
mp_integer i=string2integer(idx);
identifier=a+"["+integer2string(i)+"]";
symbol_exprt new_expr(identifier, type);
return new_expr;
}
std::string fixedbvt::format(
const format_spect &format_spec) const
{
std::string dest;
unsigned fraction_bits=spec.get_fraction_bits();
mp_integer int_value=v;
mp_integer factor=power(2, fraction_bits);
if(int_value.is_negative())
{
dest+='-';
int_value.negate();
}
std::string base_10_string=
integer2string(int_value*power(10, fraction_bits)/factor);
while(base_10_string.size()<=fraction_bits)
base_10_string="0"+base_10_string;
std::string integer_part=
std::string(base_10_string, 0, base_10_string.size()-fraction_bits);
std::string fraction_part=
std::string(base_10_string, base_10_string.size()-fraction_bits);
dest+=integer_part;
// strip trailing zeros
while(!fraction_part.empty() &&
fraction_part[fraction_part.size()-1]=='0')
fraction_part.resize(fraction_part.size()-1);
if(!fraction_part.empty())
dest+="."+fraction_part;
while(dest.size()<format_spec.min_width)
dest=" "+dest;
return dest;
}
bool Writer::WriteIt(struct page_link* pl, char* p, int size) {
fstream fp;
fill_filename(*pl);
string filename("./HTMLFiles/");
filename += file;
fp.open(filename.c_str(), ios_base::out);
if (!fp.is_open()) {
#ifdef DEBUG
tp.print( "error:writer is trying to write but cannot to open it error: %s\n", strerror(errno) );
#endif
return false;
}
fp.write(p, min(strlen(p), size));
fp.flush();
sql = "insert into pages(host,file,port,date,content) values(\"";
sql += pl->_host_addr;
sql += "\",\"";
if(pl->_host_file != NULL)
sql += pl->_host_file;
sql += "\",";
sql += integer2string(pl->_portnumber);
sql += ",";
sql += sqldate;
sql += ",\"";
sql += filename;
sql += "\")";
if((mysql_query(conn, sql.c_str()))||(mysql_affected_rows(conn) <= 0))
{
printf("%s", mysql_error(conn));
return false;
}
return true;
}
void c_typecheck_baset::typecheck_custom_type(typet &type)
{
// they all have a width
exprt size_expr=
static_cast<const exprt &>(type.find(ID_size));
typecheck_expr(size_expr);
source_locationt source_location=size_expr.source_location();
make_constant_index(size_expr);
mp_integer size_int;
if(to_integer(size_expr, size_int))
{
error().source_location=source_location;
error() << "failed to convert bit vector width to constant" << eom;
throw 0;
}
if(size_int<1)
{
error().source_location=source_location;
error() << "bit vector width invalid" << eom;
throw 0;
}
type.remove(ID_size);
type.set(ID_width, integer2string(size_int));
// depending on type, there may be a number of fractional bits
if(type.id()==ID_custom_unsignedbv)
type.id(ID_unsignedbv);
else if(type.id()==ID_custom_signedbv)
type.id(ID_signedbv);
else if(type.id()==ID_custom_fixedbv)
{
type.id(ID_fixedbv);
exprt f_expr=
static_cast<const exprt &>(type.find(ID_f));
source_locationt source_location=f_expr.find_source_location();
typecheck_expr(f_expr);
make_constant_index(f_expr);
mp_integer f_int;
if(to_integer(f_expr, f_int))
{
error().source_location=source_location;
error() << "failed to convert number of fraction bits to constant" << eom;
throw 0;
}
if(f_int<0 || f_int>size_int)
{
error().source_location=source_location;
error() << "fixedbv fraction width invalid" << eom;
throw 0;
}
type.remove(ID_f);
type.set(ID_integer_bits, integer2string(size_int-f_int));
}
else if(type.id()==ID_custom_floatbv)
{
type.id(ID_floatbv);
exprt f_expr=
static_cast<const exprt &>(type.find(ID_f));
source_locationt source_location=f_expr.find_source_location();
typecheck_expr(f_expr);
make_constant_index(f_expr);
mp_integer f_int;
if(to_integer(f_expr, f_int))
{
error().source_location=source_location;
error() << "failed to convert number of fraction bits to constant" << eom;
throw 0;
}
if(f_int<1 || f_int+1>=size_int)
{
error().source_location=source_location;
error() << "floatbv fraction width invalid" << eom;
throw 0;
}
type.remove(ID_f);
type.set(ID_f, integer2string(f_int));
}
else
assert(false);
}
void range_typet::set_to(const mp_integer &to)
{
set(ID_to, integer2string(to));
}
void range_typet::set_from(const mp_integer &from)
{
set(ID_from, integer2string(from));
}
void value_sett::output(
const namespacet &ns,
std::ostream &out) const
{
for(valuest::const_iterator
v_it=values.begin();
v_it!=values.end();
v_it++)
{
irep_idt identifier, display_name;
const entryt &e=v_it->second;
if(has_prefix(id2string(e.identifier), "value_set::dynamic_object"))
{
display_name=id2string(e.identifier)+e.suffix;
identifier="";
}
else if(e.identifier=="value_set::return_value")
{
display_name="RETURN_VALUE"+e.suffix;
identifier="";
}
else
{
#if 0
const symbolt &symbol=ns.lookup(e.identifier);
display_name=symbol.display_name()+e.suffix;
identifier=symbol.name;
#else
identifier=id2string(e.identifier);
display_name=id2string(identifier)+e.suffix;
#endif
}
out << display_name;
out << " = { ";
const object_map_dt &object_map=e.object_map.read();
std::size_t width=0;
for(object_map_dt::const_iterator
o_it=object_map.begin();
o_it!=object_map.end();
o_it++)
{
const exprt &o=object_numbering[o_it->first];
std::string result;
if(o.id()==ID_invalid || o.id()==ID_unknown)
result=from_expr(ns, identifier, o);
else
{
result="<"+from_expr(ns, identifier, o)+", ";
if(o_it->second.offset_is_set)
result+=integer2string(o_it->second.offset)+"";
else
result+='*';
if(o.type().is_nil())
result+=", ?";
else
result+=", "+from_type(ns, identifier, o.type());
result+='>';
}
out << result;
width+=result.size();
object_map_dt::const_iterator next(o_it);
next++;
if(next!=object_map.end())
{
out << ", ";
if(width>=40) out << "\n ";
}
}
out << " } " << std::endl;
}
}
exprt boolbvt::bv_get_rec(
const bvt &bv,
const std::vector<bool> &unknown,
std::size_t offset,
const typet &type) const
{
if(type.id()==ID_symbol)
return bv_get_rec(bv, unknown, offset, ns.follow(type));
std::size_t width=boolbv_width(type);
assert(bv.size()==unknown.size());
assert(bv.size()>=offset+width);
if(type.id()==ID_bool)
{
if(!unknown[offset])
{
switch(prop.l_get(bv[offset]).get_value())
{
case tvt::tv_enumt::TV_FALSE:
return false_exprt();
case tvt::tv_enumt::TV_TRUE:
return true_exprt();
default:
return false_exprt(); // default
}
}
return nil_exprt();
}
bvtypet bvtype=get_bvtype(type);
if(bvtype==IS_UNKNOWN)
{
if(type.id()==ID_array)
{
const typet &subtype=type.subtype();
std::size_t sub_width=boolbv_width(subtype);
if(sub_width!=0)
{
exprt::operandst op;
op.reserve(width/sub_width);
for(std::size_t new_offset=0;
new_offset<width;
new_offset+=sub_width)
{
op.push_back(
bv_get_rec(bv, unknown, offset+new_offset, subtype));
}
exprt dest=exprt(ID_array, type);
dest.operands().swap(op);
return dest;
}
}
else if(type.id()==ID_struct_tag)
{
return bv_get_rec(bv, unknown, offset, ns.follow_tag(to_struct_tag_type(type)));
}
else if(type.id()==ID_union_tag)
{
return bv_get_rec(bv, unknown, offset, ns.follow_tag(to_union_tag_type(type)));
}
else if(type.id()==ID_struct)
{
const struct_typet &struct_type=to_struct_type(type);
const struct_typet::componentst &components=struct_type.components();
std::size_t new_offset=0;
exprt::operandst op;
op.reserve(components.size());
for(struct_typet::componentst::const_iterator
it=components.begin();
it!=components.end();
it++)
{
const typet &subtype=ns.follow(it->type());
op.push_back(nil_exprt());
std::size_t sub_width=boolbv_width(subtype);
if(sub_width!=0)
{
op.back()=bv_get_rec(bv, unknown, offset+new_offset, subtype);
new_offset+=sub_width;
}
}
struct_exprt dest(type);
dest.operands().swap(op);
return dest;
}
else if(type.id()==ID_union)
{
const union_typet &union_type=to_union_type(type);
const union_typet::componentst &components=union_type.components();
assert(!components.empty());
// Any idea that's better than just returning the first component?
std::size_t component_nr=0;
union_exprt value(union_type);
value.set_component_name(
components[component_nr].get_name());
const typet &subtype=components[component_nr].type();
value.op()=bv_get_rec(bv, unknown, offset, subtype);
return value;
}
else if(type.id()==ID_vector)
{
const typet &subtype=ns.follow(type.subtype());
std::size_t sub_width=boolbv_width(subtype);
if(sub_width!=0 && width%sub_width==0)
{
std::size_t size=width/sub_width;
exprt value(ID_vector, type);
value.operands().resize(size);
for(std::size_t i=0; i<size; i++)
value.operands()[i]=
bv_get_rec(bv, unknown, i*sub_width, subtype);
return value;
}
}
else if(type.id()==ID_complex)
{
const typet &subtype=ns.follow(type.subtype());
std::size_t sub_width=boolbv_width(subtype);
if(sub_width!=0 && width==sub_width*2)
{
exprt value(ID_complex, type);
value.operands().resize(2);
value.op0()=bv_get_rec(bv, unknown, 0*sub_width, subtype);
value.op1()=bv_get_rec(bv, unknown, 1*sub_width, subtype);
return value;
}
}
}
std::string value;
for(std::size_t bit_nr=offset; bit_nr<offset+width; bit_nr++)
{
char ch;
if(unknown[bit_nr])
ch='0';
else
switch(prop.l_get(bv[bit_nr]).get_value())
{
case tvt::tv_enumt::TV_FALSE:
ch='0';
break;
case tvt::tv_enumt::TV_TRUE:
ch='1';
break;
case tvt::tv_enumt::TV_UNKNOWN:
ch='0';
break;
default:
assert(false);
}
value=ch+value;
}
switch(bvtype)
{
case IS_UNKNOWN:
if(type.id()==ID_string)
{
mp_integer int_value=binary2integer(value, false);
irep_idt s;
if(int_value>=string_numbering.size())
s=irep_idt();
else
s=string_numbering[int_value.to_long()];
return constant_exprt(s, type);
}
break;
case IS_RANGE:
{
mp_integer int_value=binary2integer(value, false);
mp_integer from=string2integer(type.get_string(ID_from));
constant_exprt value_expr(type);
value_expr.set_value(integer2string(int_value+from));
return value_expr;
}
break;
default:
case IS_C_ENUM:
constant_exprt value_expr(type);
value_expr.set_value(value);
return value_expr;
}
return nil_exprt();
}
exprt boolbvt::bv_get_unbounded_array(const exprt &expr) const
{
// first, try to get size
const typet &type=expr.type();
const exprt &size_expr=to_array_type(type).size();
exprt size=simplify_expr(get(size_expr), ns);
// no size, give up
if(size.is_nil()) return nil_exprt();
// get the numeric value, unless it's infinity
mp_integer size_mpint;
if(size.id()!=ID_infinity)
{
if(to_integer(size, size_mpint))
return nil_exprt();
// simple sanity check
if(size_mpint<0)
return nil_exprt();
}
else
size_mpint=0;
// search array indices
typedef std::map<mp_integer, exprt> valuest;
valuest values;
{
std::size_t number;
if(arrays.get_number(expr, number))
return nil_exprt();
// get root
number=arrays.find_number(number);
assert(number<index_map.size());
index_mapt::const_iterator it=index_map.find(number);
assert(it!=index_map.end());
const index_sett &index_set=it->second;
for(index_sett::const_iterator it1=
index_set.begin();
it1!=index_set.end();
it1++)
{
index_exprt index;
index.type()=type.subtype();
index.array()=expr;
index.index()=*it1;
exprt value=bv_get_cache(index);
exprt index_value=bv_get_cache(*it1);
if(!index_value.is_nil())
{
mp_integer index_mpint;
if(!to_integer(index_value, index_mpint))
{
if(value.is_nil())
values[index_mpint]=exprt(ID_unknown, type.subtype());
else
values[index_mpint]=value;
}
}
}
}
exprt result;
if(size_mpint>100 || size.id()==ID_infinity)
{
result=exprt("array-list", type);
result.type().set(ID_size, integer2string(size_mpint));
result.operands().reserve(values.size()*2);
for(valuest::const_iterator it=values.begin();
it!=values.end();
it++)
{
exprt index=from_integer(it->first, size.type());
result.copy_to_operands(index, it->second);
}
}
else
{
// set the size
result=exprt(ID_array, type);
result.type().set(ID_size, size);
std::size_t size_int=integer2size_t(size_mpint);
// allocate operands
result.operands().resize(size_int);
for(std::size_t i=0; i<size_int; i++)
result.operands()[i]=exprt(ID_unknown);
// search uninterpreted functions
for(valuest::iterator it=values.begin();
it!=values.end();
it++)
if(it->first>=0 && it->first<size_mpint)
result.operands()[integer2size_t(it->first)].swap(it->second);
}
return result;
}
xmlt xml(
const exprt &expr,
const namespacet &ns)
{
xmlt result;
const typet &type=ns.follow(expr.type());
if(expr.id()==ID_constant)
{
if(type.id()==ID_unsignedbv ||
type.id()==ID_signedbv ||
type.id()==ID_c_bit_field)
{
std::size_t width=to_bitvector_type(type).get_width();
result.name="integer";
result.set_attribute("binary", expr.get_string(ID_value));
result.set_attribute("width", width);
const typet &underlying_type=
type.id()==ID_c_bit_field?type.subtype():
type;
bool is_signed=underlying_type.id()==ID_signedbv;
std::string sig=is_signed?"":"unsigned ";
if(width==config.ansi_c.char_width)
result.set_attribute("c_type", sig+"char");
else if(width==config.ansi_c.int_width)
result.set_attribute("c_type", sig+"int");
else if(width==config.ansi_c.short_int_width)
result.set_attribute("c_type", sig+"short int");
else if(width==config.ansi_c.long_int_width)
result.set_attribute("c_type", sig+"long int");
else if(width==config.ansi_c.long_long_int_width)
result.set_attribute("c_type", sig+"long long int");
mp_integer i;
if(!to_integer(expr, i))
result.data=integer2string(i);
}
else if(type.id()==ID_c_enum)
{
result.name="integer";
result.set_attribute("binary", expr.get_string(ID_value));
result.set_attribute("width", type.subtype().get_string(ID_width));
result.set_attribute("c_type", "enum");
mp_integer i;
if(!to_integer(expr, i))
result.data=integer2string(i);
}
else if(type.id()==ID_c_enum_tag)
{
constant_exprt tmp;
tmp.type()=ns.follow_tag(to_c_enum_tag_type(type));
tmp.set_value(to_constant_expr(expr).get_value());
return xml(tmp, ns);
}
else if(type.id()==ID_bv)
{
result.name="bitvector";
result.set_attribute("binary", expr.get_string(ID_value));
}
else if(type.id()==ID_fixedbv)
{
result.name="fixed";
result.set_attribute("width", type.get_string(ID_width));
result.set_attribute("binary", expr.get_string(ID_value));
result.data=fixedbvt(to_constant_expr(expr)).to_ansi_c_string();
}
else if(type.id()==ID_floatbv)
{
result.name="float";
result.set_attribute("width", type.get_string(ID_width));
result.set_attribute("binary", expr.get_string(ID_value));
result.data=ieee_floatt(to_constant_expr(expr)).to_ansi_c_string();
}
else if(type.id()==ID_pointer)
{
result.name="pointer";
result.set_attribute("binary", expr.get_string(ID_value));
if(expr.get(ID_value)==ID_NULL)
result.data="NULL";
}
else if(type.id()==ID_bool)
{
result.name="boolean";
result.set_attribute("binary", expr.is_true()?"1":"0");
result.data=expr.is_true()?"TRUE":"FALSE";
}
else
{
result.name="unknown";
}
}
else if(expr.id()==ID_array)
{
result.name="array";
unsigned index=0;
forall_operands(it, expr)
{
xmlt &e=result.new_element("element");
e.set_attribute("index", index);
e.new_element(xml(*it, ns));
index++;
}
xmlt xml(
const exprt &expr,
const namespacet &ns)
{
const typet &type=ns.follow(expr.type());
xmlt result;
if(expr.id()==ID_constant)
{
if(type.id()==ID_unsignedbv ||
type.id()==ID_signedbv)
{
result.name="integer";
result.set_attribute("binary", expr.get_string(ID_value));
mp_integer i;
if(!to_integer(expr, i))
result.data=integer2string(i);
}
else if(type.id()==ID_bv)
{
result.name="bitvector";
result.set_attribute("binary", expr.get_string(ID_value));
result.data=expr.get_string(ID_value);
}
else if(type.id()==ID_fixedbv)
{
result.name="fixed";
result.set_attribute("binary", expr.get_string(ID_value));
result.data=fixedbvt(to_constant_expr(expr)).to_ansi_c_string();
}
else if(type.id()==ID_floatbv)
{
result.name="float";
result.set_attribute("binary", expr.get_string(ID_value));
result.data=ieee_floatt(to_constant_expr(expr)).to_ansi_c_string();
}
else if(type.id()==ID_pointer)
{
result.name="pointer";
result.set_attribute("binary", expr.get_string(ID_value));
if(expr.get(ID_value)==ID_NULL)
result.data="NULL";
}
else if(type.id()==ID_bool)
{
result.name="boolean";
result.set_attribute("binary", expr.is_true()?"1":"0");
result.data=expr.is_true()?"TRUE":"FALSE";
}
else
{
result.name="unknown";
}
}
else if(expr.id()==ID_array)
{
result.name="array";
unsigned index=0;
forall_operands(it, expr)
{
xmlt &e=result.new_element("element");
e.set_attribute("index", index);
e.new_element(xml(*it, ns));
index++;
}
