Updated and extended attribute rendering

Author: xea

src/bytecode/classfile.rs

@@ -328,15 +328,15 @@ pub enum Attribute {
     Code { max_stack: u16, max_locals: u16, code: Vec<Instruction>, exception_table: Vec<ExceptionHandler>, attributes: Vec<Attribute> },
     StackMapTable(Vec<StackMapFrame>),
     Exceptions(Vec<ConstantPoolIndex>),
-    InnerClass(Vec<InnerClass>),
+    InnerClasses(Vec<InnerClass>),
     EnclosingMethod { class_index: ConstantPoolIndex, method_index: ConstantPoolIndex },
     Synthetic,
     Signature(ConstantPoolIndex),
     SourceFile(ConstantPoolIndex),
     SourceDebugExtension(Vec<u8>),
-    LineNumbeTable(Vec<LineNumberTable>),
+    LineNumberTable(Vec<LineNumberTable>),
     LocalVariableTable(Vec<LocalVariableTable>),
-    LocalVariableTableType(Vec<LocalVariableTableType>),
+    LocalVariableTypeTable(Vec<LocalVariableTypeTable>),
     Deprecated,
     RuntimeVisibleAnnotations(Vec<Annotation>),
     RuntimeInvisibleAnnotations(Vec<Annotation>),
@@ -432,7 +432,7 @@ pub struct LocalVariableTable {
 }
 
 #[derive(Debug)]
-pub struct LocalVariableTableType {
+pub struct LocalVariableTypeTable {
     pub start_pc: u16,
     pub length: u16,
     pub name_index: ConstantPoolIndex,
@@ -446,22 +446,45 @@ pub struct Annotation {
     pub element_value_pairs: Vec<ElementValuePair>
 }
 
+impl Annotation {
+    pub fn len(&self) -> usize {
+        self.element_value_pairs.iter().fold(2, |acc, x| acc + x.len())
+    }
+}
+
 #[derive(Debug)]
 pub struct ElementValuePair {
     pub element_name_index: ConstantPoolIndex,
     pub value: ElementValue
 }
 
+impl ElementValuePair {
+    pub fn len(&self) -> usize {
+        2 + self.value.len()
+    }
+}
 
 #[derive(Debug)]
 pub enum ElementValue {
-    ConstantValue(ConstantPoolIndex),
+    ConstantValue(u8, ConstantPoolIndex),
     Enum { type_name_index: ConstantPoolIndex, const_name_index: ConstantPoolIndex },
     ClassInfo(ConstantPoolIndex),
     Annotation(Annotation),
     Array(Vec<ElementValue>)
 }
 
+impl ElementValue {
+    pub fn len(&self) -> usize {
+        match self {
+            &ElementValue::ConstantValue(_, _) => 3,
+            &ElementValue::Enum { type_name_index: _, const_name_index: _ } => 5,
+            &ElementValue::ClassInfo(_) => 3,
+            &ElementValue::Annotation(ref annotation) => 1 + annotation.len(),
+            &ElementValue::Array(ref table) => table.iter().fold(3, |acc, x| acc + x.len())
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct TypeAnnotation {
     pub target_info: TargetInfo,
@@ -503,12 +526,19 @@ pub struct BootstrapMethod {
     pub bootstrap_arguments: Vec<ConstantPoolIndex>
 }
 
+impl BootstrapMethod {
+}
+
 #[derive(Debug)]
 pub struct MethodParameter {
     pub name_index: ConstantPoolIndex,
     pub access_flags: AccessFlags
 }
 
+impl MethodParameter {
+    pub fn len(&self) -> usize { 4 }
+}
+
 #[allow(non_camel_case_types)]
 #[derive(Debug)]
 pub enum Instruction {

src/bytecode/io/reader.rs

@@ -629,7 +629,7 @@ impl ClassReader {
                         let n = reader.get_u16();
                         (0..n).map(|_| ConstantPoolIndex::new(reader.get_u16() as usize)).collect()
                         })),
-                    "InnerClass" => Some(Attribute::InnerClass({
+                    "InnerClasses" => Some(Attribute::InnerClasses({
                         let n = reader.get_u16();
                         (0..n).map(|_| InnerClass {
                             inner_class_info_index: ConstantPoolIndex::new(reader.get_u16() as usize),
@@ -643,7 +643,7 @@ impl ClassReader {
                     "Signature" => Some(Attribute::Signature(ConstantPoolIndex::new(reader.get_u16() as usize))),
                     "SourceFile" => Some(Attribute::SourceFile(ConstantPoolIndex::new(reader.get_u16() as usize))),
                     "SourceDebugExtension" => Some(Attribute::SourceDebugExtension(reader.get_bytes())),
-                    "LineNumberTable" => Some(Attribute::LineNumbeTable({
+                    "LineNumberTable" => Some(Attribute::LineNumberTable({
                         let n = reader.get_u16();
                         (0..n).map(|_| LineNumberTable {
                             start_pc: reader.get_u16(),
@@ -660,9 +660,9 @@ impl ClassReader {
                             index: reader.get_u16()
                         }).collect()
                     })),
-                    "LocalVariableTypeTable" => Some(Attribute::LocalVariableTableType({
+                    "LocalVariableTypeTable" => Some(Attribute::LocalVariableTypeTable({
                         let n = reader.get_u16();
-                        (0..n).map(|_| LocalVariableTableType {
+                        (0..n).map(|_| LocalVariableTypeTable {
                             start_pc: reader.get_u16(),
                             length: reader.get_u16(),
                             name_index: ConstantPoolIndex::new(reader.get_u16() as usize),
@@ -792,15 +792,15 @@ impl ClassReader {
         let tag = reader.get_u8();
 
         match tag {
-            66 /* B */ => ElementValue::ConstantValue(ConstantPoolIndex::new(reader.get_u16() as usize)),
-            67 /* C */ => ElementValue::ConstantValue(ConstantPoolIndex::new(reader.get_u16() as usize)),
-            68 /* D */ => ElementValue::ConstantValue(ConstantPoolIndex::new(reader.get_u16() as usize)),
-            70 /* F */ => ElementValue::ConstantValue(ConstantPoolIndex::new(reader.get_u16() as usize)),
-            73 /* I */ => ElementValue::ConstantValue(ConstantPoolIndex::new(reader.get_u16() as usize)),
-            74 /* J */ => ElementValue::ConstantValue(ConstantPoolIndex::new(reader.get_u16() as usize)),
-            83 /* S */ => ElementValue::ConstantValue(ConstantPoolIndex::new(reader.get_u16() as usize)),
-            90 /* Z */ => ElementValue::ConstantValue(ConstantPoolIndex::new(reader.get_u16() as usize)),
-            115 /* s */ => ElementValue::ConstantValue(ConstantPoolIndex::new(reader.get_u16() as usize)),
+            66 /* B */ => ElementValue::ConstantValue(tag, ConstantPoolIndex::new(reader.get_u16() as usize)),
+            67 /* C */ => ElementValue::ConstantValue(tag, ConstantPoolIndex::new(reader.get_u16() as usize)),
+            68 /* D */ => ElementValue::ConstantValue(tag, ConstantPoolIndex::new(reader.get_u16() as usize)),
+            70 /* F */ => ElementValue::ConstantValue(tag, ConstantPoolIndex::new(reader.get_u16() as usize)),
+            73 /* I */ => ElementValue::ConstantValue(tag, ConstantPoolIndex::new(reader.get_u16() as usize)),
+            74 /* J */ => ElementValue::ConstantValue(tag, ConstantPoolIndex::new(reader.get_u16() as usize)),
+            83 /* S */ => ElementValue::ConstantValue(tag, ConstantPoolIndex::new(reader.get_u16() as usize)),
+            90 /* Z */ => ElementValue::ConstantValue(tag, ConstantPoolIndex::new(reader.get_u16() as usize)),
+            115 /* s */ => ElementValue::ConstantValue(tag, ConstantPoolIndex::new(reader.get_u16() as usize)),
             101 /* e */ => ElementValue::Enum {
                 type_name_index: ConstantPoolIndex::new(reader.get_u16() as usize),
                 const_name_index: ConstantPoolIndex::new(reader.get_u16() as usize) },
@@ -810,7 +810,7 @@ impl ClassReader {
                 let n = reader.get_u16();
                 (0..n).map(|_| ClassReader::read_element_value(reader)).collect()
             }),
-            _ => ElementValue::ConstantValue(ConstantPoolIndex::new(0)) // TODO this deserves a better error handling
+            _ => ElementValue::ConstantValue(tag, ConstantPoolIndex::new(0)) // TODO this deserves a better error handling
         }
     }