attributeinfo.java

JPC: x86 PC Hardware Emulator. 牛津大学开发的一个纯JAVA的x86系统结构硬件模拟器。

                    
                }
            }
        }
    }


    public static class ExceptionsAttribute extends Attribute
    {
        private int numberOfExceptions;
        private int[] exceptionIndexTable;

        ExceptionsAttribute(DataInputStream in, int index) throws IOException
        {
            super(in, index);
            numberOfExceptions = in.readUnsignedShort();
            exceptionIndexTable = new int[numberOfExceptions];
            for(int i = 0; i < numberOfExceptions; i++)
                exceptionIndexTable[i] = in.readUnsignedShort();
        }
        
        public void write(DataOutputStream out) throws IOException
        {
            super.write(out);
            out.writeShort(numberOfExceptions);
            for(int i = 0; i < numberOfExceptions; i++)
                out.writeShort(exceptionIndexTable[i]);
        }
    }


    public static class InnerClassesAttribute extends Attribute
    {
        private int numberOfClasses;
        private ClassEntry[] classes;

        InnerClassesAttribute(DataInputStream in, int index) throws IOException
        {
            super(in, index);
            numberOfClasses = in.readUnsignedShort();
            classes = new ClassEntry[numberOfClasses];
            for(int i = 0; i < numberOfClasses; i++)
                classes[i] = new ClassEntry(in);
        }

        public void write (DataOutputStream out) throws IOException
        {
            super.write(out);
            out.writeShort(numberOfClasses);
            for(int i = 0; i < numberOfClasses; i++)
                classes[i].write(out);
        }

        public static class ClassEntry
        {
            private int innnerClassInfoIndex;
            private int outerClassInfoIndex;
            private int innnerNameIndex;
            private int innnerClassAccessFlags;

            public static final int PUBLIC = 0x0001;
            public static final int PRIVATE = 0x0002;
            public static final int PROTECTED = 0x0004;
            public static final int STATIC = 0x0008;
            public static final int FINAL = 0x0010;
            public static final int INTERFACE = 0x0200;
            public static final int ABSTRACT = 0x0400;
            public static final int SYNTHETIC = 0x1000;
            public static final int ANNOTATION = 0x2000;
            public static final int ENUM = 0x4000;

            ClassEntry(DataInputStream in) throws IOException
            {
                innnerClassInfoIndex = in.readUnsignedShort();
                outerClassInfoIndex = in.readUnsignedShort();
                innnerNameIndex = in.readUnsignedShort();
                innnerClassAccessFlags = in.readUnsignedShort();
            }

            void write(DataOutputStream out) throws IOException
            {
                out.writeShort(innnerClassInfoIndex);
                out.writeShort(outerClassInfoIndex);
                out.writeShort(innnerNameIndex);
                out.writeShort(innnerClassAccessFlags);
            }
        }

    }


    public static class EnclosingMethodAttribute extends Attribute
    {
        private int classIndex;
        private int methodIndex;

        EnclosingMethodAttribute(DataInputStream in, int index) throws IOException
        {
            super(in, index);
            classIndex = in.readUnsignedShort();
            methodIndex = in.readUnsignedShort();
        }
        
        public void write(DataOutputStream out) throws IOException
        {
            super.write(out);
            out.writeShort(classIndex);
            out.writeShort(methodIndex);
        }
    }


    public static class SyntheticAttribute extends Attribute
    {
        SyntheticAttribute(DataInputStream in, int index) throws IOException
        {
            super(in, index);
        }
    }


    public static class SignatureAttribute extends Attribute
    {
        private int classIndex;

        SignatureAttribute(DataInputStream in, int index) throws IOException
        {
            super(in, index);
            classIndex = in.readUnsignedShort();
        }
        
        public void write(DataOutputStream out) throws IOException
        {
            super.write(out);
            out.writeShort(classIndex);
        }
    }


    public static class SourceFileAttribute extends Attribute
    {
        private int sourceFileIndex;

        SourceFileAttribute(DataInputStream in, int index) throws IOException
        {
            super(in, index);
            sourceFileIndex = in.readUnsignedShort();
        }

        public void write(DataOutputStream out) throws IOException
        {
            super.write(out);
            out.writeShort(sourceFileIndex);
        }
    }


    public static class LineNumberTableAttribute extends Attribute
    {
        private int lineNumberTableLength;
        private LineNumberEntry[] lineNumberTable;

        LineNumberTableAttribute(DataInputStream in, int index) throws IOException
        {
            super(in, index);
            lineNumberTableLength = in.readUnsignedShort();
            lineNumberTable = new LineNumberEntry[lineNumberTableLength];
            for(int i = 0; i < lineNumberTableLength; i++)
                lineNumberTable[i] = new LineNumberEntry(in);
        }

        public void write(DataOutputStream out) throws IOException
        {
            super.write(out);
            out.writeShort(lineNumberTableLength);
            for(int i = 0; i < lineNumberTableLength; i++)
                lineNumberTable[i].write(out);
        }

        public static class LineNumberEntry
        {
            private int startPC;
            private int lineNumber;

            LineNumberEntry(DataInputStream in) throws IOException
            {
                startPC = in.readUnsignedShort();
                lineNumber = in.readUnsignedShort();
            }

            public void write(DataOutputStream out) throws IOException
            {
                out.writeShort(startPC);
                out.writeShort(lineNumber);
            }
        }
    }


    public static class LocalVariableTableAttribute extends Attribute
    {
        private int localVariableTableLength;
        private LocalVariableEntry[] localVariableTable;

        LocalVariableTableAttribute(DataInputStream in, int index) throws IOException
        {
            super(in, index);
            localVariableTableLength = in.readUnsignedShort();
            localVariableTable = new LocalVariableEntry[localVariableTableLength];
            for(int i = 0; i < localVariableTableLength; i++)
                localVariableTable[i] = new LocalVariableEntry(in);
        }

        public void write(DataOutputStream out) throws IOException
        {
            super.write(out);
            out.writeShort(localVariableTableLength);
            for(int i = 0; i < localVariableTableLength; i++)
                localVariableTable[i].write(out);
        }

        public static class LocalVariableEntry
        {
            private int startPC;
            private int length;
            private int nameIndex;
            private int descriptorIndex;
            private int index;

            LocalVariableEntry(DataInputStream in) throws IOException
            {
                startPC = in.readUnsignedShort();
                length = in.readUnsignedShort();
                nameIndex = in.readUnsignedShort();
                descriptorIndex = in.readUnsignedShort();
                index = in.readUnsignedShort();
            }

            public void write(DataOutputStream out) throws IOException
            {
                out.writeShort(startPC);
                out.writeShort(length);
                out.writeShort(nameIndex);
                out.writeShort(descriptorIndex);
                out.writeShort(index);
            }
        }
    }


    public static class DeprecatedAttribute extends Attribute
    {
        DeprecatedAttribute(DataInputStream in, int index) throws IOException
        {
            super(in, index);
        }
    }

    public static class UnknownAttribute extends Attribute
    {
        // what to do here??
        // blank the data
        // or do we retain old (possiblely out of date) data??

        int[] bytes;

        UnknownAttribute(DataInputStream in, int index) throws IOException
        {
            super(in, index);
            bytes = new int[attributeLength];
            for(int i = 0; i < attributeLength; i++)
                bytes[i] = in.readUnsignedByte();
            
        }

        public void write(DataOutputStream out) throws IOException
        {
            super.write(out);
            for(int i = 0; i < attributeLength; i++)
                out.writeByte(bytes[i]);
        }
    }
}