javaclass 0.4.1 → 0.4.2

data/lib/javaclass/classfile/class_access_flags.rb

@@ -0,0 +1,37 @@
+require 'javaclass/classfile/access_flags'
+require 'javaclass/classfile/class_format_error'
+
+module JavaClass
+  module ClassFile
+
+    # The access flags of a class or interface.
+    # Author::   Peter Kofler
+    class ClassAccessFlags < AccessFlags
+
+      # Bitmask for unknown/not supported flags on classes.
+      ACC_OTHER = 0xffff ^ ACC_PUBLIC ^ ACC_STATIC ^ ACC_FINAL ^ ACC_SUPER ^ ACC_INTERFACE ^ ACC_ABSTRACT ^ ACC_SYNTHETIC ^ ACC_ENUM ^ ACC_ANNOTATION ^ ACC_MODULE
+
+      def initialize(flags)
+        super
+        assert_flags
+      end
+
+      def assert_flags
+        raise ClassFormatError, "inconsistent flags #{flags} (other value #{flags & ACC_OTHER})" if (flags & ACC_OTHER) != 0
+      end
+      private :assert_flags
+
+      # Is this class a purely abstract class (and not an interface)?
+      def abstract_class?
+        abstract? && !interface_class?
+      end
+
+      # Is this class an interface (and not an annotation)?
+      def interface_class?
+        interface? && !annotation?
+      end
+
+    end
+
+  end
+end

data/lib/javaclass/classfile/class_file_attributes.rb

@@ -0,0 +1,62 @@
+require 'javaclass/java_name'
+
+module JavaClass
+  module ClassFile
+
+    # Class file attributes.
+    # Author::   Peter Kofler
+    class ClassFileAttributes
+
+      def initialize(attributes, this_class)
+        @attributes = attributes
+        @this_class = this_class
+      end
+
+      # Name of the source file.
+      def source_file
+        a = @attributes.with('SourceFile')
+        if a then a.source_file else '<not set>' end
+      end
+
+      # List of inner classes +Attributes::InnerClass+ with name and access flags.
+      def inner_classes
+        a = @attributes.with('InnerClasses')
+        if a then a.inner_classes else [] end
+      end
+
+      def inner_class?
+        if inner_classes.find { |inner| inner.class_name == @this_class }
+          true
+        else
+          false
+        end
+      end
+
+      # Defines an accessible inner class, which is a static inner class which is not synthetic.
+      def static_inner_class?
+        if inner_classes.find { |inner| inner.class_name == @this_class && 
+                                         inner.access_flags.static? && 
+                                         (!inner.access_flags.private? || inner.access_flags.protected?) }
+          true
+        else
+          false
+        end
+      end
+
+      def anonymous?
+        inner_class? && @this_class =~ /\$\d+$/
+      end
+
+      # Return outer class name for inner classes, or the current class name.
+      def outer_class
+        if inner_class?
+          JavaVMName.new(@this_class[/^[^$]+/])
+        else
+          @this_class
+        end
+      end
+
+    end
+
+  end
+end

data/lib/javaclass/classfile/class_version.rb

@@ -5,7 +5,6 @@ module JavaClass
 
     # Version of a class file.
     # Author::   Peter Kofler
-    # See::      http://java.sun.com/docs/books/jvms/second_edition/html/ClassFile.doc.html#75883
     class ClassVersion # ZenTest FULL to find method to_s
 
       attr_reader :minor

data/lib/javaclass/classfile/constant_pool.rb

