furnace-avm2 0.9.2 → 1.0.0

data/lib/furnace-avm2/source/implementation_tokens/case_token.rb

@@ -0,0 +1,20 @@
+module Furnace::AVM2::Tokens
+  class CaseToken < Furnace::Code::SurroundedToken
+    def initialize(origin, value, options)
+      super(origin, [ value ], options)
+      @value = value
+    end
+
+    def text_before
+      if @value
+        "case "
+      else
+        "default"
+      end
+    end
+
+    def text_after
+      ":\n"
+    end
+  end
+end

data/lib/furnace-avm2/source/implementation_tokens/catch_filter_token.rb

@@ -0,0 +1,7 @@
+module Furnace::AVM2::Tokens
+  class CatchFilterToken < Furnace::Code::SeparatedToken
+    def text_between
+      ": "
+    end
+  end
+end

data/lib/furnace-avm2/source/implementation_tokens/catch_token.rb

@@ -0,0 +1,9 @@
+require_relative 'control_flow_token'
+
+module Furnace::AVM2::Tokens
+  class CatchToken < ControlFlowToken
+    def keyword
+      "catch"
+    end
+  end
+end

data/lib/furnace-avm2/source/implementation_tokens/closure_token.rb

@@ -1,5 +1,7 @@
 module Furnace::AVM2::Tokens
   class ClosureToken < CalleeToken
