class RubyVM::InstructionSequence

InstructionSequence 类表示 MRI 中使用的虚拟机编译后的指令序列。并非所有 Ruby 实现都可能实现此类，对于实现此类的实现，方法定义和方法的行为可能在任何版本中更改。

通过它，您可以获得构成方法或 proc 的指令的句柄，将 Ruby 代码字符串编译为 VM 指令，并将指令序列反汇编为字符串以便于检查。如果您想了解 YARV 的工作原理，它主要很有用，但它也允许您控制 Ruby iseq 编译器的各种设置。

您可以在 Ruby 源代码中的 insns.def 中找到 VM 指令的源代码。

指令序列结果几乎肯定会随着 Ruby 的更改而更改，因此本文档中的示例输出可能与您看到的不同。

当然，此类是 MRI 特有的。

公共类方法

compile(source[, file[, path[, line[, options]]]]) → iseq 单击以切换源代码

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

接受 source，它可以是 Ruby 代码的字符串，也可以是包含 Ruby 源代码的打开的 File 对象。

可选地接受 file、path 和 line，它们描述了 source 中 Ruby 代码的文件路径、实际路径和第一行号，这些是附加到返回的 iseq 的元数据。

file 用于 ‘__FILE__’ 和异常回溯。path 用于 require_relative 的基础。建议它们应该是相同的完整路径。

options 可以是 true、false 或 Hash，用于修改 Ruby iseq 编译器的默认行为。

有关有效编译选项的详细信息，请参阅 ::compile_option=。

RubyVM::InstructionSequence.compile("a = 1 + 2")
#=> <RubyVM::InstructionSequence:<compiled>@<compiled>>

path = "test.rb"
RubyVM::InstructionSequence.compile(File.read(path), path, File.expand_path(path))
#=> <RubyVM::InstructionSequence:<compiled>@test.rb:1>

file = File.open("test.rb")
RubyVM::InstructionSequence.compile(file)
#=> <RubyVM::InstructionSequence:<compiled>@<compiled>:1>

path = File.expand_path("test.rb")
RubyVM::InstructionSequence.compile(File.read(path), path, path)
#=> <RubyVM::InstructionSequence:<compiled>@/absolute/path/to/test.rb:1>

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

compile_file(file[, options]) → iseq 单击以切换源代码

接受 file，一个 String，其中包含 Ruby 源代码文件的位置，读取、解析和编译该文件，并返回 iseq，编译后的 InstructionSequence，并设置了源位置元数据。

可选地接受 options，可以是 true、false 或 Hash，以修改 Ruby iseq 编译器的默认行为。

有关有效编译选项的详细信息，请参阅 ::compile_option=。

# /tmp/hello.rb
puts "Hello, world!"

# elsewhere
RubyVM::InstructionSequence.compile_file("/tmp/hello.rb")
#=> <RubyVM::InstructionSequence:<main>@/tmp/hello.rb>

static VALUE
iseqw_s_compile_file(int argc, VALUE *argv, VALUE self)
{
    VALUE file, opt = Qnil;
    VALUE parser, f, exc = Qnil, ret;
    rb_ast_t *ast;
    VALUE ast_value;
    rb_compile_option_t option;
    int i;

    i = rb_scan_args(argc, argv, "1*:", &file, NULL, &opt);
    if (i > 1+NIL_P(opt)) rb_error_arity(argc, 1, 2);
    switch (i) {
      case 2: opt = argv[--i];
    }
    FilePathValue(file);
    file = rb_fstring(file); /* rb_io_t->pathv gets frozen anyways */

    f = rb_file_open_str(file, "r");

    rb_execution_context_t *ec = GET_EC();
    VALUE v = rb_vm_push_frame_fname(ec, file);

    parser = rb_parser_new();
    rb_parser_set_context(parser, NULL, FALSE);
    ast_value = rb_parser_load_file(parser, file);
    ast = rb_ruby_ast_data_get(ast_value);
    if (!ast->body.root) exc = GET_EC()->errinfo;

    rb_io_close(f);
    if (!ast->body.root) {
        rb_ast_dispose(ast);
        rb_exc_raise(exc);
    }

    make_compile_option(&option, opt);

    ret = iseqw_new(rb_iseq_new_with_opt(ast_value, rb_fstring_lit("<main>"),
                                         file,
                                         rb_realpath_internal(Qnil, file, 1),
                                         1, NULL, 0, ISEQ_TYPE_TOP, &option,
                                         Qnil));
    rb_ast_dispose(ast);

    rb_vm_pop_frame(ec);
    RB_GC_GUARD(v);
    return ret;
}

