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

Takessource, which can be a string of Ruby code, or an openFile object. that contains Ruby source code.

Optionally takesfile,path, andline which describe the file path, real path and first line number of the ruby code insource which are metadata attached to the returnediseq.

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

options, which can betrue,false or aHash, 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")#=> <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 VALUEiseqw_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_GC_GUARD(ast_value);    rb_vm_pop_frame(ec);    RB_GC_GUARD(v);    return ret;}

Takesfile, aString with the location of a Ruby source file, reads, parses and compiles the file, and returnsiseq, the compiledInstructionSequence with source location metadata set.

Optionally takesoptions, which can betrue,false or aHash, to modify the default behavior of the Ruby iseq compiler.

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

# /tmp/hello.rbputs"Hello, world!"# elsewhereRubyVM::InstructionSequence.compile_file("/tmp/hello.rb")#=> <RubyVM::InstructionSequence:<main>@/tmp/hello.rb>

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

Takesfile, aString with the location of a Ruby source file, reads, parses and compiles the file, and returnsiseq, the compiledInstructionSequence with source location metadata set. It parses and compiles using prism.

Optionally takesoptions, which can betrue,false or aHash, to modify the default behavior of the Ruby iseq compiler.

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

# /tmp/hello.rbputs"Hello, world!"# elsewhereRubyVM::InstructionSequence.compile_file_prism("/tmp/hello.rb")#=> <RubyVM::InstructionSequence:<main>@/tmp/hello.rb>

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

Returns a hash of default options used by the Ruby iseq compiler.

For details, seeInstructionSequence.compile_option=.

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

Sets the default values for various optimizations in the Ruby iseq compiler.

Possible values foroptions includetrue, which enables all options,false which disables all options, andnil which leaves all options unchanged.

You can also pass aHash ofoptions that you want to change, any options not present in the hash will be left unchanged.

Possible option names (which are keys inoptions) which can be set totrue orfalse include:

• :inline_const_cache

• :instructions_unification

• :operands_unification

• :peephole_optimization

• :specialized_instruction

• :tailcall_optimization

Additionally,:debug_level can be set to an integer.

These default options can be overwritten for a single run of the iseq compiler by passing any of the above values as theoptions parameter to::new,::compile and::compile_file.

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

Takessource, which can be a string of Ruby code, or an openFile object. that contains Ruby source code. It parses and compiles using parse.y.

Optionally takesfile,path, andline which describe the file path, real path and first line number of the ruby code insource which are metadata attached to the returnediseq.

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

options, which can betrue,false or aHash, is used to modify the default behavior of the Ruby iseq compiler.

For details regarding valid compile options see::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 VALUEiseqw_s_compile_prism(int argc, VALUE *argv, VALUE self){    return iseqw_s_compile_parser(argc, argv, self, true);}

Takessource, which can be a string of Ruby code, or an openFile object. that contains Ruby source code. It parses and compiles using prism.

Optionally takesfile,path, andline which describe the file path, real path and first line number of the ruby code insource which are metadata attached to the returnediseq.

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

options, which can betrue,false or aHash, is used to modify the default behavior of the Ruby iseq compiler.

For details regarding valid compile options see::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 VALUEiseqw_s_disasm(VALUE klass, VALUE body){    VALUE iseqw = iseqw_s_of(klass, body);    return NIL_P(iseqw) ? Qnil : rb_iseq_disasm(iseqw_check(iseqw));}

Takesbody, aMethod orProc object, and returns aString with the human readable instructions forbody.

For aMethod object:

# /tmp/method.rbdefhelloputs"hello, world"endputsRubyVM::InstructionSequence.disasm(method(:hello))

Produces:

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

For aProc object:

# /tmp/proc.rbp =proc {num =1+2 }putsRubyVM::InstructionSequence.disasm(p)

Produces:

== 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] num0000 trace            1                                               (   1)0002 putobject        10004 putobject        20006 opt_plus         <ic:1>0008 dup0009 setlocal         num, 00012 leave

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

Takesbody, aMethod orProc object, and returns aString with the human readable instructions forbody.

For aMethod object:

