27 #include "insns_info.inc" 33 #define hidden_obj_p(obj) (!SPECIAL_CONST_P(obj) && !RBASIC(obj)->klass) 141 if (!pkw)
return size;
143 size +=
sizeof(
struct rb_iseq_param_keyword);
144 size +=
sizeof(
VALUE) * (pkw->num - pkw->required_num);
242 if (type == ISEQ_TYPE_TOP) {
245 else if (type == ISEQ_TYPE_METHOD || type == ISEQ_TYPE_CLASS) {
256 if (type == ISEQ_TYPE_MAIN) {
271 const rb_iseq_t *parent,
enum iseq_type type,
309 if (
RTEST(coverages)) {
353 #define SET_COMPILE_OPTION(o, h, mem) \ 354 { VALUE flag = rb_hash_aref((h), ID2SYM(rb_intern(#mem))); \ 355 if (flag == Qtrue) { (o)->mem = 1; } \ 356 else if (flag == Qfalse) { (o)->mem = 0; } \ 358 #define SET_COMPILE_OPTION_NUM(o, h, mem) \ 359 { VALUE num = rb_hash_aref(opt, ID2SYM(rb_intern(#mem))); \ 360 if (!NIL_P(num)) (o)->mem = NUM2INT(num); \ 374 #undef SET_COMPILE_OPTION 375 #undef SET_COMPILE_OPTION_NUM 394 else if (opt ==
Qtrue) {
412 #define SET_COMPILE_OPTION(o, h, mem) \ 413 rb_hash_aset((h), ID2SYM(rb_intern(#mem)), (o)->mem ? Qtrue : Qfalse) 414 #define SET_COMPILE_OPTION_NUM(o, h, mem) \ 415 rb_hash_aset((h), ID2SYM(rb_intern(#mem)), INT2NUM((o)->mem)) 430 #undef SET_COMPILE_OPTION 431 #undef SET_COMPILE_OPTION_NUM 437 const rb_iseq_t *parent,
enum iseq_type type)
440 &COMPILE_OPTION_DEFAULT);
447 &COMPILE_OPTION_DEFAULT);
454 path, absolute_path,
INT2FIX(0),
455 parent, ISEQ_TYPE_MAIN, &COMPILE_OPTION_DEFAULT);
481 prepare_iseq_build(iseq, name, path, absolute_path, first_lineno, parent, type, option);
501 #define CHECK_ARRAY(v) rb_convert_type((v), T_ARRAY, "Array", "to_ary") 502 #define CHECK_HASH(v) rb_convert_type((v), T_HASH, "Hash", "to_hash") 503 #define CHECK_STRING(v) rb_convert_type((v), T_STRING, "String", "to_str") 504 #define CHECK_SYMBOL(v) rb_convert_type((v), T_SYMBOL, "Symbol", "to_sym") 507 static enum iseq_type
518 const ID id_defined_guard =
rb_intern(
"defined_guard");
522 if (
typeid == id_top)
return ISEQ_TYPE_TOP;
523 if (
typeid == id_method)
return ISEQ_TYPE_METHOD;
524 if (
typeid == id_block)
return ISEQ_TYPE_BLOCK;
525 if (
typeid == id_class)
return ISEQ_TYPE_CLASS;
526 if (
typeid == id_rescue)
return ISEQ_TYPE_RESCUE;
527 if (
typeid == id_ensure)
return ISEQ_TYPE_ENSURE;
528 if (
typeid == id_eval)
return ISEQ_TYPE_EVAL;
529 if (
typeid == id_main)
return ISEQ_TYPE_MAIN;
530 if (
typeid == id_defined_guard)
return ISEQ_TYPE_DEFINED_GUARD;
531 return (
enum iseq_type)-1;
539 VALUE magic, version1, version2, format_type, misc;
540 VALUE name, path, absolute_path, first_lineno;
541 VALUE type, body, locals, params, exception;
559 ((void)magic, (
void)version1, (void)version2, (
void)format_type);
576 if (iseq_type == (
enum iseq_type)-1) {
583 parent, (
enum iseq_type)iseq_type, &option);
616 const enum iseq_type type = parent ? ISEQ_TYPE_EVAL : ISEQ_TYPE_TOP;
617 #if !defined(__GNUC__) || (__GNUC__ == 4 && __GNUC_MINOR__ == 8) 618 # define INITIALIZED volatile 640 node = (*parse)(parser, file, src, ln);
651 parent, type, &option);
706 if (local_iseq->
body->
type == ISEQ_TYPE_METHOD) {
743 union {
const rb_iseq_t *in;
void *out; } deconst;
791 case 5: opt = argv[--i];
792 case 4: line = argv[--i];
793 case 3: path = argv[--i];
794 case 2: file = argv[--i];
835 case 2: opt = argv[--i];
855 line,
NULL, ISEQ_TYPE_TOP, &option));
896 COMPILE_OPTION_DEFAULT =
option;
1190 const int debug = 0;
1201 else if (
size == 1) {
1205 for (i=1; i<
size; i++) {
1206 if (debug) printf(
"table[%"PRIuSIZE"]: position: %d, line: %d, pos: %"PRIuSIZE"\n",
1209 if (table[i].position == pos) {
1212 if (table[i].position > pos) {
1249 str = default_value;
1262 const char *types = insn_op_types(insn);
1263 char type = types[op_no];
1276 if (insn == BIN(getlocal) || insn == BIN(setlocal)) {
1282 for (i = 0; i <
level; i++) {
1382 if (dladdr((
void *)op, &info) && info.dli_sname) {
1392 rb_bug(
"insn_operand_intern: unknown operand type: %c", type);
1405 VALUE insn = code[pos];
1406 int len = insn_len(insn);
1408 const char *types = insn_op_types(insn);
1410 const char *insn_name_buff;
1412 insn_name_buff = insn_name(insn);
1418 (
int)strcspn(insn_name_buff,
"_"), insn_name_buff);
1421 for (j = 0; types[j]; j++) {
1422 const char *types = insn_op_types(insn);
1424 len, pos, &code[pos + j + 2],
1435 unsigned int prev = pos == 0 ? 0 :
find_line_no(iseq, pos - 1);
1436 if (line_no && line_no != prev) {
1438 slen = (slen > 70) ? 0 : (70 - slen);
1439 str =
rb_str_catf(str,
"%*s(%4d)", (
int)slen,
"", line_no);
1457 case CATCH_TYPE_RESCUE:
1459 case CATCH_TYPE_ENSURE:
1461 case CATCH_TYPE_RETRY:
1463 case CATCH_TYPE_BREAK:
1465 case CATCH_TYPE_REDO:
1467 case CATCH_TYPE_NEXT:
1470 rb_bug(
"unknown catch type (%d)", type);
1497 enum {header_minlen = 72};
1508 memset(
RSTRING_PTR(str) + l,
'=', header_minlen - l);
1520 "| catch type: %-6s st: %04d ed: %04d sp: %04d cont: %04d\n",
1522 (
int)entry->
end, (
int)entry->
sp, (
int)entry->
cont);
1529 rb_str_cat2(str,
"|-------------------------------------" 1530 "-----------------------------------\n");
1538 "local table (size: %d, argc: %d " 1539 "[opts: %d, rest: %d, post: %d, block: %d, kw: %d@%d, kwrest: %d])\n",
1554 char argi[0x100] =
"";
1555 char opti[0x100] =
"";
1560 if (li >= argc && li < argc + opts) {
1566 snprintf(argi,
sizeof(argi),
"%s%s%s%s%s",
1587 for (n = 0; n <
size;) {
1742 #include "node_name.inc" 1744 rb_bug(
"unknown node (%d)", node);
1749 #define DECL_SYMBOL(name) \ 1750 static VALUE sym_##name 1752 #define INIT_SYMBOL(name) \ 1753 sym_##name = ID2SYM(rb_intern(#name)) 1775 rb_bug(
"exception_type2symbol: unknown type %d", (
int)type);
1795 unsigned int line = 0;
1796 VALUE *seq, *iseq_original;
1807 static VALUE insn_syms[VM_INSTRUCTION_SIZE];
1822 for (i=0; i<VM_INSTRUCTION_SIZE; i++) {
1838 case ISEQ_TYPE_TOP: type = sym_top;
break;
1839 case ISEQ_TYPE_METHOD: type = sym_method;
break;
1840 case ISEQ_TYPE_BLOCK: type = sym_block;
break;
1841 case ISEQ_TYPE_CLASS: type = sym_class;
break;
1842 case ISEQ_TYPE_RESCUE: type = sym_rescue;
break;
1843 case ISEQ_TYPE_ENSURE: type = sym_ensure;
break;
1844 case ISEQ_TYPE_EVAL: type = sym_eval;
break;
1845 case ISEQ_TYPE_MAIN: type = sym_main;
break;
1846 case ISEQ_TYPE_DEFINED_GUARD: type = sym_defined_guard;
break;
1847 default:
rb_bug(
"unsupported iseq type");
1874 for (j = 0; j <
len; j++) {
1912 for (seq = iseq_original; seq < iseq_original + iseq->
body->
iseq_size; ) {
1913 VALUE insn = *seq++;
1914 int j,
len = insn_len(insn);
1915 VALUE *nseq = seq + len - 1;
1919 for (j=0; j<len-1; j++, seq++) {
1920 switch (insn_op_type(insn, j)) {
1922 unsigned long idx = nseq - iseq_original + *seq;
1999 unsigned long idx = nseq - iseq_original + pos;
2009 #if SIZEOF_VALUE <= SIZEOF_LONG 2018 rb_bug(
"unknown operand: %c", insn_op_type(insn, j));
2052 if (
st_lookup(labels_table, pos, &label)) {
2101 ID req, opt, rest, block,
key, keyrest;
2102 #define PARAM_TYPE(type) rb_ary_push(a = rb_ary_new2(2), ID2SYM(type)) 2103 #define PARAM_ID(i) iseq->body->local_table[(i)] 2104 #define PARAM(i, type) ( \ 2106 rb_id2str(PARAM_ID(i)) ? \ 2107 rb_ary_push(a, ID2SYM(PARAM_ID(i))) : \ 2125 for (; i < r; i++) {
2185 static const char expr_names[][18] = {
2187 "instance-variable",
2204 if ((
unsigned)(type - 1) >= (
unsigned)
numberof(expr_names))
return 0;
2205 estr = expr_names[type - 1];
2206 if (!estr[0])
return 0;
2207 defs =
GET_VM()->defined_strings;
2210 GET_VM()->defined_strings = defs;
2234 VALUE *iseq_original;
2237 for (pos = 0; cont && pos < iseq->
body->
iseq_size; pos += insn_len(insn)) {
2238 insn = iseq_original[pos];
2240 if (insn == BIN(trace)) {
2252 cont = (*func)(line, &events, data);
2253 if (current_events != events) {
2255 iseq_original[pos+1] = encoded[pos+1] =
2297 if (data->
pos == 0) {
2343 if (data.prev == 0) {
static VALUE iseq_inspect(const rb_iseq_t *iseq)
int rb_iseqw_line_trace_each(VALUE iseqw, int(*func)(int line, rb_event_flag_t *events_ptr, void *d), void *data)
VALUE rb_iseqw_line_trace_all(VALUE iseqw)
#define VM_CALL_ARGS_BLOCKARG
union iseq_inline_storage_entry * is_entries
ID rb_check_id(volatile VALUE *)
Returns ID for the given name if it is interned already, or 0.
VALUE iseq_ibf_load_extra_data(VALUE str)
rb_iseq_t * rb_iseq_new(NODE *node, VALUE name, VALUE path, VALUE absolute_path, const rb_iseq_t *parent, enum iseq_type type)
unsigned int rb_iseq_line_no(const rb_iseq_t *iseq, size_t pos)
VALUE rb_ary_entry(VALUE ary, long offset)
void rb_bug(const char *fmt,...)
void ibf_load_iseq_complete(rb_iseq_t *iseq)
#define RUBY_TYPED_FREE_IMMEDIATELY
void rb_iseq_build_from_ary(rb_iseq_t *iseq, VALUE misc, VALUE locals, VALUE params, VALUE exception, VALUE body)
NODE * rb_parser_compile_string_path(VALUE vparser, VALUE f, VALUE s, int line)
const rb_iseq_t * rb_method_iseq(VALUE body)
#define DECL_SYMBOL(name)
void rb_iseq_make_compile_option(rb_compile_option_t *option, VALUE opt)
static VALUE iseqw_path(VALUE self)
static const rb_iseq_t * iseqw_check(VALUE iseqw)
#define RB_OBJ_WRITTEN(a, oldv, b)
static unsigned int hash(str, len) register const char *str
VALUE rb_iseq_method_name(const rb_iseq_t *iseq)
static void make_compile_option(rb_compile_option_t *option, VALUE opt)
void rb_undef_alloc_func(VALUE)
void rb_define_singleton_method(VALUE obj, const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a singleton method for obj.
#define OPT_DEBUG_FROZEN_STRING_LITERAL
void rb_iseq_mark(const rb_iseq_t *iseq)
VALUE rb_fstring_cstr(const char *str)
static size_t param_keyword_size(const struct rb_iseq_param_keyword *pkw)
static enum iseq_type iseq_type_from_sym(VALUE type)
static const rb_iseq_t * rb_iseq_check(const rb_iseq_t *iseq)
#define ISEQ_MAJOR_VERSION
NODE * rb_parser_compile_file_path(VALUE vparser, VALUE fname, VALUE file, int start)
#define TypedData_Wrap_Struct(klass, data_type, sval)
static VALUE iseqw_s_compile_option_set(VALUE self, VALUE opt)
struct iseq_compile_data_storage * storage_head
static const rb_iseq_t * vm_proc_iseq(VALUE procval)
VALUE rb_iseqw_line_trace_specify(VALUE iseqval, VALUE pos, VALUE set)
struct rb_iseq_constant_body::@196::@197 flags
void rb_define_private_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
static VALUE id_to_name(ID id, VALUE default_value)
rb_iseq_t * rb_iseq_new_with_opt(NODE *node, VALUE name, VALUE path, VALUE absolute_path, VALUE first_lineno, const rb_iseq_t *parent, enum iseq_type type, const rb_compile_option_t *option)
union rb_iseq_struct::@198 aux
VALUE rb_ary_push(VALUE ary, VALUE item)
VALUE rb_iseq_absolute_path(const rb_iseq_t *iseq)
VALUE rb_iseq_local_variables(const rb_iseq_t *iseq)
SSL_METHOD *(* func)(void)
VALUE rb_str_concat(VALUE, VALUE)
static VALUE iseqw_first_lineno(VALUE self)
#define OPT_INLINE_CONST_CACHE
VALUE rb_ary_tmp_new(long capa)
VALUE rb_iseq_defined_string(enum defined_type type)
struct rb_iseq_constant_body * body
VALUE rb_funcall(VALUE, ID, int,...)
Calls a method.
static int cdhash_each(VALUE key, VALUE value, VALUE ary)
static VALUE iseqw_base_label(VALUE self)
struct rb_call_info_kw_arg * kw_arg
VALUE rb_iseq_label(const rb_iseq_t *iseq)
VALUE rb_define_class_under(VALUE outer, const char *name, VALUE super)
Defines a class under the namespace of outer.
void rb_raise(VALUE exc, const char *fmt,...)
#define RUBY_MARK_LEAVE(msg)
struct iseq_compile_data_storage * next
struct rb_iseq_constant_body::@196 param
parameter information
static VALUE iseqw_to_binary(int argc, VALUE *argv, VALUE self)
#define VM_CALL_ARGS_SPLAT
void rb_gc_mark(VALUE ptr)
VALUE rb_hash_lookup(VALUE hash, VALUE key)
static VALUE iseqw_s_compile(int argc, VALUE *argv, VALUE self)
VALUE rb_file_open_str(VALUE, const char *)
int rb_str_cmp(VALUE, VALUE)
static VALUE iseq_load(VALUE data, const rb_iseq_t *parent, VALUE opt)
static VALUE parse(int argc, VALUE *argv, VALUE self)
static void set_relation(rb_iseq_t *iseq, const rb_iseq_t *piseq)
static VALUE iseqw_s_disasm(VALUE klass, VALUE body)
void rb_undef_method(VALUE klass, const char *name)
static VALUE iseqw_eval(VALUE self)
rb_iseq_t * rb_iseq_compile_on_base(VALUE src, VALUE file, VALUE line, const struct rb_block *base_block)
const rb_iseq_t * rb_iseq_load_iseq(VALUE fname)
static VALUE iseqw_label(VALUE self)
const char * rb_obj_classname(VALUE)
#define OPT_TAILCALL_OPTIMIZATION
const rb_compile_option_t * option
VALUE iseq_ibf_dump(const rb_iseq_t *iseq, VALUE opt)
const VALUE catch_table_ary
RUBY_SYMBOL_EXPORT_BEGIN typedef unsigned long st_data_t
enum iseq_catch_table_entry::catch_type type
static size_t rb_call_info_kw_arg_bytes(int keyword_len)
const VALUE * iseq_encoded
struct rb_id_table * ivar_cache_table
void rb_hash_foreach(VALUE hash, int(*func)(ANYARGS), VALUE farg)
#define ISEQ_MINOR_VERSION
rb_iseq_t * rb_iseq_compile(VALUE src, VALUE file, VALUE line)
void rb_exc_raise(VALUE mesg)
#define SET_COMPILE_OPTION_NUM(o, h, mem)
#define ISEQ_NOT_LOADED_YET
#define RB_TYPE_P(obj, type)
void * ruby_xcalloc(size_t n, size_t size)
static VALUE iseqw_s_load_from_binary(VALUE self, VALUE str)
static VALUE coverage(VALUE fname, int n)
static rb_compile_option_t COMPILE_OPTION_DEFAULT
#define OPT_PEEPHOLE_OPTIMIZATION
int rb_str_symname_p(VALUE)
#define RUBY_TYPED_WB_PROTECTED
static VALUE iseqw_s_load_from_binary_extra_data(VALUE self, VALUE str)
void rb_id_table_free(struct rb_id_table *tbl)
static VALUE CHECK_INTEGER(VALUE v)
static int rb_obj_is_iseq(VALUE iseq)
VALUE rb_hash_aset(VALUE hash, VALUE key, VALUE val)
unsigned int local_table_size
RUBY_EXTERN VALUE rb_cObject
static size_t iseq_memsize(const rb_iseq_t *iseq)
static VALUE prepare_iseq_build(rb_iseq_t *iseq, VALUE name, VALUE path, VALUE absolute_path, VALUE first_lineno, const rb_iseq_t *parent, enum iseq_type type, const rb_compile_option_t *option)
static VALUE register_label(struct st_table *table, unsigned long idx)
struct rb_call_info * ci_entries
VALUE rb_get_coverages(void)
VALUE rb_str_cat2(VALUE, const char *)
static VALUE iseqw_s_compile_option_get(VALUE self)
static unsigned int find_line_no(const rb_iseq_t *iseq, size_t pos)
static VALUE obj_resurrect(VALUE obj)
#define SIZEOF_ISEQ_COMPILE_DATA_STORAGE
static VALUE make_compile_option_value(rb_compile_option_t *option)
VALUE rb_iseqw_new(const rb_iseq_t *iseq)
VALUE rb_iseq_first_lineno(const rb_iseq_t *iseq)
VALUE rb_insn_operand_intern(const rb_iseq_t *iseq, VALUE insn, int op_no, VALUE op, int len, size_t pos, const VALUE *pnop, VALUE child)
#define VM_CALL_ARGS_SIMPLE
void rb_ary_store(VALUE ary, long idx, VALUE val)
static VALUE iseqw_inspect(VALUE self)
#define RUBY_MARK_ENTER(msg)
VALUE * rb_iseq_original_iseq(const rb_iseq_t *iseq)
static const rb_data_type_t iseqw_data_type
static rb_iseq_location_t * iseq_location_setup(rb_iseq_t *iseq, VALUE path, VALUE absolute_path, VALUE name, VALUE first_lineno)
VALUE rb_parser_set_context(VALUE vparser, const struct rb_block *base, int main)
void rb_gc_register_mark_object(VALUE obj)
const struct rb_iseq_constant_body::@196::rb_iseq_param_keyword * keyword
#define OPT_INSTRUCTIONS_UNIFICATION
#define ISEQ_COVERAGE_SET(iseq, cov)
static VALUE iseqw_s_compile_file(int argc, VALUE *argv, VALUE self)
rb_iseq_t * rb_iseq_new_main(NODE *node, VALUE path, VALUE absolute_path, const rb_iseq_t *parent)
static VALUE iseqw_disasm(VALUE self)
VALUE rb_str_resurrect(VALUE str)
VALUE rb_str_resize(VALUE, long)
static VALUE iseq_data_to_ary(const rb_iseq_t *iseq)
static VALUE exception_type2symbol(VALUE type)
#define INIT_SYMBOL(name)
struct rb_call_cache * cc_entries
#define RUBY_EVENT_SPECIFIED_LINE
#define hidden_obj_p(obj)
VALUE rb_obj_is_proc(VALUE)
unsigned int coverage_enabled
VALUE rb_sprintf(const char *format,...)
#define OPT_TRACE_INSTRUCTION
static const rb_iseq_t * vm_block_iseq(const struct rb_block *block)
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
VALUE rb_iseq_coverage(const rb_iseq_t *iseq)
unsigned int peephole_optimization
static int iseq_catch_table_bytes(int n)
#define SET_COMPILE_OPTION(o, h, mem)
#define ISEQ_COVERAGE(iseq)
VALUE rb_iseq_compile_node(rb_iseq_t *iseq, NODE *node)
VALUE rb_iseq_load(VALUE data, VALUE parent, VALUE opt)
VALUE rb_check_funcall(VALUE, ID, int, const VALUE *)
#define INITIAL_ISEQ_COMPILE_DATA_STORAGE_BUFF_SIZE
#define OPT_STACK_CACHING
VALUE rb_str_new_cstr(const char *)
#define OPT_FROZEN_STRING_LITERAL
#define RARRAY_LENINT(ary)
void rb_iseq_free(const rb_iseq_t *iseq)
enum rb_iseq_constant_body::iseq_type type
static VALUE cleanup_iseq_build(rb_iseq_t *iseq)
int rb_respond_to(VALUE, ID)
register unsigned int len
VALUE rb_ary_new_from_values(long n, const VALUE *elts)
#define StringValueCStr(v)
static VALUE iseq_s_load(int argc, VALUE *argv, VALUE self)
const rb_iseq_t * rb_iseqw_to_iseq(VALUE iseqw)
VALUE rb_iseq_disasm(const rb_iseq_t *iseq)
#define OPT_SPECIALISED_INSTRUCTION
static VALUE iseq_mark_ary_create(int flip_cnt)
struct rb_iseq_struct::@198::@199 loader
static const struct iseq_line_info_entry * get_line_info(const rb_iseq_t *iseq, size_t pos)
static int line_trace_specify(int line, rb_event_flag_t *events_ptr, void *ptr)
const struct iseq_catch_table * catch_table
#define RARRAY_AREF(a, i)
int rb_iseq_disasm_insn(VALUE ret, const VALUE *code, size_t pos, const rb_iseq_t *iseq, VALUE child)
Disassemble a instruction Iseq -> Iseq inspect object.
#define RBASIC_CLASS(obj)
static rb_iseq_t * iseq_imemo_alloc(void)
static VALUE iseqw_new(const rb_iseq_t *iseq)
#define RUBY_FREE_LEAVE(msg)
void rb_error_arity(int argc, int min, int max)
struct rb_iseq_struct * local_iseq
#define RUBY_FREE_ENTER(msg)
const char * ruby_node_name(int node)
VALUE rb_str_catf(VALUE str, const char *format,...)
void rb_iseq_add_mark_object(const rb_iseq_t *iseq, VALUE obj)
VALUE rb_iseq_eval(const rb_iseq_t *iseq)
#define RUBY_MARK_UNLESS_NULL(ptr)
VALUE rb_str_inspect(VALUE)
VALUE rb_iseq_path(const rb_iseq_t *iseq)
VALUE rb_ary_join(VALUE ary, VALUE sep)
static const char * catch_type(int type)
VALUE rb_iseq_base_label(const rb_iseq_t *iseq)
const struct rb_iseq_struct * parent_iseq
VALUE rb_parser_new(void)
static size_t iseqw_memsize(const void *ptr)
VALUE rb_realpath_internal(VALUE basedir, VALUE path, int strict)
const struct iseq_line_info_entry * line_info_table
static void iseqw_mark(void *ptr)
static const rb_compile_option_t COMPILE_OPTION_FALSE
rb_iseq_t * rb_iseq_compile_with_option(VALUE src, VALUE file, VALUE absolute_path, VALUE line, const struct rb_block *base_block, VALUE opt)
VALUE() rb_ary_new_from_args(long n,...)
unsigned int line_info_size
static void set_compile_option_from_hash(rb_compile_option_t *option, VALUE opt)
rb_iseq_t * rb_iseq_new_top(NODE *node, VALUE name, VALUE path, VALUE absolute_path, const rb_iseq_t *parent)
#define CONST_ID(var, str)
VALUE rb_str_intern(VALUE)
#define SPECIAL_CONST_P(x)
#define ISEQ_COMPILE_DATA(iseq)
static VALUE iseqw_s_of(VALUE klass, VALUE body)
VALUE rb_ary_resurrect(VALUE ary)
VALUE rb_iseqw_local_variables(VALUE iseqval)
#define ISEQ_MARK_ARY(iseq)
static int collect_trace(int line, rb_event_flag_t *events_ptr, void *ptr)
const rb_iseq_t * iseq_ibf_load(VALUE str)
static VALUE iseqw_absolute_path(VALUE self)
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
VALUE rb_str_append(VALUE, VALUE)
VALUE rb_iseq_parameters(const rb_iseq_t *iseq, int is_proc)
static rb_iseq_t * iseq_translate(rb_iseq_t *iseq)
#define OPT_OPERANDS_UNIFICATION
static rb_iseq_t * iseq_alloc(void)
static void compile_data_free(struct iseq_compile_data *compile_data)
#define RB_OBJ_WRITE(a, slot, b)
static VALUE iseqw_to_a(VALUE self)
rb_iseq_location_t location
VALUE rb_str_new(const char *, long)