Add better support for class access flags

Author: ExcaliburZero

src/class_access.rs

@@ -0,0 +1,92 @@
+use std::collections::HashSet;
+
+use util::flag_is_set;
+
+// Access flag masks are from Table 4.1-B of the JVM specification
+//
+// https://docs.oracle.com/javase/specs/jvms/se11/html/jvms-4.html#jvms-4.1-200-E.1
+const PUBLIC_FLAG: u16 = 0x0001;
+const FINAL_FLAG: u16 = 0x0010;
+const SUPER_FLAG: u16 = 0x0020;
+const INTERFACE_FLAG: u16 = 0x0200;
+const ABSTRACT_FLAG: u16 = 0x0400;
+const SYNTHETIC_FLAG: u16 = 0x1000;
+const ANNOTATION_FLAG: u16 = 0x2000;
+const ENUM_FLAG: u16 = 0x4000;
+const MODULE_FLAG: u16 = 0x8000;
+
+/// A flag that denotes an access level or property of a class.
+///
+/// See the `access_flags` section of Chapter 4.1 of the JVM specification for
+/// details.
+///
+/// https://docs.oracle.com/javase/specs/jvms/se11/html/jvms-4.html#jvms-4.1-200-E
+#[derive(Debug)]
+#[derive(Eq)]
+#[derive(Hash)]
+#[derive(PartialEq)]
+pub enum ClassAccess {
+    Public,
+    Final,
+    Super,
+    Interface,
+    Abstract,
+    Synthetic,
+    Annotation,
+    Enum,
+    Module,
+}
+
+impl ClassAccess {
+    /// Extracts the list of class access flags that are embedded in the given
+    /// access flag value.
+    ///
+    /// Returns an error message if the extracted combination of access flags
+    /// are inconsistent. (This validation has not yet been implemented)
+    ///
+    /// See Table 4.1-B of the JVM specification for more details.
+    ///
+    /// https://docs.oracle.com/javase/specs/jvms/se11/html/jvms-4.html#jvms-4.1-200-E.1
+    ///
+    /// ```
+    /// # use std::collections::HashSet;
+    /// # use jvm_class_file_parser::ClassAccess;
+    /// #
+    /// let access_flags = 0b0000_0010_0000_0001;
+    ///
+    /// let mut expected = HashSet::new();
+    /// expected.insert(ClassAccess::Public);
+    /// expected.insert(ClassAccess::Interface);
+    ///
+    /// assert_eq!(Ok(expected), ClassAccess::from_access_flags(access_flags));
+    /// ```
+    pub fn from_access_flags(access_flags: u16) -> Result<HashSet<ClassAccess>, String> {
+        use ClassAccess::*;
+
+        let mut access = HashSet::new();
+
+        let is_public = flag_is_set(PUBLIC_FLAG, access_flags);
+        let is_final = flag_is_set(FINAL_FLAG, access_flags);
+        let is_super = flag_is_set(SUPER_FLAG, access_flags);
+        let is_interface = flag_is_set(INTERFACE_FLAG, access_flags);
+        let is_abstract = flag_is_set(ABSTRACT_FLAG, access_flags);
+        let is_synthetic = flag_is_set(SYNTHETIC_FLAG, access_flags);
+        let is_annotation = flag_is_set(ANNOTATION_FLAG, access_flags);
+        let is_enum = flag_is_set(ENUM_FLAG, access_flags);
+        let is_module = flag_is_set(MODULE_FLAG, access_flags);
+
+        // TODO: Add validation for inconsistent access flags
+
+        if is_public { access.insert(Public); }
+        if is_final { access.insert(Final); }
+        if is_super { access.insert(Super); }
+        if is_interface { access.insert(Interface); }
+        if is_abstract { access.insert(Abstract); }
+        if is_synthetic { access.insert(Synthetic); }
+        if is_annotation { access.insert(Annotation); }
+        if is_enum { access.insert(Enum); }
+        if is_module { access.insert(Module); }
+
+        Ok(access)
+    }
+}

src/class_file.rs

@@ -1,8 +1,10 @@
+use std::collections::HashSet;
 use std::fs::File;
 use std::io;
 use std::ops::Deref;
 
 use attribute::*;
+use class_access::*;
 use constant_pool::*;
 use field::*;
 use method::*;
