javaclass 0.0.2

data/Rakefile

@@ -0,0 +1,51 @@
+require 'rubygems'
+
+require 'rake'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+
+jcversion = '0.0.2'
+
+gemspec = Gem::Specification.new do |s|
+  s.name = 'javaclass'
+  s.version = jcversion
+  s.summary ='A parser and disassembler for Java class files'
+  s.files = FileList['Readme.txt', '{lib,test}/**/*.*', 'history.txt', 'Rakefile']
+  s.test_files = FileList["{test}/**/test_*.rb"]
+  s.require_path = 'lib'
+  s.has_rdoc = true
+  s.rubyforge_project = 'javaclass'
+  s.homepage = 'http://javaclass.rubyforge.org/'
+  s.author = 'Peter Kofler'
+  s.email = 'bruno41 at rubyforge dot org'
+  # TODO use new cc email
+  s.platform = Gem::Platform::RUBY
+end
+
+Rake::GemPackageTask.new(gemspec) do |pkg|
+  pkg.need_zip = true
+end
+
+Rake::PackageTask.new(gemspec.name, gemspec.version) do |pkg|
+  #pkg.need_tar = true - no compress in tar on unxutils in Windows
+  #pkg.need_tar_gz = true - no compress in tar on unxutils in Windows
+  pkg.need_zip = true
+  pkg.package_files.include gemspec.files
+end
+
+Rake::TestTask.new do |t|
+  t.pattern = 'test/**/test_*.rb'
+  t.warning = true
+  t.verbose = false
+end
+
+Rake::RDocTask.new do |rdoc|
+  # rdoc.rdoc_dir = 'html'
+  rdoc.title    = "JavaClass javaclass-#{jcversion} Documentation"
+  rdoc.main     = 'Readme.txt'
+  rdoc.rdoc_files.include 'Readme.txt', 'lib/**/*.rb', 'history.txt'
+end
+
+task :default => :test

data/Readme.txt

