Add support for constant values in the constant tool

note that the serialization fails because some bytecode instructions are
not yet recognized

Author: jbalint

classes/ConstantValues.class

@@ -0,0 +1,9 @@
+// constant values represented in constant pool as values
+
+class ConstantValues {
+    int integer_constant = 65535;
+    float float_constant = 42.0f;
+    long long_constant = 42L;
+    double double_constant = -1;
+    String string_constant = "fourty two";
+}

classes/ConstantValues.java

@@ -1,10 +1,24 @@
+use util::FloatBuffer;
+
 #[derive(Debug)]
 #[derive(Eq)]
 #[derive(PartialEq)]
 pub enum ConstantPoolEntry {
     ConstantUtf8 {
         string: String,
     },
+    ConstantInteger {
+        val: i32,
+    },
+    ConstantFloat {
+        val: FloatBuffer<[u8; 4]>,
+    },
+    ConstantLong {
+        val: i64,
+    },
+    ConstantDouble {
+        val: FloatBuffer<[u8; 8]>,
+    },
     ConstantClass {
         name_index: u16,
     },
@@ -23,4 +37,6 @@ pub enum ConstantPoolEntry {
         name_index: u16,
         descriptor_index: u16,
     },
+    // represents an empty slot in the constant pool table
+    ConstantEmptySlot { },
 }

src/constant_pool.rs

@@ -13,7 +13,7 @@ use jvm_class_file_parser::{
     Method
 };
 
-const CONSTURCTOR_NAME: &str = "<init>";
+const CONSTRUCTOR_NAME: &str = "<init>";
 
 fn main() {
     let args: Vec<String> = env::args().collect();
@@ -140,6 +140,36 @@ fn format_constant_pool_entry(
                 class_file.get_constant_utf8(string_index as usize)
             )
         },
+        ConstantInteger { ref val } => {
+            format!(
+                "{:<20}{:<16}",
+                "Integer",
+                format!("={}", val)
+            )
+        },
+        ConstantFloat { ref val } => {
+            let as_f32: f32 = val.into();
+            format!(
+                "{:<20}{:<16}",
+                "Float",
+                format!("={}", as_f32)
+            )
+        },
+        ConstantLong { val } => {
+            format!(
+                "{:<20}{:<16}",
+                "Long",
+                format!("={}", val)
+            )
+        },
+        ConstantDouble { ref val } => {
+            let as_f64: f64 = val.into();
+            format!(
+                "{:<20}{:<16}",
+                "Double",
+                format!("={}", as_f64)
+            )
+        },
         ConstantFieldref { class_index, name_and_type_index } => {
             format!(
                 "{:<20}{:<16}// {}",
@@ -180,6 +210,9 @@ fn format_constant_pool_entry(
                 )
             )
         },
+        ConstantEmptySlot {} => {
+            "<empty slot>".to_string()
+        },
     }
 }
 
@@ -188,7 +221,7 @@ fn print_method(class_file: &ClassFile, method: &Method) {
 
     println!(
         "  {}();",
-        if method_name == CONSTURCTOR_NAME { class_file.get_class_name() }
+        if method_name == CONSTRUCTOR_NAME { class_file.get_class_name() }
             else { method_name }
     );
 
@@ -223,7 +256,7 @@ fn print_method(class_file: &ClassFile, method: &Method) {
     }
 }
 
