X-Git-Url: http://nitlanguage.org diff --git a/lib/jvm.nit b/lib/jvm.nit index 7707654..62cebe1 100644 --- a/lib/jvm.nit +++ b/lib/jvm.nit @@ -1,6 +1,7 @@ # This file is part of NIT ( http://www.nitlanguage.org ). # -# Copyright 2014 Romain Chanoir +# Copyright 2014 Romain Chanoir +# Copyright 2014 Alexis Laferrière # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -14,63 +15,23 @@ # See the License for the specific language governing permissions and # limitations under the License. -# Manipulates the Java Virtual Machine +# Java Virtual Machine services # # See: http://docs.oracle.com/javase/1.5.0/docs/guide/jni/spec/jniTOC.html module jvm is - c_compiler_option("-I $(JAVA_HOME)/include/") - c_linker_option("-L $(JNI_LIB_PATH) -ljvm") + cflags "-I $(JAVA_HOME)/include/ -I $(JAVA_HOME)/include/linux/" + ldflags "-L $(JNI_LIB_PATH) -ljvm" end in "C Header" `{ #include - -`} - -`{ - inline jvalue * convert_array_of_Object_to_c(nullable_Array_of_nullable_Object nullable_nit_array, JNIEnv* env){ - if(nullable_Array_of_nullable_Object_is_null(nullable_nit_array)){ - return NULL; - } - Array_of_nullable_Object nit_array = nullable_Array_of_nullable_Object_as_Array_of_nullable_Object(nullable_nit_array); - int nit_array_length = Array_of_nullable_Object_length(nit_array); - int i; - jvalue *c_array = malloc(sizeof(jvalue)*(nit_array_length)); - for (i = 0; i < nit_array_length; i ++) { - nullable_Object nullable_obj = Array_of_nullable_Object__index(nit_array, i); - if(nullable_Object_is_a_Int(nullable_obj)) { - int val = nullable_Object_as_Int(nullable_obj); - c_array[i].i = val; - }else if (nullable_Object_is_a_Char(nullable_obj)){ - char val = nullable_Object_as_Char(nullable_obj); - c_array[i].c = val; - }else if (nullable_Object_is_a_Bool(nullable_obj)){ - int val = nullable_Object_as_Bool(nullable_obj); - c_array[i].z = val; - }else if(nullable_Object_is_a_Float(nullable_obj)){ - float val = nullable_Object_as_Float(nullable_obj); - c_array[i].f = val; - }else if(nullable_Object_is_a_JObject(nullable_obj)){ - jobject val = nullable_Object_as_JObject(nullable_obj); - c_array[i].l = val; - }else if(nullable_Object_is_a_String(nullable_obj)){ - String val = nullable_Object_as_String(nullable_obj); - char* c = String_to_cstring(val); - jstring js = (*env)->NewStringUTF(env, c); - c_array[i].l = js; - }else { - fprintf(stderr, "NOT YET SUPPORTED: nit objects are not supported\n"); - exit(1); - } - } - return c_array; - } `} # Utility to select options to create the VM using `create_jvm` # # Usage example: -# ~~~~ +# +# ~~~~nitish # var builder = new JavaVMBuilder # builder.options.add "-Djava.class.path=." # var jvm = builder.create_jvm @@ -79,9 +40,15 @@ in "C Header" `{ class JavaVMBuilder super JniEnvRef - var version: Int = "00010002".to_hex + # Version code of the JVM requested by `create_jvm` + # + # Default at 0x00010002 + var version = 0x00010002 is writable + + # Additional option strings var options = new Array[String] + # Create the JVM and return it on success fun create_jvm: nullable JavaVM do var args = new JavaVMInitArgs @@ -108,49 +75,64 @@ class JavaVMBuilder end end -extern class JavaVMInitArgs `{ JavaVMInitArgs* `} +private extern class JavaVMInitArgs `{ JavaVMInitArgs* `} new `{ return (JavaVMInitArgs*)malloc(sizeof(JavaVMInitArgs)); `} # Set the defaut config for a VM # Can be called after setting the version - fun set_default `{ JNI_GetDefaultJavaVMInitArgs(recv); `} + # + # Unavailable on Android, where you cannot instanciate a new JVM. + fun set_default `{ + #ifndef ANDROID + JNI_GetDefaultJavaVMInitArgs(self); + #endif + `} - fun version: Int `{ return recv->version; `} - fun version=(v: Int) `{ recv->version = v; `} + fun version: Int `{ return self->version; `} + fun version=(v: Int) `{ self->version = v; `} - fun options: JavaVMOptionArray `{ return recv->options; `} - fun options=(v: JavaVMOptionArray) `{ recv->options = v; `} + fun options: JavaVMOptionArray `{ return self->options; `} + fun options=(v: JavaVMOptionArray) `{ self->options = v; `} - fun n_options: Int `{ return recv->nOptions; `} - fun n_options=(v: Int) `{ recv->nOptions = v; `} + fun n_options: Int `{ return self->nOptions; `} + fun n_options=(v: Int) `{ self->nOptions = v; `} end -extern class JavaVMOption `{ JavaVMOption* `} +private extern class JavaVMOption `{ JavaVMOption* `} fun string: String import NativeString.to_s `{ - return NativeString_to_s(recv->optionString); + return NativeString_to_s((char*)self->optionString); `} fun string=(v: String) import String.to_cstring `{ - recv->optionString = String_to_cstring(v); + self->optionString = String_to_cstring(v); `} fun extra_info: String import NativeString.to_s `{ - return NativeString_to_s(recv->extraInfo); + return NativeString_to_s((char*)self->extraInfo); `} fun extra_info=(v: String) import String.to_cstring `{ - recv->extraInfo = String_to_cstring(v); + self->extraInfo = String_to_cstring(v); `} end -extern class JavaVMOptionArray `{ JavaVMOption* `} +private extern class JavaVMOptionArray `{ JavaVMOption* `} new(size: Int) `{ return (JavaVMOption*)malloc(sizeof(JavaVMOption)*size); `} - fun [](i: Int): JavaVMOption `{ return recv+i; `} + fun [](i: Int): JavaVMOption `{ return self+i; `} end # Represents a jni JavaVM extern class JavaVM `{JavaVM *`} # Create the JVM, returns its handle and store the a pointer to JniEnv in `env_ref` - new(args: JavaVMInitArgs, env_ref: JniEnvRef) import jni_error, JniEnvRef.jni_env=, JniEnv as nullable `{ + # + # Unavailable on Android, where you cannot instanciate a new JVM. + private new(args: JavaVMInitArgs, env_ref: JniEnvRef) + import jni_error, JniEnvRef.jni_env=, JniEnv.as nullable `{ + + #ifdef ANDROID + JavaVM_jni_error(NULL, "JVM creation not supported on Android", 0); + return NULL; + #endif + JavaVM *jvm; JNIEnv *env; jint res; @@ -167,180 +149,260 @@ extern class JavaVM `{JavaVM *`} } `} - fun jni_error(msg: NativeString, v: Int) + private fun jni_error(msg: NativeString, v: Int) do print "JNI Error: {msg} ({v})" abort end - fun destroy_java_vm `{ - (*recv)->DestroyJavaVM(recv); + fun destroy `{ + (*self)->DestroyJavaVM(self); + `} + + fun env: JniEnv import jni_error `{ + JNIEnv *env; + int res = (*self)->GetEnv(self, (void **)&env, JNI_VERSION_1_6); + if (res != JNI_OK) { + JavaVM_jni_error(NULL, "Could not get JNIEnv from Java VM", res); + return NULL; + } + return env; + `} + + fun attach_current_thread: JniEnv import jni_error `{ + JNIEnv *env; + #ifdef ANDROID + // the signature is different (better actually) on Android + int res = (*self)->AttachCurrentThread(self, &env, NULL); + #else + int res = (*self)->AttachCurrentThread(self, (void**)&env, NULL); + #endif + if (res != JNI_OK) { + JavaVM_jni_error(NULL, "Could not attach current thread to Java VM", res); + return NULL; + } + return env; `} end # Represents a jni JNIEnv, which is a thread in a JavaVM extern class JniEnv `{JNIEnv *`} - + # Get a class object from its fully-qualified name or null if the class cannot be found fun find_class(class_name : String): JClass import String.to_cstring `{ - return (*recv)->FindClass(recv,String_to_cstring(class_name)); + return (*self)->FindClass(self,String_to_cstring(class_name)); `} - + # Return the method id for an instance of a class or interface # The method is determined by its name and signature # To obtain the method ID of a constructor, supply "" as the method name and "void(V)" as the return type fun get_method_id(clazz : JClass, name : String, signature : String): JMethodID import String.to_cstring `{ - return (*recv)->GetMethodID(recv, clazz, String_to_cstring(name), String_to_cstring(signature)); + return (*self)->GetMethodID(self, clazz, String_to_cstring(name), String_to_cstring(signature)); `} - + # Construct a new Java object from the `clazz`, using the constructor ̀ method_id` - fun new_object(clazz: JClass, method_id: JMethodID): JObject `{ - return (*recv)->NewObject(recv, clazz, method_id); + fun new_object(clazz: JClass, method_id: JMethodID): JavaObject `{ + return (*self)->NewObject(self, clazz, method_id); `} - + # Return the JClass of `obj` - fun get_object_class(obj: JObject): JClass `{ - return (*recv)->GetObjectClass(recv, obj); + fun get_object_class(obj: JavaObject): JClass `{ + return (*self)->GetObjectClass(self, obj); `} - # Registers native methods with the class specified by the `clazz` argument + # Registers native methods with the class specified by the `clazz` argument fun register_natives(clazz: JClass, method: JNINativeMethod, n_method : Int): Int `{ - return (*recv)->RegisterNatives(recv, clazz, method, n_method); + return (*self)->RegisterNatives(self, clazz, method, n_method); `} # Call a method on `obj` designed by `method_id` with an array `args` of arguments - fun call_void_method(obj: JObject, method_id: JMethodID, args: nullable Array[nullable Object]) import Array[nullable Object] as not nullable, Array[nullable Object].[], Array[nullable Object].length, nullable Object.as(Int), nullable Object.as(Char), nullable Object.as(Bool), nullable Object.as(Float), nullable Object.as(JObject), nullable Object.as(String), String.to_cstring `{ - jvalue * args_tab = convert_array_of_Object_to_c(args, recv); - (*recv)->CallVoidMethodA(recv, obj, method_id, args_tab); + fun call_void_method(obj: JavaObject, method_id: JMethodID, args: nullable Array[nullable Object]) import convert_args_to_jni `{ + jvalue * args_tab = JniEnv_convert_args_to_jni(self, args); + (*self)->CallVoidMethodA(self, obj, method_id, args_tab); free(args_tab); `} - - # Call a method on `obj` designed by `method_id` with an array `args` of argument returning a JObject - fun call_object_method(obj: JObject, method_id: JMethodID, args: nullable Array[nullable Object]): JObject import Array[nullable Object] as not nullable, Array[nullable Object].[], Array[nullable Object].length, nullable Object.as(Int), nullable Object.as(Char), nullable Object.as(Bool), nullable Object.as(Float), nullable Object.as(JObject), nullable Object.as(String), String.to_cstring `{ - jvalue * args_tab = convert_array_of_Object_to_c(args, recv); - (*recv)->CallObjectMethod(recv, obj, method_id, args_tab); + + # Call a method on `obj` designed by `method_id` with an array `args` of argument returning a JavaObject + fun call_object_method(obj: JavaObject, method_id: JMethodID, args: nullable Array[nullable Object]): JavaObject import convert_args_to_jni `{ + jvalue * args_tab = JniEnv_convert_args_to_jni(self, args); + jobject res = (*self)->CallObjectMethod(self, obj, method_id, args_tab); free(args_tab); + return res; `} - + # Call a method on `obj` designed by `method_id` with an array `args` of arguments returning a Bool - fun call_boolean_method(obj: JObject, method_id: JMethodID, args: nullable Array[nullable Object]): Bool import Array[nullable Object] as not nullable, Array[nullable Object].[], Array[nullable Object].length, nullable Object.as(Int), nullable Object.as(Char), nullable Object.as(Bool), nullable Object.as(Float), nullable Object.as(JObject), nullable Object.as(String), String.to_cstring `{ - jvalue * args_tab = convert_array_of_Object_to_c(args, recv); - return (*recv)->CallBooleanMethod(recv, obj, method_id, args_tab); + fun call_boolean_method(obj: JavaObject, method_id: JMethodID, args: nullable Array[nullable Object]): Bool import convert_args_to_jni `{ + jvalue * args_tab = JniEnv_convert_args_to_jni(self, args); + jboolean res = (*self)->CallBooleanMethod(self, obj, method_id, args_tab); free(args_tab); + return res; `} # Call a method on `obj` designed by `method_id` with an array `args` of arguments returning a Char - fun call_char_method(obj: JObject, method_id: JMethodID, args: nullable Array[nullable Object]): Char import Array[nullable Object] as not nullable, Array[nullable Object].[], Array[nullable Object].length, nullable Object.as(Int), nullable Object.as(Char), nullable Object.as(Bool), nullable Object.as(Float), nullable Object.as(JObject), nullable Object.as(String), String.to_cstring `{ - jvalue * args_tab = convert_array_of_Object_to_c(args, recv); - return (*recv)->CallCharMethod(recv, obj, method_id, args_tab); + fun call_char_method(obj: JavaObject, method_id: JMethodID, args: nullable Array[nullable Object]): Char import convert_args_to_jni `{ + jvalue * args_tab = JniEnv_convert_args_to_jni(self, args); + jchar res = (*self)->CallCharMethod(self, obj, method_id, args_tab); free(args_tab); + return res; `} # Call a method on `obj` designed by `method_id` with an array `args` of arguments returning an Int - fun call_int_method(obj: JObject, method_id: JMethodID, args: nullable Array[nullable Object]): Int import Array[nullable Object] as not nullable, Array[nullable Object].[], Array[nullable Object].length, nullable Object.as(Int), nullable Object.as(Char), nullable Object.as(Bool), nullable Object.as(Float), nullable Object.as(JObject), nullable Object.as(String), String.to_cstring `{ - jvalue * args_tab = convert_array_of_Object_to_c(args, recv); - return (*recv)->CallIntMethod(recv, obj, method_id, args_tab); + fun call_int_method(obj: JavaObject, method_id: JMethodID, args: nullable Array[nullable Object]): Int import convert_args_to_jni `{ + jvalue * args_tab = JniEnv_convert_args_to_jni(self, args); + jint res = (*self)->CallIntMethod(self, obj, method_id, args_tab); free(args_tab); + return res; `} - + # Call a method on `obj` designed by `method_id` with an array `args` of arguments returning a Float - fun call_float_method(obj: JObject, method_id: JMethodID, args: nullable Array[nullable Object]): Float import Array[nullable Object] as not nullable, Array[nullable Object].[], Array[nullable Object].length, nullable Object.as(Int), nullable Object.as(Char), nullable Object.as(Bool), nullable Object.as(Float), nullable Object.as(JObject), nullable Object.as(String), String.to_cstring `{ - jvalue * args_tab = convert_array_of_Object_to_c(args, recv); - return (*recv)->CallFloatMethod(recv, obj, method_id, args_tab); + fun call_float_method(obj: JavaObject, method_id: JMethodID, args: nullable Array[nullable Object]): Float import convert_args_to_jni `{ + jvalue * args_tab = JniEnv_convert_args_to_jni(self, args); + jfloat res = (*self)->CallFloatMethod(self, obj, method_id, args_tab); free(args_tab); + return res; `} # Call a method on `obj` designed by `method_id` with an array `args` of arguments returning a NativeString - fun call_string_method(obj: JObject, method_id: JMethodID, args: nullable Array[nullable Object]): NativeString import Array[nullable Object] as not nullable, Array[nullable Object].[], Array[nullable Object].length, nullable Object.as(Int), nullable Object.as(Char), nullable Object.as(Bool), nullable Object.as(Float), nullable Object.as(JObject), nullable Object.as(String), String.to_cstring, String.length `{ - jvalue * args_tab = convert_array_of_Object_to_c(args, recv); - jobject jobj = (*recv)->CallObjectMethod(recv, obj, method_id, args_tab); + fun call_string_method(obj: JavaObject, method_id: JMethodID, args: nullable Array[nullable Object]): NativeString import convert_args_to_jni `{ + jvalue * args_tab = JniEnv_convert_args_to_jni(self, args); + jobject jobj = (*self)->CallObjectMethod(self, obj, method_id, args_tab); free(args_tab); - return (char*)(*recv)->GetStringUTFChars(recv, (jstring)jobj, NULL); + return (char*)(*self)->GetStringUTFChars(self, (jstring)jobj, NULL); + `} + + private fun convert_args_to_jni(args: nullable Array[nullable Object]): Pointer import Array[nullable Object].as not nullable, Array[nullable Object].[], Array[nullable Object].length, nullable Object.as(Int), nullable Object.as(Char), nullable Object.as(Bool), nullable Object.as(Float), nullable Object.as(JavaObject), nullable Object.as(String), String.to_cstring, String.length `{ + if(nullable_Array_of_nullable_Object_is_null(args)){ + return NULL; + } + Array_of_nullable_Object nit_array = nullable_Array_of_nullable_Object_as_Array_of_nullable_Object(args); + int nit_array_length = Array_of_nullable_Object_length(nit_array); + int i; + jvalue *c_array = malloc(sizeof(jvalue)*(nit_array_length)); + for (i = 0; i < nit_array_length; i ++) { + nullable_Object nullable_obj = Array_of_nullable_Object__index(nit_array, i); + if(nullable_Object_is_a_Int(nullable_obj)) { + int val = nullable_Object_as_Int(nullable_obj); + c_array[i].i = val; + } else if (nullable_Object_is_a_Char(nullable_obj)){ + char val = nullable_Object_as_Char(nullable_obj); + c_array[i].c = val; + } else if (nullable_Object_is_a_Bool(nullable_obj)){ + int val = nullable_Object_as_Bool(nullable_obj); + c_array[i].z = val; + } else if(nullable_Object_is_a_Float(nullable_obj)){ + float val = nullable_Object_as_Float(nullable_obj); + c_array[i].f = val; + } else if(nullable_Object_is_a_JavaObject(nullable_obj)){ + jobject val = nullable_Object_as_JavaObject(nullable_obj); + c_array[i].l = val; + } else if(nullable_Object_is_a_String(nullable_obj)){ + String val = nullable_Object_as_String(nullable_obj); + char* c = String_to_cstring(val); + jstring js = (*self)->NewStringUTF(self, c); + c_array[i].l = js; + } else { + fprintf(stderr, "NOT YET SUPPORTED: nit objects are not supported\n"); + exit(1); + } + } + return c_array; `} # Returns the field ID for an instance field of a class. The field is specified by its name and signature fun get_field_id(clazz: JClass, name: String, sign: String): JFieldID import String.to_cstring `{ - return (*recv)->GetFieldID(recv, clazz, String_to_cstring(name), String_to_cstring(sign)); + return (*self)->GetFieldID(self, clazz, String_to_cstring(name), String_to_cstring(sign)); `} - + # returns the value of an instance (nonstatic) field of an object. The field to access is specified by a field ID obtained by calling get_field_id() - fun get_object_field(obj: JObject, fieldID: JFieldID): JObject `{ - return (*recv)->GetObjectField(recv, obj, fieldID); + fun get_object_field(obj: JavaObject, fieldID: JFieldID): JavaObject `{ + return (*self)->GetObjectField(self, obj, fieldID); `} - fun get_boolean_field(obj: JObject, fieldID: JFieldID): Bool `{ - return (*recv)->GetBooleanField(recv, obj, fieldID); + fun get_boolean_field(obj: JavaObject, fieldID: JFieldID): Bool `{ + return (*self)->GetBooleanField(self, obj, fieldID); `} - - fun get_char_field(obj: JObject, fieldID: JFieldID): Char `{ - return (*recv)->GetCharField(recv, obj, fieldID); + + fun get_char_field(obj: JavaObject, fieldID: JFieldID): Char `{ + return (*self)->GetCharField(self, obj, fieldID); `} - fun get_int_field(obj: JObject, fieldID: JFieldID): Int `{ - return (*recv)->GetIntField(recv, obj, fieldID); + fun get_int_field(obj: JavaObject, fieldID: JFieldID): Int `{ + return (*self)->GetIntField(self, obj, fieldID); `} - fun get_float_field(obj: JObject, fieldID: JFieldID): Float `{ - return (*recv)->GetFloatField(recv, obj, fieldID); + fun get_float_field(obj: JavaObject, fieldID: JFieldID): Float `{ + return (*self)->GetFloatField(self, obj, fieldID); `} - fun set_object_field(obj: JObject, fieldID: JFieldID, value: JObject) `{ - (*recv)->SetObjectField(recv, obj, fieldID, value); + fun set_object_field(obj: JavaObject, fieldID: JFieldID, value: JavaObject) `{ + (*self)->SetObjectField(self, obj, fieldID, value); `} - fun set_boolean_field(obj: JObject, fieldID: JFieldID, value: Bool) `{ - (*recv)->SetBooleanField(recv, obj, fieldID, value); + fun set_boolean_field(obj: JavaObject, fieldID: JFieldID, value: Bool) `{ + (*self)->SetBooleanField(self, obj, fieldID, value); `} - fun set_char_field(obj: JObject, fieldID: JFieldID, value: Char) `{ - (*recv)->SetCharField(recv, obj, fieldID, value); + fun set_char_field(obj: JavaObject, fieldID: JFieldID, value: Char) `{ + (*self)->SetCharField(self, obj, fieldID, value); `} - fun set_int_field(obj: JObject, fieldID: JFieldID, value: Int) `{ - (*recv)->SetIntField(recv, obj, fieldID, value); - `} + fun set_int_field(obj: JavaObject, fieldID: JFieldID, value: Int) `{ + (*self)->SetIntField(self, obj, fieldID, value); + `} - fun set_float_field(obj: JObject, fieldID: JFieldID, value: Float) `{ - (*recv)->SetFloatField(recv, obj, fieldID, value); + fun set_float_field(obj: JavaObject, fieldID: JFieldID, value: Float) `{ + (*self)->SetFloatField(self, obj, fieldID, value); `} - + # Check for pending exception without creating a local reference to the exception object fun exception_check: Bool `{ - return (*recv)->ExceptionCheck(recv); + return (*self)->ExceptionCheck(self); `} # Construct an exception object from the specified class with the message specified by `message` and causes that exception to be thrown fun throw_new(clazz: JClass, message: String): Int import String.to_cstring `{ - return (*recv)->ThrowNew(recv, clazz, String_to_cstring(message)); + return (*self)->ThrowNew(self, clazz, String_to_cstring(message)); `} # return the exception if there is one in the process of being thrown, or NULL if no exception is currently being thrown - fun exception_occurred: JObject `{ - return (*recv)->ExceptionOccurred(recv); + fun exception_occurred: JavaObject `{ + return (*self)->ExceptionOccurred(self); `} # prints an exception and backtrace to error channel fun exception_describe `{ - return (*recv)->ExceptionDescribe(recv); + return (*self)->ExceptionDescribe(self); `} # clears any exception currently being thrown, has no effect if there is no exception fun exception_clear `{ - return (*recv)->ExceptionClear(recv); + return (*self)->ExceptionClear(self); `} - + # Raise a fatal error fun fatal_error(msg: String) import String.to_cstring `{ - (*recv)->FatalError(recv, String_to_cstring(msg)); + (*self)->FatalError(self, String_to_cstring(msg)); `} - # Transform a NIT String into a JObject - fun string_to_jobject(string: String): JObject `{ - return (*recv)->NewStringUTF(recv, String_to_cstring(string)); + # Transform a NIT String into a JavaObject + fun string_to_jobject(string: String): JavaObject `{ + return (*self)->NewStringUTF(self, String_to_cstring(string)); + `} + + # Pushes a local reference frame on the JNI stack + fun push_local_frame(capacity: Int): Bool `{ + return (*self)->PushLocalFrame(self, capacity); + `} + + # Pops the current local reference frame on the JNI stack + # + # Similiar to `JavaObject::pop_from_local_frame` which returns a value. + fun pop_local_frame `{ + (*self)->PopLocalFrame(self, NULL); `} end -# used to initialize a JavaVM +# used to initialize a JavaVM class JniEnvRef var jni_env: nullable JniEnv = null end @@ -354,25 +416,25 @@ extern class JMethodID `{jmethodID`} end # Represens a jni jobject -extern class JObject `{jobject`} +extern class JavaObject in "Java" `{ java.lang.Object `} end # Represents a jni JNINNativeMethod extern class JNINativeMethod `{ JNINativeMethod* `} fun name: String import NativeString.to_s `{ - return NativeString_to_s(recv->name); + return NativeString_to_s((void*)self->name); `} fun name=(name: String) import String.to_cstring `{ - recv->name = String_to_cstring(name); + self->name = String_to_cstring(name); `} fun signature: String import NativeString.to_s `{ - return NativeString_to_s(recv->signature); + return NativeString_to_s((void*)self->signature); `} fun signature=(signature: String) import String.to_cstring `{ - recv->signature = String_to_cstring(signature); + self->signature = String_to_cstring(signature); `} end @@ -384,50 +446,50 @@ end extern class JValue `{jvalue`} fun set_boolean(b: Bool) `{ - recv.z = b; + self.z = b; `} fun get_boolean:Bool `{ - return recv.z; + return self.z; `} - + fun set_char(c: Char)`{ - recv.c = c; + self.c = c; `} - + fun get_char: Char `{ - return recv.c; + return self.c; `} fun set_int(i: Int) `{ - recv.i = i; + self.i = i; `} fun get_int: Int `{ - return recv.i; + return self.i; `} fun set_float(f: Float) `{ - recv.f = f; + self.f = f; `} fun get_float: Float `{ - return recv.f; + return self.f; `} - fun set_jobject(obj: JObject) `{ - recv.l = obj; + fun set_jobject(obj: JavaObject) `{ + self.l = obj; `} - fun get_jobject: JObject `{ - return recv.l; + fun get_jobject: JavaObject `{ + return self.l; `} end redef class Int redef fun to_jvalue(env): JValue `{ jvalue value; - value.i = recv; + value.i = self; return value; `} end @@ -435,7 +497,7 @@ end redef class Float redef fun to_jvalue(env): JValue `{ jvalue value; - value.f = recv; + value.f = self; return value; `} end @@ -443,7 +505,7 @@ end redef class Bool redef fun to_jvalue(env): JValue `{ jvalue value; - value.z = recv; + value.z = self; return value; `} end @@ -451,7 +513,7 @@ end redef class NativeString redef fun to_jvalue(env)`{ jvalue value; - value.l = (*env)->NewStringUTF(env, recv); + value.l = (*env)->NewStringUTF(env, self); return value; `} end