duby 0.0.2-java

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

@@ -0,0 +1,19 @@
+module Duby::JVM::Types
+  Boolean = BooleanType.new(Java::boolean, java.lang.Boolean)
+  Byte = IntegerType.new(Java::byte, java.lang.Byte)
+  Char = IntegerType.new(Java::char, java.lang.Character)
+  Short = IntegerType.new(Java::short, java.lang.Short)
+  Int = IntegerType.new(Java::int, java.lang.Integer)
+  Long = LongType.new(Java::long, java.lang.Long)
+  Float = FloatType.new(Java::float, java.lang.Float)
+  Double = DoubleType.new(Java::double, java.lang.Double)
+
+  Object = Type.new(Java::JavaLang.Object)
+  String = StringType.new(Java::JavaLang.String)
+  Iterable = IterableType.new(Java::JavaLang.Iterable)
+
+  Void = VoidType.new
+  Null = NullType.new
+  
+  TYPE_ORDERING = [Byte, Short, Int, Long, Float, Double]
+end  

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

@@ -0,0 +1,11 @@
+module Duby::JVM::Types
+  class BooleanType < PrimitiveType
+    def init_value(builder)
+      builder.iconst_0
+    end
+    
+    def prefix
+      'i'
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module Duby::JVM::Types
+  class Type
+    def expand_each(transformer, call)
+      arg_types = [Duby::AST.block_type]
+      code = intrinsics['each'][arg_types].return_type
+      code.inline(transformer, call)
+    end
+    
+    def add_enumerable_macros
+      add_macro('all?') 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
+          var = transformer.tmp
+          # Parse a fake function call to create a block. Then pull of the
+          # block and attach it to the real call.
+          call.block = transformer.eval("foo {|#{var}| #{var}}").block
+        end
+        
+        # Now that we've got a block we can transform it into a Loop.
+        forloop = expand_each(transformer, call)
+        
+        # Start adding stuff to the loop.
+        # At the beginning of the loop we create a temp initialized to true
+        all = transformer.tmp
+        forloop.init << transformer.eval("#{all} = true")
+        
+        # Now we want to wrap the body of the loop. Start off by using
+        # foo as a placeholder.
+        body = transformer.eval(
+            "unless foo;#{all} = false;break;end", '', forloop)
+        # Then replace foo with the real body.
+        body.condition.predicate = call.block.body
+        # And finally patch the new body back into the forloop.
+        forloop.body = call.block.body.parent = body
+        
+        # Loops don't have a return value, so we need somewhere to
+        # put the result.
+        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('any?') do |transformer, call|
+        if !call.block
+          var = transformer.tmp
+          call.block = transformer.eval("foo {|#{var}| #{var}}").block
+        end
+        forloop = expand_each(transformer, call)
+        any = transformer.tmp
+        forloop.init << transformer.eval("#{any} = false")
+        body = transformer.eval(
+            "if foo;#{any} = true;break;end", '', forloop)
+        body.condition.predicate = call.block.body
+        forloop.body = call.block.body.parent = body
+        
+        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?'][[]]
+    end
+  end
+end

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