@@ -13,19 +13,25 @@ module JavaClass
 
       # Types of constants by their +tag+.
       CONSTANT_TYPE_TAGS = {
-        CLASS_TAG     = 7 => Constants::ConstantClass,
-        FIELD_TAG     = 9 => Constants::ConstantField,
-        METHOD_TAG    = 10 => Constants::ConstantMethod,
+        CLASS_TAG           = 7 => Constants::ConstantClass,
+        FIELD_TAG           = 9 => Constants::ConstantField,
+        METHOD_TAG          = 10 => Constants::ConstantMethod,
         INTERFACE_METHOD_TAG = 11 => Constants::ConstantInterfaceMethod,
-        STRING_TAG    = 8 => Constants::ConstantString,
-        INT_TAG       = 3 => Constants::ConstantInt,
-        FLOAT_TAG     = 4 => Constants::ConstantFloat,
-        LONG_TAG      = 5 => Constants::ConstantLong,
-        DOUBLE_TAG    = 6 => Constants::ConstantDouble,
-        NAME_AND_TYPE_TAG = 12 => Constants::ConstantNameAndType,
-        ASCIZ_TAG     = 1 => Constants::ConstantAsciz,
+        STRING_TAG          = 8 => Constants::ConstantString,
+        INT_TAG             = 3 => Constants::ConstantInt,
+        FLOAT_TAG           = 4 => Constants::ConstantFloat,
+        LONG_TAG            = 5 => Constants::ConstantLong,
+        DOUBLE_TAG          = 6 => Constants::ConstantDouble,
+        NAME_AND_TYPE_TAG   = 12 => Constants::ConstantNameAndType,
+        ASCIZ_TAG           = 1 => Constants::ConstantAsciz,
+        # Java 1.7
+        METHOD_HANDLE_TAG   = 15 => Constants::ConstantMethodHandle,
+        METHOD_TYPE_TAG     = 16 => Constants::ConstantMethodType,
+        INVOKE_DYNAMIC_TAG  = 18 => Constants::ConstantInvokeDynamic,
+        # Java 9
+        MODULE_TAG          = 19 => Constants::ConstantModule,
+        PACKAGE_TAG         = 20 => Constants::ConstantPackage,
       }
-      # TODO Java7/Java8 JDK, implement 3 new tags, see https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.4
 
       # Size of the whole constant pool in bytes.
       attr_reader :size

data/lib/javaclass/classfile/constants/single_reference.rb

@@ -68,6 +68,59 @@ module JavaClass
         alias string_value first_value
       end
 
+      class ConstantMethodHandle < SingleReference # ZenTest SKIP
+        alias method_handle_index first_index
+  
+        def initialize(pool, data, start)
+          super(pool, data, start)
+  
+          @kind = data.u1(start+1)
+          @first_index = data.u2(start+2)
+          @size = 4
+        end
+        alias method_handle_value first_value
+      end
+      
+      class ConstantMethodType < SingleReference # ZenTest SKIP
+        alias method_type_index first_index
+
+        def initialize(pool, data, start)
+          super(pool, data, start)
+        end
+        alias method_type_value first_value
+      end
+      
+      class ConstantInvokeDynamic < SingleReference # ZenTest SKIP
+        alias name_and_type_index first_index
+
+        def initialize(pool, data, start)
+          super(pool, data, start)
+
+          @bootstrap_method_attr_index = data.u2(start+1)
+          @first_index = data.u2(start+3)
+          @size = 5
+        end
+        alias name_and_type_value first_value
+      end
+
+      class ConstantModule < SingleReference # ZenTest SKIP
+        alias name_index first_index
+  
+        def initialize(pool, data, start)
+          super(pool, data, start)
+        end
+        alias name_value first_value
+      end
+  
+      class ConstantPackage < SingleReference # ZenTest SKIP
+        alias name_index first_index
+  
+        def initialize(pool, data, start)
+          super(pool, data, start)
+        end
+        alias name_value first_value
+      end
+          
     end
   end
 end

data/lib/javaclass/classfile/fields.rb

@@ -0,0 +1,37 @@
+require 'javaclass/classfile/attributes/attributes'
+
+module JavaClass
+  module ClassFile
+
+    # Container of the fields - skips the fields for now.
+    # Author::   Peter Kofler
+    class Fields # :nodoc:
+
+      # Size of the whole fields structure in bytes.
+      attr_reader :size
+
+      # Parse the field structure from the bytes _data_ beginning at position _start_.
+      def initialize(data, start, constant_pool)
+        count = data.u2(start)
+        @size = 2
+
+        (1..count).each do |i|
+          # TODO Implement parsing of fields into Field class
+
+          # access_flags = data.u2(start + @size) # later ... FieldAccessFlag.new(data, start + @size)
+          # @size += 2
+          # name_index = data.u2(start + @size) # later ... get from ConstantPool
+          # @size += 2
+          # descriptor_index = data.u2(start + @size) # later ... get from ConstantPool
+          # @size += 2
+          @size += 6
+
+          attributes = Attributes::Attributes.new(data, start + @size, constant_pool)
+          @size += attributes.size
+        end
+      end
+
+    end
+
+  end
+end

