furnace-avm2 0.9.2 → 1.0.0

data/lib/furnace-avm2/abc/opcodes/arithmetic/as3_multiply.rb

@@ -1,5 +1,5 @@
 module Furnace::AVM2::ABC
-  class AS3Multiply < Opcode
+  class AS3Multiply < ArithmeticOpcode
     instruction 0xa2
 
     consume 2

data/lib/furnace-avm2/abc/opcodes/arithmetic/as3_multiply_i.rb

@@ -1,10 +1,11 @@
 module Furnace::AVM2::ABC
-  class AS3MultiplyI < Opcode
+  class AS3MultiplyI < ArithmeticOpcode
     instruction 0xc7
 
     consume 2
     produce 1
 
     type :integer
+    ast_type :multiply
   end
 end

data/lib/furnace-avm2/abc/opcodes/arithmetic/as3_negate.rb

@@ -1,5 +1,5 @@
 module Furnace::AVM2::ABC
-  class AS3Negate < Opcode
+  class AS3Negate < ArithmeticOpcode
     instruction 0x90
 
     consume 1

data/lib/furnace-avm2/abc/opcodes/arithmetic/as3_negate_i.rb

@@ -1,10 +1,11 @@
 module Furnace::AVM2::ABC
-  class AS3NegateI < Opcode
+  class AS3NegateI < ArithmeticOpcode
     instruction 0xc4
 
     consume 1
     produce 1
 
     type :integer
+    ast_type :negate
   end
 end

data/lib/furnace-avm2/abc/opcodes/arithmetic/as3_not.rb

@@ -1,5 +1,5 @@
 module Furnace::AVM2::ABC
-  class AS3Not < Opcode
+  class AS3Not < ArithmeticOpcode
     instruction 0x96
     ast_type :!
 

data/lib/furnace-avm2/abc/opcodes/arithmetic/as3_strictequals.rb

@@ -1,5 +1,5 @@
 module Furnace::AVM2::ABC
-  class AS3StrictEquals < Opcode
+  class AS3StrictEquals < ArithmeticOpcode
     instruction 0xac
     ast_type :===
 

data/lib/furnace-avm2/abc/opcodes/arithmetic/as3_subtract.rb

@@ -1,5 +1,5 @@
 module Furnace::AVM2::ABC
-  class AS3Subtract < Opcode
+  class AS3Subtract < ArithmeticOpcode
     instruction 0xa1
 
     consume 2

data/lib/furnace-avm2/abc/opcodes/arithmetic/as3_subtract_i.rb

@@ -1,10 +1,11 @@
 module Furnace::AVM2::ABC
-  class AS3SubtractI < Opcode
+  class AS3SubtractI < ArithmeticOpcode
     instruction 0xc6
 
     consume 2
     produce 1
 
     type :integer
+    ast_type :subtract
   end
 end

data/lib/furnace-avm2/abc/opcodes/arithmetic_opcode.rb

@@ -0,0 +1,5 @@
+module Furnace::AVM2::ABC
+  class ArithmeticOpcode < Opcode
+  	define_property :ast_type
+  end
+end

data/lib/furnace-avm2/abc/opcodes/function_return/as3_returnvalue.rb

@@ -1,5 +1,5 @@
 module Furnace::AVM2::ABC
-  class AS3ReturnValue < Opcode
+  class AS3ReturnValue < FunctionReturnOpcode
     instruction 0x48
 
     consume 1

data/lib/furnace-avm2/abc/opcodes/function_return/as3_returnvoid.rb

@@ -1,5 +1,5 @@
 module Furnace::AVM2::ABC
-  class AS3ReturnVoid < Opcode
+  class AS3ReturnVoid < FunctionReturnOpcode
     instruction 0x47
 
     consume 0

data/lib/furnace-avm2/abc/opcodes/function_return_opcode.rb

@@ -0,0 +1,4 @@
+module Furnace::AVM2::ABC
+  class FunctionReturnOpcode < Opcode
+  end
+ end

data/lib/furnace-avm2/abc/opcodes/opcode.rb

@@ -122,7 +122,7 @@ module Furnace::AVM2::ABC
     end
 
     def disassemble
-      "   #{offset.to_s.rjust(4, "0")}  #{self.class.mnemonic.rjust(20, " ")} #{disassemble_parameters} # params: #{parameters.inspect}"
+      "   #{offset.to_s.rjust(4, "0")}  #{self.class.mnemonic.rjust(20, " ")} #{disassemble_parameters}"
     end
     alias :inspect :disassemble
   end

data/lib/furnace-avm2/abc/opcodes/type_conversion/as3_coerce.rb

@@ -1,5 +1,5 @@
 module Furnace::AVM2::ABC
-  class AS3Coerce < Opcode
+  class AS3Coerce < TypeConversionOpcode
     instruction 0x80
 
     body do

data/lib/furnace-avm2/abc/opcodes/type_conversion/as3_coerce_a.rb

@@ -1,8 +1,11 @@
 module Furnace::AVM2::ABC