compile_file_prism(file[, options]) → iseq 单击以切换源代码

接受 file，一个 String，其中包含 Ruby 源代码文件的位置，读取、解析和编译该文件，并返回 iseq，编译后的 InstructionSequence，并设置了源位置元数据。它使用 prism 进行解析和编译。

可选地接受 options，可以是 true、false 或 Hash，以修改 Ruby iseq 编译器的默认行为。

有关有效编译选项的详细信息，请参阅 ::compile_option=。

# /tmp/hello.rb
puts "Hello, world!"

# elsewhere
RubyVM::InstructionSequence.compile_file_prism("/tmp/hello.rb")
#=> <RubyVM::InstructionSequence:<main>@/tmp/hello.rb>

static VALUE
iseqw_s_compile_file_prism(int argc, VALUE *argv, VALUE self)
{
    VALUE file, opt = Qnil, ret;
    rb_compile_option_t option;
    int i;

    i = rb_scan_args(argc, argv, "1*:", &file, NULL, &opt);
    if (i > 1+NIL_P(opt)) rb_error_arity(argc, 1, 2);
    switch (i) {
      case 2: opt = argv[--i];
    }
    FilePathValue(file);
    file = rb_fstring(file); /* rb_io_t->pathv gets frozen anyways */

    rb_execution_context_t *ec = GET_EC();
    VALUE v = rb_vm_push_frame_fname(ec, file);

    pm_parse_result_t result = { 0 };
    result.options.line = 1;
    result.node.coverage_enabled = 1;

    VALUE script_lines;
    VALUE error = pm_load_parse_file(&result, file, ruby_vm_keep_script_lines ? &script_lines : NULL);

    if (error == Qnil) {
        make_compile_option(&option, opt);

        int error_state;
        rb_iseq_t *iseq = pm_iseq_new_with_opt(&result.node, rb_fstring_lit("<main>"),
                                               file,
                                               rb_realpath_internal(Qnil, file, 1),
                                               1, NULL, 0, ISEQ_TYPE_TOP, &option, &error_state);

        pm_parse_result_free(&result);

        if (error_state) {
            RUBY_ASSERT(iseq == NULL);
            rb_jump_tag(error_state);
        }

        ret = iseqw_new(iseq);
        rb_vm_pop_frame(ec);
        RB_GC_GUARD(v);
        return ret;
    } else {
        pm_parse_result_free(&result);
        rb_vm_pop_frame(ec);
        RB_GC_GUARD(v);
        rb_exc_raise(error);
    }
}

compile_option → options 单击以切换源代码

返回 Ruby iseq 编译器使用的默认选项的哈希值。

有关详细信息，请参阅 InstructionSequence.compile_option=。

static VALUE
iseqw_s_compile_option_get(VALUE self)
{
    return make_compile_option_value(&COMPILE_OPTION_DEFAULT);
}

compile_option = options 单击以切换源代码

设置 Ruby iseq 编译器中各种优化的默认值。

options 的可能值包括 true（启用所有选项）、false（禁用所有选项）和 nil（保持所有选项不变）。

您还可以传递要更改的 options 的 Hash，哈希中不存在的任何选项将保持不变。

可以设置为 true 或 false 的可能的选项名称（即 options 中的键）包括

:inline_const_cache
:instructions_unification
:operands_unification
:peephole_optimization
:specialized_instruction
:tailcall_optimization

此外，可以将 :debug_level 设置为整数。

通过将上述任何值作为 options 参数传递给 ::new、::compile 和 ::compile_file，可以为 iseq 编译器的一次运行覆盖这些默认选项。

static VALUE
iseqw_s_compile_option_set(VALUE self, VALUE opt)
{
    rb_compile_option_t option;
    make_compile_option(&option, opt);
    COMPILE_OPTION_DEFAULT = option;
    return opt;
}

compile_parsey(source[, file[, path[, line[, options]]]]) → iseq 单击以切换源代码

接受 source，它可以是 Ruby 代码的字符串，也可以是包含 Ruby 源代码的打开的 File 对象。它使用 parse.y 进行解析和编译。

