static Class* createArrayClass(Env* env, Class* componentType) {
jint length = strlen(componentType->name);
char* desc = NULL;
if (CLASS_IS_ARRAY(componentType) || CLASS_IS_PRIMITIVE(componentType)) {
desc = rvmAllocateMemoryAtomic(env, length + 2);
if (!desc) return NULL;
desc[0] = '[';
strcat(desc, componentType->name);
} else {
desc = rvmAllocateMemoryAtomic(env, length + 4);
if (!desc) return NULL;
desc[0] = '[';
desc[1] = 'L';
strcat(desc, componentType->name);
desc[length + 2] = ';';
}
// TODO: Add clone() method.
Class* clazz = rvmAllocateClass(env, desc, java_lang_Object, componentType->classLoader,
CLASS_TYPE_ARRAY | CLASS_STATE_INITIALIZED | ACC_PUBLIC | ACC_FINAL | ACC_ABSTRACT,
sizeof(Class), sizeof(Object), sizeof(Object), 0, 0, NULL, NULL);
if (!clazz) return NULL;
clazz->componentType = componentType;
// Initialize methods to NULL to prevent rvmGetMethods() from trying to load the methods if called with this array class
clazz->_methods = NULL;
if (!rvmAddInterface(env, clazz, java_lang_Cloneable)) return NULL;
if (!rvmAddInterface(env, clazz, java_io_Serializable)) return NULL;
if (!rvmRegisterClass(env, clazz)) return NULL;
return clazz;
}
Class* rvmFindClassByDescriptor(Env* env, const char* desc, ClassLoader* classLoader) {
switch (desc[0]) {
case 'Z':
return prim_Z;
case 'B':
return prim_B;
case 'C':
return prim_C;
case 'S':
return prim_S;
case 'I':
return prim_I;
case 'J':
return prim_J;
case 'F':
return prim_F;
case 'D':
return prim_D;
case 'V':
return prim_V;
case '[':
return rvmFindClassUsingLoader(env, desc, classLoader);
}
// desc[0] == 'L'
jint length = strlen(desc);
char* className = rvmAllocateMemoryAtomic(env, length - 2 + 1);
if (!className) return NULL;
strncpy(className, &desc[1], length - 2);
return rvmFindClassUsingLoader(env, className, classLoader);
}
Object* Java_java_lang_reflect_Array_createMultiArray(Env* env, Class* cls, Class* componentType, IntArray* dimensions) {
const char* componentTypeDesc = rvmGetClassDescriptor(env, componentType);
char* desc = rvmAllocateMemoryAtomic(env, strlen(componentTypeDesc) + dimensions->length + 1);
memset(desc, '[', dimensions->length);
strcat(desc, componentTypeDesc);
Class* clazz = rvmFindClassByDescriptor(env, desc, componentType->classLoader);
return (Object*) rvmNewMultiArray(env, dimensions->length, dimensions->values, clazz);
}
Object* Java_java_lang_System_mapLibraryName0(Env* env, Class* c, Object* userLibName) {
if (!userLibName) return NULL;
char* libName = rvmGetStringUTFChars(env, userLibName);
if (!libName) return NULL;
char* result = rvmAllocateMemoryAtomic(env, strlen(libName) + strlen(DSO_PREFIX) + strlen(DSO_EXT) + 1);
if (!result) return NULL;
strcpy(result, DSO_PREFIX);
strcat(result, libName);
strcat(result, DSO_EXT);
return rvmNewStringUTF(env, result, -1);
}
static char* createClasspathFromClasspathEntries(Env* env, ClasspathEntry* first) {
jint length = 0;
ClasspathEntry* entry = first;
while (entry) {
length += strlen(entry->jarPath);
entry = entry->next;
if (entry) length++; // Make room for the :
}
char* p = rvmAllocateMemoryAtomic(env, length + 1);
if (!p) return NULL;
entry = first;
while (entry) {
strcat(p, entry->jarPath);
entry = entry->next;
if (entry) strcat(p, ":");
}
return p;
}
ObjectArray* Java_java_lang_reflect_Method_getParameterTypes(Env* env, Class* clazz, jlong methodPtr) {
Method* method = (Method*) LONG_TO_PTR(methodPtr);
jint argsCount = rvmGetParameterCount(method);
Class* array_java_lang_Class = rvmFindClassUsingLoader(env, "[Ljava/lang/Class;", NULL);
if (!array_java_lang_Class) return NULL;
ObjectArray* paramTypes = rvmNewObjectArray(env, argsCount, NULL, array_java_lang_Class, NULL);
if (!paramTypes) return NULL;
const char* desc = method->desc;
const char* s;
jint i = 0;
while ((s = rvmGetNextParameterType(&desc))) {
char* paramTypeName = rvmAllocateMemoryAtomic(env, desc - s + 1);
if (!paramTypeName) return NULL;
strncpy(paramTypeName, s, desc - s);
Class* paramType = rvmFindClassByDescriptor(env, paramTypeName, method->clazz->classLoader);
if (!paramType) return NULL;
paramTypes->values[i++] = (Object*) paramType;
}
return paramTypes;
}
jlong Java_aura_rt_VM_allocateMemoryAtomic(Env* env, Class* c, jint size) {
return PTR_TO_LONG(rvmAllocateMemoryAtomic(env, size));
}
CallStack* allocateCallStackFrames(Env* env, jint maxLength) {
return rvmAllocateMemoryAtomic(env, sizeof(CallStack) + sizeof(CallStackFrame) * maxLength);
}
void* rvmCopyMemoryAtomic(Env* env, const void* src, size_t size) {
void* dest = rvmAllocateMemoryAtomic(env, size);
if (!dest) return NULL;
memcpy(dest, src, size);
return dest;
}