data/lib/javaclass/classfile/java_class_header.rb

@@ -2,8 +2,12 @@ require 'javaclass/string_ux'
 require 'javaclass/classfile/class_magic'
 require 'javaclass/classfile/class_version'
 require 'javaclass/classfile/constant_pool'
+require 'javaclass/classfile/class_access_flags'
+require 'javaclass/classfile/fields'
+require 'javaclass/classfile/methods'
+require 'javaclass/classfile/attributes/attributes'
+require 'javaclass/classfile/class_file_attributes'
 require 'javaclass/classfile/references'
-require 'javaclass/classfile/access_flags'
 require 'javaclass/java_name'
 
 module JavaClass
@@ -19,7 +23,7 @@ module JavaClass
     # Parse and disassemble Java class files, similar to the +javap+ command.
     # Provides all information of a Java class file. This is just a container for all kind of
     # specialised elements. The constuctor parses and creates all contained elements.
-    # See::             http://java.sun.com/docs/books/jvms/second_edition/html/ClassFile.doc.html
+    # See::             https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html
     # See::             {en.wikipedia.org/wiki/Class}[http://en.wikipedia.org/wiki/Class_(file_format)]
     # Author::          Peter Kofler
     class JavaClassHeader
@@ -30,25 +34,29 @@ module JavaClass
       attr_reader :access_flags
       attr_reader :references
       attr_reader :interfaces
+      attr_reader :attributes
 
       # Create a header with the binary _data_ from the class file.
       def initialize(data)
+        pos = 0
 
         #  ClassFile {
         #    u4 magic; 
         @magic = ClassMagic.new(data)
+        pos += 4
 
         #    u2 minor_version;
         #    u2 major_version;
         @version = ClassVersion.new(data)
+        pos += 4
 
         #    u2 constant_pool_count;
         #    cp_info constant_pool[constant_pool_count-1];
         @constant_pool = ConstantPool.new(data)
-        pos = 8 + @constant_pool.size
+        pos += @constant_pool.size
 
         #    u2 access_flags;
-        @access_flags = AccessFlags.new(data, pos)
+        @access_flags = ClassAccessFlags.new(data.u2(pos))
         pos += 2
 
         #    u2 this_class;
@@ -65,21 +73,22 @@ module JavaClass
         @interfaces = data.u2rep(count, pos + 2).collect { |i| @constant_pool.class_item(i) }
         pos += 2 + count*2
 
-        # TODO Implement parsing of fields and methods of the JVM spec 
         #    u2 fields_count;
         #    field_info fields[fields_count];
-        #        count = data.u2(pos)
-        #        @fields = data.u2rep(count, pos + 2).collect { |i| @constant_pool.field_item(i) }
-        #        pos += 2 + count*2
-
+        @fields = Fields.new(data, pos, @constant_pool)
+        pos += @fields.size
+        
         #    u2 methods_count;
         #    method_info methods[methods_count];
-        #        count = data.u2(pos)
-        #        @methods = data.u2rep(count, pos + 2).collect { |i| @constant_pool.method_item(i) }
-        #        pos += 2 + count*2
+        @methods = Methods.new(data, pos, @constant_pool)
+        pos += @methods.size
 
         #    u2 attributes_count;
         #    attribute_info attributes[attributes_count];
+        attr = Attributes::Attributes.new(data, pos, @constant_pool)
+        pos += attr.size
+        @attributes =  ClassFileAttributes.new(attr, this_class)
+         
         #  }
         @references = References.new(@constant_pool, @this_class_idx)
         
@@ -113,7 +122,7 @@ module JavaClass
         ext = super_class ? " extends #{super_class.to_classname}" : ''
         int = !@interfaces.empty? ? " implements #{@interfaces.join(',')}" : ''
         d << "#{mod}class #{this_class.to_classname}#{ext}#{int}"
-        # d << "  SourceFile: \"#{read from LineNumberTable?}\""
+        d << "  SourceFile: \"#{attributes.source_file}\""
         d += @version.dump
         d += @constant_pool.dump
         d << ''

