static jboolean getRuntimeVisibleAnnotationsIterator(Env* env, jbyte type, void* attributes, void* data) {
ObjectArray** result = (ObjectArray**) ((void**) data)[0];
Object* classLoader = (Object*) ((void**) data)[1];
if (type == RUNTIME_VISIBLE_ANNOTATIONS) {
jint length = getInt(&attributes);
ObjectArray* annotations = rvmNewObjectArray(env, length, java_lang_annotation_Annotation, NULL, NULL);
if (!annotations) return FALSE;
jint i = 0;
jint actualLength = 0;
for (i = 0; i < length; i++) {
jvalue value = {0};
if (getAnnotationValue(env, &attributes, NULL, classLoader, &value, TRUE)) {
annotations->values[actualLength++] = (Object*) value.l;
} else if (rvmExceptionCheck(env)) {
return FALSE;
}
}
if (actualLength != length) {
// One or more annotations could not be loaded due to a missing class.
// Reallocate the result array and copy over the non null values.
ObjectArray* annotations2 = rvmNewObjectArray(env, actualLength, java_lang_annotation_Annotation, NULL, NULL);
if (!annotations2) return FALSE;
memcpy(annotations2->values, annotations->values, actualLength * sizeof(Object*));
annotations = annotations2;
}
*result = annotations;
return FALSE; // Stop iterating
}
return TRUE; // Continue with next attribute
}
jboolean rvmInitAttributes(Env* env) {
java_lang_TypeNotPresentException = rvmFindClassUsingLoader(env, "java/lang/TypeNotPresentException", NULL);
if (!java_lang_TypeNotPresentException) return FALSE;
java_lang_annotation_AnnotationFormatError = rvmFindClassUsingLoader(env, "java/lang/annotation/AnnotationFormatError", NULL);
if (!java_lang_annotation_AnnotationFormatError) return FALSE;
java_lang_reflect_Method = rvmFindClassUsingLoader(env, "java/lang/reflect/Method", NULL);
if (!java_lang_reflect_Method) return FALSE;
java_lang_reflect_Method_init = rvmGetInstanceMethod(env, java_lang_reflect_Method, "<init>", "(J)V");
if (!java_lang_reflect_Method_init) return FALSE;
java_lang_annotation_Annotation = rvmFindClassUsingLoader(env, "java/lang/annotation/Annotation", NULL);
if (!java_lang_annotation_Annotation) return FALSE;
array_of_java_lang_annotation_Annotation = rvmFindClassUsingLoader(env, "[Ljava/lang/annotation/Annotation;", NULL);
if (!array_of_java_lang_annotation_Annotation) return FALSE;
Class* array_java_lang_Class = rvmFindClassUsingLoader(env, "[Ljava/lang/Class;", NULL);
if (!array_java_lang_Class) return FALSE;
emptyExceptionTypes = rvmNewObjectArray(env, 0, NULL, array_java_lang_Class, NULL);
if (!emptyExceptionTypes) return FALSE;
if (!rvmAddGlobalRef(env, (Object*) emptyExceptionTypes)) return FALSE;
emptyAnnotations = rvmNewObjectArray(env, 0, NULL, array_of_java_lang_annotation_Annotation, NULL);
if (!emptyAnnotations) return FALSE;
if (!rvmAddGlobalRef(env, (Object*) emptyAnnotations)) return FALSE;
return TRUE;
}
ObjectArray* Java_java_lang_System_robovmSpecialProperties(Env* env, Class* c) {
char* osArch = NULL;
#if defined(RVM_X86)
osArch = "os.arch=x86";
#elif defined(RVM_ARMV6) || defined(RVM_ARMV7) || defined(RVM_THUMBV6) || defined(RVM_THUMBV7)
osArch = "os.arch=arm";
#endif
#if defined(DARWIN)
char* osName = NULL;
# if defined(IOS) && defined(RVM_X86)
osName = "os.name=iOS Simulator";
# elif defined(IOS)
osName = "os.name=iOS";
# elif defined(MACOSX)
osName = "os.name=Mac OS X";
# endif
char osVersion[64];
memset(osVersion, 0, sizeof(osVersion));
strcat(osVersion, "os.version=");
readDarwinOSVersionFromSystemVersionPList(osVersion);
char userLanguage[64] = "user.language=";
char userRegion[64] = "user.region=";
char userVariant[64] = "user.variant=";
getDarwinLocaleParts(userLanguage, userRegion, userVariant);
jboolean hasLocale = strcmp(userLanguage, "user.language=") != 0;
ObjectArray* result = rvmNewObjectArray(env, hasLocale ? 6 : 3, java_lang_String, NULL, NULL);
if (!result) return NULL;
result->values[0] = rvmNewStringUTF(env, osName, -1);
if (!result->values[0]) return NULL;
result->values[1] = rvmNewStringUTF(env, osVersion, -1);
if (!result->values[1]) return NULL;
result->values[2] = rvmNewStringUTF(env, osArch, -1);
if (!result->values[2]) return NULL;
if (hasLocale) {
result->values[3] = rvmNewStringUTF(env, userLanguage, -1);
if (!result->values[3]) return NULL;
result->values[4] = rvmNewStringUTF(env, userRegion, -1);
if (!result->values[4]) return NULL;
result->values[5] = rvmNewStringUTF(env, userVariant, -1);
if (!result->values[5]) return NULL;
}
return result;
#else
ObjectArray* result = rvmNewObjectArray(env, 1, java_lang_String, NULL, NULL);
if (!result) return NULL;
result->values[0] = rvmNewStringUTF(env, osArch, -1);
if (!result->values[0]) return NULL;
return result;
#endif
}
jboolean rvmRun(Env* env) {
Options* options = env->vm->options;
Class* clazz = NULL;
rvmHookBeforeAppEntryPoint(env, options->mainClass);
clazz = rvmFindClassUsingLoader(env, options->mainClass, systemClassLoader);
if (clazz) {
Method* method = rvmGetClassMethod(env, clazz, "main", "([Ljava/lang/String;)V");
if (method) {
ObjectArray* args = rvmNewObjectArray(env, options->commandLineArgsCount, java_lang_String, NULL, NULL);
if (args) {
jint i = 0;
for (i = 0; i < args->length; i++) {
// TODO: Don't assume modified UTF-8
args->values[i] = rvmNewStringUTF(env, options->commandLineArgs[i], -1);
if (!args->values[i]) {
args = NULL;
break;
}
}
if (args) {
rvmCallVoidClassMethod(env, clazz, method, args);
}
}
}
}
return rvmDestroyVM(env->vm);
}
ObjectArray* Java_java_lang_Class_getDeclaredMethods0(Env* env, Class* clazz, jboolean publicOnly) {
if (CLASS_IS_PRIMITIVE(clazz) || CLASS_IS_ARRAY(clazz)) return NULL;
Method* methods = rvmGetMethods(env, clazz);
if (rvmExceptionCheck(env)) return NULL;
Method* method;
jint length = 0;
for (method = methods; method != NULL; method = method->next) {
if (!METHOD_IS_CONSTRUCTOR(method) && !METHOD_IS_CLASS_INITIALIZER(method)) {
if (!publicOnly || METHOD_IS_PUBLIC(method)) {
length++;
}
}
}
ObjectArray* result = NULL;
jint i = 0;
for (method = methods; method != NULL; method = method->next) {
if (!METHOD_IS_CONSTRUCTOR(method) && !METHOD_IS_CLASS_INITIALIZER(method)) {
if (!publicOnly || METHOD_IS_PUBLIC(method)) {
Object* c = createMethodObject(env, method);
if (!c) return NULL;
if (!result) {
result = rvmNewObjectArray(env, length, c->clazz, NULL, NULL);
if (!result) return NULL;
}
result->values[i++] = c;
}
}
}
return result;
}
ObjectArray* Java_java_lang_Class_getDeclaredFields0(Env* env, Class* clazz, jboolean publicOnly) {
if (CLASS_IS_PRIMITIVE(clazz) || CLASS_IS_ARRAY(clazz)) return NULL;
Field* fields = rvmGetFields(env, clazz);
if (rvmExceptionCheck(env)) return NULL;
Field* field;
jint length = 0;
for (field = fields; field != NULL; field = field->next) {
if (!publicOnly || FIELD_IS_PUBLIC(field)) {
length++;
}
}
ObjectArray* result = NULL;
jint i = 0;
for (field = fields; field != NULL; field = field->next) {
if (!publicOnly || FIELD_IS_PUBLIC(field)) {
Object* c = createFieldObject(env, field);
if (!c) return NULL;
if (!result) {
result = rvmNewObjectArray(env, length, c->clazz, NULL, NULL);
if (!result) return NULL;
}
result->values[i++] = c;
}
}
return result;
}
ObjectArray* Java_java_lang_Class_getDeclaredClasses0(Env* env, Class* clazz, jboolean publicOnly) {
if (CLASS_IS_PRIMITIVE(clazz) || CLASS_IS_ARRAY(clazz)) return NULL;
ObjectArray* result = rvmAttributeGetDeclaredClasses(env, clazz);
if (!result || result->length == 0 || !publicOnly) {
return result;
}
jint length = 0;
jint i;
for (i = 0; i < result->length; i++) {
Class* c = (Class*) result->values[i];
if (CLASS_IS_PUBLIC(c)) {
length++;
}
}
if (length == 0) return NULL;
ObjectArray* publicResult = rvmNewObjectArray(env, length, java_lang_Class, NULL, NULL);
if (!publicResult) return NULL;
jint index = 0;
for (i = 0; i < result->length; i++) {
Class* c = (Class*) result->values[i];
if (CLASS_IS_PUBLIC(c)) {
publicResult->values[index++] = (Object*) c;
}
}
return publicResult;
}
jboolean rvmRun(Env* env) {
Options* options = env->vm->options;
Class* clazz = NULL;
clazz = rvmFindClassUsingLoader(env, options->mainClass, systemClassLoader);
if (clazz) {
Method* method = rvmGetClassMethod(env, clazz, "main", "([Ljava/lang/String;)V");
if (method) {
ObjectArray* args = rvmNewObjectArray(env, options->commandLineArgsCount, java_lang_String, NULL, NULL);
if (args) {
jint i = 0;
for (i = 0; i < args->length; i++) {
// TODO: Don't assume modified UTF-8
args->values[i] = rvmNewStringUTF(env, options->commandLineArgs[i], -1);
if (!args->values[i]) {
args = NULL;
break;
}
}
if (args) rvmCallVoidClassMethod(env, clazz, method, args);
}
}
}
Object* throwable = rvmExceptionOccurred(env);
rvmDetachCurrentThread(env->vm, TRUE);
return throwable == NULL ? TRUE : FALSE;
}
ObjectArray* Java_aura_rt_VM_getStackClasses(Env* env, Class* c, jint skipNum, jint maxDepth) {
CallStack* callStack = rvmCaptureCallStack(env);
if (!callStack) return NULL;
jint index = 0;
rvmGetNextCallStackMethod(env, callStack, &index); // Skip VM.getStackClasses()
rvmGetNextCallStackMethod(env, callStack, &index); // Skip caller of VM.getStackClasses()
while (skipNum > 0) {
CallStackFrame* frame = rvmGetNextCallStackMethod(env, callStack, &index);
if (!frame) return NULL;
skipNum--;
}
jint first = index;
jint depth = 0;
while (rvmGetNextCallStackMethod(env, callStack, &index)) {
depth++;
}
if (maxDepth > -1 && maxDepth < depth) {
depth = maxDepth;
}
ObjectArray* result = rvmNewObjectArray(env, depth, java_lang_Class, NULL, NULL);
if (!result) return NULL;
jint i;
index = first;
for (i = 0; i < depth; i++) {
CallStackFrame* frame = rvmGetNextCallStackMethod(env, callStack, &index);
result->values[i] = (Object*) frame->method->clazz;
}
return result;
}
static void wrapClassNotFoundException(Env* env, const char* className) {
Object* exception = rvmExceptionOccurred(env);
if (exception && exception->clazz == java_lang_ClassNotFoundException) {
// If ClassNotFoundException is thrown we have to wrap it in a NoClassDefFoundError
exception = rvmExceptionClear(env);
Method* constructor = rvmGetInstanceMethod(env, java_lang_NoClassDefFoundError, "<init>", "(Ljava/lang/String;)V");
if (!constructor) return;
Object* message = rvmNewStringUTF(env, className, -1);
if (!message) return;
Object* wrappedException = rvmNewObject(env, java_lang_NoClassDefFoundError, constructor, message);
if (!wrappedException) return;
Class* java_lang_StackTraceElement = rvmFindClassUsingLoader(env, "java/lang/StackTraceElement", NULL);
if (!java_lang_StackTraceElement) return;
ObjectArray* stackTrace = rvmNewObjectArray(env, 0, java_lang_StackTraceElement, NULL, NULL);
if (!stackTrace) return;
Method* setStackTrace = rvmGetInstanceMethod(env, java_lang_Throwable, "setStackTrace", "([Ljava/lang/StackTraceElement;)V");
if (!setStackTrace) return;
rvmCallVoidInstanceMethod(env, wrappedException, setStackTrace, stackTrace);
if (rvmExceptionCheck(env)) return;
Method* initCause = rvmGetInstanceMethod(env, java_lang_NoClassDefFoundError, "initCause", "(Ljava/lang/Throwable;)Ljava/lang/Throwable;");
if (!initCause) return;
rvmCallObjectInstanceMethod(env, wrappedException, initCause, exception);
if (!rvmExceptionCheck(env)) rvmThrow(env, wrappedException);
}
}
jboolean rvmInitMethods(Env* env) {
if (rvmInitMutex(&nativeLibsLock) != 0) {
return FALSE;
}
if (rvmInitMutex(&threadStackTraceLock) != 0) {
return FALSE;
}
java_lang_StackTraceElement = rvmFindClassUsingLoader(env, "java/lang/StackTraceElement", NULL);
if (!java_lang_StackTraceElement) {
return FALSE;
}
java_lang_StackTraceElement_constructor = rvmGetInstanceMethod(env, java_lang_StackTraceElement, "<init>",
"(Ljava/lang/Class;Ljava/lang/String;Ljava/lang/String;I)V");
if (!java_lang_StackTraceElement_constructor) {
return FALSE;
}
empty_java_lang_StackTraceElement_array = rvmNewObjectArray(env, 0, java_lang_StackTraceElement, NULL, NULL);
if (!empty_java_lang_StackTraceElement_array) {
return FALSE;
}
if (!rvmAddObjectGCRoot(env, (Object*) empty_java_lang_StackTraceElement_array)) {
return FALSE;
}
return TRUE;
}
ObjectArray* Java_java_lang_System_robovmSpecialProperties(Env* env, Class* c) {
char* osArch = NULL;
#if defined(RVM_X86)
osArch = "os.arch=x86";
#elif defined(RVM_ARMV6) || defined(RVM_ARMV7) || defined(RVM_THUMBV6) || defined(RVM_THUMBV7)
osArch = "os.arch=arm";
#endif
#if defined(DARWIN)
char* osName = NULL;
# if defined(IOS) && defined(RVM_X86)
osName = "os.name=iOS Simulator";
# elif defined(IOS)
osName = "os.name=iOS";
# elif defined(MACOSX)
osName = "os.name=Mac OS X";
# endif
char osVersion[64];
memset(osVersion, 0, sizeof(osVersion));
strcat(osVersion, "os.version=");
readDarwinOSVersionFromSystemVersionPList(osVersion);
ObjectArray* result = rvmNewObjectArray(env, 3, java_lang_String, NULL, NULL);
if (!result) return NULL;
result->values[0] = rvmNewStringUTF(env, osName, -1);
if (!result->values[0]) return NULL;
result->values[1] = rvmNewStringUTF(env, osVersion, -1);
if (!result->values[1]) return NULL;
result->values[2] = rvmNewStringUTF(env, osArch, -1);
if (!result->values[2]) return NULL;
return result;
#else
ObjectArray* result = rvmNewObjectArray(env, 1, java_lang_String, NULL, NULL);
if (!result) return NULL;
result->values[0] = rvmNewStringUTF(env, osArch, -1);
if (!result->values[0]) return NULL;
return result;
#endif
}
ObjectArray* rvmAttributeGetDeclaredClasses(Env* env, Class* clazz) {
if (!clazz->attributes) return NULL;
jint count = 0;
void* countData[2] = {&count, clazz};
iterateInnerClasses(env, clazz->attributes, getDeclaredClassesCountIterator, countData);
if (count == 0) return NULL;
ObjectArray* result = rvmNewObjectArray(env, count, java_lang_Class, NULL, NULL);
jint index = 0;
void* data[3] = {result, &index, clazz};
iterateInnerClasses(env, clazz->attributes, getDeclaredClassesIterator, data);
return result;
}
ObjectArray* Java_aura_rt_VM_staticLibs(Env* env, Class* c) {
Options* options = env->vm->options;
if (!options->staticLibs || options->staticLibs[0] == NULL) {
return rvmNewObjectArray(env, 0, java_lang_String, NULL, NULL);
}
jint length = 0;
while (options->staticLibs[length] != NULL) {
length++;
}
ObjectArray* result = rvmNewObjectArray(env, length, java_lang_String, NULL, NULL);
if (!result) return NULL;
jint i;
for (i = 0; i < length; i++) {
Object* s = rvmNewStringUTF(env, options->staticLibs[i], -1);
if (!s) return NULL;
result->values[i] = s;
}
return result;
}
ObjectArray* Java_java_lang_Class_getInterfaces(Env* env, Class* thiz) {
Interface* interfaces = rvmGetInterfaces(env, thiz);
if (rvmExceptionCheck(env)) return NULL;
Interface* interfaze;
jint length = 0;
LL_FOREACH(interfaces, interfaze) {
length++;
}
ObjectArray* result = rvmNewObjectArray(env, length, java_lang_Class, NULL, NULL);
if (!result) return NULL;
jint i = 0;
LL_FOREACH(interfaces, interfaze) {
result->values[i++] = (Object*) interfaze->interfaze;
}
return result;
}
static ObjectArray* listClasses(Env* env, Class* instanceofClazz, ClassLoader* classLoader, void* hash) {
if (instanceofClazz && (CLASS_IS_ARRAY(instanceofClazz) || CLASS_IS_PRIMITIVE(instanceofClazz))) {
return NULL;
}
ClassInfoHeader** base = getClassInfosBase(hash);
uint32_t count = getClassInfosCount(hash);
uint32_t i = 0;
jint matches = count;
TypeInfo* instanceofTypeInfo = instanceofClazz ? instanceofClazz->typeInfo : NULL;
if (instanceofTypeInfo) {
matches = 0;
for (i = 0; i < count; i++) {
ClassInfoHeader* header = base[i];
if ((header->flags & CI_ERROR) == 0) {
if ((!CLASS_IS_INTERFACE(instanceofClazz)
&& rvmIsClassTypeInfoAssignable(env, header->typeInfo, instanceofTypeInfo))
|| (CLASS_IS_INTERFACE(instanceofClazz)
&& rvmIsInterfaceTypeInfoAssignable(env, header->typeInfo, instanceofTypeInfo))) {
matches++;
}
}
}
}
if (matches == 0) return NULL;
ObjectArray* result = rvmNewObjectArray(env, matches, java_lang_Class, NULL, NULL);
if (!result) return NULL;
jint j = 0;
for (i = 0; i < count; i++) {
ClassInfoHeader* header = base[i];
if ((header->flags & CI_ERROR) == 0) {
if (!instanceofTypeInfo || ((!CLASS_IS_INTERFACE(instanceofClazz)
&& rvmIsClassTypeInfoAssignable(env, header->typeInfo, instanceofTypeInfo))
|| (CLASS_IS_INTERFACE(instanceofClazz)
&& rvmIsInterfaceTypeInfoAssignable(env, header->typeInfo, instanceofTypeInfo)))) {
result->values[j++] = (Object*) (header->clazz ? header->clazz : createClass(env, header, classLoader));
if (rvmExceptionOccurred(env)) return NULL;
}
}
}
return result;
}
static jboolean getExceptionsIterator(Env* env, jbyte type, void* attributes, void* data) {
ObjectArray** result = (ObjectArray**) ((void**) data)[0];
Method* method = (Method*) ((void**) data)[1];
if (type == EXCEPTIONS) {
jint length = getInt(&attributes);
ObjectArray* array = rvmNewObjectArray(env, length, java_lang_Class, NULL, NULL);
if (array) {
jint i = 0;
for (i = 0; i < length; i++) {
char* className = getString(&attributes);
Class* c = rvmFindClassUsingLoader(env, className, method->clazz->classLoader);
if (!c) return FALSE;
array->values[i] = (Object*) c;
}
*result = array;
}
return FALSE; // Stop iterating
}
return TRUE; // Continue with next attribute
}
ObjectArray* rvmCallStackToStackTraceElements(Env* env, CallStack* callStack, jint first) {
if (!callStack || callStack->length == 0) {
return empty_java_lang_StackTraceElement_array;
}
// Count the number of methods
jint index = first;
jint length = 0;
while (rvmGetNextCallStackMethod(env, callStack, &index)) {
length++;
}
if (length == 0) {
return empty_java_lang_StackTraceElement_array;
}
ObjectArray* array = rvmNewObjectArray(env, length, java_lang_StackTraceElement, NULL, NULL);
if (!array) return NULL;
if (length > 0) {
jvalue args[4];
index = first;
jint i;
for (i = 0; i < length; i++) {
Method* m = rvmGetNextCallStackMethod(env, callStack, &index);
args[0].l = (jobject) m->clazz;
args[1].l = (jobject) rvmNewStringUTF(env, m->name, -1);
if (!args[1].l) return NULL;
args[2].l = (jobject) rvmAttributeGetClassSourceFile(env, m->clazz);
if (rvmExceptionOccurred(env)) {
return NULL;
}
args[3].i = METHOD_IS_NATIVE(m) ? -2 : -1; // TODO: Line numbers
array->values[i] = rvmNewObjectA(env, java_lang_StackTraceElement,
java_lang_StackTraceElement_constructor, args);
if (!array->values[i]) return NULL;
}
}
return array;
}
ObjectArray* Java_java_net_NetworkInterface_getInterfaceNames(Env* env, JClass* cls) {
if (!java_lang_String_array) {
java_lang_String_array = rvmFindClassUsingLoader(env, "[Ljava/lang/String;", NULL);
if (!java_lang_String_array) {
return NULL;
}
}
struct if_nameindex* ifs = if_nameindex();
if (!ifs) {
// Assume out of memory
rvmThrowOutOfMemoryError(env);
return NULL;
}
jint count = 0;
while (ifs[count].if_index > 0) {
count++;
}
ObjectArray* result = rvmNewObjectArray(env, count, NULL, java_lang_String_array, NULL);
if (!result) {
goto done;
}
jint i = 0;
for (i = 0; i < count; i++) {
Object* name = rvmNewStringUTF(env, ifs[i].if_name, -1);
if (!name) {
goto done;
}
result->values[i] = name;
}
done:
if_freenameindex(ifs);
return result;
}
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;
}
ObjectArray* _bcNewObjectArray(Env* env, jint length, Class* arrayClass) {
ENTER;
ObjectArray* array = rvmNewObjectArray(env, length, NULL, arrayClass, NULL);
LEAVE(array);
}
jboolean rvmRun(Env* env) {
Options* options = env->vm->options;
Class* clazz = NULL;
jboolean errorDuringSetup = FALSE;
//If our options has any properties, let's set them before we call our main.
if (options->properties) {
//First, find java.lang.System, which has the setProperty method.
clazz = rvmFindClassUsingLoader(env, "java/lang/System", NULL);
if (clazz) {
//Get the setProperty method.
Method* method = rvmGetClassMethod(env, clazz, "setProperty", "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;");
if (method) {
SystemProperty* property = options->properties;
//Go through all of our properties and add each one in turn by calling setProperty.
while (property != NULL) {
Object* key = NULL;
Object* value = NULL;
//The key is not allowed to be an empty string, so don't set it if we don't get a key.
if(property->key && strlen(property->key) > 0) {
key = rvmNewStringUTF(env, property->key, -1);
} else {
FATAL("Cannot have empty key in system property.");
errorDuringSetup = TRUE;
break;
}
if (property->value) {
value = rvmNewStringUTF(env, property->value, -1);
} else {
value = rvmNewStringUTF(env, "", -1);
}
if (key && value) {
rvmCallObjectClassMethod(env, clazz, method, key, value);
} else {
if (!key) {
FATALF("Error creating string from system property key: %s", property->key);
}
if (!value) {
FATALF("Error creating string from system property value: %s", property->value);
}
errorDuringSetup = TRUE;
break;
}
property = property->next; //Advance to the next property.
}
}
}
}
if (!errorDuringSetup) {
clazz = rvmFindClassUsingLoader(env, options->mainClass, systemClassLoader);
if (clazz) {
Method* method = rvmGetClassMethod(env, clazz, "main", "([Ljava/lang/String;)V");
if (method) {
ObjectArray* args = rvmNewObjectArray(env, options->commandLineArgsCount, java_lang_String, NULL, NULL);
if (args) {
jint i = 0;
for (i = 0; i < args->length; i++) {
// TODO: Don't assume modified UTF-8
args->values[i] = rvmNewStringUTF(env, options->commandLineArgs[i], -1);
if (!args->values[i]) {
args = NULL;
break;
}
}
if (args) rvmCallVoidClassMethod(env, clazz, method, args);
}
}
}
}
Object* throwable = rvmExceptionOccurred(env);
rvmDetachCurrentThread(env->vm, TRUE, FALSE);
rvmJoinNonDaemonThreads(env);
return throwable == NULL ? TRUE : FALSE;
}
Object* Java_java_lang_reflect_Array_createObjectArray(Env* env, Class* cls, Class* componentType, jint length) {
return (Object*) rvmNewObjectArray(env, length, componentType, NULL, NULL);
}
static jobjectArray NewObjectArray(JNIEnv* env, jsize len, jclass clazz, jobject init) {
return (jobjectArray) rvmNewObjectArray((Env*) env, len, (Class*) clazz, NULL, (Object*) init);
}
static jboolean parseArrayElementValue(Env* env, void** attributes, Class* arrayClass, Object* classLoader, jvalue* result) {
jbyte tag = getByte(attributes);
if (tag != '[') return throwFormatError(env, "Array");
Class* componentType = arrayClass->componentType;
jint length = getChar(attributes);
Array* array = NULL;
if (CLASS_IS_PRIMITIVE(componentType)) {
switch (componentType->name[0]) {
case 'Z':
array = (Array*) rvmNewBooleanArray(env, length);
break;
case 'B':
array = (Array*) rvmNewByteArray(env, length);
break;
case 'S':
array = (Array*) rvmNewShortArray(env, length);
break;
case 'C':
array = (Array*) rvmNewCharArray(env, length);
break;
case 'I':
array = (Array*) rvmNewIntArray(env, length);
break;
case 'J':
array = (Array*) rvmNewLongArray(env, length);
break;
case 'F':
array = (Array*) rvmNewFloatArray(env, length);
break;
case 'D':
array = (Array*) rvmNewDoubleArray(env, length);
break;
}
} else {
array = (Array*) rvmNewObjectArray(env, length, NULL, arrayClass, NULL);
}
if (!array) return FALSE;
jint i = 0;
for (i = 0; i < length; i++) {
jvalue v;
if (!parseElementValue(env, attributes, componentType, classLoader, &v)) return FALSE;
if (CLASS_IS_PRIMITIVE(componentType)) {
switch (componentType->name[0]) {
case 'Z':
((BooleanArray*) array)->values[i] = v.z;
break;
case 'B':
((ByteArray*) array)->values[i] = v.b;
break;
case 'S':
((ShortArray*) array)->values[i] = v.s;
break;
case 'C':
((CharArray*) array)->values[i] = v.c;
break;
case 'I':
((IntArray*) array)->values[i] = v.i;
break;
case 'J':
((LongArray*) array)->values[i] = v.j;
break;
case 'F':
((FloatArray*) array)->values[i] = v.f;
break;
case 'D':
((DoubleArray*) array)->values[i] = v.d;
break;
}
} else {
((ObjectArray*) array)->values[i] = (Object*) v.l;
}
}
result->l = (jobject) array;
return result->l ? TRUE : FALSE;
}
