bitescript 0.0.5 → 0.0.6

data/History.txt

@@ -1,3 +1,9 @@
+=== 0.0.6 / 2010-06-09
+
+* Move to a class mirror API rather than loading and walking real classes
+* Bug fixes for annotations
+* Allow forward references to labels for easier branch logic
+
 === 0.0.5 / 2010-02-04
 
 * Get tests and examples all working nicely again

data/bin/bitep

@@ -0,0 +1,13 @@
+#!/usr/bin/env jruby
+begin
+  require 'bitescript'
+rescue LoadError
+  $: << File.dirname(File.dirname(__FILE__)) + '/lib'
+  require 'bitescript'
+end
+
+file = ARGV[0]
+
+raise "usage: bitep <class_name>" unless file
+
+puts BiteScript::ASM::ClassMirror.load(file).inspect

data/bitescript.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{bitescript}
-  s.version = "0.0.5"
+  s.version = "0.0.6"
   s.authors = ["Charles Oliver Nutter", "Ryan Brown"]
   s.date = Time.now.strftime('YYYY-MM-DD')
   s.description = %q{BiteScript is a Ruby DSL for generating Java bytecode and classes.}

data/examples/fib.bs

@@ -18,9 +18,9 @@ end
 
 macro :end_timing do |i|
   load_time
-  lload 2
+  lload i
   lsub
-  lstore 2
+  lstore i
 end
 
 macro :load_times do

data/lib/bitescript.rb

@@ -3,6 +3,7 @@ require 'bitescript/asm'
 require 'bitescript/signature'
 require 'bitescript/bytecode'
 require 'bitescript/builder'
+require 'bitescript/mirror'
 
 module BiteScript
   include BiteScript::ASM

data/lib/bitescript/asm.rb

@@ -16,6 +16,12 @@ module BiteScript
     end
     java_import asm_package.Label
     java_import asm_package.Type
+    java_import asm_package.AnnotationVisitor
+    java_import asm_package.ClassVisitor
+    java_import asm_package.FieldVisitor
+    java_import asm_package.MethodVisitor
+    java_import asm_package.ClassReader
     java_import asm_package.ClassWriter
+    java_import asm_package.util.CheckClassAdapter
   end
 end

data/lib/bitescript/builder.rb

@@ -62,24 +62,30 @@ module BiteScript
   module Annotatable
     java_import "java.lang.annotation.Retention"
     def annotate(cls, runtime=nil)
-      if Java::JavaClass === cls
-        java_class = cls
-      else
-        java_class = cls.java_class
-      end
-      
       if runtime.nil?
-        retention = java_class.annotation(Retention.java_class)
-        return if retention && retention.value.name == 'CLASS'
-        runtime = retention && retention.value.name == 'RUNTIME'
+        retention = find_retention(cls)
+        return if retention == 'SOURCE'
+        runtime = retention == 'RUNTIME'
       end
 
-      annotation = visit_annotation(Signature.ci(java_class), runtime)
+      annotation = visit_annotation(Signature.ci(cls), runtime)
       annotation.extend AnnotationBuilder
 
       yield annotation
       annotation.visit_end
     end
+
+    def find_retention(cls)
+      if cls.kind_of?(BiteScript::ASM::ClassMirror)
+        retention = cls.getDeclaredAnnotation('java.lang.annotation.Retention')
+      elsif Java::JavaClass === cls
+        retention = cls.annotation(Retention.java_class)
+      else
+        retention = cls.java_class.annotation(Retention.java_class)
+      end
+      return 'CLASS' if retention.nil?
+      return retention.value.name
+    end
   end
   
   class FileBuilder
@@ -221,8 +227,12 @@ module BiteScript
       if @interface
         flags = Opcodes::ACC_INTERFACE | Opcodes::ACC_ABSTRACT
       end
-      
+
       @class_writer = ClassWriter.new(ClassWriter::COMPUTE_MAXS)
