javaclass 0.0.2

data/lib/javaclass/java_class_header.rb

@@ -0,0 +1,88 @@
+require 'javaclass/string_ux'
+require 'javaclass/class_magic'
+require 'javaclass/class_version'
+require 'javaclass/constant_pool'
+require 'javaclass/references'
+require 'javaclass/access_flags'
+
+module JavaClass 
+  
+  # Provide all information of a Java class file. 
+  # 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;
+      #    u2 minor_version;
+      #    u2 major_version;
+      #    u2 constant_pool_count;
+      #    cp_info constant_pool[constant_pool_count-1];
+      #    u2 access_flags;
+      #    u2 this_class;
+      #    u2 super_class;
+      #    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];
+      #  }
+      
+      @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
+    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
+      else
+        nil
+      end
+    end
+    
+    # Return a debug output of this class that looks similar to +javap+ output.
+    def dump
+      d = []
+      # dump << "  SourceFile: \"#{@value}\""
+      # dump << "Compiled from \"#{@value}\""
+      d += @version.dump 
+      d += @constant_pool.dump
+      d
+    end
+    
+  end
+  
+end

data/lib/javaclass/references.rb

@@ -0,0 +1,31 @@
+require 'javaclass/constant_pool'
+
+module JavaClass
+  
+  # Container class for list of all classes, methods and fields referenced by this class.
+  # Author::   Peter Kofler
+  class References
+    
+    # Create a references container with the constant _pool_ and skip references to _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 { |field| includeown || field.class_index != @class_idx }
+    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
+    
+  end
+  
+end

data/lib/javaclass/string_ux.rb

@@ -0,0 +1,39 @@
+
+# Add some +unpack+ helper methods for HI-LO byte order (network byte order) contained in this string.
+# Author::          Peter Kofler
+class String
+  
+  # Return the _index_'th element as byte.
+  def u1(index=0)
+    self[index]
+  end
+  
+  # Return the _index_'th and the next element as unsigned word.
+  def u2(index=0)
+    self[index..index+1].unpack('n')[0]
+    # same as self[index]*256 + self[index+1] 
+  end
+  
+  # Return the _index_'th and the next 3 elements as unsigned dword.
+  def u4(index=0)
+    self[index..index+3].unpack('N')[0]
+  end
+  
+  # Return the _index_'th and the next 7 elements as unsigned qword.
+  def u8(index=0)
+    u4(index) * 256**4 + u4(index+4)
+  end
+  
+  # Return the _index_'th and the next 3 elements as single precision float.
+  # See::           http://steve.hollasch.net/cgindex/coding/ieeefloat.html
+  # See::           http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/196633
+  def single(index=0)
+    self[index..index+3].unpack('g')[0]
+  end
+  
+  # Return the _index_'th and the next 7 elements as double precision float.
+  def double(index=0)
+    self[index..index+7].unpack('G')[0]
+  end
+  
+end

data/lib/javaclass.rb

@@ -0,0 +1,14 @@
+require 'javaclass/java_class_header'
+
+# Parse and disassemble Java class files, similar to the +javap+ command.
+# Author::          Peter Kofler
+# See::             http://java.sun.com/docs/books/jvms/second_edition/html/ClassFile.doc.html
+# See::             http://en.wikipedia.org/wiki/Class_(file_format)
+module JavaClass 
+  
+  # Read and disassemble the given class called _name_ (full file name).
+  def self.parse(name)
+    JavaClassHeader.new(File.open(name, 'rb') {|io| io.read } )
+  end
+  
+end

data/test/data/AccessFlagsTestAbstract.java

@@ -0,0 +1,3 @@
+package packagename;
+
+public abstract class AccessFlagsTestAbstract { }

data/test/data/AccessFlagsTestFinal.java

@@ -0,0 +1,3 @@
+package packagename;
+
+public final class AccessFlagsTestFinal { }

data/test/data/AccessFlagsTestInterface.java

@@ -0,0 +1,3 @@
+package packagename;
+
+public interface AccessFlagsTestInterface { }

data/test/data/AccessFlagsTestPackage.java

@@ -0,0 +1,3 @@
+package packagename;
+
+class AccessFlagsTestPackage { }

data/test/data/AccessFlagsTestPublic.java

@@ -0,0 +1,7 @@
+package packagename;
+
+public class AccessFlagsTestPublic {
+
+   class InnerClass { }
+
+}

data/test/data/ClassVersionTest.java

@@ -0,0 +1 @@
+public class ClassVersionTest { }