-  class AS3CoerceA < Opcode
+  class AS3CoerceA < TypeConversionOpcode
     instruction 0x82
 
     consume 1
     produce 1
+
+    ast_type :coerce
+    type     :any
   end
 end

data/lib/furnace-avm2/abc/opcodes/type_conversion/as3_coerce_b.rb

@@ -1,10 +1,11 @@
 module Furnace::AVM2::ABC
-  class AS3CoerceB < Opcode
+  class AS3CoerceB < TypeConversionOpcode
     instruction 0x76
 
     consume 1
     produce 1
 
-    type :boolean
+    ast_type :coerce
+    type     :boolean
   end
 end

data/lib/furnace-avm2/abc/opcodes/type_conversion/as3_coerce_s.rb

@@ -1,10 +1,11 @@
 module Furnace::AVM2::ABC
-  class AS3CoerceS < Opcode
+  class AS3CoerceS < TypeConversionOpcode
     instruction 0x85
 
     consume 1
     produce 1
 
-    type :string
+    ast_type :coerce
+    type     :string
   end
 end

data/lib/furnace-avm2/abc/opcodes/type_conversion/as3_convert_d.rb

@@ -1,10 +1,11 @@
 module Furnace::AVM2::ABC
-  class AS3ConvertD < Opcode
+  class AS3ConvertD < TypeConversionOpcode
     instruction 0x75
 
     consume 1
     produce 1
 
-    type :double
+    ast_type :convert
+    type     :double
   end
 end

data/lib/furnace-avm2/abc/opcodes/type_conversion/as3_convert_i.rb

@@ -1,10 +1,11 @@
 module Furnace::AVM2::ABC
-  class AS3ConvertI < Opcode
+  class AS3ConvertI < TypeConversionOpcode
     instruction 0x73
 
     consume 1
     produce 1
 
-    type :integer
+    ast_type :convert
+    type     :integer
   end
 end

data/lib/furnace-avm2/abc/opcodes/type_conversion/as3_convert_o.rb

@@ -1,10 +1,11 @@
 module Furnace::AVM2::ABC
-  class AS3ConvertO < Opcode
+  class AS3ConvertO < TypeConversionOpcode
     instruction 0x77
 
     consume 1
     produce 1
 
-    type :object
+    ast_type :convert
+    type     :object
   end
 end

data/lib/furnace-avm2/abc/opcodes/type_conversion/as3_convert_s.rb

@@ -1,10 +1,11 @@
 module Furnace::AVM2::ABC
-  class AS3ConvertS < Opcode
+  class AS3ConvertS < TypeConversionOpcode
     instruction 0x70
 
     consume 1
     produce 1
 
-    type :string
+    ast_type :convert
+    type     :string
   end
 end

data/lib/furnace-avm2/abc/opcodes/type_conversion/as3_convert_u.rb

@@ -1,10 +1,11 @@
 module Furnace::AVM2::ABC
-  class AS3ConvertU < Opcode
+  class AS3ConvertU < TypeConversionOpcode
     instruction 0x74
 
     consume 1
     produce 1
 
-    type :integer
+    ast_type :convert
+    type     :unsigned
   end
 end

data/lib/furnace-avm2/abc/opcodes/type_conversion_opcode.rb

@@ -0,0 +1,10 @@
+module Furnace::AVM2::ABC
+  class TypeConversionOpcode < Opcode
+    define_property :ast_type
+    define_property :type
+
+    def parameters
+      [ type ]
+    end
+  end
+end

data/lib/furnace-avm2/abc/primitives/opcode_sequence.rb

@@ -62,10 +62,14 @@ module Furnace::AVM2::ABC
     end
 
     def opcode_at(position)
+      parse if @raw_code
+
       @pos_cache[position]
     end
 
     def offset_of(opcode)
+      parse if @raw_code
+
       @opcode_cache[opcode]
     end
 

data/lib/furnace-avm2/abc/primitives/record.rb

@@ -37,7 +37,27 @@ module Furnace::AVM2::ABC
           elsif index = pool.index(value)
             send(:"#{field}=", index + 1)
           else
-            raise "cpool setter: no such object in cpool"
+            format_entry = ConstPoolInfo.format.find { |f| f[1] == array }
+            if format_entry.nil?
+              raise "cpool setter: [BUG] no such cpool field"
+            end
+
+            klass = nil
+            case format_entry[2][:type]
+            when :vstring; klass = String
+            when :nested;  klass = format_entry[2][:class]
+            end
+
+            if klass.nil?
+              raise "cpool setter: [BUG] no checker for type #{format_entry[2][:type]}"
+            end
+
+            if value.class != klass
+              raise "cpool setter: trying to set wrong kind of value (#{value.class} instead of #{klass})"
+            end
+
+            pool.push value
+            send(:"#{field}=", pool.index(value) + 1)
           end
         end
       end

data/lib/furnace-avm2/source/declaration_tokens/package_token.rb

