furnace-avm2 0.0.9 → 0.9.0

data/lib/furnace-avm2/transform/cfg_reduce.rb

@@ -0,0 +1,249 @@
+module Furnace::AVM2
+  module Transform
+    class CFGReduce
+      def transform(cfg)
+        @cfg   = cfg
+
+        @dom   = @cfg.dominators
+        @loops = @cfg.identify_loops
+
+        @visited       = Set.new
+        @loop_tails    = {}
+        @loop_nonlocal = Set.new
+
+        ast, = extended_block(@cfg.entry)
+
+        ast
+      end
+
+      def extended_block(block, stopgap=nil, loop_stack=[])
+        nodes = []
+
+        while block
+          if @loops.include?(block) && loop_stack.include?(block)
+            # We have just arrived to loop head. Insert `continue'
+            # and exit.
+            check_nonlocal_loop(loop_stack, block) do |params|
+              nodes << AST::Node.new(:continue, params)
+            end
+            break
+          elsif @loop_tails.include?(block) &&
+                    loop_stack.include?(@loop_tails[block])
+            # We have just arrived to loop tail. Insert `break'
+            # and exit.
+            loop = @loop_tails[block]
+            check_nonlocal_loop(loop_stack, loop) do |params|
+              nodes << AST::Node.new(:break, params)
+            end
+            break
+          elsif block == stopgap
+            # We have just arrived to a merge point of `if'
+            # contidional. Exit.
+            break
+          end
+
+          if @visited.include? block
+            raise "failsafe: block #{block.label} already visited"
+          elsif block != @cfg.exit
+            @visited.add block
+          end
+
+          block.insns.each do |insn|
+            next if insn == block.cti
+            nodes << insn
+          end
+
+          if block.cti
+            if @loops.include?(block)
+              # we're trapped in a strange loop
+              reverse = !block.cti.children[0]
+              in_root, out_root = block.targets
+
+              # One of the branch targets should reside within
+              # the loop.
+              if !@loops[block].include?(in_root)
+                in_root, out_root = out_root, in_root
+                reverse = !reverse
+              end
+
+              # Mark the loop tail so we could detect `break' and
+              # `continue' statements.
+              @loop_tails[out_root] = block
+
+              # If we reversed the roots or it was a (jump-if false),
+              # then reverse the condition.
+              expr = normalize_cti_expr(block, reverse)
+
+              body = extended_block(in_root, nil, [ block, *loop_stack ])
+
+              # [(label name)]
+              # We first parse the body and then add the label before
+              # the loop body if anything in the body requires that label
+              # to be present.
+              if @loop_nonlocal.include?(block)
+                nodes << AST::Node.new(:label, [ loop_label(block) ])
+              end
+
+              # (while (condition)
+              #   (body ...))
+              # (for-in '(var name) # to be done
+              #   (body ...))
+              nodes << AST::Node.new(:while, [
+                expr,
+                body
+              ])
+
+              block = out_root
+            else
+              # this is an `if', `break' or `continue'
+              reverse = !block.cti.children[0]
+              left_root, right_root = block.targets
+
+              # (if (condition)
+              #   (if-true ...)
+              #  [(if-false ...)])
+              # Note that you cannot reach expression if-true nor
+              # expression if-false without evaluating condition.
+              # Thus, to go inside the if body, a root has to be
+              # completely dominated by this block--that is, does
+              # not have edges coming to it even from other blocks
+              # dominated by this block.
+
+              # If the left root isn't dominated by block,
+              # then it can't be `if' branch.
+              if !completely_dominated?(left_root, block)
+                left_root, right_root = right_root, left_root
+                reverse = !reverse
+              end
+
+              # If the left root still isn't dominated by block,
+              # then this is not a proper conditional.
+              unless completely_dominated?(left_root, block)
+                raise "not-well-formed if"
+              end
+
+              # If the right root is dominated by this block, which
+              # means that we have an `else' part, and if the condition
+              # is reversed, turn that back. This serves purely aesthetical
+              # purposes and depends on behavior of ASC code generator.
+              if completely_dominated?(right_root, block) && reverse
+                left_root, right_root = right_root, left_root
+                reverse = false
+              end
+
+              # If we reversed the roots or it was a (jump-if false),
+              # then reverse the condition.
+              expr = normalize_cti_expr(block, reverse)
+
+              # Does this conditional have an `else' block?
+              if completely_dominated?(right_root, block)
+                # Yes. Find a merge point.
+                merge = find_merge_point(block, left_root, right_root, loop_stack)
+
+                # If the merge search did not yield a valid node, use
+                # stopgap for the current block to avoid runaway code
+                # synthesis.
+                #
+                # The stopgap block is actually an innermost block from
+                # a stopgap block set implicitly represented by a set of
+                # objects contained in arguments of recursive calls. As
+                # the `if's are fully nested when well-formed, we can only
+                # check for collision with innermost stopgap block.
+                nodes << AST::Node.new(:if, [
+                  expr,
+                  extended_block(left_root,  merge || stopgap, loop_stack),
+                  extended_block(right_root, merge || stopgap, loop_stack)
+                ])
+
+                block = merge
+              else
+                # No. The "right root" is actually post-if code.
+                nodes << AST::Node.new(:if, [
+                  expr,
+                  extended_block(left_root, right_root, loop_stack)
+                ])
+
+                block = right_root
+              end
+            end
+          elsif block.targets.count == 1
+            block = block.targets.first
+          elsif block == @cfg.exit
+            break
+          else
+            raise "invalid target count (#{block.targets.count})"
+          end
+        end
+
+        AST::Node.new(:begin, nodes)
+      end
+
+      # Block B is completely dominated by another block D if
+      # it is dominated by D and no edges ever lead to block B
+      # from any other block, including those dominated by D,
+      # but excluding any back edges.
+      def completely_dominated?(block, dominator)
+        if @loops.include?(block)
+          (block.sources - @loops[block].to_a) == [dominator]
+        else
+          block.sources == [dominator]
+        end
+      end
+
+      # A merge point for blocks R (root), L (left) and D (right)
+      # is first block found with BFS starting at {L,D} so that
+      # it is dominated by R, but not L or D.
+      def find_merge_point(root, left, right, loop_stack)
+        worklist = Set[left, right]
+        visited  = Set[root, left, right]
+
+        while worklist.any?
+          node = worklist.first
+          worklist.delete node
+
+          visited.add node
+
+          if (@dom[node].include?(root) &&
+              !(@dom[node].include?(left) ||
+                @dom[node].include?(right))) ||
+              loop_stack.include?(node)
+            return node
+          end
+
+          node.targets.each do |target|
+            next if visited.include? target
+            worklist.add target
+          end
+        end
+
+        # The paths have diverged.
+        nil
+      end
+
+      # Check if the control transfer is nonlocal according to the
+      # innermost loop and adjust @loop_nonlocal accordingly for labels
+      # to be inserted where appropriate.
+      def check_nonlocal_loop(loop_stack, block)
+        if loop_stack.first != block
+          @loop_nonlocal.add block
+
+          yield [loop_label(block)]
+        else
+          yield []
+        end
+      end
+
+      def loop_label(block)
+        "label#{block.label}"
+      end
+
+      def normalize_cti_expr(block, negate)
+        if negate
+          AST::Node.new(:!, [ block.cti.children[1] ])
+        else
+          block.cti.children[1]
+        end
+      end
+    end
+  end
+end

