duby 0.0.2-java → 0.0.3-java

data/lib/duby/jvm/types/enumerable.rb

@@ -7,7 +7,7 @@ module Duby::JVM::Types
     end
     
     def add_enumerable_macros
-      add_macro('all?') do |transformer, call|
+      all_proc = proc do |transformer, call|
         if !call.block
           # We need to create a block that just returns the item passed to it
           # First get a new temp for the block argument
@@ -39,9 +39,10 @@ module Duby::JVM::Types
         result = Duby::AST::Body.new(call.parent, call.position)
         result << forloop << transformer.eval("#{all}", '', nil, all)
       end
-      intrinsics['all?'][[Duby::AST.block_type]] = intrinsics['all?'][[]]
+      add_macro('all?', &all_proc)
+      add_macro('all?', Duby::AST.block_type, &all_proc)
 
-      add_macro('any?') do |transformer, call|
+      any_proc = proc do |transformer, call|
         if !call.block
           var = transformer.tmp
           call.block = transformer.eval("foo {|#{var}| #{var}}").block
@@ -57,7 +58,8 @@ module Duby::JVM::Types
         result = Duby::AST::Body.new(call.parent, call.position)
         result << forloop << transformer.eval("#{any}", '', nil, any)
       end
-      intrinsics['any?'][[Duby::AST.block_type]] = intrinsics['any?'][[]]
+      add_macro('any?', &any_proc)
+      add_macro('any?', Duby::AST.block_type, &any_proc)
     end
   end
 end

data/lib/duby/jvm/types/factory.rb

@@ -1,3 +1,4 @@
+require 'jruby'
 module Duby::JVM::Types
   class TypeFactory
     BASIC_TYPES = {
@@ -19,7 +20,8 @@ module Duby::JVM::Types
       "Iterable" => Iterable,
       "void" => Void,
       "notype" => Void,
-      "null" => Null
+      "null" => Null,
+      "dynamic" => DynamicType.new
     }.freeze
 
     attr_accessor :package
@@ -39,6 +41,8 @@ module Duby::JVM::Types
       @package = File.dirname(filename).tr('/', '.')
       @package.sub! /^\.+/, ''
       @package = nil if @package.empty?
+      @search_packages = [@package, 'java.lang']
+      @mirrors = {}
     end
 
     def define_types(builder)
@@ -48,15 +52,22 @@ module Duby::JVM::Types
     end
 
     def type(name, array=false, meta=false)