可选地接受 file、path 和 line，它们描述了 source 中 Ruby 代码的文件路径、实际路径和第一行号，这些是附加到返回的 iseq 的元数据。

file 用于 ‘__FILE__’ 和异常回溯。path 用于 require_relative 的基础。建议它们应该是相同的完整路径。

options 可以是 true、false 或 Hash，用于修改 Ruby iseq 编译器的默认行为。

有关有效编译选项的详细信息，请参阅 ::compile_option=。

RubyVM::InstructionSequence.compile_parsey("a = 1 + 2")
#=> <RubyVM::InstructionSequence:<compiled>@<compiled>>

path = "test.rb"
RubyVM::InstructionSequence.compile_parsey(File.read(path), path, File.expand_path(path))
#=> <RubyVM::InstructionSequence:<compiled>@test.rb:1>

file = File.open("test.rb")
RubyVM::InstructionSequence.compile_parsey(file)
#=> <RubyVM::InstructionSequence:<compiled>@<compiled>:1>

path = File.expand_path("test.rb")
RubyVM::InstructionSequence.compile_parsey(File.read(path), path, path)
#=> <RubyVM::InstructionSequence:<compiled>@/absolute/path/to/test.rb:1>

static VALUE
iseqw_s_compile_parsey(int argc, VALUE *argv, VALUE self)
{
    return iseqw_s_compile_parser(argc, argv, self, false);
}

compile_prism(source[, file[, path[, line[, options]]]]) → iseq 单击以切换源代码

接受 source，它可以是 Ruby 代码的字符串，也可以是包含 Ruby 源代码的打开的 File 对象。它使用 prism 进行解析和编译。

可选地接受 file、path 和 line，它们描述了 source 中 Ruby 代码的文件路径、实际路径和第一行号，这些是附加到返回的 iseq 的元数据。

file 用于 ‘__FILE__’ 和异常回溯。path 用于 require_relative 的基础。建议它们应该是相同的完整路径。

options 可以是 true、false 或 Hash，用于修改 Ruby iseq 编译器的默认行为。

有关有效编译选项的详细信息，请参阅 ::compile_option=。

RubyVM::InstructionSequence.compile_prism("a = 1 + 2")
#=> <RubyVM::InstructionSequence:<compiled>@<compiled>>

path = "test.rb"
RubyVM::InstructionSequence.compile_prism(File.read(path), path, File.expand_path(path))
#=> <RubyVM::InstructionSequence:<compiled>@test.rb:1>

file = File.open("test.rb")
RubyVM::InstructionSequence.compile_prism(file)
#=> <RubyVM::InstructionSequence:<compiled>@<compiled>:1>

path = File.expand_path("test.rb")
RubyVM::InstructionSequence.compile_prism(File.read(path), path, path)
#=> <RubyVM::InstructionSequence:<compiled>@/absolute/path/to/test.rb:1>

static VALUE
iseqw_s_compile_prism(int argc, VALUE *argv, VALUE self)
{
    return iseqw_s_compile_parser(argc, argv, self, true);
}

disasm(body) → str 单击以切换源代码

disassemble(body) → str

接受 body，一个 Method 或 Proc 对象，并返回一个 String，其中包含 body 的人类可读指令。

对于 Method 对象

# /tmp/method.rb
def hello
  puts "hello, world"
end

puts RubyVM::InstructionSequence.disasm(method(:hello))

产生

== disasm: <RubyVM::InstructionSequence:hello@/tmp/method.rb>============
0000 trace            8                                               (   1)
0002 trace            1                                               (   2)
0004 putself
0005 putstring        "hello, world"
0007 send             :puts, 1, nil, 8, <ic:0>
0013 trace            16                                              (   3)
0015 leave                                                            (   2)

对于 Proc

# /tmp/proc.rb
p = proc { num = 1 + 2 }
puts RubyVM::InstructionSequence.disasm(p)

产生

== disasm: <RubyVM::InstructionSequence:block in <main>@/tmp/proc.rb>===
== catch table
| catch type: redo   st: 0000 ed: 0012 sp: 0000 cont: 0000
| catch type: next   st: 0000 ed: 0012 sp: 0000 cont: 0012
|------------------------------------------------------------------------
local table (size: 2, argc: 0 [opts: 0, rest: -1, post: 0, block: -1] s1)
[ 2] num
0000 trace            1                                               (   1)
0002 putobject        1
0004 putobject        2
0006 opt_plus         <ic:1>
0008 dup
0009 setlocal         num, 0
0012 leave

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));
}

