kvmwriter.java

已经移植好的java虚拟机

			    String name = (value.tag == Const.CONSTANT_LONG)
				       ? "LONG" : "DOUBLE";
			    out.print(name + "(");
			    writeIntegerValue(dval.highVal);
			    previous = dval;
			}
		    } else if (previous != null) { 
			writeIntegerValue(previous.lowVal);
			out.print(")");
			previous = null;
		    } else { 
			writeIntegerValue(0);
		    }
		}
	    };

        out.println("long "+staticStoreName+"["+nStaticWords+"];");
	out.println("struct {");
	out.println("\tlong count;");
	out.println("\tINSTANCE roots[" + nRef + "];");
	out.println("\tlong nonRoots[" + (nStaticWords - nRef - 1) + "];");
	out.println("} " + masterStaticStoreName + "= {");
	out.println("\t" + nRef + ",");
	out.println("\t{");
	writeArray(1, nRef + 1, 8, "\t\t", ap);
	out.println("\t},");
	out.println("\t{");
	writeArray(nRef + 1, nStaticWords, 4, "\t\t", ap);
	out.println("\t}");
        out.println("};\n");
    }




    protected void writeAllClassDefinitions(ClassClass classes[]) 
	throws DataFormatException
    {

        Vector instanceClasses = new Vector();
        for (Enumeration e = classTable.enumerate(); e.hasMoreElements(); ) { 
            String name = ((KVMClassName)e.nextElement()).toString();
            ClassInfo ci = ClassInfo.lookupClass(name);
            if (ci != null) { 
                EVMClass cc = (EVMClass)ci.vmClass;
                if (!cc.isPrimitiveClass() && !cc.isArrayClass()) { 
                    String nativeName = cc.getNativeName();
                    instanceClasses.addElement(cc);
                    instanceClasses.addElement(cc.getNativeName());
                }
            }
        }

	if (buildingRelocationTable) { 
	    writeAllMethodDefinitions(instanceClasses);
	    return;
	} 



	writeAllByteCodes(instanceClasses);
	out.println("\014");
	writeAllHandlers(instanceClasses);
	out.println("\014");
        writeAllStackMaps(instanceClasses);
        out.println("\014");

	writeAllMethodDefinitions(instanceClasses);
        out.println("\014");
        writeAllFieldDefinitions(instanceClasses);
        out.println("\014");
        writeAllConstantPoolDefinitions(instanceClasses);
        out.println("\014");
        writeAllInterfaceTableDefinitions(instanceClasses);
        
	if (relocatableROM) { 
	    out.println("void *ClassDefinitionSectionHeader = &ClassDefinitionSectionHeader;");
	}

	out.println("static struct AllClassblocks_Struct AllClassblocks = {");


        for (Enumeration e = classTable.enumerate(); e.hasMoreElements(); ) { 
            String name = ((KVMClassName)e.nextElement()).toString();
            ClassInfo ci = ClassInfo.lookupClass(name);
            if (ci == null) { 
                writeRawClassDefinition(name);
            } else { 
                EVMClass cc = (EVMClass)ci.vmClass;
                if (cc.isPrimitiveClass()) { 
                    /* ignore */
                } else if (cc.isArrayClass()) { 
                    writeArrayClassDefinition(cc);
                } else { 
                    writeNormalClassDefinition(cc);
                }
            }
        }
	out.println("};");

        /* Write out the Class Table */
        out.println("\014");
        classTable.writeTable(out, "ClassTable");
        /* Write the primitive array table */
        out.println("\014");
        writePrimitiveArrayTable(classes);

	if (relocatableROM) { 
	    out.println("void *ClassDefinitionSectionTrailer = &ClassDefinitionSectionTrailer;");
	}
    }

    protected void writeNormalClassDefinition(EVMClass c) {
        int methodCount = c.methods.length;
        int fieldCount =  c.ci.fields.length;
        int constantCount = c.ci.constants.length;
        int intfCount =  c.ci.interfaces.length;
        // This will be clear later.  The only important thing is that it
        // becomes zero after we've output the last thing.
        int extras = methodCount + fieldCount + constantCount + intfCount;
        int access = c.ci.access + ACC_ROM_CLASS;
        if (!c.hasStaticInitializer) { 
            /* This class doesn't need to be inited */
            access += ACC_ROM_NON_INIT_CLASS;
        }
        String nativeName = c.getNativeName();
        writeBasicClassInfo(c, "instanceClassStruct", "INSTANCE_INFO", access);
        out.print("\t\t" + c.instanceSize() + ", ");
        out.println(c.hasStaticInitializer ? "CLASS_VERIFIED, \\" : "CLASS_READY, \\");
        if (c.ci.superClass == null) {
            out.println("\t\tNULL, \\");
        } else {
            ClassInfo sci = ClassInfo.lookupClass(c.ci.superClass.name.string);
            String superName = ((EVMClass)(sci.vmClass)).getNativeName();
            out.println("\t\t&AllClassblocks." + superName + ", \\");
        }
        out.println("\t\t" 
                    + ((methodCount==0) ? "NULL" 
		         : ("&AllMethods." + nativeName + "_MethodSection." + 
			    nativeName))
                    + ", \\");
        out.println("\t\t" 
                    + ((fieldCount==0) ? "NULL" : ("&AllFields." + nativeName))
                    + ", \\");
        out.println("\t\t" 
                    + ((constantCount==0) ? "NULL" : ("&AllConstantPools." + nativeName))
                    + ", \\");
        out.println("\t\t" 
                    + ((intfCount == 0) ? "NULL" : ("&AllInterfaces." + nativeName))
                    + " ),");
        // out.println("};\n");
    }


    protected void writeRawClassDefinition(String className){
        String nativeName = Util.convertToClassName(className);
        KVMClassName cn = new KVMClassName(className);
        writeBasicClassInfo(nativeName, cn, 
                            "instanceClassStruct", "RAW_CLASS_INFO", 0);
        out.println("\t\tNULL),");
        // out.println("};");
    }


    protected void writeArrayClassDefinition(EVMClass c){
        KVMClassName cn = new KVMClassName(c.ci.className);
        int access = c.ci.access + ACC_ARRAY_CLASS + ACC_ROM_CLASS; 
        ConstantObject cp = c.ci.constants[1];
        if (cp.tag == Const.CONSTANT_CLASS) {   
            ArrayClassInfo aci = (ArrayClassInfo)c.ci;
            ClassInfo elemClass = 
                ClassInfo.lookupClass(((ClassConstant)cp).name.string);
            String elemName = ((EVMClass)(elemClass.vmClass)).getNativeName();
            writeBasicClassInfo(c, "arrayClassStruct", 
                                "ARRAY_OF_OBJECT", access);
	    out.println("\t\tAllClassblocks." + elemName + "),");
        } else {
            String baseName = ((ArrayClassInfo)(c.ci)).baseName.toUpperCase();
            writeBasicClassInfo(c, "arrayClassStruct", 
                                "ARRAY_OF_PRIMITIVE", access);
            
            //out.println("\t\t" + baseName + ")};\n");
	    out.println("\t\t" + baseName + "),");
        }
    }
    
    protected void writeBasicClassInfo(EVMClass c,
                                     String type, String macro, int access) {
        writeBasicClassInfo(c.getNativeName(), new KVMClassName(c.ci.className),
                            type, macro, access);
    }

    protected void writeBasicClassInfo(String nativeName, 
                                     KVMClassName cn,
                                     String type, String macro, int access) {
        String fullBaseName = cn.getFullBaseName();
        String packageName = cn.getPackageName();
        int packageKey = -1;
        if (packageName != null) { 
            packageKey = classTable.getNameKey(packageName);
            nameTable.declareUString(out, packageName);
        }
        int baseKey = classTable.getNameKey(fullBaseName);      
        nameTable.declareUString(out, fullBaseName);

        int classKey = classTable.getClassKey(cn);

        out.println("\t" + macro + "( \\");
        if (packageKey == -1) {
            out.println("\t\tNULL, ");
        } else { 
            out.println("\t\t" + nameTable.getUString(packageName) 
                        + ",  /* " + packageName + " */ \\");
        }
        out.println("\t\t" + nameTable.getUString(fullBaseName) 
                    + ",  /* " + fullBaseName + " */ \\");
        KVMClassName nextName = (KVMClassName)classTable.getNext(cn);
        if (nextName == null) { 
            out.print("\t\tNULL, ");
        } else {
            EVMClass next = nextName.getEVMClass();
            String nextNativeName = 
                (next != null) ? next.getNativeName()
                               : Util.convertToClassName(nextName.toString());
            out.print("\t\t&AllClassblocks." + nextNativeName + ", ");
        }
        out.printHexInt(classKey);
        out.print(", ");
        out.printHexInt(access);
        out.println(", \\");
    }


    protected void writeAllMethodDefinitions(Vector instanceClasses) {
        Vector todo = new Vector();
        out.println("struct AllMethods_Struct { ");
	SectionCounter sectionCounter = 
	    new SectionCounter(relocatableROM 
			       /* Each method is roughly 40 bytes */
			       ? 50000 / 40 
			       : Integer.MAX_VALUE);
	
	sectionCounter.startFirstSection(SectionCounter.Definition);
        for (Enumeration e = instanceClasses.elements(); e.hasMoreElements();) {
            EVMClass cc = (EVMClass)e.nextElement();
            String nativeName = (String)e.nextElement();
            int length = cc.methods.length;
	    sectionCounter.maybeNextSection(length);
            if (length > 0) { 
                todo.addElement(cc);
		todo.addElement(nativeName);
                out.println("\t\tstruct {");
		out.println("#define " + nativeName + "_MethodSection " + 
			    "section" + sectionCounter.getSection());
		if (buildingRelocationTable) { 
		    out.println("#define " + nativeName + 
				"_MethodSectionNumber " + 
				sectionCounter.getSection());
		}
		out.println("\t\t\tlong length;");
                out.println("\t\t\tstruct methodStruct methods[" 
                             + length+ "];");
                out.println("\t\t} " + nativeName + ";");
            }
        }
	sectionCounter.endLastSection();
	out.println("};");
	if (buildingRelocationTable) { 
	    return;
	}
	
	out.println("static CONST struct AllMethods_Struct AllMethods = {");
	sectionCounter.startFirstSection(SectionCounter.Initialization);
	for (Enumeration e = todo.elements(); e.hasMoreElements(); ) { 
	    EVMClass cc = (EVMClass)e.nextElement();
            String nativeName = (String)e.nextElement();
            int length = cc.methods.length;
	    sectionCounter.maybeNextSection(length);
	    out.println("\t\t{");
	    out.println("\t\t\t/* " + cc.ci.className + " */");
	    writeMethods(cc);
	    out.println("\t\t},");
	}
	sectionCounter.endLastSection();
	out.println("};\n");
	if (!relocatableROM) { 
	    // We need to coercion to remove the CONST-ness
	    out.print("METHOD RunCustomCodeMethod = (METHOD) ROM_CLINIT_");
	    writeConstant(runCustomCodeConstant, true);
	    out.println(";\n");
	} else { 
	    sectionCounter.printRelocationInfo("AllMethods", "METHODTABLE");
	}
	
    }

    protected void writeAllFieldDefinitions(Vector instanceClasses) { 
        Vector todo = new Vector();
        out.println("struct AllFields_Struct { ");
        for (Enumeration e = instanceClasses.elements(); e.hasMoreElements();) {
            EVMClass cc = (EVMClass)e.nextElement();
            String nativeName = (String)e.nextElement();
            int length = cc.ci.fields.length;
            if (length > 0) { 
                todo.addElement(cc);
                out.println("\tstruct {");
                out.println("\t\tlong length;");
                out.println("\t\tstruct fieldStruct fields[" + length+ "];");
                out.println("\t} " + nativeName + ";");
            }
        }
        out.println("};");
	out.println("static CONST struct AllFields_Struct AllFields = { ");
        for (Enumeration e = todo.elements(); e.hasMoreElements();) {
            EVMClass cc = (EVMClass)e.nextElement();
            out.println("\t{");
            out.println("\t\t/* " + cc.ci.className + " */");
            writeFields(cc);
            out.println("\t},");
        }
        out.println("};\n");
    }

    protected void writeAllConstantPoolDefinitions(Vector instanceClasses) {
        Vector todo = new Vector();
        out.println("struct AllConstantPools_Struct { ");
        for (Enumeration e = instanceClasses.elements(); e.hasMoreElements();) {
            EVMClass cc = (EVMClass)e.nextElement();
            String nativeName = (String)e.nextElement();
            int length = cc.ci.constants.length;
            if (length > 0) { 
                todo.addElement(cc);
                out.println("\tstruct {");
                out.println("\t\tunion ROMconstantPoolEntryStruct entries[" + length + "];");
                out.println("\t\tunsigned char tags[" + length + "];");
                out.println("\t} " + nativeName + ";");
            }
        }
        out.println("};");
	out.println("static CONST struct AllConstantPools_Struct AllConstantPools = {");
        for (Enumeration e = todo.elements(); e.hasMoreElements();) {
            EVMClass cc = (EVMClass)e.nextElement();
            out.println("\t{");
            out.println("\t\t/* " + cc.ci.className + " */");
            writeConstantPool(cc);
            out.println("\t},");
        }
        out.println("};\n");
    }

    protected void writeAllInterfaceTableDefinitions(Vector instanceClasses) {
        Vector todo = new Vector();
        out.println("struct AllInterfaces_Struct { ");
        for (Enumeration e = instanceClasses.elements(); e.hasMoreElements();) {
            EVMClass cc = (EVMClass)e.nextElement();
            String nativeName = (String)e.nextElement();
            int length = cc.ci.interfaces.length;
            if (length > 0) { 
                todo.addElement(cc);
                out.println("\tstruct {");
                out.println("\t\tunsigned short length;");
                out.println("\t\tunsigned short index[" + length + "];");
                out.println("\t} " + nativeName + ";");
            }
        }
	out.println("};");
	out.println();
        out.println("static CONST struct AllInterfaces_Struct AllInterfaces = { ");
        for (Enumeration e = todo.elements(); e.hasMoreElements();) {
            EVMClass cc = (EVMClass)e.nextElement();
            out.println("\t{");
            out.println("\t\t/* " + cc.ci.className + " */");
            writeInterfaces(cc);
            out.println("\t},");
        }
        out.println("};\n");
    }
    

    protected void writeAllByteCodes(Vector instanceClasses) 
	      throws DataFormatException{ 
        /* Find the values of the two special methods */
	Vector todo = new Vector();
	Vector natives = new Vector();
	SectionCounter sectionCounter = 
	    new SectionCounter(relocatableROM ? 50000 : Integer.MAX_VALUE);
	
        out.println("struct AllCode_Struct { ");
	int padCount = 0;	// just so each padding will have a name

	sectionCounter.startFirstSection(SectionCounter.Definition);

        for (Enumeration e = instanceClasses.elements(); e.hasMoreElements();) {
            EVMClass cc = (EVMClass)e.nextElement();
            String classNativeName = (String)e.nextElement(); // ignored
            EVMMethodInfo  m[] = cc.methods;
            int nmethod = m.length;
            for (int j = 0; j < nmethod; j++){
                EVMMethodInfo meth = m[j];
                MethodInfo mi = meth.method;
                if ((mi.access & Const.ACC_ABSTRACT) != 0) { 
                    /* Do nothing */
                } else if ((mi.access & Const.ACC_NATIVE) != 0) { 
		    natives.addElement(meth);
                } else { 
		    String methodNativeName = meth.getNativeName();