@@ -0,0 +1,47 @@
+JavaClass
+by {Peter Kofler}[http://kofler.dot.at/work/]
+
+* {Homepage}[http://javaclass.rubyforge.org/]
+* {Rubyforge Project}[http://rubyforge.org/projects/javaclass]
+* email bruno41 at rubyforge dot org 
+
+== Description
+
+JavaClass (Java Class File Parser) is a
+parser and disassembler for Java class files, similar to the javap command. 
+It provides access to the package, protected, and public fields and methods 
+of the classes passed to it together with a list of all outgoing references.   
+
+== Motivation
+
+I am still doing Java most of the time. I used to be quite enthusiatic about
+it, but after 9 years I can see the advantages of being a polyglot. So I use
+Ruby for all kind of stuff, just for fun. Recently I needed some Java class
+analysis and happened to write it with Ruby. As I am a puritan, I did not
+want to call javap from my script, so I started disassembling the class files,
+which might be the the base for some serious static code analysis tools. (I
+started adding methods to that end...) 
+
+== Install
+
+  sudo gem install javaclass
+
+== Usage
+
+  require 'javaclass'
+  
+  clazz = JavaClass.parse('packagename/Public.class')
+  clazz.version                          # => 50.0
+  clazz.constant_pool.items[1]           # => packagename/Public
+  clazz.access_flags.public?             # => true
+  clazz.this_class                       # => packagename/Public
+  clazz.super_class                      # => java/lang/Object
+  clazz.references.referenced_methods[0] # => java/lang/Object.<init>:()V
+
+== Requirements
+
+JavaClass does not depend on any other installed libraries or gems.
+
+== License
+
+Same as Ruby.

data/history.txt

@@ -0,0 +1,29 @@
+=== 0.0.2 08/04/2009
+
+* refactored code to smaller objects for version and constant pool
+* fixed float and double constant pool items
+* added tests
+* continued implementation with class names and references
+
+=== 0.0.1 01/03/2009
+	
+* initial version extracted from ClassList project
+  * reads the class version and package/public flag of a class
+  * understands the constant pool but does not use it
+
+=== Planned
+
+* continue function for fields and methods
+* implement
+  * dump to return the class same as javap
+  * isAnnotation (checks version>=5 & superclass)
+    * are Annotation extendable, if so how do they look? (javap)
+  * isEnum (checks version>=5 & superclass)
+    * are Enums extendable (yes), if so how do they look? (javap)
+* test
+  * test with all classes of all JDKs against javap from this version
+  * Java 1.0 - private protected fields.
+  * Java 1.0 - http://www.javaworld.com/javaworld/javaqa/1999-06/03-synchronized.html 
+* think about
+  * "metric" if all referencing classes of a class is another package, propose moving it there.
+  * add zip gem to load classes directly from the classpath (i.e. the jars), add gem dependency

data/lib/javaclass/access_flags.rb

@@ -0,0 +1,44 @@
+require 'javaclass/string_ux'
+
+module JavaClass
+  
+  # The access flags of a class or interface.
+  # Author::   Peter Kofler
+  class AccessFlags
+    
+    # Access flags as defined by JVM spec.
+    ACC_PUBLIC = 0x0001    
+    ACC_FINAL = 0x0010    
+    ACC_SUPER = 0x0020 # old invokespecial instruction semantics    
+    ACC_INTERFACE = 0x0200    
+    ACC_ABSTRACT = 0x0400
+    ACC_OTHER = 0xffff ^ ACC_PUBLIC ^ ACC_FINAL ^ ACC_SUPER ^ ACC_INTERFACE ^ ACC_ABSTRACT
+    
+    def initialize(data, pos)
+      @flags = data.u2(pos)
+      raise "inconsistent flags #{flags}" if abstract? && final?
+      raise "inconsistent flags #{flags}" if interface? && (!abstract? || final?)
+      raise "inconsistent flags #{flags}" if (@flags & ACC_OTHER) != 0
+    end
+    
+    # Return +true+ if the class is public.
+    def public?
+     (@flags & ACC_PUBLIC) != 0
+    end
+    alias accessible? public?   
+    
+    def final?
+     (@flags & ACC_FINAL) != 0
+    end
+    
+    def abstract?
+     (@flags & ACC_ABSTRACT) != 0
+    end
+    
+    def interface?
+     (@flags & ACC_INTERFACE) != 0
+    end
+    
+  end
+  
+end

data/lib/javaclass/class_magic.rb

@@ -0,0 +1,27 @@
+module JavaClass
+  
+  # The +CAFEBABE+ magic of a class file.
+  # Author::   Peter Kofler
+  class ClassMagic
+    
+    CAFE_BABE = "\xCA\xFE\xBA\xBE"
+    
+    # Check the class magic in the _data_ beginning at position _start_ (which is usually 0).
+    def initialize(data, start=0)
+      # "parsing"
+      @bytes = data[start..start+3]
+    end
+    
+    # Return +true+ if the data was valid, i.e. if the class started with +CAFEBABE+.
+    def valid?
+      @bytes == CAFE_BABE
+    end
+    
+    # Return the value of the magic in this class.
+    def bytes
+      @bytes.dup
+    end
+    
+  end
+  
+end

data/lib/javaclass/class_version.rb

@@ -0,0 +1,65 @@
+require 'javaclass/string_ux'
+
+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
+    
+    attr_reader :minor
+    attr_reader :major
+    
+    # Extract the class version from the bytes _data_ starting at position _start_ (which is usually 4).
+    def initialize(data, start=4)
+      # parsing
+      @minor = data.u2(start)
+      @major = data.u2(start+2)
+    end
+    
+    # Return the class file version as +major+.+minor+ string like 48.0 (Java 1.4) or 50.0 (Java 6).
+    def to_s
+      "#{@major}.#{@minor}"
+    end
+    
+    # Return the version as +major+.+minor+ float.
+    def to_f
+      if @minor <= 0
+        denom = 1.0
+      else
+        denom = 1.0 * 10**(Math.log10(@minor).floor + 1)
+      end
+
+      @major + @minor/denom
+    end
+    
+    # Return a debug output of this version.
+    def dump
+      ["  minor version: #{@minor}", "  major version: #{@major}"] 
+    end
+    
+    # Return the JDK version corresponding to this version like "1.6" or "unknown" if none matched.
+    def jdk_version
+      v = to_f
+      if v >= 45.0 && v <= 45.3 # 1.0.2 supports class file format versions 45.0 through 45.3 inclusive.
+        '1.0'
+      elsif v > 45.3 && v <= 45.65535 # 1.1.X can support class file formats of versions in the range 45.0 through 45.65535 inclusive
+        '1.1'
+      elsif v == 46.0 # JDK 1.2=46
+        '1.2'
+      elsif v == 47.0 # JDK 1.3=47
+        '1.3'
+      elsif v == 48.0 # JDK 1.4=48
+        '1.4'
+      elsif v == 49.0 # J2SE 5.0=49
+        '1.5'
+      elsif v == 50.0 # J2SE 6.0=50
+        '1.6'
+      else
+        'unknown'
+      end
+    end
+    
+  end
+  
+end

data/lib/javaclass/constant_pool.rb

@@ -0,0 +1,85 @@
+require 'javaclass/string_ux'
+require 'javaclass/constants/value'
+require 'javaclass/constants/single_reference'
+require 'javaclass/constants/double_reference'
+
+module JavaClass
+  
+  # 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 a debug output of the whole pool.
+    def dump
+      ["  Constant pool:"] + @pool.keys.sort.collect { |k| "const ##{k} = #{self[k].dump}"}
+    end
+    
+  end
+  
+end
+

data/lib/javaclass/constants/base.rb

@@ -0,0 +1,31 @@
+require 'javaclass/string_ux'
+
+module JavaClass 
+  module Constants # :nodoc:
+    
+    # Superclass of constant values in the constant pool. Every constant has a +name+, a +tag+ and a +size+ in bytes.
+    # Author::   Peter Kofler
+    class Base
+      
+      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

data/lib/javaclass/constants/double_reference.rb

@@ -0,0 +1,81 @@
+require 'javaclass/constants/single_reference'
+
+module JavaClass 
+  module Constants # :nodoc:
+    
+    # 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
+      alias class_index first_index 
+      alias name_and_type_index second_index 
+      def initialize(pool, data, start) 
+        super(pool, data, start)
+      end
+      alias class_name first_value
+    end
+    
+    class ConstantMethod < DoubleReference
+      alias class_index first_index 
+      alias name_and_type_index second_index 
+      def initialize(pool, data, start) 
+        super(pool, data, start)
+      end  
+      alias class_name first_value
+    end
+    
+    class ConstantInterfaceMethod < DoubleReference
+      alias class_index first_index 
+      alias name_and_type_index second_index 
+      def initialize(pool, data, start) 
+        super(pool, data, start)
+      end  
+      alias class_name first_value
+    end
+    
+    class ConstantNameAndType < DoubleReference
+      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

data/lib/javaclass/constants/single_reference.rb

@@ -0,0 +1,58 @@
+require 'javaclass/constants/base'
+
+module JavaClass 
+  module Constants # :nodoc:
+    
+    # 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
+      alias name_index first_index
+      def initialize(pool, data, start)
+        super(pool, data, start, "class")
+      end
+      alias class_name first_value
+    end
+    
+    class ConstantString < SingleReference
+      alias string_index first_index
+      def initialize(pool, data, start) 
+        super(pool, data, start)
+      end
+      alias string_value first_value
+    end
+    
+  end
+end

data/lib/javaclass/constants/value.rb

@@ -0,0 +1,114 @@
+require 'javaclass/constants/base'
+
+module JavaClass 
+  module Constants # :nodoc:
+    
+    # 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
+      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
+      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
+      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
+      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
+      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