disasm(body) → str 单击以切换源代码

disassemble(body) → str

接受 body，一个 Method 或 Proc 对象，并返回一个 String，其中包含 body 的人类可读指令。

对于 Method 对象

# /tmp/method.rb
def hello
  puts "hello, world"
end

puts RubyVM::InstructionSequence.disasm(method(:hello))

产生

== disasm: <RubyVM::InstructionSequence:hello@/tmp/method.rb>============
0000 trace            8                                               (   1)
0002 trace            1                                               (   2)
0004 putself
0005 putstring        "hello, world"
0007 send             :puts, 1, nil, 8, <ic:0>
0013 trace            16                                              (   3)
0015 leave                                                            (   2)

对于 Proc

# /tmp/proc.rb
p = proc { num = 1 + 2 }
puts RubyVM::InstructionSequence.disasm(p)

产生

== disasm: <RubyVM::InstructionSequence:block in <main>@/tmp/proc.rb>===
== catch table
| catch type: redo   st: 0000 ed: 0012 sp: 0000 cont: 0000
| catch type: next   st: 0000 ed: 0012 sp: 0000 cont: 0012
|------------------------------------------------------------------------
local table (size: 2, argc: 0 [opts: 0, rest: -1, post: 0, block: -1] s1)
[ 2] num
0000 trace            1                                               (   1)
0002 putobject        1
0004 putobject        2
0006 opt_plus         <ic:1>
0008 dup
0009 setlocal         num, 0
0012 leave

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 单击以切换源代码

从 RubyVM::InstructionSequence.to_binary 创建的二进制格式 String 对象加载 iseq 对象。

此加载器没有验证器，因此加载损坏/修改的二进制文件会导致严重问题。

您不应该加载其他人提供的二进制数据。您应该使用自己转换的二进制数据。

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

RubyVM::InstructionSequence.load_from_binary_extra_data(binary) → str 单击以切换源代码

加载嵌入到二进制格式 String 对象中的额外数据。

static VALUE
iseqw_s_load_from_binary_extra_data(VALUE self, VALUE str)
{
    return rb_iseq_ibf_load_extra_data(str);
}

compile(source[, file[, path[, line[, options]]]]) → iseq 单击以切换源代码

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

接受 source，它可以是 Ruby 代码的字符串，也可以是包含 Ruby 源代码的打开的 File 对象。

可选地接受 file、path 和 line，它们描述了 source 中 Ruby 代码的文件路径、实际路径和第一行号，这些是附加到返回的 iseq 的元数据。

file 用于 ‘__FILE__’ 和异常回溯。path 用于 require_relative 的基础。建议它们应该是相同的完整路径。

options 可以是 true、false 或 Hash，用于修改 Ruby iseq 编译器的默认行为。

有关有效编译选项的详细信息，请参阅 ::compile_option=。

RubyVM::InstructionSequence.compile("a = 1 + 2")
#=> <RubyVM::InstructionSequence:<compiled>@<compiled>>

path = "test.rb"
RubyVM::InstructionSequence.compile(File.read(path), path, File.expand_path(path))
#=> <RubyVM::InstructionSequence:<compiled>@test.rb:1>

file = File.open("test.rb")
RubyVM::InstructionSequence.compile(file)
#=> <RubyVM::InstructionSequence:<compiled>@<compiled>:1>

path = File.expand_path("test.rb")
RubyVM::InstructionSequence.compile(File.read(path), path, path)
#=> <RubyVM::InstructionSequence:<compiled>@/absolute/path/to/test.rb:1>

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) 单击以切换源代码

返回包含给定 proc 或方法的指令序列。

例如，使用 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)>

使用 ::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;
}

公共实例方法

absolute_path() 单击以切换源代码

返回此指令序列的绝对路径。

如果 iseq 是从字符串评估的，则返回 nil。

例如，使用 ::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() 单击以切换源代码

返回此指令序列的基本标签。

例如，使用 irb

iseq = RubyVM::InstructionSequence.compile('num = 1 + 2')
#=> <RubyVM::InstructionSequence:<compiled>@<compiled>>
iseq.base_label
#=> "<compiled>"

使用 ::compile_file

# /tmp/method.rb
def hello
  puts "hello, world"
end

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

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

disasm → str 单击以切换源代码

