25static int vm_collect_local_variables_in_heap(
const VALUE *dfp,
const struct local_var_list *vars);
27static VALUE rb_eUncaughtThrow;
28static ID id_result, id_tag, id_value;
57 return vm_call0_body(ec, &calling,
argv);
66 .block_handler = vm_passed_block_handler(ec),
72 return vm_call0_body(ec, &calling,
argv);
79 return vm_call0_body(ec, calling,
argv);
85 ID mid = vm_ci_mid(calling->
ci);
93 return vm_call0_cme(ec, calling,
argv, cme);
111 ID mid = vm_ci_mid(ci);
129 vm_push_frame(ec, 0, frame_flags, recv,
130 block_handler, (
VALUE)me,
131 0, reg_cfp->
sp, 0, 0);
149 return vm_call0_cfunc_with_frame(ec, calling,
argv);
160 switch (vm_cc_cme(cc)->
def->type) {
169 *reg_cfp->
sp++ = calling->
recv;
170 for (i = 0; i < calling->
argc; i++) {
174 vm_call_iseq_setup(ec, reg_cfp, calling);
180 ret = vm_call0_cfunc(ec, calling,
argv);
205 ret = vm_call_bmethod_body(ec, calling,
argv);
218 return vm_call0_cme(ec, calling,
argv, orig_cme);
222 return vm_call0_super(ec, calling,
argv,
klass, 0);
225 return vm_call0_cme(ec, calling,
argv, aliased_callable_method_entry(vm_cc_cme(cc)));
229 return method_missing(ec, calling->
recv, vm_ci_mid(ci), calling->
argc,
233 switch (vm_cc_cme(cc)->
def->body.optimize_type) {
245 rb_bug(
"vm_call0: unsupported optimized method type (%d)", vm_cc_cme(cc)->
def->body.optimize_type);
251 rb_bug(
"vm_call0: unsupported method type (%d)", vm_cc_cme(cc)->
def->type);
274 if (VM_FRAME_RUBYFRAME_P(cfp)) {
275 rb_bug(
"vm_call_super: should not be reached");
294 return vm_call_super(ec,
argc,
argv, kw_splat);
310 if (!ec || !(cfp = ec->
cfp)) {
333#ifndef RB_THREAD_LOCAL_SPECIFIER
358 ccs = vm_ccs_create(klass, cme);
363 cc = ccs->entries[0].cc;
367 cc = vm_cc_new(klass, cme, vm_call_general);
369 vm_ccs_push(klass, ccs, ci, cc);
416 rb_vm_t *vm = rb_ec_vm_ptr(ec);
437 return gccct_method_search_slowpath(vm,
klass, mid,
argc, index);
485 call_status = rb_method_call_status(ec, cme, scope, self);
488 return method_missing(ec, recv, mid,
argc,
argv, call_status, kw_splat);
497 call_status = rb_method_call_status(ec, cc ? vm_cc_cme(cc) :
NULL, scope, self);
500 return method_missing(ec, recv, mid,
argc,
argv, call_status, kw_splat);
505 return vm_call0_cc(ec, recv, mid,
argc,
argv, cc, kw_splat);
522check_funcall_exec(
VALUE v)
526 args->
recv, idMethodMissing,
574 ret = basic_obj_respond_to_missing(
ec, klass,
recv,
600 args.
argv = new_args;
603 check_funcall_failed, (
VALUE)&args,
635 me = rb_search_method_entry(
recv,
mid);
636 if (!check_funcall_callable(
ec, me)) {
666 me = rb_search_method_entry(
recv,
mid);
667 if (!check_funcall_callable(
ec, me)) {
688#define type_case(t) t: return #t
733 "method `%"PRIsVALUE"' called on unexpected immediate object (%p)",
734 mname, (
void *)
recv);
736 else if ((flags =
RBASIC(
recv)->flags) == 0) {
738 "method `%"PRIsVALUE"' called on terminated object (%p)",
739 mname, (
void *)
recv);
743 "method `%"PRIsVALUE"' called on broken T_?""?""?(0x%02x) object"
745 mname, type, (
void *)
recv, flags);
749 "method `%"PRIsVALUE"' called on hidden %s object"
751 mname, typestr, (
void *)
recv, flags);
755 "method `%"PRIsVALUE"' called on unexpected %s object"
757 mname, typestr, (
void *)
recv, flags);
766 if (!klass) uncallable_object(
recv,
mid);
789 if (oid != idMethodMissing) {
881 raise_method_missing(
ec,
argc,
argv, obj,
ec->method_missing_reason);
927 format =
rb_fstring_lit(
"protected method `%s' called for %s%s%s");
930 format =
rb_fstring_lit(
"undefined local variable or method `%s' for %s%s%s");
934 format =
rb_fstring_lit(
"super: no superclass method `%s' for %s%s%s");
949 VALUE obj,
int call_status)
958 VALUE *nargv, result, work, klass;
959 VALUE block_handler = vm_passed_block_handler(
ec);
962 ec->method_missing_reason = call_status;
964 if (
id == idMethodMissing) {
982 if (!klass)
goto missing;
985 vm_passed_block_handler_set(
ec, block_handler);
1006 return vm_call0_cc(ec, recv, mid,
argc,
argv, cc,
false);
1009 return rb_call0(ec, recv, mid,
argc,
argv, scope, self);
1049 argc = RARRAY_LENINT(args);
1050 if (
argc >= 0x100) {
1052 RBASIC_CLEAR_CLASS(args);
1089 for (i = 0; i < n; i++) {
1165 if (!
NIL_P(passed_procval)) {
1166 vm_passed_block_handler_set(GET_EC(), passed_procval);
1175 if (!
NIL_P(passed_procval)) {
1176 vm_passed_block_handler_set(GET_EC(), passed_procval);
1186 if (RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(ec, prev_cfp))
return NULL;
1188 return prev_cfp->
sp + 1;
1197 VALUE ret, vargv = 0;
1223 VALUE *tmp_argv = current_vm_stack_arg(ec,
argv);
1228 else if (
argc > 1) {
1238 id = idMethodMissing;
1245 ret = rb_call0(ec, recv,
id,
argc,
argv, scope, self);
1265 return send_internal(
argc,
argv, recv, scope);
1325 return vm_yield(GET_EC(),
argc,
argv, kw_splat);
1337 return rb_yield_0(1, &val);
1344 return rb_yield_0(0,
NULL);
1347 return rb_yield_0(1, &val);
1351#undef rb_yield_values
1356 return rb_yield_0(0, 0);
1365 for (i=0; i<n; i++) {
1370 return rb_yield_0(n,
argv);
1383 return rb_yield_0_kw(
argc,
argv, kw_splat);
1415 return vm_yield_force_blockarg(GET_EC(), values);
1421 return vm_yield_with_block(GET_EC(),
argc,
argv,
1478rb_f_loop(
VALUE self)
1491 const struct vm_ifunc *
const ifunc,
1503 VALUE block_handler;
1508 block_handler = VM_BH_FROM_IFUNC_BLOCK(captured);
1511 block_handler = VM_CF_BLOCK_HANDLER(cfp);
1513 vm_passed_block_handler_set(ec, block_handler);
1515 retval = (*it_proc) (data1);
1521 if (cfp == escape_cfp) {
1529 retval = THROW_DATA_VAL(
err);
1532 SDR(); fprintf(stderr,
"%p, %p\n", (
void *)cfp, (
void *)escape_cfp);
1547 return rb_iterate0(it_proc, data1,
1548 bl_proc ? rb_vm_ifunc_proc_new(bl_proc, (
void *)data2) : 0,
1561iterate_method(
VALUE obj)
1612 return rb_iterate0(iterate_method, (
VALUE)&arg, block, GET_EC());
1616iterate_check_method(
VALUE obj)
1650 const rb_iseq_t *
const parent = vm_block_iseq(base_block);
1654 int isolated_depth = 0;
1657 const VALUE *ep = vm_block_ep(base_block);
1661 isolated_depth = depth;
1664 else if (VM_ENV_LOCAL_P(ep)) {
1667 ep = VM_ENV_PREV_EP(ep);
1689 fname, realpath,
INT2FIX(line),
1690 parent, isolated_depth);
1700 rb_exec_event_hook_script_compiled(GET_EC(), iseq, src);
1717 block.as.captured = *VM_CFP_TO_CAPTURED_BLOCK(cfp);
1718 block.as.captured.self = self;
1719 block.as.captured.code.iseq = cfp->
iseq;
1722 iseq = eval_make_iseq(src,
file, line,
NULL, &block);
1728 if (!cref && block.as.captured.code.val) {
1729 rb_cref_t *orig_cref = vm_get_cref(vm_block_ep(&block));
1730 cref = vm_cref_dup(orig_cref);
1732 vm_set_eval_stack(ec, iseq, cref, &block);
1748 vm_set_eval_stack(ec, iseq,
NULL, &bind->
block);
1752 vm_bind_update_env(scope, bind, vm_make_env_object(ec, ec->
cfp));
1780 VALUE src, scope, vfile, vline;
1797 return eval_string_with_cref(self, src,
NULL,
file, line);
1799 return eval_string_with_scope(scope, src,
file, line);
1857eval_string_wrap_protect(
VALUE data)
1938 VALUE block_handler = VM_CF_BLOCK_HANDLER(cfp);
1939 VALUE new_block_handler = 0;
1944 int is_lambda =
FALSE;
1948 switch (vm_block_handler_type(block_handler)) {
1950 captured = VM_BH_TO_CAPT_BLOCK(block_handler);
1951 new_captured = *captured;
1952 new_block_handler = VM_BH_FROM_ISEQ_BLOCK(&new_captured);
1955 captured = VM_BH_TO_CAPT_BLOCK(block_handler);
1956 new_captured = *captured;
1957 new_block_handler = VM_BH_FROM_IFUNC_BLOCK(&new_captured);
1961 block_handler = vm_proc_to_block_handler(VM_BH_TO_PROC(block_handler));
1969 new_captured.self =
self;
1975 cref = vm_cref_push(ec, under,
ep,
TRUE);
1976 return vm_yield_with_cref(ec,
argc,
argv, kw_splat, cref, is_lambda);
1983 VALUE block_handler = VM_CF_BLOCK_HANDLER(ec->
cfp);
1986 rb_bug(
"rb_yield_refine_block: an iseq block is required");
1991 VALUE new_block_handler = VM_BH_FROM_ISEQ_BLOCK(&new_captured);
1994 CREF_REFINEMENTS_SET(cref, refinements);
1996 new_captured.
self = refinement;
2007 return eval_string_with_cref(
self, src, cref,
file, line);
2015 return yield_under(klass,
self, 1, &
self, kw_splat);
2087 VALUE klass = singleton_class_for_eval(
self);
2094 VALUE klass = singleton_class_for_eval(
self);
2119 VALUE klass = singleton_class_for_eval(
self);
2126 VALUE klass = singleton_class_for_eval(
self);
2234uncaught_throw_tag(
VALUE exc)
2247uncaught_throw_value(
VALUE exc)
2260uncaught_throw_to_s(
VALUE exc)
2263 VALUE tag = uncaught_throw_tag(exc);
2323 return rb_yield_0(1, &
tag);
2423 return vm_catch_protect(
t, func, data, stateptr, GET_EC());
2440 RBASIC_CLEAR_CLASS(vars->
tbl);
2485rb_f_local_variables(
VALUE _)
2492 local_var_list_init(&vars);
2499 if (!VM_ENV_LOCAL_P(cfp->
ep)) {
2501 const VALUE *ep = VM_CF_PREV_EP(cfp);
2503 if (vm_collect_local_variables_in_heap(ep, &vars)) {
2507 while (cfp->
ep != ep) {
2516 return local_var_list_finish(&vars);
2540rb_f_block_given_p(
VALUE _)
2562rb_f_iterator_p(
VALUE self)
2565 return rb_f_block_given_p(self);
2612 rb_define_method(rb_eUncaughtThrow,
"initialize", uncaught_throw_init, -1);
2617 id_result = rb_intern_const(
"result");
2618 id_tag = rb_intern_const(
"tag");
2619 id_value = rb_intern_const(
"value");
VALUE rb_check_array_type(VALUE ary)
#define UNREACHABLE_RETURN
#define rb_ary_subseq(ary, beg, len)
#define rb_define_method(klass, mid, func, arity)
Defines klass#mid.
#define rb_define_private_method(klass, mid, func, arity)
Defines klass#mid and makes it private.
#define rb_define_global_function(mid, func, arity)
Defines rb_mKernel #mid.
#define RB_DEBUG_COUNTER_INC(type)
#define MJIT_FUNC_EXPORTED
char str[HTML_ESCAPE_MAX_LEN+1]
int rb_keyword_given_p(void)
#define rb_ec_raised_p(ec, f)
#define rb_ec_raised_set(ec, f)
#define EC_JUMP_TAG(ec, st)
int rb_ec_stack_check(rb_execution_context_t *ec)
#define PASS_PASSED_BLOCK_HANDLER()
#define PASS_PASSED_BLOCK_HANDLER_EC(ec)
#define RUBY_EVENT_C_CALL
#define RUBY_EVENT_C_RETURN
#define stack_check(ec, water_mark)
void rb_extend_object(VALUE obj, VALUE module)
Extend the object with the module.
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
VALUE rb_singleton_class(VALUE obj)
Returns the singleton class of obj.
VALUE rb_module_new(void)
VALUE rb_special_singleton_class(VALUE obj)
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
int rb_block_given_p(void)
Determines if the current method is given a block.
void rb_raise(VALUE exc, const char *fmt,...)
VALUE rb_rescue2(VALUE(*b_proc)(VALUE), VALUE data1, VALUE(*r_proc)(VALUE, VALUE), VALUE data2,...)
An equivalent of rescue clause.
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
void rb_bug(const char *fmt,...)
VALUE rb_nomethod_err_new(VALUE mesg, VALUE recv, VALUE method, VALUE args, int priv)
VALUE rb_ident_hash_new(void)
VALUE rb_protect(VALUE(*proc)(VALUE), VALUE data, int *pstate)
Protects a function call from potential global escapes from the function.
void rb_warn_deprecated(const char *fmt, const char *suggest,...)
VALUE rb_name_err_new(VALUE mesg, VALUE recv, VALUE method)
VALUE rb_mKernel
Kernel module.
VALUE rb_cObject
Object class.
VALUE rb_obj_alloc(VALUE)
Allocates an instance of klass.
VALUE rb_class_new_instance(int, const VALUE *, VALUE)
Allocates and initializes an instance of klass.
VALUE rb_obj_class(VALUE)
VALUE rb_cBasicObject
BasicObject class.
VALUE rb_cModule
Module class.
VALUE rb_obj_clone(VALUE)
Almost same as Object::clone.
VALUE rb_obj_is_kind_of(VALUE, VALUE)
Determines if obj is a kind of c.
VALUE rb_hash_keys(VALUE hash)
int rb_hash_stlike_update(VALUE hash, st_data_t key, st_update_callback_func *func, st_data_t arg)
VALUE rb_hash_clear(VALUE hash)
int rb_id_table_insert(struct rb_id_table *tbl, ID id, VALUE val)
int rb_id_table_lookup(struct rb_id_table *tbl, ID id, VALUE *valp)
struct vm_ifunc * rb_vm_ifunc_new(rb_block_call_func_t func, const void *data, int min_argc, int max_argc)
#define RETURN_SIZED_ENUMERATOR(obj, argc, argv, size_fn)
#define UNLIMITED_ARGUMENTS
VALUE rb_proc_lambda_p(VALUE)
VALUE rb_str_intern(VALUE)
#define rb_str_new_cstr(str)
VALUE rb_ivar_get(VALUE, ID)
VALUE rb_attr_get(VALUE, ID)
VALUE rb_ivar_set(VALUE, ID, VALUE)
ID rb_check_id(volatile VALUE *)
Returns ID for the given name if it is interned already, or 0.
#define UNALIGNED_MEMBER_PTR(ptr, mem)
VALUE rb_sym_proc_call(ID mid, int argc, const VALUE *argv, int kw_splat, VALUE passed_proc)
#define rb_fstring_lit(str)
void rb_check_funcall_hook(int, VALUE, ID, int, const VALUE *, VALUE)
VALUE rb_vm_top_self(void)
VALUE rb_source_location(int *pline)
void rb_vm_pop_cfunc_frame(void)
#define rb_sym_intern_ascii_cstr(...)
#define rb_method_basic_definition_p(...)
typedef int(ZCALLBACK *close_file_func) OF((voidpf opaque
rb_iseq_t * rb_iseq_new_eval(const rb_ast_body_t *ast, VALUE name, VALUE path, VALUE realpath, VALUE first_lineno, const rb_iseq_t *parent, int isolated_depth)
VALUE rb_iseq_disasm(const rb_iseq_t *iseq)
VALUE rb_iseq_realpath(const rb_iseq_t *iseq)
#define RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg)
rb_block_call_func * rb_block_call_func_t
VALUE rb_block_call_func(RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg))
#define MEMCPY(p1, p2, type, n)
#define ALLOCA_N(type, n)
void rb_add_method(VALUE klass, ID mid, rb_method_type_t type, void *option, rb_method_visibility_t visi)
const rb_callable_method_entry_t * rb_callable_method_entry(VALUE klass, ID id)
@ VM_METHOD_TYPE_ISEQ
Ruby method.
@ VM_METHOD_TYPE_ATTRSET
attr_writer or attr_accessor
@ VM_METHOD_TYPE_CFUNC
C method.
@ VM_METHOD_TYPE_OPTIMIZED
Kernel::send, Proc::call, etc.
@ VM_METHOD_TYPE_REFINED
refinement
@ VM_METHOD_TYPE_NOTIMPLEMENTED
@ VM_METHOD_TYPE_MISSING
wrapper for method_missing(id)
@ VM_METHOD_TYPE_IVAR
attr_reader or attr_accessor
#define METHOD_ENTRY_INVALIDATED(me)
@ OPTIMIZED_METHOD_TYPE_CALL
@ OPTIMIZED_METHOD_TYPE_SEND
#define UNDEFINED_METHOD_ENTRY_P(me)
#define METHOD_ENTRY_CACHED_SET(me)
#define METHOD_ENTRY_BASIC(me)
#define METHOD_ENTRY_VISI(me)
VALUE type(ANYARGS)
ANYARGS-ed function type.
void rb_ast_dispose(rb_ast_t *ast)
#define RUBY_DTRACE_CMETHOD_ENTRY_HOOK(ec, klass, id)
#define RUBY_DTRACE_CMETHOD_RETURN_HOOK(ec, klass, id)
rb_cref_t * rb_vm_cref_new_toplevel(void)
const rb_data_type_t ruby_binding_data_type
#define RARRAY_CONST_PTR(s)
#define RARRAY_CONST_PTR_TRANSIENT
VALUE rb_parser_new(void)
rb_ast_t * rb_parser_compile_string_path(VALUE vparser, VALUE f, VALUE s, int line)
VALUE rb_parser_set_context(VALUE vparser, const struct rb_iseq_struct *base, int main)
#define SafeStringValue(v)
#define StringValuePtr(v)
#define Check_TypedStruct(v, t)
#define RB_PASS_CALLED_KEYWORDS
VALUE rb_str_format(int, const VALUE *, VALUE)
const struct rb_block block
const VALUE defined_class
struct rb_method_definition_struct *const def
const struct rb_callcache * cc
const struct rb_callinfo * ci
const struct vm_ifunc * ifunc
union rb_captured_block::@198 code
unsigned int local_table_size
rb_iseq_location_t location
struct rb_iseq_constant_body * body
VALUE(* invoker)(VALUE recv, int argc, const VALUE *argv, VALUE(*func)(ANYARGS))
union rb_method_definition_struct::@123 body
rb_method_refined_t refined
struct rb_method_entry_struct * orig_me
rb_execution_context_t * ec
const struct rb_callcache * global_cc_cache_table[VM_GLOBAL_CC_CACHE_TABLE_SIZE]
unsigned int respond_to_missing
rb_execution_context_t * ec
const rb_callable_method_entry_t * cme
IFUNC (Internal FUNCtion)
native_tls_key_t ruby_current_ec_key
ruby_value_type
C-level type of an object.
rb_control_frame_t * rb_vm_get_ruby_level_next_cfp(const rb_execution_context_t *ec, const rb_control_frame_t *cfp)
VALUE rb_vm_invoke_proc(rb_execution_context_t *ec, rb_proc_t *proc, int argc, const VALUE *argv, int kw_splat, VALUE passed_block_handler)
void rb_vm_rewind_cfp(rb_execution_context_t *ec, rb_control_frame_t *cfp)
const rb_callable_method_entry_t * rb_resolve_refined_method_callable(VALUE refinements, const rb_callable_method_entry_t *me)
#define VM_CI_ON_STACK(mid_, flags_, argc_, kwarg_)
#define vm_ci_new(mid, flag, argc, kwarg)
#define VM_CC_ON_STACK(clazz, call, aux, cme)
const rb_callable_method_entry_t * rb_vm_frame_method_entry(const rb_control_frame_t *cfp)
void rb_vm_pop_frame(rb_execution_context_t *ec)
@ block_handler_type_ifunc
@ block_handler_type_proc
@ block_handler_type_symbol
@ block_handler_type_iseq
#define EXEC_EVENT_HOOK(ec_, flag_, self_, id_, called_id_, klass_, data_)
#define VM_GLOBAL_CC_CACHE_TABLE_SIZE
#define RUBY_VM_CHECK_INTS(ec)
#define CHECK_VM_STACK_OVERFLOW(cfp, margin)
#define VM_BLOCK_HANDLER_NONE
#define VM_ENV_DATA_INDEX_SPECVAL
#define GetProcPtr(obj, ptr)
#define RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp)
@ VM_FRAME_FLAG_CFRAME_KW
VALUE rb_yield_splat_kw(VALUE values, int kw_splat)
VALUE rb_check_funcall_basic_kw(VALUE recv, ID mid, VALUE ancestor, int argc, const VALUE *argv, int kw_splat)
Calls a method only if it is the basic method of ancestor otherwise returns Qundef;.
VALUE rb_funcall_passing_block(VALUE recv, ID mid, int argc, const VALUE *argv)
VALUE rb_f_send(int argc, VALUE *argv, VALUE recv)
VALUE rb_funcall(VALUE recv, ID mid, int n,...)
Calls a method.
VALUE rb_funcallv_kw(VALUE recv, ID mid, int argc, const VALUE *argv, int kw_splat)
VALUE rb_yield_1(VALUE val)
VALUE rb_funcall_with_block_kw(VALUE recv, ID mid, int argc, const VALUE *argv, VALUE passed_procval, int kw_splat)
VALUE rb_catch_obj(VALUE t, rb_block_call_func_t func, VALUE data)
VALUE rb_call_super_kw(int argc, const VALUE *argv, int kw_splat)
VALUE rb_block_call_kw(VALUE obj, ID mid, int argc, const VALUE *argv, rb_block_call_func_t bl_proc, VALUE data2, int kw_splat)
VALUE rb_yield_values2(int argc, const VALUE *argv)
VALUE rb_eval_string_protect(const char *str, int *pstate)
Evaluates the given string in an isolated binding.
VALUE rb_funcallv_public(VALUE recv, ID mid, int argc, const VALUE *argv)
Calls a method.
const char * rb_type_str(enum ruby_value_type type)
VALUE rb_obj_instance_exec(int argc, const VALUE *argv, VALUE self)
VALUE rb_check_block_call(VALUE obj, ID mid, int argc, const VALUE *argv, rb_block_call_func_t bl_proc, VALUE data2)
VALUE rb_current_receiver(void)
VALUE rb_vm_call0(rb_execution_context_t *ec, VALUE recv, ID id, int argc, const VALUE *argv, const rb_callable_method_entry_t *cme, int kw_splat)
VALUE rb_check_funcall(VALUE recv, ID mid, int argc, const VALUE *argv)
VALUE rb_funcall_passing_block_kw(VALUE recv, ID mid, int argc, const VALUE *argv, int kw_splat)
VALUE rb_block_call(VALUE obj, ID mid, int argc, const VALUE *argv, rb_block_call_func_t bl_proc, VALUE data2)
VALUE rb_make_no_method_exception(VALUE exc, VALUE format, VALUE obj, int argc, const VALUE *argv, int priv)
VALUE rb_yield_values(int n,...)
VALUE rb_yield_refine_block(VALUE refinement, VALUE refinements)
VALUE rb_f_eval(int argc, const VALUE *argv, VALUE self)
VALUE rb_check_funcall_kw(VALUE recv, ID mid, int argc, const VALUE *argv, int kw_splat)
VALUE rb_check_funcall_default(VALUE recv, ID mid, int argc, const VALUE *argv, VALUE def)
void rb_throw(const char *tag, VALUE val)
VALUE rb_yield_force_blockarg(VALUE values)
VALUE rb_check_funcall_with_hook_kw(VALUE recv, ID mid, int argc, const VALUE *argv, rb_check_funcall_hook *hook, VALUE arg, int kw_splat)
VALUE rb_catch_protect(VALUE t, rb_block_call_func *func, VALUE data, enum ruby_tag_type *stateptr)
VALUE rb_check_funcall_with_hook(VALUE recv, ID mid, int argc, const VALUE *argv, rb_check_funcall_hook *hook, VALUE arg)
VALUE rb_lambda_call(VALUE obj, ID mid, int argc, const VALUE *argv, rb_block_call_func_t bl_proc, int min_argc, int max_argc, VALUE data2)
VALUE rb_yield(VALUE val)
VALUE rb_mod_module_eval(int argc, const VALUE *argv, VALUE mod)
void rb_check_stack_overflow(void)
VALUE rb_eval_string(const char *str)
Evaluates the given string in an isolated binding.
VALUE rb_yield_block(RB_BLOCK_CALL_FUNC_ARGLIST(val, arg))
VALUE rb_iterate(VALUE(*it_proc)(VALUE), VALUE data1, rb_block_call_func_t bl_proc, VALUE data2)
VALUE rb_mod_module_exec(int argc, const VALUE *argv, VALUE mod)
VALUE ruby_eval_string_from_file(const char *str, const char *filename)
VALUE rb_obj_instance_eval(int argc, const VALUE *argv, VALUE self)
VALUE rb_eval_string_wrap(const char *str, int *pstate)
Evaluates the given string under a module binding in an isolated binding.
VALUE rb_eval_cmd_kw(VALUE cmd, VALUE arg, int kw_splat)
void rb_parser_warn_location(VALUE, int)
VALUE rb_apply(VALUE recv, ID mid, VALUE args)
Calls a method.
VALUE rb_catch(const char *tag, rb_block_call_func_t func, VALUE data)
VALUE rb_call_super(int argc, const VALUE *argv)
VALUE rb_yield_splat(VALUE values)
VALUE rb_current_realfilepath(void)
VALUE rb_funcallv_public_kw(VALUE recv, ID mid, int argc, const VALUE *argv, int kw_splat)
VALUE rb_funcall_with_block(VALUE recv, ID mid, int argc, const VALUE *argv, VALUE passed_procval)
VALUE rb_vm_call_kw(rb_execution_context_t *ec, VALUE recv, VALUE id, int argc, const VALUE *argv, const rb_callable_method_entry_t *me, int kw_splat)
void rb_throw_obj(VALUE tag, VALUE value)
VALUE rb_yield_values_kw(int argc, const VALUE *argv, int kw_splat)
#define CHECK_CFP_CONSISTENCY(func)
void rb_ec_stack_overflow(rb_execution_context_t *ec, int crit)
#define vm_check_canary(ec, sp)
#define RB_VM_LOCK_ENTER()
#define RB_VM_LOCK_LEAVE()
int def(FILE *source, FILE *dest, int level)