+      if ENV['BS_CHECK_CLASSES']
+        @real_class_writer = @class_writer
+        @class_writer = CheckClassAdapter.new(@class_writer)
+      end
       
       interface_paths = []
       (@interfaces).each {|interface| interface_paths << path(interface)}
@@ -270,7 +280,12 @@ module BiteScript
     end
     
     def generate
-      String.from_java_bytes(@class_writer.to_byte_array)
+      if ENV['BS_CHECK_CLASSES']
+        class_writer = @real_class_writer
+      else
+        class_writer = @class_writer
+      end
+      String.from_java_bytes(class_writer.to_byte_array)
     end
 
     %w[public private protected].each do |modifier|
@@ -555,7 +570,7 @@ module BiteScript
       visit k, v
     end
     def annotation(name, cls)
-      if Java::JavaClass === cls
+      if Java::JavaClass === cls || BiteScript::ASM::Type === cls
         java_class = cls
       else
         java_class = cls.java_class

data/lib/bitescript/bytecode.rb

@@ -345,12 +345,19 @@ module BiteScript
       def initialize(method_visitor)
         @method_visitor = method_visitor
         @label = ASM::Label.new
+        @set = false
       end
       
       def set!
+        raise "label set twice" if @set
+        @set = true
         @method_visitor.visit_label(@label)
         self
       end
+      
+      def set?
+        @set
+      end
     end
 
     def labels
@@ -358,18 +365,18 @@ module BiteScript
     end
 
     def sym_to_label(id)
-      lbl = labels[id] or raise "Unknown label '#{id}'"
+      lbl = labels[id]
+      unless lbl
+        lbl = labels[id] = label
+      end
+      lbl
     end
     
     def label(id = nil)
       if id
-        label = labels[id]
-        if label
-          raise "Duplicate label '#{id}'"
-        end
-        label = labels[id] = SmartLabel.new(method_visitor)
-        label.set!
-        label
+        lbl = sym_to_label(id)
+        lbl.set!
+        lbl
       else
         return SmartLabel.new(method_visitor)
       end

data/lib/bitescript/mirror.rb

