001: /*
002: * @(#)CVMClassFactory.java 1.22 06/10/22
003: *
004: * Copyright 1990-2006 Sun Microsystems, Inc. All Rights Reserved.
005: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
006: *
007: * This program is free software; you can redistribute it and/or
008: * modify it under the terms of the GNU General Public License version
009: * 2 only, as published by the Free Software Foundation.
010: *
011: * This program is distributed in the hope that it will be useful, but
012: * WITHOUT ANY WARRANTY; without even the implied warranty of
013: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
014: * General Public License version 2 for more details (a copy is
015: * included at /legal/license.txt).
016: *
017: * You should have received a copy of the GNU General Public License
018: * version 2 along with this work; if not, write to the Free Software
019: * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
020: * 02110-1301 USA
021: *
022: * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
023: * Clara, CA 95054 or visit www.sun.com if you need additional
024: * information or have any questions.
025: *
026: */
027:
028: package vm;
029:
030: import consts.Const;
031: import components.ClassInfo;
032: import components.ClassTable;
033: import components.ConstantPool;
034: import runtime.CVMWriter;
035: import util.Localizer;
036: import util.UnresolvedReferenceList;
037: import java.util.Comparator;
038: import java.util.Hashtable;
039:
040: public class CVMClassFactory implements VMClassFactory, Comparator {
041:
042: static String primitiveTypeName[] = { "void", "boolean", "char",
043: "byte", "short", "int", "long", "float", "double" };
044:
045: /*
046: * STATIC INITIALIZER:
047: * MAKE SURE THE PRIMITIVE TYPES GET SMALL TYPEID NUMBERS
048: * DO THIS BEFORE CONSTRUCTION OF ANY CVMClass!
049: */
050: static {
051: for (int i = 0; i < primitiveTypeName.length; i++) {
052: CVMDataType.lookupClassname(primitiveTypeName[i]);
053: }
054: }
055:
056: public ClassClass newVMClass(ClassInfo c) {
057: return new CVMClass(c);
058: }
059:
060: private static void setType(String name, int value) {
061: ClassInfo ci = ClassTable.lookupClass(name);
062: ClassClass cc;
063: if ((ci == null) || ((cc = ci.vmClass) == null)) {
064: throw new Error("Lookup failed for primitive class " + name);
065: }
066: ((CVMClass) cc).typeCode = value;
067: }
068:
069: private static void setAllClassID() {
070: // null had better work here!
071: // we'll find out soon enough.
072: ClassClass allClasses[] = ClassClass.getClassVector(null);
073: int n = allClasses.length;
074: for (int i = 0; i < n; i++) {
075: CVMClass cvmc = (CVMClass) allClasses[i];
076: cvmc.classId = CVMDataType.lookupClassname(CVMWriter
077: .getUTF(cvmc.ci.this Class.name));
078: }
079: }
080:
081: public void setTypes() {
082: setType("void", Const.T_VOID);
083: setType("boolean", Const.T_BOOLEAN);
084: setType("char", Const.T_CHAR);
085: setType("byte", Const.T_BYTE);
086: setType("short", Const.T_SHORT);
087: setType("int", Const.T_INT);
088: setType("long", Const.T_LONG);
089: setType("float", Const.T_FLOAT);
090: setType("double", Const.T_DOUBLE);
091: setAllClassID();
092: }
093:
094: public ConstantPool makeResolvable(ConstantPool cp,
095: UnresolvedReferenceList missingRefs, String source) {
096: //
097: // For the CVM, this is actually pretty trivial stuff...
098: //
099: CVMClass.makeResolvable(cp, missingRefs, source);
100: return cp;
101: }
102:
103: /*
104: * Compare two CVMClass objects by classid
105: */
106: public int compare(Object o1, Object o2) {
107: // just do the casts.
108: // unacceptable comparison results in
109: // classcast exception.
110: CVMClass c1 = (CVMClass) o1;
111: CVMClass c2 = (CVMClass) o2;
112: int classId1 = c1.classId;
113: int classId2 = c2.classId;
114:
115: // NOTE: This comparison method is used in the sorting of CVM Class
116: // instances in CVM_ROMClasses[]. The Class instances of the Class
117: // and Array types are sorted in incremental order of typeid values.
118: // The only exception is that deep array types (i.e. array types with
119: // depth >= 7) will be sorted based only on the basetype field of
120: // their typeids (i.e. the depth field is ignored ... hence the
121: // masking operations below). This makes it possible to access Class
122: // instances for Class and Deep array types in CVM_ROMClasses[] by
123: // indexing.
124: if ((classId1 & CVMTypeCode.CVMtypeArrayMask) == CVMTypeCode.CVMtypeBigArray) {
125: classId1 &= CVMTypeCode.CVMtypeBasetypeMask;
126: }
127: if ((classId2 & CVMTypeCode.CVMtypeArrayMask) == CVMTypeCode.CVMtypeBigArray) {
128: classId2 &= CVMTypeCode.CVMtypeBasetypeMask;
129: }
130: return classId1 - classId2; // should turn into -1, 0, 1. oops.
131: }
132: }
|