@@ -11,19 +11,27 @@ module Furnace::AVM2::Tokens
           ns.name !~ /^[A-Za-z0-9_$.]+$/
       }
 
-      super(origin, [
-        (PackageNameToken.new(origin, options[:package_name].ns.name, options) if options[:package_name]),
-        ScopeToken.new(origin, [
+      case options[:package_type]
+      when :class, :interface
+        content = ClassToken.new(origin, options)
+      when :script
+        content = ScriptToken.new(origin, options)
+      end
+
+      scope = nil
+      if content.children.any?
+        scope = ScopeToken.new(origin, [
           *import_ns.map { |ns|
             ImportToken.new(origin, ns.name, options)
           },
           (Furnace::Code::NewlineToken.new(origin, options) if import_ns.any?),
-          (case options[:package_type]
-           when :class;     ClassToken.new(origin, options)
-           when :interface; ClassToken.new(origin, options)
-           when :script;    ScriptToken.new(origin, options)
-           end)
+          content
         ], options)
+      end
+
+      super(origin, [
+        (PackageNameToken.new(origin, options[:package_name].ns.name, options) if options[:package_name]),
+        scope,
       ], options)
     end
   end

data/lib/furnace-avm2/source/declaration_tokens/script_token.rb

@@ -12,6 +12,13 @@ module Furnace::AVM2::Tokens
         *transform_traits(origin, options.merge(static: false)),
         (global_code if global_code.children.any?)
       ], options)
+
+      if options[:debug_funids] && global_code.children.any?
+        @children.unshift \
+          CommentToken.new(origin,
+            "Function ##{origin.initializer_idx}",
+          options)
+      end
     end
   end
 end

data/lib/furnace-avm2/source/declaration_tokens/slot_token.rb

@@ -10,10 +10,18 @@ module Furnace::AVM2::Tokens
         ], options) if origin.type)
       ], options)
 
-      if origin.printable_value
-        @children << InitializationToken.new(origin, [
-          ImmediateToken.new(origin, origin.printable_value, options)
-        ], @options)
+      value = nil
+
+      if options[:property_values]
+        *, value = options[:property_values].find { |k,v| k == origin.name.to_astlet }
+      end
+
+      if value.nil? && origin.printable_value
+        value = ImmediateToken.new(origin, origin.printable_value, options)
+      end
+
+      if value
+        @children << InitializationToken.new(origin, [ value ], @options)
       end
     end
 

data/lib/furnace-avm2/source/declaration_tokens/token_with_traits.rb

@@ -7,21 +7,22 @@ module Furnace::AVM2::Tokens
         [:Class, :Slot, :Const].include? trait.kind
       end
 
+      if options[:environment] == :class && options[:static]
+        if origin.initializer_body
+          properties = Furnace::AVM2::Decompiler.new(
+                origin.initializer_body, options).decompose_static_initializer
+          options = options.merge(property_values: properties)
+        end
+      end
+
       tokens += vars.map { |trait| transform_trait trait, options }
 
       if tokens.any?
         tokens << Furnace::Code::NewlineToken.new(origin, options)
       end
 
-      if options[:environment] == :class
-        if options[:static]
-          tokens << CommentToken.new(origin, "Static initializer", options)
-          tokens << CommentToken.new(origin,
-            ConstructorToken.new(origin, options.merge(commented: true)),
-          options)
-        else
-          tokens << ConstructorToken.new(origin, options)
-        end
+      if options[:environment] == :class && !options[:static]
+        tokens << ConstructorToken.new(origin, options)
       end
 
       tokens += methods.map { |trait| transform_trait trait, options }

data/lib/furnace-avm2/source/decompiler.rb

@@ -17,55 +17,24 @@ module Furnace::AVM2
       @closure = @options.delete(:closure)
     end
 
-    ActivationPrologue = Matcher.new do
-      [:begin,
-        [:push_scope,
-          [:get_local, 0]],
-        [:set_local, -1,
-          [:new_activation]],
-        [:set_local, capture(:activation_local),
-          [:get_local, -1]],
-        [:push_scope,
-          [:get_local, -1]],
-        skip
-      ]
-    end
-
-    RegularPrologue = Matcher.new do
-      [:begin,
-        [:push_scope,
-          [:get_local, 0]],
-        skip
-      ]
-    end
-
     def decompile
       begin
         @locals = Set.new([0]) + (1..@method.param_count).to_a
         @scopes = []
+        @metascopes = []
 
-        @nf = @body.code_to_nf
-
-        if captures = ActivationPrologue.match(@nf)
-          @closure_slots = {}
-          @body.slot_traits.each do |trait|
-            @closure_slots[trait.idx] = trait
-          end
+        @catch_scopes = {}
 
-          @closure_locals = Set.new
+        @closure_locals = Set.new
 
-          @nf.children.slice! 0...4
-        else
-          if RegularPrologue.match @nf
-            @nf.children.slice! 0...1
-          else
-            # No prologue; probably a closure.
-          end
+        @closure_slots  = {}
+        @body.slot_traits.each do |trait|
+          @closure_slots[trait.idx] = trait
         end
 
