vmtype.java

来自「纯java操作系统jnode,安装简单和操作简单的个人使用的Java操作系统」· Java 代码 · 共 1,918 行 · 第 1/4 页

/**
 * $Id: VmType.java,v 1.16 2004/02/24 08:04:15 epr Exp $
 */

package org.jnode.vm.classmgr;

import java.lang.reflect.InvocationTargetException;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;

import org.jnode.assembler.NativeStream;
import org.jnode.vm.PragmaLoadStatics;
import org.jnode.vm.Uninterruptible;
import org.jnode.vm.Unsafe;
import org.jnode.vm.VmReflection;
import org.jnode.vm.VmSystemObject;
import org.jnode.vm.compiler.NativeCodeCompiler;

public abstract class VmType extends VmSystemObject implements VmStaticsEntry, Uninterruptible {

    /**
     * The parent of this class. Normally VmClass instance, during loading
     * String instance
     */
    private VmNormalClass superClass;

    /** The classname of the parent of this class. */
    private final String superClassName;

    /** The number of super classes until (and including) Object */
    private int superClassDepth;

    /** The name of this class */
    private String name;

    /** All methods and constructors declared in this class */
    private VmMethod[] methodTable;

    /** All fields declared in this class */
    private VmField[] fieldTable;

    /** My modifiers */
    private int modifiers = -1;

    /** State of this type see {@link VmTypeState}. */
    private int state;

    /** The constant pool */
    private VmCP cp;

    /** Interface implemented by this class */
    private VmImplementedInterface[] interfaceTable;

    /** All interface implemented by this class and its superclasses */
    private VmInterfaceClass[] allInterfaceTable;

    /** Loaded of this class */
    private final VmClassLoader loader;

    /** The corresponding java.lang.Class of this class */
    private Class javaClass;

    /** Have the references in the constant pool been resolved? */
    private boolean resolvedCpRefs;

    /** Size of instances of this class in bytes (1..8) */
    private final int typeSize;

    /** Name of the array class with this class as component type */
    private String arrayClassName;

    /** The array class with this class as component type */
    private VmArrayClass arrayClass;

    /** Array containing all super classes and all implemented interfaces */
    private VmType[] superClassesArray;

    /** The finalize method of this class */
    private VmMethod finalizeMethod;

    /** The mangled name (cache) */
    private String mangledName;

    /** Error message during linkage */
    private String errorMsg;
    
    /** Index of this type in the statics index */
    private final int staticsIndex;

    private static VmNormalClass ObjectClass;

    private static VmInterfaceClass CloneableClass;

    private static VmInterfaceClass SerializableClass;

    private static VmNormalClass BooleanClass;

    private static VmNormalClass ByteClass;

    private static VmNormalClass CharClass;

    private static VmNormalClass ShortClass;

    private static VmNormalClass IntClass;

    private static VmNormalClass FloatClass;

    private static VmNormalClass LongClass;

    private static VmNormalClass DoubleClass;

    private static VmNormalClass VoidClass;

    private static VmArrayClass BooleanArrayClass;

    private static VmArrayClass ByteArrayClass;

    private static VmArrayClass CharArrayClass;

    private static VmArrayClass ShortArrayClass;

    private static VmArrayClass IntArrayClass;

    private static VmArrayClass FloatArrayClass;

    private static VmArrayClass LongArrayClass;

    private static VmArrayClass DoubleArrayClass;

    private static VmArrayClass ObjectArrayClass;

    /**
     * Construct a new VmClass
     * 
     * @param name
     * @param superClassName
     * @param loader
     * @param accessFlags
     */
    protected VmType(String name, String superClassName, VmClassLoader loader,
            int accessFlags) {
        this(name, null, superClassName, loader, accessFlags, -1);
    }

    /**
     * Construct a new VmClass with a given name and superclass
     * 
     * @param name
     * @param superClass
     * @param loader
     * @param typeSize
     */
    VmType(String name, VmNormalClass superClass, VmClassLoader loader,
            int typeSize) {
        this(name, superClass, superClass.getName(), loader,
                Modifier.ACC_PUBLIC, typeSize);
    }

    /**
     * Construct a new VmClass with a given name and superclass
     * 
     * @param name
     * @param superClass
     * @param superClassName
     * @param loader
     * @param accessFlags
     * @param typeSize
     */
    private VmType(String name, VmNormalClass superClass,
            String superClassName, VmClassLoader loader, int accessFlags,
            int typeSize) {
        if (superClassName == null) {
            if (!name.equals("java.lang.Object")) { throw new IllegalArgumentException(
                    "superClassName cannot be null in class " + name); }
        } else if (superClassName.indexOf('/') >= 0) { throw new IllegalArgumentException(
                "superClassName contains '/'"); }
        if (name.indexOf('/') >= 0) { throw new IllegalArgumentException(
                "name contains '/'"); }

        this.name = name;
        this.superClass = superClass;
        this.superClassName = superClassName;
        this.modifiers = accessFlags;
        this.state = VmTypeState.ST_LOADED;
        this.loader = loader;
        this.staticsIndex = loader.getStatics().allocClass(this);
        if (name.charAt(0) == '[') {
            this.interfaceTable = new VmImplementedInterface[] {
                    new VmImplementedInterface(CloneableClass),
                    new VmImplementedInterface(SerializableClass)};
            this.typeSize = loader.getArchitecture().getReferenceSize();
        } else if (typeSize >= 0) {
            this.typeSize = typeSize;
        } else {
            this.typeSize = loader.getArchitecture().getReferenceSize();
        }

    }

