furnace-avm2 0.0.1

data/lib/avm2/abc/opcodes/push_literal/as3_pushshort.rb

@@ -0,0 +1,11 @@
+module AVM2::ABC
+  class AS3PushShort < PushLiteralOpcode
+    instruction 0x25
+
+    body do
+      vuint30 :value
+    end
+
+    type :integer
+  end
+end

data/lib/avm2/abc/opcodes/push_literal/as3_pushstring.rb

@@ -0,0 +1,11 @@
+module AVM2::ABC
+  class AS3PushString < PushLiteralOpcode
+    instruction 0x2c
+
+    body do
+      const_ref :value, :string
+    end
+
+    type :string
+  end
+end

data/lib/avm2/abc/opcodes/push_literal/as3_pushtrue.rb

@@ -0,0 +1,7 @@
+module AVM2::ABC
+  class AS3PushTrue < PushLiteralOpcode
+    instruction 0x26
+
+    type :true
+  end
+end

data/lib/avm2/abc/opcodes/push_literal/as3_pushundefined.rb

@@ -0,0 +1,7 @@
+module AVM2::ABC
+  class AS3PushUndefined < PushLiteralOpcode
+    instruction 0x21
+
+    type :undefined
+  end
+end

data/lib/avm2/abc/opcodes/push_literal/as3_pushwith.rb

@@ -0,0 +1,8 @@
+module AVM2::ABC
+  class AS3PushWith < Opcode
+    instruction 0x1c
+
+    consume 1
+    produce 0
+  end
+end

data/lib/avm2/abc/opcodes/push_literal_opcode.rb

@@ -0,0 +1,18 @@
+module AVM2::ABC
+  class PushLiteralOpcode < Opcode
+    consume 0
+    produce 1
+
+    def ast_type
+      type
+    end
+
+    def parameters
+      if respond_to? :body
+        [ body.value ]
+      else
+        [ ]
+      end
+    end
+  end
+end

data/lib/avm2/abc/opcodes/type_conversion/as3_applytype.rb

@@ -0,0 +1,12 @@
+module AVM2::ABC
+  class AS3ApplyType < TypeConversionOpcode
+    instruction 0x53
+
+    body do
+      vuint30 :argc
+    end
+
+    consume { body.argc + 1 }
+    produce 1
+  end
+end

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

@@ -0,0 +1,16 @@
+module AVM2::ABC
+  class AS3Coerce < TypeConversionOpcode
+    instruction 0x80
+
+    body do
+      const_ref :type, :multiname
+    end
+
+    consume 1
+    produce 1
+
+    def parameters
+      [ body.type.to_astlet ]
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+module AVM2::ABC
+  class AS3CoerceA < TypeConversionOpcode
+    instruction 0x82
+
+    consume 1
+    produce 1
+  end
+end

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,10 @@
+module AVM2::ABC
+  class AS3ConvertU < TypeConversionOpcode
+    instruction 0x74
+
+    consume 1
+    produce 1
+
+    type :integer
+  end
+end

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

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

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

