javaclass 0.0.2 → 0.0.3

data/lib/javaclass/classfile/constant_pool.rb

@@ -0,0 +1,91 @@
+require 'javaclass/string_ux'
+require 'javaclass/classfile/constants/value'
+require 'javaclass/classfile/constants/single_reference'
+require 'javaclass/classfile/constants/double_reference'
+
+module JavaClass
+  module ClassFile 
+    
+    # Container of the constant pool's constants.
+    # Author::   Peter Kofler
+    class ConstantPool
+      
+      # Types of constants by their +tag+.
+      CONSTANT_TYPE_TAGS = {
+        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,
+      }
+      
+      # Size of the whole constant pool in bytes.
+      attr_reader :size
+      
+      # Parse the constant pool from the bytes _data_ beginning at position _start_ (which is usually 8).
+      def initialize(data, start=8)
+        @pool = {} # cnt (fixnum) => constant
+        
+        # parsing
+        @item_count = data.u2(start)
+        pos = start + 2
+        cnt = 1
+        while cnt <= @item_count-1
+          
+          type = CONSTANT_TYPE_TAGS[data.u1(pos)]
+          unless type
+            #puts dump.join("\n") 
+            raise "const ##{cnt} = unknown constant pool tag #{data[pos]} at pos #{pos} in class"
+          end
+          
+          constant = type.new(@pool, data, pos)
+          @pool[cnt] = constant
+          pos += constant.size
+          cnt += constant.slots
+          
+        end
+        
+        @size = pos - start
+      end
+      
+      # Return the number of pool items. This number might be larger than +items+ available, 
+      # because +long+ and +double+ constants take two slots.
+      def item_count
+        @item_count-1
+      end
+      
+      # Return the _index_'th pool item. _index_ is the real index in the pool which may skip numbers. 
+      def[](index)
+        @pool[index]
+      end
+      
+      # Return an array of the ordered list of constants.
+      def items
+        @pool.keys.sort.collect { |k| self[k] }
+      end
+      
+      # Return an array of all constants of the given _tags_ types.
+      def find(*tags)
+        items.find_all { |item| tags.include? item.tag }
+      end
+      
+      # Return all string constants.
+      def strings
+        find(STRING_TAG)
+      end
+      
+      # Return a debug output of the whole pool.
+      def dump
+        ["  Constant pool:"] + @pool.keys.sort.collect { |k| "const ##{k} = #{self[k].dump}"}
+      end
+      
+    end
+    
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'javaclass/string_ux'
+
+module JavaClass 
+  module ClassFile 
+    module Constants # :nodoc:
+      
+      # Superclass of all constant values in the constant pool. Every constant has a +name+, a +tag+ and a +size+ in bytes.
+      # Author::   Peter Kofler
+      class Base # ZenTest FULL to find method name
+        
+        attr_reader :name
+        attr_reader :tag
+        attr_reader :size
+        attr_reader :slots
+        
+        # Set default constants.
+        def initialize(name=nil)
+          @name = self.class.to_s[/::[^:]+$/][10..-1] # skip modules (::) and "Constant"
+          @name = name if name
+          @size = 3
+          @slots = 1
+        end
+        
+        # Return part of debug output.
+        def dump
+          "#{@name}\t" # #{@tag} 
+        end
+        
+      end
+      
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+require 'javaclass/classfile/constants/single_reference'
+require 'javaclass/java_name'
+
+module JavaClass 
+  module ClassFile 
+    module Constants 
+      
+      # Superclass of double reference constants like +ConstantField+ (+FieldRef+) in the constant pool. 
+      # Author::   Peter Kofler
+      class DoubleReference < SingleReference
+        
+        attr_reader :second_index
+        
+        # Define a double reference into _pool_ from _data_ beginning at _start_
+        def initialize(pool, data, start, name=nil)
+          super(pool, data, start, name)
+          @size = 5
+          
+          @second_index = data.u2(start+3)
+        end
+        
+        # Return the second value, which is the referenced value from the pool.
+        def second_value
+          get(@second_index)
+        end
+        
+        # Return the value, which are both referenced values from the pool.
+        def to_s
+          "#{super}.#{second_value}"
+        end
+        
+        # Return part of debug output.
+        def dump
+          "#{@name}\t##{@first_index}.##{@second_index};\t//  #{to_s}"
+        end
+        
+      end
+      
+      class ConstantField < DoubleReference # ZenTest SKIP
+        alias class_index first_index 
+        alias name_and_type_index second_index 
+        def initialize(pool, data, start) 
+          super(pool, data, start)
+        end
+        def first_value 
+          # is a classname
+          super.to_javaname
+        end
+        alias class_name first_value
+        alias signature second_value
+      end
+      
+      class ConstantMethod < DoubleReference # ZenTest SKIP
+        alias class_index first_index 
+        alias name_and_type_index second_index 
+        def initialize(pool, data, start) 
+          super(pool, data, start)
+        end  
+        def first_value 
+          # is a classname
+          super.to_javaname
+        end
+        alias class_name first_value
+        alias signature second_value
+      end
+      
+      class ConstantInterfaceMethod < DoubleReference # ZenTest SKIP
+        alias class_index first_index 
+        alias name_and_type_index second_index 
+        def initialize(pool, data, start) 
+          super(pool, data, start)
+        end  
+        def first_value 
+          # is a classname
+          super.to_javaname
+        end
+        alias class_name first_value
+        alias signature second_value
+      end
+      
+      class ConstantNameAndType < DoubleReference # ZenTest SKIP
+        alias name_index first_index 
+        alias descriptor_index second_index 
+        def initialize(pool, data, start)
+          super(pool, data, start)
+        end
+        
+        def to_s
+          "#{get(name_index)}:#{get(descriptor_index)}"
+        end
+        
+        def dump
+          "#{@name}\t##{name_index}:##{descriptor_index};//  #{to_s}"
+        end
+      end
+      
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+require 'javaclass/classfile/constants/base'
+require 'javaclass/java_name'
+
+module JavaClass 
+  module ClassFile 
+    module Constants 
+      
+      # Superclass of single reference constants like +ConstantClass+ (+Class+) in the constant pool. 
+      # Author::   Peter Kofler
+      class SingleReference < Base
+        
+        attr_reader :first_index
+        
+        # Define a single reference into _pool_ from _data_ beginning at _start_
+        def initialize(pool, data, start, name=nil)
+          super(name)
+          @tag = data.u1(start)
+          
+          @enclosing_pool = pool
+          @first_index = data.u2(start+1)
+        end
+        
+        # Return the value, which is the referenced value from the pool.
+        def first_value
+          get(@first_index)
+        end
+        alias to_s first_value
+        
+        # Return part of debug output.
+        def dump
+          super + "##{@first_index};\t//  #{to_s}"
+        end
+        
+        protected
+        
+        # Get a reference _ref_ from the +enclosing_pool+
+        def get(ref)
+          @enclosing_pool[ref].to_s
+        end
+        
+      end
+      
+      class ConstantClass < SingleReference # ZenTest SKIP
+        alias name_index first_index
+        def initialize(pool, data, start)
+          super(pool, data, start, "class")
+        end
+        def first_value 
+          # is a classname
+          super.to_javaname
+        end
+        alias class_name first_value
+      end
+      
+      class ConstantString < SingleReference # ZenTest SKIP
+        alias string_index first_index
+        def initialize(pool, data, start) 
+          super(pool, data, start)
+        end
+        alias string_value first_value
+      end
+      
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+require 'javaclass/classfile/constants/base'
+
+module JavaClass 
+  module ClassFile 
+    module Constants 
+      
+      # Superclass of value constants like +ConstantInt+ (+Integer+) in the constant pool. 
+      # Author::   Peter Kofler
+      class Value < Base
+        
+        attr_reader :value
+        
+        # Create a constant value with an optional downcase _name_
+        def initialize(name=self.class.to_s[/::[^:]+$/][10..-1].downcase)
+          super(name)
+        end
+        
+        # Return the value as string.
+        def to_s
+          @value.to_s
+        end
+        
+        # Return part of debug output.
+        def dump
+          super + "#{@value}"
+        end
+        
+        protected
+        
+        # Define a +value+ from _data_ beginning at position _start_ with the _size_ in bytes and _slots_ (1 or 2).
+        def get_value(data, start, size, slots=1)
+          @tag = data.u1(start)
+          @size = size
+          @slots = slots
+          
+          data[start+1..start+size-1]
+        end
+        
+        # Dummy method to "fix" unused warning of param _pool_ in Eclipse.
+        def silence_unused_warning(pool)
+          raise "pool is nil" unless pool
+        end
+        
+      end
+      
+      class ConstantInt < Value # ZenTest SKIP
+        def initialize(pool, data, start) 
+          super()
+          silence_unused_warning(pool)
+          @value = get_value(data, start, 5).u4
+        end
+        
+        def dump
+          super + ';'
+        end
+      end
+      
+      class ConstantFloat < Value # ZenTest SKIP
+        def initialize(pool, data, start) 
+          super()
+          silence_unused_warning(pool)
+          @value = get_value(data, start, 5).single 
+        end
+        def to_s
+          super.upcase # sprintf('%E',@value)
+        end
+        def dump
+          super + 'f;'
+        end
+      end
+      
+      class ConstantLong < Value # ZenTest SKIP
+        def initialize(pool, data, start) 
+          super()
+          silence_unused_warning(pool)
+          @value = get_value(data, start, 9, 2).u8
+        end
+        def dump
+          super + 'l;'
+        end
+      end
+      
+      class ConstantDouble < Value # ZenTest SKIP
+        def initialize(pool, data, start) 
+          super()
+          silence_unused_warning(pool)
+          @value = get_value(data, start, 9, 2).double
+        end
+        def to_s
+          @value.to_s.upcase # sprintf('%E',@value)
+        end
+        def dump
+          super + 'd;'
+        end
+      end
+      
+      class ConstantAsciz < Value # ZenTest SKIP
+        alias string value
+        def initialize(pool, data, start) 
+          super('Asciz')
+          silence_unused_warning(pool)
+          @tag = data.u1(start)
+          
+          @length = data.u2(start+1)
+          @size = 3 + @length
+          @value = data[start+3..start+3+@length-1]
+        end
+        
+        def dump
+          super + ';'
+        end
+      end
+      
+    end
+  end
+end

