This is the mail archive of the
java-discuss@sourceware.cygnus.com
mailing list for the Java project.
Re: CNI namespace
- To: Tom Tromey <tromey at cygnus dot com>
- Subject: Re: CNI namespace
- From: Per Bothner <per at bothner dot com>
- Date: 03 Apr 2000 12:53:34 -0700
- Cc: java-discuss at sourceware dot cygnus dot com
- References: <y683dpaetn2.fsf_-_@ignucius.devel.redhat.com> <m2r9ct8pho.fsf@kelso.bothner.com> <y68k8ilcrfj.fsf@idoru.labs.redhat.com> <m2hfdp8hjy.fsf@kelso.bothner.com> <y6866u5cn4b.fsf@idoru.labs.redhat.com> <m27lel8eb3.fsf@kelso.bothner.com> <200004031916.MAA02911@ferrule.cygnus.com>
Tom Tromey <tromey@cygnus.com> writes:
> The current plan is to use Paul's wrapper class idea.
> Changing g++ would work, but there is nobody to do the actual
> implementation. (And, in my estimation, it is unlikely that the g++
> maintainers would accept the patch in any case.)
Paul sent me some private email, which didn't really explain the
idea. For one thing, I don't see how the JNIEnv can get passed.
Do you have a pointer to the "wrapper class" idea?
A hybrid idea: Modify gcc to to implement __builtin_jnienv().
This get the JNIEnv environment. This would only be valid in
native method that has a JNIEnv parameter *or* in a function
that gets inlined into the latter. Similarly, __builtin_jthis
gets the "this" paramater passed to a native metod.
Next change gcjh so:
class Foo
{
int x;
Foo f(double y);
}
gets emitted as:
class Foo : public java::lang::Object
{
jint x;
#ifdef CNI
inline jint get$x() { return x; }
inline void set$x(jint n) { x = n; }
Foo* f(jdouble y);
#else
static jfieldID x$fieldID = 0;
static jmethodID f = 0;
static jclass Foo$class = 0;
inline jint get$x() {
JNIEnv *env = *__builtin_jni_env();
if (Foo$class == 0) Foo$class = ...;
if (x$fieldID == 0)
jfieldID = (*env)->GetFieldID(env, Foo$class, "x", "I");
return (*env)->GetIntField(env, __builtin_jthis(), x$fieldID);
}
inline void set$x(jint n) { ... }
inline Foo* f(jdouble y) {
JNIEnv *env = *__builtin_jni_env();
if (Foo$class == 0) Foo$class = ...;
if (f$methodId == 0) f$methodId = ...;
return (*env)->CallObjectMethod(env, __builtin_jthis(), f$methodId, y);
}
#endif
}
This requires fairly minimal changes to g++. It requires that
inline methods get inlined in the g++ front-end, *before* __builtin_xxx
is expanded. However, I believe that is now the case, thanks to
Mark Mitchell's work. In addition, we need to implement a few
builtin functions like __builtin_jnienv and __builtin_jthis in g++,
but this a fairly localized and should have no impact on the rest of
g++.
It does mean that code meant to work for bothy jni and cni has to
use get$x and set$x pseudo-methods instead of using x directly.
--
--Per Bothner
per@bothner.com http://www.bothner.com/~per/