本章介绍 classJava 虚拟机的文件格式。每个class文件都包含单个类或接口的定义。尽管类或接口不需要在文件中包含字面上的外部表示(例如,因为该类是由类加载器生成的),但我们将通俗地说,将类或接口的任何有效表示称为class文件格式.
一个class文件由一个 8 位字节流组成。所有 16 位、32 位和 64 位量都是通过分别读取两个、四个和八个连续的 8 位字节来构造的。多字节数据项始终以大端顺序存储,高字节在先。在 Java SE 平台中,这种格式由接口java.io.DataInput 和java.io.DataOutput类支持,例如 java.io.DataInputStream 和java.io.DataOutputStream。
本章定义了自己的一组表示class文件数据的数据类型:类型u1、u2和u4分别表示无符号的一、二或四字节数量。在 Java SE 平台中,这些类型可以通过 java.io.DataInput接口的readUnsignedByte、 readUnsignedShort、 和readInt等方法读取。
本章介绍了 class使用以类 C 结构表示法编写的伪结构的文件格式。为了避免与类和类实例的字段等混淆,描述 class文件格式的结构的内容被称为items。连续的项目按顺序存储在class文件中,没有填充或对齐。
由零个或多个可变大小项目组成的 表格class用于多个文件结构中。尽管我们使用类似 C 的数组语法来引用表项,但表是不同大小结构的流这一事实意味着不可能将表索引直接转换为表中的字节偏移量。
我们将数据结构称为数组,它由零个或多个连续的固定大小的项组成,并且可以像数组一样被索引。
本章中对 ASCII 字符的引用应解释为对应于 ASCII 字符的 Unicode 代码点。
1 ClassFile结构https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html
一个class文件由一个ClassFile结构组成:
ClassFile {
u4 magic;
u2 minor_version;
u2 major_version;
u2 constant_pool_count;
cp_info constant_pool[constant_pool_count-1];
u2 access_flags;
u2 this_class;
u2 super_class;
u2 interfaces_count;
u2 interfaces[interfaces_count];
u2 fields_count;
field_info fields[fields_count];
u2 methods_count;
method_info methods[methods_count];
u2 attributes_count;
attribute_info attributes[attributes_count];
}
结构中的项目ClassFile 如下:
-
magic
该magic项目提供标识class文件格式的幻数;它的值为0xCAFEBABE。 -
minor_version、major_version
minor_version 和major_version的次要和主要版本号。class主要和次要版本号一起确定 class文件格式的版本。如果一个class文件的主版本号为 M 和次要版本号为 m,我们将其class文件格式的版本表示为 Mm。因此,class文件格式版本可以按字典顺序排序,例如 1.5 < 2.0 < 2.1。
class当且仅当 v 位于某个连续范围 Mi.0 ≤ v ≤ Mj.m时, Java 虚拟机实现才能支持版本 v 的文件格式。Java 虚拟机实现所遵循的 Java SE 平台的发布级别负责确定范围。
JDK 版本 1.0.2 中的 Oracle 的 Java 虚拟机实现支持class文件格式版本 45.0 到 45.3(含)。JDK 发行版 1.1.* 支持class45.0 到 45.65535(含)范围内的文件格式版本。对于 k ≥ 2,JDK 版本 1.k 支持class45.0 到 44+k.0(含)范围内的文件格式版本。 -
constant_pool_count
该constant_pool_count项目的值等于表中的条目数constant_pool加一。如果constant_pool索引大于零且小于constant_pool_count,则认为索引有效,但类型常量除外,long并double在 §4.4.5中注明。 -
constant_pool[]
这constant_pool是一个结构表,表示在 结构及其子结构中引用的各种字符串常量、类和接口名称、字段名称和其他常量。每个 constant_pool表条目的格式由其第一个“标记”字节指示。
该constant_pool表的索引从 1 到constant_pool_count- 1。 -
access_flags
该access_flags项目的值是一个标志掩码,用于表示对此类或接口的访问权限和属性。表 4.1-A中指定了每个标志在设置时的解释。
表 4.1-A。类访问和属性修饰符
标志名称 价值 解释
ACC_PUBLIC 0x0001 宣布public;可以从其包外部访问。
ACC_FINAL 0x0010 宣布final;不允许子类。
ACC_SUPER 0x0020 当被invokespecial指令 调用时,对超类方法进行特殊处理。
ACC_INTERFACE 0x0200 是接口,不是类。
ACC_ABSTRACT 0x0400 宣布abstract;不得实例化。
ACC_SYNTHETIC 0x1000 宣布合成;源代码中不存在。
ACC_ANNOTATION 0x2000 声明为注解类型。
ACC_ENUM 0x4000 声明为一种enum类型。
ACC_INTERFACE接口通过设置的标志 来区分。如果ACC_INTERFACE未设置该标志,则此 class文件定义一个类,而不是一个接口。
如果ACC_INTERFACE设置了ACC_ABSTRACT标志,则也必须设置标志,并且不能设置ACC_FINAL、ACC_SUPER和 ACC_ENUM标志集。
如果ACC_INTERFACE未设置该标志,则可以设置 表 4.1-AACC_ANNOTATION中的任何其他标志,除了. 但是,此类class文件不得同时设置其ACC_FINAL和ACC_ABSTRACT标志。
如果出现在此类或接口中, 该ACC_SUPER标志指示由invokespecial 指令(§invokespecial )表示的两种替代语义中的哪一种。Java 虚拟机指令集的编译器应设置该ACC_SUPER 标志。在 Java SE 8 及更高版本中,Java 虚拟机认为 ACC_SUPER要在每个class文件中设置标志,而不管文件中标志的实际值和class文件的版本。class文件。
该ACC_SUPER标志的存在是为了向后兼容由 Java 编程语言的旧编译器编译的代码。在 JDK 1.0.2 之前的版本中,生成的编译器access_flags现在表示的标志 ACC_SUPER没有指定的含义,如果设置了标志,Oracle 的 Java 虚拟机实现会忽略该标志。
该ACC_SYNTHETIC标志表示此类或接口是由编译器生成的,并且不会出现在源代码中。
注释类型必须ACC_ANNOTATION设置其标志。如果ACC_ANNOTATION设置了ACC_INTERFACE标志,则也必须设置标志。
该ACC_ENUM标志指示该类或其超类被声明为枚举类型。
表 4.1-Aaccess_flags中未分配 的项目的所有位都保留供将来使用。它们应该在生成的文件中设置为零,并且应该被 Java 虚拟机实现忽略。 -
this_class
项目的值this_class必须是constant_pool表中的有效索引。该 constant_pool索引处的条目必须是一个 CONSTANT_Class_info结构(第 4.4.1 节),表示该class 文件定义的类或接口。 -
super_class
对于一个类,super_class 项目的值要么必须为零,要么必须是 constant_pool表中的有效索引。如果super_class项目的值非零,则 constant_pool该索引处的条目必须是 CONSTANT_Class_info表示此class文件定义的类的直接超类的结构。直接超类及其任何超类都不能 在ClassFile结构设置标志access_flags为 ACC_FINAL。
如果该项的值super_class为零,则此class文件必须表示 class Object,这是唯一没有直接超类的类或接口。
对于接口, super_class项目的值必须始终是constant_pool表中的有效索引。该constant_pool 索引处的条目必须是CONSTANT_Class_info表示类的结构Object。 -
interfaces_count
该interfaces_count项目的值给出了此类或接口类型的直接超接口的数量。 -
interfaces[]
数组中的每个值都interfaces必须是constant_pool表中的有效索引。的 constant_pool每个值 interfaces[i] ( 其中 0 ≤ i < interfaces_count)处的条目必须是 CONSTANT_Class_info表示接口的结构,该接口是此类或接口类型的直接超接口,按类型源中给出的从左到右的顺序排列。 -
fields_count
fields_count的值给出了表中field_info结构fields的数量。结构表示由此类或接口类型声明的field_info 所有字段,包括类变量和实例变量。 -
fields[]
表中的每个值都fields必须是一个 field_info结构(第4.5 节),提供此类或接口中字段的完整描述。该fields表仅包括由此类或接口声明的那些字段。它不包括表示从超类或超接口继承的字段的项。 -
methods_count
methods_count 的值给出了表中method_info结构methods的数量。 -
methods[]
表中的每个值都methods必须是一个 method_info结构(第 4.6 节),提供此类或接口中方法的完整描述。如果结构项method_info中 access_flags没有设置ACC_NATIVE和ACC_ABSTRACT 标志 ,则还提供实现该方法的 Java 虚拟机指令。
method_info结构体表示此类或接口类型声明的所有方法,包括实例方法、类方法、实例初始化方法( 第2.9 节)以及任何类或接口初始化方法(第 2.9 节)。该 methods表不包括表示从超类或超接口继承的方法的项目。 -
attributes_count
attributes_count的值给出了attributes该类表中的属性数。 -
attributes[]
表的每个值都attributes必须是一个 attribute_info结构(§4.7)。
本规范定义的出现在ClassFile结构attributes表中的属性在表 4.7-C 中列出。
有关定义出现在ClassFile结构 attributes表中的 属性的规则 在第4.7 节中给出。
有关ClassFile结构 attributes表 中非预定义属性的规则在第 4.7.1 节中给出。
package com.example;
public class HelloWorld {
public static void main(String[] args) {
System.out.println("HelloWord");
}
}
javap -verbose HelloWorld .class
Classfile /D:/git/HelloWorld.class Last modified 2022-6-4; size 555 bytes MD5 checksum 947d6562ab51ba57f2a1b87fab091919 Compiled from "HelloWorld.java" public class com.example.HelloWorld minor version: 0 major version: 52 flags: ACC_PUBLIC, ACC_SUPER Constant pool: #1 = Methodref #6.#20 // java/lang/Object."2.2 jclasslib-bytecode-viewer 2.3 自定义代码":()V #2 = Fieldref #21.#22 // java/lang/System.out:Ljava/io/PrintStream; #3 = String #23 // HelloWord #4 = Methodref #24.#25 // java/io/PrintStream.println:(Ljava/lang/String;)V #5 = Class #26 // com/example/HelloWorld #6 = Class #27 // java/lang/Object #7 = Utf8 #8 = Utf8 ()V #9 = Utf8 Code #10 = Utf8 LineNumberTable #11 = Utf8 LocalVariableTable #12 = Utf8 this #13 = Utf8 Lcom/example/HelloWorld; #14 = Utf8 main #15 = Utf8 ([Ljava/lang/String;)V #16 = Utf8 args #17 = Utf8 [Ljava/lang/String; #18 = Utf8 SourceFile #19 = Utf8 HelloWorld.java #20 = NameAndType #7:#8 // " ":()V #21 = Class #28 // java/lang/System #22 = NameAndType #29:#30 // out:Ljava/io/PrintStream; #23 = Utf8 HelloWord #24 = Class #31 // java/io/PrintStream #25 = NameAndType #32:#33 // println:(Ljava/lang/String;)V #26 = Utf8 com/example/HelloWorld #27 = Utf8 java/lang/Object #28 = Utf8 java/lang/System #29 = Utf8 out #30 = Utf8 Ljava/io/PrintStream; #31 = Utf8 java/io/PrintStream #32 = Utf8 println #33 = Utf8 (Ljava/lang/String;)V { public com.example.HelloWorld(); descriptor: ()V flags: ACC_PUBLIC Code: stack=1, locals=1, args_size=1 0: aload_0 1: invokespecial #1 // Method java/lang/Object." ":()V 4: return LineNumberTable: line 3: 0 LocalVariableTable: Start Length Slot Name Signature 0 5 0 this Lcom/example/HelloWorld; public static void main(java.lang.String[]); descriptor: ([Ljava/lang/String;)V flags: ACC_PUBLIC, ACC_STATIC Code: stack=2, locals=1, args_size=1 0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream; 3: ldc #3 // String HelloWord 5: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V 8: return LineNumberTable: line 6: 0 line 7: 8 LocalVariableTable: Start Length Slot Name Signature 0 9 0 args [Ljava/lang/String; } SourceFile: "HelloWorld.java"
使用java代码参照https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html实现,通过java.io.DataInput进行解析。解析结果对照 jclasslib-bytecode-viewer和javap用于对比验证。
注意:解析只能从前到后解析,不能跳过。错一个后面都会有问题。
DataInputStream dis = new DataInputStream(new FileInputStream(file));2.3.1 magic 验证
private static boolean validateMagic(DataInputStream dis) throws IOException {
System.out.println("----------magic start----------");
// magic
int magic = dis.readInt();
if(magic != 0xcafebabe) {
System.out.println("ERROR:无效的class文件");
return false;
}
System.out.println("----------magic end----------n");
return true;
}
2.3.2 version
private static void parseVersion(DataInputStream dis) throws IOException {
System.out.println("----------version start----------");
// minor_version
int minorVersion = dis.readUnsignedShort();
System.out.println("minorVersion:"+minorVersion);
// major_version
int majorVersion = dis.readUnsignedShort();
System.out.println("majorVersion:"+majorVersion);
System.out.println("----------version end----------n");
}
2.3.3 ConstantPool
private static String[] parseConstantPool(DataInputStream dis) throws Exception {
// constant_pool[constant_pool_count-1]
System.out.println("----------constant_pool start----------");
// constant_pool_count
int constantPoolCount = dis.readUnsignedShort();
System.out.println("constantPoolCount:"+constantPoolCount);
String[] strs = new String[constantPoolCount];
for (int i = 1; i < constantPoolCount; i++) {
int tag = dis.readUnsignedByte();
switch (tag) {
case 7: {
int nameIndex = dis.readUnsignedShort();
System.out.println("["+i+"]"+"CONSTANT_Class。nameIndex:" + nameIndex);
break;
}
case 9: {
int classIndex = dis.readUnsignedShort();
int nameAndTypeIndex = dis.readUnsignedShort();
System.out.println("["+i+"]"+"CONSTANT_Fieldref。classIndex:" + classIndex + ",nameAndTypeIndex:" + nameAndTypeIndex);
break;
}
case 10: {
int classIndex = dis.readUnsignedShort();
int nameAndTypeIndex = dis.readUnsignedShort();
System.out.println("["+i+"]"+"CONSTANT_Methodref。classIndex:" + classIndex + ",nameAndTypeIndex:" + nameAndTypeIndex);
break;
}
case 11: {
int classIndex = dis.readUnsignedShort();
int nameAndTypeIndex = dis.readUnsignedShort();
System.out.println("["+i+"]"+"CONSTANT_InterfaceMethodref。classIndex:" + classIndex + ",nameAndTypeIndex:" + nameAndTypeIndex);
break;
}
case 8: {
int stringIndex = dis.readUnsignedShort();
System.out.println("["+i+"]"+"CONSTANT_String。stringIndex:" + stringIndex);
break;
}
case 3: {
int bytes = dis.readInt();
System.out.println("["+i+"]"+"CONSTANT_Integer。bytes:" + bytes);
break;
}
case 4: {
float bytes = dis.readFloat();
System.out.println("["+i+"]"+"CONSTANT_Float。bytes:" + bytes);
break;
}
case 5: {
long bytes = dis.readLong();
System.out.println("["+i+"]"+"CONSTANT_Long。bytes:" + bytes);
i++;
System.out.println("["+i+"]"+"CONSTANT_Long");
break;
}
case 6: {
double bytes = dis.readDouble();
System.out.println("["+i+"]"+"CONSTANT_Double。bytes:" + bytes);
i++;
System.out.println("["+i+"]"+"CONSTANT_Double");
break;
}
case 12: {
int nameIndex = dis.readUnsignedShort();
int descriptorIndex = dis.readUnsignedShort();
System.out.println("["+i+"]"+"CONSTANT_NameAndType。nameIndex:" + nameIndex + ",descriptorIndex:"+ descriptorIndex);
break;
}
case 1: {
int length = dis.readUnsignedShort();
byte[] bytes = new byte[length];
dis.read(bytes);
String str = new String(bytes);
strs[i] = str;
System.out.println("["+i+"]"+"CONSTANT_Utf8。length:" + length + ",bytes:"+ new String(bytes));
break;
}
case 15: {
int referenceKind = dis.readUnsignedByte();
int referenceIndex = dis.readUnsignedShort();
System.out.println("["+i+"]"+"CONSTANT_MethodHandle。referenceKind:" + referenceKind + ",referenceIndex:"+ referenceIndex);
break;
}
case 16: {
int descriptorIndex = dis.readUnsignedShort();
System.out.println("["+i+"]"+"CONSTANT_MethodType。descriptorIndex:" + descriptorIndex);
break;
}
case 18: {
int bootstrapMethodAttrIndex = dis.readUnsignedShort();
int nameAndTypeIndex = dis.readUnsignedShort();
System.out.println("["+i+"]"+"CONSTANT_InvokeDynamic。bootstrapMethodAttrIndex:" + bootstrapMethodAttrIndex + ",nameAndTypeIndex:"+ nameAndTypeIndex);
break;
}
default:
throw new Exception("constant tag");
}
}
System.out.println("----------constant_pool end----------n");
return strs;
}
2.3.4 基础信息
System.out.println("----------base info start----------");
int accessFlags = dis.readUnsignedShort();
int thisClass = dis.readUnsignedShort();
int superClass = dis.readUnsignedShort();
System.out.println("accessFlags:"+accessFlags+",thisClass:"+thisClass+",superClass:"+superClass);
System.out.println("----------base info endn----------");
2.3.5 interfaces
System.out.println("----------interfaces start----------");
int interfacesCount = dis.readUnsignedShort();
System.out.println("interfacesCount:"+interfacesCount);
for(int i = 0; i < interfacesCount; i++) {
System.out.println("interface:"+ dis.readUnsignedShort());
}
System.out.println("----------interfaces end----------n");
2.3.6 fields
private static void parseFields(DataInputStream dis, String[] strs) throws IOException {
System.out.println("----------fields start----------");
int fieldsCount = dis.readUnsignedShort();
System.out.println("fieldsCount:"+fieldsCount);
for (int i = 0; i < fieldsCount; i++) {
int accessFlags = dis.readUnsignedShort();
int nameIndex = dis.readUnsignedShort();
int descriptorIndex = dis.readUnsignedShort();
int attributesCount = dis.readUnsignedShort();
System.out.println("nameIndex:"+nameIndex+",accessFlags:"+accessFlags+",descriptorIndex:"+descriptorIndex+",attributesCount:"+attributesCount);
for (int j = 0; j < attributesCount; j++) {
parseAttribute(dis, strs);
}
}
System.out.println("----------fields end----------n");
}
2.3.7 methods
private static void parseMethods(DataInputStream dis, String[] strs) throws IOException {
System.out.println("----------methods start----------");
int methodsCount = dis.readUnsignedShort();
System.out.println("methodsCount:"+methodsCount);
for (int i = 0; i < methodsCount; i++) {
int accessFlags = dis.readUnsignedShort();
int nameIndex = dis.readUnsignedShort();
int descriptorIndex = dis.readUnsignedShort();
int attributesCount = dis.readUnsignedShort();
System.out.println("nameIndex:"+nameIndex+",accessFlags:"+accessFlags+",descriptorIndex:"+descriptorIndex+",attributesCount:"+attributesCount);
for (int j = 0; j < attributesCount; j++) {
parseAttribute(dis, strs);
}
}
System.out.println("----------methods end----------n");
}
2.3.8 attributes
private static void pareseAttributes(DataInputStream dis, String[] strs) throws IOException {
System.out.println("----------attributes start----------");
int attributesCount = dis.readUnsignedShort();
System.out.println("attributesCount:"+attributesCount);
for (int j = 0; j < attributesCount; j++) {
parseAttribute(dis, strs);
}
System.out.println("----------attributes end----------n");
}
2.3.9 attribute
public static void parseAttribute(DataInputStream dis, String[] strs) throws IOException {
int attributeNameIndex = dis.readUnsignedShort();
int attributeLength = dis.readInt();
System.out.println("attributeNameIndex:"+attributeNameIndex + ",attributeLength:" + attributeLength);
switch (strs[attributeNameIndex]) {
case "ConstantValue": {
int constantvalueIndex = dis.readUnsignedShort();
System.out.println("constantvalueIndex:" +constantvalueIndex);
break;
}
case "Code": {
int maxStack = dis.readUnsignedShort();
int maxLocals = dis.readUnsignedShort();
int codeLength = dis.readInt();
System.out.println("maxStack:"+maxStack + ",maxLocals:" + maxLocals+ ",codeLength:" + codeLength);
for (int i = 0; i < codeLength; i++) {
System.out.println("code["+i + "]=" + dis.readUnsignedByte());
}
int exception_table_length = dis.readUnsignedShort();
for (int i = 0; i < exception_table_length; i++) {
int startPc = dis.readUnsignedShort();
int endPc = dis.readUnsignedShort();
int handlerPc = dis.readUnsignedShort();
int catchType = dis.readUnsignedShort();
System.out.println("startPc:"+startPc + ",endPc:" + endPc+ ",handlerPc:" + handlerPc+ ",catchType:" + catchType);
}
int attributes_count = dis.readUnsignedShort();
for (int i = 0; i < attributes_count; i++) {
parseAttribute(dis, strs);
}
break;
}
case "StackMapTable":{
int numberOfEntries = dis.readUnsignedShort();
System.out.println("numberOfEntries:"+numberOfEntries);
for (int i = 0; i < numberOfEntries; i++) {
int frameType = dis.readUnsignedByte();
System.out.println("frameType:"+frameType);
if (frameType >= 64 && frameType <= 127) {
parseVerificationTypeInfo(dis, strs);
} else if (frameType == 247) {
int offsetDelta = dis.readUnsignedShort();
parseVerificationTypeInfo(dis, strs);
} else if (frameType >= 248 && frameType<=250) {
int offsetDelta = dis.readUnsignedShort();
} else if (frameType == 251) {
int offsetDelta = dis.readUnsignedShort();
} else if (frameType >=252 && frameType<=254) {
int offsetDelta = dis.readUnsignedShort();
for (int j = 0; j < frameType - 251; j++) {
parseVerificationTypeInfo(dis, strs);
}
} else if (frameType == 255) {
int offsetDelta = dis.readUnsignedShort();
int numberOfLocals = dis.readUnsignedShort();
for (int j = 0; j < numberOfLocals; j++) {
parseVerificationTypeInfo(dis, strs);
}
int numberOfStackItems = dis.readUnsignedShort();
for (int j = 0; j < numberOfStackItems; j++) {
parseVerificationTypeInfo(dis, strs);
}
}
}
break;
}
case "Exceptions": {
int numberOfExceptions = dis.readUnsignedShort();
System.out.println("numberOfExceptions:" +numberOfExceptions);
for (int i = 0; i < numberOfExceptions; i++) {
int exceptionIndex = dis.readUnsignedShort();
System.out.println("exceptionIndex:" +exceptionIndex);
}
break;
}
case "InnerClasses": {
int numberOfClasses = dis.readUnsignedShort();
System.out.println("numberOfClasses:" +numberOfClasses);
for (int i = 0; i < numberOfClasses; i++) {
int innerClassInfoIndex = dis.readUnsignedShort();
int outerClassInfoIndex = dis.readUnsignedShort();
int innerNameIndex = dis.readUnsignedShort();
int innerClassAccessFlags = dis.readUnsignedShort();
System.out.println("innerClassInfoIndex:" +innerClassInfoIndex+",outerClassInfoIndex:" +outerClassInfoIndex+",innerNameIndex:" +innerNameIndex+",innerClassAccessFlags:" +innerClassAccessFlags);
}
break;
}
case "EnclosingMethod": {
int classIndex = dis.readUnsignedShort();
int methodIndex = dis.readUnsignedShort();
System.out.println("classIndex:" +classIndex+",methodIndex:" +methodIndex);
break;
}
case "Synthetic": {
System.out.println("Synthetic");
break;
}
case "Signature": {
int signatureIndex = dis.readUnsignedShort();
System.out.println("signatureIndex:" +signatureIndex);
break;
}
case "SourceFile": {
int sourcefileIndex = dis.readUnsignedShort();
System.out.println("sourcefileIndex:" +sourcefileIndex);
break;
}
case "SourceDebugExtension": {
break;
}
case "LineNumberTable": {
int lineNumberTableLength = dis.readUnsignedShort();
System.out.println("lineNumberTableLength:" +lineNumberTableLength);
for (int i = 0; i < lineNumberTableLength; i++) {
int startPc = dis.readUnsignedShort();
int lineNumber = dis.readUnsignedShort();
System.out.println("startPc:" +startPc+",lineNumber:" +lineNumber);
}
break;
}
case "LocalVariableTable": {
int localVariableTableLength = dis.readUnsignedShort();
System.out.println("localVariableTableLength:" +localVariableTableLength);
for (int i = 0; i < localVariableTableLength; i++) {
int startPc = dis.readUnsignedShort();
int length = dis.readUnsignedShort();
int nameIndex = dis.readUnsignedShort();
int descriptorIndex = dis.readUnsignedShort();
int index = dis.readUnsignedShort();
System.out.println("startPc:" +startPc+",length:" +length+",nameIndex:" +nameIndex+",descriptorIndex:" +descriptorIndex+",index:" +index);
}
break;
}
case "LocalVariableTypeTable": {
int localVariableTypeTableLength = dis.readUnsignedShort();
System.out.println("localVariableTypeTableLength:" +localVariableTypeTableLength);
for (int i = 0; i < localVariableTypeTableLength; i++) {
int startPc = dis.readUnsignedShort();
int length = dis.readUnsignedShort();
int nameIndex = dis.readUnsignedShort();
int signatureIndex = dis.readUnsignedShort();
int index = dis.readUnsignedShort();
System.out.println("startPc:" +startPc+",length:" +length+",nameIndex:" +nameIndex+",signatureIndex:" +signatureIndex+",index:" +index);
}
break;
}
case "Deprecated": {
System.out.println("Deprecated");
break;
}
case "RuntimeVisibleAnnotations": {
int numAnnotations = dis.readUnsignedShort();
for (int i = 0; i < numAnnotations; i++) {
parseAnnotation(dis, strs);
}
break;
}
case "RuntimeInvisibleAnnotations": {
int numAnnotations = dis.readUnsignedShort();
for (int i = 0; i < numAnnotations; i++) {
parseAnnotation(dis, strs);
}
break;
}
case "RuntimeVisibleParameterAnnotations": {
int numParameters = dis.readUnsignedByte();
System.out.println("numParameters:"+numParameters);
for (int i = 0; i < numParameters; i++) {
int numAnnotations = dis.readUnsignedShort();
System.out.println("numAnnotations:"+numAnnotations);
for (int j = 0; j < numAnnotations; j++) {
parseAnnotation(dis, strs);
}
}
break;
}
case "RuntimeInvisibleParameterAnnotations": {
int numParameters = dis.readUnsignedByte();
for (int i = 0; i < numParameters; i++) {
int numAnnotations = dis.readUnsignedShort();
for (int j = 0; j < numAnnotations; j++) {
parseAnnotation(dis, strs);
}
}
break;
}
case "RuntimeVisibleTypeAnnotations": {
int numAnnotations = dis.readUnsignedShort();
for (int i = 0; i < numAnnotations; i++) {
parseAnnotation(dis, strs);
}
break;
}
case "RuntimeInvisibleTypeAnnotations": {
int numAnnotations = dis.readUnsignedShort();
for (int i = 0; i < numAnnotations; i++) {
parseAnnotation(dis, strs);
}
break;
}
case "AnnotationDefault": {
parseElementValue(dis, strs);
break;
}
case "BootstrapMethods": {
int numBootstrapMethods = dis.readUnsignedShort();
System.out.println("numBootstrapMethods:" +numBootstrapMethods);
for (int i = 0; i < numBootstrapMethods; i++) {
int bootstrapMethodRef = dis.readUnsignedShort();
int numBootstrapArguments = dis.readUnsignedShort();
System.out.println("bootstrapMethodRef:" +bootstrapMethodRef+",numBootstrapArguments:" +numBootstrapArguments);
for (int j = 0; j < numBootstrapArguments; j++) {
int bootstrapArguments = dis.readUnsignedShort();
System.out.println("bootstrapArguments:" +bootstrapArguments);
}
}
break;
}
case "MethodParameters": {
int parametersCount = dis.readUnsignedShort();
System.out.println("parametersCount:" +parametersCount);
for (int i = 0; i < parametersCount; i++) {
int nameIndex = dis.readUnsignedShort();
int accessFlags = dis.readUnsignedShort();
System.out.println("nameIndex:" +nameIndex+",accessFlags:" +accessFlags);
}
break;
}
}
}
2.3.10 annotation
public static void parseAnnotation(DataInputStream dis, String[] strs) throws IOException {
int typeIndex = dis.readUnsignedShort();
int numElementValuePairs = dis.readUnsignedShort();
System.out.println("typeIndex:" +typeIndex+",numElementValuePairs:" +numElementValuePairs);
for (int i = 0; i < numElementValuePairs; i++) {
int elementNameIndex = dis.readUnsignedShort();
System.out.println(elementNameIndex);
parseElementValue(dis, strs);
}
}
2.3.11 elementValue
public static void parseElementValue(DataInputStream dis, String[] strs) throws IOException {
int tag = dis.readUnsignedByte();
switch (tag) {
case 'B':
case 'C':
case 'D':
case 'F':
case 'I':
case 'J':
case 'S':
case 'Z':
case 's': {
int constValueIndex = dis.readUnsignedShort();
System.out.println("tag:" + tag + ",constValueIndex:" + constValueIndex);
break;
}
case 'e': {
int typeNameIndex = dis.readUnsignedShort();
int constNameIndex = dis.readUnsignedShort();
System.out.println("tag:" + tag + ",typeNameIndex:" + typeNameIndex+ ",constNameIndex:" + constNameIndex);
break;
}
case 'c': {
int classInfoIndex = dis.readUnsignedShort();
System.out.println("tag:" + tag + ",classInfoIndex:" + classInfoIndex);
break;
}
case '@': {
parseAnnotation(dis, strs);
break;
}
case '[': {
int num_values = dis.readUnsignedShort();
for (int j = 0; j < num_values; j++) {
parseElementValue(dis, strs);
}
break;
}
}
}
2.3.12 verificationTypeInfo
public static void parseVerificationTypeInfo(DataInputStream dis, String[] strs) throws IOException {
int tag = dis.readUnsignedByte();
System.out.println("tag:"+tag);
if (tag == 7) {
int cpoolIndex = dis.readUnsignedShort();
System.out.println("cpoolIndex:"+cpoolIndex);
} else if (tag == 8) {
int offset = dis.readUnsignedShort();
System.out.println("offset:"+offset);
}
}