-        @global_slots = @options[:global_slots]
+        @global_slots = @options[:global_slots] || {}
 
-        stmt_block @nf,
+        stmt_block @body.code_to_nf,
           function: !@options[:global_code],
           closure:  @closure
 
@@ -97,19 +66,50 @@ module Furnace::AVM2
       end
     end
 
+    StaticProperty = Matcher.new do
+      [ either[:set_property, :init_property],
+        [:find_property, capture(:property)],
+        backref(:property),
+        capture(:value)
+      ]
+    end
+
+    def decompose_static_initializer
+      properties = {}
+
+      StaticProperty.find_all(@body.code_to_nf.children) do |match, captures|
+        begin
+          token = handle_expression(captures[:value])
+        rescue ExpressionNotRecognized => e
+          token = token(CommentToken, "Unrecognized static initializer:\n#{e.opcode.inspect}")
+        end
+
+        properties[captures[:property]] = token
+      end
+
+      properties
+    end
+
     # Statements
 
     def stmt_block(block, options={})
       nodes = []
+      last_index = 0
+
+      block.children.each_with_index do |opcode, index|
+        last_index = index
 
-      block.children.each do |opcode|
         if respond_to?(:"stmt_#{opcode.type}")
           send :"stmt_#{opcode.type}", opcode, nodes
         else
           catch(:skip) do
-            nodes << token(StatementToken, [
+            @collected_vars = []
+            stmt = token(StatementToken, [
               handle_expression(opcode)
             ])
+
+            nodes.concat @collected_vars
+            nodes.push stmt
           end
         end
       end
@@ -121,9 +121,9 @@ module Furnace::AVM2
         "Expression recognizer failed at:\n" +
         "#{e.opcode.inspect}\n"
 
-      if e.context != e.opcode
-        comment << "\nOpcode at the top of stack:\n" +
-          "#{e.context.inspect}\n"
+      comment << "\nRest of the code in this block:\n"
+      block.children[last_index..-1].each do |opcode|
+        comment << "#{opcode.inspect}\n"
       end
 
       nodes << CommentToken.new(@body, comment, @options)
@@ -134,13 +134,28 @@ module Furnace::AVM2
       end
     end
 
+    def stmt_begin(opcode, nodes)
+      nodes << stmt_block(opcode)
+    end
+
     def stmt_if(opcode, nodes)
       condition, if_true, if_false = opcode.children
 
       nodes << token(IfToken, handle_expression(condition),
         stmt_block(if_true, continuation: !if_false.nil?))
-      nodes << token(ElseToken,
-        stmt_block(if_false)) if if_false
+
+      if if_false
+        first_child = if_false.children.first
+        if if_false.children.count == 1 &&
+              first_child.type == :if
+          nodes << token(ElseToken,
+            nil)
+          stmt_if(first_child, nodes)
+        else
+          nodes << token(ElseToken,
+            stmt_block(if_false))
+        end
+      end
     end
 
     def stmt_label(opcode, nodes)
@@ -152,10 +167,19 @@ module Furnace::AVM2
     def stmt_while(opcode, nodes)
       condition, body = opcode.children
 
-      nodes << token(WhileToken, handle_expression(condition),
+      nodes << token(WhileToken,
+        handle_expression(condition),
         stmt_block(body))
     end
 
+    def stmt_do_while(opcode, nodes)
+      condition, body = opcode.children
+
+      nodes << token(DoWhileToken,
+        stmt_block(body, continuation: true),
+        handle_expression(condition))
+    end
+
     def stmt_for(opcode, nodes)
       value_reg, value_type, object_reg, body = opcode.children
 
@@ -167,10 +191,10 @@ module Furnace::AVM2
         klass = ForEachToken
       end
 
-      if @closure_slots
+      if @activation_local
         name = token(VariableNameToken, @closure_slots[value_reg].name.name)
       else
-        name = token(VariableNameToken, local_name(value_reg))
+        name = local_token(value_reg)
       end
 
       nodes << token(klass,
@@ -179,7 +203,7 @@ module Furnace::AVM2
             name,
             type_token(value_type)
           ]),
-          token(VariableNameToken, local_name(object_reg)),
+          local_token(object_reg),
         ]),
         stmt_block(body))
     end
@@ -187,11 +211,17 @@ module Furnace::AVM2
     alias :stmt_for_each_in :stmt_for
 
     def stmt_break(opcode, nodes)
-      nodes << token(ReturnToken, exprs(opcode.children))
+      label, = opcode.children
+      nodes << token(BreakToken, [
+        (token(LabelNameToken, label) if label)
+      ])
     end
 
     def stmt_continue(opcode, nodes)
-      nodes << token(ContinueToken, exprs(opcode.children))
+      label, = opcode.children
+      nodes << token(ContinueToken, [
+        (token(LabelNameToken, label) if label)
+      ])
     end
 
     def stmt_throw(opcode, nodes)
