void* _bcLookupInterfaceMethodImpl(Env* env, ClassInfoHeader* header, Object* thiz, uint32_t index) {
TypeInfo* typeInfo = header->typeInfo;
ITables* itables = thiz->clazz->itables;
ITable* itable = itables->cache;
if (itable->typeInfo == typeInfo) {
return itable->table.table[index];
}
uint32_t i;
for (i = 0; i < itables->count; i++) {
itable = itables->table[i];
if (itable->typeInfo == typeInfo) {
itables->cache = itable;
return itable->table.table[index];
}
}
ENTER;
initializeClass(env, header);
Class* ownerInterface = header->clazz;
char message[256];
snprintf(message, 256, "Class %s does not implement the requested interface %s",
rvmToBinaryClassName(env, thiz->clazz->name), rvmToBinaryClassName(env, ownerInterface->name));
rvmThrowIncompatibleClassChangeError(env, message);
LEAVE(NULL);
}
/**
* @brief Inicializa a JVM; Aloca memória para as estruturas principais;
Chama o carregador para a primeira classe; inicializa a primeira classe
*
* @param classHeap
* @param objectHeap
* @param stackFrame
* @param classPathF_ptr
*/
void jvmStartup(ClassFile *classHeap_ptr, Object *objectHeap_ptr, Frame *stackFrame_ptr, FILE *classPathF_ptr, dataMSize_t *dmSize_ptr){
classHeap_ptr = malloc( CLSHEAP_MAX*sizeof( ClassFile ) );
objectHeap_ptr = malloc( OBJHEAP_MAX*sizeof( Object_t ) );
stackFrame_ptr = malloc( STKFRAME_MAX*sizeof( Frame ) );
dmSize_ptr->clsHeap_size = 0;
dmSize_ptr->objHeap_size = 0;
dmSize_ptr->stkHeap_size = 0;
//Carrega a classe inicial
//OK!
loadClass(classPathF_ptr, classHeap_ptr, dmSize_ptr);
printf("\nstatic_values_size %d", classHeap_ptr->static_values_size);
for(int i = 0; i < classHeap_ptr->static_values_size; i++)
printf("\nname %s", classHeap_ptr->static_values[i].field_name);
//Checa a consistência da classe
printf("\n\nConteudo do .class");
printf("\n--------------------------------");
print_ClassFile(classHeap_ptr);
//Inicializa a classe inicial, roda clinit
//OK!
initializeClass(classHeap_ptr, stackFrame_ptr, dmSize_ptr, classHeap_ptr);
//initializeClass(classHeap_ptr, stackFrame_ptr, &dmSize_ptr->stkHeap_size); //Sei que o primeiro elemento da classHeap é a classe inicial
//Chamo o método main
callMethod(classHeap_ptr, stackFrame_ptr, dmSize_ptr, classHeap_ptr, "main", "([Ljava/lang/String;)V");
}
void* lookupInterfaceMethod(Env* env, ClassInfoHeader* header, Object* thiz, char* name, char* desc) {
initializeClass(env, header);
if (rvmExceptionCheck(env)) return NULL;
Class* ownerInterface = header->clazz;
if (!rvmIsInstanceOf(env, thiz, ownerInterface)) {
char message[256];
snprintf(message, 256, "Class %s does not implement the requested interface %s",
rvmToBinaryClassName(env, thiz->clazz->name), rvmToBinaryClassName(env, ownerInterface->name));
rvmThrowIncompatibleClassChangeError(env, message);
return NULL;
}
Method* method = rvmGetInstanceMethod(env, thiz->clazz, name, desc);
Object* throwable = rvmExceptionClear(env);
if (!method && throwable->clazz != java_lang_NoSuchMethodError) {
rvmThrow(env, throwable);
return NULL;
}
if (!method || METHOD_IS_ABSTRACT(method)) {
rvmThrowAbstractMethodError(env, ""); // TODO: Message
return NULL;
}
if (!METHOD_IS_PUBLIC(method)) {
rvmThrowIllegalAccessError(env, ""); // TODO: Message
return NULL;
}
return method->synchronizedImpl ? method->synchronizedImpl : method->impl;
}
void LSLuaState::initializeLuaTypes(const utArray<Type *>& types)
{
for (UTsize i = 0; i < types.size(); i++)
{
types[i]->cache();
}
// initialize all classes
for (UTsize i = 0; i < types.size(); i++)
{
initializeClass(types[i]);
}
// run static initializers now that all classes have been initialized
for (UTsize i = 0; i < types.size(); i++)
{
lsr_classinitializestatic(VM(), types[i]);
}
}
void Java_java_lang_Class_forName(void)
{
START_TEMPORARY_ROOTS
DECLARE_TEMPORARY_ROOT(STRING_INSTANCE, string,
topStackAsType(STRING_INSTANCE));
if (string == NULL) {
raiseException(NullPointerException);
} else {
long length = string->length;
CLASS thisClass = NULL;
DECLARE_TEMPORARY_ROOT(char*, className, mallocBytes(length + 1));
getStringContentsSafely(string, className, length + 1);
if (strchr(className, '/') == NULL) {
replaceLetters(className,'.','/');
if (verifyName(className, LegalClass, FALSE)) {
thisClass =
getClassX((CONST_CHAR_HANDLE)&className, 0, length);
/* The specification does not require that the current
* class have "access" to thisClass */
}
}
if (thisClass != NULL) {
topStackAsType(CLASS) = thisClass;
if (!IS_ARRAY_CLASS(thisClass)) {
if (!CLASS_INITIALIZED((INSTANCE_CLASS)thisClass)) {
initializeClass((INSTANCE_CLASS)thisClass);
}
}
} else {
raiseExceptionMsg("java/lang/ClassNotFoundException",
string);
}
}
END_TEMPORARY_ROOTS
}
void _bcInitializeClass(Env* env, ClassInfoHeader* header) {
ENTER;
initializeClass(env, header);
LEAVEV;
}
int Modifier::isAbstract(int mod)
{
jclass cls = initializeClass();
return (int) env->callStaticBooleanMethod(cls, _mids[mid_isAbstract], mod);
}