harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ge...@apache.org
Subject svn commit: r307257 [17/24] - in /incubator/harmony/enhanced/trunk/sandbox/contribs/bootjvm: ./ bootJVM/ bootJVM/jni/ bootJVM/jni/src/ bootJVM/jni/src/gnu/ bootJVM/jni/src/gnu/classpath/ bootJVM/jni/src/gnu/classpath/0.16/ bootJVM/jni/src/gnu/classpath...
Date Sat, 08 Oct 2005 04:29:29 GMT
Added: incubator/harmony/enhanced/trunk/sandbox/contribs/bootjvm/bootJVM/jvm/src/linkage.c
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/bootjvm/bootJVM/jvm/src/linkage.c?rev=307257&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/bootjvm/bootJVM/jvm/src/linkage.c (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/bootjvm/bootJVM/jvm/src/linkage.c Fri Oct  7 21:27:56 2005
@@ -0,0 +1,894 @@
+/*!
+ * @file linkage.c
+ *
+ * @brief Late binding linkages between classes.
+ *
+ * This logic should be called each and every time a class is
+ * loaded or unloaded.  When a new class is loaded, existing
+ * classes may have unresolved linkages to them that need to
+ * be filled in to point to the new class.  Likewise, when a
+ * class is unloaded, the remaining classes need to have the
+ * linkages removed.  In this manner, the class linkage status
+ * will stay current.
+ *
+ *
+ * @section Control
+ *
+ * \$URL: https://svn.apache.org/path/name/linkage.c $ \$Id: linkage.c 0 09/28/2005 dlydick $
+ *
+ * Copyright 2005 The Apache Software Foundation
+ * or its licensors, as applicable.
+ *
+ * Licensed under the Apache License, Version 2.0 ("the License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied.
+ *
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * @version \$LastChangedRevision: 0 $
+ *
+ * @date \$LastChangedDate: 09/28/2005 $
+ *
+ * @author \$LastChangedBy: dlydick $
+ *         Original code contributed by Daniel Lydick on 09/28/2005.
+ *
+ * @section Reference
+ *
+ */
+
+#include "arch.h"
+ARCH_COPYRIGHT_APACHE(linkage, c, "$URL: https://svn.apache.org/path/name/linkage.c $ $Id: linkage.c 0 09/28/2005 dlydick $");
+
+#include "jvmcfg.h"
+#include "cfmacros.h"
+#include "classfile.h"
+#include "attribute.h"
+#include "exit.h"
+#include "field.h"
+#include "gc.h" 
+#include "jvm.h"
+#include "jvmclass.h"
+#include "linkage.h"
+#include "method.h"
+#include "native.h"
+#include "util.h"
+
+
+/*!
+ * @brief Resolve class table and object table linkages for a class
+ * file, typically one just loaded by
+ * @link #class_static_new() class_static_new()@endlink
+ *
+ *
+ * @param  clsidx   Class table index to class to resolve against
+ *                  all loaded classes.
+ *
+ * @param find_registerNatives When @link #rtrue rtrue@endlink, will
+ *                  return the ordinal for
+ *                  @link #JVMCFG_JLOBJECT_NMO_REGISTER 
+                    JVMCFG_JLOBJECT_NMO_REGISTER@endlink and
+ *                  @link #JVMCFG_JLOBJECT_NMO_UNREGISTER 
+                    JVMCFG_JLOBJECT_NMO_UNREGISTER@endlink
+ *                  as well as the other ordinals.  Once JVM
+ *                  initialization is complete, this should always
+ *                  be @link #rfalse rfalse@endlink because all
+ *                  future classes should @e never have local ordinals.
+ *
+ *
+ * @returns @link #rtrue rtrue@endlink if class was completely
+ *          resolved, @link #rfalse rfalse@endlink otherwise.
+ *
+ */
+
+rboolean linkage_resolve_class(jvm_class_index clsidx,
+                               rboolean        find_registerNatives)
+{
+    if (jvm_class_index_null == clsidx)
+    {
+        /*!
+         * @link #rtrue rtrue@endlink/@link #rfalse rfalse@endlink
+         * irrelevant here
+         */
+        return(rfalse);
+    }
+
+    /* If class is not present, cannot resolve linkages */
+    if (!(CLASS_STATUS_INUSE & CLASS(clsidx).status))
+    {
+        return(rfalse);
+    }
+
+    /* If class is fully linked, there is no need to do it again */
+    if (CLASS_STATUS_LINKED & CLASS(clsidx).status)
+    {
+        return(rtrue);
+    }
+
+    /*
+     * Try to find @e one instance of a class not yet loaded.  If found,
+     * then this class cannot be linked to it, so set
+     * @link #rfalse rfalse@endlink.  This result will be stored in the
+     * </b><code>CLASS(clsidx)->status</code></b>
+     * as the @link #CLASS_STATUS_LINKED CLASS_STATUS_LINKED@endlink
+     * bit, either @link #rtrue rtrue@endlink or
+     * @link #rfalse rfalse@endlink.
+     */
+    rboolean class_fully_linked = rtrue;
+
+    /*
+     * Scan through constant_pool, resolving any missing items
+     * that might now be available.
+     */
+
+    ClassFile *pcfs = CLASS_OBJECT_LINKAGE(clsidx)->pcfs;
+
+    jvm_constant_pool_index cpidx;
+    for (cpidx = CONSTANT_CP_START_INDEX;
+         cpidx < pcfs->constant_pool_count + CONSTANT_CP_START_INDEX -1;
+         cpidx++)
+    {
+        jvm_class_index        clsidxFIND;
+        jvm_field_index        fldidxFIND;
+        jvm_field_lookup_index fluidxFIND;
+
+        jvm_method_index       mthidxFIND;
+        jvm_attribute_index    atridxFIND;
+
+        cp_info_dup *pcpd = pcfs->constant_pool[cpidx];
+
+        CONSTANT_Class_info              *pcpd_Class;
+        CONSTANT_Fieldref_info           *pcpd_Fieldref;
+        CONSTANT_Methodref_info          *pcpd_Methodref;
+        CONSTANT_InterfaceMethodref_info *pcpd_InterfaceMethodref;
+        CONSTANT_NameAndType_info        *pcpd_NameAndType;
+
+        cp_info_dup *clsname;
+
+        switch (CP_TAG(pcfs, cpidx))
+        {
+            case CONSTANT_Class:
+
+                pcpd_Class = PTR_THIS_CP_Class(pcpd);
+
+                /* Only resolve this CP slot if it is not yet done. */
+                if (jvm_class_index_null ==
+                    pcpd_Class->LOCAL_Class_binding.clsidxJVM)
+                {
+                    clsname =
+                        pcfs->constant_pool[pcpd_Class->name_index];
+
+                    clsidxFIND = class_find_by_cp_entry(clsname);
+
+                    if (jvm_class_index_null == clsidxFIND)
+                    {
+                        /* Class not yet loaded in memory */
+                        class_fully_linked = rfalse;
+                    }
+                    else
+                    {
+                        PTR_THIS_CP_Class(pcpd)
+                           ->LOCAL_Class_binding.clsidxJVM = clsidxFIND;
+
+                        /* Add reference unless it references itself */
+                        if (clsidx != clsidxFIND)
+                        {
+                            (rvoid) GC_CLASS_MKREF_FROM_CLASS(
+                                        clsidx,
+                                        clsidxFIND);
+                        }
+                    }
+                }
+                break;
+
+            case CONSTANT_Fieldref:
+
+                pcpd_Fieldref = PTR_THIS_CP_Fieldref(pcpd);
+
+                /* Only resolve this CP slot if it is not yet done. */
+                if (jvm_class_index_null ==
+                    pcpd_Fieldref->LOCAL_Fieldref_binding.clsidxJVM)
+                {
+                    pcpd_Class =
+                        PTR_THIS_CP_Class(pcfs->constant_pool
+                                         [pcpd_Fieldref->class_index]);
+
+                    clsname =
+                        pcfs->constant_pool[pcpd_Class->name_index];
+
+                    clsidxFIND = class_find_by_cp_entry(clsname);
+
+                    pcpd_Fieldref
+                        ->LOCAL_Fieldref_binding.clsidxJVM = clsidxFIND;
+
+                    if (jvm_class_index_null == clsidxFIND)
+                    {
+                        /* Class not yet loaded in memory */
+                        class_fully_linked = rfalse;
+                    }
+                    else
+                    {
+                        pcpd_NameAndType =
+                            PTR_THIS_CP_NameAndType(
+                                pcfs->constant_pool
+                                  [pcpd_Fieldref->name_and_type_index]);
+
+                        fldidxFIND =
+                            field_find_by_cp_entry(
+                                clsidxFIND,
+                                pcfs->constant_pool
+                                    [pcpd_NameAndType->name_index],
+                                pcfs->constant_pool
+                                  [pcpd_NameAndType->descriptor_index]);
+
+                        if (jvm_field_index_bad == fldidxFIND)
+                        {
+                            /* Field not found in class-- fatal error */
+                            exit_throw_exception(EXIT_JVM_CLASS,
+                                   JVMCLASS_JAVA_LANG_NOSUCHFIELDERROR);
+/*NOTREACHED*/
+#if 0
+                            pcpd_Fieldref
+                                ->LOCAL_Fieldref_binding.fluidxJVM =
+                                    jvm_field_lookup_index_bad;
+
+                            pcpd_Fieldref
+                                ->LOCAL_Fieldref_binding.oiflagJVM =
+                                    rneither_true_nor_false;
+
+                            pcpd_Fieldref
+                                ->LOCAL_Fieldref_binding.jvaluetypeJVM =
+                                    LOCAL_BASETYPE_ERROR;
+
+                            /* No point processing ACC_STATIC bit */
+                            continue;
+#endif
+                        }
+
+                        /*
+                         * Now check if ACC_STATIC or not and store
+                         * the proper type of field lookup index.
+                         */
+                        if (FIELD(clsidxFIND, fldidxFIND)
+                              ->access_flags & ACC_STATIC)
+                        {
+                            fluidxFIND =
+            field_index_get_class_static_lookup(clsidxFIND, fldidxFIND);
+
+                        }
+                        else
+                        {
+                            fluidxFIND =
+         field_index_get_object_instance_lookup(clsidxFIND, fldidxFIND);
+
+                        }
+
+                        pcpd_Fieldref
+                            ->LOCAL_Fieldref_binding.fluidxJVM =
+                                fluidxFIND;
+
+                        if (jvm_field_lookup_index_bad == fluidxFIND)
+                        {
+                            /* Field not found in class-- fatal error */
+                            exit_throw_exception(EXIT_JVM_CLASS,
+                                   JVMCLASS_JAVA_LANG_NOSUCHFIELDERROR);
+/*NOTREACHED*/
+
+                            pcpd_Fieldref
+                                ->LOCAL_Fieldref_binding.oiflagJVM =
+                                    rneither_true_nor_false;
+
+                            pcpd_Fieldref
+                                ->LOCAL_Fieldref_binding.jvaluetypeJVM =
+                                    LOCAL_BASETYPE_ERROR;
+
+                            /*
+                             * Don't have valid @b oiflagJVM or
+                             * @b jvaluetypeJVM result
+                             */
+                            continue;
+                        }
+
+                        pcpd_Fieldref
+                            ->LOCAL_Fieldref_binding.oiflagJVM =
+                                (FIELD(clsidxFIND, fldidxFIND)
+                                   ->access_flags & ACC_STATIC)
+                                ? rfalse
+                                : rtrue;
+
+                        cp_info_dup *pfldesc_dup =
+                           CLASS_OBJECT_LINKAGE(clsidxFIND)
+                             ->pcfs
+                               ->constant_pool
+                                 [FIELD(clsidxFIND, fldidxFIND)
+                                    ->descriptor_index];
+
+                        CONSTANT_Utf8_info *pfldesc =
+                                          PTR_THIS_CP_Utf8(pfldesc_dup);
+
+                        /*!
+                         * @todo What needs to happen when base type
+                         *       is BASETYPE_ARRAY or BASETYPE_ERROR
+                         *       or BASETYPE_VOID?
+                         */
+                        pcpd_Fieldref
+                            ->LOCAL_Fieldref_binding.jvaluetypeJVM =
+
+                                pfldesc->bytes[0];
+
+                        /* Add reference unless it references itself */
+                        if (clsidx != clsidxFIND)
+                        {
+                            (rvoid) GC_CLASS_MKREF_FROM_CLASS(
+                                        clsidx,
+                                        clsidxFIND);
+                        }
+                    }
+                }
+                break;
+
+            case CONSTANT_Methodref:
+
+                pcpd_Methodref = PTR_THIS_CP_Methodref(pcpd);
+
+                /* Only resolve this CP slot if it is not yet done. */
+                if (jvm_class_index_null ==
+                    pcpd_Methodref->LOCAL_Methodref_binding.clsidxJVM)
+                {
+                    pcpd_Class =
+                        PTR_THIS_CP_Class(pcfs->constant_pool
+                                         [pcpd_Methodref->class_index]);
+
+                    clsname =
+                        pcfs->constant_pool[pcpd_Class->name_index];
+
+                    clsidxFIND = class_find_by_cp_entry(clsname);
+
+                    pcpd_Methodref
+                        ->LOCAL_Methodref_binding.clsidxJVM =clsidxFIND;
+
+                    if (jvm_class_index_null == clsidxFIND)
+                    {
+                        /* Class not yet loaded in memory */
+                        class_fully_linked = rfalse;
+                    }
+                    else
+                    {
+                        pcpd_NameAndType =
+                            PTR_THIS_CP_NameAndType(
+                                pcfs->constant_pool
+                                 [pcpd_Methodref->name_and_type_index]);
+
+                        mthidxFIND =
+                            method_find_by_cp_entry(
+                                clsidxFIND,
+                                pcfs->constant_pool
+                                    [pcpd_NameAndType->name_index],
+                                pcfs->constant_pool
+                                  [pcpd_NameAndType->descriptor_index]);
+
+                        pcpd_Methodref
+                            ->LOCAL_Methodref_binding.mthidxJVM =
+                                mthidxFIND;
+
+                        if (jvm_method_index_bad == mthidxFIND)
+                        {
+                            /* Method not found in class-- fatal error*/
+                            exit_throw_exception(EXIT_JVM_CLASS,
+                                  JVMCLASS_JAVA_LANG_NOSUCHMETHODERROR);
+/*NOTREACHED*/
+                        }
+
+                        /*
+                         * Now check if Code_attribute is present
+                         * and store its index.  First check if native
+                         * and insert native method ordinal if so.
+                         */
+
+                        if (ACC_NATIVE &
+                            METHOD(clsidxFIND,mthidxFIND)->access_flags)
+                        {
+                            atridxFIND = jvm_attribute_index_native;
+
+                            pcpd_Methodref
+                              ->LOCAL_Methodref_binding
+                                  .nmordJVM =
+                                native_locate_local_method(
+                                        pcfs,
+                                        pcpd_Class->name_index,
+                                        pcpd_NameAndType->name_index,
+                                        pcpd_NameAndType
+                                          ->descriptor_index,
+                                        find_registerNatives);
+                        }
+                        else
+                        {
+                            atridxFIND =
+                                attribute_find_in_method_by_enum(
+                                    clsidxFIND,
+                                    mthidxFIND,
+                                    LOCAL_CODE_ATTRIBUTE);
+                        }
+
+                        pcpd_Methodref
+                            ->LOCAL_Methodref_binding.codeatridxJVM =
+                                atridxFIND;
+
+                        if (jvm_attribute_index_bad == atridxFIND)
+                        {
+                            /* Code not found in method-- fatal error */
+                            exit_throw_exception(EXIT_JVM_ATTRIBUTE,
+                                  JVMCLASS_JAVA_LANG_NOSUCHMETHODERROR);
+/*NOTREACHED*/
+                        }
+
+                        /*
+                         * Now check if Exceptions attribute is
+                         * present and store its index.
+                         */
+
+                        atridxFIND =
+                            attribute_find_in_method_by_enum(
+                                clsidxFIND,
+                                mthidxFIND,
+                                LOCAL_EXCEPTIONS_ATTRIBUTE);
+
+                        pcpd_Methodref
+                            ->LOCAL_Methodref_binding.excpatridxJVM =
+                                atridxFIND;
+
+                        if (jvm_attribute_index_bad == atridxFIND)
+                        {
+                            /* It is OKAY to not have exceptions */
+                        }
+ 
+                        /* Add reference unless it references itself */
+                        if (clsidx != clsidxFIND)
+                        {
+                            (rvoid) GC_CLASS_MKREF_FROM_CLASS(
+                                        clsidx,
+                                        clsidxFIND);
+                        }
+                    }
+                }
+                break;
+
+            case CONSTANT_InterfaceMethodref:
+
+                pcpd_InterfaceMethodref =
+                    PTR_THIS_CP_InterfaceMethodref(pcpd);
+
+                /* Only resolve this CP slot if it is not yet done. */
+                if (jvm_class_index_null ==
+                    pcpd_InterfaceMethodref
+                        ->LOCAL_InterfaceMethodref_binding.clsidxJVM)
+                {
+                    pcpd_Class =
+                        PTR_THIS_CP_Class(pcfs->constant_pool
+                                [pcpd_InterfaceMethodref->class_index]);
+                    clsname =
+                        pcfs->constant_pool[pcpd_Class->name_index];
+
+                    clsidxFIND = class_find_by_cp_entry(clsname);
+
+                    pcpd_InterfaceMethodref
+                        ->LOCAL_InterfaceMethodref_binding.clsidxJVM =
+                            clsidxFIND;
+
+                    if (jvm_class_index_null == clsidxFIND)
+                    {
+                        /* Class not yet loaded in memory */
+                        class_fully_linked = rfalse;
+                    }
+                    else
+                    {
+                        pcpd_NameAndType =
+                            PTR_THIS_CP_NameAndType(
+                                pcfs->constant_pool
+                                [pcpd_InterfaceMethodref
+                                  ->name_and_type_index]);
+
+                        mthidxFIND =
+                            method_find_by_cp_entry(
+                                clsidxFIND,
+                                pcfs->constant_pool
+                                    [pcpd_NameAndType->name_index],
+                                pcfs->constant_pool
+                                  [pcpd_NameAndType->descriptor_index]);
+
+                        pcpd_InterfaceMethodref
+                            ->LOCAL_InterfaceMethodref_binding
+                              .mthidxJVM =
+                                  mthidxFIND;
+
+                        if (jvm_method_index_bad == mthidxFIND)
+                        {
+                            /* Method not found in class-- fatal error*/
+                            exit_throw_exception(EXIT_JVM_CLASS,
+                                  JVMCLASS_JAVA_LANG_NOSUCHMETHODERROR);
+/*NOTREACHED*/
+                        }
+
+                        /*
+                         * Now check if Code_attribute is present
+                         * and store its index.  First check if native
+                         * and insert native method ordinal if so.
+                         */
+
+                        if (ACC_NATIVE &
+                            METHOD(clsidxFIND,mthidxFIND)->access_flags)
+                        {
+                            atridxFIND = jvm_attribute_index_native;
+
+                            /*!
+                             * @todo Should this instance permit
+                             *       use of @b find_registerNatives
+                             *       since interaces are not a part
+                             *       of the JVM startup, just a few
+                             *       foundational classes?  Should
+                             *       it just be
+                             *       @link #rfalse rfalse@endlink
+                             *       instead?
+                             */
+                            pcpd_InterfaceMethodref
+                              ->LOCAL_InterfaceMethodref_binding
+                                  .nmordJVM =
+                                native_locate_local_method(
+                                        pcfs,
+                                        pcpd_Class->name_index,
+                                        pcpd_NameAndType->name_index,
+                                        pcpd_NameAndType
+                                          ->descriptor_index,
+                                        find_registerNatives);
+                        }
+                        else
+                        {
+                            atridxFIND =
+                                attribute_find_in_method_by_enum(
+                                    clsidxFIND,
+                                    mthidxFIND,
+                                    LOCAL_CODE_ATTRIBUTE);
+                        }
+
+                        pcpd_InterfaceMethodref
+                            ->LOCAL_InterfaceMethodref_binding
+                              .codeatridxJVM =
+                                  atridxFIND;
+
+                        if (jvm_attribute_index_bad == atridxFIND)
+                        {
+                            /* Code not found in method-- fatal error */
+                            exit_throw_exception(EXIT_JVM_ATTRIBUTE,
+                                  JVMCLASS_JAVA_LANG_NOSUCHMETHODERROR);
+/*NOTREACHED*/
+                        }
+
+                        /*
+                         * Now check if Exceptions attribute is
+                         * present and store its index.
+                         */
+
+                        atridxFIND =
+                            attribute_find_in_method_by_enum(
+                                clsidxFIND,
+                                mthidxFIND,
+                                LOCAL_EXCEPTIONS_ATTRIBUTE);
+
+                        pcpd_InterfaceMethodref
+                            ->LOCAL_InterfaceMethodref_binding
+                              .excpatridxJVM =
+                                  atridxFIND;
+
+                        if (jvm_attribute_index_bad == atridxFIND)
+                        {
+                            /* It is OKAY to not have exceptions */
+                        }
+
+                        /* Add reference unless it references itself */
+                        if (clsidx != clsidxFIND)
+                        {
+                            (rvoid) GC_CLASS_MKREF_FROM_CLASS(
+                                        clsidx,
+                                        clsidxFIND);
+                        }
+                    }
+                }
+                break;
+
+            case CONSTANT_String:
+
+            case CONSTANT_Integer:
+
+            case CONSTANT_Float:
+
+            case CONSTANT_Long:
+
+            case CONSTANT_Double:
+
+            case CONSTANT_NameAndType:
+
+            case CONSTANT_Utf8:
+
+                /*
+                 * There is no late binding associated
+                 * directly with these tags.
+                 */
+
+                break;
+
+            default:
+                GENERIC_FAILURE1_VALUE(rtrue,
+                                       DMLNORM,
+                                       "linkage_resolve_class",
+                                       "Invalid CP tag %d",
+                                       CP_TAG(pcfs, cpidx),
+                                       rfalse,
+                                       rnull,
+                                       rnull);
+
+        } /* switch ... */
+
+    } /* for (cpidx) */
+
+    /* If this class linked to existing classes, it is fully linked */
+    if (rtrue == class_fully_linked)
+    {
+        CLASS(clsidx).status |= CLASS_STATUS_LINKED;
+    } 
+
+    cfmsgs_show_constant_pool(CLASS_OBJECT_LINKAGE(clsidx)->pcfs);
+
+    return(class_fully_linked);
+
+} /* END of linkage_resolve_class() */
+
+
+/*!
+ * @brief Unresolve class table and object table linkages for a
+ * class file that is getting ready to be unloaded.
+ *
+ *
+ * @param  clsidx   Class table index to class to unresolve against
+ *                  all loaded classes.
+ *
+ *
+ * @returns @link #rtrue rtrue@endlink if class linkages were
+ *          unresolved, @link #rfalse rfalse@endlink otherwise.
+ *
+ */
+
+rboolean linkage_unresolve_class(jvm_class_index clsidx)
+{
+    if (jvm_class_index_null == clsidx)
+    {
+        /*
+         * @link #rtrue rtrue@endlink/@link #rfalse rfalse@endlink
+         * irrelevant here
+         */
+        return(rfalse);
+    }
+
+    /* If class is not present, cannot unresolve linkages */
+    if (!(CLASS_STATUS_INUSE & CLASS(clsidx).status))
+    {
+        return(rfalse);
+    }
+
+
+    ClassFile *pcfs = CLASS_OBJECT_LINKAGE(clsidx)->pcfs;
+
+    /*
+     * Scan through constant_pool, resolving any missing items
+     * that might now be available.
+     */
+    jvm_constant_pool_index cpidx;
+    for (cpidx = CONSTANT_CP_START_INDEX;
+         cpidx < pcfs->constant_pool_count + CONSTANT_CP_START_INDEX -1;
+         cpidx++)
+    {
+        cp_info_dup *pcpd = pcfs->constant_pool[cpidx];
+
+        CONSTANT_Class_info              *pcpd_Class;
+        CONSTANT_Fieldref_info           *pcpd_Fieldref;
+        CONSTANT_Methodref_info          *pcpd_Methodref;
+        CONSTANT_InterfaceMethodref_info *pcpd_InterfaceMethodref;
+
+        switch (CP_TAG(pcfs, cpidx))
+        {
+            case CONSTANT_Class:
+
+                pcpd_Class = PTR_THIS_CP_Class(pcpd);
+
+                /* Only unresolve this CP slot if it was resolved */
+                if (jvm_class_index_null !=
+                    pcpd_Class->LOCAL_Class_binding.clsidxJVM)
+                {
+                    /* Remove reference unless it references itself */
+                    if (clsidx !=
+                        pcpd_Class->LOCAL_Class_binding.clsidxJVM)
+                    {
+                        (rvoid) GC_CLASS_RMREF_FROM_CLASS(
+                                    clsidx,
+                                    pcpd_Class
+                                      ->LOCAL_Class_binding
+                                        .clsidxJVM);
+                    }
+
+                    pcpd_Class->LOCAL_Class_binding.clsidxJVM =
+                        jvm_class_index_null;
+                }
+                break;
+
+            case CONSTANT_Fieldref:
+
+                pcpd_Fieldref = PTR_THIS_CP_Fieldref(pcpd);
+
+                /* Only unresolve this CP slot if it was resolved */
+                if (jvm_class_index_null !=
+                    pcpd_Fieldref->LOCAL_Fieldref_binding.clsidxJVM)
+                {
+                    /* Remove reference unless it references itself */
+                    if (clsidx != 
+                        pcpd_Fieldref->LOCAL_Fieldref_binding.clsidxJVM)
+                    {
+                        (rvoid) GC_CLASS_RMREF_FROM_CLASS(
+                                    clsidx,
+                                    pcpd_Fieldref
+                                      ->LOCAL_Fieldref_binding
+                                        .clsidxJVM);
+                    }
+
+                    pcpd_Fieldref
+                        ->LOCAL_Fieldref_binding.clsidxJVM =
+                            jvm_class_index_null;
+
+                    pcpd_Fieldref
+                        ->LOCAL_Fieldref_binding.fluidxJVM =
+                            jvm_field_lookup_index_bad;
+
+                    pcpd_Fieldref
+                        ->LOCAL_Fieldref_binding.oiflagJVM =
+                            rneither_true_nor_false;
+
+                    pcpd_Fieldref
+                        ->LOCAL_Fieldref_binding.jvaluetypeJVM =
+                            LOCAL_BASETYPE_ERROR;
+                }
+                break;
+
+            case CONSTANT_Methodref:
+
+                pcpd_Methodref = PTR_THIS_CP_Methodref(pcpd);
+
+                /* Only unresolve this CP slot if it was resolved */
+                if (jvm_class_index_null !=
+                    pcpd_Methodref->LOCAL_Methodref_binding.clsidxJVM)
+                {
+                    /* Remove reference unless it references itself */
+                    if (clsidx != 
+                      pcpd_Methodref->LOCAL_Methodref_binding.clsidxJVM)
+                    {
+                        (rvoid) GC_CLASS_RMREF_FROM_CLASS(
+                                    clsidx,
+                                    pcpd_Methodref
+                                      ->LOCAL_Methodref_binding
+                                        .clsidxJVM);
+                    }
+
+                    pcpd_Methodref
+                        ->LOCAL_Methodref_binding.clsidxJVM =
+                            jvm_class_index_null;
+
+                    pcpd_Methodref
+                        ->LOCAL_Methodref_binding.mthidxJVM =
+                            jvm_method_index_bad;
+
+                    pcpd_Methodref
+                        ->LOCAL_Methodref_binding.codeatridxJVM =
+                            jvm_attribute_index_bad;
+
+                    pcpd_Methodref
+                        ->LOCAL_Methodref_binding.excpatridxJVM =
+                            jvm_attribute_index_bad;
+
+                    pcpd_Methodref
+                        ->LOCAL_Methodref_binding.nmordJVM =
+                            jvm_native_method_ordinal_null;
+                }
+                break;
+
+            case CONSTANT_InterfaceMethodref:
+
+                pcpd_InterfaceMethodref =
+                    PTR_THIS_CP_InterfaceMethodref(pcpd);
+
+                /* Only unresolve this CP slot if it was resolved */
+                if (jvm_class_index_null !=
+                    pcpd_InterfaceMethodref
+                        ->LOCAL_InterfaceMethodref_binding.clsidxJVM)
+                {
+                    /* Remove reference unless it references itself */
+                    if (clsidx != 
+                        pcpd_InterfaceMethodref
+                          ->LOCAL_InterfaceMethodref_binding.clsidxJVM)
+                    {
+                        (rvoid) GC_CLASS_RMREF_FROM_CLASS(
+                                    clsidx,
+                                    pcpd_InterfaceMethodref
+                                      ->LOCAL_InterfaceMethodref_binding
+                                        .clsidxJVM);
+                    }
+
+                    pcpd_InterfaceMethodref
+                        ->LOCAL_InterfaceMethodref_binding.clsidxJVM =
+                            jvm_class_index_null;
+
+                    pcpd_InterfaceMethodref
+                        ->LOCAL_InterfaceMethodref_binding.mthidxJVM =
+                            jvm_method_index_bad;
+
+                    pcpd_InterfaceMethodref
+                       ->LOCAL_InterfaceMethodref_binding.codeatridxJVM=
+                            jvm_attribute_index_bad;
+
+                    pcpd_InterfaceMethodref
+                       ->LOCAL_InterfaceMethodref_binding.excpatridxJVM=
+                            jvm_attribute_index_bad;
+
+                    pcpd_InterfaceMethodref
+                       ->LOCAL_InterfaceMethodref_binding.nmordJVM=
+                            jvm_native_method_ordinal_null;
+                }
+                break;
+
+            case CONSTANT_String:
+
+            case CONSTANT_Integer:
+
+            case CONSTANT_Float:
+
+            case CONSTANT_Long:
+
+            case CONSTANT_Double:
+
+            case CONSTANT_NameAndType:
+
+            case CONSTANT_Utf8:
+
+                /*
+                 * There is no late binding associated
+                 * directly with these tags.
+                 */
+
+                break;
+
+            default:
+                GENERIC_FAILURE1_VALUE(rtrue,
+                                       DMLNORM,
+                                       "linkage_rmresolve_class",
+                                       "Invalid CP tag %d",
+                                       CP_TAG(pcfs, cpidx),
+                                       rfalse,
+                                       rnull,
+                                       rnull);
+
+        } /* switch ... */
+
+    } /* for (cpidx) */
+
+    /* This class is no longer fully linked */
+    CLASS(clsidx).status &= ~CLASS_STATUS_LINKED;
+
+    return(rtrue);
+
+} /* END of linkage_unresolve_class() */
+
+
+/* EOF */

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/bootjvm/bootJVM/jvm/src/linkage.h
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/bootjvm/bootJVM/jvm/src/linkage.h?rev=307257&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/bootjvm/bootJVM/jvm/src/linkage.h (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/bootjvm/bootJVM/jvm/src/linkage.h Fri Oct  7 21:27:56 2005
@@ -0,0 +1,242 @@
+#ifndef _linkage_h_included_
+#define _linkage_h_included_
+
+/*!
+ * @file linkage.h
+ *
+ * @brief Runtime linkages between major data structures.
+ *
+ * Of particular interest are the linkages between thread, class,
+ * and object areas.
+ *
+ * Several useful macros are defined here.  They are used to associate
+ * an object instance with its ClassFile structure, its class
+ * definition, and its thread definition, where applicable.
+ *
+ * The macro CLASS_OBJECT_LINKAGE() associates a class definition with
+ * its object instance.  The macro OBJECT_CLASS_LINKAGE() associates
+ * an object instance with its class definition.
+ *
+ * The macro THREAD_OBJECT_LINKAGE() associates a thread definition with
+ * its object instance.  The macro OBJECT_THREAD_LINKAGE() associates
+ * an object instance with its thread definition.  This functionality
+ * is @e only meaningful when the object is a
+ * <b><code>java.lang.Thread</code></b>.
+ *
+ * The information stored in that object table entry points to both
+ * the ClassFile storage for that class and to the class table entry
+ * for that class.
+ *
+ * @section Control
+ *
+ * \$URL: https://svn.apache.org/path/name/linkage.h $ \$Id: linkage.h 0 09/28/2005 dlydick $
+ *
+ * Copyright 2005 The Apache Software Foundation
+ * or its licensors, as applicable.
+ *
+ * Licensed under the Apache License, Version 2.0 ("the License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied.
+ *
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * @version \$LastChangedRevision: 0 $
+ *
+ * @date \$LastChangedDate: 09/28/2005 $
+ *
+ * @author \$LastChangedBy: dlydick $
+ *         Original code contributed by Daniel Lydick on 09/28/2005.
+ *
+ * @section Reference
+ *
+ */
+
+ARCH_COPYRIGHT_APACHE(linkage, h, "$URL: https://svn.apache.org/path/name/linkage.h $ $Id: linkage.h 0 09/28/2005 dlydick $");
+
+
+/*!
+ * @def CLASS_OBJECT_LINKAGE()
+ *
+ * @brief Retrieve class information about a class from its
+ * class object.
+ *
+ * @param  clsidx     Class table index of class definition for which
+ *                    to locate its class definition
+ *                   @link #jvm_table_linkage jvm_table_linkage@endlink.
+ *
+ *
+ * @returns (jvm_table_linkage *) to object table class linkage entry
+ *
+ */
+#define CLASS_OBJECT_LINKAGE(clsidx) \
+                (&OBJECT(CLASS(clsidx).class_objhash).table_linkage)
+
+/*!
+ * @def OBJECT_CLASS_LINKAGE()
+ *
+ * @brief Retrieve class information about an object from its
+ * class.
+ *
+ * @param  objhash    Object hash of object for which to locate its
+ *                    class table entry.
+ *
+ * @returns (jvm_table_linkage *) to object table class linkage entry
+ *
+ */
+
+#define OBJECT_CLASS_LINKAGE(objhash) (&OBJECT(objhash).table_linkage)
+
+
+/* Now the thread definitions: */
+
+/*!
+ * @def VERIFY_THREAD_LINKAGE()
+ *
+ * @brief Verify that a thread slot is in use, is not a null thread,
+ * and contains a valid, non-null, thread object hash that is
+ * definitely marked as a thread object
+ *
+ * @param  thridx     Thread table index of thread to verify its
+ *                    thread table entry.
+ *
+ *
+ * @returns @link #rtrue rtrue@endlink if this thread index indicates
+ * a valid thread table slot, otherwise @link #rfalse rfalse@endlink.
+ *
+ */
+#define VERIFY_THREAD_LINKAGE(thridx)                            \
+   (((thridx != jvm_thread_index_null) &&                        \
+     (THREAD(thridx).status & THREAD_STATUS_INUSE) &&            \
+     (!(THREAD(thridx).status & THREAD_STATUS_NULL)) &&          \
+     (THREAD(thridx).thread_objhash != jvm_object_hash_null)&&   \
+     (OBJECT(THREAD(thridx).thread_objhash).status &             \
+                                        OBJECT_STATUS_INUSE) &&  \
+     (!(OBJECT(THREAD(thridx).thread_objhash).status &           \
+                                        OBJECT_STATUS_NULL)) &&  \
+     (OBJECT(THREAD(thridx).thread_objhash).status &             \
+                                        OBJECT_STATUS_THREAD))   \
+    ? rtrue                                                      \
+    : rfalse)
+
+
+/*!
+ * @def THREAD_OBJECT_LINKAGE()
+ *
+ * @brief Retrieve object information about a thread from its
+ * thread object instance.
+ *
+ * @param  thridx     Thread table index of thread definition for which
+ *                    to locate its class definition
+ *                   @link #jvm_table_linkage jvm_table_linkage@endlink.
+ *
+ *
+ * @returns (jvm_table_linkage *) to object table class linkage entry
+ *
+ *
+ * @note  This macro will return @link #rnull rnull@endlink if
+ *        the object hash in this slot is a
+ *        @link #jvm_thread_index_null jvm_thread_index_null@endlink
+ *        reference.
+ *        
+ */
+#define THREAD_OBJECT_LINKAGE(thridx)                         \
+    ((THREAD(thridx).thread_objhash != jvm_object_hash_null)  \
+     ? (&OBJECT(THREAD(thridx).thread_objhash).table_linkage) \
+     : (jvm_table_linkage *) rnull)
+
+
+/*!
+ * @def OBJECT_THREAD_LINKAGE()
+ *
+ * @brief Retrieve thread information about an object from its
+ * thread entry.
+ *
+ *
+ * @param  objhash    Object hash of object for which to locate its
+ *                    thread table entry.
+ *
+ *
+ * @returns (jvm_table_linkage *) to object table class linkage entry of
+ *                               <b><code>java.lang.Thread</code></b>
+ *                               class object.
+ *
+ * @note  This macro will return @link #rnull rnull@endlink if the
+ * object in this slot is not a <b><code>java.lang.Thread</code></b>
+ * object and one which indexes a valid thread.
+ *
+ */
+#define OBJECT_THREAD_LINKAGE(objhash)                                 \
+    (((OBJECT(objhash).status & OBJECT_STATUS_INUSE) &&                \
+      (OBJECT(objhash).status & OBJECT_STATUS_THREAD) &&               \
+      (jvm_thread_index_null != OBJECT(objhash).table_linkage.thridx)) \
+     ? (&OBJECT(objhash).table_linkage)                                \
+     : ((jvm_table_linkage *) rnull))
+
+
+/*!
+ * @def VERIFY_OBJECT_THREAD_LINKAGE()
+ *
+ * @brief Verify that a thread slot is in use, is not a null thread,
+ * and contains a valid thread object hash.
+ *
+ * @param  objhash    Object hash of object for which to verify its
+ *                    thread linkage and its thread table entry.
+ *
+ *
+ * @returns @link #rtrue rtrue@endlink if this object hash indicates
+ * a valid thread linkage and a thread table slot, otherwise
+ * @link #rfalse rfalse@endlink.
+ *
+ */
+#define VERIFY_OBJECT_THREAD_LINKAGE(objhash)   \
+   ((rnull != (OBJECT_THREAD_LINKAGE(objhash))) \
+    ? rtrue                                     \
+    : rfalse)
+
+
+/* Finally the object self-referential definitions: */
+
+/*!
+ * @def OBJECT_OBJECT_LINKAGE()
+ *
+ * @brief Retrieve object information about an object from itself.
+ *
+ * @param  objhash    Object hash of object for which
+ *                    to locate its class definition
+ *                   @link #jvm_table_linkage jvm_table_linkage@endlink.
+ *
+ *
+ * @returns (jvm_table_linkage *) to object table class linkage entry
+ *
+ *
+ * @note  This macro will return @link #rnull rnull@endlink if the
+ *        object hash in this slot is a
+ *        @link #jvm_object_hash_null jvm_object_hash_null@endlink
+ *        reference.
+ *
+ */
+
+#define OBJECT_OBJECT_LINKAGE(objhash)             \
+    ((OBJECT(objhash).status & OBJECT_STATUS_INUSE) \
+     ? (&OBJECT(objhash).table_linkage)             \
+     : (jvm_table_linkage *) rnull)
+
+
+/* Prototypes for functions in 'linkage.c' */
+extern rboolean linkage_resolve_class(jvm_class_index clsidx,
+                                      rboolean    find_registerNatives);
+
+extern rboolean linkage_unresolve_class(jvm_class_index clsidx);
+
+#endif /* _linkage_h_included_ */
+
+
+/* EOF */

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/bootjvm/bootJVM/jvm/src/main.c
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/bootjvm/bootJVM/jvm/src/main.c?rev=307257&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/bootjvm/bootJVM/jvm/src/main.c (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/bootjvm/bootJVM/jvm/src/main.c Fri Oct  7 21:27:56 2005
@@ -0,0 +1,84 @@
+/*!
+ * @file jvm/src/main.c
+ *
+ * @brief Entry point for bootstrap Java Virtual Machine
+ *
+ * The normal invocation of the JVM is very simple: just pass
+ * the main() parameters into the JVM entry point, then call
+ * @c @b exit(2) with the return code from it.  That's all there
+ * is to it from the top level.
+ *
+ *
+ * @section Control
+ *
+ * \$URL: https://svn.apache.org/path/name/main.c $ \$Id: main.c 0 09/28/2005 dlydick $
+ *
+ * Copyright 2005 The Apache Software Foundation
+ * or its licensors, as applicable.
+ *
+ * Licensed under the Apache License, Version 2.0 ("the License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied.
+ *
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * @version \$LastChangedRevision: 0 $
+ *
+ * @date \$LastChangedDate: 09/28/2005 $
+ *
+ * @author \$LastChangedBy: dlydick $
+ *         Original code contributed by Daniel Lydick on 09/28/2005.
+ *
+ * @section Reference
+ *
+ */
+
+#include "arch.h"
+ARCH_COPYRIGHT_APACHE(main, c, "$URL: https://svn.apache.org/path/name/main.c $ $Id: main.c 0 09/28/2005 dlydick $");
+
+
+#include <stdlib.h>
+
+#include "jvmcfg.h"
+#include "classfile.h"
+#include "jvm.h"
+
+
+/*!
+ * @brief Example of invoking the main JVM entry point
+ *
+ * The arguments to @link #jvm() jvm()@endlink are identical in
+ * format and presentation to those used to enter a 'C' main program.
+ *
+ *
+ * @param argc  Number of parameters being passed in @b argv
+ *
+ * @param argv  Array of null-terminated strings, @b argv[0] being the
+ *              program name, @b argv[1] being the first argument, etc.
+ *
+ * @param envp  Environment pointer
+ *
+ *
+ * @returns exit code from @link #jvm() jvm()@endlink
+ *
+ */
+int main(int argc, char **argv, char **envp)
+{
+    /* Run the JVM and retrieve its return code */
+    int rc = jvm(argc, argv, envp);
+
+    /* Report the return code to the OS shell */
+    exit(rc);
+
+} /* END of main() */
+
+
+/* EOF */

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/bootjvm/bootJVM/jvm/src/manifest.c
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/bootjvm/bootJVM/jvm/src/manifest.c?rev=307257&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/bootjvm/bootJVM/jvm/src/manifest.c (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/bootjvm/bootJVM/jvm/src/manifest.c Fri Oct  7 21:27:56 2005
@@ -0,0 +1,189 @@
+/*!
+ * @file manifest.c
+ *
+ * @brief Read JAR manifest file.
+ *
+ *
+ * @section Control
+ *
+ * \$URL: https://svn.apache.org/path/name/manifest.c $ \$Id: manifest.c 0 09/28/2005 dlydick $
+ *
+ * Copyright 2005 The Apache Software Foundation
+ * or its licensors, as applicable.
+ *
+ * Licensed under the Apache License, Version 2.0 ("the License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied.
+ *
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * @version \$LastChangedRevision: 0 $
+ *
+ * @date \$LastChangedDate: 09/28/2005 $
+ *
+ * @author \$LastChangedBy: dlydick $
+ *         Original code contributed by Daniel Lydick on 09/28/2005.
+ *
+ * @section Reference
+ *
+ */
+
+#include "arch.h"
+ARCH_COPYRIGHT_APACHE(manifest, c, "$URL: https://svn.apache.org/path/name/manifest.c $ $Id: manifest.c 0 09/28/2005 dlydick $");
+
+
+#include <stdio.h>
+#include <ctype.h>
+#include <strings.h>
+
+#include "jvmcfg.h"
+#include "heap.h" 
+#include "exit.h"
+#include "util.h"
+
+/*!
+ * @brief Search a JAR manifest file for a main class attribute.
+ *
+ * This attribute MUST be all on one line and without any
+ * line continuations breaking up the class name.  Look for
+ * a line of text like this, where @b | indicates that the
+ * following character is the first one on the line:
+ *
+ * @verbatim
+      |
+      |Main-Class: name.of.start.class\n
+      |
+  
+   WITHOUT any line continuations,
+  
+      |
+      |Main-Class: name.of.sta\n
+      | rt.class\n
+      |
+  
+   @endverbatim
+ *
+ * @todo  Although such a continuation is supported by the JAR file,
+ * this implementation does not support it (yet).  With this
+ * restriction, the if only one single space separates the name of
+ * the attribute and the class name, then since a line may be up
+ * to 72 characters long (that is JVMCFG_JARFILE_MANIFEST_LINE_MAX
+ * characters), then the class name may be 61 characters long.
+ *
+ *
+ * @param  mnfname   JAR manifest file name, /absolute/path/name
+ *         
+ *
+ * @returns Heap pointer to null-terminated class name, or
+ *          @link #rnull rnull@endlink if not found.
+ *          Call HEAP_FREE_DATA() when done.
+ *
+ */
+rchar *manifest_get_main(rchar *mnfname)
+{
+    FILE *mf = fopen(mnfname, "r");
+
+    if (rnull == mf)
+    {
+        return((rchar *) rnull);
+    }
+
+    rchar *mnfdata = HEAP_GET_DATA(JVMCFG_STDIO_BFR, rfalse);
+
+    int mclen =  strlen(JVMCFG_JARFILE_MANIFEST_MAIN_CLASS);
+
+    /* Read until end of file or match located */
+    while (mnfdata == (rchar *) fgets(mnfdata, JVMCFG_STDIO_BFR, mf))
+    {
+        /*
+         * Scan for ^Main-Class: attribute name (text starting
+         * at beginnin of line)
+         */
+        if (0 != strncmp(mnfdata,
+                         JVMCFG_JARFILE_MANIFEST_MAIN_CLASS,
+                         mclen))
+        {
+            continue;
+        }
+
+        /*
+         * Attribute name found.
+         *
+         * Scan for first non-white character after attribute name.
+         * This will be the start of the class name.
+         */
+        rint i;
+        for (i = mclen; i < strlen(mnfdata); i++)
+        {
+            /* if <b>white space</b> is rfalse */
+            if (0 == isspace((int) mnfdata[i]))
+            {
+                break; /* Found first non-white-space character */
+            }
+        }
+        /* If nothing else, the \n at end of line is white space */
+
+        /*
+         * Class name found.
+         *
+         * Scan for first white character after class name.
+         * This will be the end of the class name.
+         */
+        rint j;
+        for (j = i; j < strlen(mnfdata); j++)
+        {
+            /* if <b>white space</b> is @link #rtrue rtrue@endlink */
+            if (0 != isspace((int) mnfdata[j]))
+            {
+                break;  /* Found first white-space character */
+            }
+        }
+        /* If nothing else, the \n at end of line is white space */
+
+        fclose(mf);
+
+        /* Allocate space for non-empty class name plus NUL byte */
+        rchar *mnfresult;
+        if (i != j)
+        { 
+            mnfresult = HEAP_GET_DATA(j - i + sizeof(rchar), rfalse);
+
+            /* If failure above, HEAP_FREE_DATA(mnfdata) is never run */
+        }
+        else
+        {
+            /* Do not process empty class name, declare error instead */
+            HEAP_FREE_DATA(mnfdata);
+
+            sysErrMsg("manifest_get_main",
+                      "Missing class name in manifest file %s",
+                      mnfname);
+            exit_jvm(EXIT_MANIFEST_JAR);
+/*NOTREACHED*/
+        }
+
+        memcpy(mnfresult, &mnfdata[i], j - i);
+        mnfresult[j - i] = '\0';
+
+        HEAP_FREE_DATA(mnfdata);
+        return(mnfresult);
+    }
+
+    fclose(mf);
+
+    HEAP_FREE_DATA(mnfdata);
+
+    return((rchar *) rnull);
+
+} /* END of manifest_get_main() */
+
+
+/* EOF */

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/bootjvm/bootJVM/jvm/src/method.c
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/bootjvm/bootJVM/jvm/src/method.c?rev=307257&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/bootjvm/bootJVM/jvm/src/method.c (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/bootjvm/bootJVM/jvm/src/method.c Fri Oct  7 21:27:56 2005
@@ -0,0 +1,237 @@
+/*!
+ * @file method.c
+ *
+ * @brief Manipulate ClassFile methods.
+ *
+ *
+ * @section Control
+ *
+ * \$URL: https://svn.apache.org/path/name/method.c $ \$Id: method.c 0 09/28/2005 dlydick $
+ *
+ * Copyright 2005 The Apache Software Foundation
+ * or its licensors, as applicable.
+ *
+ * Licensed under the Apache License, Version 2.0 ("the License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied.
+ *
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * @version \$LastChangedRevision: 0 $
+ *
+ * @date \$LastChangedDate: 09/28/2005 $
+ *
+ * @author \$LastChangedBy: dlydick $
+ *         Original code contributed by Daniel Lydick on 09/28/2005.
+ *
+ * @section Reference
+ *
+ */
+
+#include "arch.h"
+ARCH_COPYRIGHT_APACHE(method, c, "$URL: https://svn.apache.org/path/name/method.c $ $Id: method.c 0 09/28/2005 dlydick $");
+
+
+#include <stdlib.h>
+#include <strings.h>
+
+#include "jvmcfg.h"
+#include "cfmacros.h"
+#include "classfile.h"
+#include "exit.h"
+#include "jvm.h"
+#include "jvmclass.h"
+#include "linkage.h"
+#include "nts.h"
+#include "utf.h"
+
+
+/*!
+ * @brief Locate the method_info index for a normal method in a class
+ * using a constant_pool entry to the name and description of
+ * the method.
+ *
+ *
+ * @param  clsidx            Class index of class whose method is to be
+ *                             located.
+ *
+ * @param  mthname           UTF8 constant_pool entry of name of method
+ *                             in class.
+ *
+ * @param  mthdesc           UTF8 constant_pool entry of description of
+ *                             method parameters and return type.
+ *
+ *
+ * @returns method table index of this method in class or
+ *          @link #jvm_method_index_bad jvm_method_index_bad@endlink
+ *          if not found.
+ *
+ *
+ * Throws: nothing.  Let caller throw an error like
+ *         JVMCLASS_JAVA_LANG_NOSUCHMETHODERROR if it is
+ *         useful at that point.  The purpose of this
+ *         function is simply to locate the method, not
+ *         make a value judgment on the meaning of the
+ *         search result.
+ *
+ */
+jvm_method_index method_find_by_cp_entry(jvm_class_index  clsidx,
+                                         cp_info_dup     *mthname,
+                                         cp_info_dup     *mthdesc)
+{
+    /* Prohibit invalid parameter */
+    if (jvm_class_index_null == clsidx)
+    {
+        exit_throw_exception(EXIT_JVM_METHOD,
+                             JVMCLASS_JAVA_LANG_INTERNALERROR);
+    }
+
+    /* Prohibit non-UTF8 CP entries from being parsed */
+    CONSTANT_Utf8_info *pmthdata = PTR_THIS_CP_Utf8(mthname);
+    if (CONSTANT_Utf8 != pmthdata->tag)
+    {
+        return(jvm_method_index_bad);
+    }
+
+    pmthdata = PTR_THIS_CP_Utf8(mthdesc);
+    if (CONSTANT_Utf8 != pmthdata->tag)
+    {
+        return(jvm_method_index_bad);
+    }
+
+    /* Point to class structure, then look for method  */
+    ClassFile *pcfs = CLASS_OBJECT_LINKAGE(clsidx)->pcfs;
+
+    u2 mcount = pcfs->methods_count;
+    jvm_method_index mthidx;
+    for (mthidx = 0; mthidx < mcount; mthidx++)
+    {
+        /* Report a match of method name and description when found */
+        if ((0 == utf_pcfs_strcmp(PTR_THIS_CP_Utf8(mthname),
+                                  pcfs,
+                                  pcfs->methods[mthidx]->name_index))
+            &&
+            (0 == utf_pcfs_strcmp(PTR_THIS_CP_Utf8(mthdesc),
+                                  pcfs,
+                                  pcfs
+                                    ->methods[mthidx]
+                                      ->descriptor_index)))
+        {
+            return(mthidx);
+        }
+    }
+
+    /* Not found */
+    return(jvm_method_index_bad);
+
+} /* END of method_find_by_cp_entry() */
+
+
+/*!
+ * @brief Retrieve by <b><code>(rchar *)</code></b> name a method
+ * index to a method in a class.
+ *
+ *
+ * @param  clsidx            Class index of class whose method is to be
+ *                             located.
+ *
+ * @param  mthname           Null-terminated string of name of method
+ *                             in class.
+ *
+ * @param  mthdesc           Null-terminated string of description of
+ *                             method parameters and return type.
+ *
+ *
+ * @returns method index of located method in class, otherwise
+ *          @link #jvm_method_index_bad jvm_method_index_bad@endlink.
+ *
+ */
+jvm_method_index
+    method_find_by_prchar(jvm_class_index  clsidx,
+                          rchar           *mthname,
+                          rchar           *mthdesc)
+{
+    cp_info_dup *pcip_mthname = nts_prchar2utf(mthname);
+    cp_info_dup *pcip_mthdesc = nts_prchar2utf(mthdesc);
+
+    jvm_method_index rc =
+        method_find_by_cp_entry(clsidx, pcip_mthname, pcip_mthdesc);
+
+    HEAP_FREE_DATA(pcip_mthname);
+    HEAP_FREE_DATA(pcip_mthdesc);
+
+    return(rc);
+
+} /* END of method_find_by_prchar() */
+
+/*!
+ * @brief Extract method return type from descriptor
+ *
+ *
+ * @param clsidx      Class table index of method to examine.
+ *
+ * @param mthdescidx  Class file constant_pool index of method
+ *                    descriptor to examine.  This entry must be a
+ *                    CONSTANT_Utf8_info string containing the
+ *                    descriptor of an unqualified method name.
+ *
+ *
+ * @returns Primative base type of method return value or
+ *          @link #LOCAL_BASETYPE_ERROR LOCAL_BASETYPE_ERROR@endlink
+ *          if not found.
+ *
+ */
+jvm_basetype method_return_type(jvm_class_index         clsidx,
+                                jvm_constant_pool_index mthdescidx)
+{
+    cp_info_dup        *pcpd;
+    CONSTANT_Utf8_info *pcpd_Utf8;
+
+    pcpd =CLASS_OBJECT_LINKAGE(clsidx)->pcfs->constant_pool[mthdescidx];
+    pcpd_Utf8 = PTR_THIS_CP_Utf8(pcpd);
+
+    u2 idx;
+           /* Last char will be result:/ - 1/ except 'Lsome/class;' */
+    for(idx = 0; idx < pcpd_Utf8->length - 1; idx++)
+    {
+        /* Scan for parm list closure, next char is return type */
+        if (METHOD_CHAR_CLOSE_PARM == pcpd_Utf8->bytes[idx])
+        {
+            switch (pcpd_Utf8->bytes[idx + 1])
+            {
+                case BASETYPE_CHAR_B:
+                case BASETYPE_CHAR_C:
+                case BASETYPE_CHAR_D:
+                case BASETYPE_CHAR_F:
+                case BASETYPE_CHAR_I:
+                case BASETYPE_CHAR_J:
+                case BASETYPE_CHAR_L:
+                case BASETYPE_CHAR_S:
+                case BASETYPE_CHAR_Z:
+                case BASETYPE_CHAR_ARRAY:
+                case METHOD_CHAR_VOID:
+                    return((jvm_basetype) pcpd_Utf8->bytes[idx + 1]);
+            }
+        }
+    }
+
+    /*!
+     * @todo  Should this throw a @b VerifyError instead?
+     *        Is it better to let caller do this?
+     */
+
+    /* Error, something else found */
+    return((jvm_basetype) LOCAL_BASETYPE_ERROR);
+
+} /* END of method_return_type() */
+
+
+/* EOF */

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/bootjvm/bootJVM/jvm/src/method.h
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/bootjvm/bootJVM/jvm/src/method.h?rev=307257&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/bootjvm/bootJVM/jvm/src/method.h (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/bootjvm/bootJVM/jvm/src/method.h Fri Oct  7 21:27:56 2005
@@ -0,0 +1,86 @@
+#ifndef _method_h_included_
+#define _method_h_included_
+
+/*!
+ * @file method.h
+ *
+ * @brief Method management functions for the JVM.
+ *
+ *
+ * @section Control
+ *
+ * \$URL: https://svn.apache.org/path/name/method.h $ \$Id: method.h 0 09/28/2005 dlydick $
+ *
+ * Copyright 2005 The Apache Software Foundation
+ * or its licensors, as applicable.
+ *
+ * Licensed under the Apache License, Version 2.0 ("the License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied.
+ *
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * @version \$LastChangedRevision: 0 $
+ *
+ * @date \$LastChangedDate: 09/28/2005 $
+ *
+ * @author \$LastChangedBy: dlydick $
+ *         Original code contributed by Daniel Lydick on 09/28/2005.
+ *
+ * @section Reference
+ *
+ */
+
+ARCH_COPYRIGHT_APACHE(method, h, "$URL: https://svn.apache.org/path/name/method.h $ $Id: method.h 0 09/28/2005 dlydick $");
+
+
+/*!
+ * @def METHOD
+ * @brief Access structures of a class' method table at certain index.
+ *
+ * Each class has a table of methods, divided into virtual methods
+ * @e within the Java code and native methods referenced @e from the
+ * Java code and implemented in some outside object library.
+ * They may be distinquished by the @link #ACC_NATIVE ACC_NATIVE@endlink
+ * status bit in @link #rclass.status rclass.status@endlink
+ * This macro references one of them using the @p @b clsidx index for
+ * the class and @p @b mthidx for the method table entry in that class.
+ *
+ * @param clsidx  Class table index into the global
+ * @link #rjvm.class rjvm.class[]@endlink array (via
+ * @link #pjvm pjvm->class[]@endlink).
+ * 
+ * @param mthidx  Index into method table for this class.
+ * 
+ * @returns pointer to a method table entry
+ * 
+ */
+#define METHOD(clsidx, mthidx) \
+    (CLASS_OBJECT_LINKAGE(clsidx)->pcfs->methods[mthidx])
+
+
+/* Prototypes for functions in 'method.c' */
+
+extern
+    jvm_method_index method_find_by_cp_entry(jvm_class_index  clsidx,
+                                             cp_info_dup    *mthname,
+                                             cp_info_dup    *mthdesc);
+
+extern jvm_method_index method_find_by_prchar(jvm_class_index  clsidx,
+                                              rchar           *mthname,
+                                              rchar           *mthdesc);
+
+extern jvm_basetype method_return_type(jvm_class_index      clsidx,
+                                    jvm_constant_pool_index mthdescidx);
+
+#endif /* _method_h_included_ */
+
+/* EOF */



Mime
View raw message