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);
46MJIT_FUNC_EXPORTED
VALUE
50 .ci = &VM_CI_ON_STACK(
id, kw_splat ? VM_CALL_KW_SPLAT : 0, argc, NULL),
51 .cc = &VM_CC_ON_STACK(
Qfalse, vm_call_general, {{ 0 }}, cme),
52 .block_handler = vm_passed_block_handler(ec),
58 return vm_call0_body(ec, &calling, argv);
61MJIT_FUNC_EXPORTED
VALUE
65 rb_callable_method_entry_with_refinements(
CLASS_OF(recv),
id, NULL);
67 return rb_vm_call0(ec, recv,
id, argc, argv, me, kw_splat);
71 return rb_funcallv(recv,
id, argc, argv);
79 .ci = &VM_CI_ON_STACK(
id, kw_splat ? VM_CALL_KW_SPLAT : 0, argc, NULL),
81 .block_handler = vm_passed_block_handler(ec),
87 return vm_call0_body(ec, &calling, argv);
93 calling->cc = &VM_CC_ON_STACK(
Qfalse, vm_call_general, {{ 0 }}, cme);
94 return vm_call0_body(ec, calling, argv);
100 ID mid = vm_ci_mid(calling->ci);
107 RUBY_VM_CHECK_INTS(ec);
108 return vm_call0_cme(ec, calling, argv, cme);
112 vm_passed_block_handler_set(ec, calling->block_handler);
113 return method_missing(ec, calling->recv, mid, calling->argc, argv, ex, calling->kw_splat);
123 int len = cfunc->argc;
124 VALUE recv = calling->recv;
125 int argc = calling->argc;
126 ID mid = vm_ci_mid(ci);
127 VALUE block_handler = calling->block_handler;
128 int frame_flags = VM_FRAME_MAGIC_CFUNC | VM_FRAME_FLAG_CFRAME | VM_ENV_FLAG_LOCAL;
130 if (calling->kw_splat) {
135 frame_flags |= VM_FRAME_FLAG_CFRAME_KW;
139 RUBY_DTRACE_CMETHOD_ENTRY_HOOK(ec, me->owner, me->def->original_id);
144 vm_push_frame(ec, 0, frame_flags, recv,
145 block_handler, (
VALUE)me,
146 0, reg_cfp->sp, 0, 0);
148 if (len >= 0) rb_check_arity(argc, len, len);
150 val = (*cfunc->invoker)(recv, argc, argv, cfunc->func);
152 CHECK_CFP_CONSISTENCY(
"vm_call0_cfunc_with_frame");
156 RUBY_DTRACE_CMETHOD_RETURN_HOOK(ec, me->owner, me->def->original_id);
164 return vm_call0_cfunc_with_frame(ec, calling, argv);
170 if (calling->kw_splat &&
172 RB_TYPE_P(argv[calling->argc-1],
T_HASH) &&
177 rb_check_arity(calling->argc, argc, argc);
190 switch (vm_cc_cme(cc)->def->type) {
191 case VM_METHOD_TYPE_ISEQ:
196 CHECK_VM_STACK_OVERFLOW(reg_cfp, calling->argc + 1);
197 vm_check_canary(ec, reg_cfp->sp);
199 *reg_cfp->sp++ = calling->recv;
200 for (i = 0; i < calling->argc; i++) {
201 *reg_cfp->sp++ = argv[i];
204 vm_call_iseq_setup(ec, reg_cfp, calling);
205 VM_ENV_FLAGS_SET(ec->cfp->ep, VM_FRAME_FLAG_FINISH);
206 return vm_exec(ec,
true);
208 case VM_METHOD_TYPE_NOTIMPLEMENTED:
209 case VM_METHOD_TYPE_CFUNC:
210 ret = vm_call0_cfunc(ec, calling, argv);
212 case VM_METHOD_TYPE_ATTRSET:
213 vm_call_check_arity(calling, 1, argv);
214 VM_CALL_METHOD_ATTR(ret,
215 rb_ivar_set(calling->recv, vm_cc_cme(cc)->def->body.attr.id, argv[0]),
218 case VM_METHOD_TYPE_IVAR:
219 vm_call_check_arity(calling, 0, argv);
220 VM_CALL_METHOD_ATTR(ret,
221 rb_attr_get(calling->recv, vm_cc_cme(cc)->def->body.attr.id),
224 case VM_METHOD_TYPE_BMETHOD:
225 ret = vm_call_bmethod_body(ec, calling, argv);
227 case VM_METHOD_TYPE_ZSUPER:
229 VALUE klass = RCLASS_ORIGIN(vm_cc_cme(cc)->defined_class);
230 return vm_call0_super(ec, calling, argv, klass, MISSING_SUPER);
232 case VM_METHOD_TYPE_REFINED:
236 if (cme->def->body.refined.orig_me) {
238 return vm_call0_cme(ec, calling, argv, orig_cme);
241 VALUE klass = cme->defined_class;
242 return vm_call0_super(ec, calling, argv, klass, 0);
244 case VM_METHOD_TYPE_ALIAS:
249 if (cme == orig_cme)
rb_bug(
"same!!");
251 if (vm_cc_markable(cc)) {
252 return vm_call0_cme(ec, calling, argv, orig_cme);
259 case VM_METHOD_TYPE_MISSING:
261 vm_passed_block_handler_set(ec, calling->block_handler);
262 return method_missing(ec, calling->recv, vm_ci_mid(ci), calling->argc,
263 argv, MISSING_NOENTRY, calling->kw_splat);
265 case VM_METHOD_TYPE_OPTIMIZED:
266 switch (vm_cc_cme(cc)->def->body.optimized.type) {
267 case OPTIMIZED_METHOD_TYPE_SEND:
268 ret = send_internal(calling->argc, argv, calling->recv, calling->kw_splat ? CALL_FCALL_KW : CALL_FCALL);
270 case OPTIMIZED_METHOD_TYPE_CALL:
273 GetProcPtr(calling->recv, proc);
274 ret = rb_vm_invoke_proc(ec, proc, calling->argc, argv, calling->kw_splat, calling->block_handler);
277 case OPTIMIZED_METHOD_TYPE_STRUCT_AREF:
278 vm_call_check_arity(calling, 0, argv);
279 ret = vm_call_opt_struct_aref0(ec, calling);
281 case OPTIMIZED_METHOD_TYPE_STRUCT_ASET:
282 vm_call_check_arity(calling, 1, argv);
283 ret = vm_call_opt_struct_aset0(ec, calling, argv[0]);
286 rb_bug(
"vm_call0: unsupported optimized method type (%d)", vm_cc_cme(cc)->def->body.optimized.type);
289 case VM_METHOD_TYPE_UNDEF:
292 rb_bug(
"vm_call0: unsupported method type (%d)", vm_cc_cme(cc)->def->type);
296 RUBY_VM_CHECK_INTS(ec);
300MJIT_FUNC_EXPORTED
VALUE
303 return rb_vm_call0(ec, recv,
id, argc, argv, me, kw_splat);
309 VALUE recv = ec->cfp->self;
315 if (VM_FRAME_RUBYFRAME_P(cfp)) {
316 rb_bug(
"vm_call_super: should not be reached");
319 klass = RCLASS_ORIGIN(me->defined_class);
321 id = me->def->original_id;
322 me = rb_callable_method_entry(klass,
id);
325 return method_missing(ec, recv,
id, argc, argv, MISSING_SUPER, kw_splat);
327 return rb_vm_call_kw(ec, recv,
id, argc, argv, me, kw_splat);
334 PASS_PASSED_BLOCK_HANDLER_EC(ec);
335 return vm_call_super(ec, argc, argv, kw_splat);
349 if (!ec || !(cfp = ec->cfp)) {
360 if (!rb_ec_raised_p(ec, RAISED_STACKOVERFLOW) &&
361 rb_ec_stack_check(ec)) {
362 rb_ec_raised_set(ec, RAISED_STACKOVERFLOW);
363 rb_ec_stack_overflow(ec, FALSE);
370rb_check_stack_overflow(
void)
372#ifndef RB_THREAD_LOCAL_SPECIFIER
373 if (!ruby_current_ec_key)
return;
376 if (ec) stack_check(ec);
379NORETURN(
static void uncallable_object(
VALUE recv,
ID mid));
394 if (rb_id_table_lookup(cc_tbl, mid, &ccs_data)) {
399 ccs = vm_ccs_create(klass, cme);
400 rb_id_table_insert(cc_tbl, mid, (
VALUE)ccs);
403 for (
int i=0; i<ccs->len; i++) {
404 cc = ccs->entries[i].cc;
405 if (vm_cc_cme(cc) == cme) {
412 const struct rb_callinfo *ci = vm_ci_new(mid, 0, argc, NULL);
413 cc = vm_cc_new(klass, cme, vm_call_general);
415 vm_ccs_push(klass, ccs, ci, cc);
426 return (klass >> 3) ^ (
VALUE)mid;
429NOINLINE(
static const struct rb_callcache *gccct_method_search_slowpath(
rb_vm_t *vm,
VALUE klass,
ID mid,
int argc,
unsigned int index));
432gccct_method_search_slowpath(
rb_vm_t *vm,
VALUE klass,
ID mid,
int argc,
unsigned int index)
438 cc = cc_new(klass, mid, argc, cme);
444 return vm->global_cc_cache_table[index] = cc;
453 klass = RBASIC_CLASS(recv);
454 if (UNLIKELY(!klass)) uncallable_object(recv, mid);
461 unsigned int index = (
unsigned int)(gccct_hash(klass, mid) % VM_GLOBAL_CC_CACHE_TABLE_SIZE);
462 rb_vm_t *vm = rb_ec_vm_ptr(ec);
463 const struct rb_callcache *cc = vm->global_cc_cache_table[index];
466 if (LIKELY(vm_cc_class_check(cc, klass))) {
468 if (LIKELY(!METHOD_ENTRY_INVALIDATED(cme) &&
469 cme->called_id == mid)) {
471 VM_ASSERT(vm_cc_check_cme(cc, rb_callable_method_entry(klass, mid)));
472 RB_DEBUG_COUNTER_INC(gccct_hit);
479 RB_DEBUG_COUNTER_INC(gccct_null);
482 RB_DEBUG_COUNTER_INC(gccct_miss);
483 return gccct_method_search_slowpath(vm, klass, mid, argc, index);
505 call_type call_scope,
VALUE self)
507 enum method_missing_reason call_status;
508 call_type scope = call_scope;
524 const struct rb_callcache *cc = gccct_method_search(ec, recv, mid, argc);
526 if (scope == CALL_PUBLIC) {
527 RB_DEBUG_COUNTER_INC(call0_public);
531 call_status = rb_method_call_status(ec, cme, scope, self);
533 if (UNLIKELY(call_status != MISSING_NONE)) {
534 return method_missing(ec, recv, mid, argc, argv, call_status, kw_splat);
536 else if (UNLIKELY(cc_cme != cme)) {
538 return rb_vm_call_kw(ec, recv, mid, argc, argv, cme, kw_splat);
542 RB_DEBUG_COUNTER_INC(call0_other);
543 call_status = rb_method_call_status(ec, cc ? vm_cc_cme(cc) : NULL, scope, self);
545 if (UNLIKELY(call_status != MISSING_NONE)) {
546 return method_missing(ec, recv, mid, argc, argv, call_status, kw_splat);
551 return vm_call0_cc(ec, recv, mid, argc, argv, cc, kw_splat);
560 unsigned int respond: 1;
561 unsigned int respond_to_missing: 1;
568check_funcall_exec(
VALUE v)
571 return call_method_entry(args->ec, args->defined_class,
572 args->recv, idMethodMissing,
573 args->cme, args->argc, args->argv, args->kw_splat);
580 int ret = args->respond;
582 switch (method_boundp(args->defined_class, args->mid,
583 BOUND_PRIVATE|BOUND_RESPONDS)) {
588 ret = args->respond_to_missing;
604 return vm_respond_to(ec, klass, recv, mid, TRUE);
610 return rb_method_call_status(ec, me, CALL_FCALL, ec->cfp->self) == MISSING_NONE;
620 ret = basic_obj_respond_to_missing(ec, klass, recv,
622 if (!
RTEST(ret))
return def;
623 args.respond = respond > 0;
624 args.respond_to_missing = !UNDEF_P(ret);
626 cme = callable_method_entry(klass, idMethodMissing, &args.defined_class);
628 if (cme && !METHOD_ENTRY_BASIC(cme)) {
631 new_args[0] =
ID2SYM(mid);
635 VM_ASSERT(argc == 0);
640 ec->method_missing_reason = MISSING_NOENTRY;
645 args.argc = argc + 1;
646 args.argv = new_args;
647 args.kw_splat = kw_splat;
649 check_funcall_failed, (
VALUE)&args,
656static VALUE rb_check_funcall_default_kw(
VALUE recv,
ID mid,
int argc,
const VALUE *argv,
VALUE def,
int kw_splat);
661 return rb_check_funcall_default_kw(recv, mid, argc, argv,
Qundef, kw_splat);
671rb_check_funcall_default_kw(
VALUE recv,
ID mid,
int argc,
const VALUE *argv,
VALUE def,
int kw_splat)
673 VM_ASSERT(ruby_thread_has_gvl_p());
678 int respond = check_funcall_respond_to(ec, klass, recv, mid);
683 me = rb_search_method_entry(recv, mid);
684 if (!check_funcall_callable(ec, me)) {
685 VALUE ret = check_funcall_missing(ec, klass, recv, mid, argc, argv,
686 respond, def, kw_splat);
687 if (UNDEF_P(ret)) ret = def;
691 return rb_vm_call_kw(ec, recv, mid, argc, argv, me, kw_splat);
695rb_check_funcall_default(
VALUE recv,
ID mid,
int argc,
const VALUE *argv,
VALUE def)
697 return rb_check_funcall_default_kw(recv, mid, argc, argv, def,
RB_NO_KEYWORDS);
701rb_check_funcall_with_hook_kw(
VALUE recv,
ID mid,
int argc,
const VALUE *argv,
702 rb_check_funcall_hook *hook,
VALUE arg,
int kw_splat)
707 int respond = check_funcall_respond_to(ec, klass, recv, mid);
710 (*hook)(FALSE, recv, mid, argc, argv, arg);
714 me = rb_search_method_entry(recv, mid);
715 if (!check_funcall_callable(ec, me)) {
716 VALUE ret = check_funcall_missing(ec, klass, recv, mid, argc, argv,
717 respond,
Qundef, kw_splat);
718 (*hook)(!UNDEF_P(ret), recv, mid, argc, argv, arg);
722 (*hook)(TRUE, recv, mid, argc, argv, arg);
723 return rb_vm_call_kw(ec, recv, mid, argc, argv, me, kw_splat);
727rb_check_funcall_with_hook(
VALUE recv,
ID mid,
int argc,
const VALUE *argv,
728 rb_check_funcall_hook *hook,
VALUE arg)
730 return rb_check_funcall_with_hook_kw(recv, mid, argc, argv, hook, arg,
RB_NO_KEYWORDS);
736#define type_case(t) t: return #t
754 case type_case(
T_NIL);
772uncallable_object(
VALUE recv,
ID mid)
777 VALUE mname = rb_id2str(mid);
781 "method `%"PRIsVALUE
"' called on unexpected immediate object (%p)",
782 mname, (
void *)recv);
784 else if ((flags =
RBASIC(recv)->flags) == 0) {
786 "method `%"PRIsVALUE
"' called on terminated object (%p)",
787 mname, (
void *)recv);
791 "method `%"PRIsVALUE
"' called on broken T_?""?""?(0x%02x) object"
792 " (%p flags=0x%"PRIxVALUE
")",
793 mname,
type, (
void *)recv, flags);
797 "method `%"PRIsVALUE
"' called on hidden %s object"
798 " (%p flags=0x%"PRIxVALUE
")",
799 mname, typestr, (
void *)recv, flags);
803 "method `%"PRIsVALUE
"' called on unexpected %s object"
804 " (%p flags=0x%"PRIxVALUE
")",
805 mname, typestr, (
void *)recv, flags);
810rb_search_method_entry(
VALUE recv,
ID mid)
814 if (!klass) uncallable_object(recv, mid);
815 return rb_callable_method_entry(klass, mid);
818static inline enum method_missing_reason
821 if (UNLIKELY(UNDEFINED_METHOD_ENTRY_P(me))) {
824 else if (UNLIKELY(me->def->type == VM_METHOD_TYPE_REFINED)) {
825 me = rb_resolve_refined_method_callable(
Qnil, me);
826 if (UNDEFINED_METHOD_ENTRY_P(me))
goto undefined;
829 rb_method_visibility_t visi = METHOD_ENTRY_VISI(me);
832 if (UNLIKELY(visi != METHOD_VISI_PUBLIC)) {
833 if (me->def->original_id == idMethodMissing) {
836 else if (visi == METHOD_VISI_PRIVATE &&
837 scope == CALL_PUBLIC) {
838 return MISSING_PRIVATE;
841 else if (visi == METHOD_VISI_PROTECTED &&
842 scope == CALL_PUBLIC) {
844 VALUE defined_class = me->owner;
845 if (RB_TYPE_P(defined_class,
T_ICLASS)) {
846 defined_class =
RBASIC(defined_class)->klass;
850 return MISSING_PROTECTED;
858 return scope == CALL_VCALL ? MISSING_VCALL : MISSING_NOENTRY;
874rb_call(
VALUE recv,
ID mid,
int argc,
const VALUE *argv, call_type scope)
877 return rb_call0(ec, recv, mid, argc, argv, scope, ec->cfp->self);
881 VALUE obj,
enum method_missing_reason call_status));
923rb_method_missing(
int argc,
const VALUE *argv,
VALUE obj)
926 raise_method_missing(ec, argc, argv, obj, ec->method_missing_reason);
930MJIT_FUNC_EXPORTED
VALUE
932 int argc,
const VALUE *argv,
int priv)
934 VALUE name = argv[0];
937 format = rb_fstring_lit(
"undefined method `%s' for %s%s%s");
941 return rb_nomethod_err_new(format, obj, name, args, priv);
944 return rb_name_err_new(format, obj, name);
952 enum method_missing_reason last_call_status)
957 if (UNLIKELY(argc == 0)) {
960 else if (UNLIKELY(!
SYMBOL_P(argv[0]))) {
962 rb_raise(e,
"method name must be a Symbol but %"PRIsVALUE
" is given",
968 if (last_call_status & MISSING_PRIVATE) {
969 format = rb_fstring_lit(
"private method `%s' called for %s%s%s");
971 else if (last_call_status & MISSING_PROTECTED) {
972 format = rb_fstring_lit(
"protected method `%s' called for %s%s%s");
974 else if (last_call_status & MISSING_VCALL) {
975 format = rb_fstring_lit(
"undefined local variable or method `%s' for %s%s%s");
978 else if (last_call_status & MISSING_SUPER) {
979 format = rb_fstring_lit(
"super: no superclass method `%s' for %s%s%s");
983 exc = rb_make_no_method_exception(exc, format, obj, argc, argv,
984 last_call_status & (MISSING_FCALL|MISSING_VCALL));
985 if (!(last_call_status & MISSING_MISSING)) {
986 rb_vm_pop_cfunc_frame();
994 VALUE obj,
int call_status)
996 vm_passed_block_handler_set(ec, VM_BLOCK_HANDLER_NONE);
997 raise_method_missing(ec, argc, argv, obj, call_status | MISSING_MISSING);
1003 VALUE *nargv, result, work, klass;
1004 VALUE block_handler = vm_passed_block_handler(ec);
1007 ec->method_missing_reason = call_status;
1009 if (
id == idMethodMissing) {
1018 VM_ASSERT(argc == 0);
1027 if (!klass)
goto missing;
1028 me = rb_callable_method_entry(klass, idMethodMissing);
1029 if (!me || METHOD_ENTRY_BASIC(me))
goto missing;
1030 vm_passed_block_handler_set(ec, block_handler);
1031 result = rb_vm_call_kw(ec, obj, idMethodMissing, argc, argv, me, kw_splat);
1035 raise_method_missing(ec, argc, argv, obj, call_status | MISSING_MISSING);
1042rb_funcallv_scope(
VALUE recv,
ID mid,
int argc,
const VALUE *argv, call_type scope)
1045 const struct rb_callcache *cc = gccct_method_search(ec, recv, mid, argc);
1046 VALUE self = ec->cfp->self;
1049 LIKELY(rb_method_call_status(ec, vm_cc_cme(cc), scope, self) == MISSING_NONE)) {
1051 return vm_call0_cc(ec, recv, mid, argc, argv, cc,
false);
1054 return rb_call0(ec, recv, mid, argc, argv, scope, self);
1064 VM_ASSERT(ruby_thread_has_gvl_p());
1066 return rb_funcallv_scope(recv, mid, argc, argv, CALL_FCALL);
1072 VM_ASSERT(ruby_thread_has_gvl_p());
1074 return rb_call(recv, mid, argc, argv, kw_splat ? CALL_FCALL_KW : CALL_FCALL);
1083 argc = RARRAY_LENINT(args);
1084 if (argc >= 0x100) {
1085 args = rb_ary_subseq(args, 0, argc);
1086 RBASIC_CLEAR_CLASS(args);
1095 return rb_funcallv(recv, mid, argc, argv);
1115 for (i = 0; i < n; i++) {
1116 argv[i] = va_arg(ar,
VALUE);
1123 return rb_funcallv(recv, mid, n, argv);
1137rb_check_funcall_basic_kw(
VALUE recv,
ID mid,
VALUE ancestor,
int argc,
const VALUE *argv,
int kw_splat)
1142 if (!klass)
return Qundef;
1144 cme = rb_callable_method_entry(klass, mid);
1145 if (cme && METHOD_ENTRY_BASIC(cme) && RBASIC_CLASS(cme->defined_class) == ancestor) {
1147 return rb_vm_call0(ec, recv, mid, argc, argv, cme, kw_splat);
1156 return rb_funcallv_scope(recv, mid, argc, argv, CALL_PUBLIC);
1162 return rb_call(recv, mid, argc, argv, kw_splat ? CALL_PUBLIC_KW : CALL_PUBLIC);
1168 PASS_PASSED_BLOCK_HANDLER();
1175 PASS_PASSED_BLOCK_HANDLER();
1176 return rb_call(recv, mid, argc, argv, kw_splat ? CALL_PUBLIC_KW : CALL_PUBLIC);
1182 if (!
NIL_P(passed_procval)) {
1183 vm_passed_block_handler_set(GET_EC(), passed_procval);
1192 if (!
NIL_P(passed_procval)) {
1193 vm_passed_block_handler_set(GET_EC(), passed_procval);
1196 return rb_call(recv, mid, argc, argv, kw_splat ? CALL_PUBLIC_KW : CALL_PUBLIC);
1203 if (RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(ec, prev_cfp))
return NULL;
1204 if (prev_cfp->sp + 1 != argv)
return NULL;
1205 return prev_cfp->sp + 1;
1209send_internal(
int argc,
const VALUE *argv,
VALUE recv, call_type scope)
1214 VALUE ret, vargv = 0;
1216 int public = scope == CALL_PUBLIC || scope == CALL_PUBLIC_KW;
1222 self = RUBY_VM_PREVIOUS_CONTROL_FRAME(ec->cfp)->self;
1233 if (rb_method_basic_definition_p(
CLASS_OF(recv), idMethodMissing)) {
1240 VALUE *tmp_argv = current_vm_stack_arg(ec, argv);
1245 else if (argc > 1) {
1255 id = idMethodMissing;
1256 ec->method_missing_reason = MISSING_NOENTRY;
1261 PASS_PASSED_BLOCK_HANDLER_EC(ec);
1262 ret = rb_call0(ec, recv,
id, argc, argv, scope, self);
1268send_internal_kw(
int argc,
const VALUE *argv,
VALUE recv, call_type scope)
1273 scope = CALL_PUBLIC_KW;
1276 scope = CALL_FCALL_KW;
1282 return send_internal(argc, argv, recv, scope);
1314 return send_internal_kw(argc, argv, recv, CALL_FCALL);
1332rb_f_public_send(
int argc,
VALUE *argv,
VALUE recv)
1334 return send_internal_kw(argc, argv, recv, CALL_PUBLIC);
1340rb_yield_0_kw(
int argc,
const VALUE * argv,
int kw_splat)
1342 return vm_yield(GET_EC(), argc, argv, kw_splat);
1346rb_yield_0(
int argc,
const VALUE * argv)
1352rb_yield_1(
VALUE val)
1354 return rb_yield_0(1, &val);
1361 return rb_yield_0(0, NULL);
1364 return rb_yield_0(1, &val);
1368#undef rb_yield_values
1370rb_yield_values(
int n, ...)
1373 return rb_yield_0(0, 0);
1382 for (i=0; i<n; i++) {
1383 argv[i] = va_arg(args,
VALUE);
1387 return rb_yield_0(n, argv);
1394 return rb_yield_0(argc, argv);
1400 return rb_yield_0_kw(argc, argv, kw_splat);
1406 VALUE tmp = rb_check_array_type(values);
1419 VALUE tmp = rb_check_array_type(values);
1430rb_yield_force_blockarg(
VALUE values)
1432 return vm_yield_force_blockarg(GET_EC(), values);
1438 return vm_yield_with_block(GET_EC(), argc, argv,
1439 NIL_P(blockarg) ? VM_BLOCK_HANDLER_NONE : blockarg,
1495rb_f_loop(
VALUE self)
1508 const struct vm_ifunc *
const ifunc,
1511 enum ruby_tag_type state;
1516 state = EC_EXEC_TAG();
1520 VALUE block_handler;
1524 captured->code.ifunc = ifunc;
1525 block_handler = VM_BH_FROM_IFUNC_BLOCK(captured);
1528 block_handler = VM_CF_BLOCK_HANDLER(cfp);
1530 vm_passed_block_handler_set(ec, block_handler);
1532 retval = (*it_proc) (data1);
1534 else if (state == TAG_BREAK || state == TAG_RETRY) {
1538 if (cfp == escape_cfp) {
1539 rb_vm_rewind_cfp(ec, cfp);
1542 ec->tag->state = TAG_NONE;
1545 if (state == TAG_RETRY)
goto iter_retry;
1546 retval = THROW_DATA_VAL(err);
1549 SDR(); fprintf(stderr,
"%p, %p\n", (
void *)cfp, (
void *)escape_cfp);
1555 EC_JUMP_TAG(ec, state);
1564 return rb_iterate0(it_proc, data1,
1565 bl_proc ? rb_vm_ifunc_proc_new(bl_proc, (
void *)data2) : 0,
1573 return rb_iterate_internal(it_proc, data1, bl_proc, data2);
1585iterate_method(
VALUE obj)
1590 return rb_call(arg->obj, arg->mid, arg->argc, arg->argv, arg->kw_splat ? CALL_FCALL_KW : CALL_FCALL);
1612 arg.kw_splat = kw_splat;
1613 return rb_iterate_internal(iterate_method, (
VALUE)&arg, bl_proc, data2);
1617rb_lambda_call(
VALUE obj,
ID mid,
int argc,
const VALUE *argv,
1630 block = rb_vm_ifunc_new(bl_proc, (
void *)data2, min_argc, max_argc);
1631 return rb_iterate0(iterate_method, (
VALUE)&arg, block, GET_EC());
1635iterate_check_method(
VALUE obj)
1644rb_check_block_call(
VALUE obj,
ID mid,
int argc,
const VALUE *argv,
1654 return rb_iterate_internal(iterate_check_method, (
VALUE)&arg, bl_proc, data2);
1660 return rb_call(obj, idEach, 0, 0, CALL_FCALL);
1663void rb_parser_warn_location(
VALUE,
int);
1665static VALUE eval_default_path;
1671 const VALUE parser = rb_parser_new();
1672 const rb_iseq_t *
const parent = vm_block_iseq(base_block);
1675 int isolated_depth = 0;
1678 VALUE coverage_enabled = RBOOL(rb_get_coverage_mode() & COVERAGE_TARGET_EVAL);
1682 const VALUE *ep = vm_block_ep(base_block);
1685 if (VM_ENV_FLAGS(ep, VM_ENV_FLAG_ISOLATED)) {
1686 isolated_depth = depth;
1689 else if (VM_ENV_LOCAL_P(ep)) {
1692 ep = VM_ENV_PREV_EP(ep);
1698 fname = rb_source_location(&line);
1701 if (!UNDEF_P(fname)) {
1702 if (!
NIL_P(fname)) fname = rb_fstring(fname);
1705 fname = rb_fstring_lit(
"(eval)");
1706 if (!eval_default_path) {
1707 eval_default_path = rb_fstring_lit(
"(eval)");
1708 rb_gc_register_mark_object(eval_default_path);
1710 fname = eval_default_path;
1711 coverage_enabled =
Qfalse;
1714 rb_parser_set_context(parser, parent, FALSE);
1715 ast = rb_parser_compile_string_path(parser, fname, src, line);
1716 if (ast->body.root) {
1717 if (ast->body.compile_option ==
Qnil) {
1718 ast->body.compile_option =
rb_obj_hide(rb_ident_hash_new());
1720 rb_hash_aset(ast->body.compile_option, rb_sym_intern_ascii_cstr(
"coverage_enabled"), coverage_enabled);
1722 iseq = rb_iseq_new_eval(&ast->body,
1723 ISEQ_BODY(parent)->location.label,
1725 parent, isolated_depth);
1727 rb_ast_dispose(ast);
1731 VALUE disasm = rb_iseq_disasm(iseq);
1735 rb_exec_event_hook_script_compiled(GET_EC(), iseq, src);
1752 block.as.captured = *VM_CFP_TO_CAPTURED_BLOCK(cfp);
1753 block.as.captured.self = self;
1754 block.as.captured.code.iseq = cfp->iseq;
1755 block.type = block_type_iseq;
1757 iseq = eval_make_iseq(src, file, line, NULL, &block);
1763 if (!cref && block.as.captured.code.val) {
1764 rb_cref_t *orig_cref = vm_get_cref(vm_block_ep(&block));
1765 cref = vm_cref_dup(orig_cref);
1767 vm_set_eval_stack(ec, iseq, cref, &block);
1770 return vm_exec(ec,
true);
1778 const rb_iseq_t *iseq = eval_make_iseq(src, file, line, bind, &bind->block);
1783 vm_set_eval_stack(ec, iseq, NULL, &bind->block);
1786 if (ISEQ_BODY(iseq)->local_table_size > 0) {
1787 vm_bind_update_env(scope, bind, vm_make_env_object(ec, ec->cfp));
1791 return vm_exec(ec,
true);
1813rb_f_eval(
int argc,
const VALUE *argv,
VALUE self)
1815 VALUE src, scope, vfile, vline;
1819 rb_scan_args(argc, argv,
"13", &src, &scope, &vfile, &vline);
1832 return eval_string_with_cref(self, src, NULL, file, line);
1834 return eval_string_with_scope(scope, src, file, line);
1839ruby_eval_string_from_file(
const char *str,
const char *filename)
1844 VALUE self = cfp ? cfp->self : rb_vm_top_self();
1845 return eval_string_with_cref(self,
rb_str_new2(str), NULL, file, 1);
1851 return ruby_eval_string_from_file(str,
"eval");
1855eval_string_protect(
VALUE str)
1863 return rb_protect(eval_string_protect, (
VALUE)str, pstate);
1873eval_string_wrap_protect(
VALUE data)
1876 rb_cref_t *cref = rb_vm_cref_new_toplevel();
1877 cref->klass_or_self = arg->klass;
1886 VALUE self = th->top_self;
1887 VALUE wrapper = th->top_wrapper;
1895 data.top_self = th->top_self;
1896 data.klass = th->top_wrapper;
1899 val = rb_protect(eval_string_wrap_protect, (
VALUE)&data, &state);
1901 th->top_self = self;
1902 th->top_wrapper = wrapper;
1907 else if (state != TAG_NONE) {
1908 EC_JUMP_TAG(th->ec, state);
1916 enum ruby_tag_type state;
1921 if ((state = EC_EXEC_TAG()) == TAG_NONE) {
1927 val = eval_string_with_cref(rb_vm_top_self(), cmd, NULL, 0, 0);
1932 if (state) EC_JUMP_TAG(ec, state);
1939yield_under(
VALUE self,
int singleton,
int argc,
const VALUE *argv,
int kw_splat)
1943 VALUE block_handler = VM_CF_BLOCK_HANDLER(cfp);
1944 VALUE new_block_handler = 0;
1947 const VALUE *ep = NULL;
1949 int is_lambda = FALSE;
1951 if (block_handler != VM_BLOCK_HANDLER_NONE) {
1953 switch (vm_block_handler_type(block_handler)) {
1954 case block_handler_type_iseq:
1955 captured = VM_BH_TO_CAPT_BLOCK(block_handler);
1956 new_captured = *captured;
1957 new_block_handler = VM_BH_FROM_ISEQ_BLOCK(&new_captured);
1959 case block_handler_type_ifunc:
1960 captured = VM_BH_TO_CAPT_BLOCK(block_handler);
1961 new_captured = *captured;
1962 new_block_handler = VM_BH_FROM_IFUNC_BLOCK(&new_captured);
1964 case block_handler_type_proc:
1966 block_handler = vm_proc_to_block_handler(VM_BH_TO_PROC(block_handler));
1968 case block_handler_type_symbol:
1969 return rb_sym_proc_call(
SYM2ID(VM_BH_TO_SYMBOL(block_handler)),
1970 argc, argv, kw_splat,
1971 VM_BLOCK_HANDLER_NONE);
1974 new_captured.self = self;
1977 VM_FORCE_WRITE_SPECIAL_CONST(&VM_CF_LEP(ec->cfp)[VM_ENV_DATA_INDEX_SPECVAL], new_block_handler);
1980 VM_ASSERT(singleton || RB_TYPE_P(self,
T_MODULE) || RB_TYPE_P(self,
T_CLASS));
1981 cref = vm_cref_push(ec, self, ep, TRUE, singleton);
1983 return vm_yield_with_cref(ec, argc, argv, kw_splat, cref, is_lambda);
1987rb_yield_refine_block(
VALUE refinement,
VALUE refinements)
1990 VALUE block_handler = VM_CF_BLOCK_HANDLER(ec->cfp);
1992 if (vm_block_handler_type(block_handler) != block_handler_type_iseq) {
1993 rb_bug(
"rb_yield_refine_block: an iseq block is required");
1998 VALUE new_block_handler = VM_BH_FROM_ISEQ_BLOCK(&new_captured);
1999 const VALUE *ep = captured->ep;
2000 rb_cref_t *cref = vm_cref_push(ec, refinement, ep, TRUE, FALSE);
2001 CREF_REFINEMENTS_SET(cref, refinements);
2002 VM_FORCE_WRITE_SPECIAL_CONST(&VM_CF_LEP(ec->cfp)[VM_ENV_DATA_INDEX_SPECVAL], new_block_handler);
2003 new_captured.self = refinement;
2004 return vm_yield_with_cref(ec, 0, NULL,
RB_NO_KEYWORDS, cref, FALSE);
2012 rb_cref_t *cref = vm_cref_push(GET_EC(), self, NULL, FALSE, singleton);
2015 return eval_string_with_cref(self, src, cref, file, line);
2019specific_eval(
int argc,
const VALUE *argv,
VALUE self,
int singleton,
int kw_splat)
2022 rb_check_arity(argc, 0, 0);
2023 return yield_under(self, singleton, 1, &self, kw_splat);
2030 rb_check_arity(argc, 1, 3);
2039 return eval_under(self, singleton, code, file, line);
2077rb_obj_instance_eval_internal(
int argc,
const VALUE *argv,
VALUE self)
2107rb_obj_instance_exec_internal(
int argc,
const VALUE *argv,
VALUE self)
2146rb_mod_module_eval_internal(
int argc,
const VALUE *argv,
VALUE mod)
2180rb_mod_module_exec_internal(
int argc,
const VALUE *argv,
VALUE mod)
2205uncaught_throw_init(
int argc,
const VALUE *argv,
VALUE exc)
2222uncaught_throw_tag(
VALUE exc)
2235uncaught_throw_value(
VALUE exc)
2248uncaught_throw_to_s(
VALUE exc)
2251 VALUE tag = uncaught_throw_tag(exc);
2272 rb_scan_args(argc, argv,
"11", &tag, &value);
2284 if (tt->tag == tag) {
2298 ec->errinfo = (
VALUE)THROW_DATA_NEW(tag, NULL, TAG_THROW);
2299 EC_JUMP_TAG(ec, TAG_THROW);
2311 return rb_yield_0(1, &tag);
2383 enum ruby_tag_type state;
2391 if ((state = EC_EXEC_TAG()) == TAG_NONE) {
2393 val = (*func)(tag, data, 1, (
const VALUE *)&tag,
Qnil);
2395 else if (state == TAG_THROW && THROW_DATA_VAL((
struct vm_throw_data *)ec->errinfo) == tag) {
2396 rb_vm_rewind_cfp(ec, saved_cfp);
2397 val = ec->tag->retval;
2411 return vm_catch_protect(t, func, data, stateptr, GET_EC());
2417 enum ruby_tag_type state;
2420 if (state) EC_JUMP_TAG(ec, state);
2427 vars->tbl = rb_ident_hash_new();
2428 RBASIC_CLEAR_CLASS(vars->tbl);
2435 VALUE ary = rb_hash_keys(vars->tbl);
2436 rb_hash_clear(vars->tbl);
2442local_var_list_update(st_data_t *key, st_data_t *value, st_data_t arg,
int existing)
2444 if (existing)
return ST_STOP;
2445 *value = (st_data_t)
Qtrue;
2455 rb_hash_stlike_update(vars->tbl,
ID2SYM(lid), local_var_list_update, idx);
2473rb_f_local_variables(
VALUE _)
2477 rb_control_frame_t *cfp = vm_get_ruby_level_caller_cfp(ec, RUBY_VM_PREVIOUS_CONTROL_FRAME(ec->cfp));
2480 local_var_list_init(&vars);
2483 for (i = 0; i < ISEQ_BODY(cfp->iseq)->local_table_size; i++) {
2484 local_var_list_add(&vars, ISEQ_BODY(cfp->iseq)->local_table[i]);
2487 if (!VM_ENV_LOCAL_P(cfp->ep)) {
2489 const VALUE *ep = VM_CF_PREV_EP(cfp);
2491 if (vm_collect_local_variables_in_heap(ep, &vars)) {
2495 while (cfp->ep != ep) {
2496 cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
2504 return local_var_list_finish(&vars);
2528rb_f_block_given_p(
VALUE _)
2532 cfp = vm_get_ruby_level_caller_cfp(ec, RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp));
2534 return RBOOL(cfp != NULL && VM_CF_BLOCK_HANDLER(cfp) != VM_BLOCK_HANDLER_NONE);
2545rb_f_iterator_p(
VALUE self)
2547 rb_warn_deprecated(
"iterator?",
"block_given?");
2548 return rb_f_block_given_p(self);
2552rb_current_realfilepath(
void)
2556 cfp = vm_get_ruby_level_caller_cfp(ec, RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp));
2558 VALUE path = rb_iseq_realpath(cfp->iseq);
2559 if (
RTEST(path))
return path;
2561 path = rb_iseq_path(cfp->iseq);
2562 if (path == eval_default_path) {
2591 VM_METHOD_TYPE_OPTIMIZED, (
void *)OPTIMIZED_METHOD_TYPE_SEND, METHOD_VISI_PUBLIC);
2593 VM_METHOD_TYPE_OPTIMIZED, (
void *)OPTIMIZED_METHOD_TYPE_SEND, METHOD_VISI_PUBLIC);
2606 rb_define_method(rb_eUncaughtThrow,
"initialize", uncaught_throw_init, -1);
2611 id_result = rb_intern_const(
"result");
2612 id_tag = rb_intern_const(
"tag");
2613 id_value = rb_intern_const(
"value");
#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_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 DBL2NUM
Old name of rb_float_new.
#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.
void rb_raise(VALUE exc, const char *fmt,...)
Exception entry point.
VALUE rb_eNotImpError
NotImplementedError exception.
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
void rb_bug(const char *fmt,...)
Interpreter panic switch.
VALUE rb_eNameError
NameError exception.
VALUE rb_eNoMethodError
NoMethodError exception.
VALUE rb_eRuntimeError
RuntimeError exception.
VALUE rb_eStopIteration
StopIteration exception.
VALUE rb_eArgError
ArgumentError exception.
VALUE rb_mKernel
Kernel module.
VALUE rb_cObject
Documented in include/ruby/internal/globals.h.
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_hide(VALUE obj)
Make the object invisible from Ruby code.
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_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 RETURN_SIZED_ENUMERATOR(obj, argc, argv, size_fn)
This roughly resembles return enum_for(__callee__) unless block_given?.
#define UNLIMITED_ARGUMENTS
This macro is used in conjunction with rb_check_arity().
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_str_intern(VALUE str)
Identical to rb_to_symbol(), except it assumes the receiver being an instance of RString.
VALUE rb_attr_get(VALUE obj, ID name)
Identical to rb_ivar_get()
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...
ID rb_check_id(volatile VALUE *namep)
Detects if the given name is already interned or not.
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_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.
#define RARRAY_CONST_PTR_TRANSIENT
Just another name of rb_array_const_ptr_transient.
#define RARRAY_CONST_PTR
Just another name of rb_array_const_ptr.
#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 VALUE
Type that represents a Ruby object.
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
ruby_value_type
C-level type of an object.