+  	include IsComplex
+
     def initialize(origin, body, options={})
       super(origin, [
         ClosureNameToken.new(origin, options)

data/lib/furnace-avm2/source/implementation_tokens/control_flow_token.rb

@@ -1,6 +1,5 @@
 module Furnace::AVM2::Tokens
   class ControlFlowToken < Furnace::Code::NonterminalToken
-
     def initialize(origin, condition, body, options={})
       super(origin, [condition, body], options)
       @condition, @body = condition, body

data/lib/furnace-avm2/source/implementation_tokens/do_while_token.rb

@@ -0,0 +1,16 @@
+module Furnace::AVM2::Tokens
+  class DoWhileToken < Furnace::Code::NonterminalToken
+    def initialize(origin, body, condition, options={})
+      super(origin, [body, condition], options)
+      @condition, @body = condition, body
+    end
+
+    def to_text
+      "do #{@body.to_text}while(#{@condition.to_text});\n"
+    end
+
+    def to_structure(options={})
+      structurize "do ... while(...)", options
+    end
+  end
+end

data/lib/furnace-avm2/source/implementation_tokens/else_token.rb

@@ -10,8 +10,10 @@ module Furnace::AVM2::Tokens
       header = "else"
       if @body.is_a? ScopeToken
         "#{header} #{@body.to_text}"
-      else
+      elsif @body
         "#{header}\n#{indent @body.to_text}"
+      else
+        "#{header} "
       end
     end
 

data/lib/furnace-avm2/source/implementation_tokens/finally_token.rb

@@ -0,0 +1,11 @@
+module Furnace::AVM2::Tokens
+  class FinallyToken < Furnace::Code::SeparatedToken
+  	def initialize(origin, body, options={})
+      super(origin, [ body ], options)
+    end
+
+    def text_before
+      "finally "
+    end
+  end
+end

data/lib/furnace-avm2/source/implementation_tokens/label_name_token.rb

@@ -0,0 +1,12 @@
+module Furnace::AVM2::Tokens
+  class LabelNameToken < Furnace::Code::TerminalToken
+    def initialize(origin, name, options={})
+      super(origin, options)
+      @name = name
+    end
+
+    def to_text
+      @name
+    end
+  end
+end

data/lib/furnace-avm2/source/implementation_tokens/this_token.rb

@@ -0,0 +1,9 @@
+module Furnace::AVM2::Tokens
+  class ThisToken < Furnace::Code::TerminalToken
+    include IsSimple
+
+    def to_text
+      "this"
+    end
+  end
+end

data/lib/furnace-avm2/source/implementation_tokens/try_token.rb

@@ -0,0 +1,11 @@
+module Furnace::AVM2::Tokens
+  class TryToken < Furnace::Code::SeparatedToken
+    def text_before
+      "try "
+    end
+
+    def text_between
+      " "
+    end
+  end
+end

data/lib/furnace-avm2/source/implementation_tokens/unary_operator_token.rb

@@ -2,8 +2,8 @@ module Furnace::AVM2::Tokens
   class UnaryOperatorToken < Furnace::Code::SurroundedToken
     include IsSimple
 
-    def initialize(origin, children, operator, options={})
-      super(origin, children, options)
+    def initialize(origin, child, operator, options={})
+      super(origin, [ child ], options)
       @operator = operator
     end
 

data/lib/furnace-avm2/source/implementation_tokens/unary_post_operator_token.rb

@@ -2,8 +2,8 @@ module Furnace::AVM2::Tokens
   class UnaryPostOperatorToken < Furnace::Code::SurroundedToken
     include IsSimple
 
-    def initialize(origin, children, operator, options={})
-      super(origin, children, options)
+    def initialize(origin, child, operator, options={})
+      super(origin, [ child ], options)
       @operator = operator
     end
 

data/lib/furnace-avm2/transform.rb

@@ -5,6 +5,8 @@ end
 
 require_relative "transform/ast_build"
 require_relative "transform/ast_normalize"
+require_relative "transform/propagate_labels"
+require_relative "transform/propagate_constants"
 require_relative "transform/cfg_build"
 require_relative "transform/cfg_reduce"
 require_relative "transform/nf_normalize"

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

@@ -7,7 +7,15 @@ module Furnace::AVM2
                                 :if_le,  :if_lt,    :if_ne,        :if_nge,       :if_ngt,
                                 :if_nle, :if_nlt,   :if_strict_eq, :if_strict_ne, :if_true ]
 
-      CONST_OPERATORS = [ :integer, :double, :string, :false, :true, :nan, :undefined, :null ]
+      PURE_OPERATORS = [ :integer, :double, :string, :false, :true, :nan, :undefined, :null,
+                         :find_property_strict ]
+
+      PRE_POST_OPERATORS = [ :increment, :increment_i, :decrement, :decrement_i ]
+
+      SHORT_ASSIGN_OPERATORS = [ :add, :add_i, :subtract, :subtract_i, :multiply, :multiply_i,
+                                 :divide, :modulo,
+                                 :set_local, :set_local_0, :set_local_1, :set_local_2, :set_local_3,
+                                 :new_catch, :new_activation ]
 
       def initialize(options)
         @validate = options[:validate] || false
@@ -16,94 +24,196 @@ module Furnace::AVM2
         #@verbose = true
       end
 
-      def transform(code, method)
-        stack = []
-        ast   = AST::Node.new(:root)
+      def consume(count)
+        if count == 0
+          []
+        elsif count <= @stack.size
+          @stack.slice!(-count..-1)
+        else
+          raise "cannot consume #{count}: stack underflow with #{@stack.size}"
+        end
+      end
 
-        dup         = nil
-        spurious    = 0
+      def produce(what)
+        @stack.push what
+      end
 
-        in_shortcut = false
-        shortjump   = []
-        ternary     = []
+      def emit(node)
+        if @verbose
+          puts "emitted:"
+          puts node.to_sexp(1)
+        end
 
-        consume = lambda do |count|
-          if count == 0
-            []
-          elsif count <= stack.size
-            stack.slice!(-count..-1)
-          else
-            raise "cannot consume #{count}: stack underflow with #{stack.size}"
+        @ast.children.push node
+      end
+
+      def unemit
+        @ast.children.delete(-1)
+      end
+
+      def extend_complex_expr(valid_types, expected_depth=nil)
+        expr, current = consume(2)
+
+        if @validate
+          if !valid_types.include?(expr.type)
+            raise "invalid complex expr: #{expr.type} not in #{valid_types}"
+          elsif expected_depth && expr.children.count != expected_depth
+            raise "invalid complex expr: depth #{expr.children.count} != #{expected_depth}"
           end
         end
 
-        produce = lambda do |what|
-          stack.push what
-        end
+        expr.children << current
+        produce(expr)
+      end
 
-        emit = lambda do |node|
-          if @verbose
-            puts "emitted:"
-            puts node.to_sexp(1)
+      def finalize_complex_expr(opcode, worklist, valid_types, expected_depth=nil, wrap_to=nil)
+        while worklist.last == opcode.offset
+          extend_complex_expr(valid_types, expected_depth)
+
+          if wrap_to
+            node, *prepend = *wrap_to
+
+            expr, = consume(1)
+            expr = AST::Node.new(node, [*prepend, expr])
+            produce(expr)
           end
 
-          ast.children.push node
+          worklist.pop
         end
+      end
 
-        extend_complex_expr = lambda do |valid_types, expected_depth=nil|
-          expr, current = consume.(2)
+      def expand_conditionals
+        expressions = []
 
-          if @validate
-            if !valid_types.include?(expr.type)
-              raise "invalid complex expr: #{expr.type} not in #{valid_types}"
-            elsif expected_depth && expr.children.count != expected_depth
-              raise "invalid complex expr: depth #{expr.children.count} != #{expected_depth}"
-            end
-          end
+        while @stack.any? && CONDITIONAL_OPERATORS.include?(@stack.last.type)
+          conditional, = consume(1)
+
+          jump_node = AST::Node.new(:jump_if, [
+            true,
+            conditional.metadata[:offset],
+            conditional
+          ], label: conditional.metadata[:label])
+
+          expressions.unshift jump_node
+        end
 
-          expr.children << current
-          produce.(expr)
+        expressions.each do |expr|
+          emit(expr)
         end
+      end
 
-        finalize_complex_expr = lambda do |opcode, worklist, valid_types, expected_depth=nil, wrap_to=nil|
-          while worklist.last == opcode.offset
-            extend_complex_expr.(valid_types, expected_depth)
+      LocalIncDecInnerMatcher = AST::Matcher.new do
+        [ either[*PRE_POST_OPERATORS],
+          either[
+            [:convert, any,
+              [:get_local, any]],
+            [:get_local, any],
+          ]
+        ]
+      end
 
-            if wrap_to
-              node, *prepend = *wrap_to
+      def transform(code, body)
+        @stack = []
+        @ast   = AST::Node.new(:root)
 
-              expr, = consume.(1)
-              expr = AST::Node.new(node, [*prepend, expr])
-              produce.(expr)
-            end
+        dup         = nil
+        spurious    = 0
 
-            worklist.pop
-          end
-        end
+        in_shortcut = false
+        shortjump   = []
+        ternary     = []
 
-        expand_conditionals = lambda do
-          expressions = []
+        current_handler = nil
+        current_finally = nil
+
+        finallies   = {}
+        body.exceptions.each_with_index do |exception, index|
+          first, second = exception, body.exceptions[index + 1]
+          next unless second
+
+          if first.from_offset == second.from_offset &&
+                second.to_offset > first.to_offset &&
+                first.target_offset > second.from_offset &&
+                first.target_offset < second.to_offset &&
+                first.to.is_a?(ABC::AS3Jump) &&
+                first.to.target.is_a?(ABC::AS3PushByte)
+            entry    = first.to.target.next.target
+            epilogue = nil
+
+            cursor = entry.next
+            while cursor
+              if cursor.is_a?(ABC::AS3LookupSwitch) &&
+                    cursor.body.default_offset == 8 &&
+                    cursor.body.case_count == 0
+                epilogue = cursor
+                break
+              end
 
-          while stack.any? && CONDITIONAL_OPERATORS.include?(stack.last.type)
-            conditional, = consume.(1)
+              cursor = cursor.next
+            end
 
-            jump_node = AST::Node.new(:jump_if, [ true, conditional.metadata[:offset], conditional ])
-            expressions.unshift jump_node
+            raise "cannot find finally epilogue" if epilogue.nil?
+
+            finallies[first.to_offset] = {
+              first_catch:      first,
+              second_catch:     second,
+              skip_intervals:   [ first.target_offset...second.target_offset,
+                                  (second.target_offset + 4)...entry.offset ],
+              begin_offset:     first.to.offset,
+              entry_offset:     entry.offset,
+              epilogue_offset:  epilogue.offset,
+              end_offset:       epilogue.offset + epilogue.byte_length,
+            }
           end
+        end
 
-          ast.children.concat expressions
+        exceptions  = {}
+        body.exceptions.each_with_index do |exception, index|
+          next if finallies.find { |k,f| f[:first_catch] == exception }
+          exceptions[exception.target_offset] = exception
         end
 
         code.each do |opcode|
           if @verbose
             puts "================================"
-            puts "stack: #{stack.inspect}"
+            puts "stack: #{@stack.inspect}"
             puts "shortjump: #{shortjump.inspect} ternary: #{ternary.inspect}"
             puts "opcode: #{opcode.inspect}"
           end
 
-          finalize_complex_expr.(opcode, ternary, CONDITIONAL_OPERATORS, nil, [:ternary_if, false])
-          finalize_complex_expr.(opcode, shortjump, [ :and, :or ], 1)
+          finalize_complex_expr(opcode, ternary, CONDITIONAL_OPERATORS, nil, [:ternary_if, false])
+          finalize_complex_expr(opcode, shortjump, [ :and, :or ], 1)
+
+          if finallies.has_key? opcode.offset
+            current_finally = finallies[opcode.offset]
+          end
+
+          if current_finally
+            if current_finally[:begin_offset] == opcode.offset
+              puts "FINALLY: begin" if @verbose
+              emit(AST::Node.new(:jump, [ current_finally[:end_offset] ], label: opcode.offset))
+              next
+            elsif current_finally[:skip_intervals].find { |si| si.include? opcode.offset }
+              puts "FINALLY: skip" if @verbose
+              next
+            elsif current_finally[:epilogue_offset] == opcode.offset
+              puts "FINALLY: epilogue" if @verbose
+              emit(AST::Node.new(:nop, [], label: opcode.offset))
+              @stack.clear
+              next
+            end
+          end
+
+          if exceptions.has_key? opcode.offset
+            exception = exceptions[opcode.offset]
+
+            current_handler  = exception
+            if exception.variable
+              produce(AST::Node.new(:exception_variable, [ exception.variable.to_astlet ]))
+            else
+              produce(AST::Node.new(:exception_variable))
+            end
+          end
 
           if dup == 1 && (opcode.is_a?(ABC::AS3CoerceB) ||
                   opcode.is_a?(ABC::AS3IfTrue) || opcode.is_a?(ABC::AS3IfFalse))
@@ -129,21 +239,21 @@ module Furnace::AVM2
             end
 
             node = AST::Node.new(type, [], label: opcode.offset)
-            node.children = consume.(1)
-            produce.(node)
+            node.children = consume(1)
+            produce(node)
 
             shortjump.push opcode.target_offset
           elsif opcode.is_a?(ABC::AS3Swap)
-            first, second = stack.pop, stack.pop
-            stack.push first, second
+            first, second = @stack.pop, @stack.pop
+            @stack.push first, second
           elsif opcode.is_a?(ABC::AS3Dup)
-            node = stack.last
+            node = @stack.last
 
-            if CONST_OPERATORS.include?(node.type) ||
+            if PURE_OPERATORS.include?(node.type) ||
                   (node.type == :get_local && node.children.first == 0)
               dup_node = node.dup
               dup_node.metadata[:label] = opcode.offset
-              produce.(dup_node)
+              produce(dup_node)
             else
               dup ||= 0
               dup  += 1
@@ -151,44 +261,68 @@ module Furnace::AVM2
           elsif opcode.is_a?(ABC::AS3Jump)
             if opcode.body.jump_offset == 0
               node = AST::Node.new(:nop, [], label: opcode.offset)
-              emit.(node)
-            elsif stack.any? && !CONDITIONAL_OPERATORS.include?(stack.last.type)
-              extend_complex_expr.(CONDITIONAL_OPERATORS)
+              emit(node)
+            elsif opcode.target.is_a? ABC::AS3Throw
+              node = AST::Node.new(:throw, [ consume(1) ], label: opcode.offset)
+              emit(node)
+            elsif @stack.any? && !CONDITIONAL_OPERATORS.include?(@stack.last.type)
+              extend_complex_expr(CONDITIONAL_OPERATORS)
 
               ternary.push opcode.target_offset
             else
-              expand_conditionals.()
+              expand_conditionals()
 
               node = AST::Node.new(opcode.ast_type, opcode.parameters, label: opcode.offset)
-              emit.(node)
+              emit(node)
             end
           elsif opcode.is_a?(ABC::ControlTransferOpcode)
             node = AST::Node.new(opcode.ast_type, [], label: opcode.offset)
             node.metadata[:offset] = opcode.target_offset
-            node.children = consume.(opcode.consumes)
-            produce.(node)
-          elsif opcode.is_a?(ABC::AS3Kill)
-            # Ignore. SSA will handle that.
+            node.children = consume(opcode.consumes)
+            produce(node)
           else
+            node = AST::Node.new(opcode.ast_type, [], label: opcode.offset)
+
+            if dup == 1
+              top_opcode, = consume(1)
+              found = true
+
+              if PRE_POST_OPERATORS.include?(top_opcode.type)
+                top_opcode.update(:"pre_#{top_opcode.type}")
+              elsif PRE_POST_OPERATORS.include?(node.type)
+                node.update(:"post_#{node.type}")
+              elsif SHORT_ASSIGN_OPERATORS.include? top_opcode.type
+                # just push it through
+              else
+                found = false
+              end
+
+              if found
+                produce(AST::Node.new(:unemit))
+                dup = false
+              end
+
+              produce(top_opcode)
+            end
+
             if dup
               spurious += 1
 
-              save_node = AST::Node.new(:set_local, [ -spurious, *consume.(1) ])
-              emit.(save_node)
+              save_node = AST::Node.new(:set_local, [ -spurious, *consume(1) ])
+              expand_conditionals()
+              emit(save_node)
 
               (1 + dup).times do
                 load_node = AST::Node.new(:get_local, [ -spurious ])
-                produce.(load_node)
+                produce(load_node)
               end
 
               dup = false
             end
 
-            node = AST::Node.new(opcode.ast_type, [], label: opcode.offset)
-
-            parameters = consume.(opcode.consumes)
+            parameters = consume(opcode.consumes)
             if opcode.consumes_context
-              context = opcode.context(consume.(opcode.consumes_context))
+              context = opcode.context(consume(opcode.consumes_context))
             end
 
             node.children.concat context if context
@@ -198,23 +332,31 @@ module Furnace::AVM2
             # All opcodes which produce 2 results--that is, dup and swap--
             # are already handled at the top.
             if opcode.produces == 0
-              expand_conditionals.()
-              emit.(node)
+              # This was a fallthrough assignment.
+              if @stack.any? && @stack.last.type == :unemit
+                consume(1) # dump unemit
+                produce(node)
+                next
+              end
+
+              expand_conditionals()
+
+              # Spec does not require stack to be empty upon encountering return.
+              # If there's something left, it should have been here.
+              if opcode.is_a? ABC::FunctionReturnOpcode
+                while @stack.any?
+                  emit(*consume(1))
+                end
+              end
+
+              emit(node)
             elsif opcode.produces == 1
-              produce.(node)
+              produce(node)
             end
           end
         end
 
-        if @validate
-          extracted_opcodes = []
-          extract = lambda do |tree|
-            extracted_opcodes.push tree.metadata[:label]
-            tree.select { |c| c.is_a? Node }.each { |c| extract.(c) }
-          end
-        end
-
-        ast.normalize_hierarchy!
+        [ @ast.normalize_hierarchy!, body, finallies.values ]
       end
     end
   end