+      if name.kind_of?(BiteScript::ASM::Type)
+        if name.getDescriptor[0] == ?[
+          return type(name.getElementType, true, meta)
+        else
+          name = name.getClassName
+        end
+      end
       type = basic_type(name)
       type = type.meta if meta
       type = type.array_type if array
       return type
     end
-    
+
     def basic_type(name)
       if name.kind_of?(Type) || name.kind_of?(NarrowingType)
-        return name.basic_type 
+        return name.basic_type
       end
       orig = name
       if name.kind_of? Java::JavaClass
@@ -72,18 +83,27 @@ module Duby::JVM::Types
       return @known_types[name].basic_type if @known_types[name]
       raise ArgumentError, "Bad Type #{orig}" if name =~ /Java::/
       raise ArgumentError, "Bad Type #{orig.inspect}" if name == '' || name.nil?
+      if name.include? '.'
+        alt_names = []
+      else
+        alt_names = @search_packages.map {|package| "#{package}.#{name}"}
+      end
       full_name = name
       begin
-        @known_types[name] = Type.new(Java::JavaClass.for_name(full_name))
+        @known_types[name] = Type.new(get_mirror(full_name))
       rescue NameError
-        unless full_name.include? '.'
-          full_name = "java.lang.#{full_name}"
+        unless alt_names.empty?
+          full_name = alt_names.shift
           retry
         end
         raise $!
       end
     end
 
+    def known_type(name)
+      basic_type(name) rescue nil
+    end
+
     def declare_type(node)
       if node.kind_of? ::String
         name = node
@@ -92,9 +112,7 @@ module Duby::JVM::Types
         name = node.name
       end
 
-      if Duby::AST::InterfaceDeclaration === node
-        @known_types[name] = InterfaceDefinition.new(name, node)
-      elsif @known_types.include? name
+      if @known_types.include? name
         existing = @known_types[name]
         existing.node ||= node
         existing
@@ -103,26 +121,44 @@ module Duby::JVM::Types
         if !name.include?('.') && package
           full_name = "#{package}.#{name}"
         end
-        @known_types[full_name] = TypeDefinition.new(full_name, node)
+        if Duby::AST::InterfaceDeclaration === node
+          klass = InterfaceDefinition
+        else
+          klass = TypeDefinition
+        end
+        @known_types[full_name] = klass.new(full_name, node)
         @known_types[name] = @known_types[full_name]
       end
     end
 
     def alias(from, to)
-      @known_types[from] = type(to)
+      if from == '*'
+        @search_packages << to.sub(".*", "")
+      else
+        @known_types[from] = type(to)
+      end
     end
 
     def no_type
       Void
     end
-    
+
     def fixnum(parent, line_number, literal)
       FixnumLiteralNode.new(parent, line_number, literal)
     end
-    
+
     def float(parent, line_number, literal)
       FloatLiteralNode.new(parent, line_number, literal)
     end
+
+    def get_mirror(name)
+      @mirrors[name] ||= begin
+        classname = name.tr('.', '/') + ".class"
+        stream = JRuby.runtime.jruby_class_loader.getResourceAsStream(classname)
+        raise NameError, "Class '#{name}' not found." unless stream
+        BiteScript::ASM::ClassMirror.load(stream)
+      end
+    end
   end
 
   class FixnumLiteralNode < AST::Fixnum

data/lib/duby/jvm/types/floats.rb

@@ -3,6 +3,14 @@ module Duby::JVM::Types
     def prefix
       'f'
     end
+
+    def math_type
+      Float
+    end
+
+    def box_type
+      java.lang.Float
+    end
     
     def suffix
       'g'
@@ -42,6 +50,14 @@ module Duby::JVM::Types
       'd'
     end
 
+    def math_type
+      Double
+    end
+
+    def box_type
+      java.lang.Double
+    end
+
     def wide?
       true
     end

data/lib/duby/jvm/types/integers.rb

@@ -50,10 +50,49 @@ module Duby::JVM::Types
       Int
     end
 
+    def box_type
+      java.lang.Integer
+    end
+
     def jump_if(builder, op, label)
       builder.send "if_icmp#{op}", label
     end
 
+    def build_loop(parent, position, duby, block, first_value,
+                   last_value, ascending, inclusive)
+      if ascending
+        comparison = "<"
+        op = "+="
+      else
+        comparison = ">"
+        op = "-="
+      end
+      comparison << "=" if inclusive
+      forloop = Duby::AST::Loop.new(parent, position, true, false) do |forloop|
+        first, last = duby.tmp, duby.tmp
+        init = duby.eval("#{first} = 0; #{last} = 0;")
+        init.children[-2].value = first_value
+        init.children[-1].value = last_value
+        forloop.init << init
+
+        var = (block.args.args || [])[0]
+        if var
+          forloop.pre << duby.eval(
+              "#{var.name} = #{first}", '', forloop, first, last)
+        end
+        forloop.post << duby.eval("#{first} #{op} 1")
+        [
+          Duby::AST::Condition.new(forloop, position) do |c|
+            [duby.eval("#{first} #{comparison} #{last}",
+                       '', forloop, first, last)]
+          end,
+          nil
+        ]
+      end
+      forloop.body = block.body
+      forloop
+    end
+
     def add_intrinsics
       super
       math_operator('<<', 'shl')
@@ -63,14 +102,36 @@ module Duby::JVM::Types
       math_operator('&', 'and')
       math_operator('^', 'xor')
       unary_operator('~', 'not')
+
+      add_macro('downto', Int, Duby::AST.block_type) do |transformer, call|
+        build_loop(call.parent, call.position, transformer,
+                   call.block, call.target, call.parameters[0], false, true)
+      end
+      add_macro('upto', Int, Duby::AST.block_type) do |transformer, call|
+        build_loop(call.parent, call.position, transformer,
+                   call.block, call.target, call.parameters[0], true, true)
+      end
+      add_macro('times', Duby::AST.block_type) do |transformer, call|
+        build_loop(call.parent, call.position, transformer,
+                   call.block, Duby::AST::fixnum(nil, call.position, 0),
+                   call.target, true, false)
+      end
     end
   end
-  
+
   class LongType < Number
     def prefix
       'l'
     end
 
+    def math_type
+      Long
+    end
+
+    def box_type
+      java.lang.Long
+    end
+
     def literal(builder, value)
       builder.ldc_long(value)
     end
@@ -107,4 +168,4 @@ module Duby::JVM::Types
       unary_operator('~', 'not')
     end
   end
-end
+end

data/lib/duby/jvm/types/intrinsics.rb

@@ -20,19 +20,19 @@ module Duby::JVM::Types
     def load(builder, index)
       builder.send "#{prefix}load", index
     end
-    
+
     def store(builder, index)
       builder.send "#{prefix}store", index
     end
-    
+
     def return(builder)
       builder.send "#{prefix}return"
     end
-    
+
     def init_value(builder)
       builder.aconst_null
     end
-    
+
     def intrinsics
       @intrinsics ||= begin
         @intrinsics = Hash.new {|h, k| h[k] = {}}
@@ -40,7 +40,7 @@ module Duby::JVM::Types
         @intrinsics
       end
     end
-    
+
     def add_method(name, args, method_or_type=nil, &block)
       if block_given?
         method_or_type = Intrinsic.new(self, name, args,
@@ -56,15 +56,20 @@ module Duby::JVM::Types
       end
     end
 
-    def declared_intrinsics
+    def declared_intrinsics(name=nil)
       methods = []
-      intrinsics.each do |name, group|
+      all_intrinsics = if name.nil?
+        intrinsics
+      else
+        [[name, intrinsics[name]]]
+      end
+      all_intrinsics.each do |name, group|
         group.each do |args, method|
           methods << method
         end
       end
       interfaces.each do |interface|
-        methods.concat(interface.declared_intrinsics)
+        methods.concat(interface.declared_intrinsics(name))
       end
       methods
     end
@@ -78,7 +83,7 @@ module Duby::JVM::Types
           end
         end
       end
-      
+
       add_method('==', [Object], Boolean) do |compiler, call, expression|
         # Should this call Object.equals for consistency with Ruby?
         if expression
@@ -89,7 +94,7 @@ module Duby::JVM::Types
           end
         end
       end
-      
+
       add_method('!=', [Object], Boolean) do |compiler, call, expression|
         # Should this call Object.equals for consistency with Ruby?
         if expression
@@ -102,7 +107,7 @@ module Duby::JVM::Types
       end
     end
   end
-  
+
   class ArrayType
     def add_intrinsics
       super
@@ -119,7 +124,7 @@ module Duby::JVM::Types
 
       add_method('[]=',
                  [Int, component_type],
-                 component_type) do |compiler, call, expression| 
+                 component_type) do |compiler, call, expression|
         call.target.compile(compiler, true)
         convert_args(compiler, call.parameters, [Int, component_type])
         component_type.astore(compiler.method)
@@ -127,24 +132,24 @@ module Duby::JVM::Types
           call.parameters[1].compile(compiler, true)
         end
       end
-      
+
       add_method('length', [], Int) do |compiler, call, expression|
         call.target.compile(compiler, true)
-        compiler.method.arraylength              
+        compiler.method.arraylength
       end
-      
+
       add_macro('each', Duby::AST.block_type) do |transformer, call|
         Duby::AST::Loop.new(call.parent,
                             call.position, true, false) do |forloop|
           index = transformer.tmp
           array = transformer.tmp
-          
+
           init = transformer.eval("#{index} = 0;#{array} = nil")
           array_assignment = init.children[-1]
           array_assignment.value = call.target
           call.target.parent = array_assignment
           forloop.init << init
-          
+
           var = call.block.args.args[0]
           if var
             forloop.pre << transformer.eval(
@@ -163,7 +168,7 @@ module Duby::JVM::Types
       end
     end
   end
-  
+
   class StringType < Type
     def add_intrinsics
       super
@@ -188,6 +193,23 @@ module Duby::JVM::Types
           compiler.method.invokevirtual String, "concat", [String, String]
         end
       end
+      add_method('[]', [Int], Char) do |compiler, call, expression|
+        if expression
+          call.target.compile(compiler, true)
+          call.parameters[0].compile(compiler, true)
+          compiler.method.invokevirtual String, "charAt", [Char, Int]
+        end
+      end
+      add_method('[]', [Int, Int], String) do |compiler, call, expression|
+        if expression
+          call.target.compile(compiler, true)
+          call.parameters[0].compile(compiler, true)
+          compiler.method.dup
+          call.parameters[1].compile(compiler, true)
+          compiler.method.iadd
+          compiler.method.invokevirtual String, "substring", [String, Int, Int]
+        end
+      end
     end
   end
 
@@ -199,12 +221,12 @@ module Duby::JVM::Types
         Duby::AST::Loop.new(call.parent,
                             call.position, true, false) do |forloop|
           it = transformer.tmp
-          
+
           assignment = transformer.eval("#{it} = foo.iterator")
           assignment.value.target = call.target
           call.target.parent = assignment.value
           forloop.init << assignment
-          
+
           var = call.block.args.args[0]
           if var
             forloop.pre << transformer.eval(
@@ -221,7 +243,7 @@ module Duby::JVM::Types
       end
     end
   end
-  
+
   class PrimitiveType
     # Primitives define their own intrinsics instead of getting the Object ones.
     def add_intrinsics