@@ -0,0 +1,195 @@
+module AVM2::ABC
+  class OpcodeSequence < ::Array
+    attr_reader :root, :parent
+
+    def initialize(options={})
+      @root, @parent = options[:parent].root, options[:parent]
+      @pos_cache    = {}
+      @opcode_cache = {}
+
+      @raw_code = nil
+    end
+
+    def read(io)
+      @raw_code = io.read(@parent.code_length)
+    end
+
+    def write(io)
+      if @raw_code
+        io.write @raw_code
+      else
+        lookup!
+
+        each do |opcode|
+          opcode.write(io)
+        end
+      end
+    end
+
+    def each(&block)
+      parse if @raw_code
+
+      super
+    end
+
+    # Offsets
+
+    def recache!
+      flush!
+
+      pos = 0
+      each do |opcode|
+        @pos_cache[pos]       = opcode
+        @opcode_cache[opcode] = pos
+
+        pos += opcode.byte_length
+      end
+
+      lookup!
+    end
+
+    def flush!
+      @pos_cache    = {}
+      @opcode_cache = {}
+    end
+
+    def opcode_at(position)
+      @pos_cache[position]
+    end
+
+    def offset_of(opcode)
+      @opcode_cache[opcode]
+    end
+
+    def byte_length
+      map(&:byte_length).reduce(0, :+)
+    end
+
+    # Transformations
+
+    def disassemble
+      map(&:disassemble).join("\n")
+    end
+
+    def build_cfg
+      graph = CFG::Graph.new
+
+      targets = []
+
+      each do |opcode|
+        if opcode.is_a? ControlTransferOpcode
+          targets << opcode.target
+        elsif opcode.is_a? AS3LookupSwitch
+          targets << opcode.default_target
+          targets += opcode.case_targets
+        end
+      end
+
+      if exceptions.any?
+        exception_node = CFG::Node.new(graph, :exception, [])
+        graph.nodes.add exception_node
+
+        exceptions.each do |exception|
+          targets << exception.target_offset
+        end
+      end
+
+      each do |opcode|
+        if targets.include? opcode
+          graph.transfer({ nil => opcode.offset })
+        end
+
+        graph.expand opcode.offset, opcode
+
+        if opcode.is_a? ControlTransferOpcode
+          if opcode.conditional
+            graph.transfer({ true  => opcode.target.offset,
+                             false => opcode.offset + opcode.byte_length })
+          else
+            graph.transfer({ nil => opcode.target.offset })
+          end
+        elsif opcode.is_a? AS3LookupSwitch
+          map = { nil => opcode.default_target.offset }
+
+          opcode.case_targets.each_with_index do |target, index|
+            map[index] = target.offset
+          end
+
+          graph.transfer map
+        end
+      end
+
+      graph.transfer({ })
+
+      exceptions.each do |exception|
+        graph.edges.add CFG::Edge.new(graph, nil, :exception, exception.target_offset)
+      end
+
+      graph
+    end
+
+    def eliminate_dead!
+      cfg = build_cfg
+      dead_opcodes = []
+
+      cfg.nodes.each do |node|
+        if node.label != 0 && node.entering_edges.count == 0
+          dead_opcodes.concat node.operations
+        end
+      end
+
+      dead_opcodes.each do |opcode|
+        delete opcode
+      end
+
+      recache!
+
+      dead_opcodes.any?
+    end
+
+    protected
+
+    def parse
+      sub_io = StringIO.new(@raw_code)
+      map    = Opcode::MAP
+
+      until sub_io.eof?
+        instruction = sub_io.read(1).unpack("C").at(0)
+
+        opcode = map[instruction]
+        if opcode.nil?
+          raise "Unknown opcode 0x#{instruction.to_s(16)}"
+        end
+
+        element = opcode.new(self)
+
+        @pos_cache[sub_io.pos - 1] = element
+        @opcode_cache[element]     = sub_io.pos - 1
+
+        element.read(sub_io)
+
+        self << element
+      end
+
+      @raw_code = nil
+
+      each do |element|
+        element.resolve! if element.respond_to? :resolve!
+      end
+    end
+
+    def lookup!
+      each do |element|
+        element.lookup! if element.respond_to? :lookup!
+      end
+
+      exceptions.each do |exception|
+        exception.lookup!
+      end
+    end
+
+    def exceptions
+      @parent.exceptions
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+module AVM2::ABC
+  class Record < AVM2::Binary::Record
+    def self.abc_array_of(name, type, options={})
+      field_size, field_array = :"#{name}_count", options.delete(:plural) || :"#{name}s"
+      klass = options.delete(:class)
+
+      vuint30  field_size,  { :value   => lambda { send(field_array).count } }.merge(options)
+      array    field_array, { :type    => type, :initial_length => field_size,
+                              :options => { :class => klass } }.merge(options)
+    end
+
+    # Pools
+
+    def self.pool_ref(pool, name, type=name, options={})
+      field, array = :"#{name}_idx", options.delete(:plural) || :"#{type}s"
+
+      vuint30 field, options
+
+      if pool == :root
+        define_method(name) do
+          root.send(array)[send(field)]
+        end
+      elsif pool == :const
+        define_method(name) do
+          index = send(field)
+          if index == 0
+            nil
+          else
+            root.constant_pool.send(array)[index - 1]
+          end
+        end
+      end
+    end
+
+    def self.pool_array(pool, name, type, options={})
+      field, type_plural = :"#{name}_raw", options.delete(:plural) || :"#{type}s"
+
+      array field, { :type => :vuint30 }.merge(options)
+
+      if pool == :root
+        define_method(name) do
+          send(field).map do |element|
+            root.send(type_plural)[element]
+          end
+        end
+      elsif pool == :const
+        define_method(name) do
+          send(field).map do |element|
+            if element == 0
+              nil
+            else
+              root.constant_pool.send(type_plural)[element - 1]
+            end
+          end
+        end
+      end
+    end
+
+    def self.pool_array_of(pool, name, type, options={})
+      field_size, field_array = :"#{name}_count", options.delete(:plural) || :"#{name}s"
+
+      vuint30          field_size,        { :value => lambda { send(field_array).count } }.merge(options)
+      pool_array pool, field_array, type, { :initial_length => field_size }.merge(options)
+    end
+
+    # Pool references
+
+    [:root, :const].each do |pool|
+      [:ref, :array, :array_of].each do |method|
+        define_singleton_method(:"#{pool}_#{method}") do |*args|
+          send(:"pool_#{method}", pool, *args)
+        end
+      end
+    end
+
+    # Xlat
+
+    def self.xlat_direct
+      @xlat_direct  ||= const_get(:XlatTable).invert
+    end
+
+    def self.xlat_inverse
+      @xlat_inverse ||= const_get(:XlatTable)
+    end
+
+    def self.xlat_field(name)
+      define_method(:"#{name}") do
+        value = instance_variable_get :"@#{name}_raw"
+
+        unless self.class.xlat_direct.has_key? value
+          raise ArgumentError, "Unknown xlat value #{value} for #{self.class}"
+        end
+
+        self.class.xlat_direct[value]
+      end
+
+      define_method(:"#{name}=") do |new_value|
+        unless self.class.xlat_inverse.has_key? new_value
+          raise ArgumentError, "Unknown xlat identifier #{new_value} for #{self.class}"
+        end
+
+        instance_variable_set :"@#{name}_raw", self.class.xlat_inverse[new_value]
+      end
+    end
+
+    # Flags
+
+    def self.flag(name, field, constant)
+      define_method(:"#{name}?") do
+        instance_variable_get(:"@#{field}") & constant != 0
+      end
+
+      define_method(:"#{name}=") do |is_set|
+        flags = instance_variable_get(:"@#{field}")
+
+        if is_set
+          instance_variable_set(:"@#{field}", flags | constant)
+        else
+          instance_variable_set(:"@#{field}", flags & ~constant)
+        end
+      end
+    end
+
+    # Subsetting
+
+    def self.subset(name, array, selector)
+      define_method(:"#{name}") do
+        send(array).select &selector
+      end
+    end
+  end
+end