One addition:
Everywhere Japhar references private_data or privateInfo fields to get
pointers in Class and Thread in java.lang, change it so that it uses native
state instead. Reflection should really be using
ToReflectedField/FromReflectedField rather than directly accessing fields,
so we should be OK on that.
Also I think there may be a place in libruntime (maybe
interploop.c:initialize_system_threads()?) that references
Thread.PrivateInfo, too. Gotta change that one.
--John Keiser
> -----Original Message-----
> From: John Keiser [mailto:[EMAIL PROTECTED]]
> Sent: Sunday, November 08, 1998 6:40 PM
> To: Classpath; Japhar
> Subject: List of changes for Classpath+Japhar
>
>
> Why don't we talk about specifics for this integration? I have
> distilled my
> patch and our recent discussions and made a list of changes required to
> Classpath and Japhar so that Japhar can be binary compatible with both
> Classpath and JDK. Note that I have given in; I am going to go change the
> String fields. I will also make sure offset exists and is set to 0. I
> found one other change I can make to Classpath to minimize runtime
> differences between Japhar with Classpath and JDK (adding a private
> constructor to Thread).
>
> This is partially in response to your request for a patch,
> Petter. We have
> and you have integrated so much in a different way, that the old patch is
> all but useless. The information in this email is complete as
> far as I know
> it; i.e. japhar-patch.tgz is made obsolete by it.
>
> Key:
> N marks changes dependent on the new native state stuff that
> reduce the need
> for private fields.
> ! marks something that actually runs differently when JDK is
> loaded vs. when
> Classpath is loaded. I have minimized these as much as possible. Only
> libnative and one ThreadGroup thing are different at runtime.
>
> (1) Japhar:Makefiles, configure files - Need to make sure FOR_CLASSPATH is
> defined for all files that need it when compiling for Classpath, and needs
> to control which native libs are built. If you want to deprecate
> FOR_CLASSPATH and make it binary compatible, using an if() instead, be my
> guest.
>
>
> (2) Japhar:lib/libnative - add cp.java.lang, cp.java.lang.reflect, or find
> another way to differentiate Classpath native methods and Japhar native
> methods. Japhar may change the classes that hook to these native methods,
> as much as you want. They are classes in Classpath CVS vm/reference.
> Bottom line: make sure no native methods from Japhar's JDK implementation
> collide with Classpath's native libs (not cp.java.lang, the ones in
> Classpath CVS native/java.lang).
>
> For purposes of this document, we'll use separate libraries with
> different names, and call the Classpath ones cplang and cpreflect. We'll
> leave the JDK lib names alone.
>
>
> (3)! Japhar:startup - set a flag depending on whether we're using
> Classpath
> or not
>
> How you implement this is up to you. Auto-discovery would
> be nice. If
> you want us to provide a ClasspathVersion class so that you can tell it's
> us, that'd be just fine.
>
> (4)! Japhar:dynamic_loading.c - only load Classpath libs when Classpath is
> used, and load all JDK when JDK is used.
>
> #include "global_flags.h" (at the top of the file; this is so that you
> get the using_classpath variable)
>
> DLL_loadSystemLibraries() {
> if(using_classpath) {
> native_handle = DLL_find("cplang");
> if(!native_handle)
> return 0;
>
> native_handle = DLL_find("cpreflect");
> if(!native_handle)
> return 0;
>
> } else {
> INSERT THE LIBRARY LOADING YOU CURRENTLY DO HERE
> }
> return 1;
> }
>
>
> (5)N Japhar:jnirefl.c - {To/From}Reflected{Field/Method} - change to use
> native state pointers (both JDK and Classpath).
>
> struct ReflectNativeField {
> ClazzFile * declaringClass;
> jint slot;
> }
>
> struct ReflectNativeMethod {
> ClazzFile * declaringClass;
> jint slot;
> }
>
> ToReflectedMethod() is guaranteed to always be called to
> create a Method
> or Constructor. Likewise, ToReflectedField() and Field. This will avoid
> segfaults.
> Just instantiate one of the structs in ToReflectedXXX() and attach it
> using NSA_SetNativeState().
> Then, in FromReflectedXXX(), use NSA_GetNativeState() and resolve the
> jfieldID with declaringClass->{fields|methods}[slot].
>
>
> (6) Japhar:jnistr.c - Change nothing. It should all work fine.
> (Actually,
> remove the "offset" change you made this weekend.)
>
>
> (7) Japhar:exceptions.c - call getMessage() instead of using
> detailMessage.
> Completed.
>
>
> (8) Classpath:String - Change str -> value, len -> count, make sure offset
> is always set right.
>
>
> (9)N Japhar:interploop.c - initialize_class_class() - Initialize the Class
> class without adding any funky fields (actually investigate the
> possibility
> of not *having* to initialize Class--with native state, I think it's
> actually possible).
>
>
> (10)! Japhar:interploop.c - initialize_system_threads() - Do not
> create the
> system thread group if Classpath is being used, instead grabbing it from
> "ThreadGroup.root".
>
> Everything that has to do with system_thread_group must be if()'d out
> using if(using_classpath) and replaced with this on the Classpath side:
> initialize_class(env, jclass_to_clazzfile(env, ThreadGroup)); // XXX
> this shouldn't be necessary, but GetStaticObjectField() isn't initializing
> the class before grabbing the system thread group, even though
> according to
> spec it should.
> field = (*env)->GetStaticFieldID(env, ThreadGroup, "root",
> "Ljava/lang/ThreadGroup;");
> system_thread_group = (*env)->GetStaticObjectField(env, ThreadGroup,
> field);
>
>
> (11) Classpath:Thread - add private constructor Thread(ThreadGroup;String)
>
>
> (12)N Japhar:objects.c - use native state pointers for
> clazzfile_to_jclass()
> and jclass_to_clazzfile(). This is why you might be able to avoid
> initialize_class_class() altogether.
>
> See jnirefl.c changes.
>
>
> (13) Classpath:? - load the VM-independent native libs ourselves using
> System.loadLibrary(). No known chicken-egg problems with this.
>
>
> --John Keiser
>
>
