14#include "internal/thread.h"
26static int vm_collect_local_variables_in_heap(
const VALUE *dfp,
const struct local_var_list *vars);
28static VALUE rb_eUncaughtThrow;
29static ID id_result, id_tag, id_value;
32typedef enum call_type {
41static VALUE send_internal(
int argc,
const VALUE *argv,
VALUE recv, call_type scope);
45vm_argv_ruby_array(
VALUE *av,
const VALUE *argv,
int *flags,
int *argc,
int kw_splat)
47 *flags |= VM_CALL_ARGS_SPLAT;
48 VALUE argv_ary = rb_ary_hidden_new(*argc);
49 rb_ary_cat(argv_ary, argv, *argc);
53 av[1] = rb_ary_pop(argv_ary);
58 *flags |= VM_CALL_KW_SPLAT;
59 av[1] = rb_hash_new();
70 return vm_call0_cc(ec, recv,
id, argc, argv, &cc, kw_splat);
77 rb_callable_method_entry_with_refinements(
CLASS_OF(recv),
id, NULL);
79 return rb_vm_call0(ec, recv,
id, argc, argv, me, kw_splat);
83 return rb_funcallv(recv,
id, argc, argv);
90 int flags = kw_splat ? VM_CALL_KW_SPLAT : 0;
94 if (UNLIKELY(vm_cc_cme(cc)->def->type == VM_METHOD_TYPE_ISEQ && argc > VM_ARGC_STACK_MAX)) {
95 use_argv = vm_argv_ruby_array(av, argv, &flags, &argc, kw_splat);
100 .ci = &VM_CI_ON_STACK(
id, flags, argc, NULL),
104 .block_handler = vm_passed_block_handler(ec),
107 .kw_splat = kw_splat,
110 return vm_call0_body(ec, &calling, use_argv);
116 calling->cc = &VM_CC_ON_STACK(
Qfalse, vm_call_general, {{ 0 }}, cme);
117 return vm_call0_body(ec, calling, argv);
123 ID mid = vm_ci_mid(calling->cd->ci);
130 RUBY_VM_CHECK_INTS(ec);
131 return vm_call0_cme(ec, calling, argv, cme);
135 vm_passed_block_handler_set(ec, calling->block_handler);
136 return method_missing(ec, calling->recv, mid, calling->argc, argv, ex, calling->kw_splat);
146 int len = cfunc->argc;
147 VALUE recv = calling->recv;
148 int argc = calling->argc;
149 ID mid = vm_ci_mid(ci);
150 VALUE block_handler = calling->block_handler;
151 int frame_flags = VM_FRAME_MAGIC_CFUNC | VM_FRAME_FLAG_CFRAME | VM_ENV_FLAG_LOCAL;
153 if (calling->kw_splat) {
158 frame_flags |= VM_FRAME_FLAG_CFRAME_KW;
162 RUBY_DTRACE_CMETHOD_ENTRY_HOOK(ec, me->owner, me->def->original_id);
167 vm_push_frame(ec, 0, frame_flags, recv,
168 block_handler, (
VALUE)me,
169 0, reg_cfp->sp, 0, 0);
173 val = (*cfunc->invoker)(recv, argc, argv, cfunc->func);
175 CHECK_CFP_CONSISTENCY(
"vm_call0_cfunc_with_frame");
179 RUBY_DTRACE_CMETHOD_RETURN_HOOK(ec, me->owner, me->def->original_id);
187 return vm_call0_cfunc_with_frame(ec, calling, argv);
193 if (calling->kw_splat &&
195 RB_TYPE_P(argv[calling->argc-1],
T_HASH) &&
213 switch (vm_cc_cme(cc)->def->type) {
214 case VM_METHOD_TYPE_ISEQ:
219 CHECK_VM_STACK_OVERFLOW(reg_cfp, calling->argc + 1);
220 vm_check_canary(ec, reg_cfp->sp);
222 *reg_cfp->sp++ = calling->recv;
223 for (i = 0; i < calling->argc; i++) {
224 *reg_cfp->sp++ = argv[i];
227 vm_call_iseq_setup(ec, reg_cfp, calling);
228 VM_ENV_FLAGS_SET(ec->cfp->ep, VM_FRAME_FLAG_FINISH);
231 case VM_METHOD_TYPE_NOTIMPLEMENTED:
232 case VM_METHOD_TYPE_CFUNC:
233 ret = vm_call0_cfunc(ec, calling, argv);
235 case VM_METHOD_TYPE_ATTRSET:
236 vm_call_check_arity(calling, 1, argv);
237 VM_CALL_METHOD_ATTR(ret,
238 rb_ivar_set(calling->recv, vm_cc_cme(cc)->def->body.attr.id, argv[0]),
241 case VM_METHOD_TYPE_IVAR:
242 vm_call_check_arity(calling, 0, argv);
243 VM_CALL_METHOD_ATTR(ret,
244 rb_attr_get(calling->recv, vm_cc_cme(cc)->def->body.attr.id),
247 case VM_METHOD_TYPE_BMETHOD:
248 ret = vm_call_bmethod_body(ec, calling, argv);
250 case VM_METHOD_TYPE_ZSUPER:
252 VALUE klass = RCLASS_ORIGIN(vm_cc_cme(cc)->defined_class);
253 return vm_call0_super(ec, calling, argv, klass, MISSING_SUPER);
255 case VM_METHOD_TYPE_REFINED:
259 if (cme->def->body.refined.orig_me) {
261 return vm_call0_cme(ec, calling, argv, orig_cme);
264 VALUE klass = cme->defined_class;
265 return vm_call0_super(ec, calling, argv, klass, 0);
267 case VM_METHOD_TYPE_ALIAS:
272 if (cme == orig_cme) rb_bug(
"same!!");
274 if (vm_cc_markable(cc)) {
275 return vm_call0_cme(ec, calling, argv, orig_cme);
282 case VM_METHOD_TYPE_MISSING:
284 vm_passed_block_handler_set(ec, calling->block_handler);
285 return method_missing(ec, calling->recv, vm_ci_mid(ci), calling->argc,
286 argv, MISSING_NOENTRY, calling->kw_splat);
288 case VM_METHOD_TYPE_OPTIMIZED:
289 switch (vm_cc_cme(cc)->def->body.optimized.type) {
290 case OPTIMIZED_METHOD_TYPE_SEND:
291 ret = send_internal(calling->argc, argv, calling->recv, calling->kw_splat ? CALL_FCALL_KW : CALL_FCALL);
293 case OPTIMIZED_METHOD_TYPE_CALL:
296 GetProcPtr(calling->recv, proc);
297 ret = rb_vm_invoke_proc(ec, proc, calling->argc, argv, calling->kw_splat, calling->block_handler);
300 case OPTIMIZED_METHOD_TYPE_STRUCT_AREF:
301 vm_call_check_arity(calling, 0, argv);
302 VM_CALL_METHOD_ATTR(ret,
303 vm_call_opt_struct_aref0(ec, calling),
306 case OPTIMIZED_METHOD_TYPE_STRUCT_ASET:
307 vm_call_check_arity(calling, 1, argv);
308 VM_CALL_METHOD_ATTR(ret,
309 vm_call_opt_struct_aset0(ec, calling, argv[0]),
313 rb_bug(
"vm_call0: unsupported optimized method type (%d)", vm_cc_cme(cc)->def->body.optimized.type);
316 case VM_METHOD_TYPE_UNDEF:
319 rb_bug(
"vm_call0: unsupported method type (%d)", vm_cc_cme(cc)->def->type);
323 RUBY_VM_CHECK_INTS(ec);
330 return rb_vm_call0(ec, recv,
id, argc, argv, me, kw_splat);
336 VALUE recv = ec->cfp->self;
342 if (VM_FRAME_RUBYFRAME_P(cfp)) {
343 rb_bug(
"vm_call_super: should not be reached");
346 klass = RCLASS_ORIGIN(me->defined_class);
348 id = me->def->original_id;
349 me = rb_callable_method_entry(klass,
id);
352 return method_missing(ec, recv,
id, argc, argv, MISSING_SUPER, kw_splat);
354 return rb_vm_call_kw(ec, recv,
id, argc, argv, me, kw_splat);
361 PASS_PASSED_BLOCK_HANDLER_EC(ec);
362 return vm_call_super(ec, argc, argv, kw_splat);
376 if (!ec || !(cfp = ec->cfp)) {
385 if (!rb_ec_raised_p(ec, RAISED_STACKOVERFLOW) &&
386 rb_ec_stack_check(ec)) {
387 rb_ec_raised_set(ec, RAISED_STACKOVERFLOW);
388 rb_ec_stack_overflow(ec, FALSE);
393rb_check_stack_overflow(
void)
395#ifndef RB_THREAD_LOCAL_SPECIFIER
396 if (!ruby_current_ec_key)
return;
399 if (ec) stack_check(ec);
402NORETURN(
static void uncallable_object(
VALUE recv,
ID mid));
417 if (rb_id_table_lookup(cc_tbl, mid, &ccs_data)) {
422 ccs = vm_ccs_create(klass, cc_tbl, mid, cme);
425 for (
int i=0; i<ccs->len; i++) {
426 cc = ccs->entries[i].cc;
427 if (vm_cc_cme(cc) == cme) {
434 const struct rb_callinfo *ci = vm_ci_new(mid, 0, argc, NULL);
435 cc = vm_cc_new(klass, cme, vm_call_general, cc_type_normal);
437 vm_ccs_push(klass, ccs, ci, cc);
448 return (klass >> 3) ^ (
VALUE)mid;
451NOINLINE(
static const struct rb_callcache *gccct_method_search_slowpath(
rb_vm_t *vm,
VALUE klass,
ID mid,
int argc,
unsigned int index));
454gccct_method_search_slowpath(
rb_vm_t *vm,
VALUE klass,
ID mid,
int argc,
unsigned int index)
460 cc = cc_new(klass, mid, argc, cme);
466 return vm->global_cc_cache_table[index] = cc;
476 if (UNLIKELY(!klass)) uncallable_object(recv, mid);
483 unsigned int index = (
unsigned int)(gccct_hash(klass, mid) % VM_GLOBAL_CC_CACHE_TABLE_SIZE);
484 rb_vm_t *vm = rb_ec_vm_ptr(ec);
485 const struct rb_callcache *cc = vm->global_cc_cache_table[index];
488 if (LIKELY(vm_cc_class_check(cc, klass))) {
490 if (LIKELY(!METHOD_ENTRY_INVALIDATED(cme) &&
491 cme->called_id == mid)) {
493 VM_ASSERT(vm_cc_check_cme(cc, rb_callable_method_entry(klass, mid)));
494 RB_DEBUG_COUNTER_INC(gccct_hit);
501 RB_DEBUG_COUNTER_INC(gccct_null);
504 RB_DEBUG_COUNTER_INC(gccct_miss);
505 return gccct_method_search_slowpath(vm, klass, mid, argc, index);
527 call_type call_scope,
VALUE self)
529 enum method_missing_reason call_status;
530 call_type scope = call_scope;
546 const struct rb_callcache *cc = gccct_method_search(ec, recv, mid, argc);
548 if (scope == CALL_PUBLIC) {
549 RB_DEBUG_COUNTER_INC(call0_public);
553 call_status = rb_method_call_status(ec, cme, scope, self);
555 if (UNLIKELY(call_status != MISSING_NONE)) {
556 return method_missing(ec, recv, mid, argc, argv, call_status, kw_splat);
558 else if (UNLIKELY(cc_cme != cme)) {
560 return rb_vm_call_kw(ec, recv, mid, argc, argv, cme, kw_splat);
564 RB_DEBUG_COUNTER_INC(call0_other);
565 call_status = rb_method_call_status(ec, cc ? vm_cc_cme(cc) : NULL, scope, self);
567 if (UNLIKELY(call_status != MISSING_NONE)) {
568 return method_missing(ec, recv, mid, argc, argv, call_status, kw_splat);
573 return vm_call0_cc(ec, recv, mid, argc, argv, cc, kw_splat);
582 unsigned int respond: 1;
583 unsigned int respond_to_missing: 1;
590check_funcall_exec(
VALUE v)
593 return call_method_entry(args->ec, args->defined_class,
594 args->recv, idMethodMissing,
595 args->cme, args->argc, args->argv, args->kw_splat);
602 int ret = args->respond;
604 switch (method_boundp(args->defined_class, args->mid,
605 BOUND_PRIVATE|BOUND_RESPONDS)) {
610 ret = args->respond_to_missing;
626 return vm_respond_to(ec, klass, recv, mid, TRUE);
632 return rb_method_call_status(ec, me, CALL_FCALL, ec->cfp->self) == MISSING_NONE;
642 ret = basic_obj_respond_to_missing(ec, klass, recv,
644 if (!
RTEST(ret))
return def;
645 args.respond = respond > 0;
646 args.respond_to_missing = !UNDEF_P(ret);
648 cme = callable_method_entry(klass, idMethodMissing, &args.defined_class);
650 if (cme && !METHOD_ENTRY_BASIC(cme)) {
653 new_args[0] =
ID2SYM(mid);
657 VM_ASSERT(argc == 0);
662 ec->method_missing_reason = MISSING_NOENTRY;
667 args.argc = argc + 1;
668 args.argv = new_args;
669 args.kw_splat = kw_splat;
671 check_funcall_failed, (
VALUE)&args,
678static VALUE rb_check_funcall_default_kw(
VALUE recv,
ID mid,
int argc,
const VALUE *argv,
VALUE def,
int kw_splat);
683 return rb_check_funcall_default_kw(recv, mid, argc, argv,
Qundef, kw_splat);
693rb_check_funcall_default_kw(
VALUE recv,
ID mid,
int argc,
const VALUE *argv,
VALUE def,
int kw_splat)
695 VM_ASSERT(ruby_thread_has_gvl_p());
700 int respond = check_funcall_respond_to(ec, klass, recv, mid);
705 me = rb_search_method_entry(recv, mid);
706 if (!check_funcall_callable(ec, me)) {
707 VALUE ret = check_funcall_missing(ec, klass, recv, mid, argc, argv,
708 respond, def, kw_splat);
709 if (UNDEF_P(ret)) ret = def;
713 return rb_vm_call_kw(ec, recv, mid, argc, argv, me, kw_splat);
717rb_check_funcall_default(
VALUE recv,
ID mid,
int argc,
const VALUE *argv,
VALUE def)
719 return rb_check_funcall_default_kw(recv, mid, argc, argv, def,
RB_NO_KEYWORDS);
723rb_check_funcall_with_hook_kw(
VALUE recv,
ID mid,
int argc,
const VALUE *argv,
724 rb_check_funcall_hook *hook,
VALUE arg,
int kw_splat)
729 int respond = check_funcall_respond_to(ec, klass, recv, mid);
732 (*hook)(FALSE, recv, mid, argc, argv, arg);
736 me = rb_search_method_entry(recv, mid);
737 if (!check_funcall_callable(ec, me)) {
738 VALUE ret = check_funcall_missing(ec, klass, recv, mid, argc, argv,
739 respond,
Qundef, kw_splat);
740 (*hook)(!UNDEF_P(ret), recv, mid, argc, argv, arg);
744 (*hook)(TRUE, recv, mid, argc, argv, arg);
745 return rb_vm_call_kw(ec, recv, mid, argc, argv, me, kw_splat);
749rb_check_funcall_with_hook(
VALUE recv,
ID mid,
int argc,
const VALUE *argv,
750 rb_check_funcall_hook *hook,
VALUE arg)
752 return rb_check_funcall_with_hook_kw(recv, mid, argc, argv, hook, arg,
RB_NO_KEYWORDS);
758#define type_case(t) t: return #t
776 case type_case(
T_NIL);
794uncallable_object(
VALUE recv,
ID mid)
799 VALUE mname = rb_id2str(mid);
803 "method `%"PRIsVALUE
"' called on unexpected immediate object (%p)",
804 mname, (
void *)recv);
806 else if ((flags =
RBASIC(recv)->flags) == 0) {
808 "method `%"PRIsVALUE
"' called on terminated object (%p)",
809 mname, (
void *)recv);
813 "method `%"PRIsVALUE
"' called on broken T_?""?""?(0x%02x) object"
814 " (%p flags=0x%"PRIxVALUE
")",
815 mname,
type, (
void *)recv, flags);
819 "method `%"PRIsVALUE
"' called on hidden %s object"
820 " (%p flags=0x%"PRIxVALUE
")",
821 mname, typestr, (
void *)recv, flags);
825 "method `%"PRIsVALUE
"' called on unexpected %s object"
826 " (%p flags=0x%"PRIxVALUE
")",
827 mname, typestr, (
void *)recv, flags);
832rb_search_method_entry(
VALUE recv,
ID mid)
836 if (!klass) uncallable_object(recv, mid);
837 return rb_callable_method_entry(klass, mid);
840static inline enum method_missing_reason
843 if (UNLIKELY(UNDEFINED_METHOD_ENTRY_P(me))) {
846 else if (UNLIKELY(me->def->type == VM_METHOD_TYPE_REFINED)) {
847 me = rb_resolve_refined_method_callable(
Qnil, me);
848 if (UNDEFINED_METHOD_ENTRY_P(me))
goto undefined;
851 rb_method_visibility_t visi = METHOD_ENTRY_VISI(me);
854 if (UNLIKELY(visi != METHOD_VISI_PUBLIC)) {
855 if (me->def->original_id == idMethodMissing) {
858 else if (visi == METHOD_VISI_PRIVATE &&
859 scope == CALL_PUBLIC) {
860 return MISSING_PRIVATE;
863 else if (visi == METHOD_VISI_PROTECTED &&
864 scope == CALL_PUBLIC) {
866 VALUE defined_class = me->owner;
867 if (RB_TYPE_P(defined_class,
T_ICLASS)) {
868 defined_class =
RBASIC(defined_class)->klass;
872 return MISSING_PROTECTED;
880 return scope == CALL_VCALL ? MISSING_VCALL : MISSING_NOENTRY;
896rb_call(
VALUE recv,
ID mid,
int argc,
const VALUE *argv, call_type scope)
899 return rb_call0(ec, recv, mid, argc, argv, scope, ec->cfp->self);
903 VALUE obj,
enum method_missing_reason call_status));
945rb_method_missing(
int argc,
const VALUE *argv,
VALUE obj)
948 raise_method_missing(ec, argc, argv, obj, ec->method_missing_reason);
954 int argc,
const VALUE *argv,
int priv)
956 VALUE name = argv[0];
959 format = rb_fstring_lit(
"undefined method `%1$s' for %3$s%4$s");
963 return rb_nomethod_err_new(format, obj, name, args, priv);
966 return rb_name_err_new(format, obj, name);
972 enum method_missing_reason last_call_status)
977 if (UNLIKELY(argc == 0)) {
978 rb_raise(rb_eArgError,
"no method name given");
980 else if (UNLIKELY(!
SYMBOL_P(argv[0]))) {
981 const VALUE e = rb_eArgError;
982 rb_raise(e,
"method name must be a Symbol but %"PRIsVALUE
" is given",
988 if (last_call_status & MISSING_PRIVATE) {
989 format = rb_fstring_lit(
"private method `%1$s' called for %3$s%4$s");
991 else if (last_call_status & MISSING_PROTECTED) {
992 format = rb_fstring_lit(
"protected method `%1$s' called for %3$s%4$s");
994 else if (last_call_status & MISSING_VCALL) {
995 format = rb_fstring_lit(
"undefined local variable or method `%1$s' for %3$s%4$s");
998 else if (last_call_status & MISSING_SUPER) {
999 format = rb_fstring_lit(
"super: no superclass method `%1$s' for %3$s%4$s");
1003 exc = rb_make_no_method_exception(exc, format, obj, argc, argv,
1004 last_call_status & (MISSING_FCALL|MISSING_VCALL));
1005 if (!(last_call_status & MISSING_MISSING)) {
1006 rb_vm_pop_cfunc_frame();
1014 VALUE obj,
int call_status)
1016 vm_passed_block_handler_set(ec, VM_BLOCK_HANDLER_NONE);
1017 raise_method_missing(ec, argc, argv, obj, call_status | MISSING_MISSING);
1023 VALUE *nargv, result, work, klass;
1024 VALUE block_handler = vm_passed_block_handler(ec);
1027 ec->method_missing_reason = call_status;
1029 if (
id == idMethodMissing) {
1038 VM_ASSERT(argc == 0);
1047 if (!klass)
goto missing;
1048 me = rb_callable_method_entry(klass, idMethodMissing);
1049 if (!me || METHOD_ENTRY_BASIC(me))
goto missing;
1050 vm_passed_block_handler_set(ec, block_handler);
1051 result = rb_vm_call_kw(ec, obj, idMethodMissing, argc, argv, me, kw_splat);
1055 raise_method_missing(ec, argc, argv, obj, call_status | MISSING_MISSING);
1060rb_funcallv_scope(
VALUE recv,
ID mid,
int argc,
const VALUE *argv, call_type scope)
1063 const struct rb_callcache *cc = gccct_method_search(ec, recv, mid, argc);
1064 VALUE self = ec->cfp->self;
1067 LIKELY(rb_method_call_status(ec, vm_cc_cme(cc), scope, self) == MISSING_NONE)) {
1069 return vm_call0_cc(ec, recv, mid, argc, argv, cc,
false);
1072 return rb_call0(ec, recv, mid, argc, argv, scope, self);
1082 VM_ASSERT(ruby_thread_has_gvl_p());
1084 return rb_funcallv_scope(recv, mid, argc, argv, CALL_FCALL);
1090 VM_ASSERT(ruby_thread_has_gvl_p());
1092 return rb_call(recv, mid, argc, argv, kw_splat ? CALL_FCALL_KW : CALL_FCALL);
1102 if (argc >= 0x100) {
1103 args = rb_ary_subseq(args, 0, argc);
1104 RBASIC_CLEAR_CLASS(args);
1113 return rb_funcallv(recv, mid, argc, argv);
1133 for (i = 0; i < n; i++) {
1134 argv[i] = va_arg(ar,
VALUE);
1141 return rb_funcallv(recv, mid, n, argv);
1155rb_check_funcall_basic_kw(
VALUE recv,
ID mid,
VALUE ancestor,
int argc,
const VALUE *argv,
int kw_splat)
1160 if (!klass)
return Qundef;
1162 cme = rb_callable_method_entry(klass, mid);
1163 if (cme && METHOD_ENTRY_BASIC(cme) &&
RBASIC_CLASS(cme->defined_class) == ancestor) {
1165 return rb_vm_call0(ec, recv, mid, argc, argv, cme, kw_splat);
1174 return rb_funcallv_scope(recv, mid, argc, argv, CALL_PUBLIC);
1180 return rb_call(recv, mid, argc, argv, kw_splat ? CALL_PUBLIC_KW : CALL_PUBLIC);
1186 PASS_PASSED_BLOCK_HANDLER();
1193 PASS_PASSED_BLOCK_HANDLER();
1194 return rb_call(recv, mid, argc, argv, kw_splat ? CALL_PUBLIC_KW : CALL_PUBLIC);
1200 if (!
NIL_P(passed_procval)) {
1201 vm_passed_block_handler_set(GET_EC(), passed_procval);
1210 if (!
NIL_P(passed_procval)) {
1211 vm_passed_block_handler_set(GET_EC(), passed_procval);
1214 return rb_call(recv, mid, argc, argv, kw_splat ? CALL_PUBLIC_KW : CALL_PUBLIC);
1221 if (RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(ec, prev_cfp))
return NULL;
1222 if (prev_cfp->sp + 1 != argv)
return NULL;
1223 return prev_cfp->sp + 1;
1227send_internal(
int argc,
const VALUE *argv,
VALUE recv, call_type scope)
1232 VALUE ret, vargv = 0;
1234 int public = scope == CALL_PUBLIC || scope == CALL_PUBLIC_KW;
1240 self = RUBY_VM_PREVIOUS_CONTROL_FRAME(ec->cfp)->self;
1244 rb_raise(rb_eArgError,
"no method name given");
1251 if (rb_method_basic_definition_p(
CLASS_OF(recv), idMethodMissing)) {
1258 VALUE *tmp_argv = current_vm_stack_arg(ec, argv);
1259 vid = rb_str_intern(vid);
1263 else if (argc > 1) {
1273 id = idMethodMissing;
1274 ec->method_missing_reason = MISSING_NOENTRY;
1279 PASS_PASSED_BLOCK_HANDLER_EC(ec);
1280 ret = rb_call0(ec, recv,
id, argc, argv, scope, self);
1286send_internal_kw(
int argc,
const VALUE *argv,
VALUE recv, call_type scope)
1291 scope = CALL_PUBLIC_KW;
1294 scope = CALL_FCALL_KW;
1300 return send_internal(argc, argv, recv, scope);
1332 return send_internal_kw(argc, argv, recv, CALL_FCALL);
1350rb_f_public_send(
int argc,
VALUE *argv,
VALUE recv)
1352 return send_internal_kw(argc, argv, recv, CALL_PUBLIC);
1358rb_yield_0_kw(
int argc,
const VALUE * argv,
int kw_splat)
1360 return vm_yield(GET_EC(), argc, argv, kw_splat);
1364rb_yield_0(
int argc,
const VALUE * argv)
1370rb_yield_1(
VALUE val)
1372 return rb_yield_0(1, &val);
1379 return rb_yield_0(0, NULL);
1382 return rb_yield_0(1, &val);
1386#undef rb_yield_values
1391 return rb_yield_0(0, 0);
1400 for (i=0; i<n; i++) {
1401 argv[i] = va_arg(args,
VALUE);
1405 return rb_yield_0(n, argv);
1412 return rb_yield_0(argc, argv);
1418 return rb_yield_0_kw(argc, argv, kw_splat);
1424 VALUE tmp = rb_check_array_type(values);
1427 rb_raise(rb_eArgError,
"not an array");
1437 VALUE tmp = rb_check_array_type(values);
1440 rb_raise(rb_eArgError,
"not an array");
1448rb_yield_force_blockarg(
VALUE values)
1450 return vm_yield_force_blockarg(GET_EC(), values);
1456 return vm_yield_with_block(GET_EC(), argc, argv,
1457 NIL_P(blockarg) ? VM_BLOCK_HANDLER_NONE : blockarg,
1468 const struct vm_ifunc *
const ifunc,
1471 enum ruby_tag_type state;
1476 state = EC_EXEC_TAG();
1480 VALUE block_handler;
1484 captured->code.ifunc = ifunc;
1485 block_handler = VM_BH_FROM_IFUNC_BLOCK(captured);
1488 block_handler = VM_CF_BLOCK_HANDLER(cfp);
1490 vm_passed_block_handler_set(ec, block_handler);
1492 retval = (*it_proc) (data1);
1494 else if (state == TAG_BREAK || state == TAG_RETRY) {
1498 if (cfp == escape_cfp) {
1499 rb_vm_rewind_cfp(ec, cfp);
1502 ec->tag->state = TAG_NONE;
1505 if (state == TAG_RETRY)
goto iter_retry;
1506 retval = THROW_DATA_VAL(err);
1509 SDR(); fprintf(stderr,
"%p, %p\n", (
void *)cfp, (
void *)escape_cfp);
1515 EC_JUMP_TAG(ec, state);
1524 return rb_iterate0(it_proc, data1,
1525 bl_proc ? rb_vm_ifunc_proc_new(bl_proc, (
void *)data2) : 0,
1533 return rb_iterate_internal(it_proc, data1, bl_proc, data2);
1545iterate_method(
VALUE obj)
1550 return rb_call(arg->obj, arg->mid, arg->argc, arg->argv, arg->kw_splat ? CALL_FCALL_KW : CALL_FCALL);
1572 arg.kw_splat = kw_splat;
1573 return rb_iterate_internal(iterate_method, (
VALUE)&arg, bl_proc, data2);
1577rb_lambda_call(
VALUE obj,
ID mid,
int argc,
const VALUE *argv,
1584 if (!bl_proc) rb_raise(rb_eArgError,
"NULL lambda function");
1590 block = rb_vm_ifunc_new(bl_proc, (
void *)data2, min_argc, max_argc);
1591 return rb_iterate0(iterate_method, (
VALUE)&arg, block, GET_EC());
1595iterate_check_method(
VALUE obj)
1604rb_check_block_call(
VALUE obj,
ID mid,
int argc,
const VALUE *argv,
1614 return rb_iterate_internal(iterate_check_method, (
VALUE)&arg, bl_proc, data2);
1620 return rb_call(obj, idEach, 0, 0, CALL_FCALL);
1625#define EVAL_LOCATION_MARK "eval at "
1626#define EVAL_LOCATION_MARK_LEN (int)rb_strlen_lit(EVAL_LOCATION_MARK)
1629get_eval_default_path(
void)
1631 int location_lineno;
1632 VALUE location_path = rb_source_location(&location_lineno);
1633 if (!
NIL_P(location_path)) {
1634 return rb_fstring(rb_sprintf(
"("EVAL_LOCATION_MARK
"%"PRIsVALUE
":%d)",
1635 location_path, location_lineno));
1638 if (!eval_default_path) {
1639 eval_default_path = rb_fstring_lit(
"(eval)");
1640 rb_gc_register_mark_object(eval_default_path);
1642 return eval_default_path;
1649 const VALUE parser = rb_parser_new();
1650 const rb_iseq_t *
const parent = vm_block_iseq(base_block);
1653 int isolated_depth = 0;
1656 int coverage_enabled = (rb_get_coverage_mode() & COVERAGE_TARGET_EVAL) != 0;
1660 const VALUE *ep = vm_block_ep(base_block);
1663 if (VM_ENV_FLAGS(ep, VM_ENV_FLAG_ISOLATED)) {
1664 isolated_depth = depth;
1667 else if (VM_ENV_LOCAL_P(ep)) {
1670 ep = VM_ENV_PREV_EP(ep);
1676 fname = rb_source_location(&line);
1679 if (!UNDEF_P(fname)) {
1680 if (!
NIL_P(fname)) fname = rb_fstring(fname);
1683 fname = get_eval_default_path();
1684 coverage_enabled = FALSE;
1687 rb_parser_set_context(parser, parent, FALSE);
1688 rb_parser_set_script_lines(parser, RBOOL(ruby_vm_keep_script_lines));
1689 ast = rb_parser_compile_string_path(parser, fname, src, line);
1690 if (ast->body.root) {
1691 ast->body.coverage_enabled = coverage_enabled;
1692 iseq = rb_iseq_new_eval(&ast->body,
1693 ISEQ_BODY(parent)->location.label,
1695 parent, isolated_depth);
1697 rb_ast_dispose(ast);
1701 VALUE disasm = rb_iseq_disasm(iseq);
1705 rb_exec_event_hook_script_compiled(GET_EC(), iseq, src);
1722 block.as.captured = *VM_CFP_TO_CAPTURED_BLOCK(cfp);
1723 block.as.captured.self = self;
1724 block.as.captured.code.iseq = cfp->iseq;
1725 block.type = block_type_iseq;
1727 iseq = eval_make_iseq(src, file, line, NULL, &block);
1729 rb_exc_raise(ec->errinfo);
1733 if (!cref && block.as.captured.code.val) {
1734 rb_cref_t *orig_cref = vm_get_cref(vm_block_ep(&block));
1735 cref = vm_cref_dup(orig_cref);
1737 vm_set_eval_stack(ec, iseq, cref, &block);
1748 const rb_iseq_t *iseq = eval_make_iseq(src, file, line, bind, &bind->block);
1750 rb_exc_raise(ec->errinfo);
1753 vm_set_eval_stack(ec, iseq, NULL, &bind->block);
1756 if (ISEQ_BODY(iseq)->local_table_size > 0) {
1757 vm_bind_update_env(scope, bind, vm_make_env_object(ec, ec->cfp));
1783rb_f_eval(
int argc,
const VALUE *argv,
VALUE self)
1785 VALUE src, scope, vfile, vline;
1789 rb_scan_args(argc, argv,
"13", &src, &scope, &vfile, &vline);
1802 return eval_string_with_cref(self, src, NULL, file, line);
1804 return eval_string_with_scope(scope, src, file, line);
1809ruby_eval_string_from_file(
const char *str,
const char *filename)
1814 VALUE self = cfp ? cfp->self : rb_vm_top_self();
1815 return eval_string_with_cref(self,
rb_str_new2(str), NULL, file, 1);
1821 return ruby_eval_string_from_file(str,
"eval");
1825eval_string_protect(
VALUE str)
1833 return rb_protect(eval_string_protect, (
VALUE)str, pstate);
1843eval_string_wrap_protect(
VALUE data)
1846 rb_cref_t *cref = rb_vm_cref_new_toplevel();
1847 cref->klass_or_self = arg->klass;
1856 VALUE self = th->top_self;
1857 VALUE wrapper = th->top_wrapper;
1865 data.top_self = th->top_self;
1866 data.klass = th->top_wrapper;
1869 val = rb_protect(eval_string_wrap_protect, (
VALUE)&data, &state);
1871 th->top_self = self;
1872 th->top_wrapper = wrapper;
1877 else if (state != TAG_NONE) {
1878 EC_JUMP_TAG(th->ec, state);
1886 enum ruby_tag_type state;
1891 if ((state = EC_EXEC_TAG()) == TAG_NONE) {
1897 val = eval_string_with_cref(rb_vm_top_self(), cmd, NULL, 0, 0);
1902 if (state) EC_JUMP_TAG(ec, state);
1909yield_under(
VALUE self,
int singleton,
int argc,
const VALUE *argv,
int kw_splat)
1913 VALUE block_handler = VM_CF_BLOCK_HANDLER(cfp);
1914 VALUE new_block_handler = 0;
1917 const VALUE *ep = NULL;
1919 int is_lambda = FALSE;
1921 if (block_handler != VM_BLOCK_HANDLER_NONE) {
1923 switch (vm_block_handler_type(block_handler)) {
1924 case block_handler_type_iseq:
1925 captured = VM_BH_TO_CAPT_BLOCK(block_handler);
1926 new_captured = *captured;
1927 new_block_handler = VM_BH_FROM_ISEQ_BLOCK(&new_captured);
1929 case block_handler_type_ifunc:
1930 captured = VM_BH_TO_CAPT_BLOCK(block_handler);
1931 new_captured = *captured;
1932 new_block_handler = VM_BH_FROM_IFUNC_BLOCK(&new_captured);
1934 case block_handler_type_proc:
1936 block_handler = vm_proc_to_block_handler(VM_BH_TO_PROC(block_handler));
1938 case block_handler_type_symbol:
1939 return rb_sym_proc_call(
SYM2ID(VM_BH_TO_SYMBOL(block_handler)),
1940 argc, argv, kw_splat,
1941 VM_BLOCK_HANDLER_NONE);
1944 new_captured.self = self;
1947 VM_FORCE_WRITE_SPECIAL_CONST(&VM_CF_LEP(ec->cfp)[VM_ENV_DATA_INDEX_SPECVAL], new_block_handler);
1950 VM_ASSERT(singleton || RB_TYPE_P(self,
T_MODULE) || RB_TYPE_P(self,
T_CLASS));
1951 cref = vm_cref_push(ec, self, ep, TRUE, singleton);
1953 return vm_yield_with_cref(ec, argc, argv, kw_splat, cref, is_lambda);
1957rb_yield_refine_block(
VALUE refinement,
VALUE refinements)
1960 VALUE block_handler = VM_CF_BLOCK_HANDLER(ec->cfp);
1962 if (vm_block_handler_type(block_handler) != block_handler_type_iseq) {
1963 rb_bug(
"rb_yield_refine_block: an iseq block is required");
1968 const VALUE *
const argv = &new_captured.self;
1969 VALUE new_block_handler = VM_BH_FROM_ISEQ_BLOCK(&new_captured);
1970 const VALUE *ep = captured->ep;
1971 rb_cref_t *cref = vm_cref_push(ec, refinement, ep, TRUE, FALSE);
1972 CREF_REFINEMENTS_SET(cref, refinements);
1973 VM_FORCE_WRITE_SPECIAL_CONST(&VM_CF_LEP(ec->cfp)[VM_ENV_DATA_INDEX_SPECVAL], new_block_handler);
1974 new_captured.self = refinement;
1975 return vm_yield_with_cref(ec, 0, argv,
RB_NO_KEYWORDS, cref, FALSE);
1983 rb_cref_t *cref = vm_cref_push(GET_EC(), self, NULL, FALSE, singleton);
1986 return eval_string_with_cref(self, src, cref, file, line);
1990specific_eval(
int argc,
const VALUE *argv,
VALUE self,
int singleton,
int kw_splat)
1994 return yield_under(self, singleton, 1, &self, kw_splat);
2012 file = get_eval_default_path();
2015 return eval_under(self, singleton, code, file, line);
2053rb_obj_instance_eval_internal(
int argc,
const VALUE *argv,
VALUE self)
2083rb_obj_instance_exec_internal(
int argc,
const VALUE *argv,
VALUE self)
2122rb_mod_module_eval_internal(
int argc,
const VALUE *argv,
VALUE mod)
2156rb_mod_module_exec_internal(
int argc,
const VALUE *argv,
VALUE mod)
2181uncaught_throw_init(
int argc,
const VALUE *argv,
VALUE exc)
2198uncaught_throw_tag(
VALUE exc)
2211uncaught_throw_value(
VALUE exc)
2224uncaught_throw_to_s(
VALUE exc)
2226 VALUE mesg = rb_attr_get(exc, id_mesg);
2227 VALUE tag = uncaught_throw_tag(exc);
2260 if (tt->tag == tag) {
2274 ec->errinfo = (
VALUE)THROW_DATA_NEW(tag, NULL, TAG_THROW);
2275 EC_JUMP_TAG(ec, TAG_THROW);
2287 return rb_yield_0(1, &tag);
2359 enum ruby_tag_type state;
2367 if ((state = EC_EXEC_TAG()) == TAG_NONE) {
2369 val = (*func)(tag, data, 1, (
const VALUE *)&tag,
Qnil);
2371 else if (state == TAG_THROW && THROW_DATA_VAL((
struct vm_throw_data *)ec->errinfo) == tag) {
2372 rb_vm_rewind_cfp(ec, saved_cfp);
2373 val = ec->tag->retval;
2387 return vm_catch_protect(t, func, data, stateptr, GET_EC());
2393 enum ruby_tag_type state;
2396 if (state) EC_JUMP_TAG(ec, state);
2403 vars->tbl = rb_ident_hash_new();
2404 RBASIC_CLEAR_CLASS(vars->tbl);
2411 VALUE ary = rb_hash_keys(vars->tbl);
2412 rb_hash_clear(vars->tbl);
2418local_var_list_update(st_data_t *key, st_data_t *value, st_data_t arg,
int existing)
2420 if (existing)
return ST_STOP;
2421 *value = (st_data_t)
Qtrue;
2431 rb_hash_stlike_update(vars->tbl,
ID2SYM(lid), local_var_list_update, idx);
2449rb_f_local_variables(
VALUE _)
2453 rb_control_frame_t *cfp = vm_get_ruby_level_caller_cfp(ec, RUBY_VM_PREVIOUS_CONTROL_FRAME(ec->cfp));
2456 local_var_list_init(&vars);
2459 for (i = 0; i < ISEQ_BODY(cfp->iseq)->local_table_size; i++) {
2460 local_var_list_add(&vars, ISEQ_BODY(cfp->iseq)->local_table[i]);
2463 if (!VM_ENV_LOCAL_P(cfp->ep)) {
2465 const VALUE *ep = VM_CF_PREV_EP(cfp);
2467 if (vm_collect_local_variables_in_heap(ep, &vars)) {
2471 while (cfp->ep != ep) {
2472 cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
2480 return local_var_list_finish(&vars);
2504rb_f_block_given_p(
VALUE _)
2508 cfp = vm_get_ruby_level_caller_cfp(ec, RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp));
2510 return RBOOL(cfp != NULL && VM_CF_BLOCK_HANDLER(cfp) != VM_BLOCK_HANDLER_NONE);
2521rb_f_iterator_p(
VALUE self)
2523 rb_warn_deprecated(
"iterator?",
"block_given?");
2524 return rb_f_block_given_p(self);
2528rb_current_realfilepath(
void)
2532 cfp = vm_get_ruby_level_caller_cfp(ec, RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp));
2534 VALUE path = rb_iseq_realpath(cfp->iseq);
2535 if (
RTEST(path))
return path;
2537 path = rb_iseq_path(cfp->iseq);
2538 if (path == eval_default_path) {
2543 const long len = RSTRING_LEN(path);
2544 if (
len > EVAL_LOCATION_MARK_LEN+1) {
2545 const char *
const ptr = RSTRING_PTR(path);
2546 if (ptr[
len - 1] ==
')' &&
2547 memcmp(ptr,
"("EVAL_LOCATION_MARK, EVAL_LOCATION_MARK_LEN+1) == 0) {
2574 VM_METHOD_TYPE_OPTIMIZED, (
void *)OPTIMIZED_METHOD_TYPE_SEND, METHOD_VISI_PUBLIC);
2576 VM_METHOD_TYPE_OPTIMIZED, (
void *)OPTIMIZED_METHOD_TYPE_SEND, METHOD_VISI_PUBLIC);
2588 rb_eUncaughtThrow =
rb_define_class(
"UncaughtThrowError", rb_eArgError);
2589 rb_define_method(rb_eUncaughtThrow,
"initialize", uncaught_throw_init, -1);
#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 RUBY_EVENT_C_CALL
A method, written in C, is called.
#define RUBY_EVENT_C_RETURN
Return from a method, written in C.
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
void rb_extend_object(VALUE obj, VALUE module)
Extend the object with the module.
VALUE rb_module_new(void)
Creates a new, anonymous module.
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
Retrieves argument from argc and argv to given VALUE references according to the format string.
int rb_keyword_given_p(void)
Determines if the current method is given a keyword argument.
int rb_block_given_p(void)
Determines if the current method is given a block.
#define rb_str_new2
Old name of rb_str_new_cstr.
#define T_COMPLEX
Old name of RUBY_T_COMPLEX.
#define T_FILE
Old name of RUBY_T_FILE.
#define T_STRING
Old name of RUBY_T_STRING.
#define T_MASK
Old name of RUBY_T_MASK.
#define Qundef
Old name of RUBY_Qundef.
#define T_NIL
Old name of RUBY_T_NIL.
#define T_FLOAT
Old name of RUBY_T_FLOAT.
#define T_IMEMO
Old name of RUBY_T_IMEMO.
#define ID2SYM
Old name of RB_ID2SYM.
#define T_BIGNUM
Old name of RUBY_T_BIGNUM.
#define SPECIAL_CONST_P
Old name of RB_SPECIAL_CONST_P.
#define T_STRUCT
Old name of RUBY_T_STRUCT.
#define OBJ_FREEZE
Old name of RB_OBJ_FREEZE.
#define T_FIXNUM
Old name of RUBY_T_FIXNUM.
#define UNREACHABLE_RETURN
Old name of RBIMPL_UNREACHABLE_RETURN.
#define SYM2ID
Old name of RB_SYM2ID.
#define T_DATA
Old name of RUBY_T_DATA.
#define CLASS_OF
Old name of rb_class_of.
#define T_NONE
Old name of RUBY_T_NONE.
#define T_NODE
Old name of RUBY_T_NODE.
#define rb_ary_new4
Old name of rb_ary_new_from_values.
#define T_MODULE
Old name of RUBY_T_MODULE.
#define T_TRUE
Old name of RUBY_T_TRUE.
#define T_RATIONAL
Old name of RUBY_T_RATIONAL.
#define T_ICLASS
Old name of RUBY_T_ICLASS.
#define T_HASH
Old name of RUBY_T_HASH.
#define T_FALSE
Old name of RUBY_T_FALSE.
#define T_UNDEF
Old name of RUBY_T_UNDEF.
#define Qtrue
Old name of RUBY_Qtrue.
#define NUM2INT
Old name of RB_NUM2INT.
#define T_ZOMBIE
Old name of RUBY_T_ZOMBIE.
#define Qnil
Old name of RUBY_Qnil.
#define Qfalse
Old name of RUBY_Qfalse.
#define T_ARRAY
Old name of RUBY_T_ARRAY.
#define T_OBJECT
Old name of RUBY_T_OBJECT.
#define NIL_P
Old name of RB_NIL_P.
#define ALLOCV_N
Old name of RB_ALLOCV_N.
#define T_SYMBOL
Old name of RUBY_T_SYMBOL.
#define T_MATCH
Old name of RUBY_T_MATCH.
#define T_CLASS
Old name of RUBY_T_CLASS.
#define BUILTIN_TYPE
Old name of RB_BUILTIN_TYPE.
#define T_MOVED
Old name of RUBY_T_MOVED.
#define Check_TypedStruct(v, t)
Old name of rb_check_typeddata.
#define ALLOCV_END
Old name of RB_ALLOCV_END.
#define SYMBOL_P
Old name of RB_SYMBOL_P.
#define T_REGEXP
Old name of RUBY_T_REGEXP.
VALUE rb_eNotImpError
NotImplementedError exception.
VALUE rb_eNameError
NameError exception.
VALUE rb_eNoMethodError
NoMethodError exception.
VALUE rb_eRuntimeError
RuntimeError exception.
VALUE rb_mKernel
Kernel module.
VALUE rb_obj_alloc(VALUE klass)
Allocates an instance of the given class.
VALUE rb_class_new_instance(int argc, const VALUE *argv, VALUE klass)
Allocates, then initialises an instance of the given class.
VALUE rb_obj_class(VALUE obj)
Queries the class of an object.
VALUE rb_cBasicObject
BasicObject class.
VALUE rb_cModule
Module class.
VALUE rb_obj_clone(VALUE obj)
Produces a shallow copy of the given object.
VALUE rb_obj_is_kind_of(VALUE obj, VALUE klass)
Queries if the given object is an instance (of possibly descendants) of the given class.
VALUE rb_eval_string_wrap(const char *str, int *state)
Identical to rb_eval_string_protect(), except it evaluates the given string under a module binding in...
VALUE rb_funcall_passing_block(VALUE recv, ID mid, int argc, const VALUE *argv)
Identical to rb_funcallv_public(), except you can pass the passed block.
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)
Identical to rb_funcallv(), except you can specify how to handle the last element of the given array.
VALUE rb_funcall_with_block(VALUE recv, ID mid, int argc, const VALUE *argv, VALUE procval)
Identical to rb_funcallv_public(), except you can pass a block.
VALUE rb_eval_string_protect(const char *str, int *state)
Identical to rb_eval_string(), except it avoids potential global escapes.
VALUE rb_call_super_kw(int argc, const VALUE *argv, int kw_splat)
Identical to rb_call_super(), except you can specify how to handle the last element of the given arra...
VALUE rb_funcallv_public(VALUE recv, ID mid, int argc, const VALUE *argv)
Identical to rb_funcallv(), except it only takes public methods into account.
VALUE rb_current_receiver(void)
This resembles ruby's self.
VALUE rb_funcall_passing_block_kw(VALUE recv, ID mid, int argc, const VALUE *argv, int kw_splat)
Identical to rb_funcallv_passing_block(), except you can specify how to handle the last element of th...
VALUE rb_funcall_with_block_kw(VALUE recv, ID mid, int argc, const VALUE *argv, VALUE procval, int kw_splat)
Identical to rb_funcallv_with_block(), except you can specify how to handle the last element of the g...
VALUE rb_eval_string(const char *str)
Evaluates the given string.
VALUE rb_call_super(int argc, const VALUE *argv)
This resembles ruby's super.
VALUE rb_funcallv_public_kw(VALUE recv, ID mid, int argc, const VALUE *argv, int kw_splat)
Identical to rb_funcallv_public(), except you can specify how to handle the last element of the given...
#define UNLIMITED_ARGUMENTS
This macro is used in conjunction with rb_check_arity().
static int rb_check_arity(int argc, int min, int max)
Ensures that the passed integer is in the passed range.
int rb_is_local_id(ID id)
Classifies the given ID, then sees if it is a local variable.
VALUE rb_proc_lambda_p(VALUE recv)
Queries if the given object is a lambda.
#define rb_str_new_cstr(str)
Identical to rb_str_new, except it assumes the passed pointer is a pointer to a C string.
VALUE rb_ivar_set(VALUE obj, ID name, VALUE val)
Identical to rb_iv_set(), except it accepts the name as an ID instead of a C string.
VALUE rb_ivar_get(VALUE obj, ID name)
Identical to rb_iv_get(), except it accepts the name as an ID instead of a C string.
VALUE rb_check_funcall(VALUE recv, ID mid, int argc, const VALUE *argv)
Identical to rb_funcallv(), except it returns RUBY_Qundef instead of raising rb_eNoMethodError.
VALUE rb_check_funcall_kw(VALUE recv, ID mid, int argc, const VALUE *argv, int kw_splat)
Identical to rb_check_funcall(), except you can specify how to handle the last element of the given a...
VALUE rb_mod_module_eval(int argc, const VALUE *argv, VALUE mod)
Identical to rb_obj_instance_eval(), except it evaluates within the context of module.
VALUE rb_mod_module_exec(int argc, const VALUE *argv, VALUE mod)
Identical to rb_obj_instance_exec(), except it evaluates within the context of module.
VALUE rb_obj_instance_exec(int argc, const VALUE *argv, VALUE recv)
Executes the given block within the context of the receiver.
VALUE rb_eval_cmd_kw(VALUE cmd, VALUE arg, int kw_splat)
This API is practically a variant of rb_proc_call_kw() now.
VALUE rb_apply(VALUE recv, ID mid, VALUE args)
Identical to rb_funcallv(), except it takes Ruby's array instead of C's.
VALUE rb_obj_instance_eval(int argc, const VALUE *argv, VALUE recv)
Evaluates a string containing Ruby source code, or the given block, within the context of the receive...
static ID rb_intern_const(const char *str)
This is a "tiny optimisation" over rb_intern().
ID rb_check_id(volatile VALUE *namep)
Detects if the given name is already interned or not.
int len
Length of the buffer.
VALUE rb_str_format(int argc, const VALUE *argv, VALUE fmt)
Formats a string.
#define RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg)
Shim for block function parameters.
VALUE rb_each(VALUE obj)
This is a shorthand of calling obj.each.
VALUE rb_yield_values(int n,...)
Identical to rb_yield(), except it takes variadic number of parameters and pass them to the block.
VALUE rb_yield_splat(VALUE ary)
Identical to rb_yield_values(), except it splats an array to generate the list of parameters.
void rb_throw(const char *tag, VALUE val)
Transfers control to the end of the active catch block waiting for tag.
VALUE rb_yield_values2(int n, const VALUE *argv)
Identical to rb_yield_values(), except it takes the parameters as a C array instead of variadic argum...
VALUE rb_yield(VALUE val)
Yields the block.
VALUE rb_yield_values_kw(int n, const VALUE *argv, int kw_splat)
Identical to rb_yield_values2(), except you can specify how to handle the last element of the given a...
rb_block_call_func * rb_block_call_func_t
Shorthand type that represents an iterator-written-in-C function pointer.
VALUE rb_yield_block(RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg))
Pass a passed block.
void rb_throw_obj(VALUE tag, VALUE val)
Identical to rb_throw(), except it allows arbitrary Ruby object to become a tag.
VALUE rb_block_call_func(RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg))
This is the type of a function that the interpreter expect for C-backended blocks.
VALUE rb_block_call_kw(VALUE obj, ID mid, int argc, const VALUE *argv, rb_block_call_func_t proc, VALUE data2, int kw_splat)
Identical to rb_funcallv_kw(), except it additionally passes a function as a block.
VALUE rb_yield_splat_kw(VALUE ary, int kw_splat)
Identical to rb_yield_splat(), except you can specify how to handle the last element of the given arr...
#define MEMCPY(p1, p2, type, n)
Handy macro to call memcpy.
#define ALLOCA_N(type, n)
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
VALUE rb_catch_obj(VALUE q, type *w, VALUE e)
An equivalent of Kernel#catch.
VALUE rb_catch(const char *q, type *w, VALUE e)
An equivalent of Kernel#catch.
VALUE rb_block_call(VALUE q, ID w, int e, const VALUE *r, type *t, VALUE y)
Call a method with a block.
VALUE rb_iterate(onearg_type *q, VALUE w, type *e, VALUE r)
Old way to implement iterators.
VALUE type(ANYARGS)
ANYARGS-ed function type.
VALUE rb_rescue2(type *q, VALUE w, type *e, VALUE r,...)
An equivalent of rescue clause.
static int RARRAY_LENINT(VALUE ary)
Identical to rb_array_len(), except it differs for the return type.
#define RARRAY_CONST_PTR
Just another name of rb_array_const_ptr
static VALUE RBASIC_CLASS(VALUE obj)
Queries the class of an object.
#define RBASIC(obj)
Convenient casting macro.
#define RCLASS_SUPER
Just another name of rb_class_get_superclass
#define RHASH_EMPTY_P(h)
Checks if the hash is empty.
#define SafeStringValue(v)
#define StringValue(v)
Ensures that the parameter object is a String.
#define StringValuePtr(v)
Identical to StringValue, except it returns a char*.
#define RB_PASS_CALLED_KEYWORDS
Pass keywords if current method is called with keywords, useful for argument delegation.
#define RB_NO_KEYWORDS
Do not pass keywords.
#define RTEST
This is an old name of RB_TEST.
#define _(args)
This was a transition path from K&R to ANSI.
IFUNC (Internal FUNCtion)
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
uintptr_t VALUE
Type that represents a Ruby object.
ruby_value_type
C-level type of an object.