static VALUE iseqw_s_disasm(VALUE klass, VALUE body) { VALUE iseqw = iseqw_s_of(klass, body); return NIL_P(iseqw) ? Qnil : rb_iseq_disasm(iseqw_check(iseqw)); }

RubyVM::InstructionSequence.load_from_binary(binary) → iseq click to toggle source

Load an iseq object from binary format String object created by RubyVM::InstructionSequence.to_binary.

This loader does not have a verifier, so that loading broken/modified binary causes critical problem.

You should not load binary data provided by others. You should use binary data translated by yourself.

static VALUE iseqw_s_load_from_binary(VALUE self, VALUE str) { return iseqw_new(rb_iseq_ibf_load(str)); }

compile(source[, file[, path[, line[, options]]]]) → iseq click to toggle source

new(source[, file[, path[, line[, options]]]]) → iseq

Takes source, which can be a string of Ruby code, or an open File object. that contains Ruby source code.

Optionally takes file, path, and line which describe the file path, real path and first line number of the ruby code in source which are metadata attached to the returned iseq.

file is used for ‘__FILE__` and exception backtrace. path is used for require_relative base. It is recommended these should be the same full path.

options, which can be true, false or a Hash, is used to modify the default behavior of the Ruby iseq compiler.

For details regarding valid compile options see ::compile_option=.

RubyVM::InstructionSequence.compile("a = 1 + 2")

path = "test.rb" RubyVM::InstructionSequence.compile(File.read(path), path, File.expand_path(path))

file = File.open("test.rb") RubyVM::InstructionSequence.compile(file)

path = File.expand_path("test.rb") RubyVM::InstructionSequence.compile(File.read(path), path, path)

static VALUE iseqw_s_compile(int argc, VALUE *argv, VALUE self) { return iseqw_s_compile_parser(argc, argv, self, rb_ruby_prism_p()); }

of(p1) click to toggle source

Returns the instruction sequence containing the given proc or method.

For example, using irb:

a proc

p = proc { num = 1 + 2 } RubyVM::InstructionSequence.of(p) #=> <RubyVM::InstructionSequence:block in irb_binding@(irb)>

for a method

def foo(bar); puts bar; end RubyVM::InstructionSequence.of(method(:foo)) #=> RubyVM::InstructionSequence:foo@(irb)

Using ::compile_file:

/tmp/iseq_of.rb

def hello puts "hello, world" end

$a_global_proc = proc { str = 'a' + 'b' }

in irb

require '/tmp/iseq_of.rb'

first the method hello

RubyVM::InstructionSequence.of(method(:hello)) #=> #RubyVM::InstructionSequence:0x007fb73d7cb1d0

then the global proc

RubyVM::InstructionSequence.of($a_global_proc) #=> #RubyVM::InstructionSequence:0x007fb73d7caf78

static VALUE iseqw_s_of(VALUE klass, VALUE body) { const rb_iseq_t *iseq = NULL;

if (rb_frame_info_p(body)) {
    iseq = rb_get_iseq_from_frame_info(body);
}
else if (rb_obj_is_proc(body)) {
    iseq = vm_proc_iseq(body);

    if (!rb_obj_is_iseq((VALUE)iseq)) {
        iseq = NULL;
    }
}
else if (rb_obj_is_method(body)) {
    iseq = rb_method_iseq(body);
}
else if (rb_typeddata_is_instance_of(body, &iseqw_data_type)) {
    return body;
}

return iseq ? iseqw_new(iseq) : Qnil;

}

Public Instance Methods

absolute_path() click to toggle source

Returns the absolute path of this instruction sequence.

nil if the iseq was evaluated from a string.

For example, using ::compile_file:

/tmp/method.rb

def hello puts "hello, world" end

in irb

iseq = RubyVM::InstructionSequence.compile_file('/tmp/method.rb') iseq.absolute_path #=> /tmp/method.rb

static VALUE iseqw_absolute_path(VALUE self) { return rb_iseq_realpath(iseqw_check(self)); }

base_label() click to toggle source

Returns the base label of this instruction sequence.

For example, using irb:

iseq = RubyVM::InstructionSequence.compile('num = 1 + 2')

iseq.base_label

Using ::compile_file:

/tmp/method.rb

def hello puts "hello, world" end

in irb

iseq = RubyVM::InstructionSequence.compile_file('/tmp/method.rb') iseq.base_label #=>

static VALUE iseqw_base_label(VALUE self) { return rb_iseq_base_label(iseqw_check(self)); }

disasm → str click to toggle source

Returns the instruction sequence as a String in human readable form.

puts RubyVM::InstructionSequence.compile('1 + 2').disasm

Produces:

== disasm: <RubyVM::InstructionSequence:@>========== 0000 trace 1 ( 1) 0002 putobject 1 0004 putobject 2 0006 opt_plus ic:1 0008 leave

static VALUE iseqw_disasm(VALUE self) { return rb_iseq_disasm(iseqw_check(self)); }

disassemble → str

Returns the instruction sequence as a String in human readable form.

puts RubyVM::InstructionSequence.compile('1 + 2').disasm

Produces:

== disasm: <RubyVM::InstructionSequence:@>========== 0000 trace 1 ( 1) 0002 putobject 1 0004 putobject 2 0006 opt_plus ic:1 0008 leave

each_child{|child_iseq| ...} → iseq click to toggle source

Iterate all direct child instruction sequences. Iteration order is implementation/version defined so that people should not rely on the order.

static VALUE iseqw_each_child(VALUE self) { const rb_iseq_t *iseq = iseqw_check(self); iseq_iterate_children(iseq, yield_each_children, NULL); return self; }

eval → obj click to toggle source

Evaluates the instruction sequence and returns the result.

RubyVM::InstructionSequence.compile("1 + 2").eval

static VALUE iseqw_eval(VALUE self) { return rb_iseq_eval(iseqw_check(self)); }

first_lineno() click to toggle source

Returns the number of the first source line where the instruction sequence was loaded from.

For example, using irb:

iseq = RubyVM::InstructionSequence.compile('num = 1 + 2')

iseq.first_lineno

static VALUE iseqw_first_lineno(VALUE self) { return rb_iseq_first_lineno(iseqw_check(self)); }

inspect() click to toggle source

Returns a human-readable string representation of this instruction sequence, including the label and path.

static VALUE iseqw_inspect(VALUE self) { const rb_iseq_t *iseq = iseqw_check(self); const struct rb_iseq_constant_body *const body = ISEQ_BODY(iseq); VALUE klass = rb_class_name(rb_obj_class(self));

if (!body->location.label) {
    return rb_sprintf("#<%"PRIsVALUE": uninitialized>", klass);
}
else {
    return rb_sprintf("<%"PRIsVALUE":%"PRIsVALUE"@%"PRIsVALUE":%d>",
                      klass,
                      body->location.label, rb_iseq_path(iseq),
                      FIX2INT(rb_iseq_first_lineno(iseq)));
}

}

label() click to toggle source

Returns the label of this instruction sequence.

<main> if it’s at the top level, <compiled> if it was evaluated from a string.

For example, using irb:

iseq = RubyVM::InstructionSequence.compile('num = 1 + 2')

iseq.label

Using ::compile_file:

/tmp/method.rb

def hello puts "hello, world" end

in irb

iseq = RubyVM::InstructionSequence.compile_file('/tmp/method.rb') iseq.label #=>

static VALUE iseqw_label(VALUE self) { return rb_iseq_label(iseqw_check(self)); }

path() click to toggle source

Returns the path of this instruction sequence.

<compiled> if the iseq was evaluated from a string.

For example, using irb:

iseq = RubyVM::InstructionSequence.compile('num = 1 + 2')

iseq.path

Using ::compile_file:

/tmp/method.rb

def hello puts "hello, world" end

in irb

iseq = RubyVM::InstructionSequence.compile_file('/tmp/method.rb') iseq.path #=> /tmp/method.rb

static VALUE iseqw_path(VALUE self) { return rb_iseq_path(iseqw_check(self)); }

script_lines → array or nil click to toggle source

It returns recorded script lines if it is available. The script lines are not limited to the iseq range, but are entire lines of the source file.

Note that this is an API for ruby internal use, debugging, and research. Do not use this for any other purpose. The compatibility is not guaranteed.

static VALUE iseqw_script_lines(VALUE self) { const rb_iseq_t *iseq = iseqw_check(self); return ISEQ_BODY(iseq)->variable.script_lines; }

to_a → ary click to toggle source

Returns an Array with 14 elements representing the instruction sequence with the following data:

magic

A string identifying the data format. Always YARVInstructionSequence/SimpleDataFormat.

major_version

The major version of the instruction sequence.

minor_version

The minor version of the instruction sequence.

format_type

A number identifying the data format. Always 1.

misc

A hash containing:

:arg_size

the total number of arguments taken by the method or the block (0 if iseq doesn’t represent a method or block)

:local_size

the number of local variables + 1

:stack_max

used in calculating the stack depth at which a SystemStackError is thrown.

label

The name of the context (block, method, class, module, etc.) that this instruction sequence belongs to.

<main> if it’s at the top level, <compiled> if it was evaluated from a string.

path

The relative path to the Ruby file where the instruction sequence was loaded from.

<compiled> if the iseq was evaluated from a string.

absolute_path

The absolute path to the Ruby file where the instruction sequence was loaded from.

nil if the iseq was evaluated from a string.

first_lineno

The number of the first source line where the instruction sequence was loaded from.

type

The type of the instruction sequence.

Valid values are :top, :method, :block, :class, :rescue, :ensure, :eval, :main, and plain.

locals

An array containing the names of all arguments and local variables as symbols.

params

An Hash object containing parameter information.

More info about these values can be found in vm_core.h.

catch_table

A list of exceptions and control flow operators (rescue, next, redo, break, etc.).

bytecode

An array of arrays containing the instruction names and operands that make up the body of the instruction sequence.

Note that this format is MRI specific and version dependent.

static VALUE iseqw_to_a(VALUE self) { const rb_iseq_t *iseq = iseqw_check(self); return iseq_data_to_ary(iseq); }

to_binary(extra_data = nil) → binary str click to toggle source

Returns serialized iseq binary format data as a String object. A corresponding iseq object is created by RubyVM::InstructionSequence.load_from_binary() method.

String extra_data will be saved with binary data. You can access this data with RubyVM::InstructionSequence.load_from_binary_extra_data(binary).

Note that the translated binary data is not portable. You can not move this binary data to another machine. You can not use the binary data which is created by another version/another architecture of Ruby.

static VALUE iseqw_to_binary(int argc, VALUE *argv, VALUE self) { VALUE opt = !rb_check_arity(argc, 0, 1) ? Qnil : argv[0]; return rb_iseq_ibf_dump(iseqw_check(self), opt); }

trace_points → ary click to toggle source

Return trace points in the instruction sequence. Return an array of [line, event_symbol] pair.

static VALUE iseqw_trace_points(VALUE self) { const rb_iseq_t *iseq = iseqw_check(self); const struct rb_iseq_constant_body *const body = ISEQ_BODY(iseq); unsigned int i; VALUE ary = rb_ary_new();

for (i=0; i<body->insns_info.size; i++) {
    const struct iseq_insn_info_entry *entry = &body->insns_info.body[i];
    if (entry->events) {
        push_event_info(iseq, entry->events, entry->line_no, ary);
    }
}
return ary;

}