duby 0.0.1

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

@@ -0,0 +1,18 @@
+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)
+
+  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/factory.rb

@@ -0,0 +1,151 @@
+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,
+      "java.lang.Object" => Object,
+      "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,157 @@
+require 'bitescript'
+
+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 declared_intrinsics
+      methods = []
+      intrinsics.each do |name, group|
+        group.each do |args, method|
+          methods << method
+        end
+      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_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
+    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 PrimitiveType
+    # Primitives define their own intrinsics instead of getting the Object ones.
+    def add_intrinsics
+    end
+  end
+end