TypeDesc* type_desc_create_from_java_descriptor(const char* d, ClassLoader* loader)
{
Global_Env* env = VM_Global_State::loader_env;
switch (*d)
{
case 'B': return env->bootstrap_class_loader->get_primitive_type(K_S1);
case 'C': return env->bootstrap_class_loader->get_primitive_type(K_Char);
case 'D': return env->bootstrap_class_loader->get_primitive_type(K_F8);
case 'F': return env->bootstrap_class_loader->get_primitive_type(K_F4);
case 'I': return env->bootstrap_class_loader->get_primitive_type(K_S4);
case 'J': return env->bootstrap_class_loader->get_primitive_type(K_S8);
case 'S': return env->bootstrap_class_loader->get_primitive_type(K_S2);
case 'Z': return env->bootstrap_class_loader->get_primitive_type(K_Boolean);
case 'V': return env->bootstrap_class_loader->get_primitive_type(K_Void);
case 'L':
{
const char* sn = d+1;
const char* en = sn;
while (en[0]!=';') {
en++;
}
unsigned len = (unsigned)(en-sn);
String* str = env->string_pool.lookup(sn, len);
assert(loader);
loader->LockTypesCache();
TypeDesc** tdres = loader->GetJavaTypes()->Lookup(str);
if (tdres)
{
assert (*tdres);
loader->UnlockTypesCache();
return *tdres;
}
TypeDesc* td = new TypeDesc(K_Object, NULL, NULL, str, loader, NULL);
assert(td);
loader->GetJavaTypes()->Insert(str, td);
loader->UnlockTypesCache();
return td;
}
case '[':
{
// descriptor is checked in recursion
TypeDesc* et = type_desc_create_from_java_descriptor(d+1, loader);
if( !et ) {
return NULL;
}
return et->type_desc_create_vector();
}
default:
DIE(("Bad type descriptor"));
return NULL;
}
}
void Class::setup_as_array(Global_Env* env, unsigned char num_dimensions,
bool isArrayOfPrimitives, Class* baseClass, Class* elementClass)
{
m_is_array = 1;
m_num_dimensions = (unsigned char)num_dimensions;
if(m_num_dimensions == 1) {
m_is_array_of_primitives = isArrayOfPrimitives;
} else {
m_is_array_of_primitives = false;
}
m_array_element_class = elementClass;
m_array_base_class = baseClass;
m_state = ST_Initialized;
assert(elementClass);
// insert Java field, required by spec - 'length I'
m_num_fields = 1;
m_fields = new Field[1];
m_fields[0].set(this, env->Length_String,
env->string_pool.lookup("I"), ACC_PUBLIC|ACC_FINAL);
m_fields[0].set_field_type_desc(
type_desc_create_from_java_descriptor("I", NULL));
m_fields[0].set_injected();
m_super_class.name = env->JavaLangObject_String;
m_super_class.cp_index = 0;
m_access_flags = (ACC_FINAL | ACC_ABSTRACT);
if(isArrayOfPrimitives) {
m_access_flags |= ACC_PUBLIC;
} else {
// set array access flags the same as in its base class
m_access_flags = (uint16)(m_access_flags
| (baseClass->get_access_flags()
& (ACC_PUBLIC | ACC_PRIVATE | ACC_PROTECTED)));
}
m_package = elementClass->m_package;
// array classes implement two interfaces: Cloneable and Serializable
m_superinterfaces = (Class_Super*) STD_MALLOC(2 * sizeof(Class_Super));
m_superinterfaces[0].name = env->Clonable_String;
m_superinterfaces[0].cp_index = 0;
m_superinterfaces[1].name = env->Serializable_String;
m_superinterfaces[1].cp_index = 0;
m_num_superinterfaces = 2;
}
TypeDesc* type_desc_create_from_java_class(Class* c)
{
const String* cname = c->get_name();
if(c->is_array())
return type_desc_create_from_java_descriptor(cname->bytes, c->get_class_loader());
assert(!c->is_primitive());
c->get_class_loader()->LockTypesCache();
TypeDesc** tdres = c->get_class_loader()->GetJavaTypes()->Lookup(cname);
if (tdres)
{
assert (*tdres);
c->get_class_loader()->UnlockTypesCache();
return *tdres;
}
TypeDesc* td = new TypeDesc(K_Object, NULL, NULL, cname, c->get_class_loader(), c);
assert(td);
c->get_class_loader()->GetJavaTypes()->Insert(cname, td);
c->get_class_loader()->UnlockTypesCache();
return td;
}
Type_Info_Handle type_info_create_from_java_descriptor(
Class_Loader_Handle cl, const char* typeName) {
return type_desc_create_from_java_descriptor(typeName, cl);
}
