javaclass 0.0.3 → 0.0.4

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

@@ -1,99 +1,113 @@
 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. 
+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) 
+        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
+
+        def first_value
+          JavaVMName.new(super) # this is a classname
         end
         alias class_name first_value
         alias signature second_value
+
+        def const_field?
+          true
+        end
       end
-      
+
       class ConstantMethod < DoubleReference # ZenTest SKIP
-        alias class_index first_index 
-        alias name_and_type_index second_index 
-        def initialize(pool, data, start) 
+        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
+
+        def first_value
+          JavaVMName.new(super) # this is a classname
+        end
+        
         alias class_name first_value
         alias signature second_value
+
+        def const_method?
+          true
+        end
       end
-      
+
       class ConstantInterfaceMethod < DoubleReference # ZenTest SKIP
-        alias class_index first_index 
-        alias name_and_type_index second_index 
-        def initialize(pool, data, start) 
+        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
+
+        def first_value
+          JavaVMName.new(super) # this is a classname
+        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 
+        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

@@ -1,65 +1,73 @@
 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. 
+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
-        
+        def to_s
+          first_value
+        end
+
         # 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
+
+        def first_value
+          JavaVMName.new(super) # this is a classname
         end
         alias class_name first_value
+
+        def const_class?
+          true
+        end
       end
-      
+
       class ConstantString < SingleReference # ZenTest SKIP
         alias string_index first_index
-        def initialize(pool, data, start) 
+
+        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

@@ -1,116 +1,126 @@
 require 'javaclass/classfile/constants/base'
 
-module JavaClass 
-  module ClassFile 
-    module Constants 
-      
-      # Superclass of value constants like +ConstantInt+ (+Integer+) in the constant pool. 
+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}"
+          super + to_s
         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
+          raise ArgumentError, 'pool is nil' unless pool
         end
-        
+
       end
-      
+
       class ConstantInt < Value # ZenTest SKIP
-        def initialize(pool, data, start) 
+
+        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) 
+
+        def initialize(pool, data, start)
           super()
           silence_unused_warning(pool)
-          @value = get_value(data, start, 5).single 
+          @value = get_value(data, start, 5).single
         end
+
         def to_s
-          super.upcase # sprintf('%E',@value)
+          sprintf('%.14e', @value).sub(/e(\+|-)0+/, 'e\\1')
         end
+
         def dump
           super + 'f;'
         end
       end
-      
+
       class ConstantLong < Value # ZenTest SKIP
-        def initialize(pool, data, start) 
+
+        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) 
+
+        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)
+          sprintf('%.14e', @value).sub(/e(\+|-)0+/, 'e\\1')
         end
+
         def dump
           super + 'd;'
         end
       end
-      
+
       class ConstantAsciz < Value # ZenTest SKIP
         alias string value
-        def initialize(pool, data, start) 
+
+        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

@@ -6,89 +6,115 @@ require 'javaclass/classfile/references'
 require 'javaclass/classfile/access_flags'
 require 'javaclass/java_name'
 
-module JavaClass 
-  module ClassFile # :nodoc:
-    
+module JavaClass
+
+  # The module ClassFile is for separating namespaces. It contains the logic 
+  # to parse a Java class file. This logic is tied to the JVM specification
+  # of class files, very low-level and has no usage/DSL features.
+  # The main entry point is JavaClassHeader. It's the only "public" class
+  # of the module, so the only class to require from outside.
+  # Author::          Peter Kofler
+  module ClassFile
+
     # 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. 
+    # 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 :magic
       attr_reader :version
       attr_reader :constant_pool
       attr_reader :access_flags
       attr_reader :references
-      
+      attr_reader :interfaces
+
       # 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)
+        #    u4 magic; 
+        @magic = ClassMagic.new(data)
+
+        #    u2 minor_version;
+        #    u2 major_version;
+        @version = ClassVersion.new(data)
+
+        #    u2 constant_pool_count;
+        #    cp_info constant_pool[constant_pool_count-1];
+        @constant_pool = ConstantPool.new(data)
+        pos = 8 + @constant_pool.size
+
+        #    u2 access_flags;
+        @access_flags = AccessFlags.new(data, pos)
+        pos += 2
+
+        #    u2 this_class;
+        @this_class_idx = data.u2(pos)
+        pos += 2
+
+        #    u2 super_class;
+        @super_class_idx = data.u2(pos)
+        pos += 2
+
         #    u2 interfaces_count;
         #    u2 interfaces[interfaces_count];
+        count = data.u2(pos)
+        @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
+
         #    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
+
         #    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
+        #  Body {
+        # Class: add the byte code sequences to the methods so it can be analysed later (see JVM spec)
+        #  }
+
       end
-      
-      # Return the name of this class.
+
+      # Return the name of this class. Returns a JavaVMName.
       def this_class
-        @constant_pool[@this_class_idx].to_s.to_javaname
+        # This is a ConstantClass entry in the constant pool.
+        @jvmname ||= @constant_pool.class_item(@this_class_idx).class_name 
       end
-      
-      # Return the name of the superclass of this class or +nil+.
+
+      # Return the name of the superclass of this class or +nil+. Returns a JavaVMName.
       def super_class
         if @super_class_idx > 0
-          @constant_pool[@super_class_idx].to_s.to_javaname
+          # This is a ConstantClass entry in the constant pool.
+          @constant_pool.class_item(@super_class_idx).class_name
         else
+          # special case: java.lang.Object has no superclass 
           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}" 
+        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 += @version.dump 
+        d += @version.dump
         d += @constant_pool.dump
         d << ''
         d << '{'
@@ -97,6 +123,6 @@ module JavaClass
       end
       
     end
-    
+
   end
 end

data/lib/javaclass/classfile/java_class_header_as_java_name.rb

@@ -0,0 +1,33 @@
+require 'javaclass/delegate_directive'
+
+module JavaClass
+  module ClassFile
+
+    class JavaClassHeader
+      extend DelegateDirective
+
+      # Extend JavaClassHeader to behave like a JavaName in delegating to _this_class_ method which returns a JavaVMName.
+      def to_javaname
+        this_class
+      end
+
+      def to_jvmname
+        this_class
+      end
+      
+      delegate :to_classname, :this_class
+      delegate :to_java_file, :this_class
+      delegate :to_class_file, :this_class
+      
+      delegate :package, :this_class
+      delegate :simple_name, :this_class
+      delegate :full_name, :this_class
+      delegate :same_or_subpackage_of?, :this_class
+      delegate :subpackage_of?, :this_class
+      delegate :split_simple_name, :this_class
+      delegate :in_jdk?, :this_class
+
+    end
+
+  end
+end

data/lib/javaclass/classfile/java_class_header_shortcuts.rb

@@ -0,0 +1,19 @@
+module JavaClass
+  module ClassFile
+
+    class JavaClassHeader
+
+      # Is this class an interface (and not an annotation)?
+      def interface?
+        access_flags.interface? && !access_flags.annotation?
+      end
+
+      # Is this class an abstract class (and not an interface)?
+      def abstract_class?
+        access_flags.abstract? && !access_flags.interface?
+      end
+
+    end
+
+  end
+end