data/lib/javaclass/classfile/java_class_header.rb

@@ -0,0 +1,102 @@
+require 'javaclass/string_ux'
+require 'javaclass/classfile/class_magic'
+require 'javaclass/classfile/class_version'
+require 'javaclass/classfile/constant_pool'
+require 'javaclass/classfile/references'
+require 'javaclass/classfile/access_flags'
+require 'javaclass/java_name'
+
+module JavaClass 
+  module ClassFile # :nodoc:
+    
+    # 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::             {en.wikipedia.org/wiki/Class}[http://en.wikipedia.org/wiki/Class_(file_format)]
+    # Author::          Peter Kofler
+    class JavaClassHeader
+      
+      attr_reader :magic    
+      attr_reader :version
+      attr_reader :constant_pool
+      attr_reader :access_flags
+      attr_reader :references
+      
+      # Create a header with the binary _data_ from the class file.
+      def initialize(data)
+        
+        #  ClassFile {
+        #    u4 magic; - ok
+        #    u2 minor_version; - ok
+        #    u2 major_version; - ok
+        #    u2 constant_pool_count; - ok
+        #    cp_info constant_pool[constant_pool_count-1]; - ok
+        #    u2 access_flags; - ok
+        #    u2 this_class; - ok
+        #    u2 super_class; - ok
+        # TODO implement function for fields and methods (JVM spec)
+        #    u2 interfaces_count;
+        #    u2 interfaces[interfaces_count];
+        #    u2 fields_count;
+        #    field_info fields[fields_count];
+        #    u2 methods_count;
+        #    method_info methods[methods_count];
+        #    u2 attributes_count;
+        #    attribute_info attributes[attributes_count];
+        #  }
+        # TODO Java 1.0 - "private protected" fields.
+        
+        @magic = ClassMagic.new(data)
+        @version = ClassVersion.new(data)
+        
+        @constant_pool = ConstantPool.new(data)
+        pos = 8 + @constant_pool.size
+        
+        @access_flags = AccessFlags.new(data, pos)
+        pos += 2
+        
+        idx = data.u2(pos)
+        pos += 2
+        @this_class_idx = idx
+        
+        @references = References.new(@constant_pool, @this_class_idx)
+        
+        idx = data.u2(pos)
+        pos += 2
+        @super_class_idx = idx
+      end
+      
+      # Return the name of this class.
+      def this_class
+        @constant_pool[@this_class_idx].to_s.to_javaname
+      end
+      
+      # Return the name of the superclass of this class or +nil+.
+      def super_class
+        if @super_class_idx > 0
+          @constant_pool[@super_class_idx].to_s.to_javaname
+        else
+          nil
+        end
+      end
+      
+      # Return a debug output of this class that looks similar to +javap+ output.
+      def dump
+        d = []
+        mod = @access_flags.public? ? 'public ' : ''
+        ext = super_class ? "extends #{super_class.to_classname}" : ''
+        d << "#{mod}class #{this_class.to_classname} #{ext}" 
+        # d << "  SourceFile: \"#{read from LineNumberTable?}\""
+        d += @version.dump 
+        d += @constant_pool.dump
+        d << ''
+        d << '{'
+        d << '}'
+        d
+      end
+      
+    end
+    
+  end
+end