data/lib/furnace-avm2/transform/nf_normalize.rb

@@ -0,0 +1,130 @@
+module Furnace::AVM2
+  module Transform
+    class NFNormalize
+      include AST::Visitor
+
+      def transform(nf)
+        @nf = nf.normalize_hierarchy!
+
+        remove_useless_return
+        visit @nf
+
+        @nf
+      end
+
+      def remove_useless_return
+        if @nf.children.last.type == :return_void
+          @nf.children.slice! -1
+        end
+      end
+
+      COERCE_MAP = {
+        :coerce_a => :any,
+        :coerce_b => :bool,
+        :coerce_s => :string,
+      }
+
+      def on_coerce_imm(node)
+        expr, = node.children
+        node.update(:coerce, [
+          COERCE_MAP[node.type],
+          expr
+        ])
+      end
+      alias :on_coerce_a :on_coerce_imm
+      alias :on_coerce_b :on_coerce_imm
+      alias :on_coerce_s :on_coerce_imm
+
+      CONVERT_MAP = {
+        :convert_i => :integer,
+        :convert_u => :unsigned,
+        :convert_d => :double,
+        :convert_s => :string,
+        :convert_o => :object,
+      }
+
+      def on_convert_imm(node)
+        expr, = node.children
+        node.update(:convert, [
+          CONVERT_MAP[node.type],
+          expr
+        ])
+      end
+      alias :on_convert_i :on_convert_imm
+      alias :on_convert_u :on_convert_imm
+      alias :on_convert_d :on_convert_imm
+      alias :on_convert_s :on_convert_imm
+      alias :on_convert_o :on_convert_imm
+
+      ForInMatcher = AST::Matcher.new do
+        [:while,
+          [:has_next2, capture(:object_reg), capture(:index_reg)],
+          [:begin,
+            [:set_local, capture(:value_reg),
+              [either[:coerce, :convert], capture(:value_type),
+                [capture(:iterator),
+                  [:get_local, backref(:object_reg)],
+                  [:get_local, backref(:index_reg)]]]],
+            capture_rest(:body)]]
+      end
+
+      ForInIndexMatcher = AST::Matcher.new do
+        [:set_local, backref(:index_reg), [:integer, 0]]
+      end
+
+      ForInObjectMatcher = AST::Matcher.new do
+        [:set_local, backref(:object_reg),
+          [:coerce, :any,
+            capture(:root)]]
+      end
+
+      SuperfluousContinueMatcher = AST::Matcher.new do
+        [:continue]
+      end
+
+      def on_while(node)
+        if captures = ForInMatcher.match(node)
+          parent = node.parent
+
+          case captures[:iterator]
+          when :next_name
+            type = :for_in
+          when :next_value
+            type = :for_each_in
+          else
+            return
+          end
+
+          index_node = object_node = nil
+
+          loop_index = parent.children.index(node)
+          parent.children[0..loop_index].reverse_each do |parent_node|
+            if ForInIndexMatcher.match(parent_node, captures)
+              index_node  = parent_node
+            elsif ForInObjectMatcher.match(parent_node, captures)
+              object_node = parent_node
+            end
+
+            break if index_node && object_node
+          end
+
+          return unless index_node && object_node
+
+          index_node.update(:remove)
+          object_node.update(:remove)
+
+          if SuperfluousContinueMatcher.match captures[:body].last
+            captures[:body].slice! -1
+          end
+
+          node.update(type, [
+            captures[:value_reg],
+            captures[:value_type],
+            captures[:object_reg],
+            AST::Node.new(:begin, captures[:body])
+          ])
+        end
+      end
+    end
+  end
+end

