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();
}
}