@@ -19,7 +21,7 @@ pub struct ClassFile {
     pub minor_version: u16,
     pub major_version: u16,
     pub constant_pool: Vec<Box<ConstantPoolEntry>>,
-    pub access_flags: u16,
+    pub access_flags: HashSet<ClassAccess>,
     pub this_class: u16,
     pub super_class: u16,
     pub interfaces: Vec<u16>,

src/lib.rs

@@ -16,14 +16,17 @@
 mod attribute;
 mod bytecode;
 mod class_file;
+mod class_access;
 mod constant_pool;
 mod field;
 mod method;
 mod parsing;
+mod util;
 
 pub use attribute::*;
 pub use bytecode::*;
 pub use class_file::*;
+pub use class_access::*;
 pub use constant_pool::*;
 pub use field::*;
 pub use method::*;

src/main.rs

@@ -1,5 +1,6 @@
 extern crate jvm_class_file_parser;
 
+use std::collections::HashSet;
 use std::env;
 use std::fs;
 use std::fs::File;
@@ -8,7 +9,8 @@ use std::ops::Deref;
 use std::path::PathBuf;
 
 use jvm_class_file_parser::{
-    Bytecode, ClassFile, ConstantPoolEntry, ExceptionTableEntry, Method
+    Bytecode, ClassAccess, ClassFile, ConstantPoolEntry, ExceptionTableEntry,
+    Method
 };
 
 const CONSTURCTOR_NAME: &str = "<init>";
@@ -39,6 +41,8 @@ fn javap(filepath: &str) {
     println!("  minor version: {}", class_file.minor_version);
     println!("  major version: {}", class_file.major_version);
 
+    print_access_flags(&class_file.access_flags);
+
     print_constant_pool(&class_file);
 
     println!("{}", "{");
@@ -62,6 +66,31 @@ fn to_absolute_filepath(filepath: &str) -> io::Result<PathBuf> {
     fs::canonicalize(path)
 }
 
+fn print_access_flags(access_flags: &HashSet<ClassAccess>) {
+    let flags_str = access_flags.iter()
+        .map(access_flag_to_name)
+        .collect::<Vec<&str>>()
+        .join(", ");
+
+    println!("  flags: {}", flags_str);
+}
+
+fn access_flag_to_name(flag: &ClassAccess) -> &'static str {
+    use ClassAccess::*;
+
+    match flag {
+        Public => "PUBLIC_FLAG",
+        Final => "FINAL_FLAG",
+        Super => "SUPER_FLAG",
+        Interface => "INTERFACE_FLAG",
+        Abstract => "ABSTRACT_FLAG",
+        Synthetic => "SYNTHETIC_FLAG",
+        Annotation => "ANNOTATION_FLAG",
+        Enum => "ENUM_FLAG",
+        Module => "MODULE_FLAG",
+    }
+}
+
 fn print_constant_pool(class_file: &ClassFile) {
     println!("Constant pool:");
 

src/parsing.rs

@@ -1,13 +1,16 @@
+use std::collections::HashSet;
 use std::fs::File;
 use std::io;
 use std::io::{Error, ErrorKind, Read};
 use std::str;
 
 use attribute::*;
+use class_access::*;
 use class_file::ClassFile;
 use constant_pool::*;
 use field::*;
 use method::*;
+use util::promote_result_to_io;
 
 const EXPECTED_MAGIC: u32 = 0xCAFE_BABE;
 
@@ -40,6 +43,10 @@ pub fn read_class_file(file: &mut File) -> io::Result<ClassFile> {
     let methods = read_methods(file)?;
     let attributes = read_attributes(file)?;
 
+    let access_flags = promote_result_to_io(
+        ClassAccess::from_access_flags(access_flags)
+    )?;
+
     Ok(ClassFile {
         minor_version,
         major_version,

src/util.rs

@@ -0,0 +1,38 @@
+use std::io;
+use std::io::{Error, ErrorKind, Read};
+
+/// Checks if the given unary flag is set within the given binary encoding of a
+/// list of flags.
+pub fn flag_is_set(flag_to_check: u16, flags: u16) -> bool {
+    let check = flags & flag_to_check;
+
+    check > 0
+}
+
+pub fn promote_result_to_io<A>(result: Result<A, String>) -> io::Result<A> {
+    match result {
+        Ok(v) => Ok(v),
+        Err(s) => Err(Error::new(ErrorKind::Other, s)),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use util::flag_is_set;
+
+    #[test]
+    fn flag_is_set_finds_a_set_flag() {
+        let public_flag = 0b0000_0000_0000_0001;
+        let access_flags = 0b0000_0000_0000_1001;
+
+        assert_eq!(true, flag_is_set(public_flag, access_flags))
+    }
+
+    #[test]
+    fn flag_is_set_does_not_find_a_missing_flag() {
+        let volatile_flag = 0b0000_0000_0100_0000;
+        let access_flags = 0b0000_0000_0000_1001;
+
+        assert_eq!(false, flag_is_set(volatile_flag, access_flags))
+    }
+}

tests/parse_classes.rs

@@ -1,7 +1,7 @@
 extern crate jvm_class_file_parser;
 
 use std::fs::File;
-use jvm_class_file_parser::{Bytecode, ClassFile, Code};
+use jvm_class_file_parser::{Bytecode, ClassAccess, ClassFile, Code};
 
 #[test]
 fn parse_class_dummy() {
@@ -12,6 +12,10 @@ fn parse_class_dummy() {
 
     assert_eq!(Some("Dummy.java"), class_file.get_source_file_name());
 
+    assert_eq!(2, class_file.access_flags.len());
+    assert!(class_file.access_flags.contains(&ClassAccess::Public));
+    assert!(class_file.access_flags.contains(&ClassAccess::Super));
+
     assert_eq!(1, class_file.methods.len());
 
     let constructor = &class_file.methods[0];
@@ -42,6 +46,10 @@ fn parse_class_intbox() {
 
     assert_eq!(Some("IntBox.java"), class_file.get_source_file_name());
 
+    assert_eq!(2, class_file.access_flags.len());
+    assert!(class_file.access_flags.contains(&ClassAccess::Public));
+    assert!(class_file.access_flags.contains(&ClassAccess::Super));
+
     assert_eq!(2, class_file.methods.len());
 
     let constructor = &class_file.methods[0];