Martin Platter
Christian Thalinger
- $Id: jni.c 3409 2005-10-12 11:28:23Z twisti $
+ $Id: jni.c 4123 2006-01-10 20:46:50Z twisti $
*/
+#include "config.h"
+
#include <assert.h>
#include <string.h>
-#include "config.h"
+#include "vm/types.h"
#include "mm/boehm.h"
#include "mm/memory.h"
#include "vm/resolve.h"
#include "vm/statistics.h"
#include "vm/stringlocal.h"
-#include "vm/tables.h"
#include "vm/jit/asmpart.h"
#include "vm/jit/jit.h"
#include "vm/statistics.h"
/* direct buffer stuff ********************************************************/
-static utf *utf_java_nio_DirectByteBufferImpl;
+static utf *utf_java_nio_DirectByteBufferImpl_ReadWrite;
#if SIZEOF_VOID_P == 8
static utf *utf_gnu_classpath_Pointer64;
#else
static utf *utf_gnu_classpath_Pointer32;
#endif
-static classinfo *class_java_nio_DirectByteBufferImpl;
+static classinfo *class_java_nio_DirectByteBufferImpl_ReadWrite;
#if SIZEOF_VOID_P == 8
static classinfo *class_gnu_classpath_Pointer64;
#else
static classinfo *class_gnu_classpath_Pointer32;
#endif
+static methodinfo *dbbirw_init;
-/* local reference table ******************************************************/
-#if defined(USE_THREADS)
-#define LOCALREFTABLE (THREADINFO->_localref_table)
-#else
-#define LOCALREFTABLE (_no_threads_localref_table)
-#endif
+/* local reference table ******************************************************/
#if !defined(USE_THREADS)
-static localref_table *_no_threads_localref_table;
+localref_table *_no_threads_localref_table;
#endif
-/********************* accessing instance-fields **********************************/
+/* accessing instance fields macros *******************************************/
-#define setField(obj,typ,var,val) *((typ*) ((long int) obj + (long int) var->offset))=val;
-#define getField(obj,typ,var) *((typ*) ((long int) obj + (long int) var->offset))
-#define setfield_critical(clazz,obj,name,sig,jdatatype,val) \
- setField(obj, jdatatype, getFieldID_critical(env,clazz,name,sig), val);
+#define SET_FIELD(obj,type,var,value) \
+ *((type *) ((ptrint) (obj) + (ptrint) (var)->offset)) = (type) (value)
+
+#define GET_FIELD(obj,type,var) \
+ *((type *) ((ptrint) (obj) + (ptrint) (var)->offset))
/* some forward declarations **************************************************/
/* direct buffer stuff */
- utf_java_nio_DirectByteBufferImpl =
- utf_new_char("java/nio/DirectByteBufferImpl");
+ utf_java_nio_DirectByteBufferImpl_ReadWrite =
+ utf_new_char("java/nio/DirectByteBufferImpl$ReadWrite");
+
+ if (!(class_java_nio_DirectByteBufferImpl_ReadWrite =
+ load_class_bootstrap(utf_java_nio_DirectByteBufferImpl_ReadWrite)))
+ return false;
- if (!(class_java_nio_DirectByteBufferImpl =
- load_class_bootstrap(utf_java_nio_DirectByteBufferImpl)))
+ if (!link_class(class_java_nio_DirectByteBufferImpl_ReadWrite))
return false;
- if (!link_class(class_java_nio_DirectByteBufferImpl))
+ if (!(dbbirw_init =
+ class_resolvemethod(class_java_nio_DirectByteBufferImpl_ReadWrite,
+ utf_init,
+ utf_new_char("(Ljava/lang/Object;Lgnu/classpath/Pointer;III)V"))))
return false;
#if SIZEOF_VOID_P == 8
if (params->data[j] != 0) {
if (paramtypes->arraydim > 0) {
- if (!builtin_arrayinstanceof(params->data[j], c->vftbl))
+ if (!builtin_arrayinstanceof(params->data[j], c))
goto illegal_arg;
} else {
return true;
illegal_arg:
- *exceptionptr = new_exception(string_java_lang_IllegalArgumentException);
+ exceptions_throw_illegalargumentexception();
return false;
}
fill_callblock_from_vargs(obj, methodID->parseddesc, blk, args, TYPE_ADR);
- STATS(jnicallXmethodnvokation();)
+ STATISTICS(jnicallXmethodnvokation());
ret = asm_calljavafunction2(methodID,
argcount,
jni_callblock *blk;
jint ret;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
/*
log_text("JNI-Call: CallObjectMethodV");
fill_callblock_from_vargs(obj, methodID->parseddesc, blk, args, retType);
- STATS(jnicallXmethodnvokation();)
+ STATISTICS(jnicallXmethodnvokation());
ret = asm_calljavafunction2int(methodID,
argcount,
jni_callblock *blk;
jlong ret;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (methodID == 0) {
*exceptionptr = new_exception(string_java_lang_NoSuchMethodError);
fill_callblock_from_vargs(obj, methodID->parseddesc, blk, args, TYPE_LNG);
- STATS(jnicallXmethodnvokation();)
+ STATISTICS(jnicallXmethodnvokation());
ret = asm_calljavafunction2long(methodID,
argcount,
jni_callblock *blk;
jdouble ret;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
assert(0);
fill_callblock_from_vargs(obj, methodID->parseddesc, blk, args, retType);
/* printf("parameter: obj: %p",blk[0].item); */
- STATS(jnicallXmethodnvokation();)
+
+ STATISTICS(jnicallXmethodnvokation());
+
ret = asm_calljavafunction2double(methodID,
argcount + 1,
(argcount + 1) * sizeof(jni_callblock),
paramcount = m->parseddesc->paramcount;
+/* #error XXX does not work on intrp, but on JIT */
if (!(m->flags & ACC_STATIC))
paramcount++;
fill_callblock_from_vargs(obj, m->parseddesc, blk, ap, TYPE_VOID);
- STATS(jnicallXmethodnvokation();)
+ STATISTICS(jnicallXmethodnvokation());
(void) asm_calljavafunction2(m,
paramcount,
jint GetVersion(JNIEnv *env)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
/* we support JNI 1.4 */
java_bytearray *ba;
jclass c;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
cl = (java_lang_ClassLoader *) loader;
s = javastring_new_char(name);
c = (jclass) Java_java_lang_VMClassLoader_defineClass(env, NULL, cl, s, ba,
0, bufLen, NULL);
- return c;
+ return (jclass) NewLocalRef(env, (jobject) c);
}
classinfo *c;
java_objectheader *cl;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
u = utf_new_char_classname((char *) name);
if (!link_class(c))
return NULL;
- if (!use_class_as_object(c))
- return NULL;
-
return (jclass) NewLocalRef(env, (jobject) c);
}
classinfo *c;
s4 slot;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (method == NULL)
return NULL;
jclass GetSuperclass(JNIEnv *env, jclass sub)
{
classinfo *c;
- STATS(jniinvokation();)
+
+ STATISTICS(jniinvokation());
c = ((classinfo *) sub)->super.cls;
if (!c)
return NULL;
- use_class_as_object(c);
-
- return c;
+ return (jclass) NewLocalRef(env, (jobject) c);
}
jboolean IsAssignableFrom(JNIEnv *env, jclass sub, jclass sup)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
+
return Java_java_lang_VMClass_isAssignableFrom(env,
NULL,
(java_lang_Class *) sup,
}
-/***** converts a field ID derived from cls to a java.lang.reflect.Field object ***/
-
-jobject ToReflectedField(JNIEnv* env, jclass cls, jfieldID fieldID, jboolean isStatic)
-{
- log_text("JNI-Call: ToReflectedField: IMPLEMENT ME!!!");
- STATS(jniinvokation();)
- return NULL;
-}
-
-
/* Throw ***********************************************************************
Causes a java.lang.Throwable object to be thrown.
jint Throw(JNIEnv *env, jthrowable obj)
{
+ STATISTICS(jniinvokation());
+
*exceptionptr = (java_objectheader *) obj;
- STATS(jniinvokation();)
return JNI_OK;
}
{
java_lang_Throwable *o;
java_lang_String *s;
- STATS(jniinvokation();)
+
+ STATISTICS(jniinvokation());
s = (java_lang_String *) javastring_new_char(msg);
{
java_objectheader *e;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
e = *exceptionptr;
{
java_objectheader *e;
methodinfo *m;
- STATS(jniinvokation();)
+
+ STATISTICS(jniinvokation());
e = *exceptionptr;
void ExceptionClear(JNIEnv *env)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
*exceptionptr = NULL;
}
void FatalError(JNIEnv *env, const char *msg)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
throw_cacao_exception_exit(string_java_lang_InternalError, msg);
}
jint PushLocalFrame(JNIEnv* env, jint capacity)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
log_text("JNI-Call: PushLocalFrame: IMPLEMENT ME!");
jobject PopLocalFrame(JNIEnv* env, jobject result)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
log_text("JNI-Call: PopLocalFrame: IMPLEMENT ME!");
localref_table *lrt;
s4 i;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
o = (java_objectheader *) localRef;
jboolean IsSameObject(JNIEnv *env, jobject ref1, jobject ref2)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (ref1 == ref2)
return JNI_TRUE;
localref_table *lrt;
s4 i;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (ref == NULL)
return NULL;
/* should not happen, just to be sure */
assert(0);
+
+ /* keep compiler happy */
+
+ return NULL;
}
{
localref_table *lrt;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
/* get local reference table (thread specific) */
{
java_objectheader *o;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if ((clazz->flags & ACC_INTERFACE) || (clazz->flags & ACC_ABSTRACT)) {
*exceptionptr =
java_objectheader *o;
va_list ap;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
/* create object */
jobject NewObjectV(JNIEnv* env, jclass clazz, jmethodID methodID, va_list args)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
log_text("JNI-Call: NewObjectV: IMPLEMENT ME!");
jobject NewObjectA(JNIEnv* env, jclass clazz, jmethodID methodID, jvalue *args)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
log_text("JNI-Call: NewObjectA: IMPLEMENT ME!");
jclass GetObjectClass(JNIEnv *env, jobject obj)
{
classinfo *c;
- STATS(jniinvokation();)
+
+ STATISTICS(jniinvokation());
if (!obj || !obj->vftbl)
return NULL;
c = obj->vftbl->class;
- use_class_as_object(c);
- return c;
+
+ return (jclass) NewLocalRef(env, (jobject) c);
}
jboolean IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
return Java_java_lang_VMClass_isInstance(env,
NULL,
java_lang_reflect_Field *f;
classinfo *c;
jfieldID fid; /* the JNI-fieldid of the wrapping object */
- STATS(jniinvokation();)
+
+ STATISTICS(jniinvokation());
+
/*log_text("JNI-Call: FromReflectedField");*/
f=(java_lang_reflect_Field *)field;
}
-/**********************************************************************************
+/* ToReflectedMethod ***********************************************************
- converts a method ID to a java.lang.reflect.Method or
- java.lang.reflect.Constructor object
+ Converts a method ID derived from cls to an instance of the
+ java.lang.reflect.Method class or to an instance of the
+ java.lang.reflect.Constructor class.
-**********************************************************************************/
+*******************************************************************************/
jobject ToReflectedMethod(JNIEnv* env, jclass cls, jmethodID methodID, jboolean isStatic)
{
- log_text("JNI-Call: ToReflectedMethod");
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: ToReflectedMethod: IMPLEMENT ME!");
+
+ return NULL;
+}
+
+
+/* ToReflectedField ************************************************************
+
+ Converts a field ID derived from cls to an instance of the
+ java.lang.reflect.Field class.
+
+*******************************************************************************/
+
+jobject ToReflectedField(JNIEnv* env, jclass cls, jfieldID fieldID,
+ jboolean isStatic)
+{
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: ToReflectedField: IMPLEMENT ME!");
return NULL;
}
+/* Calling Instance Methods ***************************************************/
+
/* GetMethodID *****************************************************************
- returns the method ID for an instance method
+ Returns the method ID for an instance (nonstatic) method of a class
+ or interface. The method may be defined in one of the clazz's
+ superclasses and inherited by clazz. The method is determined by
+ its name and signature.
+
+ GetMethodID() causes an uninitialized class to be initialized.
*******************************************************************************/
-jmethodID GetMethodID(JNIEnv* env, jclass clazz, const char *name, const char *sig)
+jmethodID GetMethodID(JNIEnv* env, jclass clazz, const char *name,
+ const char *sig)
{
+ classinfo *c;
+ utf *uname;
+ utf *udesc;
methodinfo *m;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
+
+ c = (classinfo *) clazz;
+
+ if (!c)
+ return NULL;
+
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
+ return NULL;
+
+ /* try to get the method of the class or one of it's superclasses */
- m = class_resolvemethod(clazz,
- utf_new_char((char *) name),
- utf_new_char((char *) sig));
+ uname = utf_new_char((char *) name);
+ udesc = utf_new_char((char *) sig);
+
+ m = class_resolvemethod(clazz, uname, udesc);
if (!m || (m->flags & ACC_STATIC)) {
- *exceptionptr =
- new_exception_message(string_java_lang_NoSuchMethodError, name);
+ *exceptionptr = exceptions_new_nosuchmethoderror(c, uname, udesc);
return NULL;
}
java_objectheader* ret;
va_list vaargs;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
va_start(vaargs, methodID);
ret = callObjectMethod(obj, methodID, vaargs);
{
java_objectheader* ret;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
ret = callObjectMethod(obj, methodID, args);
jobject CallObjectMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
log_text("JNI-Call: CallObjectMethodA: IMPLEMENT ME!");
{
jboolean ret;
va_list vaargs;
- STATS(jniinvokation();)
+
+ STATISTICS(jniinvokation());
/* log_text("JNI-Call: CallBooleanMethod");*/
jboolean CallBooleanMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
return (jboolean)callIntegerMethod(obj,get_virtual(obj,methodID),PRIMITIVETYPE_BOOLEAN,args);
jboolean CallBooleanMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
+
log_text("JNI-Call: CallBooleanMethodA");
return 0;
{
jbyte ret;
va_list vaargs;
- STATS(jniinvokation();)
+
+ STATISTICS(jniinvokation());
/* log_text("JNI-Call: CallVyteMethod");*/
jbyte CallByteMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
{
/* log_text("JNI-Call: CallByteMethodV");*/
- STATS(jniinvokation();)
+
+ STATISTICS(jniinvokation());
return callIntegerMethod(obj,methodID,PRIMITIVETYPE_BYTE,args);
}
jbyte CallByteMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
{
- log_text("JNI-Call: CallByteMethodA");
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: CallByteMethodA: IMPLEMENT ME!");
return 0;
}
{
jchar ret;
va_list vaargs;
- STATS(jniinvokation();)
+
+ STATISTICS(jniinvokation());
/* log_text("JNI-Call: CallCharMethod");*/
jchar CallCharMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
/* log_text("JNI-Call: CallCharMethodV");*/
+
return callIntegerMethod(obj,get_virtual(obj,methodID),PRIMITIVETYPE_CHAR,args);
}
jchar CallCharMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
- log_text("JNI-Call: CallCharMethodA");
+ log_text("JNI-Call: CallCharMethodA: IMPLEMENT ME!");
return 0;
}
{
jshort ret;
va_list vaargs;
- STATS(jniinvokation();)
+
+ STATISTICS(jniinvokation());
/* log_text("JNI-Call: CallShortMethod");*/
jshort CallShortMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
+
return callIntegerMethod(obj, get_virtual(obj, methodID),PRIMITIVETYPE_SHORT, args);
}
jshort CallShortMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: CallShortMethodA");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: CallShortMethodA: IMPLEMENT ME!");
return 0;
}
{
jint ret;
va_list vaargs;
- STATS(jniinvokation();)
+
+ STATISTICS(jniinvokation());
va_start(vaargs,methodID);
ret = callIntegerMethod(obj, get_virtual(obj, methodID),PRIMITIVETYPE_INT, vaargs);
jint CallIntMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
+
return callIntegerMethod(obj, get_virtual(obj, methodID),PRIMITIVETYPE_INT, args);
}
jint CallIntMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: CallIntMethodA");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: CallIntMethodA: IMPLEMENT ME!");
return 0;
}
{
jlong ret;
va_list vaargs;
- STATS(jniinvokation();)
-
+
+ STATISTICS(jniinvokation());
+
va_start(vaargs,methodID);
ret = callLongMethod(obj,get_virtual(obj, methodID),vaargs);
va_end(vaargs);
jlong CallLongMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
+
return callLongMethod(obj,get_virtual(obj, methodID),args);
}
jlong CallLongMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: CallLongMethodA");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: CallLongMethodA: IMPLEMENT ME!");
return 0;
}
jfloat ret;
va_list vaargs;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
+
/* log_text("JNI-Call: CallFloatMethod");*/
va_start(vaargs,methodID);
jfloat CallFloatMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: CallFloatMethodV");
+ STATISTICS(jniinvokation());
+
+/* log_text("JNI-Call: CallFloatMethodV"); */
+
return callFloatMethod(obj, get_virtual(obj, methodID), args, PRIMITIVETYPE_FLOAT);
}
jfloat CallFloatMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: CallFloatMethodA");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: CallFloatMethodA: IMPLEMENT ME!");
return 0;
}
{
jdouble ret;
va_list vaargs;
- STATS(jniinvokation();)
+
+ STATISTICS(jniinvokation());
/* log_text("JNI-Call: CallDoubleMethod");*/
jdouble CallDoubleMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: CallDoubleMethodV");
+ STATISTICS(jniinvokation());
+
+/* log_text("JNI-Call: CallDoubleMethodV"); */
+
return callFloatMethod(obj, get_virtual(obj, methodID), args, PRIMITIVETYPE_DOUBLE);
}
jdouble CallDoubleMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: CallDoubleMethodA");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: CallDoubleMethodA: IMPLEMENT ME!");
+
return 0;
}
void CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
{
va_list vaargs;
- STATS(jniinvokation();)
+
+ STATISTICS(jniinvokation());
va_start(vaargs,methodID);
(void) callIntegerMethod(obj, get_virtual(obj, methodID),TYPE_VOID, vaargs);
}
-void CallVoidMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
+void CallVoidMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
{
- log_text("JNI-Call: CallVoidMethodV");
- STATS(jniinvokation();)
- (void)callIntegerMethod(obj,get_virtual(obj,methodID),TYPE_VOID,args);
+ STATISTICS(jniinvokation());
+
+/* log_text("JNI-Call: CallVoidMethodV"); */
+
+ (void) callIntegerMethod(obj, get_virtual(obj, methodID), TYPE_VOID,args);
}
-void CallVoidMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
+void CallVoidMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: CallVoidMethodA");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: CallVoidMethodA: IMPLEMENT ME!");
}
jobject CallNonvirtualObjectMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
log_text("JNI-Call: CallNonvirtualObjectMethod: IMPLEMENT ME!");
jobject CallNonvirtualObjectMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
log_text("JNI-Call: CallNonvirtualObjectMethodV: IMPLEMENT ME!");
}
-jobject CallNonvirtualObjectMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
+jobject CallNonvirtualObjectMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
log_text("JNI-Call: CallNonvirtualObjectMethodA: IMPLEMENT ME!");
{
jboolean ret;
va_list vaargs;
- STATS(jniinvokation();)
+
+ STATISTICS(jniinvokation());
/* log_text("JNI-Call: CallNonvirtualBooleanMethod");*/
va_start(vaargs,methodID);
ret = (jboolean)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),PRIMITIVETYPE_BOOLEAN,vaargs);
va_end(vaargs);
+
return ret;
}
jboolean CallNonvirtualBooleanMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
+
/* log_text("JNI-Call: CallNonvirtualBooleanMethodV");*/
+
return (jboolean)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),PRIMITIVETYPE_BOOLEAN,args);
}
-jboolean CallNonvirtualBooleanMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
+jboolean CallNonvirtualBooleanMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: CallNonvirtualBooleanMethodA");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: CallNonvirtualBooleanMethodA: IMPLEMENT ME!");
return 0;
}
-
jbyte CallNonvirtualByteMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
{
jbyte ret;
va_list vaargs;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
+
/* log_text("JNI-Call: CallNonvirutalByteMethod");*/
va_start(vaargs,methodID);
ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),PRIMITIVETYPE_BYTE,vaargs);
va_end(vaargs);
+
return ret;
}
jbyte CallNonvirtualByteMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
+
/*log_text("JNI-Call: CallNonvirtualByteMethodV"); */
- return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),PRIMITIVETYPE_BYTE,args);
+ return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),PRIMITIVETYPE_BYTE,args);
}
-jbyte CallNonvirtualByteMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
+jbyte CallNonvirtualByteMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: CallNonvirtualByteMethodA");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: CallNonvirtualByteMethodA: IMPLEMENT ME!");
return 0;
}
-jchar CallNonvirtualCharMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
+jchar CallNonvirtualCharMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
{
jchar ret;
va_list vaargs;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
+
/* log_text("JNI-Call: CallNonVirtualCharMethod");*/
va_start(vaargs,methodID);
ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),PRIMITIVETYPE_CHAR,vaargs);
va_end(vaargs);
+
return ret;
}
jchar CallNonvirtualCharMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
+
/*log_text("JNI-Call: CallNonvirtualCharMethodV");*/
+
return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),PRIMITIVETYPE_CHAR,args);
}
jchar CallNonvirtualCharMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: CallNonvirtualCharMethodA");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: CallNonvirtualCharMethodA: IMPLEMENT ME!");
return 0;
}
{
jshort ret;
va_list vaargs;
- STATS(jniinvokation();)
+
+ STATISTICS(jniinvokation());
/*log_text("JNI-Call: CallNonvirtualShortMethod");*/
va_start(vaargs,methodID);
ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),PRIMITIVETYPE_SHORT,vaargs);
va_end(vaargs);
+
return ret;
}
jshort CallNonvirtualShortMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
+
/*log_text("JNI-Call: CallNonvirtualShortMethodV");*/
+
return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),PRIMITIVETYPE_SHORT,args);
}
jshort CallNonvirtualShortMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: CallNonvirtualShortMethodA");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: CallNonvirtualShortMethodA: IMPLEMENT ME!");
return 0;
}
jint CallNonvirtualIntMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
{
+ jint ret;
+ va_list vaargs;
- jint ret;
- va_list vaargs;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
/*log_text("JNI-Call: CallNonvirtualIntMethod");*/
- va_start(vaargs,methodID);
- ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),PRIMITIVETYPE_INT,vaargs);
- va_end(vaargs);
- return ret;
+ va_start(vaargs,methodID);
+ ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),PRIMITIVETYPE_INT,vaargs);
+ va_end(vaargs);
+
+ return ret;
}
jint CallNonvirtualIntMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
+
/*log_text("JNI-Call: CallNonvirtualIntMethodV");*/
- return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),PRIMITIVETYPE_INT,args);
+
+ return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),PRIMITIVETYPE_INT,args);
}
jint CallNonvirtualIntMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: CallNonvirtualIntMethodA");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: CallNonvirtualIntMethodA: IMPLEMENT ME!");
return 0;
}
jlong CallNonvirtualLongMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: CallNonvirtualLongMethod");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: CallNonvirtualLongMethod: IMPLEMENT ME!");
return 0;
}
jlong CallNonvirtualLongMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: CallNonvirtualLongMethodV");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: CallNonvirtualLongMethodV: IMPLEMENT ME!");
return 0;
}
jlong CallNonvirtualLongMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: CallNonvirtualLongMethodA");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: CallNonvirtualLongMethodA: IMPLEMENT ME!");
return 0;
}
{
jfloat ret;
va_list vaargs;
- STATS(jniinvokation();)
- /*log_text("JNI-Call: CallNonvirtualFloatMethod");*/
+ STATISTICS(jniinvokation());
+ /*log_text("JNI-Call: CallNonvirtualFloatMethod");*/
va_start(vaargs,methodID);
ret = callFloatMethod(obj,get_nonvirtual(clazz,methodID),vaargs,PRIMITIVETYPE_FLOAT);
va_end(vaargs);
- return ret;
+ return ret;
}
jfloat CallNonvirtualFloatMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: CallNonvirtualFloatMethodV");
+ STATISTICS(jniinvokation());
+
+/* log_text("JNI-Call: CallNonvirtualFloatMethodV"); */
+
return callFloatMethod(obj,get_nonvirtual(clazz,methodID),args,PRIMITIVETYPE_FLOAT);
}
jfloat CallNonvirtualFloatMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: CallNonvirtualFloatMethodA");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: CallNonvirtualFloatMethodA: IMPLEMENT ME!");
return 0;
}
{
jdouble ret;
va_list vaargs;
- STATS(jniinvokation();)
- log_text("JNI-Call: CallNonvirtualDoubleMethod");
+
+ STATISTICS(jniinvokation());
+
+/* log_text("JNI-Call: CallNonvirtualDoubleMethod"); */
va_start(vaargs,methodID);
ret = callFloatMethod(obj,get_nonvirtual(clazz,methodID),vaargs,PRIMITIVETYPE_DOUBLE);
va_end(vaargs);
- return ret;
+ return ret;
}
jdouble CallNonvirtualDoubleMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
+
/* log_text("JNI-Call: CallNonvirtualDoubleMethodV");*/
+
return callFloatMethod(obj,get_nonvirtual(clazz,methodID),args,PRIMITIVETYPE_DOUBLE);
}
jdouble CallNonvirtualDoubleMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: CallNonvirtualDoubleMethodA");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: CallNonvirtualDoubleMethodA: IMPLEMENT ME!");
return 0;
}
void CallNonvirtualVoidMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
{
- va_list vaargs;
- STATS(jniinvokation();)
+ va_list vaargs;
-/* log_text("JNI-Call: CallNonvirtualVoidMethod");*/
+ STATISTICS(jniinvokation());
- va_start(vaargs,methodID);
- (void)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),TYPE_VOID,vaargs);
- va_end(vaargs);
+/* log_text("JNI-Call: CallNonvirtualVoidMethod");*/
+ va_start(vaargs,methodID);
+ (void)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),TYPE_VOID,vaargs);
+ va_end(vaargs);
}
void CallNonvirtualVoidMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
{
-/* log_text("JNI-Call: CallNonvirtualVoidMethodV");*/
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
- (void)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),TYPE_VOID,args);
+/* log_text("JNI-Call: CallNonvirtualVoidMethodV");*/
+ (void)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),TYPE_VOID,args);
}
void CallNonvirtualVoidMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: CallNonvirtualVoidMethodA");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: CallNonvirtualVoidMethodA: IMPLEMENT ME!");
}
-/************************* JNI-functions for accessing fields ************************/
-jfieldID GetFieldID(JNIEnv *env, jclass clazz, const char *name, const char *sig)
+/* Accessing Fields of Objects ************************************************/
+
+/* GetFieldID ******************************************************************
+
+ Returns the field ID for an instance (nonstatic) field of a
+ class. The field is specified by its name and signature. The
+ Get<type>Field and Set<type>Field families of accessor functions
+ use field IDs to retrieve object fields.
+
+*******************************************************************************/
+
+jfieldID GetFieldID(JNIEnv *env, jclass clazz, const char *name,
+ const char *sig)
{
- jfieldID f;
+ fieldinfo *f;
+ utf *uname;
+ utf *udesc;
+
+ STATISTICS(jniinvokation());
- STATS(jniinvokation();)
+ uname = utf_new_char((char *) name);
+ udesc = utf_new_char((char *) sig);
- f = class_findfield(clazz, utf_new_char((char *) name), utf_new_char((char *) sig));
+ f = class_findfield(clazz, uname, udesc);
if (!f)
*exceptionptr = new_exception(string_java_lang_NoSuchFieldError);
return f;
}
-/*************************** retrieve fieldid, abort on error ************************/
-jfieldID getFieldID_critical(JNIEnv *env, jclass clazz, char *name, char *sig)
-{
- jfieldID id = GetFieldID(env, clazz, name, sig);
- STATS(jniinvokation();)
+/* Get<type>Field Routines *****************************************************
- if (!id) {
- log_text("class:");
- utf_display(clazz->name);
- log_text("\nfield:");
- log_text(name);
- log_text("sig:");
- log_text(sig);
+ This family of accessor routines returns the value of an instance
+ (nonstatic) field of an object. The field to access is specified by
+ a field ID obtained by calling GetFieldID().
- log_text("setfield_critical failed");
- assert(0);
- }
- return id;
-}
+*******************************************************************************/
jobject GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
java_objectheader *o;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
- o = getField(obj, java_objectheader*, fieldID);
+ o = GET_FIELD(obj, java_objectheader*, fieldID);
return NewLocalRef(env, o);
}
-jboolean GetBooleanField (JNIEnv *env, jobject obj, jfieldID fieldID)
+
+jboolean GetBooleanField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
- STATS(jniinvokation();)
- return getField(obj,jboolean,fieldID);
+ s4 i;
+
+ STATISTICS(jniinvokation());
+
+ i = GET_FIELD(obj, s4, fieldID);
+
+ return (jboolean) i;
}
-jbyte GetByteField (JNIEnv *env, jobject obj, jfieldID fieldID)
+jbyte GetByteField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
- STATS(jniinvokation();)
- return getField(obj,jbyte,fieldID);
+ s4 i;
+
+ STATISTICS(jniinvokation());
+
+ i = GET_FIELD(obj, s4, fieldID);
+
+ return (jbyte) i;
}
-jchar GetCharField (JNIEnv *env, jobject obj, jfieldID fieldID)
+jchar GetCharField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
- STATS(jniinvokation();)
- return getField(obj,jchar,fieldID);
+ s4 i;
+
+ STATISTICS(jniinvokation());
+
+ i = GET_FIELD(obj, s4, fieldID);
+
+ return (jchar) i;
}
-jshort GetShortField (JNIEnv *env, jobject obj, jfieldID fieldID)
+jshort GetShortField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
- STATS(jniinvokation();)
- return getField(obj,jshort,fieldID);
+ s4 i;
+
+ STATISTICS(jniinvokation());
+
+ i = GET_FIELD(obj, s4, fieldID);
+
+ return (jshort) i;
}
-jint GetIntField (JNIEnv *env, jobject obj, jfieldID fieldID)
+jint GetIntField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
- STATS(jniinvokation();)
- return getField(obj,jint,fieldID);
+ s4 i;
+
+ STATISTICS(jniinvokation());
+
+ i = GET_FIELD(obj, s4, fieldID);
+
+ return i;
}
-jlong GetLongField (JNIEnv *env, jobject obj, jfieldID fieldID)
+jlong GetLongField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
- STATS(jniinvokation();)
- return getField(obj,jlong,fieldID);
+ s8 l;
+
+ STATISTICS(jniinvokation());
+
+ l = GET_FIELD(obj, s8, fieldID);
+
+ return l;
}
-jfloat GetFloatField (JNIEnv *env, jobject obj, jfieldID fieldID)
+jfloat GetFloatField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
- STATS(jniinvokation();)
- return getField(obj,jfloat,fieldID);
+ float f;
+
+ STATISTICS(jniinvokation());
+
+ f = GET_FIELD(obj, float, fieldID);
+
+ return f;
}
-jdouble GetDoubleField (JNIEnv *env, jobject obj, jfieldID fieldID)
+jdouble GetDoubleField(JNIEnv *env, jobject obj, jfieldID fieldID)
{
- STATS(jniinvokation();)
- return getField(obj,jdouble,fieldID);
+ double d;
+
+ STATISTICS(jniinvokation());
+
+ d = GET_FIELD(obj, double, fieldID);
+
+ return d;
}
-void SetObjectField (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val)
+
+/* Set<type>Field Routines *****************************************************
+
+ This family of accessor routines sets the value of an instance
+ (nonstatic) field of an object. The field to access is specified by
+ a field ID obtained by calling GetFieldID().
+
+*******************************************************************************/
+
+void SetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID, jobject value)
{
- STATS(jniinvokation();)
- setField(obj,jobject,fieldID,val);
+ STATISTICS(jniinvokation());
+
+ SET_FIELD(obj, java_objectheader*, fieldID, value);
}
-void SetBooleanField (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val)
+void SetBooleanField(JNIEnv *env, jobject obj, jfieldID fieldID, jboolean value)
{
- STATS(jniinvokation();)
- setField(obj,jboolean,fieldID,val);
+ STATISTICS(jniinvokation());
+
+ SET_FIELD(obj, s4, fieldID, value);
}
-void SetByteField (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val)
+void SetByteField(JNIEnv *env, jobject obj, jfieldID fieldID, jbyte value)
{
- STATS(jniinvokation();)
- setField(obj,jbyte,fieldID,val);
+ STATISTICS(jniinvokation());
+
+ SET_FIELD(obj, s4, fieldID, value);
}
-void SetCharField (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val)
+void SetCharField(JNIEnv *env, jobject obj, jfieldID fieldID, jchar value)
{
- STATS(jniinvokation();)
- setField(obj,jchar,fieldID,val);
+ STATISTICS(jniinvokation());
+
+ SET_FIELD(obj, s4, fieldID, value);
}
-void SetShortField (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val)
+void SetShortField(JNIEnv *env, jobject obj, jfieldID fieldID, jshort value)
{
- STATS(jniinvokation();)
- setField(obj,jshort,fieldID,val);
+ STATISTICS(jniinvokation());
+
+ SET_FIELD(obj, s4, fieldID, value);
}
-void SetIntField (JNIEnv *env, jobject obj, jfieldID fieldID, jint val)
+void SetIntField(JNIEnv *env, jobject obj, jfieldID fieldID, jint value)
{
- STATS(jniinvokation();)
- setField(obj,jint,fieldID,val);
+ STATISTICS(jniinvokation());
+
+ SET_FIELD(obj, s4, fieldID, value);
}
-void SetLongField (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val)
+void SetLongField(JNIEnv *env, jobject obj, jfieldID fieldID, jlong value)
{
- STATS(jniinvokation();)
- setField(obj,jlong,fieldID,val);
+ STATISTICS(jniinvokation());
+
+ SET_FIELD(obj, s8, fieldID, value);
}
-void SetFloatField (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val)
+void SetFloatField(JNIEnv *env, jobject obj, jfieldID fieldID, jfloat value)
{
- STATS(jniinvokation();)
- setField(obj,jfloat,fieldID,val);
+ STATISTICS(jniinvokation());
+
+ SET_FIELD(obj, float, fieldID, value);
}
-void SetDoubleField (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val)
+void SetDoubleField(JNIEnv *env, jobject obj, jfieldID fieldID, jdouble value)
{
- STATS(jniinvokation();)
- setField(obj,jdouble,fieldID,val);
+ STATISTICS(jniinvokation());
+
+ SET_FIELD(obj, double, fieldID, value);
}
-/**************** JNI-functions for calling static methods **********************/
+/* Calling Static Methods *****************************************************/
+
+/* GetStaticMethodID ***********************************************************
+
+ Returns the method ID for a static method of a class. The method is
+ specified by its name and signature.
+
+ GetStaticMethodID() causes an uninitialized class to be
+ initialized.
-jmethodID GetStaticMethodID(JNIEnv *env, jclass clazz, const char *name, const char *sig)
+*******************************************************************************/
+
+jmethodID GetStaticMethodID(JNIEnv *env, jclass clazz, const char *name,
+ const char *sig)
{
- jmethodID m;
- STATS(jniinvokation();)
+ classinfo *c;
+ utf *uname;
+ utf *udesc;
+ methodinfo *m;
+
+ STATISTICS(jniinvokation());
- m = class_resolvemethod(clazz,
- utf_new_char((char *) name),
- utf_new_char((char *) sig));
+ c = (classinfo *) clazz;
+
+ if (!c)
+ return NULL;
+
+ if (!(c->state & CLASS_INITIALIZED))
+ if (!initialize_class(c))
+ return NULL;
+
+ /* try to get the static method of the class */
+
+ uname = utf_new_char((char *) name);
+ udesc = utf_new_char((char *) sig);
+
+ m = class_resolvemethod(c, uname, udesc);
if (!m || !(m->flags & ACC_STATIC)) {
- *exceptionptr =
- new_exception_message(string_java_lang_NoSuchMethodError, name);
+ *exceptionptr = exceptions_new_nosuchmethoderror(c, uname, udesc);
return NULL;
}
java_objectheader *ret;
va_list vaargs;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
va_start(vaargs, methodID);
ret = callObjectMethod(0, methodID, vaargs);
{
java_objectheader *ret;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
ret = callObjectMethod(0, methodID, args);
jobject CallStaticObjectMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
log_text("JNI-Call: CallStaticObjectMethodA: IMPLEMENT ME!");
jboolean CallStaticBooleanMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
{
+ va_list vaargs;
jboolean ret;
- va_list vaargs;
- STATS(jniinvokation();)
+
+ STATISTICS(jniinvokation());
va_start(vaargs, methodID);
ret = (jboolean) callIntegerMethod(0, methodID, PRIMITIVETYPE_BOOLEAN, vaargs);
jboolean CallStaticBooleanMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
+
return (jboolean) callIntegerMethod(0, methodID, PRIMITIVETYPE_BOOLEAN, args);
}
jboolean CallStaticBooleanMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: CallStaticBooleanMethodA");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: CallStaticBooleanMethodA: IMPLEMENT ME!");
return 0;
}
jbyte CallStaticByteMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
{
- jbyte ret;
va_list vaargs;
- STATS(jniinvokation();)
+ jbyte ret;
- /* log_text("JNI-Call: CallStaticByteMethod");*/
+ STATISTICS(jniinvokation());
va_start(vaargs, methodID);
ret = (jbyte) callIntegerMethod(0, methodID, PRIMITIVETYPE_BYTE, vaargs);
jbyte CallStaticByteMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
+
return (jbyte) callIntegerMethod(0, methodID, PRIMITIVETYPE_BYTE, args);
}
jbyte CallStaticByteMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: CallStaticByteMethodA");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: CallStaticByteMethodA: IMPLEMENT ME!");
return 0;
}
jchar CallStaticCharMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
{
- jchar ret;
va_list vaargs;
- STATS(jniinvokation();)
+ jchar ret;
- /* log_text("JNI-Call: CallStaticByteMethod");*/
+ STATISTICS(jniinvokation());
va_start(vaargs, methodID);
ret = (jchar) callIntegerMethod(0, methodID, PRIMITIVETYPE_CHAR, vaargs);
jchar CallStaticCharMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
+
return (jchar) callIntegerMethod(0, methodID, PRIMITIVETYPE_CHAR, args);
}
jchar CallStaticCharMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: CallStaticCharMethodA");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: CallStaticCharMethodA: IMPLEMENT ME!");
return 0;
}
-
jshort CallStaticShortMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
{
- jshort ret;
va_list vaargs;
- STATS(jniinvokation();)
+ jshort ret;
- /* log_text("JNI-Call: CallStaticByteMethod");*/
+ STATISTICS(jniinvokation());
va_start(vaargs, methodID);
ret = (jshort) callIntegerMethod(0, methodID, PRIMITIVETYPE_SHORT, vaargs);
jshort CallStaticShortMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
{
- STATS(jniinvokation();)
- /*log_text("JNI-Call: CallStaticShortMethodV");*/
+ STATISTICS(jniinvokation());
+
return (jshort) callIntegerMethod(0, methodID, PRIMITIVETYPE_SHORT, args);
}
jshort CallStaticShortMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: CallStaticShortMethodA");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: CallStaticShortMethodA: IMPLEMENT ME!");
return 0;
}
-
jint CallStaticIntMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
{
- jint ret;
va_list vaargs;
- STATS(jniinvokation();)
+ jint ret;
- /* log_text("JNI-Call: CallStaticIntMethod");*/
+ STATISTICS(jniinvokation());
va_start(vaargs, methodID);
ret = callIntegerMethod(0, methodID, PRIMITIVETYPE_INT, vaargs);
jint CallStaticIntMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: CallStaticIntMethodV");
+ STATISTICS(jniinvokation());
return callIntegerMethod(0, methodID, PRIMITIVETYPE_INT, args);
}
jint CallStaticIntMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: CallStaticIntMethodA");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: CallStaticIntMethodA: IMPLEMENT ME!");
return 0;
}
-
jlong CallStaticLongMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
{
- jlong ret;
va_list vaargs;
- STATS(jniinvokation();)
+ jlong ret;
- /* log_text("JNI-Call: CallStaticLongMethod");*/
+ STATISTICS(jniinvokation());
va_start(vaargs, methodID);
ret = callLongMethod(0, methodID, vaargs);
jlong CallStaticLongMethodV(JNIEnv *env, jclass clazz, jmethodID methodID,
va_list args)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
return callLongMethod(0, methodID, args);
}
jlong CallStaticLongMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
- log_text("JNI-Call: CallStaticLongMethodA: IMPLEMENT ME!!!");
+ log_text("JNI-Call: CallStaticLongMethodA: IMPLEMENT ME!");
return 0;
}
jfloat CallStaticFloatMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
{
- jfloat ret;
va_list vaargs;
- STATS(jniinvokation();)
+ jfloat ret;
- /* log_text("JNI-Call: CallStaticLongMethod");*/
+ STATISTICS(jniinvokation());
va_start(vaargs, methodID);
ret = callFloatMethod(0, methodID, vaargs, PRIMITIVETYPE_FLOAT);
jfloat CallStaticFloatMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
return callFloatMethod(0, methodID, args, PRIMITIVETYPE_FLOAT);
jfloat CallStaticFloatMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: CallStaticFloatMethodA");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: CallStaticFloatMethodA: IMPLEMENT ME!");
return 0;
}
-
jdouble CallStaticDoubleMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
{
- jdouble ret;
va_list vaargs;
- STATS(jniinvokation();)
+ jdouble ret;
- /* log_text("JNI-Call: CallStaticDoubleMethod");*/
+ STATISTICS(jniinvokation());
va_start(vaargs,methodID);
ret = callFloatMethod(0, methodID, vaargs, PRIMITIVETYPE_DOUBLE);
jdouble CallStaticDoubleMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: CallStaticDoubleMethodV");
+ STATISTICS(jniinvokation());
return callFloatMethod(0, methodID, args, PRIMITIVETYPE_DOUBLE);
}
jdouble CallStaticDoubleMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: CallStaticDoubleMethodA");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: CallStaticDoubleMethodA: IMPLEMENT ME!");
return 0;
}
void CallStaticVoidMethod(JNIEnv *env, jclass cls, jmethodID methodID, ...)
{
va_list vaargs;
- STATS(jniinvokation();)
+
+ STATISTICS(jniinvokation());
va_start(vaargs, methodID);
(void) callIntegerMethod(0, methodID, TYPE_VOID, vaargs);
void CallStaticVoidMethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)
{
- log_text("JNI-Call: CallStaticVoidMethodV");
- STATS(jniinvokation();)
- (void)callIntegerMethod(0, methodID, TYPE_VOID, args);
+ STATISTICS(jniinvokation());
+
+ (void) callIntegerMethod(0, methodID, TYPE_VOID, args);
}
void CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID methodID, jvalue * args)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: CallStaticVoidMethodA");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: CallStaticVoidMethodA: IMPLEMENT ME!");
}
jfieldID GetStaticFieldID(JNIEnv *env, jclass clazz, const char *name, const char *sig)
{
jfieldID f;
- STATS(jniinvokation();)
+
+ STATISTICS(jniinvokation());
f = class_findfield(clazz,
utf_new_char((char *) name),
jobject GetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
- if (!clazz->initialized)
+ if (!(clazz->state & CLASS_INITIALIZED))
if (!initialize_class(clazz))
return NULL;
jboolean GetStaticBooleanField(JNIEnv *env, jclass clazz, jfieldID fieldID)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
- if (!clazz->initialized)
+ if (!(clazz->state & CLASS_INITIALIZED))
if (!initialize_class(clazz))
return false;
jbyte GetStaticByteField(JNIEnv *env, jclass clazz, jfieldID fieldID)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
- if (!clazz->initialized)
+ if (!(clazz->state & CLASS_INITIALIZED))
if (!initialize_class(clazz))
return 0;
jchar GetStaticCharField(JNIEnv *env, jclass clazz, jfieldID fieldID)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
- if (!clazz->initialized)
+ if (!(clazz->state & CLASS_INITIALIZED))
if (!initialize_class(clazz))
return 0;
jshort GetStaticShortField(JNIEnv *env, jclass clazz, jfieldID fieldID)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
- if (!clazz->initialized)
+ if (!(clazz->state & CLASS_INITIALIZED))
if (!initialize_class(clazz))
return 0;
jint GetStaticIntField(JNIEnv *env, jclass clazz, jfieldID fieldID)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
- if (!clazz->initialized)
+ if (!(clazz->state & CLASS_INITIALIZED))
if (!initialize_class(clazz))
return 0;
jlong GetStaticLongField(JNIEnv *env, jclass clazz, jfieldID fieldID)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
- if (!clazz->initialized)
+ if (!(clazz->state & CLASS_INITIALIZED))
if (!initialize_class(clazz))
return 0;
jfloat GetStaticFloatField(JNIEnv *env, jclass clazz, jfieldID fieldID)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
- if (!clazz->initialized)
+ if (!(clazz->state & CLASS_INITIALIZED))
if (!initialize_class(clazz))
return 0.0;
jdouble GetStaticDoubleField(JNIEnv *env, jclass clazz, jfieldID fieldID)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
- if (!clazz->initialized)
+ if (!(clazz->state & CLASS_INITIALIZED))
if (!initialize_class(clazz))
return 0.0;
void SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
- if (!clazz->initialized)
+ if (!(clazz->state & CLASS_INITIALIZED))
if (!initialize_class(clazz))
return;
void SetStaticBooleanField(JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
- if (!clazz->initialized)
+ if (!(clazz->state & CLASS_INITIALIZED))
if (!initialize_class(clazz))
return;
void SetStaticByteField(JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
- if (!clazz->initialized)
+ if (!(clazz->state & CLASS_INITIALIZED))
if (!initialize_class(clazz))
return;
void SetStaticCharField(JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
- if (!clazz->initialized)
+ if (!(clazz->state & CLASS_INITIALIZED))
if (!initialize_class(clazz))
return;
void SetStaticShortField(JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
- if (!clazz->initialized)
+ if (!(clazz->state & CLASS_INITIALIZED))
if (!initialize_class(clazz))
return;
void SetStaticIntField(JNIEnv *env, jclass clazz, jfieldID fieldID, jint value)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
- if (!clazz->initialized)
+ if (!(clazz->state & CLASS_INITIALIZED))
if (!initialize_class(clazz))
return;
void SetStaticLongField(JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
- if (!clazz->initialized)
+ if (!(clazz->state & CLASS_INITIALIZED))
if (!initialize_class(clazz))
return;
void SetStaticFloatField(JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
- if (!clazz->initialized)
+ if (!(clazz->state & CLASS_INITIALIZED))
if (!initialize_class(clazz))
return;
void SetStaticDoubleField(JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
- if (!clazz->initialized)
+ if (!(clazz->state & CLASS_INITIALIZED))
if (!initialize_class(clazz))
return;
java_chararray *a;
u4 i;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
s = (java_lang_String *) builtin_new(class_java_lang_String);
a = builtin_newarray_char(len);
u2 *stringbuffer;
u4 i;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
s = (java_lang_String *) so;
{
jchar *jc;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
jc = javastring_tou2(str);
void ReleaseStringChars(JNIEnv *env, jstring str, const jchar *chars)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (chars == emptyStringJ)
return;
{
java_lang_String *s;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
s = javastring_new(utf_new_char(bytes));
jsize GetStringUTFLength (JNIEnv *env, jstring string)
{
java_lang_String *s = (java_lang_String*) string;
- STATS(jniinvokation();)
+
+ STATISTICS(jniinvokation());
return (jsize) u2_utflength(s->value->data, s->count);
}
const char *GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy)
{
utf *u;
- STATS(jniinvokation();)
+
+ STATISTICS(jniinvokation());
if (!string)
return "";
void ReleaseStringUTFChars(JNIEnv *env, jstring string, const char *utf)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
/* XXX we don't release utf chars right now, perhaps that should be done
later. Since there is always one reference the garbage collector will
jsize GetArrayLength(JNIEnv *env, jarray array)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
return array->size;
}
java_objectarray *oa;
s4 i;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (length < 0) {
- *exceptionptr = new_negativearraysizeexception();
+ exceptions_throw_negativearraysizeexception();
return NULL;
}
{
jobject o;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (index >= array->header.size) {
- *exceptionptr =
- new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
+ exceptions_throw_arrayindexoutofboundsexception();
return NULL;
}
void SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject val)
{
- STATS(jniinvokation();)
- if (index >= array->header.size)
- *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
+ java_objectarray *oa;
+ java_objectheader *o;
+
+ STATISTICS(jniinvokation());
+
+ oa = (java_objectarray *) array;
+ o = (java_objectheader *) val;
- else {
- /* check if the class of value is a subclass of the element class of the array */
- if (!builtin_canstore((java_objectarray *) array, (java_objectheader *) val))
- *exceptionptr = new_exception(string_java_lang_ArrayStoreException);
+ if (index >= array->header.size) {
+ exceptions_throw_arrayindexoutofboundsexception();
+ return;
+ }
+
+ /* check if the class of value is a subclass of the element class
+ of the array */
- else
- array->data[index] = val;
- }
+ if (!builtin_canstore(oa, o)) {
+ *exceptionptr = new_exception(string_java_lang_ArrayStoreException);
+
+ return;
+ }
+
+ array->data[index] = val;
}
{
java_booleanarray *ba;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (len < 0) {
- *exceptionptr = new_negativearraysizeexception();
+ exceptions_throw_negativearraysizeexception();
return NULL;
}
{
java_bytearray *ba;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (len < 0) {
- *exceptionptr = new_negativearraysizeexception();
+ exceptions_throw_negativearraysizeexception();
return NULL;
}
{
java_chararray *ca;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (len < 0) {
- *exceptionptr = new_negativearraysizeexception();
+ exceptions_throw_negativearraysizeexception();
return NULL;
}
{
java_shortarray *sa;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (len < 0) {
- *exceptionptr = new_negativearraysizeexception();
+ exceptions_throw_negativearraysizeexception();
return NULL;
}
{
java_intarray *ia;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (len < 0) {
- *exceptionptr = new_negativearraysizeexception();
+ exceptions_throw_negativearraysizeexception();
return NULL;
}
{
java_longarray *la;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (len < 0) {
- *exceptionptr = new_negativearraysizeexception();
+ exceptions_throw_negativearraysizeexception();
return NULL;
}
{
java_floatarray *fa;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (len < 0) {
- *exceptionptr = new_negativearraysizeexception();
+ exceptions_throw_negativearraysizeexception();
return NULL;
}
{
java_doublearray *da;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (len < 0) {
- *exceptionptr = new_negativearraysizeexception();
+ exceptions_throw_negativearraysizeexception();
return NULL;
}
jboolean *GetBooleanArrayElements(JNIEnv *env, jbooleanArray array,
jboolean *isCopy)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (isCopy)
*isCopy = JNI_FALSE;
jbyte *GetByteArrayElements(JNIEnv *env, jbyteArray array, jboolean *isCopy)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (isCopy)
*isCopy = JNI_FALSE;
jchar *GetCharArrayElements(JNIEnv *env, jcharArray array, jboolean *isCopy)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (isCopy)
*isCopy = JNI_FALSE;
jshort *GetShortArrayElements(JNIEnv *env, jshortArray array, jboolean *isCopy)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (isCopy)
*isCopy = JNI_FALSE;
jint *GetIntArrayElements(JNIEnv *env, jintArray array, jboolean *isCopy)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (isCopy)
*isCopy = JNI_FALSE;
jlong *GetLongArrayElements(JNIEnv *env, jlongArray array, jboolean *isCopy)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (isCopy)
*isCopy = JNI_FALSE;
jfloat *GetFloatArrayElements(JNIEnv *env, jfloatArray array, jboolean *isCopy)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (isCopy)
*isCopy = JNI_FALSE;
jdouble *GetDoubleArrayElements(JNIEnv *env, jdoubleArray array,
jboolean *isCopy)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (isCopy)
*isCopy = JNI_FALSE;
void ReleaseBooleanArrayElements(JNIEnv *env, jbooleanArray array,
jboolean *elems, jint mode)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (elems != array->data) {
switch (mode) {
void ReleaseByteArrayElements(JNIEnv *env, jbyteArray array, jbyte *elems,
jint mode)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (elems != array->data) {
switch (mode) {
void ReleaseCharArrayElements(JNIEnv *env, jcharArray array, jchar *elems,
jint mode)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (elems != array->data) {
switch (mode) {
void ReleaseShortArrayElements(JNIEnv *env, jshortArray array, jshort *elems,
jint mode)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (elems != array->data) {
switch (mode) {
void ReleaseIntArrayElements(JNIEnv *env, jintArray array, jint *elems,
jint mode)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (elems != array->data) {
switch (mode) {
void ReleaseLongArrayElements(JNIEnv *env, jlongArray array, jlong *elems,
jint mode)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (elems != array->data) {
switch (mode) {
void ReleaseFloatArrayElements(JNIEnv *env, jfloatArray array, jfloat *elems,
jint mode)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (elems != array->data) {
switch (mode) {
void ReleaseDoubleArrayElements(JNIEnv *env, jdoubleArray array,
jdouble *elems, jint mode)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (elems != array->data) {
switch (mode) {
void GetBooleanArrayRegion(JNIEnv *env, jbooleanArray array, jsize start,
jsize len, jboolean *buf)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (start < 0 || len < 0 || start + len > array->header.size)
- *exceptionptr =
- new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
-
+ exceptions_throw_arrayindexoutofboundsexception();
else
MCOPY(buf, &array->data[start], jboolean, len);
}
void GetByteArrayRegion(JNIEnv *env, jbyteArray array, jsize start, jsize len,
jbyte *buf)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (start < 0 || len < 0 || start + len > array->header.size)
- *exceptionptr =
- new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
-
+ exceptions_throw_arrayindexoutofboundsexception();
else
MCOPY(buf, &array->data[start], jbyte, len);
}
void GetCharArrayRegion(JNIEnv *env, jcharArray array, jsize start, jsize len,
jchar *buf)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (start < 0 || len < 0 || start + len > array->header.size)
- *exceptionptr =
- new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
-
+ exceptions_throw_arrayindexoutofboundsexception();
else
MCOPY(buf, &array->data[start], jchar, len);
}
void GetShortArrayRegion(JNIEnv *env, jshortArray array, jsize start,
jsize len, jshort *buf)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (start < 0 || len < 0 || start + len > array->header.size)
- *exceptionptr =
- new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
-
+ exceptions_throw_arrayindexoutofboundsexception();
else
MCOPY(buf, &array->data[start], jshort, len);
}
void GetIntArrayRegion(JNIEnv *env, jintArray array, jsize start, jsize len,
jint *buf)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (start < 0 || len < 0 || start + len > array->header.size)
- *exceptionptr =
- new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
-
+ exceptions_throw_arrayindexoutofboundsexception();
else
MCOPY(buf, &array->data[start], jint, len);
}
void GetLongArrayRegion(JNIEnv *env, jlongArray array, jsize start, jsize len,
jlong *buf)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (start < 0 || len < 0 || start + len > array->header.size)
- *exceptionptr =
- new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
-
+ exceptions_throw_arrayindexoutofboundsexception();
else
MCOPY(buf, &array->data[start], jlong, len);
}
void GetFloatArrayRegion(JNIEnv *env, jfloatArray array, jsize start,
jsize len, jfloat *buf)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (start < 0 || len < 0 || start + len > array->header.size)
- *exceptionptr =
- new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
-
+ exceptions_throw_arrayindexoutofboundsexception();
else
MCOPY(buf, &array->data[start], jfloat, len);
}
void GetDoubleArrayRegion(JNIEnv *env, jdoubleArray array, jsize start,
jsize len, jdouble *buf)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (start < 0 || len < 0 || start+len>array->header.size)
- *exceptionptr =
- new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
-
+ exceptions_throw_arrayindexoutofboundsexception();
else
MCOPY(buf, &array->data[start], jdouble, len);
}
void SetBooleanArrayRegion(JNIEnv *env, jbooleanArray array, jsize start,
jsize len, jboolean *buf)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (start < 0 || len < 0 || start + len > array->header.size)
- *exceptionptr =
- new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
-
+ exceptions_throw_arrayindexoutofboundsexception();
else
MCOPY(&array->data[start], buf, jboolean, len);
}
void SetByteArrayRegion(JNIEnv *env, jbyteArray array, jsize start, jsize len,
jbyte *buf)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (start < 0 || len < 0 || start + len > array->header.size)
- *exceptionptr =
- new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
-
+ exceptions_throw_arrayindexoutofboundsexception();
else
MCOPY(&array->data[start], buf, jbyte, len);
}
void SetCharArrayRegion(JNIEnv *env, jcharArray array, jsize start, jsize len,
jchar *buf)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (start < 0 || len < 0 || start + len > array->header.size)
- *exceptionptr =
- new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
-
+ exceptions_throw_arrayindexoutofboundsexception();
else
MCOPY(&array->data[start], buf, jchar, len);
-
}
void SetShortArrayRegion(JNIEnv *env, jshortArray array, jsize start,
jsize len, jshort *buf)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (start < 0 || len < 0 || start + len > array->header.size)
- *exceptionptr =
- new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
-
+ exceptions_throw_arrayindexoutofboundsexception();
else
MCOPY(&array->data[start], buf, jshort, len);
}
void SetIntArrayRegion(JNIEnv *env, jintArray array, jsize start, jsize len,
jint *buf)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (start < 0 || len < 0 || start + len > array->header.size)
- *exceptionptr =
- new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
-
+ exceptions_throw_arrayindexoutofboundsexception();
else
MCOPY(&array->data[start], buf, jint, len);
-
}
void SetLongArrayRegion(JNIEnv* env, jlongArray array, jsize start, jsize len,
jlong *buf)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (start < 0 || len < 0 || start + len > array->header.size)
- *exceptionptr =
- new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
-
+ exceptions_throw_arrayindexoutofboundsexception();
else
MCOPY(&array->data[start], buf, jlong, len);
-
}
void SetFloatArrayRegion(JNIEnv *env, jfloatArray array, jsize start,
jsize len, jfloat *buf)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (start < 0 || len < 0 || start + len > array->header.size)
- *exceptionptr =
- new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
-
+ exceptions_throw_arrayindexoutofboundsexception();
else
MCOPY(&array->data[start], buf, jfloat, len);
-
}
void SetDoubleArrayRegion(JNIEnv *env, jdoubleArray array, jsize start,
jsize len, jdouble *buf)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (start < 0 || len < 0 || start + len > array->header.size)
- *exceptionptr =
- new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
-
+ exceptions_throw_arrayindexoutofboundsexception();
else
MCOPY(&array->data[start], buf, jdouble, len);
}
jint RegisterNatives(JNIEnv *env, jclass clazz, const JNINativeMethod *methods,
jint nMethods)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
log_text("JNI-Call: RegisterNatives: IMPLEMENT ME!!!");
jint UnregisterNatives(JNIEnv *env, jclass clazz)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
/* XXX TWISTI hmm, maybe we should not support that (like kaffe) */
jint MonitorEnter(JNIEnv *env, jobject obj)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (!obj) {
- *exceptionptr = new_nullpointerexception();
+ exceptions_throw_nullpointerexception();
return JNI_ERR;
}
jint MonitorExit(JNIEnv *env, jobject obj)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
+
if (!obj) {
- *exceptionptr = new_nullpointerexception();
+ exceptions_throw_nullpointerexception();
return JNI_ERR;
}
jint GetJavaVM(JNIEnv *env, JavaVM **vm)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
+
*vm = &ptr_jvm;
return 0;
}
-void GetStringRegion (JNIEnv* env, jstring str, jsize start, jsize len, jchar *buf)
+void GetStringRegion(JNIEnv* env, jstring str, jsize start, jsize len, jchar *buf)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: GetStringRegion");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: GetStringRegion: IMPLEMENT ME!");
}
void GetStringUTFRegion (JNIEnv* env, jstring str, jsize start, jsize len, char *buf)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: GetStringUTFRegion");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: GetStringUTFRegion: IMPLEMENT ME!");
}
void *GetPrimitiveArrayCritical(JNIEnv *env, jarray array, jboolean *isCopy)
{
+ java_bytearray *ba;
+ jbyte *bp;
+
+ ba = (java_bytearray *) array;
+
/* do the same as Kaffe does */
- return GetByteArrayElements(env, (jbyteArray) array, isCopy);
+ bp = GetByteArrayElements(env, ba, isCopy);
+
+ return (void *) bp;
}
void ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array, void *carray,
jint mode)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
/* do the same as Kaffe does */
const jchar *GetStringCritical(JNIEnv *env, jstring string, jboolean *isCopy)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
return GetStringChars(env, string, isCopy);
}
void ReleaseStringCritical(JNIEnv *env, jstring string, const jchar *cstring)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
ReleaseStringChars(env, string, cstring);
}
-jweak NewWeakGlobalRef (JNIEnv* env, jobject obj)
+jweak NewWeakGlobalRef(JNIEnv* env, jobject obj)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: NewWeakGlobalRef");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: NewWeakGlobalRef: IMPLEMENT ME!");
return obj;
}
-void DeleteWeakGlobalRef (JNIEnv* env, jweak ref)
+void DeleteWeakGlobalRef(JNIEnv* env, jweak ref)
{
- STATS(jniinvokation();)
- log_text("JNI-Call: DeleteWeakGlobalRef");
+ STATISTICS(jniinvokation());
- /* empty */
+ log_text("JNI-Call: DeleteWeakGlobalRef: IMPLEMENT ME");
}
java_lang_Integer *refcount;
java_objectheader *newval;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
#if defined(USE_THREADS)
builtin_monitorenter(*global_ref_table);
java_lang_Integer *refcount;
s4 val;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
#if defined(USE_THREADS)
builtin_monitorenter(*global_ref_table);
jboolean ExceptionCheck(JNIEnv *env)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
+
return *exceptionptr ? JNI_TRUE : JNI_FALSE;
}
jobject NewDirectByteBuffer(JNIEnv *env, void *address, jlong capacity)
{
- java_nio_DirectByteBufferImpl *nbuf;
+ java_objectheader *nbuf;
#if SIZEOF_VOID_P == 8
gnu_classpath_Pointer64 *paddress;
#else
gnu_classpath_Pointer32 *paddress;
#endif
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
log_text("JNI-NewDirectByteBuffer: called");
- /* allocate a java.nio.DirectByteBufferImpl object */
+#if 0
+ /* allocate a java.nio.DirectByteBufferImpl$ReadWrite object */
- if (!(nbuf = (java_nio_DirectByteBufferImpl *) builtin_new(class_java_nio_DirectByteBufferImpl)))
+ if (!(nbuf = (java_nio_DirectByteBufferImpl$ReadWrite *)
+ builtin_new(class_java_nio_DirectByteBufferImpl_ReadWrite)))
return NULL;
+#endif
/* alocate a gnu.classpath.Pointer{32,64} object */
#if SIZEOF_VOID_P == 8
- if (!(paddress = (gnu_classpath_Pointer64 *) builtin_new(class_gnu_classpath_Pointer64)))
+ if (!(paddress = (gnu_classpath_Pointer64 *)
+ builtin_new(class_gnu_classpath_Pointer64)))
#else
- if (!(paddress = (gnu_classpath_Pointer32 *) builtin_new(class_gnu_classpath_Pointer32)))
+ if (!(paddress = (gnu_classpath_Pointer32 *)
+ builtin_new(class_gnu_classpath_Pointer32)))
#endif
return NULL;
paddress->data = (ptrint) address;
+#if 0
/* fill java.nio.Buffer object */
nbuf->cap = (s4) capacity;
nbuf->limit = (s4) capacity;
nbuf->pos = 0;
nbuf->address = (gnu_classpath_Pointer *) paddress;
+#endif
+
+ nbuf = (*env)->NewObject(env, class_java_nio_DirectByteBufferImpl_ReadWrite,
+ dbbirw_init, NULL, paddress,
+ (jint) capacity, (jint) capacity, (jint) 0);
/* add local reference and return the value */
- return NewLocalRef(env, (jobject) nbuf);
+ return NewLocalRef(env, nbuf);
}
gnu_classpath_Pointer32 *address;
#endif
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
#if 0
if (!builtin_instanceof(buf, class_java_nio_DirectByteBufferImpl))
{
java_nio_Buffer *nbuf;
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
if (buf == NULL)
return -1;
jint DestroyJavaVM(JavaVM *vm)
{
- STATS(jniinvokation();)
- log_text("DestroyJavaVM called");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: DestroyJavaVM: IMPLEMENT ME!");
return 0;
}
jint AttachCurrentThread(JavaVM *vm, void **env, void *thr_args)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
- log_text("AttachCurrentThread called");
+ log_text("JNI-Call: AttachCurrentThread: IMPLEMENT ME!");
#if !defined(HAVE___THREAD)
/* cacao_thread_attach();*/
jint DetachCurrentThread(JavaVM *vm)
{
- STATS(jniinvokation();)
- log_text("DetachCurrentThread called");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: DetachCurrentThread: IMPLEMENT ME!");
return 0;
}
jint GetEnv(JavaVM *vm, void **env, jint version)
{
- STATS(jniinvokation();)
+ STATISTICS(jniinvokation());
#if defined(USE_THREADS) && defined(NATIVE_THREADS)
if (thread_getself() == NULL) {
jint AttachCurrentThreadAsDaemon(JavaVM *vm, void **par1, void *par2)
{
- STATS(jniinvokation();)
- log_text("AttachCurrentThreadAsDaemon called");
+ STATISTICS(jniinvokation());
+
+ log_text("JNI-Call: AttachCurrentThreadAsDaemon: IMPLEMENT ME!");
return 0;
}
}
break;
- case 'J': {
+ case PRIMITIVETYPE_LONG: {
jlong longVal;
longVal = asm_calljavafunction2long(methodID,
argcount,
projects / cacao.git / blobdiff