@@ -204,31 +234,127 @@ module Furnace::AVM2
     alias :stmt_return_value :stmt_return
     alias :stmt_return_void  :stmt_return
 
+    def stmt_try(opcode, nodes)
+      body, *handlers = opcode.children
+
+      nodes << token(TryToken, [
+        stmt_block(body, continuation: true),
+      ])
+
+      handlers.each_with_index do |handler, index|
+        block = within_meta_scope do
+          stmt_block(handler.children.last, continuation: index < handlers.size - 1)
+        end
+
+        if handler.type == :catch
+          type, variable, = handler.children
+
+          if type
+            filter_node = token(CatchFilterToken, [
+              token(MultinameToken, variable.metadata[:origin]),
+              token(MultinameToken, type.metadata[:origin])
+            ])
+          else
+            filter_node = token(MultinameToken, variable.metadata[:origin])
+          end
+
+          nodes << token(CatchToken, filter_node, block)
+        elsif handler.type == :finally
+          nodes << token(FinallyToken, block)
+        else
+          raise "unknown handler type #{handler.type}"
+        end
+      end
+    end
+
+    def stmt_switch(opcode, nodes)
+      condition, body = opcode.children
+
+      nodes << token(SwitchToken,
+        handle_expression(condition),
+        stmt_block(body))
+    end
+
+    def stmt_default(opcode, nodes)
+      nodes << token(CaseToken, nil)
+    end
+
+    def stmt_case(opcode, nodes)
+      value, = opcode.children
+      nodes << token(CaseToken, handle_expression(value))
+    end
+
+    def within_meta_scope
+      @metascopes.push @scopes
+      @scopes = []
+
+      yield
+    ensure
+      @scopes = @metascopes.pop
+    end
+
+    KnownPushScopeMatcher = AST::Matcher.new do
+      [:push_scope,
+        either[
+          [:get_local, capture(:get_local)],
+          [:set_local, capture(:set_activation_local),
+            [:new_activation]]
+        ]
+      ]
+    end
+
     def stmt_push_scope(opcode, nodes)
       if @options[:global_code]
         @scopes.push opcode.children.first
+      elsif captures = KnownPushScopeMatcher.match(opcode)
+        if captures[:get_local] == 0
+          @scopes << :this
+        elsif !@activation_local.nil? &&
+            captures[:get_local] == @activation_local
+          @scopes << :activation
+        elsif @catch_scopes.include? captures[:get_local]
+          @scopes << @catch_scopes[captures[:get_local]]
+        elsif captures[:set_activation_local]
+          if @activation_local
+            raise "more than one activation per function is not supported"
+          end
+
+          @scopes << :activation
+          @activation_local = captures[:set_activation_local]
+        else
+          raise "abnormal matched pushscope in nonglobal code: #{captures.inspect}"
+        end
       else
-        raise "pushscope in nonglobal code"
+        raise "abnormal pushscope in nonglobal code"
       end
     end
 
     def stmt_pop_scope(opcode, nodes)
       if @options[:global_code]
         @scopes.pop
+      elsif @scopes.any?
+        @scopes.pop
       else
-        raise "popscope in nonglobal code"
+        raise "popscope with empty stack"
       end
     end
 
     # Expressions
 
     def handle_expression(opcode)
-      expression(opcode)
+      expression(opcode, true)
     rescue ExpressionNotRecognized => e
       raise ExpressionNotRecognized.new(opcode, e.opcode)
     end
 
-    def expression(opcode)
+    def expression(opcode, toplevel=false)
+      if toplevel
+        handler = :"expr_#{opcode.type}_toplevel"
+        if respond_to?(handler) && node = send(handler, opcode)
+          return node
+        end
+      end
+
       handler = :"expr_#{opcode.type}"
       if respond_to?(handler) && node = send(handler, opcode)
         node
@@ -287,59 +413,63 @@ module Furnace::AVM2
 
     ## Locals
 
-    def local_name(index)
+    def local_token(index)
       if index < 0
-        "sp#{-index}"
+        token(VariableNameToken, "sp#{-index}")
       elsif index == 0
         if @options[:static]
-          @options[:instance].name.name
+          token(VariableNameToken, @options[:instance].name.name)
         else
-          "this"
+          token(ThisToken)
         end
       elsif index <= @method.param_count
         if @method.has_param_names?
-          @method.param_names[index - 1]
+          token(VariableNameToken, @method.param_names[index - 1])
         else
-          "param#{index - 1}"
+          token(VariableNameToken, "param#{index - 1}")
         end
       else
-        "local#{index - @method.param_count - 1}"
+        token(VariableNameToken, "local#{index - @method.param_count - 1}")
       end
     end
 
     def expr_get_local(opcode)
       index, = opcode.children
-      token(VariableNameToken, local_name(index))
+      local_token(index)
     end
 
