Start working on code writing

src/attribute.rs

@@ -1,4 +1,5 @@
 use std::io;
+use std::io::Write;
 
 use bytecode::*;
 use parsing;
@@ -68,6 +69,38 @@ impl Code {
             attributes,
         })
     }
+
+    pub fn to_bytes(&self) -> Vec<u8> {
+        let mut buffer = vec![];
+
+        let max_stack = u16::to_be_bytes(self.max_stack);
+        let max_locals = u16::to_be_bytes(self.max_locals);
+
+        buffer.write_all(&max_stack).unwrap();
+        buffer.write_all(&max_locals).unwrap();
+
+        let mut code: Vec<u8> = self.code.iter()
+            .map(|(_, bytecode)| bytecode)
+            .flat_map(Bytecode::to_bytes)
+            .collect();
+
+        let code_length = u32::to_be_bytes(code.len() as u32);
+
+        buffer.write_all(&code_length).unwrap();
+        buffer.write_all(&mut code).unwrap();
+
+        // TODO: implement writing of execption table and attributes
+        assert!(self.exception_table.len() == 0);
+        assert!(self.attributes.len() == 0);
+
+        let exception_table_length = u16::to_be_bytes(0);
+        let attributes_length = u16::to_be_bytes(0);
+
+        buffer.write_all(&exception_table_length).unwrap();
+        buffer.write_all(&attributes_length).unwrap();
+
+        buffer
+    }
 }
 
 #[derive(Debug)]

src/bytecode.rs

@@ -251,6 +251,39 @@ impl Bytecode {
         bytecode
     }
 
+    /// Converts the bytecode into a vector of bytes.
+    ///
+    /// ```
+    /// # use jvm_class_file_parser::Bytecode::*;
+    /// #
+    /// assert_eq!(Aconst_null.to_bytes(), vec![1]);
+    /// assert_eq!(Getstatic(2).to_bytes(), vec![178, 0, 2]);
+    /// ```
+    pub fn to_bytes(&self) -> Vec<u8> {
+        use Bytecode::*;
+
+        match self {
+            Aconst_null => vec![ACONST_NULL],
+            Ldc(constant_index) => {
+                let bytes = u8::to_be_bytes(*constant_index);
+
+                vec![LDC, bytes[0]]
+            },
+            Return => vec![RETURN],
+            Getstatic(field) => {
+                let bytes = u16::to_be_bytes(*field);
+
+                vec![GETSTATIC, bytes[0], bytes[1]]
+            },
+            Invokevirtual(method) => {
+                let bytes = u16::to_be_bytes(*method);
+
+                vec![INVOKEVIRTUAL, bytes[0], bytes[1]]
+            },
+            _ => panic!(),
+        }
+    }
+
     /// Converts the bytecode into a String representation.
     ///
     /// Takes in the index of the instruction so that it can be used to display

src/main.rs

@@ -47,7 +47,7 @@ fn javap(filepath: &str) {
 
     println!("{{");
 
-    for method in class_file.methods.iter() {
+    for method in &class_file.methods {
         print_method(&class_file, method);
     }
 

src/writing.rs

@@ -11,6 +11,7 @@ const MAGIC: u32 = 0xCAFE_BABE;
 
 const CONSTANT_TAG_UTF8: u8 = 1;
 const CONSTANT_TAG_CLASS: u8 = 7;
+const CONSTANT_TAG_STRING: u8 = 8;
 const CONSTANT_TAG_FIELDREF: u8 = 9;
 const CONSTANT_TAG_METHODREF: u8 = 10;
 const CONSTANT_TAG_NAME_AND_TYPE: u8 = 12;
@@ -68,6 +69,10 @@ fn write_constant_pool_entry<W: Write>(file: &mut W, entry: &Box<ConstantPoolEnt
     match **entry {
         ConstantUtf8 { ref string } => write_constant_utf8(file, &string)?,
         ConstantClass { name_index } => write_constant_class(file, name_index)?,
+        ConstantString { string_index } =>
+            write_constant_string(file, string_index)?,
+        ConstantFieldref { class_index, name_and_type_index } =>
+            write_constant_fieldref(file, class_index, name_and_type_index)?,
         ConstantMethodref { class_index, name_and_type_index } =>
             write_constant_methodref(file, class_index, name_and_type_index)?,
         ConstantNameAndType { name_index, descriptor_index } =>
@@ -95,6 +100,21 @@ fn write_constant_class<W: Write>(file: &mut W, name_index: u16) -> io::Result<(
     Ok(())
 }
 
+fn write_constant_string<W: Write>(file: &mut W, string_index: u16) -> io::Result<()> {
+    write_u8(file, CONSTANT_TAG_STRING)?;
+    write_u16(file, string_index)?;
+
+    Ok(())
+}
+
+fn write_constant_fieldref<W: Write>(file: &mut W, class_index: u16, name_and_type_index: u16) -> io::Result<()> {
+    write_u8(file, CONSTANT_TAG_FIELDREF)?;
+    write_u16(file, class_index)?;
+    write_u16(file, name_and_type_index)?;
+
+    Ok(())
+}
+
 fn write_constant_methodref<W: Write>(file: &mut W, class_index: u16, name_and_type_index: u16) -> io::Result<()> {
     write_u8(file, CONSTANT_TAG_METHODREF)?;
     write_u16(file, class_index)?;

tests/parse_and_write.rs

@@ -27,3 +27,8 @@ fn parse_and_write(filepath: &str) {
 fn parse_and_write_class_dummy() {
     parse_and_write("classes/Dummy.class");
 }
+
+#[test]
+fn parse_and_write_class_helloworld() {
+    parse_and_write("classes/HelloWorld.class");
+}