@@ -0,0 +1,155 @@
+module Duby::JVM::Types
+  class TypeFactory
+    BASIC_TYPES = {
+      "boolean" => Boolean,
+      "byte" => Byte,
+      "char" => Char,
+      "short" => Short,
+      "int" => Int,
+      "long" => Long,
+      "float" => Float,
+      "double" => Double,
+      "fixnum" => Int,
+      "string" => String,
+      "java.lang.String" => String,
+      "String" => String,
+      "java.lang.Object" => Object,
+      "Object" => Object,
+      "java.lang.Iterable" => Iterable,
+      "Iterable" => Iterable,
+      "void" => Void,
+      "notype" => Void,
+      "null" => Null
+    }.freeze
+
+    attr_accessor :package
+    attr_reader :known_types
+
+    class ParanoidHash < Hash
+      def []=(k, v)
+        raise ArgumentError, "Can't store nil for key #{k.inspect}" if v.nil?
+        super(k, v)
+      end
+    end
+
+    def initialize(filename='')
+      @known_types = ParanoidHash.new
+      @known_types.update(BASIC_TYPES)
+      @declarations = []
+      @package = File.dirname(filename).tr('/', '.')
+      @package.sub! /^\.+/, ''
+      @package = nil if @package.empty?
+    end
+
+    def define_types(builder)
+      @declarations.each do |declaration|
+        declaration.define(builder)
+      end
+    end
+
+    def type(name, array=false, meta=false)
+      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 
+      end
+      orig = name
+      if name.kind_of? Java::JavaClass
+        if name.array?
+          return type(name.component_type, true)
+        else
+          name = name.name
+        end
+      elsif name.respond_to? :java_class
+        name = name.java_class.name
+      end
+      name = name.to_s unless name.kind_of?(::String)
+      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?
+      full_name = name
+      begin
+        @known_types[name] = Type.new(Java::JavaClass.for_name(full_name))
+      rescue NameError
+        unless full_name.include? '.'
+          full_name = "java.lang.#{full_name}"
+          retry
+        end
+        raise $!
+      end
+    end
+
+    def declare_type(node)
+      if node.kind_of? ::String
+        name = node
+        node = nil
+      else
+        name = node.name
+      end
+
+      if Duby::AST::InterfaceDeclaration === node
+        @known_types[name] = InterfaceDefinition.new(name, node)
+      elsif @known_types.include? name
+        existing = @known_types[name]
+        existing.node ||= node
+        existing
+      else
+        full_name = name
+        if !name.include?('.') && package
+          full_name = "#{package}.#{name}"
+        end
+        @known_types[full_name] = TypeDefinition.new(full_name, node)
+        @known_types[name] = @known_types[full_name]
+      end
+    end
+
+    def alias(from, to)
+      @known_types[from] = type(to)
+    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
+  end
+
+  class FixnumLiteralNode < AST::Fixnum
+    def infer(typer)
+      return @inferred_type if resolved?
+      resolved!
+      @inferred_type = FixnumLiteral.new(@literal)
+    end
+
+    def compile(compiler, expression)
+      if expression
+        inferred_type.literal(compiler.method, @literal)
+      end
+    end
+  end
+
+  class FloatLiteralNode < AST::Float
+    def infer(typer)
+      return @inferred_type if resolved?
+      resolved!
+      @inferred_type = FloatLiteral.new(@literal)
+    end
+
+    def compile(compiler, expression)
+      if expression
+        inferred_type.literal(compiler.method, @literal)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+module Duby::JVM::Types
+  class FloatType < Number
+    def prefix
+      'f'
+    end
+    
+    def suffix
+      'g'
+    end
+
+    def init_value(builder)
+      builder.fconst_0
+    end
+
+    def literal(builder, value)
+      case value
+      when 0.0
+        builder.fconst_0
+      when 1.0
+        builder.fconst_1
+      when 2.0
+        builder.fconst_2
+      else
+        builder.ldc_float(value)
+      end
+    end
+    
+    def widen(builder, type)
+      case type
+      when Float
+        # Do nothing
+      when Double
+        builder.f2d
+      else
+        raise ArgumentError, "Invalid widening conversion from Int to #{type}"
+      end
+    end
+  end
+  
+  class DoubleType < FloatType
+    def prefix
+      'd'
+    end
+
+    def wide?
+      true
+    end
+
+    def init_value(builder)
+      builder.dconst_0
+    end
+
+    def literal(builder, value)
+      case value
+      when 0.0
+        builder.dconst_0
+      when 1.0
+        builder.dconst_1
+      else
+        builder.ldc_double(value)
+      end
+    end
+    
+    def widen(builder, type)
+      if type != Double
+        raise ArgumentError, "Invalid widening conversion from Int to #{type}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+class BiteScript::MethodBuilder
+  def inot
+    iconst_m1
+    ixor
+  end
+  
+  def lnot
+    # TODO would any of these be faster?
+    #   iconst_m1; i2l
+    #   lconst_1; lneg
+    ldc_long(-1)
+    ixor
+  end
+end
+
+module Duby::JVM::Types
+  class IntegerType < Number
+    def literal(builder, value)
+      builder.push_int(value)
+    end
+    
+    def init_value(builder)
+      builder.iconst_0
+    end
+    
+    def load(builder, index)
+      builder.iload(index)
+    end
+    
+    def widen(builder, type)
+      case type
+      when Byte, Short, Int
+        # do nothing
+      when Long
+        builder.i2l
+      when Float
+        builder.i2f
+      when Double
+        builder.i2d
+      else
+        raise ArgumentError, "Invalid widening conversion from #{name} to #{type}"
+      end
+    end
+    
+    def prefix
+      'i'
+    end
+    
+    def math_type
+      Int
+    end
+
+    def jump_if(builder, op, label)
+      builder.send "if_icmp#{op}", label
+    end
+
+    def add_intrinsics
+      super
+      math_operator('<<', 'shl')
+      math_operator('>>', 'shr')
+      math_operator('>>>', 'ushr')
+      math_operator('|', 'or')
+      math_operator('&', 'and')
+      math_operator('^', 'xor')
+      unary_operator('~', 'not')
+    end
+  end
+  
+  class LongType < Number
+    def prefix
+      'l'
+    end
+
+    def literal(builder, value)
+      builder.ldc_long(value)
+    end
+
+    def init_value(builder)
+      builder.lconst_0
+    end
+    
+    def wide?
+      true
+    end
+
+    def widen(builder, type)
+      case type
+      when Long
+        # do nothing
+      when Float
+        builder.l2f
+      when Double
+        builder.l2d
+      else
+        raise ArgumentError, "Invalid widening conversion from Int to #{type}"
+      end
+    end
+    
+    def add_intrinsics
+      super
+      math_operator('<<', 'shl')
+      math_operator('>>', 'shr')
+      math_operator('>>>', 'ushr')
+      math_operator('|', 'or')
+      math_operator('&', 'and')
+      math_operator('^', 'xor')
+      unary_operator('~', 'not')
+    end
+  end
+end

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