data/lib/javaclass/classfile/java_class_header_shortcuts.rb

@@ -5,14 +5,18 @@ module JavaClass
 
       # Is this class an interface (and not an annotation)?
       def interface?
-        access_flags.interface? && !access_flags.annotation?
+        access_flags.interface_class?
       end
 
       # Is this class an abstract class (and not an interface)?
       def abstract_class?
-        access_flags.abstract? && !access_flags.interface?
+        access_flags.abstract_class?
       end
 
+      def inner?
+        attributes.inner?
+      end
+      
     end
 
     # TODO add tests for this

data/lib/javaclass/classfile/methods.rb

@@ -0,0 +1,37 @@
+require 'javaclass/classfile/attributes/attributes'
+
+module JavaClass
+  module ClassFile
+
+    # Container of the methods - skips the fields for now.
+    # Author::   Peter Kofler
+    class Methods # :nodoc:
+
+      # Size of the whole methods structure in bytes.
+      attr_reader :size
+
+      # Parse the method structure from the bytes _data_ beginning at position _start_.
+      def initialize(data, start, constant_pool)
+        count = data.u2(start)
+        @size = 2
+
+        (1..count).each do |i|
+          # TODO Implement parsing of methods into Method class
+
+          # access_flags = data.u2(start + @size) # later ... MethodAccessFlag.new(data, start + @size)
+          # @size += 2
+          # name_index = data.u2(start + @size) # later ... get from ConstantPool
+          # @size += 2
+          # descriptor_index = data.u2(start + @size) # later ... get from ConstantPool
+          # @size += 2
+          @size += 6
+
+          attributes = Attributes::Attributes.new(data, start + @size, constant_pool)
+          @size += attributes.size
+        end
+      end
+
+    end
+
+  end
+end

data/lib/javaclass/classlist/jar_searcher.rb

@@ -47,16 +47,49 @@ module JavaClass
       # Return true if the _classfile_ in the given _classpath_ is public. This is expensive because the JAR file is opened and the
       # _classfile_ is extracted and read.
       def public?(classpath, classfile)
+        # temporal hack, store @classpath and @header
+        @classpath = classpath
         begin
-          header = ClassFile::JavaClassHeader.new(classpath.load_binary(classfile))
+          @header = ClassFile::JavaClassHeader.new(classpath.load_binary(classfile))
         rescue JavaClass::ClassFile::ClassFormatError => ex
           ex.add_classname(classfile, classpath.to_s)
           raise ex
         end
-        header.magic.check("invalid java class #{classfile}")
-        header.access_flags.accessible?
+        @header.magic.check("invalid java class #{classfile}")
+        @header.access_flags.accessible?
       end
 
+      def accessible?
+        if @skip_package_classes && !@header.access_flags.accessible?
+          # not public and we only want public
+          false
+        
+        elsif @skip_inner_classes || !@header.attributes.inner_class?
+          # no inner classes have been collected, everything is accessible due its public flag
+          # or this is not an inner class, so everything is OK
+          true
+          
+        # it is an inner class
+          
+        elsif @header.access_flags.synthetic? || @header.attributes.anonymous?
+          # the inner class is anonymous or synthetic, not accessible
+          false
+
+        elsif !@header.attributes.static_inner_class?
+          # must be static (and not private nor protected) to be accessible
+          false
+          
+        elsif !@skip_package_classes
+          # inner class is public or package access, OK
+          true
+          
+        else
+          # inner class is public, but parent class might be package only
+          public?(@classpath, @header.attributes.outer_class.to_class_file)
+          
+        end
+      end
+      
       # Compile the class list for the given _version_ of Java. This searches the _path_ for zips and JARs
       # and adds them to the given _list_ of found classes. _version_ is a number >= 0, e.g. 2 for JDK 1.2.
       # _list_ must provide a <code>add_class(entry, is_public, version)</code> method.
@@ -72,7 +105,8 @@ module JavaClass
       def add_list_from_classpath(version, classpath, list)
         filter_classes(classpath.names).each do |entry|
           is_public = public?(classpath, entry)
-          next if @skip_package_classes && !is_public
+          next if !accessible?
+          
           list.add_class(entry, is_public, version) if list
           yield(entry, is_public, version) if block_given?
         end