以人类可读的形式返回指令序列作为 String。

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

产生

== disasm: <RubyVM::InstructionSequence:<compiled>@<compiled>>==========
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, disassemble

disassemble → str

以人类可读的形式返回指令序列作为 String。

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

产生

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

别名为： disasm

each_child{|child_iseq| ...} → iseq 单击以切换源代码

迭代所有直接子指令序列。迭代顺序是实现/版本定义的，因此人们不应依赖于该顺序。

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 单击以切换源代码

评估指令序列并返回结果。

RubyVM::InstructionSequence.compile("1 + 2").eval #=> 3

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

first_lineno() 单击以切换源代码

返回加载指令序列的第一个源代码行的行号。

例如，使用 irb

iseq = RubyVM::InstructionSequence.compile('num = 1 + 2')
#=> <RubyVM::InstructionSequence:<compiled>@<compiled>>
iseq.first_lineno
#=> 1

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

inspect() 单击以切换源代码

返回此指令序列的人类可读的字符串表示形式，包括 label 和 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() 单击以切换源代码

返回此指令序列的标签。

如果在顶层，则为 <main>，如果从字符串评估，则为 <compiled>。

例如，使用 irb

iseq = RubyVM::InstructionSequence.compile('num = 1 + 2')
#=> <RubyVM::InstructionSequence:<compiled>@<compiled>>
iseq.label
#=> "<compiled>"

使用 ::compile_file

# /tmp/method.rb
def hello
  puts "hello, world"
end

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

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

path() 单击以切换源代码

返回此指令序列的路径。

如果 iseq 是从字符串评估的，则返回 <compiled>。

例如，使用 irb

iseq = RubyVM::InstructionSequence.compile('num = 1 + 2')
#=> <RubyVM::InstructionSequence:<compiled>@<compiled>>
iseq.path
#=> "<compiled>"

使用 ::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 单击以切换源代码

如果可用，它将返回记录的脚本行。脚本行不限于 iseq 范围，而是整个源文件的行。

请注意，这是一个用于 Ruby 内部使用、调试和研究的 API。请勿将其用于任何其他目的。不保证兼容性。

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 单击以切换源代码

返回一个包含 14 个元素的 Array，表示具有以下数据的指令序列

magic

标识数据格式的字符串。始终为 YARVInstructionSequence/SimpleDataFormat。

major_version

指令序列的主要版本。

minor_version

指令序列的次要版本。

format_type

标识数据格式的数字。始终为 1。

misc

包含以下内容的哈希值

:arg_size: 方法或块采用的参数总数（如果 iseq 不表示方法或块，则为 0）
:local_size: 局部变量的数量 + 1
:stack_max: 用于计算抛出 SystemStackError 时的堆栈深度。

标签

此指令序列所属的上下文（块、方法、类、模块等）的名称。

如果在顶层，则为 <main>，如果从字符串评估，则为 <compiled>。

路径

加载指令序列的 Ruby 文件的相对路径。

如果 iseq 是从字符串评估的，则返回 <compiled>。

绝对路径

加载指令序列的 Ruby 文件的绝对路径。

如果 iseq 是从字符串评估的，则返回 nil。

首行号

加载指令序列的第一个源代码行的行号。

类型

指令序列的类型。

有效值包括 :top、:method、:block、:class、:rescue、:ensure、:eval、:main 和 plain。

局部变量

一个数组，包含所有参数和局部变量的名称，以符号形式表示。

参数

一个包含参数信息的 Hash 对象。

有关这些值的更多信息，请参阅 vm_core.h。

捕获表

一个异常和控制流操作符（rescue、next、redo、break 等）的列表。

字节码

一个数组的数组，其中包含构成指令序列主体的指令名称和操作数。

请注意，此格式是 MRI 特有的，并且依赖于版本。

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 点击切换源代码

以 String 对象的形式返回序列化的 iseq 二进制格式数据。可以通过 RubyVM::InstructionSequence.load_from_binary() 方法创建相应的 iseq 对象。

String extra_data 将与二进制数据一起保存。您可以使用 RubyVM::InstructionSequence.load_from_binary_extra_data(binary) 访问此数据。

请注意，转换后的二进制数据不可移植。您不能将此二进制数据移动到另一台机器。您不能使用由其他 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 点击切换源代码

返回指令序列中的跟踪点。返回一个 [行号, 事件符号] 对的数组。

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;
}