-    ActivationGetSlot = Matcher.new do
-      [:get_slot,
-        capture(:index),
-        [:get_scope_object, 1]]
-    end
-
-    GlobalGetSlot = Matcher.new do
+    GetSlot = Matcher.new do
       [:get_slot,
         capture(:index),
         either[
-          [:get_global_scope],    # normalized form
-          [:get_scope_object, 0]  # not emitted by ASC
-        ]]
+          [:get_scope_object, capture(:scope_pos)],
+          [:get_global_scope]
+        ]
+      ]
     end
 
     def expr_get_slot(opcode)
-      if @closure_slots && captures = ActivationGetSlot.match(opcode)
-        # treat as a local variable
-        slot = @closure_slots[captures[:index]]
-        token(VariableNameToken, slot.name.name)
-      elsif captures = GlobalGetSlot.match(opcode)
-        # treat as a global property
-        if @global_slots
-          slot = @global_slots[captures[:index]]
-          get_name(nil, slot.name.to_astlet)
-        else
-          token(PropertyNameToken,
-            "$__GLOBAL_#{captures[:index]}")
+      if captures = GetSlot.match(opcode)
+        scope = @scopes[captures[:scope_pos] || 0]
+
+        if scope.is_a? Hash
+          # treat as an inline scope, probably from an eh
+          if scope[captures[:index]]
+            var = scope[captures[:index]]
+            token(VariableNameToken, var.metadata[:origin].name)
+          end
+        elsif @closure_slots && scope == :activation
+          # treat as a local variable
+          slot = @closure_slots[captures[:index]]
+          token(VariableNameToken, slot.name.name)
+        elsif scope == :this
+          # treat as a global property
+          if slot = @global_slots[captures[:index]]
+            get_name(nil, slot.name.to_astlet)
+          else
+            token(PropertyNameToken,
+              "$__GLOBAL_#{captures[:index]}")
+          end
         end
       end
     end
@@ -351,7 +481,7 @@ module Furnace::AVM2
       :string    => 'String',
       :double    => 'Number',
       :object    => 'Object',
-      :bool      => 'Boolean',
+      :boolean   => 'Boolean',
       :true      => 'Boolean',
       :false     => 'Boolean',
     }
@@ -372,24 +502,38 @@ module Furnace::AVM2
       [:coerce, [:q, "XML"], any]
     end
 
-    def expr_set_var(name, value, type, declare)
+    def expr_set_var(var, value, type, declare, toplevel)
       if declare
-        token(LocalVariableToken, [
-          token(VariableNameToken, name),
-          type,
+        declaration =
+          token(LocalVariableToken, [
+            var,
+            type
+          ])
+      end
+
+      if declare && toplevel
+        declaration.children <<
           token(InitializationToken, [
             expr(value)
           ])
-        ])
+
+        declaration
       else
+        if declare
+          @collected_vars <<
+            token(StatementToken, [
+              declaration
+            ])
+        end
+
         token(AssignmentToken, [
-          token(VariableNameToken, name),
-          expr(value)
+          var,
+          parenthesize(expr(value))
         ])
       end
     end
 