    /**
     * Load the system classes during our bootstrap process.
     * 
     * @param clc
     * @return VmClass[]
     * @throws ClassNotFoundException
     */
    public final static VmType[] initializeForBootImage(VmClassLoader clc)
            throws ClassNotFoundException {
        ObjectClass = (VmNormalClass) clc.loadClass("java.lang.Object", false);
        CloneableClass = (VmInterfaceClass) clc.loadClass(
                "java.lang.Cloneable", false);
        SerializableClass = (VmInterfaceClass) clc.loadClass(
                "java.io.Serializable", false);

        ObjectClass.link();
        CloneableClass.link();
        SerializableClass.link();

        BooleanClass = new VmPrimitiveClass("boolean", ObjectClass, clc, 1,
                false);
        ByteClass = new VmPrimitiveClass("byte", ObjectClass, clc, 1, false);
        CharClass = new VmPrimitiveClass("char", ObjectClass, clc, 2, false);
        ShortClass = new VmPrimitiveClass("short", ObjectClass, clc, 2, false);
        IntClass = new VmPrimitiveClass("int", ObjectClass, clc, 4, false);
        FloatClass = new VmPrimitiveClass("float", ObjectClass, clc, 4, true);
        LongClass = new VmPrimitiveClass("long", ObjectClass, clc, 8, false);
        DoubleClass = new VmPrimitiveClass("double", ObjectClass, clc, 8, true);
        VoidClass = new VmPrimitiveClass("void", ObjectClass, clc, 0, false);

        BooleanClass.link();
        ByteClass.link();
        CharClass.link();
        ShortClass.link();
        IntClass.link();
        FloatClass.link();
        LongClass.link();
        DoubleClass.link();
        VoidClass.link();

        BooleanArrayClass = BooleanClass.getArrayClass("[Z");
        ByteArrayClass = ByteClass.getArrayClass("[B");
        CharArrayClass = CharClass.getArrayClass("[C");
        ShortArrayClass = ShortClass.getArrayClass("[S");
        IntArrayClass = IntClass.getArrayClass("[I");
        FloatArrayClass = FloatClass.getArrayClass("[F");
        LongArrayClass = LongClass.getArrayClass("[J");
        DoubleArrayClass = DoubleClass.getArrayClass("[D");
        ObjectArrayClass = ObjectClass.getArrayClass();

        BooleanArrayClass.link();
        ByteArrayClass.link();
        CharArrayClass.link();
        ShortArrayClass.link();
        IntArrayClass.link();
        FloatArrayClass.link();
        LongArrayClass.link();
        DoubleArrayClass.link();
        ObjectArrayClass.link();

        return new VmType[] { ObjectClass, CloneableClass, SerializableClass,
                BooleanClass, ByteClass, CharClass, ShortClass, IntClass,
                FloatClass, LongClass, DoubleClass, VoidClass,
                BooleanArrayClass, ByteArrayClass, CharArrayClass,
                ShortArrayClass, IntArrayClass, FloatArrayClass,
                LongArrayClass, DoubleArrayClass, ObjectArrayClass,};
    }