@@ -0,0 +1,230 @@
+require 'bitescript'
+require 'duby/jvm/types/enumerable'
+
+class BiteScript::MethodBuilder
+  def op_to_bool
+    done_label = label
+    true_label = label
+
+    yield(true_label)
+    iconst_0
+    goto(done_label)
+    true_label.set!
+    iconst_1
+    done_label.set!
+  end
+end
+
+module Duby::JVM::Types
+  class Type
+    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] = {}}
+        add_intrinsics
+        @intrinsics
+      end
+    end
+    
+    def add_method(name, args, method_or_type=nil, &block)
+      if block_given?
+        method_or_type = Intrinsic.new(self, name, args,
+                                       method_or_type, &block)
+      end
+      intrinsics[name][args] = method_or_type
+    end
+
+    def add_macro(name, *args, &block)
+      type = Duby::AST::InlineCode.new(&block)
+      intrinsics[name][args] = Intrinsic.new(self, name, args, type) do
+        raise "Macro should be expanded, no called!"
+      end
+    end
+
+    def declared_intrinsics
+      methods = []
+      intrinsics.each do |name, group|
+        group.each do |args, method|
+          methods << method
+        end
+      end
+      interfaces.each do |interface|
+        methods.concat(interface.declared_intrinsics)
+      end
+      methods
+    end
+
+    def add_intrinsics
+      add_method('nil?', [], Boolean) do |compiler, call, expression|
+        if expression
+          call.target.compile(compiler, true)
+          compiler.method.op_to_bool do |target|
+            compiler.method.ifnull(target)
+          end
+        end
+      end
+      
+      add_method('==', [Object], Boolean) do |compiler, call, expression|
+        # Should this call Object.equals for consistency with Ruby?
+        if expression
+          call.target.compile(compiler, true)
+          call.parameters[0].compile(compiler, true)
+          compiler.method.op_to_bool do |target|
+            compiler.method.if_acmpeq(target)
+          end
+        end
+      end
+      
+      add_method('!=', [Object], Boolean) do |compiler, call, expression|
+        # Should this call Object.equals for consistency with Ruby?
+        if expression
+          call.target.compile(compiler, true)
+          call.parameters[0].compile(compiler, true)
+          compiler.method.op_to_bool do |target|
+            compiler.method.if_acmpne(target)
+          end
+        end
+      end
+    end
+  end
+  
+  class ArrayType
+    def add_intrinsics
+      super
+      add_enumerable_macros
+
+      add_method(
+          '[]', [Int], component_type) do |compiler, call, expression|
+        if expression
+          call.target.compile(compiler, true)
+          call.parameters[0].compile(compiler, true)
+          component_type.aload(compiler.method)
+        end
+      end
+
+      add_method('[]=',
+                 [Int, component_type],
+                 component_type) do |compiler, call, expression| 
+        call.target.compile(compiler, true)
+        convert_args(compiler, call.parameters, [Int, component_type])
+        component_type.astore(compiler.method)
+        if expression
+          call.parameters[1].compile(compiler, true)
+        end
+      end
+      
+      add_method('length', [], Int) do |compiler, call, expression|
+        call.target.compile(compiler, true)
+        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(
+                "#{var.name} = #{array}[#{index}]", '', forloop, index, array)
+          end
+          forloop.post << transformer.eval("#{index} += 1")
+          call.block.body.parent = forloop if call.block.body
+          [
+            Duby::AST::Condition.new(forloop, call.position) do |c|
+              [transformer.eval("#{index} < #{array}.length",
+                                '', forloop, index, array)]
+            end,
+            call.block.body
+          ]
+        end
+      end
+    end
+  end
+  
+  class StringType < Type
+    def add_intrinsics
+      super
+      add_method('+', [String], String) do |compiler, call, expression|
+        if expression
+          java_method('concat', String).call(compiler, call, expression)
+        end
+      end
+      add_method('+', [Int], String) do |compiler, call, expression|
+        if expression
+          call.target.compile(compiler, true)
+          call.parameters[0].compile(compiler, true)
+          compiler.method.invokestatic String, "valueOf", [String, Int]
+          compiler.method.invokevirtual String, "concat", [String, String]
+        end
+      end
+      add_method('+', [Float], String) do |compiler, call, expression|
+        if expression
+          call.target.compile(compiler, true)
+          call.parameters[0].compile(compiler, true)
+          compiler.method.invokestatic String, "valueOf", [String, Float]
+          compiler.method.invokevirtual String, "concat", [String, String]
+        end
+      end
+    end
+  end
+
+  class IterableType < Type
+    def add_intrinsics
+      super
+      add_enumerable_macros
+      add_macro('each', Duby::AST.block_type) do |transformer, call|
+        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(
+                "#{var.name} = #{it}.next", '', forloop, it)
+          end
+          call.block.body.parent = forloop if call.block.body
+          [
+            Duby::AST::Condition.new(forloop, call.position) do |c|
+              [transformer.eval("#{it}.hasNext", '', forloop, it)]
+            end,
+            call.block.body
+          ]
+        end
+      end
+    end
+  end
+  
+  class PrimitiveType
+    # Primitives define their own intrinsics instead of getting the Object ones.
+    def add_intrinsics
+    end
+  end
+end