static int initAnnotation() {
Class *enum_cls, *map_cls, *anno_inv_cls, *obj_ary_cls;
Class *anno_ary_cls, *dbl_anno_ary_cls;
enum_cls = findSystemClass("java/lang/Enum");
map_cls = findSystemClass("java/util/HashMap");
anno_inv_cls = findSystemClass("sun/reflect/annotation/Annotation"
"InvocationHandler");
obj_ary_cls = findArrayClass("[Ljava/lang/Object;");
anno_ary_cls = findArrayClass("[Ljava/lang/annotation/Annotation;");
dbl_anno_ary_cls = findArrayClass("[[Ljava/lang/annotation/Annotation;");
if(!enum_cls || !map_cls || !anno_inv_cls || !obj_ary_cls
|| !anno_ary_cls || !dbl_anno_ary_cls)
return FALSE;
map_init_mb = findMethod(map_cls, SYMBOL(object_init), SYMBOL(___V));
map_put_mb = findMethod(map_cls, SYMBOL(put),
newUtf8("(Ljava/lang/Object;Ljava/lang/Object;)"
"Ljava/lang/Object;"));
anno_create_mb = findMethod(anno_inv_cls, newUtf8("create"),
newUtf8("(Ljava/lang/Class;Ljava/util/Map;)"
"Ljava/lang/annotation/Annotation;"));
enum_valueof_mb = findMethod(enum_cls, newUtf8("valueOf"),
newUtf8("(Ljava/lang/Class;Ljava/lang/String;)"
"Ljava/lang/Enum;"));
if(!map_init_mb || !map_put_mb || !anno_create_mb || !enum_valueof_mb) {
/* FindMethod doesn't throw an exception... */
signalException(java_lang_InternalError,
"Expected field/method doesn't exist");
return FALSE;
}
registerStaticClassRefLocked(&enum_class, enum_cls);
registerStaticClassRefLocked(&map_class, map_cls);
registerStaticClassRefLocked(&anno_inv_class, anno_inv_cls);
registerStaticClassRefLocked(&obj_array_class, obj_ary_cls);
registerStaticClassRefLocked(&anno_array_class, anno_ary_cls);
registerStaticClassRefLocked(&dbl_anno_array_class, dbl_anno_ary_cls);
return anno_inited = TRUE;
}
int main(int argc, char *argv[]) {
Class *array_class, *main_class;
Object *system_loader, *array;
MethodBlock *mb;
InitArgs args;
int class_arg;
char *cpntr;
int status;
int i;
setDefaultInitArgs(&args);
class_arg = parseCommandLine(argc, argv, &args);
args.main_stack_base = &array_class;
if(!initVM(&args)) {
printf("Could not initialise VM. Aborting.\n");
exit(1);
}
if((system_loader = getSystemClassLoader()) == NULL)
goto error;
mainThreadSetContextClassLoader(system_loader);
for(cpntr = argv[class_arg]; *cpntr; cpntr++)
if(*cpntr == '.')
*cpntr = '/';
main_class = findClassFromClassLoader(argv[class_arg], system_loader);
if(main_class != NULL)
initClass(main_class);
if(exceptionOccurred())
goto error;
mb = lookupMethod(main_class, SYMBOL(main),
SYMBOL(_array_java_lang_String__V));
if(mb == NULL || !(mb->access_flags & ACC_STATIC)) {
signalException(java_lang_NoSuchMethodError, "main");
goto error;
}
/* Create the String array holding the command line args */
i = class_arg + 1;
if((array_class = findArrayClass(SYMBOL(array_java_lang_String))) &&
(array = allocArray(array_class, argc - i, sizeof(Object*)))) {
Object **args = ARRAY_DATA(array, Object*) - i;
for(; i < argc; i++)
if(!(args[i] = Cstr2String(argv[i])))
break;
/* Call the main method */
if(i == argc)
executeStaticMethod(main_class, mb, array);
}
jobjectArray jmm_GetMemoryManagers(JNIEnv *env, jobject obj) {
Class *array_class = findArrayClass(SYMBOL(array_java_lang_String));
if(array_class == NULL)
return NULL;
return allocArray(array_class, 0, sizeof(Object*));
}
void initialiseException() {
FieldBlock *bcktrce;
int i;
ste_class = findSystemClass0(SYMBOL(java_lang_StackTraceElement));
ste_array_class = findArrayClass(SYMBOL(array_java_lang_StackTraceElement));
vmthrow_class = findSystemClass0(SYMBOL(java_lang_VMThrowable));
throw_class = findSystemClass0(SYMBOL(java_lang_Throwable));
bcktrce = findField(vmthrow_class, SYMBOL(backtrace), SYMBOL(sig_java_lang_Object));
vmthrow_init_mb = findMethod(ste_class, SYMBOL(object_init),
SYMBOL(_java_lang_String_I_java_lang_String_java_lang_String_Z__V));
if((bcktrce == NULL) || (vmthrow_init_mb == NULL)) {
jam_fprintf(stderr, "Error initialising VM (initialiseException)\n");
exitVM(1);
}
CLASS_CB(vmthrow_class)->flags |= VMTHROWABLE;
backtrace_offset = bcktrce->offset;
registerStaticClassRef(&ste_class);
registerStaticClassRef(&ste_array_class);
registerStaticClassRef(&vmthrow_class);
registerStaticClassRef(&throw_class);
/* Load and register the exceptions used within the VM.
These are preloaded to speed up access. The VM will
abort if any can't be loaded */
for(i = 0; i < MAX_EXCEPTION_ENUM; i++) {
exceptions[i] = findSystemClass0(symbol_values[exception_symbols[i]]);
registerStaticClassRef(&exceptions[i]);
}
inited = TRUE;
}
int main(int argc, char *argv[]) {
Class *array_class, *main_class;
Object *system_loader, *array;
MethodBlock *mb;
InitArgs args;
int class_arg;
char *cpntr;
int status;
int i;
setDefaultInitArgs(&args);
class_arg = parseCommandLine(argc, argv, &args);
args.main_stack_base = &array_class;
initVM(&args);
if((system_loader = getSystemClassLoader()) == NULL) {
printf("Cannot create system class loader\n");
printException();
exitVM(1);
}
mainThreadSetContextClassLoader(system_loader);
for(cpntr = argv[class_arg]; *cpntr; cpntr++)
if(*cpntr == '.')
*cpntr = '/';
if((main_class = findClassFromClassLoader(argv[class_arg], system_loader)) != NULL)
initClass(main_class);
if(exceptionOccurred()) {
printException();
exitVM(1);
}
mb = lookupMethod(main_class, SYMBOL(main), SYMBOL(_array_java_lang_String__V));
if(!mb || !(mb->access_flags & ACC_STATIC)) {
printf("Static method \"main\" not found in %s\n", argv[class_arg]);
exitVM(1);
}
/* Create the String array holding the command line args */
i = class_arg + 1;
if((array_class = findArrayClass(SYMBOL(array_java_lang_String))) &&
(array = allocArray(array_class, argc - i, sizeof(Object*)))) {
Object **args = (Object**)ARRAY_DATA(array) - i;
for(; i < argc; i++)
if(!(args[i] = Cstr2String(argv[i])))
break;
/* Call the main method */
if(i == argc)
executeStaticMethod(main_class, mb, array);
}
/* ExceptionOccurred returns the exception or NULL, which is OK
for normal conditionals, but not here... */
if((status = exceptionOccurred() ? 1 : 0))
printException();
/* Wait for all but daemon threads to die */
mainThreadWaitToExitVM();
exitVM(status);
}
Class *classlibBootPackagesArrayClass() {
return findArrayClass(SYMBOL(array_java_lang_String));
}
static int initReflection() {
Class *cls_ary_cls, *cons_ary_cls, *cons_ref_cls, *mthd_ary_cls;
Class *mthd_ref_cls, *fld_ary_cls, *fld_ref_cls, *vm_cons_cls;
Class *vm_mthd_cls, *vm_fld_cls;
FieldBlock *vm_cons_slot_fb, *vm_cons_class_fb, *vm_cons_param_fb;
FieldBlock *vm_cons_cons_fb, *vm_mthd_slot_fb, *vm_mthd_class_fb;
FieldBlock *vm_mthd_ret_fb, *vm_mthd_param_fb, *vm_mthd_m_fb;
FieldBlock *vm_fld_slot_fb, *vm_fld_class_fb, *vm_fld_type_fb;
FieldBlock *vm_fld_f_fb, *cons_cons_fb, *mthd_m_fb, *fld_f_fb;
FieldBlock *acc_flag_fb;
cls_ary_cls = findArrayClass(SYMBOL(array_java_lang_Class));
cons_ary_cls = findArrayClass(SYMBOL(array_java_lang_reflect_Constructor));
cons_ref_cls = findSystemClass(SYMBOL(java_lang_reflect_Constructor));
vm_cons_cls = findSystemClass(SYMBOL(java_lang_reflect_VMConstructor));
mthd_ary_cls = findArrayClass(SYMBOL(array_java_lang_reflect_Method));
mthd_ref_cls = findSystemClass(SYMBOL(java_lang_reflect_Method));
vm_mthd_cls = findSystemClass(SYMBOL(java_lang_reflect_VMMethod));
fld_ary_cls = findArrayClass(SYMBOL(array_java_lang_reflect_Field));
fld_ref_cls = findSystemClass(SYMBOL(java_lang_reflect_Field));
vm_fld_cls = findSystemClass(SYMBOL(java_lang_reflect_VMField));
if(!cls_ary_cls || !cons_ary_cls || !cons_ref_cls || !mthd_ary_cls
|| !mthd_ref_cls || !fld_ary_cls || !fld_ref_cls
|| !vm_cons_cls || !vm_mthd_cls || !vm_fld_cls)
return FALSE;
vm_cons_slot_fb = findField(vm_cons_cls, SYMBOL(slot), SYMBOL(I));
vm_cons_class_fb = findField(vm_cons_cls, SYMBOL(clazz),
SYMBOL(sig_java_lang_Class));
vm_cons_param_fb = findField(vm_cons_cls, SYMBOL(parameterTypes),
SYMBOL(array_java_lang_Class));
vm_cons_cons_fb = findField(vm_cons_cls, SYMBOL(cons),
SYMBOL(sig_java_lang_reflect_Constructor));
vm_mthd_slot_fb = findField(vm_mthd_cls, SYMBOL(slot), SYMBOL(I));
vm_mthd_class_fb = findField(vm_mthd_cls, SYMBOL(clazz),
SYMBOL(sig_java_lang_Class));
vm_mthd_ret_fb = findField(vm_mthd_cls, SYMBOL(returnType),
SYMBOL(sig_java_lang_Class));
vm_mthd_param_fb = findField(vm_mthd_cls, SYMBOL(parameterTypes),
SYMBOL(array_java_lang_Class));
vm_mthd_m_fb = findField(vm_mthd_cls, SYMBOL(m),
SYMBOL(sig_java_lang_reflect_Method));
vm_fld_slot_fb = findField(vm_fld_cls, SYMBOL(slot), SYMBOL(I));
vm_fld_class_fb = findField(vm_fld_cls, SYMBOL(clazz),
SYMBOL(sig_java_lang_Class));
vm_fld_type_fb = findField(vm_fld_cls, SYMBOL(type),
SYMBOL(sig_java_lang_Class));
vm_fld_f_fb = findField(vm_fld_cls, SYMBOL(f),
SYMBOL(sig_java_lang_reflect_Field));
cons_cons_fb = findField(cons_ref_cls, SYMBOL(cons),
SYMBOL(sig_java_lang_reflect_VMConstructor));
mthd_m_fb = findField(mthd_ref_cls, SYMBOL(m),
SYMBOL(sig_java_lang_reflect_VMMethod));
fld_f_fb = findField(fld_ref_cls, SYMBOL(f),
SYMBOL(sig_java_lang_reflect_VMField));
acc_flag_fb = lookupField(cons_ref_cls, SYMBOL(flag), SYMBOL(Z));
if(!vm_cons_slot_fb || !vm_cons_class_fb || !vm_cons_param_fb ||
!vm_cons_cons_fb || !vm_mthd_slot_fb || !vm_mthd_class_fb ||
!vm_mthd_ret_fb || !vm_mthd_m_fb || !vm_mthd_param_fb ||
!vm_fld_slot_fb || !vm_fld_class_fb || !vm_fld_type_fb ||
!vm_fld_f_fb || !cons_cons_fb || !mthd_m_fb ||
!fld_f_fb || !acc_flag_fb) {
/* Find Field/Method doesn't throw an exception... */
signalException(java_lang_InternalError,
"Expected reflection field doesn't exist");
return FALSE;
}
vm_cons_slot_offset = vm_cons_slot_fb->u.offset;
vm_cons_class_offset = vm_cons_class_fb->u.offset;
vm_cons_param_offset = vm_cons_param_fb->u.offset;
vm_cons_cons_offset = vm_cons_cons_fb->u.offset;
vm_mthd_slot_offset = vm_mthd_slot_fb->u.offset;
vm_mthd_class_offset = vm_mthd_class_fb->u.offset;
vm_mthd_ret_offset = vm_mthd_ret_fb->u.offset;
vm_mthd_param_offset = vm_mthd_param_fb->u.offset;
vm_mthd_m_offset = vm_mthd_m_fb->u.offset;
vm_fld_slot_offset = vm_fld_slot_fb->u.offset;
vm_fld_class_offset = vm_fld_class_fb->u.offset;
vm_fld_type_offset = vm_fld_type_fb->u.offset;
vm_fld_f_offset = vm_fld_f_fb->u.offset;
cons_cons_offset = cons_cons_fb->u.offset;
mthd_m_offset = mthd_m_fb->u.offset;
fld_f_offset = fld_f_fb->u.offset;
acc_flag_offset = acc_flag_fb->u.offset;
registerStaticClassRefLocked(&class_array_class, cls_ary_cls);
registerStaticClassRefLocked(&cons_array_class, cons_ary_cls);
registerStaticClassRefLocked(&method_array_class, mthd_ary_cls);
registerStaticClassRefLocked(&field_array_class, fld_ary_cls);
registerStaticClassRefLocked(&cons_reflect_class, cons_ref_cls);
registerStaticClassRefLocked(&vmcons_reflect_class, vm_cons_cls);
registerStaticClassRefLocked(&method_reflect_class, mthd_ref_cls);
registerStaticClassRefLocked(&vmmethod_reflect_class, vm_mthd_cls);
registerStaticClassRefLocked(&field_reflect_class, fld_ref_cls);
registerStaticClassRefLocked(&vmfield_reflect_class, vm_fld_cls);
return inited = TRUE;
}