data/test/data/ConstantPoolTest.java

@@ -0,0 +1,20 @@
+public class ConstantPoolTest implements Runnable {
+
+   // Class - it's own and Object
+   // Field ref (plus String)
+   String stringField = "String field";
+   // Method ref - Object ctor
+   // InterfaceMethod
+   {
+      ((Runnable)this).run();
+   }
+   final int intField = 42;
+   float floatField = 3.1415898996736E+22f;
+   long longField = 99999999L;
+   double doubleField = 3.14159265258979E-208;
+   // NameAndType - ctor init
+   // Asciz - classname
+
+   public void run(){}
+
+}

data/test/data/makeAccessFlagsTest.bat

@@ -0,0 +1,9 @@
+if exist AccessFlagsTest*.class del AccessFlagsTest*.class
+
+md classes
+javac -d classes AccessFlagsTest*.java
+
+copy classes\packagename\*.class .
+
+rmdir /S /Q classes
+pause

data/test/data/makeClassVersionTest.bat

@@ -0,0 +1,35 @@
+if exist ClassVersionTest*.class del ClassVersionTest*.class
+
+setlocal
+
+call profile102
+javac -classpath %CLASSPATH% ClassVersionTest.java
+ren ClassVersionTest.class ClassVersionTest10.class
+
+call profile118
+javac -classpath %CLASSPATH% ClassVersionTest.java
+ren ClassVersionTest.class ClassVersionTest11.class
+
+call profile122
+javac -target 1.2 ClassVersionTest.java
+ren ClassVersionTest.class ClassVersionTest12.class
+
+call profile131
+javac -target 1.3 ClassVersionTest.java
+ren ClassVersionTest.class ClassVersionTest13.class
+
+call profile141
+javac -target 1.4 ClassVersionTest.java
+ren ClassVersionTest.class ClassVersionTest14.class
+
+call profile150
+javac ClassVersionTest.java
+ren ClassVersionTest.class ClassVersionTest15.class
+
+call profile160
+javac ClassVersionTest.java
+ren ClassVersionTest.class ClassVersionTest16.class
+
+endlocal
+
+pause

data/test/data/makeConstantPoolTest.bat

@@ -0,0 +1,6 @@
+if exist ConstantPoolTest.class del ConstantPoolTest.class
+
+javac -g:none ConstantPoolTest.java
+javap -verbose -private ConstantPoolTest
+
+pause

data/test/setup.rb

@@ -0,0 +1,14 @@
+require 'test/unit'
+
+# add the lib to the load path
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+TEST_DATA_PATH = File.join(File.dirname(__FILE__), 'data')
+
+# Load the binary class data of given _name_ from the test path.
+def load_class(name)
+  File.open("#{TEST_DATA_PATH}/#{name}.class", 'rb') {|io| io.read } 
+end
+
+# require 'javaclass'
+# require File.join(File.dirname(__FILE__), %w[.. lib javaclass])

data/test/test_access_flags.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/setup'
+require 'javaclass/java_class_header'
+
+module TestJavaClass
+  
+  class TestAccessFlags < Test::Unit::TestCase
+    
+    def setup
+      @cls = {}
+      %w[Public Package Abstract Interface Final].each do |t| 
+        eval("@#{t.downcase} = JavaClass::JavaClassHeader.new(load_class('AccessFlagsTest#{t}')).access_flags") 
+      end
+    end
+    
+    def test_accessible_eh
+      assert(@public.accessible?)
+      assert(!@package.accessible?)
+      assert(@abstract.accessible?)
+      assert(@interface.accessible?)
+      assert(@final.accessible?)
+    end
+    
+    def test_public_eh
+      assert(@public.public?)
+    end    
+    
+    def test_interface_eh
+      assert(!@public.interface?)
+      assert(!@package.interface?)
+      assert(!@abstract.interface?)
+      assert(@interface.interface?)
+      assert(!@final.interface?)
+    end
+    
+    def test_abstract_eh
+      assert(!@public.abstract?)
+      assert(!@package.abstract?)
+      assert(@abstract.abstract?)
+      assert(@interface.abstract?)
+      assert(!@final.abstract?)
+    end
+    
+    def test_final_eh
+      assert(!@public.final?)
+      assert(!@package.final?)
+      assert(!@abstract.final?)
+      assert(!@interface.final?)
+      assert(@final.final?)
+    end
+    
+  end
+  
+end

