Class: Furnace::AVM2::ABC::Opcode

Inherits:
Object
  • Object
show all
Defined in:
lib/furnace-avm2/abc/opcodes/opcode.rb

Constant Summary collapse

MAP = 
{}

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(sequence) ⇒ Opcode

Returns a new instance of Opcode.



61
62
63
 
# File 'lib/furnace-avm2/abc/opcodes/opcode.rb', line 61

def initialize(sequence)
  @sequence = sequence
end

Instance Attribute Details

#sequence ⇒ Object (readonly)

Returns the value of attribute sequence.



59
60
61
 
# File 'lib/furnace-avm2/abc/opcodes/opcode.rb', line 59

def sequence
  @sequence
end

Class Method Details

.body(&block) ⇒ Object 



29
30
31
32
33
34
35
36
37
38
 
# File 'lib/furnace-avm2/abc/opcodes/opcode.rb', line 29

def self.body(&block)
  @body_defined = true

  klass = Class.new(Record)
  klass.instance_exec &block

  const_set :Body, klass

  attr_accessor :body
end

.define_property(name, options = {}, &block) ⇒ Object

Metamethods



7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
# File 'lib/furnace-avm2/abc/opcodes/opcode.rb', line 7

def self.define_property(name, options={}, &block)
  accessor_name = options[:accessor] || name

  define_singleton_method(name) do |value=nil, &value_block|
    if value_block
      define_method(accessor_name) do
        instance_exec &value_block
      end
    elsif !value.nil?
      define_method(accessor_name) do
        value
      end
    else
      define_method(accessor_name) do
        true
      end
    end

    instance_exec(value, &block) if block
  end
end

.mnemonic ⇒ Object 



40
41
42
 
# File 'lib/furnace-avm2/abc/opcodes/opcode.rb', line 40

def self.mnemonic
  @mnemonic ||= name.sub("Furnace::AVM2::ABC::AS3", "")
end

Instance Method Details

#ast_type ⇒ Object

Attributes



104
105
106
107
108
 
# File 'lib/furnace-avm2/abc/opcodes/opcode.rb', line 104

def ast_type
  self.class.mnemonic.
    gsub(/^[A-Z]/) { |m| m[0].downcase }.
    gsub(/([a-z])([A-Z])/) { |m| "#{m[0]}_#{m[1].downcase}" }
end

#byte_length ⇒ Object 



86
87
88
89
90
91
92
 
# File 'lib/furnace-avm2/abc/opcodes/opcode.rb', line 86

def byte_length
  if respond_to? :body
    @body.byte_length + 1
  else
    1
  end
end

#consumes_context ⇒ Object 



110
111
112
 
# File 'lib/furnace-avm2/abc/opcodes/opcode.rb', line 110

def consumes_context
  false
end

#disassemble ⇒ Object Also known as: inspect 



124
125
126
 
# File 'lib/furnace-avm2/abc/opcodes/opcode.rb', line 124

def disassemble
  "   #{offset.to_s.rjust(4, "0")}  #{self.class.mnemonic.rjust(20, " ")} #{disassemble_parameters}"
end

#disassemble_parameters ⇒ Object

Disassembling



120
121
122
 
# File 'lib/furnace-avm2/abc/opcodes/opcode.rb', line 120

def disassemble_parameters
  @body.to_hash if @body
end

#next ⇒ Object 



98
99
100
 
# File 'lib/furnace-avm2/abc/opcodes/opcode.rb', line 98

def next
  @sequence.opcode_at(offset + byte_length)
end

#offset ⇒ Object 



94
95
96
 
# File 'lib/furnace-avm2/abc/opcodes/opcode.rb', line 94

def offset
  @sequence.offset_of(self)
end

#parameters ⇒ Object 



114
115
116
 
# File 'lib/furnace-avm2/abc/opcodes/opcode.rb', line 114

def parameters
  []
end

#read(io) ⇒ Object

Stream manipulation



71
72
73
74
75
76
 
# File 'lib/furnace-avm2/abc/opcodes/opcode.rb', line 71

def read(io)
  if respond_to? :body
    @body = self.class.const_get(:Body).new(:parent => @sequence)
    @body.read(io)
  end
end

#root ⇒ Object 



65
66
67
 
# File 'lib/furnace-avm2/abc/opcodes/opcode.rb', line 65

def root
  @sequence.root
end

#write(io) ⇒ Object 



78
79
80
81
82
83
84
 
# File 'lib/furnace-avm2/abc/opcodes/opcode.rb', line 78

def write(io)
  io.write([ instruction ].pack("C"))

  if respond_to? :body
    @body.write(io)
  end
end