cast_off 0.2.0

data/lib/cast_off/compile/ir/operand.rb

@@ -0,0 +1,934 @@
+# coding=utf-8
+
+module CastOff::Compiler
+  module SimpleIR
+    class TypeContainer
+      include CastOff::Util
+
+      undef_method(:==)
+      undef_method(:eql?)
+      undef_method(:hash)
+      undef_method(:to_s)
+
+      attr_reader :types, :state
+      # state = :undefined || :initialized || :dynamic || :static
+
+      # undefined   は、何と交わっても、交わった相手の状態に変わる
+      # initialized は、dynamic と交わったときのみ、相手の状態に変わる
+      # dynamic     は、何と交わっても dynamic のまま
+      # static      は、何と交わっても static のまま
+
+      # ignore に入っていたら @types に加えない
+      # annotation に入っていたら dynamic にするときに、annotation で指定された型にする, ignore に含まれているものは加えない
+
+      def initialize()
+        @types = []
+        @state = :undefined
+        @annotation = []
+        @ignore = []
+        @unboxing_state = :undefined
+        @negative_cond_value = false
+      end
+
+      ### unboxing begin ###
+      def unbox()
+        case @unboxing_state
+        when :can_unbox
+          @unboxing_state = :unboxed
+          return true
+        when :unboxed
+          return false
+        end
+        bug()
+      end
+
+      def unboxed?
+        @unboxing_state == :unboxed
+      end
+
+      def box()
+        case @unboxing_state
+        when :unboxed, :can_unbox, :can_not_unbox
+          @unboxing_state = :boxed
+          return true
+        when :boxed
+          return false
+        end
+        bug()
+      end
+
+      def boxed?
+        @unboxing_state == :boxed
+      end
+
+      def can_unbox?
+        if instance_of?(LocalVariable) || instance_of?(TmpVariable) || instance_of?(Literal)
+          if dynamic? || @types.size != 1
+            false
+          else
+            true
+          end
+        else
+          # ConstWrapper, Self, Pointer, Argument, TmpBuffer
+          false
+        end
+      end
+
+      def can_not_unbox?
+        @unboxing_state == :can_not_unbox
+      end
+
+      def can_unbox()
+        bug() unless @unboxing_state == :undefined
+        @unboxing_state = :can_unbox
+      end
+
+      def can_not_unbox()
+        case @unboxing_state
+        when :undefined, :can_unbox
+          @unboxing_state = :can_not_unbox
+          true
+        when :can_not_unbox
+          false
+        else
+          bug()
+        end
+      end
+
+      def box_unbox_undefined?
+        @unboxing_state == :undefined
+      end
+      ### unboxing end ###
+
+      FloatWrapper = ClassWrapper.new(Float, true)
+      FixnumWrapper = ClassWrapper.new(Fixnum, true)
+      def declare_class()
+        case @unboxing_state
+        when :unboxed
+          bug() if dynamic?
+          bug() unless @types.size == 1
+          c = @types[0]
+          case c
+          when FloatWrapper
+            return :double
+          when FixnumWrapper
+            return :long
+          end
+        when :can_unbox, :can_not_unbox, :boxed
+          return :VALUE
+        end
+        bug()
+      end
+
+      def declare()
+        case declare_class()
+        when :double
+          return 'double'
+        when :long
+          return 'long'
+        when :VALUE
+          return 'VALUE'
+        end
+        bug()
+      end
+
+      def to_name()
+        bug()
+      end
+
+      def to_debug_string()
+        "#{self}(#{dynamic? ? 'dynamic' : @types.join(", ")})"
+      end
+
+      def to_s()
+        case declare_class()
+        when :double
+          return "#{to_name()}_Float"
+        when :long
+          return "#{to_name()}_Fixnum"
+        when :VALUE
+          return to_name()
+        end
+        bug()
+      end
+
+      def class_exact?
+        bug()
+      end
+
+      def is_class_exact()
+        bug()
+      end
+
+      def reset()
+        @ignore.clear()
+        case @state
+        when :undefined
+          bug()
+        when :initialized, :dynamic
+          @types = []
+          @state = :undefined
+        when :static
+          # nothing to do
+        else
+          bug()
+        end
+      end
+
+      def not_initialized()
+        # @ignore のせいで :undefined になっているものとしか交わらなかったため、initialize されなかったものがある。
+        # そのため、@ignore が空のときに、ここに来る場合がある。
+        @state = :dynamic
+      end
+
+      def is_not(types)
+        bug() if @state == :static
+        bug() unless (@types & @ignore).empty?
+        bug() if types.empty?
+        types = types.map{|t| convert(t)}
+        if (types - @ignore).empty?
+          false
+        else
+          @ignore |= types
+          @types  -= types
+          true
+        end
+      end
+
+      def is_also(t)
+        t = convert(t)
+        return false if @ignore.include?(t)
+        case @state
+        when :undefined
+          @state = :initialized
+          bug() unless @types.empty?
+          @types << t
+          return true
+        when :initialized
+          bug() if @types.empty?
+          if @types.include?(t)
+            return false
+          else
+            @types << t
+            return true
+          end
+        when :static
+          bug() if @types.empty?
+          bug() unless @types.include?(t)
+          return false
+        when :dynamic
+          return false
+        else
+          bug()
+        end
+        bug()
+      end
+
+      def undefined?()
+        @state == :undefined
+      end
+
+      def dynamic?()
+        @state == :dynamic
+      end
+
+      def is_dynamic()
+        return false if @state == :dynamic
+        return false if @state == :static
+        if annotated?
+          if (@annotation - @ignore - @types).empty?
+            return false
+          else
+            @state = :initialized
+            @types |= (@annotation - @ignore)
+            return true
+          end
+        else
+          @state = :dynamic
+          return true
+        end
+        bug()
+      end
+
+      def static?()
+        @state == :static
+      end
+
+      def is_static(types)
+        bug() if types.empty?
+        types = types.map{|t| convert(t)}
+        bug() unless (@ignore & types).empty?
+        case @state
+        when :undefined
+          bug() unless @types.empty?
+          @types = types
+          @state = :static
+          return true
+        when :static
+          bug() unless @types == types
+          return false
+        end
+        bug()
+      end
+
+      def is_annotated(types)
+        # 代入の対象となるような変数(local, instance, class, global variable)は、
+        # static ではなく annotated とする。
+        # initialized にしちゃうと、dynamic と union したときに、dynamic になってしまうのがもどかしい。
+        bug() unless @state == :undefined
+        bug() unless @annotation.empty?
+        bug() unless @ignore.empty?
+        bug() if types.empty?
+        @annotation = types.map{|t| convert(t)}
+        @annotation.freeze()
+      end
+
+      def is_just?(c)
+        case c
+        when Class, ClassWrapper
+          return is_just_class(c)
+        when Array
+          return is_just_classes(c)
+        end
+        bug()
+      end
+
+      def is_also?(c)
+        case c
+        when Class, ClassWrapper
+          return is_also_class(c)
+        end
+        bug()
+      end
+
+      def union(v)
+        bug() if (v.types + @types).find{|t| not t.is_a?(ClassWrapper)}
+        union_types = v.types - @ignore
+        case @state
+        when :undefined
+          bug() unless @types.empty?
+          case v.state
+          when :undefined
+            return false
+          when :initialized, :static
+            return false if union_types.empty?
+            @state = :initialized
+            @types |= union_types
+            return true
+          when :dynamic
+            return is_dynamic()
+          else
+            bug()
+          end
+        when :initialized
+          bug() if @types.empty?
+          case v.state
+          when :undefined
+            return false
+          when :initialized, :static
+            if (union_types - @types).empty?
+              return false
+            else
+              @types |= union_types
+              return true
+            end
+          when :dynamic
+            return is_dynamic()
+          else
+            bug()
+          end
+        when :static
+          bug() if @types.empty?
+          case v.state
+          when :undefined, :dynamic
+            return false
+          when :initialized, :static
+            bug() unless (union_types - @types).empty? || negative_cond_value?
+            return false
+          else
+            bug()
+          end
+        when :dynamic
+          return false
+        else
+          bug()
+        end
+        bug()
+      end
+
+      def is_negative_cond_value
+        @negative_cond_value = true
+      end
+
+      private
+
+      def negative_cond_value?
+        @negative_cond_value
+      end
+
+      def is_just_classes(classes)
+        classes = classes.map{|c| convert(c)}
+        case @state
+        when :undefined
+          bug()
+        when :initialized, :static
+          bug() if @types.empty?
+          bug() if classes.empty?
+          return false unless (@types - classes).empty?
+          return false unless (classes - @types).empty?
+          return true
+        when :dynamic
+          return false
+        end
+        bug()
+      end
+
+      def is_just_class(klass)
+        klass = convert(klass)
+        case @state
+        when :undefined
+          bug()
+        when :initialized, :static
+          bug() if @types.empty?
+          return false if @types.size != 1
+          return false if @types[0] != klass
+          return true
+        when :dynamic
+          return false
+        end
+        bug()
+      end
+
+      def is_also_class(klass)
+        klass = convert(klass)
+        case @state
+        when :undefined
+          bug()
+        when :initialized, :static
+          bug() if @types.empty?
+          return @types.include?(klass)
+        when :dynamic
+          return false
+        end
+        bug()
+      end
+
+      def convert(t)
+        case t
+        when ClassWrapper
+          # nothing to do
+        when Class
+          t = ClassWrapper.new(t, true)
+        else
+          bug()
+        end
+        t
+      end
+
+      def annotated?
+        not @annotation.empty?
+      end
+    end
+
+    class ConstWrapper < TypeContainer
+      attr_reader :path
+
+      def initialize(flag, *ids, translator)
+        super()
+        @chain = ids
+        @flag = flag
+        @path = "#{@flag ? '::' : nil}#{@chain.join("::")}"
+        @translator = translator
+        @name = @translator.allocate_name("const_#{@path}")
+        @translator.declare_constant(@name)
+        conf = @translator.configuration
+        @cache_constant_p = @prefetch_constant_p = conf.prefetch_constant? && conf.has_binding?
+        if prefetch?
+          begin
+            val = conf.evaluate_by_passed_binding(@path)
+            c = ClassWrapper.new(val, false)
+          rescue
+            @prefetch_constant_p = false
+            c = nil
+          end
+        else
+          c = nil
+        end
+        if c && @translator.get_c_classname(c)
+          is_static([c])
+        else
+          is_dynamic()
+        end
+      end
+
+      def get_constant_chain
+        ret = []
+        ret << "  cast_off_tmp = #{@flag ? 'rb_cObject' : 'Qnil'};"
+        @chain.each do |id|
+          ret << "  cast_off_tmp = cast_off_get_constant(cast_off_tmp, #{@translator.allocate_id(id)});"
+        end
+        ret << "  #{@name} = cast_off_tmp;"
+        ret.join("\n")
+      end
+
+      def cache?
+        @cache_constant_p
+      end
+
+      def prefetch?
+        @prefetch_constant_p
+      end
+
+      def class_exact?
+        false
+      end
+
+      def to_name
+        @name
+      end
+
+      def source
+        @path
+      end
+
+      def eql?(v)
+        return false unless v.is_a?(ConstWrapper)
+        @path == v.path
+      end
+
+      def ==(v)
+        eql?(v)
+      end
+
+      def hash
+        @path.to_s.hash
+      end
+    end
+
+    class Literal < TypeContainer
+      include CastOff::Util
+
+      attr_reader :val, :literal_value
+
+      def initialize(val, translator)
+        super()
+        case val
+        when NilClass
+          @val = "Qnil"
+          type = NilClass
+          @literal_value = nil
+        when Fixnum, Symbol, Bignum, Float, String, Regexp, Array, Range, TrueClass, FalseClass, Class
+          @val = translator.allocate_object(val)
+          type = val.class
+          @literal_value = val
+        else
+          bug("unexpected object #{val}")
+        end
+        is_static([type])
+      end
+
+      def to_s()
+        case declare_class()
+        when :double, :long
+          return "#{@literal_value}"
+        when :VALUE
+          return to_name()
+        end
+        bug()
+      end
+
+      def class_exact?
+        true
+      end
+
+      def to_name
+        @val
+      end
+
+      def source
+        @literal_value.inspect
+      end
+
+      def eql?(v)
+        return false unless v.is_a?(Literal)
+        @literal_value == v.literal_value
+      end
+
+      def ==(v)
+        eql?(v)
+      end
+
+      def hash()
+        @literal_value.hash()
+      end
+    end
+
+    class Self < TypeContainer
+      include CastOff::Util
+
+      def initialize(translator)
+        super()
+        reciever_class = translator.reciever_class
+        if reciever_class
+          #is_static(reciever_class)
+          reciever_class = [reciever_class] unless reciever_class.instance_of?(Array)
+          reciever_class.each{|c| is_also(c)}
+        else
+          is_dynamic()
+        end
+      end
+
+      def class_exact?
+        false
+      end
+
+      def to_name
+        "self"
+      end
+
+      def source
+        "self"
+      end
+
+      def eql?(v)
+        v.is_a?(Self)
+      end
+
+      def ==(v)
+        eql?(v)
+      end
+
+      def hash
+        self.to_name.hash
+      end
+    end
+
+    class Variable < TypeContainer
+      def initialize()
+        super()
+        @isclassexact = false
+      end
+
+      def class_exact?
+        @isclassexact
+      end
+
+      def is_class_exact()
+        bug() if @isclassexact
+        @isclassexact = true
+      end
+
+      def has_undefined_path()
+        # nothing to do
+      end
+
+      def declare?
+        self.is_a?(LocalVariable) || self.is_a?(TmpVariable) || self.is_a?(Pointer)
+      end
+    end
+
+    class TmpVariable < Variable
+      include CastOff::Util
+      attr_reader :index
+
+      def initialize(index)
+        super()
+        @index = index
+      end
+
+      def to_name
+        "tmp#{@index}"
+      end
+
+      def source
+        bug()
+      end
+
+      def eql?(v)
+        return false unless v.is_a?(TmpVariable)
+        @index == v.index
+      end
+
+      def ==(v)
+        eql?(v)
+      end
+
+      def hash
+        self.to_name.hash
+      end
+
+      def has_undefined_path()
+        bug()
+      end
+    end
+
+    class Pointer < Variable
+      def initialize
+        super()
+      end
+    end
+
+    class InstanceVariable < Pointer
+      attr_reader :id
+
+      def initialize(id, types)
+        super()
+        @id = id
+        @name = id.slice(1, id.size - 1)
+        
+        if types
+          bug() unless types.is_a?(Array)
+          is_annotated(types)
+        end
+      end
+
+      def to_name
+        "instance_#{@name}"
+      end
+
+      def source
+        @id.to_s
+      end
+
+      def eql?(v)
+        return false unless v.is_a?(InstanceVariable)
+        @id == v.id
+      end
+
+      def ==(v)
+        eql?(v)
+      end
+
+      def hash
+        self.to_name.hash
+      end
+    end
+
+    class ClassVariable < Pointer
+      attr_reader :id
+
+      def initialize(id, types)
+        super()
+        @id = id
+        @name = id.slice(2, id.size - 2)
+        
+        if types
+          bug() unless types.is_a?(Array)
+          is_annotated(types)
+        end
+      end
+
+      def to_name
+        "class_#{@name}"
+      end
+
+      def source
+        @id.to_s
+      end
+
+      def eql?(v)
+        return false unless v.is_a?(ClassVariable)
+        @id == v.id
+      end
+
+      def ==(v)
+        eql?(v)
+      end
+
+      def hash
+        self.to_name.hash
+      end
+    end
+
+    class GlobalVariable < Pointer
+      attr_reader :id
+
+      def initialize(gentry, types, translator)
+        super()
+        @id = gentry
+        @name = gentry.slice(1, gentry.size - 1)
+        @name = translator.allocate_name(@name)
+        
+        if types
+          bug() unless types.is_a?(Array)
+          is_annotated(types)
+        end
+      end
+
+      def to_name
+        "global_#{@name}"
+      end
+
+      def source
+        @id.to_s
+      end
+
+      def eql?(v)
+        return false unless v.is_a?(GlobalVariable)
+        @id == v.id
+      end
+
+      def ==(v)
+        eql?(v)
+      end
+
+      def hash
+        self.to_name.hash
+      end
+    end
+
+    class DynamicVariable < Pointer
+      attr_reader :index, :level
+
+      def initialize(name, idx, op_idx, lv, types)
+        super()
+        @name = name
+        @index = idx
+        @op_idx = op_idx
+        @level = lv
+
+        if types
+          bug() unless types.is_a?(Array)
+          is_annotated(types)
+        end
+      end
+
+      def to_name
+        "dfp#{@level}[#{@op_idx}]"
+      end
+
+      def source
+        @name.to_s
+      end
+
+      def eql?(v)
+        return false unless v.is_a?(DynamicVariable)
+        @index == v.index && @level == v.level
+      end
+
+      def ==(v)
+        eql?(v)
+      end
+
+      def hash
+        self.to_name.hash
+      end
+
+      def declare?
+        false
+      end
+    end
+
+    class Argument < Variable
+      attr_reader :id, :lvar
+
+      def initialize(name, id, op_idx, lv, types)
+        super()
+        @name = name
+        @id = id
+        @op_idx = op_idx
+        @level = lv
+        @lvar = "local#{@id}_#{@name}" # FIXME
+
+        if types
+          bug() unless types.is_a?(Array)
+          is_static(types)
+        end
+      end
+
+      def to_name
+        "<Argument:#{@id}_#{@name}>"
+      end
+
+      def source
+        bug()
+      end
+
+      def eql?(v)
+        return false unless v.is_a?(Argument)
+        @id == v.id
+      end
+
+      def ==(v)
+        eql?(v)
+      end
+
+      def hash
+        self.to_name.hash
+      end
+    end
+
+    class LocalVariable < Variable
+      attr_reader :id, :name
+
+      def initialize(name, id, op_idx, lv, types)
+        super()
+        @name = name
+        @id = id
+        @op_idx = op_idx
+        @level = lv
+
+        if types
+          bug() unless types.is_a?(Array)
+          is_annotated(types)
+        end
+      end
+
+      def to_name
+        "local#{@id}_#{@name}"
+      end
+
+      def source
+        @name.to_s
+      end
+
+      def eql?(v)
+        return false unless v.is_a?(LocalVariable)
+        @id == v.id
+      end
+
+      def ==(v)
+        eql?(v)
+      end
+
+      def hash
+        self.to_name.hash
+      end
+
+      def has_undefined_path()
+        bug()
+      end
+    end
+
+    class TmpBuffer < Variable
+      attr_reader :index
+
+      def initialize(index)
+        super()
+        @index = index
+      end
+
+      def to_name
+        "cast_off_argv[#{@index}]"
+      end
+
+      def source
+        bug()
+      end
+
+      def eql?(v)
+        return false unless v.is_a?(TmpBuffer)
+        @index == v.index
+      end
+
+      def ==(v)
+        eql?(v)
+      end
+
+      def hash
+        self.to_name.hash
+      end
+    end
+  end
+end
+