data/lib/javaclass/classfile/references.rb

@@ -0,0 +1,43 @@
+require 'javaclass/classfile/constant_pool'
+
+module JavaClass
+  module ClassFile 
+    
+    # Container class for list of all classes, methods and fields referenced by this class.
+    # This information is derived from the constant pool, no analysis.
+    # Author::   Peter Kofler
+    class References
+      
+      # Create a references container with the constant _pool_ and skip references to index _classidx_ which is the host class itself.  
+      def initialize(pool, classidx)
+        @constant_pool = pool
+        @class_idx = classidx
+      end
+      
+      # Return the constants referring to fields (Constants::ConstantField). 
+      # If _includeown_ is +true+ then fields of this class are returned also. 
+      def referenced_fields(includeown=false)
+        @constant_pool.find(ConstantPool::FIELD_TAG).find_all do |field| 
+          includeown || field.class_index != @class_idx
+        end
+      end
+      
+      # Return the constants referring to methods (Constants::ConstantMethod) in classes or interfaces. 
+      # If _includeown_ is +true+ then methods of this class are returned also. 
+      def referenced_methods(includeown=false)
+        @constant_pool.find(ConstantPool::METHOD_TAG, ConstantPool::INTERFACE_METHOD_TAG).find_all do |method| 
+          includeown || method.class_index != @class_idx 
+        end
+      end
+      
+      # Return the list of all constants containing class names of all used classes.
+      def used_classes
+        @constant_pool.find(ConstantPool::CLASS_TAG).find_all do |cl| 
+          cl.class_name != @constant_pool[@class_idx].to_s 
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/javaclass/classlist/class_entry.rb

