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