@@ -0,0 +1,367 @@
+module BiteScript::ASM
+  class EnumValue
+    attr_reader :declaring_type, :name
+
+    def initialize(declaring_type, name)
+      @declaring_type = declaring_type
+      @name = name
+    end
+  end
+
+  class AnnotationMirror
+    attr_reader :type, :parent
+    def initialize(type, parent=nil)
+      @type = type
+      @parent = parent
+      @values = {}
+    end
+
+    def value
+      @values['value']
+    end
+
+    def value=(value)
+      @values['value'] = value
+    end
+
+    def [](name)
+      @values[name]
+    end
+
+    def []=(name, value)
+      @values[name] = value
+    end
+
+    def inspect
+      unless @values.empty?
+        values = []
+        @values.each do |k, v|
+          values << "#{k}=#{inspect_value(v)}"
+        end
+        values = "(#{values.join ', '})"
+      end
+      "@#{type.class_name}#{values}\n"
+    end
+
+    def inspect_value(v)
+      case v
+      when Type
+        v.class_name + ".class"
+      when Array
+        "{#{v.map{|x| inspect_value(x)}.join(', ')}}"
+      when EnumValue
+        "#{v.declaring_type.class_name}.#{v.name}"
+      else
+        v.inspect
+      end
+    end
+
+    class Builder
+      class ValueArray
+        attr_reader :parent
+        def initialize(annotation, array)
+          @parent = annotation
+          @array = array
+        end
+
+        def []=(name, value)
+          @array << value
+        end
+      end
+
+      include BiteScript::ASM::AnnotationVisitor
+
+      attr_reader :annotation
+      def initialize(desc, visible)
+        @current = @annotation = AnnotationMirror.new(Type.getType(desc))
+      end
+
+
+      def visit(name, value)
+        case value
+        when ArrayJavaProxy
+          visitArray(name)
+          value.each {|x| visit(name, x)}
+          visitEnd
+        else
+          @current[name] = value
+        end
+      end
+
+      def visitAnnotation(name, desc)
+        child = AnnotationMirror.new(Type.getType(desc), @current)
+        @current[name] = child
+        @current = child
+        self
+      end
+
+      def visitArray(name)
+        array = @current[name] = []
+        @current = ValueArray.new(@current, array)
+        self
+      end
+
+      def visitEnum(name, desc, value)
+        @current[name] = EnumValue.new(Type.getType(desc), value)
+      end
+
+      def visitEnd
+        @current = @current.parent
+      end
+    end
+  end
+
+  module Annotated
+    def annotations
+      @annotations ||= {}
+    end
+
+    def addAnnotation(annotation)
+      annotations[annotation.type.class_name] = annotation
+    end
+
+    def getDeclaredAnnotation(name)
+      annotations[name]
+    end
+
+    def declaredAnnotations
+      annotations.values
+    end
+
+    def inspect_annotations
+      declaredAnnotations.map {|a| a.inspect}.join('')
+    end
+  end
+
+  module Modifiers
+    attr_accessor :flags
+    def self.add_modifier(name)
+      class_eval <<-EOF
+        def #{name.downcase}?
+          (flags & Opcodes.ACC_#{name.upcase}) != 0
+        end
+      EOF
+    end
+    %w(annotation bridge deprecated enum interface synthetic).each do |name|
+      add_modifier(name)
+    end
+    code = ''
+    %w(Public Private Protected Final Native Abstract
+       Static Strict Synchronized Transient Volatile).each do |name|
+      add_modifier(name)
+      code << "modifiers << '#{name.downcase} ' if #{name.downcase}?\n"
+    end
+
+    class_eval <<-EOF
+      def modifier_string
+        modifiers = ''
+        #{code}
+        modifiers
+      end
+    EOF
+  end
+
+  class ClassMirror
+    include Annotated
+    include Modifiers
+
+    attr_reader :type, :interfaces
+    attr_accessor :superclass
+
+    def initialize(type, flags)
+      super()
+      @type = type
+      @flags = flags
+      @methods = Hash.new {|h, k| h[k] = {}}
+      @constructors = {}
+      @fields = {}
+      @interfaces = []
+    end
+
+    def self.load(name_or_bytes)
+      builder = BiteScript::ASM::ClassMirror::Builder.new
+      BiteScript::ASM::ClassReader.new(name_or_bytes).accept(builder, 3)
+      builder.mirror
+    end
+    alias for_name load
+
+    def getConstructor(*arg_types)
+      @constructors[arg_types]
+    end
+
+    def getConstructors
+      @constructors.values
+    end
+
+    def addConstructor(constructor)
+      @constructors[constructor.parameters] = constructor
+    end
+
+    def getDeclaredMethod(name, *args)
+      if args[0].kind_of?(Array)
+        args = args[0]
+      end
+      @methods[name][args]
+    end
+
+    def getDeclaredMethods(name=nil)
+      if name
+        @methods[name].values
+      else
+        @methods.values.map {|m| m.values}.flatten
+      end
+    end
+
+    def addMethod(method)
+      # TODO this is a hack to fix resolution of covariant returns.
+      # We should properly support methods that only differ by return type.
+      return if method.synthetic?
+      type_names = method.argument_types.map {|type| type.descriptor}
+      if method.name == '<init>'
+        @constructors[type_names] = method
+      else
+        @methods[method.name][type_names] = method
+      end
+    end
+
+    def getField(name)
+      @fields[name]
+    end
+
+    def getDeclaredFields
+      @fields.values
+    end
+
+    def addField(field)
+      @fields[field.name] = field
+    end
+
+    def inspect
+      if annotation?
+        kind = "@interface"
+      elsif interface?
+        kind = "interface"
+      elsif enum?
+        kind = "enum"
+      else
+        kind = "class"
+      end
+      if superclass && !enum? && !interface?
+        extends = "extends #{superclass.getClassName} "
+      end
+      if self.interfaces && !self.interfaces.empty?
+        interfaces = self.interfaces.map{|i| i.class_name}.join(', ')
+        if interface?
+          extends = "extends #{interfaces} "
+        else
+          implements = "implements #{interfaces} "
+        end
+      end
+      result = "#{inspect_annotations}#{modifier_string}#{kind} "
+      result << "#{type.class_name} #{extends}{\n"
+      (getDeclaredFields + getConstructors + getDeclaredMethods).each do |f|
+        result << f.inspect << "\n"
+      end
+      result << "}"
+    end
+
+    class Builder
+      include BiteScript::ASM::ClassVisitor
+      include BiteScript::ASM::FieldVisitor
+      include BiteScript::ASM::MethodVisitor
+
+      def visit(version, access, name, signature, super_name, interfaces)
+        @current = @class = ClassMirror.new(Type.getObjectType(name), access)
+        @class.superclass = Type.getObjectType(super_name) if super_name
+        if interfaces
+          interfaces.each do |i|
+            @class.interfaces << Type.getObjectType(i)
+          end
+        end
+      end
+
+      def mirror
+        @class
+      end
+
+      def visitSource(source, debug); end
+      def visitOuterClass(owner, name, desc); end
+      def visitAttribute(attribute); end
+      def visitInnerClass(name, outer, inner, access); end
+      def visitEnd; end
+
+      def visitAnnotation(desc, visible)
+        builder = AnnotationMirror::Builder.new(desc, visible)
+        @current.addAnnotation(builder.annotation)
+        builder
+      end
+
+      def visitField(flags, name, desc, signature, value)
+        @current = FieldMirror.new(@class.type, flags, name, Type.getType(desc), value)
+        @class.addField(@current)
+        self
+      end
+
+      def visitMethod(flags, name, desc, signature, exceptions)
+        return_type = Type.getReturnType(desc)
+        parameters = Type.getArgumentTypes(desc).to_a
+        exceptions = (exceptions || []).map {|e| Type.getObjectType(e)}
+        @current = MethodMirror.new(
+            @class.type, flags, return_type, name, parameters, exceptions)
+        @class.addMethod(@current)
+        # TODO parameter annotations, default value, etc.
+        self  # This isn't legal is it?
+      end
+
+      def visitAnnotationDefault(*args);end
+
+      def to_s
+        "ClassMirror(#{type.class_name})"
+      end
+    end
+  end
+
+  class FieldMirror
+    include Modifiers
+    include Annotated
+
+    attr_reader :declaring_class, :name, :type, :value
+    def initialize(klass, flags, name, type, value)
+      @declaring_class = klass
+      @flags = flags
+      @name = name
+      @type = type
+      @value = value
+    end
+
+    def inspect
+      inspect_annotations + "#{modifier_string}#{type.getClassName} #{name};"
+    end
+  end
+
+  class MethodMirror
+    include Modifiers
+    include Annotated
+
+    attr_reader :declaring_class, :name, :return_type
+    attr_reader :argument_types, :exception_types
+    def initialize(klass, flags, return_type, name, parameters, exceptions)
+      @flags = flags
+      @declaring_class = klass
+      @name = name
+      @return_type = return_type
+      @argument_types = parameters
+      @exception_types = exceptions
+    end
+
+    def inspect
+      "%s%s%s %s(%s);" % [
+        inspect_annotations,
+        modifier_string,
+        return_type.class_name,
+        name,
+        argument_types.map {|x| x.class_name}.join(', '),
+      ]
+    end
+  end
+end

data/lib/bitescript/signature.rb

@@ -33,6 +33,9 @@ module BiteScript
     module_function :path
     
     def class_id(cls)
+      return cls.descriptor if cls.kind_of?(BiteScript::ASM::Type)
+      return cls.type.descriptor if cls.kind_of?(BiteScript::ASM::ClassMirror)
+
       cls = cls.java_class if Class === cls
       
       if !cls || cls == java.lang.Void.java_class || Java::void == cls

data/nbproject/private/rake-d.txt

@@ -0,0 +1,2 @@
+default=
+test=Run tests

data/test/test_bytecode.rb

@@ -311,7 +311,7 @@ class TestBytecode < Test::Unit::TestCase
     assert_equal([:visit_try_catch_block, a_lbl.label, b_lbl.label, c_lbl.label, "java/lang/Integer"], @dummy.single {trycatch a_lbl, b_lbl, c_lbl, Integer})
   end
   
-  def test_jump_insns
+  def test_backward_jump_insns
     a_lbl = label :a
     assert_equal([:visit_jump_insn, Opcodes::GOTO, a_lbl.label], @dummy.single {goto a_lbl})
     assert_equal([:visit_jump_insn, Opcodes::IFEQ, a_lbl.label], @dummy.single {ifeq a_lbl})
@@ -350,8 +350,68 @@ class TestBytecode < Test::Unit::TestCase
     assert_equal([:visit_jump_insn, Opcodes::IFNULL, a_lbl.label], @dummy.single {ifnull :a})
     assert_equal([:visit_jump_insn, Opcodes::IFNONNULL, a_lbl.label], @dummy.single {ifnonnull :a})
     assert_equal([:visit_jump_insn, Opcodes::JSR, a_lbl.label], @dummy.single {jsr :a})
+
+    # should already have been set above at label :a
+    assert_raises(RuntimeError) {a_lbl.set!}
+  end
     
-    assert_equal([:visit_label, a_lbl.label], @dummy.single {a_lbl.set!})
+  def test_forward_jump_insns
+    # allow forward references to as-yet-unset labels
+    lbl = nil
+    result = @dummy.single {goto :a1; lbl = labels[:a1]}
+    assert_equal([:visit_jump_insn, Opcodes::GOTO, lbl.label], result)
+    assert_equal([:visit_label, lbl.label], @dummy.single {label :a1})
+    result = @dummy.single {ifeq :a2; lbl = labels[:a2]}
+    assert_equal([:visit_jump_insn, Opcodes::IFEQ, lbl.label], result)
+    assert_equal([:visit_label, lbl.label], @dummy.single {label :a2})
+    result = @dummy.single {ifne :a3; lbl = labels[:a3]}
+    assert_equal([:visit_jump_insn, Opcodes::IFNE, lbl.label], result)
+    assert_equal([:visit_label, lbl.label], @dummy.single {label :a3})
+    result = @dummy.single {ifle :a4; lbl = labels[:a4]}
+    assert_equal([:visit_jump_insn, Opcodes::IFLE, lbl.label], result)
+    assert_equal([:visit_label, lbl.label], @dummy.single {label :a4})
+    result = @dummy.single {iflt :a5; lbl = labels[:a5]}
+    assert_equal([:visit_jump_insn, Opcodes::IFLT, lbl.label], result)
+    assert_equal([:visit_label, lbl.label], @dummy.single {label :a5})
+    result = @dummy.single {ifge :a6; lbl = labels[:a6]}
+    assert_equal([:visit_jump_insn, Opcodes::IFGE, lbl.label], result)
+    assert_equal([:visit_label, lbl.label], @dummy.single {label :a6})
+    result = @dummy.single {ifgt :a7; lbl = labels[:a7]}
+    assert_equal([:visit_jump_insn, Opcodes::IFGT, lbl.label], result)
+    assert_equal([:visit_label, lbl.label], @dummy.single {label :a7})
+    result = @dummy.single {if_acmpeq :a8; lbl = labels[:a8]}
+    assert_equal([:visit_jump_insn, Opcodes::IF_ACMPEQ, lbl.label], result)
+    assert_equal([:visit_label, lbl.label], @dummy.single {label :a8})
+    result = @dummy.single {if_acmpne :a9; lbl = labels[:a9]}
+    assert_equal([:visit_jump_insn, Opcodes::IF_ACMPNE, lbl.label], result)
+    assert_equal([:visit_label, lbl.label], @dummy.single {label :a9})
+    result = @dummy.single {if_icmpeq :a10; lbl = labels[:a10]}
+    assert_equal([:visit_jump_insn, Opcodes::IF_ICMPEQ, lbl.label], result)
+    assert_equal([:visit_label, lbl.label], @dummy.single {label :a10})
+    result = @dummy.single {if_icmpne :a11; lbl = labels[:a11]}
+    assert_equal([:visit_jump_insn, Opcodes::IF_ICMPNE, lbl.label], result)
+    assert_equal([:visit_label, lbl.label], @dummy.single {label :a11})
+    result = @dummy.single {if_icmplt :a12; lbl = labels[:a12]}
+    assert_equal([:visit_jump_insn, Opcodes::IF_ICMPLT, lbl.label], result)
+    assert_equal([:visit_label, lbl.label], @dummy.single {label :a12})
+    result = @dummy.single {if_icmpgt :a13; lbl = labels[:a13]}
+    assert_equal([:visit_jump_insn, Opcodes::IF_ICMPGT, lbl.label], result)
+    assert_equal([:visit_label, lbl.label], @dummy.single {label :a13})
+    result = @dummy.single {if_icmple :a14; lbl = labels[:a14]}
+    assert_equal([:visit_jump_insn, Opcodes::IF_ICMPLE, lbl.label], result)
+    assert_equal([:visit_label, lbl.label], @dummy.single {label :a14})
+    result = @dummy.single {if_icmpge :a15; lbl = labels[:a15]}
+    assert_equal([:visit_jump_insn, Opcodes::IF_ICMPGE, lbl.label], result)
+    assert_equal([:visit_label, lbl.label], @dummy.single {label :a15})
+    result = @dummy.single {ifnull :a16; lbl = labels[:a16]}
+    assert_equal([:visit_jump_insn, Opcodes::IFNULL, lbl.label], result)
+    assert_equal([:visit_label, lbl.label], @dummy.single {label :a16})
+    result = @dummy.single {ifnonnull :a17; lbl = labels[:a17]}
+    assert_equal([:visit_jump_insn, Opcodes::IFNONNULL, lbl.label], result)
+    assert_equal([:visit_label, lbl.label], @dummy.single {label :a17})
+    result = @dummy.single {jsr :a18; lbl = labels[:a18]}
+    assert_equal([:visit_jump_insn, Opcodes::JSR, lbl.label], result)
+    assert_equal([:visit_label, lbl.label], @dummy.single {label :a18})
   end
 
   def test_multidim_array

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: bitescript
 version: !ruby/object:Gem::Version 
-  version: 0.0.5
+  prerelease: false
+  segments: 
+    - 0
+    - 0
+    - 6
+  version: 0.0.6
 platform: ruby
 authors: 
   - Charles Oliver Nutter
@@ -10,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-15 12:41:28.313000 -06:00
+date: 2010-06-09 09:15:57.264000 -04:00
 default_executable: 
 dependencies: []
 
@@ -30,6 +35,7 @@ extra_rdoc_files:
 files: 
   - bin/bite
   - bin/bitec
+  - bin/bitep
   - examples/fib.bs
   - examples/hello_world.bs
   - examples/hello_world_macro.bs
@@ -41,12 +47,12 @@ files:
   - lib/bitescript/asm.rb
   - lib/bitescript/builder.rb
   - lib/bitescript/bytecode.rb
+  - lib/bitescript/mirror.rb
   - lib/bitescript/signature.rb
   - nbproject/project.properties
   - nbproject/project.xml
-  - nbproject/private/config.properties
-  - nbproject/private/private.properties
   - nbproject/private/private.xml
+  - nbproject/private/rake-d.txt
   - test/test_bitescript.rb
   - test/test_builder.rb
   - test/test_bytecode.rb
@@ -68,21 +74,25 @@ rdoc_options:
 require_paths: 
   - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+          - 0
         version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+          - 0
         version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: jruby-extras
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: BiteScript is a Ruby DSL for generating Java bytecode.

data/nbproject/private/private.properties

@@ -1,3 +0,0 @@
-file.reference.jvmscript-lib=/Users/headius/projects/bitescript/lib
-file.reference.jvmscript-test=/Users/headius/projects/bitescript/test
-platform.active=default