# /tmp/method.rbdefhelloputs"hello, world"endputsRubyVM::InstructionSequence.disasm(method(:hello))

Produces:

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

For aProc object:

# /tmp/proc.rbp =proc {num =1+2 }putsRubyVM::InstructionSequence.disasm(p)

Produces:

== 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] num0000 trace            1                                               (   1)0002 putobject        10004 putobject        20006 opt_plus         <ic:1>0008 dup0009 setlocal         num, 00012 leave

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

Load an iseq object from binary formatString object created byRubyVM::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 VALUEiseqw_s_load_from_binary_extra_data(VALUE self, VALUE str){    return rb_iseq_ibf_load_extra_data(str);}

Load extra data embed into binary formatString object.

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

Takessource, which can be a string of Ruby code, or an openFile object. that contains Ruby source code.

Optionally takesfile,path, andline which describe the file path, real path and first line number of the ruby code insource which are metadata attached to the returnediseq.

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

options, which can betrue,false or aHash, 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")#=> <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 VALUEiseqw_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;}

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.rbdef 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 VALUEiseqw_absolute_path(VALUE self){    return rb_iseq_realpath(iseqw_check(self));}

Returns the absolute path of this instruction sequence.

nil if the iseq was evaluated from a string.

For example, using::compile_file:

# /tmp/method.rbdef hello  puts "hello, world"end# in irb> iseq = RubyVM::InstructionSequence.compile_file('/tmp/method.rb')> iseq.absolute_path #=> /tmp/method.rb

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

Returns the base label of this instruction sequence.

For example, using irb:

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

Using::compile_file:

# /tmp/method.rbdef hello  puts "hello, world"end# in irb> iseq = RubyVM::InstructionSequence.compile_file('/tmp/method.rb')> iseq.base_label #=> <main>

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

Returns the instruction sequence as aString in human readable form.

putsRubyVM::InstructionSequence.compile('1 + 2').disasm

Produces:

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

Returns the instruction sequence as aString in human readable form.

putsRubyVM::InstructionSequence.compile('1 + 2').disasm

Produces:

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

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

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

static VALUEiseqw_eval(VALUE self){    const rb_iseq_t *iseq = iseqw_check(self);    if (0 == ISEQ_BODY(iseq)->iseq_size) {        rb_raise(rb_eTypeError, "attempt to evaluate dummy InstructionSequence");    }    return rb_iseq_eval(iseq, rb_current_namespace());}

Evaluates the instruction sequence and returns the result.

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

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

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')#=> <RubyVM::InstructionSequence:<compiled>@<compiled>>iseq.first_lineno#=> 1

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

Returns a human-readable string representation of this instruction sequence, including thelabel andpath.

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

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')#=> <RubyVM::InstructionSequence:<compiled>@<compiled>>iseq.label#=> "<compiled>"

Using::compile_file:

# /tmp/method.rbdef hello  puts "hello, world"end# in irb> iseq = RubyVM::InstructionSequence.compile_file('/tmp/method.rb')> iseq.label #=> <main>

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

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')#=> <RubyVM::InstructionSequence:<compiled>@<compiled>>iseq.path#=> "<compiled>"

Using::compile_file:

# /tmp/method.rbdef hello  puts "hello, world"end# in irb> iseq = RubyVM::InstructionSequence.compile_file('/tmp/method.rb')> iseq.path #=> /tmp/method.rb

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

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 VALUEiseqw_to_a(VALUE self){    const rb_iseq_t *iseq = iseqw_check(self);    return iseq_data_to_ary(iseq);}

Returns anArray with 14 elements representing the instruction sequence with the following data:

magic

A string identifying the data format.AlwaysYARVInstructionSequence/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 ifiseq 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 aSystemStackError 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, andplain.

locals

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

params

AnHash object containing parameter information.

More info about these values can be found invm_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 VALUEiseqw_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);}

Returns serialized iseq binary format data as aString object. A corresponding iseq object is created byRubyVM::InstructionSequence.load_from_binary() method.

String extra_data will be saved with binary data. You can access this data withRubyVM::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 VALUEiseqw_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;}

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