data/lib/furnace-avm2/version.rb

@@ -1,3 +1,5 @@
-module Furnace::AVM2
-  VERSION = "0.0.9"
+module Furnace
+  module AVM2
+    VERSION = "0.9.0"
+  end
 end

data/test/basic.as

@@ -0,0 +1,239 @@
+package test {
+  class Literal {
+    function test() {
+      call(1, 1, 200, 200, -1, -50, 32767, 32768, -32760, -500000);
+    }
+  }
+
+  class Arithmetics {
+    function b() {
+      var a:int = 0;
+      var b:int;
+      b = (a += 1);
+      return (b -= (a += 1));
+    }
+
+    function a() {
+      var a:int = 0;
+      var b:int = ++a;
+      var c:int = a++;
+      return a;
+    }
+  }
+
+  class Logic {
+    function P_a_or_b_p_and_P_c_and_d_p_or_e(a: Boolean, b:Boolean, c:Boolean, d:Boolean, e:Boolean) : Boolean {
+      var v:Boolean = (a || b) && (c && d) || e;
+      away();
+      return v;
+    }
+
+    function a_or_b(a: Boolean, b:Boolean, c:Boolean, d:Boolean, e:Boolean) : Boolean {
+      if(a || b) {
+        yes();
+      } else {
+        no();
+      }
+    }
+
+    function a_and_b_and_c(a: Boolean, b:Boolean, c:Boolean, d:Boolean, e:Boolean) : Boolean {
+      return a && (b && c);
+    }
+
+    function P_a_and_b_p_and_c(a: Boolean, b:Boolean, c:Boolean, d:Boolean, e:Boolean) : Boolean {
+      return (a && b) && c;
+    }
+
+    function a_and_b(a: Boolean, b:Boolean, c:Boolean, d:Boolean, e:Boolean) : Boolean {
+      return a && b;
+    }
+  }
+
+  class Ternary {
+    function hardcore(a: Boolean, b:Boolean, c:Boolean, d:Boolean, e:Boolean) : Boolean {
+      if(((a && b) ? (c || d) && e : b) && (a || b)) {
+        return pow();
+      } else {
+        weeee();
+      }
+      duh();
+    }
+    function q(a: Boolean, b:Boolean, c:Boolean, d:Boolean, e:Boolean) : Boolean {
+      return ((a ? b : c) ? (b ? c : d) : (c ? d : e));
+    }
+    function a_I_b_E_c_I_d_E_e(a: Boolean, b:Boolean, c:Boolean, d:Boolean, e:Boolean) : Boolean {
+      return a ? b : (c ? d : e);
+    }
+    function a_I_b_I_c_E_d_E_e(a: Boolean, b:Boolean, c:Boolean, d:Boolean, e:Boolean) : Boolean {
+      return a ? (b ? c : d) : e;
+    }
+    function a_I_b_E_c(a: Boolean, b:Boolean, c:Boolean, d:Boolean, e:Boolean) : Boolean {
+      return (1 > 2) ? b : c;
+    }
+  }
+
+  class Conditionals {
+    function els(param1:Object, param2:String, param3:String) : Boolean {
+      var _loc_4:Object = null;
+      if (param1 != null)
+      {
+          _loc_4 = param1[param2];
+          if (_loc_4 != null)
+          {
+              if (_loc_4[param3] != null)
+              {
+                  return true;
+              }
+              a();
+          }
+          b();
+      }
+      heys();
+      return false;
+    }
+
+    function els2(param1:Object, param2:String, param3:String) : Boolean {
+      var _loc_4:Object = null;
+      if (param1 != null)
+      {
+          _loc_4 = param1[param2];
+          if (_loc_4 != null)
+          {
+              if (_loc_4[param3] != null)
+              {
+                  return true;
+              }
+          }
+      }
+      heys();
+      return false;
+    }
+
+    function b(a:Boolean) {
+      if(a)
+        return foo();
+      else
+        return 1;
+    }
+
+    function q(a:Boolean, b:Boolean) {
+      if(b) {
+        if(a) {
+          foo();
+        }
+      }
+      baz();
+    }
+
+    function a(a:Boolean) {
+      baz();
+      if(a) {
+        foge();
+      } else {
+        huga();
+      }
+      piyo();
+    }
+
+    function nested(a:Boolean, b:Boolean) {
+      if(a) {
+        foo();
+      } else {
+        if(b) {
+          bar();
+        } else {
+          baz();
+        }
+      }
+    }
+  }
+
+  class Loops {
+    function e(f:Boolean) {
+      do { f = tttest();
+      } while(f);
+    }
+
+    function d() {
+      while(true) {
+        pow();
+        if(frak()) { a(); break; b(); }
+        weee();
+      }
+    }
+
+    function b() {
+      weee();
+      for(var q:int = 1; q > 0; q++) {
+        frak();
+      }
+    }
+  }
+
+  class Switch {
+    function proper_switch(q:int):Boolean {
+      switch(q) {
+      case 0x10:
+        hoge();
+        break;
+      case "test":
+        fuga();
+        break;
+      case 0x30:
+        piyo();
+        break;
+      case 0x40:
+        fuck();
+        break;
+      }
+      return false;
+    }
+
+    function improper_switch(q:int):Boolean {
+      switch(q) {
+      case 0x10:
+        hoge();
+      case 0x20:
+        fuga();
+      break;
+      case 0x30:
+        piyo();
+      break;
+      default:
+        baz();
+      break;
+      }
+      return false;
+    }
+  }
+
+  class Exceptions {
+    function c() {
+      try {
+        hoge();
+      } finally {
+        piyo();
+      }
+    }
+    function b() {
+      try {
+        hoge();
+        throw 1;
+        fuga();
+      } catch(e: SecurityError) {
+        piyo(e);
+      }
+    }
+    function a() {
+      try {
+        hoge();
+        throw 1;
+        fuga();
+      } catch(e: SecurityError) {
+        piyo(e);
+      } catch(e: Error) {
+        throw e;
+      }
+    }
+  }
+}