@@ -0,0 +1,89 @@
+require 'javaclass/java_name'
+
+module JavaClass
+  module ClassList # :nodoc:
+    
+    # An entry in the list. A ClassEntry belongs to a PackageEntry and has a list ov versions it exists in.
+    # Author::          Peter Kofler
+    class ClassEntry
+      
+      # Return the short (simple) name of this class.
+      attr_reader :name
+      attr_reader :full_name
+      # Return the list of versions this class exists.
+      attr_reader :version
+      
+      # Create a new entry. _parent_ must provide a +version+ field to compare against. _vers_ is the 
+      # base version of this class. 
+      def initialize(parent, full_name, is_public, vers)
+        @parent = parent
+        @full_name = full_name.to_javaname.to_classname
+        @name = @full_name.simple_name
+        @is_public = is_public
+        @version = [vers]
+      end
+      
+      def public?
+        @is_public
+      end
+      
+      # Update the _version_ this class also exists in.
+      def update(version, is_public=@is_public)
+        raise "update class #{@name} is older than its last version: latest version=#{@version.last}, new version=#{version}" if version <= @version.last
+        # check for holes in versions
+        if version > @version.last+1
+          warn "#{@full_name} last in version #{@version.last}, not in #{@version.last+1}, but again in #{version}"        
+        end
+        @version << version 
+        
+        if !is_public && @is_public
+          warn "#{@full_name} changed from public to package in version #{version}"
+          @is_public = is_public
+          @version = [version] # skip older versions
+        elsif is_public && ! @is_public
+          info "#{@full_name} changed from package to public in version #{version}"
+          @is_public = is_public
+          @version = [version] # skip older versions
+        end
+      end
+      
+      # Sorts by simple +name+ inside the package.
+      def <=>(other)
+        @name.casecmp other.name
+      end
+      
+      def to_s
+        @full_name
+      end
+      
+      # Return a string containing the full qualified name together with first and last version
+      # of this class. Ignore package versions, but obey _minversion_ and _maxversion_ .
+      # Print all versions, first to last, but skip <code>first<=minversion</code> and <code>last>=maxversion</code>.
+      def to_full_qualified_s(minversion, maxversion)
+        format_version(@full_name, minversion, maxversion)
+      end
+      
+      # Return a string containing the simple name and the version, if it is different from the package version.
+      def to_package_shortcut_s
+        vp = @parent.version
+        format_version("   #{@name}", vp.first, vp.last)
+      end
+      
+      private
+      
+      def format_version(start, minversion, maxversion)
+        # this class has a set of versions where it exists
+        # the parent has a set of versions where it exists, contains class versions
+        is_newer = @version.first > minversion
+        is_outdated = @version.last < maxversion
+        line = start + 
+          " [#{ is_newer || (!@is_public && @version.first>0) ? @version.first.to_s : ''}" +
+          "#{is_outdated ? '-' + @version.last.to_s : ''}" +
+          "#{!@is_public ? 'p' : '' }]" +
+          " - \n"
+        line.sub(/\[-0/, "[0-0").sub(/(\d)-\1/, "only \\1").sub(/ \[\]/, '')
+      end
+    end
+    
+  end
+end