-    def expr_set_local(opcode)
+    def expr_set_local(opcode, toplevel=false)
       index, value = opcode.children
       if IMMEDIATE_TYPE_MAP.include?(value.type)
         type = token(TypeToken, [
@@ -406,83 +550,109 @@ module Furnace::AVM2
         value = value.children.last
       end
 
-      expr_set_var(local_name(index), value, type, !@locals.include?(index))
+      expr_set_var(local_token(index), value, type, !@locals.include?(index), toplevel)
     ensure
       @locals.add index if index
     end
 
-    ActivationSetSlot = Matcher.new do
-      [:set_slot,
-        capture(:index),
-        [:get_scope_object, 1],
-        capture(:value)]
+    def expr_set_local_toplevel(opcode)
+      expr_set_local(opcode, true)
     end
 
-    GlobalSetSlot = Matcher.new do
+    SetSlot = Matcher.new do
       [:set_slot,
         capture(:index),
         either[
-          [:get_global_scope],    # normalized form
-          [:get_scope_object, 0]  # not emitted by ASC
+          [:get_scope_object, capture(:scope_pos)],
+          [:get_global_scope],
+          [:push_scope,
+            [:set_local, capture(:catch_local),
+              [:new_catch, capture(:catch_id)]]]
         ],
-        capture(:value)]
+        capture(:value)
+      ]
     end
 
-    def expr_set_slot(opcode)
-      if @closure_slots && captures = ActivationSetSlot.match(opcode)
-        # treat as a local variable
-        index, value = captures.values_at(:index, :value)
-        slot = @closure_slots[index]
+    ExceptionVariable = Matcher.new do
+      [:exception_variable, capture(:variable)]
+    end
 
-        type = type_token(slot.type.to_astlet) if slot.type
-        expr = expr_set_var(slot.name.name, value, type,
-              !@closure_locals.include?(index))
-        @closure_locals.add index
+    def expr_set_slot(opcode, toplevel=false)
+      if captures = SetSlot.match(opcode)
+        scope = @scopes[captures[:scope_pos] || 0]
 
-        expr
-      elsif captures = GlobalSetSlot.match(opcode)
-        # treat as a global property
-        index, value = captures.values_at(:index, :value)
+        if captures[:catch_id]
+          stmt = nil
 
-        if @global_slots
-          slot = @global_slots[index]
-          name = get_name(nil, slot.name.to_astlet)
-        else
-          token(PropertyNameToken, "$__GLOBAL_#{index}")
-        end
+          unless ExceptionVariable.match captures[:value], captures
+            stmt = token(SupplementaryCommentToken,
+              "Non-matching catch_id and catch id", [])
+          end
 
-        token(AssignmentToken, [
-          name,
-          expr(value)
-        ])
+          scope = {
+            captures[:index] => captures[:variable]
+          }
+
+          @catch_scopes[captures[:catch_local]] = scope
+          @scopes << scope
+
+          throw :skip unless stmt
+          stmt
+        elsif @closure_slots && scope == :activation
+          # treat as a local variable
+          index, value = captures.values_at(:index, :value)
+          slot = @closure_slots[index]
+
+          type = type_token(slot.type.to_astlet) if slot.type
+          expr = expr_set_var(token(VariableNameToken, slot.name.name),
+                value, type,
+                !@closure_locals.include?(index), toplevel)
+          @closure_locals.add index
+
+          expr
+        elsif scope == :this
+          # treat as a global property
+          index, value = captures.values_at(:index, :value)
+
+          if slot = @global_slots[index]
+            name = get_name(nil, slot.name.to_astlet)
+          else
+            name = token(PropertyNameToken, "$__GLOBAL_#{index}")
+          end
+
+          token(AssignmentToken, [
+            name,
+            parenthesize(expr(value))
+          ])
+        end
       end
     end
 
+    def expr_set_slot_toplevel(opcode)
+      expr_set_slot(opcode, true)
+    end
+
     ## Arithmetics
 
     INPLACE_OPERATOR_MAP = {
       :inc_local   => :"++",
-      :inc_local_i => :"++",
       :dec_local   => :"--",
-      :dec_local_i => :"--",
     }
 
     def expr_inplace_arithmetic(opcode)
-      token(UnaryPostOperatorToken, [
-        token(VariableNameToken, local_name(*opcode.children)),
-      ], INPLACE_OPERATOR_MAP[opcode.type])
+      index, = opcode.children
+
+      token(UnaryPostOperatorToken,
+        local_token(index),
+        INPLACE_OPERATOR_MAP[opcode.type])
     end
 
-    alias :expr_inc_local   :expr_inplace_arithmetic
-    alias :expr_inc_local_i :expr_inplace_arithmetic
-    alias :expr_dec_local   :expr_inplace_arithmetic
-    alias :expr_dec_local_i :expr_inplace_arithmetic
+    alias :expr_inc_local :expr_inplace_arithmetic
+    alias :expr_dec_local :expr_inplace_arithmetic
 
     PSEUDO_OPERATOR_MAP = {
       :increment   => [:"+", 1],
-      :increment_i => [:"+", 1],
       :decrement   => [:"-", 1],
-      :decrement_i => [:"-", 1],
     }
 
     def expr_pseudo_arithmetic(opcode)
@@ -497,25 +667,38 @@ module Furnace::AVM2
     end
 
     alias :expr_increment   :expr_pseudo_arithmetic
-    alias :expr_increment_i :expr_pseudo_arithmetic
     alias :expr_decrement   :expr_pseudo_arithmetic
-    alias :expr_decrement_i :expr_pseudo_arithmetic
+
+    def expr_prepost_incdec_local(opcode)
+      index, = opcode.children
+      lvar = local_token(index)
+
+      if opcode.type == :post_increment_local
+        token(UnaryPostOperatorToken, lvar, "++")
+      elsif opcode.type == :post_decrement_local
+        token(UnaryPostOperatorToken, lvar, "--")
+      elsif opcode.type == :pre_increment_local
+        token(UnaryOperatorToken, lvar, "++")
+      elsif opcode.type == :pre_decrement_local
+        token(UnaryOperatorToken, lvar, "--")
+      end
+    end
+    alias :expr_post_increment_local :expr_prepost_incdec_local
+    alias :expr_post_decrement_local :expr_prepost_incdec_local
+    alias :expr_pre_increment_local  :expr_prepost_incdec_local
+    alias :expr_pre_decrement_local  :expr_prepost_incdec_local
 
     OPERATOR_MAP = {
       :and         => :"&&",
       :or          => :"||",
 
       :add         => :"+",
-      :add_i       => :"+",
       :subtract    => :"-",
-      :subtract_i  => :"-",
       :multiply    => :"*",
-      :multiply_i  => :"*",
       :divide      => :"/",
       :modulo      => :"%",
       :multiply    => :"*",
       :negate      => :"-",
-      :negate_i    => :"-",
 
       :!           => :!,
       :>           => :>,
@@ -541,7 +724,7 @@ module Furnace::AVM2
         insides = parenthesize_each(exprs(opcode.children))
 
         if insides.count == 1
-          token(UnaryOperatorToken, insides, OPERATOR_MAP[opcode.type])
+          token(UnaryOperatorToken, insides.first, OPERATOR_MAP[opcode.type])
         elsif insides.count == 2
           token(BinaryOperatorToken, insides, OPERATOR_MAP[opcode.type])
         else
@@ -554,11 +737,8 @@ module Furnace::AVM2
     alias :expr_or          :expr_arithmetic
 
     alias :expr_add         :expr_arithmetic
-    alias :expr_add_i       :expr_arithmetic
     alias :expr_subtract    :expr_arithmetic
-    alias :expr_subtract_i  :expr_arithmetic
     alias :expr_multiply    :expr_arithmetic
-    alias :expr_multiply_i  :expr_arithmetic
     alias :expr_divide      :expr_arithmetic
     alias :expr_modulo      :expr_arithmetic
     alias :expr_negate      :expr_arithmetic
@@ -601,11 +781,14 @@ module Furnace::AVM2
           ],
           [
             [:find_property_strict,
-              [:m, [:set, "*"], any]],
+              [:m, [:set, any], any]],
             capture(:multiname)
           ],
           [
-            [:get_scope_object, 0],
+            either[
+              [:get_scope_object, 0],
+              [:get_global_scope]
+            ],
             capture(:multiname)
           ],
         ],
