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);
}
typet java_type(char t)
{
switch(t)
{
case 'i': return java_int_type();
case 'l': return java_long_type();
case 's': return java_short_type();
case 'b': return java_byte_type();
case 'c': return java_char_type();
case 'f': return java_float_type();
case 'd': return java_double_type();
case 'z': return java_boolean_type();
case 'a': return java_reference_type(void_typet());
default: assert(false);
}
}
std::string expr2javat::convert_rec(
const typet &src,
const c_qualifierst &qualifiers,
const std::string &declarator)
{
c_qualifierst new_qualifiers(qualifiers);
new_qualifiers.read(src);
const std::string d=
declarator==""?declarator:(" "+declarator);
const std::string q=
new_qualifiers.as_string();
if(src==java_int_type())
return q+"int"+d;
else if(src==java_long_type())
return q+"long"+d;
else if(src==java_short_type())
return q+"short"+d;
else if(src==java_byte_type())
return q+"byte"+d;
else if(src==java_char_type())
return q+"char"+d;
else if(src==java_float_type())
return q+"float"+d;
else if(src==java_double_type())
return q+"double"+d;
else if(src==java_boolean_type())
return q+"bool"+d;
else if(src==java_byte_type())
return q+"byte"+d;
else if(src.id()==ID_code)
{
const code_typet &code_type=to_code_type(src);
// Java doesn't really have syntax for function types,
// so we make one up, loosley inspired by the syntax
// of lamda expressions.
std::string dest="";
dest+='(';
const code_typet::parameterst ¶meters=code_type.parameters();
for(code_typet::parameterst::const_iterator
it=parameters.begin();
it!=parameters.end();
it++)
{
if(it!=parameters.begin())
dest+=", ";
dest+=convert(it->type());
}
if(code_type.has_ellipsis())
{
if(!parameters.empty()) dest+=", ";
dest+="...";
}
dest+=')';
const typet &return_type=code_type.return_type();
dest+=" -> "+convert(return_type);
return dest;
}
else
return expr2ct::convert_rec(src, qualifiers, declarator);
}
typet java_type_from_string(const std::string &src)
{
if(src.empty())
return nil_typet();
switch(src[0])
{
case '(': // function type
{
std::size_t e_pos=src.rfind(')');
if(e_pos==std::string::npos) return nil_typet();
code_typet result;
result.return_type()=
java_type_from_string(std::string(src, e_pos+1, std::string::npos));
for(std::size_t i=1; i<src.size() && src[i]!=')'; i++)
{
code_typet::parametert param;
size_t start=i;
while(i<src.size())
{
if(src[i]=='L')
{
i=src.find(';', i); // ends on ;
break;
}
else if(src[i]=='[')
i++;
else
break;
}
std::string sub_str=src.substr(start, i-start+1);
param.type()=java_type_from_string(sub_str);
if(param.type().id()==ID_symbol)
param.type()=java_reference_type(param.type());
result.parameters().push_back(param);
}
return result;
}
case '[': // array type
{
if(src.size()<=2) return nil_typet();
typet subtype=java_type_from_string(src.substr(1, std::string::npos));
return java_reference_type(java_array_type(subtype));
}
case 'F': return java_float_type();
case 'D': return java_double_type();
case 'I': return java_int_type();
case 'C': return java_char_type();
case 'Z': return java_boolean_type();
case 'V': return java_void_type();
case 'J': return java_long_type();
case 'L':
{
// ends on ;
if(src[src.size()-1]!=';') return nil_typet();
std::string identifier="java::"+src.substr(1, src.size()-2);
for(unsigned i=0; i<identifier.size(); i++)
if(identifier[i]=='/') identifier[i]='.';
reference_typet result;
result.subtype()=symbol_typet(identifier);
return result;
}
default:
return nil_typet();
}
}
void java_bytecode_parsert::rconstant_pool()
{
u2 constant_pool_count=read_u2();
if(constant_pool_count==0)
{
error() << "invalid constant_pool_count" << eom;
throw 0;
}
constant_pool.resize(constant_pool_count);
for(constant_poolt::iterator
it=constant_pool.begin();
it!=constant_pool.end();
it++)
{
// the first entry isn't used
if(it==constant_pool.begin())
continue;
it->tag=read_u1();
switch(it->tag)
{
case CONSTANT_Class:
it->ref1=read_u2();
break;
case CONSTANT_Fieldref:
case CONSTANT_Methodref:
case CONSTANT_InterfaceMethodref:
case CONSTANT_NameAndType:
case CONSTANT_InvokeDynamic:
it->ref1=read_u2();
it->ref2=read_u2();
break;
case CONSTANT_String:
case CONSTANT_MethodType:
it->ref1=read_u2();
break;
case CONSTANT_Integer:
case CONSTANT_Float:
it->number=read_u4();
break;
case CONSTANT_Long:
case CONSTANT_Double:
it->number=read_u8();
// Eight-byte constants take up two entires
// in the constant_pool table, for annoying this programmer.
if(it==constant_pool.end())
{
error() << "invalid double entry" << eom;
throw 0;
}
it++;
it->tag=0;
break;
case CONSTANT_Utf8:
{
u2 bytes=read_u2();
std::string s;
s.resize(bytes);
for(std::string::iterator s_it=s.begin(); s_it!=s.end(); s_it++)
*s_it=read_u1();
it->s=s; // hashes
}
break;
case CONSTANT_MethodHandle:
it->ref1=read_u1();
it->ref2=read_u2();
break;
default:
error() << "unknown constant pool entry (" << it->tag << ")"
<< eom;
throw 0;
}
}
// we do a bit of post-processing after we have them all
for(constant_poolt::iterator
it=constant_pool.begin();
it!=constant_pool.end();
it++)
{
// the first entry isn't used
if(it==constant_pool.begin())
continue;
switch(it->tag)
{
case CONSTANT_Class:
{
const std::string &s=id2string(pool_entry(it->ref1).s);
it->expr=type_exprt(java_classname(s));
}
break;
case CONSTANT_Fieldref:
{
const pool_entryt &nameandtype_entry=pool_entry(it->ref2);
const pool_entryt &name_entry=pool_entry(nameandtype_entry.ref1);
const pool_entryt &class_entry=pool_entry(it->ref1);
const pool_entryt &class_name_entry=pool_entry(class_entry.ref1);
typet type=type_entry(nameandtype_entry.ref2);
symbol_typet class_symbol=
java_classname(id2string(class_name_entry.s));
exprt fieldref("fieldref", type);
fieldref.set(ID_class, class_symbol.get_identifier());
fieldref.set(ID_component_name, name_entry.s);
it->expr=fieldref;
}
break;
case CONSTANT_Methodref:
case CONSTANT_InterfaceMethodref:
{
const pool_entryt &nameandtype_entry=pool_entry(it->ref2);
const pool_entryt &name_entry=pool_entry(nameandtype_entry.ref1);
const pool_entryt &class_entry=pool_entry(it->ref1);
const pool_entryt &class_name_entry=pool_entry(class_entry.ref1);
typet type=type_entry(nameandtype_entry.ref2);
symbol_typet class_symbol=
java_classname(id2string(class_name_entry.s));
irep_idt component_name=
id2string(name_entry.s)+
":"+id2string(pool_entry(nameandtype_entry.ref2).s);
irep_idt class_name=
class_symbol.get_identifier();
irep_idt identifier=
id2string(class_name)+"."+id2string(component_name);
exprt virtual_function(ID_virtual_function, type);
virtual_function.set(ID_component_name, component_name);
virtual_function.set(ID_C_class, class_name);
virtual_function.set(ID_C_base_name, name_entry.s);
virtual_function.set(ID_identifier, identifier);
it->expr=virtual_function;
}
break;
case CONSTANT_String:
{
// ldc turns these into references to java.lang.String
exprt string_literal(ID_java_string_literal);
string_literal.set(ID_value, pool_entry(it->ref1).s);
it->expr=string_literal;
}
break;
case CONSTANT_Integer:
it->expr=from_integer(it->number, java_int_type());
break;
case CONSTANT_Float:
{
ieee_floatt value(ieee_float_spect::single_precision());
value.unpack(it->number);
it->expr=value.to_expr();
}
break;
case CONSTANT_Long:
it->expr=from_integer(it->number, java_long_type());
break;
case CONSTANT_Double:
{
ieee_floatt value(ieee_float_spect::double_precision());
value.unpack(it->number);
it->expr=value.to_expr();
}
break;
case CONSTANT_NameAndType:
{
it->expr.id("nameandtype");
}
break;
case CONSTANT_MethodHandle:
{
it->expr.id("methodhandle");
}
break;
case CONSTANT_MethodType:
{
it->expr.id("methodtype");
}
break;
case CONSTANT_InvokeDynamic:
{
it->expr.id("invokedynamic");
const pool_entryt &nameandtype_entry=pool_entry(it->ref2);
typet type=type_entry(nameandtype_entry.ref2);
it->expr.type()=type;
}
break;
default:{};
}
}
}