    /**
     * Load the system classes from an array of system classes. This method is
     * called during the boot of the system.
     * 
     * @param bootClasses
     */
    protected static void loadFromBootClassArray(VmType[] bootClasses)
    throws PragmaLoadStatics {
        Unsafe.debug("loadFromBootClassArray");
        int count = bootClasses.length;
        for (int i = 0; i < count; i++) {
            VmType vmClass = bootClasses[ i];
            String name = vmClass.name;
            if (vmClass.isPrimitive()) {
                if (name.equals("boolean")) {
                    BooleanClass = (VmNormalClass) vmClass;
                } else if (name.equals("byte")) {
                    ByteClass = (VmNormalClass) vmClass;
                } else if (name.equals("char")) {
                    CharClass = (VmNormalClass) vmClass;
                } else if (name.equals("short")) {
                    ShortClass = (VmNormalClass) vmClass;
                } else if (name.equals("int")) {
                    IntClass = (VmNormalClass) vmClass;
                } else if (name.equals("float")) {
                    FloatClass = (VmNormalClass) vmClass;
                } else if (name.equals("long")) {
                    LongClass = (VmNormalClass) vmClass;
                } else if (name.equals("double")) {
                    DoubleClass = (VmNormalClass) vmClass;
                } else if (name.equals("void")) {
                    VoidClass = (VmNormalClass) vmClass;
                }
            } else if (vmClass.isArray()) {
                if (name.equals("[Z")) {
                    BooleanArrayClass = (VmArrayClass) vmClass;
                } else if (name.equals("[B")) {
                    ByteArrayClass = (VmArrayClass) vmClass;
                } else if (name.equals("[C")) {
                    CharArrayClass = (VmArrayClass) vmClass;
                } else if (name.equals("[S")) {
                    ShortArrayClass = (VmArrayClass) vmClass;
                } else if (name.equals("[I")) {
                    IntArrayClass = (VmArrayClass) vmClass;
                } else if (name.equals("[F")) {
                    FloatArrayClass = (VmArrayClass) vmClass;
                } else if (name.equals("[J")) {
                    LongArrayClass = (VmArrayClass) vmClass;
                } else if (name.equals("[D")) {
                    DoubleArrayClass = (VmArrayClass) vmClass;
                }
            } else if (name.equals("java.lang.Object")) {
                ObjectClass = (VmNormalClass) vmClass;
            } else if (name.equals("java.lang.Cloneable")) {
                CloneableClass = (VmInterfaceClass) vmClass;
            } else if (name.equals("java.io.Serializable")) {
                SerializableClass = (VmInterfaceClass) vmClass;
            }
        }
    }

    /**
     * Create an array classname with a this class as component type.
     * 
     * @return char[]
     */
    public final String getArrayClassName() {
        if (arrayClassName == null) {
            char[] result;
            int count = name.length();
            if (isPrimitive() || isArray()) {
                result = new char[ count + 1];
                result[ 0] = '[';
                for (int i = 0; i < count; i++) {
                    result[ i + 1] = name.charAt(i);
                }
            } else {
                result = new char[ count + 3];
                result[ 0] = '[';
                result[ 1] = 'L';
                result[ count + 2] = ';';
                for (int i = 0; i < count; i++) {
                    result[ i + 2] = name.charAt(i);
                }
            }
            arrayClassName = new String(result);
        }
        return arrayClassName;
    }

    /**
     * Gets the array class with this class as its component type
     * 
     * @param arrayClassName
     * @return The array class
     */
    final VmArrayClass getArrayClass(String arrayClassName) {
        if (arrayClass == null) {
            arrayClass = createArrayClass(true, arrayClassName);
        } else {
            arrayClass.link();
        }
        return arrayClass;
    }

    /**
     * Gets the array class with this class as its component type
     * 
     * @return The array class
     */
    public final VmArrayClass getArrayClass() {
        return getArrayClass(null);
    }

    /**
     * Gets the array class with this class as its component type
     * 
     * @param link
     * @return The array class
     */
    final VmArrayClass getArrayClass(boolean link) {
        if (arrayClass == null) {
            arrayClass = createArrayClass(link, null);
        }
        return arrayClass;
    }

    /**
     * Create an array class with a given component type.
     * 
     * @param link
     *            True if the new class should be linked, false otherwise
     * @param arrayClassName
     * @return VmClass
     */
    private final VmArrayClass createArrayClass(boolean link,
            String arrayClassName) {
        final String name;
        if (arrayClassName != null) {
            name = arrayClassName;
        } else {
            name = getArrayClassName();
        }
        final VmArrayClass arrayClass = new VmArrayClass(name,
                this.getLoader(), this, -1);
        if (link) {
            arrayClass.link();
        }
        return arrayClass;
    }

    /**
     * Gets the VmClass of java.lang.Object.
     * 
     * @return The class
     */
    public final static VmNormalClass getObjectClass() {
        return ObjectClass;
    }

    /**
     * Gets the primitive class corresponding to the given signature type.
     * 
     * @param type
     * @return VmClass
     */
    public final static VmNormalClass getPrimitiveClass(char type) {
        switch (type) {
        case 'Z':
            return BooleanClass;
        case 'B':
            return ByteClass;
        case 'C':
            return CharClass;
        case 'S':
            return ShortClass;
        case 'I':
            return IntClass;
        case 'F':
            return FloatClass;
        case 'J':
            return LongClass;
        case 'D':
            return DoubleClass;
        case 'V':
            return VoidClass;
        default:
            throw new IllegalArgumentException("Unknown type " + type);
        }
    }

    /**
     * Gets the primitive arrayclass corresponding to the given signature type.
     * 
     * @param type
     * @return VmClass
     */
    public final static VmType getPrimitiveArrayClass(char type) {
        switch (type) {
        case 'Z':
            return BooleanArrayClass;
        case 'B':
            return ByteArrayClass;
        case 'C':
            return CharArrayClass;
        case 'S':
            return ShortArrayClass;
        case 'I':
            return IntArrayClass;
        case 'F':
            return FloatArrayClass;