@@ -644,13 +827,13 @@ module Furnace::AVM2
       if captures = PropertyGlobal.match(opcode)
         token(AssignmentToken, [
           get_name(nil, captures[:multiname]),
-          expr(*captures[:arguments])
+          parenthesize(expr(*captures[:arguments]))
         ])
       else
         subject, multiname, value, = opcode.children
         token(AssignmentToken, [
           get_name(expr(subject), multiname),
-          expr(value)
+          parenthesize(expr(value))
         ])
       end
     end
@@ -661,7 +844,7 @@ module Furnace::AVM2
 
       stmt = token(AssignmentToken, [
         get_name(token(SuperToken), multiname),
-        expr(value)
+        parenthesize(expr(value))
       ])
 
       unless This.match subject
@@ -673,28 +856,27 @@ module Furnace::AVM2
       stmt
     end
 
-    def expr_delete_property(opcode)
-      subject, multiname, = opcode.children
-      token(DeleteToken, [get_name(expr(subject), multiname)])
-    end
-
-    def expr_do_property(opcode, klass)
+    def expr_do_property(opcode, klass, has_args)
       if captures = PropertyGlobal.match(opcode)
         token(klass, [
           get_name(nil, captures[:multiname]),
-          token(ArgumentsToken, exprs(captures[:arguments]))
+          (token(ArgumentsToken, exprs(captures[:arguments])) if has_args)
         ])
       else
         subject, multiname, *args = opcode.children
         token(klass, [
           get_name(expr(subject), multiname),
-          token(ArgumentsToken, exprs(args))
+          (token(ArgumentsToken, exprs(args)) if has_args)
         ])
       end
     end
 
+    def expr_delete_property(opcode)
+      expr_do_property(opcode, DeleteToken, false)
+    end
+
     def expr_call_property(opcode)
-      expr_do_property(opcode, CallToken)
+      expr_do_property(opcode, CallToken, true)
     end
     alias :expr_call_property_lex :expr_call_property
 
@@ -711,7 +893,7 @@ module Furnace::AVM2
     ## Object creation
 
     def expr_construct_property(opcode)
-      expr_do_property(opcode, NewToken)
+      expr_do_property(opcode, NewToken, true)
     end
 
     def expr_construct(opcode)
@@ -761,7 +943,7 @@ module Furnace::AVM2
         token(CallToken, [
           subject_token,
           token(ArgumentsToken, [
-            token(VariableNameToken, local_name(0)),
+            local_token(0),
             *exprs(args)
           ])
         ])
@@ -880,6 +1062,11 @@ module Furnace::AVM2
       xml_expr(node.children.first)
     end
 
+    def expr_check_filter(node)
+      content, = node.children
+      expr(content)
+    end
+
     private
 
     def token(klass, *args)
@@ -910,14 +1097,24 @@ module Furnace::AVM2
             parenthesize(subject),
             expr(multiname.children.last)
           ])
+        elsif @scopes[0] == :this
+          token(IndexToken, [
+            local_token(0),
+            expr(multiname.children.last)
+          ])
         else
-          token(CommentToken, "%%type #{origin} with no subject")
+          token(CommentToken, "%%type #{origin} with no subject and non-this global-scope")
         end
       when :RTQName, :RTQNameA
         token(RTNameToken, [
           parenthesize(expr(multiname.children.first)),
           token(PropertyNameToken, origin.name)
         ])
+      when :RTQNameL, :RTQNameLA
+        token(RTNameToken, [
+          parenthesize(expr(multiname.children.first)),
+          parenthesize(expr(multiname.children.last))
+        ])
       else
         token(CommentToken, "%%type #{origin}")
       end