data/test/test_base.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/setup'
+require 'javaclass/constants/base'
+
+module TestJavaClass
+  
+  class TestConstantBase < Test::Unit::TestCase
+    
+    class ConstantClass < JavaClass::Constants::Base;
+      def initialize(name=nil); super(name); end
+    end
+    
+    def test_name
+      v = ConstantClass.new
+      assert_equal("Class", v.name)
+      
+      v = ConstantClass.new("Bubu")
+      assert_equal("Bubu", v.name)
+    end
+    
+  end
+  
+end

data/test/test_class_version.rb

@@ -0,0 +1,59 @@
+require File.dirname(__FILE__) + '/setup'
+require 'javaclass/class_version'
+
+module TestJavaClass
+  
+  class TestClassVersion < Test::Unit::TestCase
+    
+    def setup
+      @v = (0..6).collect do |i| 
+        JavaClass::ClassVersion.new(load_class("ClassVersionTest1#{i}")) 
+      end
+    end
+    
+    # Assert the list of +v+ against the list of _expectations_ when invoking the given block.
+    def assert_classes(expectations)
+      expectations.values_at.each do |i|
+        assert_equal(expectations[i], yield(@v[i]), "#{i}. element")
+      end
+    end
+    
+    def test_major
+      assert_classes([45, 45, 46, 47, 48, 49, 50]) {|v| v.major}
+    end
+    
+    def test_minor
+      assert_classes([3, 3, 0, 0, 0, 0, 0]) {|v| v.minor}
+      assert_equal(3, @v[1].minor) # shouldn't it be > 45.3  
+    end
+    
+    def test_to_s
+      assert_equal('50.0', @v[6].to_s)
+      assert_equal('45.3', @v[0].to_s)
+    end
+    
+    def test_dump
+      assert_equal(["  minor version: 0", "  major version: 50"], @v[6].dump)
+    end
+    
+    def test_to_f
+      assert_equal(50.0, @v[6].to_f)
+      assert_equal(45.3, @v[0].to_f)
+      
+      v = JavaClass::ClassVersion.new("....\000\xff\0002")
+      assert_equal(50.255, v.to_f) 
+      
+      v = JavaClass::ClassVersion.new("....\xff\xff\0002")
+      assert_equal(50.65535, v.to_f) 
+    end
+    
+    def test_jdk_version
+      assert_classes(%w[1.0 1.0 1.2 1.3 1.4 1.5 1.6]) {|v| v.jdk_version}
+      
+      v = JavaClass::ClassVersion.new("....\000\xff\0002")
+      assert_equal('unknown', v.jdk_version)
+    end
+    
+  end
+  
+end

data/test/test_constant_pool.rb