-fn print_bytecode(class_file: &ClassFile, code: &[(usize, Bytecode)]) {
+fn print_bytecode(_class_file: &ClassFile, code: &[(usize, Bytecode)]) {
     for (i, bytecode) in code {
         print!(
             "        {:>3}: {:35}",

src/main.rs

@@ -9,11 +9,16 @@ use constant_pool::*;
 use field::*;
 use field_access::*;
 use method::*;
-use util::{Contextable, promote_result_to_io};
+use util::{Contextable, promote_result_to_io, FloatBuffer};
+use std::ops::Deref;
 
 const EXPECTED_MAGIC: u32 = 0xCAFE_BABE;
 
 const CONSTANT_TAG_UTF8: u8 = 1;
+const CONSTANT_TAG_INTEGER: u8 = 3;
+const CONSTANT_TAG_FLOAT: u8 = 4;
+const CONSTANT_TAG_LONG: u8 = 5;
+const CONSTANT_TAG_DOUBLE: u8 = 6;
 const CONSTANT_TAG_CLASS: u8 = 7;
 const CONSTANT_TAG_STRING: u8 = 8;
 const CONSTANT_TAG_FIELDREF: u8 = 9;
@@ -106,14 +111,31 @@ fn read_n_bytes<R: Read>(file: &mut R, length: usize) -> io::Result<Vec<u8>> {
 
 #[allow(clippy::vec_box)]
 fn read_constant_pool<R: Read>(file: &mut R) -> io::Result<Vec<Box<ConstantPoolEntry>>> {
-    let constant_pool_count = i32::from(read_u16(file)?);
+    let mut constant_pool_count = read_u16(file)? - 1;
 
-    let mut constant_pool = Vec::<Box<ConstantPoolEntry>>::new();
+    let mut constant_pool = Vec::<Box<ConstantPoolEntry>>::with_capacity(constant_pool_count as usize);
 
-    for _ in 0..(constant_pool_count - 1) {
+    while constant_pool_count > 0 {
         let entry = read_constant_pool_entry(file)?;
 
         constant_pool.push(entry);
+
+        // from https://docs.oracle.com/javase/specs/jvms/se11/html/jvms-4.html#jvms-4.4.5
+        // All 8-byte constants take up two entries in the constant_pool table of the class file.
+        // If a CONSTANT_Long_info or CONSTANT_Double_info structure is the entry at index n in the
+        // constant_pool table, then the next usable entry in the table is located at index n+2. The
+        // constant_pool index n+1 must be valid but is considered unusable.
+        // (we could abstract this slightly by placing the structure constraint in the enum)
+        match constant_pool.get(constant_pool.len() - 1).unwrap().deref() {
+            ConstantPoolEntry::ConstantLong { val: _ } | ConstantPoolEntry::ConstantDouble { val: _ } => {
+                // we need this ensure proper indexes of all other entries
+                constant_pool.push(Box::new(ConstantPoolEntry::ConstantEmptySlot {}));
+                constant_pool_count = constant_pool_count - 1
+            },
+            _ => {},
+        }
+
+        constant_pool_count = constant_pool_count - 1
     }
 
     Ok(constant_pool)
@@ -129,6 +151,14 @@ fn read_constant_pool_entry<R: Read>(file: &mut R) -> io::Result<Box<ConstantPoo
             Box::new(read_constant_class(file)?),
         CONSTANT_TAG_STRING =>
             Box::new(read_constant_string(file)?),
+        CONSTANT_TAG_INTEGER =>
+            Box::new(read_constant_integer(file)?),
+        CONSTANT_TAG_FLOAT =>
+            Box::new(read_constant_float(file)?),
+        CONSTANT_TAG_LONG =>
+            Box::new(read_constant_long(file)?),
+        CONSTANT_TAG_DOUBLE =>
+            Box::new(read_constant_double(file)?),
         CONSTANT_TAG_FIELDREF =>
             Box::new(read_constant_fieldref(file)?),
         CONSTANT_TAG_METHODREF =>
@@ -154,6 +184,42 @@ fn read_constant_utf8<R: Read>(file: &mut R) -> io::Result<ConstantPoolEntry> {
     })
 }
 
+fn read_constant_integer<R: Read>(file: &mut R) -> io::Result<ConstantPoolEntry> {
+    let mut buffer = [0; 4];
+    file.read_exact(&mut buffer)?;
+
+    Ok(ConstantPoolEntry::ConstantInteger {
+        val: i32::from_be_bytes(buffer)
+    })
+}
+
+fn read_constant_float<R: Read>(file: &mut R) -> io::Result<ConstantPoolEntry> {
+    let mut buffer = [0; 4];
+    file.read_exact(&mut buffer)?;
+
+    Ok(ConstantPoolEntry::ConstantFloat {
+        val: FloatBuffer { buf: buffer }
+    })
+}
+
+fn read_constant_long<R: Read>(file: &mut R) -> io::Result<ConstantPoolEntry> {
+    let mut buffer = [0; 8];
+    file.read_exact(&mut buffer)?;
+
+    Ok(ConstantPoolEntry::ConstantLong {
+        val: i64::from_be_bytes(buffer)
+    })
+}
+
+fn read_constant_double<R: Read>(file: &mut R) -> io::Result<ConstantPoolEntry> {
+    let mut buffer = [0; 8];
+    file.read_exact(&mut buffer)?;
+
+    Ok(ConstantPoolEntry::ConstantDouble {
+        val: FloatBuffer { buf: buffer }
+    })
+}
+
 fn read_constant_class<R: Read>(file: &mut R) -> io::Result<ConstantPoolEntry> {
     let name_index = read_u16(file)?;
 

src/parsing.rs

@@ -32,6 +32,27 @@ impl<A> Contextable for Result<A, io::Error> {
     }
 }
 
+/// Wrapper around a buffer representing a float or double. We can't use `f32`
+/// directly because it doesn't implement `Eq` which we depend on in containing structs.
+#[derive(Debug)]
+#[derive(PartialEq)]
+#[derive(Eq)]
+pub struct FloatBuffer<B: Eq> {
+    pub buf: B,
+}
+
+impl From<&FloatBuffer<[u8; 4]>> for f32 {
+    fn from(float_buf: &FloatBuffer<[u8; 4]>) -> Self {
+        f32::from_be_bytes(float_buf.buf)
+    }
+}
+
+impl From<&FloatBuffer<[u8; 8]>> for f64 {
+    fn from(float_buf: &FloatBuffer<[u8; 8]>) -> Self {
+        f64::from_be_bytes(float_buf.buf)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use util::flag_is_set;

src/util.rs

@@ -11,7 +11,7 @@ const MAGIC: u32 = 0xCAFE_BABE;
 
 const CONSTANT_TAG_UTF8: u8 = 1;
 const CONSTANT_TAG_CLASS: u8 = 7;
-const CONSTANT_TAG_FIELDREF: u8 = 9;
+const _CONSTANT_TAG_FIELDREF: u8 = 9;
 const CONSTANT_TAG_METHODREF: u8 = 10;
 const CONSTANT_TAG_NAME_AND_TYPE: u8 = 12;
 

src/writing.rs

@@ -3,9 +3,8 @@ extern crate jvm_class_file_parser;
 use std::collections::HashSet;
 use std::fs::File;
 
-use jvm_class_file_parser::{
-    Attribute, Bytecode, ClassAccess, ClassFile, Code, Field, FieldAccess
-};
+use jvm_class_file_parser::{Attribute, Bytecode, ClassAccess, ClassFile, Code, Field, FieldAccess, ConstantPoolEntry};
+use std::ops::Deref;
 
 #[test]
 fn parse_class_dummy() {
@@ -131,3 +130,54 @@ fn parse_class_intbox() {
        get_value_code.unwrap()
     );
 }
+
+#[test]
+fn parse_class_constant_values() {
+    let mut file = File::open("classes/ConstantValues.class").unwrap();
+    let class_file = ClassFile::from_file(&mut file).unwrap();
+
+    match class_file.get_constant(2).deref() {
+        ConstantPoolEntry::ConstantInteger { val } => {
+            assert_eq!(65535, *val)
+        },
+        _ => {
+            panic!("Expected an integer")
+        }
+    }
+
+    match class_file.get_constant(4).deref() {
+        ConstantPoolEntry::ConstantFloat { ref val } => {
+            assert_eq!(42.0 as f32, val.into())
+        },
+        _ => {
+            panic!("Expected a float")
+        }
+    }
+
+    match class_file.get_constant(6).deref() {
+        ConstantPoolEntry::ConstantLong { val } => {
+            assert_eq!(42, *val)
+        },
+        _ => {
+            panic!("Expected a long")
+        }
+    }
+
+    match class_file.get_constant(9).deref() {
+        ConstantPoolEntry::ConstantDouble { ref val } => {
+            assert_eq!(-1 as f64, val.into())
+        },
+        _ => {
+            panic!("Expected a double")
+        }
+    }
+
+    match class_file.get_constant(37).deref() {
+        ConstantPoolEntry::ConstantUtf8 { ref string } => {
+            assert_eq!("fourty two".to_string(), *string)
+        },
+        _ => {
+            panic!("Expected a utf8 string")
+        }
+    }
+}