@@ -0,0 +1,90 @@
+require File.dirname(__FILE__) + '/setup'
+require 'javaclass/constant_pool'
+
+module TestJavaClass
+  
+  class TestConstantPool < Test::Unit::TestCase
+    
+    # 1.6.0_11 javap.exe output of test class, only tweaked the float value a bit...
+    JAVAP_OUTPUT = '  Constant pool:
+const #1 = Method       #15.#33;        //  java/lang/Object."<init>":()V
+const #2 = String       #34;    //  String field
+const #3 = Field        #14.#35;        //  ConstantPoolTest.stringField:Ljava/lang/String;
+const #4 = InterfaceMethod      #16.#36;        //  java/lang/Runnable.run:()V
+const #5 = Field        #14.#37;        //  ConstantPoolTest.intField:I
+const #6 = float        3.14158995322368e+022f;
+const #7 = Field        #14.#38;        //  ConstantPoolTest.floatField:F
+const #8 = long 99999999l;
+const #10 = Field       #14.#39;        //  ConstantPoolTest.longField:J
+const #11 = double      3.14159265258979e-208d;
+const #13 = Field       #14.#40;        //  ConstantPoolTest.doubleField:D
+const #14 = class       #41;    //  ConstantPoolTest
+const #15 = class       #42;    //  java/lang/Object
+const #16 = class       #43;    //  java/lang/Runnable
+const #17 = Asciz       stringField;
+const #18 = Asciz       Ljava/lang/String;;
+const #19 = Asciz       intField;
+const #20 = Asciz       I;
+const #21 = Asciz       ConstantValue;
+const #22 = int 42;
+const #23 = Asciz       floatField;
+const #24 = Asciz       F;
+const #25 = Asciz       longField;
+const #26 = Asciz       J;
+const #27 = Asciz       doubleField;
+const #28 = Asciz       D;
+const #29 = Asciz       <init>;
+const #30 = Asciz       ()V;
+const #31 = Asciz       Code;
+const #32 = Asciz       run;
+const #33 = NameAndType #29:#30;//  "<init>":()V
+const #34 = Asciz       String field;
+const #35 = NameAndType #17:#18;//  stringField:Ljava/lang/String;
+const #36 = NameAndType #32:#30;//  run:()V
+const #37 = NameAndType #19:#20;//  intField:I
+const #38 = NameAndType #23:#24;//  floatField:F
+const #39 = NameAndType #25:#26;//  longField:J
+const #40 = NameAndType #27:#28;//  doubleField:D
+const #41 = Asciz       ConstantPoolTest;
+const #42 = Asciz       java/lang/Object;
+const #43 = Asciz       java/lang/Runnable;'
+    
+    def setup
+      @cp = JavaClass::ConstantPool.new(load_class('ConstantPoolTest'))
+    end
+    
+    def test_index
+      assert_equal('Method', @cp[1].name)
+      assert_equal('Field', @cp[10].name)
+    end
+    
+    def test_size
+      assert_equal(331, @cp.size)
+    end
+    
+    def test_item_count
+      assert_equal(43, @cp.item_count)
+    end
+    
+    def test_dump
+      # puts @cp.dump.join("\n")
+      assert_equal(JAVAP_OUTPUT.gsub(/ +/,' ').gsub(/"</,'<').gsub(/>"/,'>'), @cp.dump.join("\n").gsub(/( |\t)+/,' '))
+    end
+    
+    def test_items
+      pool = @cp.items
+      assert_equal(41, pool.size) # 2 double
+      assert_equal('Method', pool[0].name)
+      assert_equal('stringField', pool[14].value)
+    end
+    
+    def test_find
+      found = @cp.find(JavaClass::ConstantPool::STRING_TAG)
+      assert_equal(1, found.size)
+      assert_equal('String', found[0].name)
+      assert_equal(34, found[0].string_index)
+    end
+    
+  end
+  
+end

data/test/test_java_class_header.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/setup'
+require 'javaclass/java_class_header'
+
+module TestJavaClass
+  
+  class TestJavaClassHeader < Test::Unit::TestCase
+    
+    def setup
+      @public = JavaClass::JavaClassHeader.new(load_class("AccessFlagsTestPublic"))
+    end
+    
+    def test_magic
+      assert(@public.magic.valid?)
+    end
+    
+    def test_version
+      assert_equal('50.0', @public.version.to_s) # JDK 6
+    end
+    
+    def test_this_class
+      assert_equal('packagename/AccessFlagsTestPublic', @public.this_class)
+    end
+    
+    def test_super_class
+      assert_equal('java/lang/Object', @public.super_class)
+    end
+    
+  end
+  
+end

data/test/test_references.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/setup'
+require 'javaclass/java_class_header'
+
+module TestJavaClass
+  
+  class TestReferences < Test::Unit::TestCase
+    
+    def setup
+      @refs = JavaClass::JavaClassHeader.new(load_class("AccessFlagsTestPublic")).references
+    end
+    
+    def test_referenced_fields
+      fields = @refs.referenced_fields(false)
+      assert_equal(0, fields.size)
+    end
+    
+    def test_referenced_methods
+      methods = @refs.referenced_methods(false)
+      assert_equal(1, methods.size) # ctor init
+      assert_equal('java/lang/Object', methods[0].class_name)
+      
+      # TODO test with myself (true)...
+    end
+    
+    # TODO test referenced classes
+    
+  end
+  
+end

data/test/test_string_ux.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/setup'
+require 'javaclass/string_ux'
+
+class TestString < Test::Unit::TestCase
+  
+  def test_u1
+    assert_equal(49, "1".u1(0))
+    assert_equal(49, "212".u1(1))
+    assert_equal(50, "212".u1(2))
+  end
+  
+  def test_u2
+    assert_equal(49*256+50, "12".u2(0))
+    assert_equal(49*256+50, "312".u2(1))
+  end
+  
+  def test_u4
+    assert_equal(1, "\0\0\0\1".u4(0))
+    assert_equal(256**4-2, "\xff\xff\xff\xfe".u4(0))
+  end
+  
+  def test_single
+    assert_in_delta(3.14159, '@I�'.single(0), 0.0000002) 
+  end
+  
+  def test_double
+    assert_in_delta(3.14159265258981, "@\t!�T!� ".double(0), 0.00000000000001) 
+  end
+  
+end