12#include "eval_intern.h"
14#include "internal/class.h"
15#include "internal/error.h"
16#include "internal/eval.h"
17#include "internal/gc.h"
18#include "internal/hash.h"
19#include "internal/object.h"
20#include "internal/proc.h"
21#include "internal/symbol.h"
22#include "internal/vm.h"
26#include "ractor_core.h"
29const rb_cref_t *rb_vm_cref_in_context(
VALUE self,
VALUE cbase);
39 const rb_method_entry_t *
const me;
47static VALUE rb_cSourceRange;
50static int method_arity(
VALUE);
51static int method_min_max_arity(
VALUE,
int *max);
64source_range_memsize(
const void *ptr)
69RUBY_REFERENCES(source_range_refs) = {
78 RUBY_REFS_LIST_PTR(source_range_refs),
86rb_source_range_new(
VALUE path,
VALUE absolute_path,
const rb_code_location_t *location)
93 data->start_line = location->beg_pos.lineno;
94 data->start_column = location->beg_pos.column;
95 data->end_line = location->end_pos.lineno;
96 data->end_column = location->end_pos.column;
102source_range_new(
const rb_iseq_t *iseq)
109 VALUE path = rb_iseq_path(iseq);
110 VALUE absolute_path = rb_iseq_realpath(iseq);
115 return rb_source_range_new(path, absolute_path, &ISEQ_BODY(iseq)->location.code_location);
119source_range_data_get(
VALUE self)
134source_range_path(
VALUE self)
136 return source_range_data_get(self)->path;
147source_range_absolute_path(
VALUE self)
149 return source_range_data_get(self)->absolute_path;
159source_range_start_line(
VALUE self)
161 return INT2NUM(source_range_data_get(self)->start_line);
176source_range_start_column(
VALUE self)
178 return INT2NUM(source_range_data_get(self)->start_column);
197source_range_end_line(
VALUE self)
199 return INT2NUM(source_range_data_get(self)->end_line);
218source_range_end_column(
VALUE self)
220 return INT2NUM(source_range_data_get(self)->end_column);
231source_range_inspect(
VALUE self)
235 VALUE path =
NIL_P(data->absolute_path) ? data->path : data->absolute_path;
237 VM_ASSERT(!
NIL_P(path));
240 rb_str_catf(str,
":(%d,%d)-(%d,%d)>",
241 data->start_line, data->start_column,
242 data->end_line, data->end_column);
249#define IS_METHOD_PROC_IFUNC(ifunc) ((ifunc)->func == bmcall)
252block_mark_and_move(
struct rb_block *block)
254 switch (block->type) {
255 case block_type_iseq:
256 case block_type_ifunc:
259 rb_gc_mark_and_move(&captured->self);
260 rb_gc_mark_and_move(&captured->code.val);
262 rb_gc_mark_and_move((
VALUE *)&captured->ep[VM_ENV_DATA_INDEX_ENV]);
266 case block_type_symbol:
267 rb_gc_mark_and_move(&block->as.symbol);
269 case block_type_proc:
270 rb_gc_mark_and_move(&block->as.proc);
275static ID id_refinements_recipe;
278proc_mark_and_move(
void *ptr)
281 block_mark_and_move((
struct rb_block *)&proc->block);
284enum refinement_recipe_index {
285 REFINEMENT_RECIPE_BASE_CREF,
286 REFINEMENT_RECIPE_CREF,
287 REFINEMENT_RECIPE_SRC_ISEQ,
288 REFINEMENT_RECIPE_MODS
294 if (r1 == r2)
return true;
297 if (
RARRAY_AREF(r1, REFINEMENT_RECIPE_BASE_CREF) !=
298 RARRAY_AREF(r2, REFINEMENT_RECIPE_BASE_CREF))
return false;
300 RARRAY_AREF(r2, REFINEMENT_RECIPE_SRC_ISEQ))
return false;
301 for (
rb_len_t i = REFINEMENT_RECIPE_MODS; i <
len; i++) {
308rb_proc_refinements_recipe(
VALUE procval)
311 GetProcPtr(procval, proc);
312 if (!proc->header.is_refined)
return Qnil;
313 return rb_ivar_get(procval, id_refinements_recipe);
317rb_proc_set_refinements_recipe(
VALUE procval,
VALUE recipe)
320 GetProcPtr(procval, proc);
321 rb_ivar_set(procval, id_refinements_recipe, recipe);
322 proc->header.is_refined = 1;
327 VALUE env[VM_ENV_DATA_SIZE + 1];
331cfunc_proc_inline_env_p(
const rb_proc_t *proc)
333 return proc->block.as.captured.ep == ((
const cfunc_proc_t *)proc)->env + VM_ENV_DATA_SIZE - 1;
337proc_memsize(
const void *ptr)
340 switch (proc->block.type) {
341 case block_type_iseq:
342 case block_type_ifunc:
343 if (proc->block.as.captured.ep == ((
const cfunc_proc_t *)ptr)->env+1)
346 case block_type_symbol:
348 case block_type_proc:
351 VM_UNREACHABLE(proc_memsize);
363 0, 0, RUBY_TYPED_THREAD_SAFE_FREE | RUBY_TYPED_WB_PROTECTED
366#define proc_data_type ruby_proc_data_type
369rb_proc_alloc(
VALUE klass,
enum rb_block_type block_type)
372 switch (block_type) {
373 case block_type_symbol:
376 case block_type_proc:
379 case block_type_iseq:
380 case block_type_ifunc:
384 VM_UNREACHABLE(rb_proc_alloc);
388 return rb_data_typed_object_zalloc(klass, size, &proc_data_type);
394 return RBOOL(rb_typeddata_is_kind_of(proc, &proc_data_type));
399proc_clone(
VALUE self)
401 VALUE procval = rb_proc_dup_0(self);
402 return rb_obj_clone_setup(self, procval,
Qnil);
409 VALUE procval = rb_proc_dup_0(self);
410 return rb_obj_dup_setup(self, procval);
413rb_cref_t *rb_vm_get_cref(
const VALUE *ep);
414VALUE rb_proc_dup_with_iseq_and_recipe(
VALUE self,
const rb_iseq_t *iseq,
VALUE recipe);
431enum refinement_memo_index {
432 REFINEMENT_MEMO_RECIPE,
433 REFINEMENT_MEMO_COPIED_ISEQ
436static VALUE refinement_memo_map;
439refinement_memo_get(
const rb_iseq_t *src_iseq)
443 if (refinement_memo_map) {
444 memo = rb_hash_lookup(refinement_memo_map, (
VALUE)src_iseq);
451refinement_memo_set(
const rb_iseq_t *src_iseq,
VALUE recipe,
const rb_iseq_t *copied_iseq)
453 VM_ASSERT(ISEQ_BODY(src_iseq)->
type == ISEQ_TYPE_BLOCK);
465 if (!refinement_memo_map) {
470 if (!refinement_memo_map) {
471 rb_vm_register_global_object(new_map);
472 refinement_memo_map = new_map;
474 rb_hash_aset(refinement_memo_map, (
VALUE)src_iseq, memo);
479refinement_recipe_modc(
VALUE recipe)
481 return NIL_P(recipe) ? 0 :
RARRAY_LEN(recipe) - REFINEMENT_RECIPE_MODS;
485refinement_recipe_match(
VALUE recipe,
const rb_cref_t *base_cref,
VALUE src_recipe,
486 long argc,
const VALUE *mods)
488 rb_len_t inherited = refinement_recipe_modc(src_recipe);
489 if (
RARRAY_AREF(recipe, REFINEMENT_RECIPE_BASE_CREF) != (
VALUE)base_cref)
return false;
490 if (refinement_recipe_modc(recipe) != inherited + argc)
return false;
491 for (
rb_len_t i = 0; i < inherited; i++) {
492 if (
RARRAY_AREF(recipe, REFINEMENT_RECIPE_MODS + i) !=
493 RARRAY_AREF(src_recipe, REFINEMENT_RECIPE_MODS + i))
return false;
495 for (
long i = 0; i < argc; i++) {
496 if (
RARRAY_AREF(recipe, REFINEMENT_RECIPE_MODS + inherited + i) != mods[i])
return false;
502refinement_recipe_new(
const rb_cref_t *base_cref,
const rb_cref_t *cref,
503 const rb_iseq_t *src_iseq,
VALUE src_recipe,
504 long argc,
const VALUE *mods)
506 rb_len_t inherited = refinement_recipe_modc(src_recipe);
511 for (
rb_len_t i = 0; i < inherited; i++) {
514 for (
long i = 0; i < argc; i++) {
523refinement_memo_lookup(
const rb_iseq_t *src_iseq,
const rb_cref_t *base_cref,
VALUE src_recipe,
524 long argc,
const VALUE *mods)
526 VM_ASSERT(ISEQ_BODY(src_iseq)->
type == ISEQ_TYPE_BLOCK);
527 VALUE memo = refinement_memo_get(src_iseq);
530 if (!refinement_recipe_match(recipe, base_cref, src_recipe, argc, mods))
return Qnil;
534static const rb_iseq_t *
535refinement_iseq_copy(
VALUE recipe)
537 const rb_iseq_t *src_iseq =
538 (
const rb_iseq_t *)
RARRAY_AREF(recipe, REFINEMENT_RECIPE_SRC_ISEQ);
539 VALUE memo = refinement_memo_get(src_iseq);
541 if (refinement_recipe_eq(
RARRAY_AREF(memo, REFINEMENT_MEMO_RECIPE), recipe)) {
542 const rb_iseq_t *copied_iseq =
543 (
const rb_iseq_t *)
RARRAY_AREF(memo, REFINEMENT_MEMO_COPIED_ISEQ);
544 if (ISEQ_BODY(copied_iseq)->param.flags.ruby2_keywords ==
545 ISEQ_BODY(src_iseq)->param.flags.ruby2_keywords) {
550 "Proc#refined re-copies the block because the ruby2_keywords flag changed after the copy was memoized"
556 "Proc#refined called with different modules for the same block disables memoization"
562 const rb_iseq_t *copied_iseq = rb_iseq_dup_with_independent_caches(src_iseq);
563 refinement_memo_set(src_iseq, recipe, copied_iseq);
567NOINLINE(
static void refinement_iseq_install(
VALUE procval,
rb_proc_t *proc));
572 const rb_iseq_t *copied_iseq = refinement_iseq_copy(recipe);
575 if (!
FL_TEST_RAW((
VALUE)proc->block.as.captured.code.iseq, ISEQ_REFINED_COPY)) {
584 if (UNLIKELY(!
FL_TEST_RAW((
VALUE)proc->block.as.captured.code.iseq, ISEQ_REFINED_COPY))) {
585 refinement_iseq_install(procval, proc);
590rb_proc_refinements_cref_for_call(
VALUE procval)
593 GetProcPtr(procval, proc);
594 if (!proc->header.is_refined)
return NULL;
596 refinement_iseq_ensure(procval, proc);
598 return (
const rb_cref_t *)
RARRAY_AREF(recipe, REFINEMENT_RECIPE_CREF);
655proc_refined(
int argc,
VALUE *argv,
VALUE self)
658 GetProcPtr(self, src);
664 if (vm_block_type(&src->block) != block_type_iseq || src->header.is_from_method) {
665 rb_raise(rb_eArgError,
"can't apply refinements to a Proc without a Ruby block");
668 for (
int i = 0; i < argc; i++) {
672 const rb_iseq_t *src_iseq = src->block.as.captured.code.iseq;
673 VALUE src_recipe = rb_proc_refinements_recipe(self);
674 const rb_cref_t *src_cref, *base_cref;
675 if (
NIL_P(src_recipe)) {
676 src_cref = base_cref = rb_vm_get_cref(src->block.as.captured.ep);
681 src_cref = (
const rb_cref_t *)
RARRAY_AREF(src_recipe, REFINEMENT_RECIPE_CREF);
682 base_cref = (
const rb_cref_t *)
RARRAY_AREF(src_recipe, REFINEMENT_RECIPE_BASE_CREF);
692 "Proc#refined on a Proc whose block was already copied by Proc#refined is not memoized"
697 refinement_memo_lookup(src_iseq, base_cref, src_recipe, argc, argv);
699 rb_cref_t *cref = rb_vm_cref_dup(src_cref);
702 for (
int i = 0; i < argc; i++) {
703 rb_using_module_recursive(cref, argv[i]);
708 VALUE refs = CREF_REFINEMENTS(cref);
713 CREF_OMOD_SHARED_SET(cref);
714 CREF_REFINED_PROC_SET(cref);
715 recipe = refinement_recipe_new(base_cref, cref, src_iseq, src_recipe, argc, argv);
718 const rb_iseq_t *new_iseq = copied_src ?
719 rb_iseq_dup_with_independent_caches(src_iseq) : src_iseq;
721 return rb_proc_dup_with_iseq_and_recipe(self, new_iseq, recipe);
831 GetProcPtr(procval, proc);
833 return RBOOL(proc->header.is_lambda);
839binding_free(
void *ptr)
841 RUBY_FREE_ENTER(
"binding");
843 RUBY_FREE_LEAVE(
"binding");
847binding_mark_and_move(
void *ptr)
851 block_mark_and_move((
struct rb_block *)&bind->block);
852 rb_gc_mark_and_move((
VALUE *)&bind->pathobj);
856binding_memsize(
const void *ptr)
864 binding_mark_and_move,
867 binding_mark_and_move,
869 0, 0, RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_THREAD_SAFE_FREE
873rb_binding_alloc(
VALUE klass)
879 rb_yjit_collect_binding_alloc();
885binding_copy(
VALUE self)
889 GetBindingPtr(self, src);
890 GetBindingPtr(bindval, dst);
891 rb_vm_block_copy(bindval, &dst->block, &src->block);
893 dst->first_lineno = src->first_lineno;
899binding_dup(
VALUE self)
901 return rb_obj_dup_setup(self, binding_copy(self));
906binding_clone(
VALUE self)
908 return rb_obj_clone_setup(self, binding_copy(self),
Qnil);
914 rb_execution_context_t *ec = GET_EC();
915 return rb_vm_make_binding(ec, ec->cfp);
963rb_f_binding(
VALUE self)
997bind_eval(
int argc,
VALUE *argv,
VALUE bindval)
1001 rb_scan_args(argc, argv,
"12", &args[0], &args[2], &args[3]);
1003 return rb_f_eval(argc+1, args,
Qnil );
1007get_local_variable_ptr(
const rb_env_t **envp,
ID lid,
bool search_outer)
1011 if (!VM_ENV_FLAGS(env->ep, VM_FRAME_FLAG_CFRAME)) {
1012 if (VM_ENV_FLAGS(env->ep, VM_ENV_FLAG_ISOLATED)) {
1016 const rb_iseq_t *iseq = env->iseq;
1018 VM_ASSERT(rb_obj_is_iseq((
VALUE)iseq));
1020 const unsigned int local_table_size = ISEQ_BODY(iseq)->local_table_size;
1021 for (
unsigned int i=0; i<local_table_size; i++) {
1022 if (ISEQ_BODY(iseq)->local_table[i] == lid) {
1023 if (ISEQ_BODY(iseq)->local_iseq == iseq &&
1024 ISEQ_BODY(iseq)->param.flags.has_block &&
1025 (
unsigned int)ISEQ_BODY(iseq)->param.block_start == i) {
1026 const VALUE *ep = env->ep;
1027 if (!VM_ENV_FLAGS(ep, VM_FRAME_FLAG_MODIFIED_BLOCK_PARAM)) {
1028 RB_OBJ_WRITE(env, &env->env[i], rb_vm_bh_to_procval(GET_EC(), VM_ENV_BLOCK_HANDLER(ep)));
1029 VM_ENV_FLAGS_SET(ep, VM_FRAME_FLAG_MODIFIED_BLOCK_PARAM);
1034 unsigned int last_lvar = env->env_size+VM_ENV_INDEX_LAST_LVAR
1036 return &env->env[last_lvar - (local_table_size - i)];
1044 }
while (search_outer && (env = rb_vm_env_prev_env(env)) != NULL);
1056check_local_id(
VALUE bindval,
volatile VALUE *pname)
1059 VALUE name = *pname;
1063 rb_name_err_raise(
"wrong local variable name '%1$s' for %2$s",
1068 if (!rb_is_local_name(name)) {
1069 rb_name_err_raise(
"wrong local variable name '%1$s' for %2$s",
1096bind_local_variables(
VALUE bindval)
1101 GetBindingPtr(bindval, bind);
1102 env = VM_ENV_ENVVAL_PTR(vm_block_ep(&bind->block));
1103 return rb_vm_env_local_variables(env);
1107rb_numparam_id_p(
ID id)
1109 return (tNUMPARAM_1 << ID_SCOPE_SHIFT) <=
id &&
id < ((tNUMPARAM_1 + 9) << ID_SCOPE_SHIFT);
1113rb_implicit_param_p(
ID id)
1115 return id == idItImplicit || rb_numparam_id_p(
id);
1136bind_local_variable_get(
VALUE bindval,
VALUE sym)
1138 ID lid = check_local_id(bindval, &sym);
1143 if (!lid)
goto undefined;
1144 if (rb_numparam_id_p(lid)) {
1145 rb_name_err_raise(
"numbered parameter '%1$s' is not a local variable",
1149 GetBindingPtr(bindval, bind);
1151 env = VM_ENV_ENVVAL_PTR(vm_block_ep(&bind->block));
1152 if ((ptr = get_local_variable_ptr(&env, lid, TRUE)) != NULL) {
1158 rb_name_err_raise(
"local variable '%1$s' is not defined for %2$s",
1191 ID lid = check_local_id(bindval, &sym);
1196 if (!lid) lid = rb_intern_str(sym);
1197 if (rb_numparam_id_p(lid)) {
1198 rb_name_err_raise(
"numbered parameter '%1$s' is not a local variable",
1202 GetBindingPtr(bindval, bind);
1203 env = VM_ENV_ENVVAL_PTR(vm_block_ep(&bind->block));
1204 if ((ptr = get_local_variable_ptr(&env, lid, TRUE)) == NULL) {
1206 ptr = rb_binding_add_dynavars(bindval, bind, 1, &lid);
1207 env = VM_ENV_ENVVAL_PTR(vm_block_ep(&bind->block));
1211 rb_yjit_collect_binding_set();
1237bind_local_variable_defined_p(
VALUE bindval,
VALUE sym)
1239 ID lid = check_local_id(bindval, &sym);
1244 if (rb_numparam_id_p(lid)) {
1245 rb_name_err_raise(
"numbered parameter '%1$s' is not a local variable",
1249 GetBindingPtr(bindval, bind);
1250 env = VM_ENV_ENVVAL_PTR(vm_block_ep(&bind->block));
1251 return RBOOL(get_local_variable_ptr(&env, lid, TRUE));
1275bind_implicit_parameters(
VALUE bindval)
1280 GetBindingPtr(bindval, bind);
1281 env = VM_ENV_ENVVAL_PTR(vm_block_ep(&bind->block));
1283 if (get_local_variable_ptr(&env, idItImplicit, FALSE)) {
1284 return rb_ary_new_from_args(1,
ID2SYM(idIt));
1287 env = VM_ENV_ENVVAL_PTR(vm_block_ep(&bind->block));
1288 return rb_vm_env_numbered_parameters(env);
1312bind_implicit_parameter_get(
VALUE bindval,
VALUE sym)
1314 ID lid = check_local_id(bindval, &sym);
1319 if (lid == idIt) lid = idItImplicit;
1321 if (!lid || !rb_implicit_param_p(lid)) {
1322 rb_name_err_raise(
"'%1$s' is not an implicit parameter",
1326 GetBindingPtr(bindval, bind);
1328 env = VM_ENV_ENVVAL_PTR(vm_block_ep(&bind->block));
1329 if ((ptr = get_local_variable_ptr(&env, lid, FALSE)) != NULL) {
1333 if (lid == idItImplicit) lid = idIt;
1334 rb_name_err_raise(
"implicit parameter '%1$s' is not defined for %2$s", bindval,
ID2SYM(lid));
1362bind_implicit_parameter_defined_p(
VALUE bindval,
VALUE sym)
1364 ID lid = check_local_id(bindval, &sym);
1368 if (lid == idIt) lid = idItImplicit;
1370 if (!lid || !rb_implicit_param_p(lid)) {
1371 rb_name_err_raise(
"'%1$s' is not an implicit parameter",
1375 GetBindingPtr(bindval, bind);
1376 env = VM_ENV_ENVVAL_PTR(vm_block_ep(&bind->block));
1377 return RBOOL(get_local_variable_ptr(&env, lid, FALSE));
1387bind_receiver(
VALUE bindval)
1390 GetBindingPtr(bindval, bind);
1391 return vm_block_self(&bind->block);
1401bind_location(
VALUE bindval)
1405 GetBindingPtr(bindval, bind);
1406 loc[0] = pathobj_path(bind->pathobj);
1407 loc[1] =
INT2FIX(bind->first_lineno);
1420 proc = &sproc->basic;
1421 vm_block_type_set(&proc->block, block_type_ifunc);
1423 *(
VALUE **)&proc->block.as.captured.ep = ep = sproc->env + VM_ENV_DATA_SIZE-1;
1424 ep[VM_ENV_DATA_INDEX_FLAGS] = VM_FRAME_MAGIC_IFUNC | VM_FRAME_FLAG_CFRAME | VM_ENV_FLAG_LOCAL | VM_ENV_FLAG_ESCAPED;
1425 ep[VM_ENV_DATA_INDEX_ME_CREF] =
Qfalse;
1426 ep[VM_ENV_DATA_INDEX_SPECVAL] = VM_BLOCK_HANDLER_NONE;
1427 ep[VM_ENV_DATA_INDEX_ENV] =
Qundef;
1430 RB_OBJ_WRITE(procval, &proc->block.as.captured.code.ifunc, ifunc);
1431 proc->header.is_lambda = TRUE;
1436rb_func_proc_dup(
VALUE src_obj)
1438 RUBY_ASSERT(rb_typeddata_is_instance_of(src_obj, &proc_data_type));
1441 GetProcPtr(src_obj, src_proc);
1442 RUBY_ASSERT(vm_block_type(&src_proc->block) == block_type_ifunc);
1447 memcpy(&proc->basic, src_proc,
sizeof(
rb_proc_t));
1451 const VALUE *src_ep = src_proc->block.as.captured.ep;
1452 if (cfunc_proc_inline_env_p(src_proc)) {
1453 VALUE *ep = *(
VALUE **)&proc->basic.block.as.captured.ep = proc->env + VM_ENV_DATA_SIZE - 1;
1454 ep[VM_ENV_DATA_INDEX_FLAGS] = src_ep[VM_ENV_DATA_INDEX_FLAGS];
1455 ep[VM_ENV_DATA_INDEX_ME_CREF] = src_ep[VM_ENV_DATA_INDEX_ME_CREF];
1456 ep[VM_ENV_DATA_INDEX_SPECVAL] = src_ep[VM_ENV_DATA_INDEX_SPECVAL];
1457 RB_OBJ_WRITE(proc_obj, &ep[VM_ENV_DATA_INDEX_ENV], src_ep[VM_ENV_DATA_INDEX_ENV]);
1460 rb_vm_block_ep_update(proc_obj, &proc->basic.block, src_ep);
1469 VALUE procval = rb_proc_alloc(klass, block_type_symbol);
1471 GetProcPtr(procval, proc);
1473 vm_block_type_set(&proc->block, block_type_symbol);
1474 proc->header.is_lambda = TRUE;
1484 min_argc >= (
int)(1U << (
SIZEOF_VALUE * CHAR_BIT) / 2) ||
1487 rb_raise(
rb_eRangeError,
"minimum argument number out of range: %d",
1492 max_argc >= (
int)(1U << (
SIZEOF_VALUE * CHAR_BIT) / 2) ||
1495 rb_raise(
rb_eRangeError,
"maximum argument number out of range: %d",
1498 rb_execution_context_t *ec = GET_EC();
1500 struct vm_ifunc *ifunc = IMEMO_NEW(
struct vm_ifunc, imemo_ifunc, (
VALUE)rb_vm_svar_lep(ec, ec->cfp));
1502 rb_gc_register_pinning_obj((
VALUE)ifunc);
1506 ifunc->argc.min = min_argc;
1507 ifunc->argc.max = max_argc;
1515 struct vm_ifunc *ifunc = rb_vm_ifunc_new(func, (
void *)val, min_argc, max_argc);
1519static const char proc_without_block[] =
"tried to create Proc object without a block";
1522proc_new(
VALUE klass, int8_t is_lambda)
1525 const rb_execution_context_t *ec = GET_EC();
1526 rb_control_frame_t *cfp = ec->cfp;
1527 VALUE block_handler;
1529 if ((block_handler = rb_vm_frame_block_handler(cfp)) == VM_BLOCK_HANDLER_NONE) {
1530 rb_raise(rb_eArgError, proc_without_block);
1534 switch (vm_block_handler_type(block_handler)) {
1535 case block_handler_type_proc:
1536 procval = VM_BH_TO_PROC(block_handler);
1542 VALUE newprocval = rb_proc_dup(procval);
1543 RBASIC_SET_CLASS(newprocval, klass);
1548 case block_handler_type_symbol:
1550 sym_proc_new(klass, VM_BH_TO_SYMBOL(block_handler)) :
1551 rb_sym_to_proc(VM_BH_TO_SYMBOL(block_handler));
1554 case block_handler_type_ifunc:
1555 case block_handler_type_iseq:
1556 return rb_vm_make_proc_lambda(ec, VM_BH_TO_CAPT_BLOCK(block_handler), klass, is_lambda);
1558 VM_UNREACHABLE(proc_new);
1577rb_proc_s_new(
int argc,
VALUE *argv,
VALUE klass)
1579 VALUE block = proc_new(klass, FALSE);
1611f_lambda_filter_non_literal(
void)
1613 rb_control_frame_t *cfp = GET_EC()->cfp;
1614 VALUE block_handler = rb_vm_frame_block_handler(cfp);
1616 if (block_handler == VM_BLOCK_HANDLER_NONE) {
1621 switch (vm_block_handler_type(block_handler)) {
1622 case block_handler_type_iseq:
1623 if (RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp)->ep == VM_BH_TO_ISEQ_BLOCK(block_handler)->ep) {
1627 case block_handler_type_symbol:
1629 case block_handler_type_proc:
1634 case block_handler_type_ifunc:
1638 rb_raise(rb_eArgError,
"the lambda method requires a literal block");
1652 f_lambda_filter_non_literal();
1707proc_call(
int argc,
VALUE *argv,
VALUE procval)
1713#if SIZEOF_RB_LEN_T > SIZEOF_INT
1717 if (argc > INT_MAX || argc < 0) {
1718 rb_raise(rb_eArgError,
"too many arguments (%"PRIuLEN
")",
1724#define check_argc(argc) (argc)
1739 GetProcPtr(self, proc);
1740 vret = rb_vm_invoke_proc(GET_EC(), proc, argc, argv,
1741 kw_splat, VM_BLOCK_HANDLER_NONE,
1742 rb_proc_refinements_cref_for_call(self));
1755proc_to_block_handler(
VALUE procval)
1757 return NIL_P(procval) ? VM_BLOCK_HANDLER_NONE : procval;
1763 rb_execution_context_t *ec = GET_EC();
1766 GetProcPtr(self, proc);
1767 vret = rb_vm_invoke_proc(ec, proc, argc, argv, kw_splat, proc_to_block_handler(passed_procval),
1768 rb_proc_refinements_cref_for_call(self));
1822proc_arity(
VALUE self)
1829rb_iseq_min_max_arity(
const rb_iseq_t *iseq,
int *max)
1831 *max = ISEQ_BODY(iseq)->param.flags.has_rest == FALSE ?
1832 ISEQ_BODY(iseq)->param.lead_num + ISEQ_BODY(iseq)->param.opt_num + ISEQ_BODY(iseq)->param.post_num +
1833 (ISEQ_BODY(iseq)->param.flags.has_kw == TRUE || ISEQ_BODY(iseq)->param.flags.has_kwrest == TRUE || ISEQ_BODY(iseq)->param.flags.forwardable == TRUE)
1835 return ISEQ_BODY(iseq)->param.lead_num + ISEQ_BODY(iseq)->param.post_num + (ISEQ_BODY(iseq)->param.flags.has_kw && ISEQ_BODY(iseq)->param.keyword->required_num > 0);
1839rb_vm_block_min_max_arity(
const struct rb_block *block,
int *max)
1842 switch (vm_block_type(block)) {
1843 case block_type_iseq:
1844 return rb_iseq_min_max_arity(rb_iseq_check(block->as.captured.code.iseq), max);
1845 case block_type_proc:
1846 block = vm_proc_block(block->as.proc);
1848 case block_type_ifunc:
1850 const struct vm_ifunc *ifunc = block->as.captured.code.ifunc;
1851 if (IS_METHOD_PROC_IFUNC(ifunc)) {
1853 return method_min_max_arity((
VALUE)ifunc->data, max);
1855 *max = ifunc->argc.max;
1856 return ifunc->argc.min;
1858 case block_type_symbol:
1873rb_proc_min_max_arity(
VALUE self,
int *max)
1876 GetProcPtr(self, proc);
1877 return rb_vm_block_min_max_arity(&proc->block, max);
1885 GetProcPtr(self, proc);
1886 min = rb_vm_block_min_max_arity(&proc->block, &max);
1893 switch (vm_block_handler_type(block_handler)) {
1894 case block_handler_type_iseq:
1895 block->type = block_type_iseq;
1896 block->as.captured = *VM_BH_TO_ISEQ_BLOCK(block_handler);
1898 case block_handler_type_ifunc:
1899 block->type = block_type_ifunc;
1900 block->as.captured = *VM_BH_TO_IFUNC_BLOCK(block_handler);
1902 case block_handler_type_symbol:
1903 block->type = block_type_symbol;
1904 block->as.symbol = VM_BH_TO_SYMBOL(block_handler);
1906 case block_handler_type_proc:
1907 block->type = block_type_proc;
1908 block->as.proc = VM_BH_TO_PROC(block_handler);
1913rb_block_pair_yield_optimizable(
void)
1916 const rb_execution_context_t *ec = GET_EC();
1917 rb_control_frame_t *cfp = ec->cfp;
1918 VALUE block_handler = rb_vm_frame_block_handler(cfp);
1921 if (block_handler == VM_BLOCK_HANDLER_NONE) {
1922 rb_raise(rb_eArgError,
"no block given");
1925 block_setup(&block, block_handler);
1926 min = rb_vm_block_min_max_arity(&block, &max);
1928 switch (vm_block_type(&block)) {
1929 case block_type_symbol:
1932 case block_type_proc:
1934 VALUE procval = block_handler;
1936 GetProcPtr(procval, proc);
1937 if (proc->header.is_lambda)
return 0;
1938 if (min != max)
return 0;
1942 case block_type_ifunc:
1944 const struct vm_ifunc *ifunc = block.as.captured.code.ifunc;
1945 if (ifunc->flags & IFUNC_YIELD_OPTIMIZABLE)
return 1;
1957 const rb_execution_context_t *ec = GET_EC();
1958 rb_control_frame_t *cfp = ec->cfp;
1959 VALUE block_handler = rb_vm_frame_block_handler(cfp);
1962 if (block_handler == VM_BLOCK_HANDLER_NONE) {
1963 rb_raise(rb_eArgError,
"no block given");
1966 block_setup(&block, block_handler);
1968 switch (vm_block_type(&block)) {
1969 case block_type_symbol:
1972 case block_type_proc:
1976 min = rb_vm_block_min_max_arity(&block, &max);
1982rb_block_min_max_arity(
int *max)
1984 const rb_execution_context_t *ec = GET_EC();
1985 rb_control_frame_t *cfp = ec->cfp;
1986 VALUE block_handler = rb_vm_frame_block_handler(cfp);
1989 if (block_handler == VM_BLOCK_HANDLER_NONE) {
1990 rb_raise(rb_eArgError,
"no block given");
1993 block_setup(&block, block_handler);
1994 return rb_vm_block_min_max_arity(&block, max);
1998rb_proc_get_iseq(
VALUE self,
int *is_proc)
2003 GetProcPtr(self, proc);
2004 block = &proc->block;
2005 if (is_proc) *is_proc = !proc->header.is_lambda;
2007 switch (vm_block_type(block)) {
2008 case block_type_iseq:
2009 return rb_iseq_check(block->as.captured.code.iseq);
2010 case block_type_proc:
2011 return rb_proc_get_iseq(block->as.proc, is_proc);
2012 case block_type_ifunc:
2014 const struct vm_ifunc *ifunc = block->as.captured.code.ifunc;
2015 if (IS_METHOD_PROC_IFUNC(ifunc)) {
2017 if (is_proc) *is_proc = 0;
2018 return rb_method_iseq((
VALUE)ifunc->data);
2024 case block_type_symbol:
2028 VM_UNREACHABLE(rb_proc_get_iseq);
2067 const rb_proc_t *self_proc, *other_proc;
2068 const struct rb_block *self_block, *other_block;
2074 GetProcPtr(self, self_proc);
2075 GetProcPtr(other, other_proc);
2077 if (self_proc->header.is_from_method != other_proc->header.is_from_method ||
2078 self_proc->header.is_lambda != other_proc->header.is_lambda ||
2079 self_proc->header.is_refined != other_proc->header.is_refined) {
2083 self_block = &self_proc->block;
2084 other_block = &other_proc->block;
2086 if (vm_block_type(self_block) != vm_block_type(other_block)) {
2090 switch (vm_block_type(self_block)) {
2091 case block_type_iseq:
2092 if (self_block->as.captured.ep != \
2093 other_block->as.captured.ep) {
2098 if (self_proc->header.is_refined) {
2099 if (!refinement_recipe_eq(rb_proc_refinements_recipe(self),
2100 rb_proc_refinements_recipe(other))) {
2104 else if (self_block->as.captured.code.iseq != \
2105 other_block->as.captured.code.iseq) {
2109 case block_type_ifunc:
2110 if (self_block->as.captured.code.ifunc != \
2111 other_block->as.captured.code.ifunc) {
2115 if (self_block->as.captured.ep != other_block->as.captured.ep) {
2116 if (!cfunc_proc_inline_env_p(self_proc) ||
2117 !cfunc_proc_inline_env_p(other_proc) ||
2126 case block_type_proc:
2127 if (self_block->as.proc != other_block->as.proc) {
2131 case block_type_symbol:
2132 if (self_block->as.symbol != other_block->as.symbol) {
2142iseq_location(
const rb_iseq_t *iseq)
2146 if (!iseq)
return Qnil;
2147 rb_iseq_check(iseq);
2148 loc[0] = rb_iseq_path(iseq);
2149 loc[1] =
RB_INT2NUM(ISEQ_BODY(iseq)->location.first_lineno);
2155rb_iseq_location(
const rb_iseq_t *iseq)
2157 return iseq_location(iseq);
2169rb_proc_location(
VALUE self)
2171 return iseq_location(rb_proc_get_iseq(self, 0));
2188rb_proc_source_range(
VALUE self)
2190 return source_range_new(rb_proc_get_iseq(self, 0));
2194rb_unnamed_parameters(
int arity)
2197 int n = (arity < 0) ? ~arity : arity;
2231rb_proc_parameters(
int argc,
VALUE *argv,
VALUE self)
2233 static ID keyword_ids[1];
2237 const rb_iseq_t *iseq;
2239 iseq = rb_proc_get_iseq(self, &is_proc);
2241 if (!keyword_ids[0]) {
2242 CONST_ID(keyword_ids[0],
"lambda");
2249 if (!
NIL_P(lambda)) {
2250 is_proc = !
RTEST(lambda);
2257 return rb_iseq_parameters(iseq, is_proc);
2261iseq_location_hash(st_index_t hash,
const rb_iseq_t *iseq)
2265 const rb_iseq_location_t *loc = &body->location;
2266 hash = rb_st_hash_uint(hash, (st_index_t)loc->code_location.beg_pos.lineno);
2267 hash = rb_st_hash_uint(hash, (st_index_t)loc->code_location.beg_pos.column);
2268 hash = rb_st_hash_uint(hash, (st_index_t)loc->code_location.end_pos.lineno);
2269 hash = rb_st_hash_uint(hash, (st_index_t)loc->code_location.end_pos.column);
2275rb_hash_proc(st_index_t hash,
VALUE prc)
2278 GetProcPtr(prc, proc);
2280 switch (vm_block_type(&proc->block)) {
2281 case block_type_iseq:
2282 if (proc->header.is_refined) {
2285 VALUE recipe = rb_proc_refinements_recipe(prc);
2287 hash = rb_st_hash_uint(hash, (st_index_t)
RARRAY_AREF(recipe, REFINEMENT_RECIPE_BASE_CREF));
2288 hash = iseq_location_hash(hash, (
const rb_iseq_t *)
RARRAY_AREF(recipe, REFINEMENT_RECIPE_SRC_ISEQ));
2289 for (
rb_len_t i = REFINEMENT_RECIPE_MODS; i <
len; i++) {
2290 hash = rb_st_hash_uint(hash, (st_index_t)
RARRAY_AREF(recipe, i));
2294 hash = iseq_location_hash(hash, proc->block.as.captured.code.iseq);
2297 case block_type_ifunc:
2298 hash = rb_st_hash_uint(hash, (st_index_t)proc->block.as.captured.code.ifunc->func);
2299 hash = rb_st_hash_uint(hash, (st_index_t)proc->block.as.captured.code.ifunc->data);
2301 case block_type_symbol:
2302 hash = rb_st_hash_uint(hash, rb_any_hash(proc->block.as.symbol));
2304 case block_type_proc:
2305 hash = rb_st_hash_uint(hash, rb_any_hash(proc->block.as.proc));
2308 rb_bug(
"rb_hash_proc: unknown block type %d", vm_block_type(&proc->block));
2315 if (vm_block_type(&proc->block) == block_type_iseq) {
2316 hash =
rb_hash_uint(hash, (st_index_t)proc->block.as.captured.ep);
2339rb_sym_to_proc(
VALUE sym)
2341 enum {SYM_PROC_CACHE_SIZE = 67};
2343 if (rb_ractor_main_p()) {
2344 if (!sym_proc_cache) {
2350 rb_len_t index = (
id % SYM_PROC_CACHE_SIZE);
2352 if (
RTEST(procval)) {
2354 GetProcPtr(procval, proc);
2356 if (proc->block.as.symbol == sym) {
2361 procval = sym_proc_new(
rb_cProc, sym);
2367 return sym_proc_new(
rb_cProc, sym);
2381proc_hash(
VALUE self)
2385 hash = rb_hash_proc(hash, self);
2391rb_block_to_s(
VALUE self,
const struct rb_block *block,
const char *additional_info)
2394 VALUE str = rb_sprintf(
"#<%"PRIsVALUE
":", cname);
2397 switch (vm_block_type(block)) {
2398 case block_type_proc:
2399 block = vm_proc_block(block->as.proc);
2401 case block_type_iseq:
2403 const rb_iseq_t *iseq = rb_iseq_check(block->as.captured.code.iseq);
2404 rb_str_catf(str,
"%p %"PRIsVALUE
":%d", (
void *)self,
2406 ISEQ_BODY(iseq)->location.first_lineno);
2409 case block_type_symbol:
2410 rb_str_catf(str,
"%p(&%+"PRIsVALUE
")", (
void *)self, block->as.symbol);
2412 case block_type_ifunc:
2413 rb_str_catf(str,
"%p", (
void *)block->as.captured.code.ifunc);
2431proc_to_s(
VALUE self)
2434 GetProcPtr(self, proc);
2435 return rb_block_to_s(self, &proc->block, proc->header.is_lambda ?
" (lambda)" : NULL);
2447proc_to_proc(
VALUE self)
2453bm_mark_and_move(
void *ptr)
2455 struct METHOD *data = ptr;
2456 rb_gc_mark_and_move((
VALUE *)&data->recv);
2457 rb_gc_mark_and_move((
VALUE *)&data->klass);
2458 rb_gc_mark_and_move((
VALUE *)&data->iclass);
2459 rb_gc_mark_and_move((
VALUE *)&data->owner);
2460 rb_gc_mark_and_move_ptr((rb_method_entry_t **)&data->me);
2471 0, 0, RUBY_TYPED_THREAD_SAFE_FREE | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_EMBEDDABLE | RUBY_TYPED_FROZEN_SHAREABLE_NO_REC
2477 return RBOOL(rb_typeddata_is_kind_of(m, &method_data_type));
2484 ID rmiss = idRespond_to_missing;
2486 if (UNDEF_P(obj))
return 0;
2497 rb_method_entry_t *me;
2498 rb_method_definition_t *def;
2504 def =
ZALLOC(rb_method_definition_t);
2505 def->type = VM_METHOD_TYPE_MISSING;
2506 def->original_id = id;
2508 me = rb_method_entry_create(
id, klass, METHOD_VISI_UNDEF, def);
2520 if (!respond_to_missing_p(klass, obj, vid, scope))
return Qfalse;
2521 return mnew_missing(klass, obj,
SYM2ID(vid), mclass);
2527refinement_module_p(
VALUE mod)
2532VALUE rb_vm_module_refinement_iclass(
VALUE refinement_iclass,
VALUE defined_class);
2533VALUE rb_vm_refinement_iclass_for_cme(
VALUE refinement,
const rb_callable_method_entry_t *cme);
2536find_refined_target_ancestor(
VALUE start,
VALUE refined_target)
2539 for (klass = start; klass; klass =
RCLASS_SUPER(klass)) {
2551 for (klass = start; klass; klass =
RCLASS_SUPER(klass)) {
2552 if (klass == ancestor)
return klass;
2560 VALUE refined_target = rb_refinement_module_get_refined_class(owner);
2568 while (RICLASS_FOR_REFINEMENT_P(refinement_iclass)) {
2572 RBASIC(refinement_iclass)->klass == refined_target &&
2573 find_ancestor(klass, refinement_iclass)) {
2577 VALUE refined_ancestor = find_refined_target_ancestor(klass, refined_target);
2578 if (!refined_ancestor) {
2579 refined_ancestor = rb_include_class_new(refined_target, klass);
2581 iclass = rb_vm_module_refinement_iclass(iclass, refined_ancestor);
2588mnew_internal(
const rb_method_entry_t *me,
VALUE klass,
VALUE iclass,
2593 const rb_method_entry_t *original_me = me;
2594 rb_method_visibility_t visi = METHOD_VISI_UNDEF;
2597 if (UNDEFINED_METHOD_ENTRY_P(me)) {
2598 if (respond_to_missing_p(klass, obj,
ID2SYM(
id), scope)) {
2599 return mnew_missing(klass, obj,
id, mclass);
2601 if (!error)
return Qnil;
2602 rb_print_undef(klass,
id, METHOD_VISI_UNDEF);
2604 if (visi == METHOD_VISI_UNDEF) {
2605 visi = METHOD_ENTRY_VISI(me);
2607 if (scope && (visi != METHOD_VISI_PUBLIC)) {
2608 if (!error)
return Qnil;
2609 rb_print_inaccessible(klass,
id, visi);
2612 if (me->def->type == VM_METHOD_TYPE_ZSUPER ||
2613 (me->def->type == VM_METHOD_TYPE_CFUNC && me->def->body.cfunc.func == (rb_cfunc_t)rb_zsuper_to_super)) {
2614 if (me->def->type == VM_METHOD_TYPE_ZSUPER && me->defined_class) {
2616 id = me->def->original_id;
2617 me = (rb_method_entry_t *)rb_callable_method_entry_with_refinements(klass,
id, &iclass);
2621 id = me->def->original_id;
2622 me = rb_method_entry_without_refinements(klass,
id, &iclass);
2638 RB_OBJ_WRITE(method, &data->owner, original_me->owner);
2645mnew_from_me(
const rb_method_entry_t *me,
VALUE klass,
VALUE iclass,
2648 if (me && refinement_module_p(me->owner) && !RICLASS_FOR_REFINEMENT_P(iclass)) {
2652 return mnew_internal(me, klass, iclass, obj,
id, mclass, scope, TRUE);
2658 const rb_method_entry_t *me;
2662 me = (rb_method_entry_t *)rb_callable_method_entry_with_refinements(klass,
id, &iclass);
2663 return mnew_from_me(me, klass, iclass, obj,
id, mclass, scope);
2667mnew_unbound(
VALUE klass,
ID id,
VALUE mclass,
int scope)
2669 const rb_method_entry_t *me;
2672 me = rb_method_entry_with_refinements(klass,
id, &iclass);
2673 return mnew_from_me(me, klass, iclass,
Qundef,
id, mclass, scope);
2677method_entry_defined_class(
const rb_method_entry_t *me)
2679 VALUE defined_class = me->defined_class;
2680 return defined_class ? defined_class : me->owner;
2724 VALUE klass1, klass2;
2732 m1 = (
struct METHOD *)RTYPEDDATA_GET_DATA(method);
2733 m2 = (
struct METHOD *)RTYPEDDATA_GET_DATA(other);
2735 klass1 = method_entry_defined_class(m1->me);
2736 klass2 = method_entry_defined_class(m2->me);
2740 if (!rb_method_entry_eq(m1->me, m2->me) ||
2742 m1->klass != m2->klass ||
2743 m1->recv != m2->recv) {
2764#define unbound_method_eq method_eq
2776method_hash(
VALUE method)
2783 hash = rb_hash_method_entry(hash, m->me);
2799method_unbind(
VALUE obj)
2802 struct METHOD *orig, *data;
2806 &method_data_type, data);
2811 RB_OBJ_WRITE(method, &data->me, rb_method_entry_clone(orig->me));
2826method_receiver(
VALUE obj)
2842method_name(
VALUE obj)
2847 return ID2SYM(data->me->called_id);
2864method_original_name(
VALUE obj)
2869 return ID2SYM(data->me->def->original_id);
2891method_owner(
VALUE obj)
2905method_box(
VALUE obj)
2908 const rb_box_t *box;
2911 box = data->me->def->box;
2912 if (!box)
return Qnil;
2913 if (box->box_object)
return box->box_object;
2914 rb_bug(
"Unexpected box on the method definition: %p", (
void*) box);
2921#define MSG(s) rb_fstring_lit("undefined method '%1$s' for"s" '%2$s'")
2925 if (RCLASS_SINGLETON_P(c)) {
2926 VALUE obj = RCLASS_ATTACHED_OBJECT(klass);
2943 rb_name_err_raise_str(s, c, str);
2955 VALUE m = mnew_missing_by_name(klass, obj, &vid, scope, mclass);
2957 rb_method_name_error(klass, vid);
2959 return mnew_callable(klass, obj,
id, mclass, scope);
3004 return obj_method(obj, vid, FALSE);
3017 return obj_method(obj, vid, TRUE);
3021rb_obj_singleton_method_lookup(
VALUE arg)
3028rb_obj_singleton_method_lookup_fail(
VALUE arg1,
VALUE arg2)
3065 NIL_P(klass = RCLASS_ORIGIN(sc)) ||
3066 !
NIL_P(rb_special_singleton_class(obj))) {
3075 VALUE args[2] = {obj, vid};
3076 VALUE ruby_method =
rb_rescue(rb_obj_singleton_method_lookup, (
VALUE)args, rb_obj_singleton_method_lookup_fail,
Qfalse);
3078 struct METHOD *method = (
struct METHOD *)RTYPEDDATA_GET_DATA(ruby_method);
3081 VALUE method_class = method->iclass;
3085 if (lookup_class == method_class) {
3089 }
while (lookup_class && lookup_class != stop_class);
3094 if (
id) vid =
ID2SYM(
id);
3095 rb_name_err_raise(
"undefined singleton method '%1$s' for '%2$s'",
3136 rb_method_name_error(mod, vid);
3149rb_mod_public_instance_method(
VALUE mod,
VALUE vid)
3153 rb_method_name_error(mod, vid);
3164 int is_method = FALSE;
3183 "wrong argument type %s (expected Proc/Method/UnboundMethod)",
3190 struct METHOD *method = (
struct METHOD *)RTYPEDDATA_GET_DATA(body);
3193 if (RCLASS_SINGLETON_P(method->me->owner)) {
3195 "can't bind singleton method to a different class");
3199 "bind argument must be a subclass of % "PRIsVALUE,
3203 rb_method_entry_set(mod,
id, method->me, scope_visi->method_visi);
3204 if (scope_visi->module_func) {
3211 GetProcPtr(body, body_proc);
3214 if (body_proc->header.is_refined) {
3215 rb_raise(rb_eArgError,
3216 "can't define a method from a Proc with refinements");
3218 VALUE procval = rb_proc_dup(body);
3219 if (vm_proc_iseq(procval) != NULL) {
3221 GetProcPtr(procval, proc);
3222 proc->header.is_lambda = TRUE;
3223 proc->header.is_from_method = TRUE;
3225 rb_add_method(mod,
id, VM_METHOD_TYPE_BMETHOD, (
void *)procval, scope_visi->method_visi);
3226 if (scope_visi->module_func) {
3227 rb_add_method(
rb_singleton_class(mod),
id, VM_METHOD_TYPE_BMETHOD, (
void *)body, METHOD_VISI_PUBLIC);
3275rb_mod_define_method(
int argc,
VALUE *argv,
VALUE mod)
3277 const rb_cref_t *cref = rb_vm_cref_in_context(mod, mod);
3278 const rb_scope_visibility_t default_scope_visi = {METHOD_VISI_PUBLIC, FALSE};
3279 const rb_scope_visibility_t *scope_visi = &default_scope_visi;
3282 scope_visi = CREF_SCOPE_VISI(cref);
3285 return rb_mod_define_method_with_visibility(argc, argv, mod, scope_visi);
3320rb_obj_define_method(
int argc,
VALUE *argv,
VALUE obj)
3323 const rb_scope_visibility_t scope_visi = {METHOD_VISI_PUBLIC, FALSE};
3325 return rb_mod_define_method_with_visibility(argc, argv, klass, &scope_visi);
3336top_define_method(
int argc,
VALUE *argv,
VALUE obj)
3338 return rb_mod_define_method(argc, argv, rb_top_main_class(
"define_method"));
3359method_clone(
VALUE self)
3362 struct METHOD *orig, *data;
3366 rb_obj_clone_setup(self, clone,
Qnil);
3371 RB_OBJ_WRITE(clone, &data->me, rb_method_entry_clone(orig->me));
3377method_dup(
VALUE self)
3380 struct METHOD *orig, *data;
3384 rb_obj_dup_setup(self, clone);
3389 RB_OBJ_WRITE(clone, &data->me, rb_method_entry_clone(orig->me));
3418rb_method_call_pass_called_kw(
int argc,
const VALUE *argv,
VALUE method)
3437static const rb_callable_method_entry_t *
3438method_callable_method_entry(
const struct METHOD *data)
3440 if (data->me->defined_class == 0) rb_bug(
"method_callable_method_entry: not callable.");
3441 return (
const rb_callable_method_entry_t *)data->me;
3445call_method_data(rb_execution_context_t *ec,
const struct METHOD *data,
3446 int argc,
const VALUE *argv,
VALUE passed_procval,
int kw_splat)
3448 vm_passed_block_handler_set(ec, proc_to_block_handler(passed_procval));
3449 return rb_vm_call_kw(ec, data->recv, data->me->called_id, argc, argv,
3450 method_callable_method_entry(data), kw_splat);
3456 const struct METHOD *data;
3457 rb_execution_context_t *ec = GET_EC();
3460 if (UNDEF_P(data->recv)) {
3461 rb_raise(
rb_eTypeError,
"can't call unbound method; bind first");
3463 return call_method_data(ec, data, argc, argv, passed_procval, kw_splat);
3528convert_umethod_to_method_components(
const struct METHOD *data,
VALUE recv,
VALUE *methclass_out,
VALUE *klass_out,
VALUE *iclass_out,
const rb_method_entry_t **me_out,
const bool clone)
3530 VALUE methclass = data->owner;
3531 VALUE iclass = data->iclass;
3535 VALUE refined_class = rb_refinement_module_get_refined_class(methclass);
3536 if (!
NIL_P(refined_class)) methclass = refined_class;
3539 if (RCLASS_SINGLETON_P(methclass)) {
3541 "singleton method called for a different object");
3544 rb_raise(
rb_eTypeError,
"bind argument must be an instance of % "PRIsVALUE,
3549 const rb_method_entry_t *me;
3551 me = rb_method_entry_clone(data->me);
3561 me = rb_method_entry_clone(me);
3563 if (refinement_module_p(me->owner) && RICLASS_FOR_REFINEMENT_P(iclass)) {
3564 iclass = find_refinement_iclass(me->owner, klass, iclass);
3569 if (!ic) ic = rb_class_search_ancestor(klass, me->owner);
3575 klass = rb_include_class_new(methclass, klass);
3579 me = (
const rb_method_entry_t *) rb_method_entry_complement_defined_class(me, me->called_id, klass);
3582 *methclass_out = methclass;
3584 *iclass_out = iclass;
3626 VALUE methclass, klass, iclass;
3627 const rb_method_entry_t *me;
3628 const struct METHOD *data;
3630 convert_umethod_to_method_components(data, recv, &methclass, &klass, &iclass, &me,
true);
3652umethod_bind_call(
int argc,
VALUE *argv,
VALUE method)
3655 VALUE recv = argv[0];
3660 rb_execution_context_t *ec = GET_EC();
3662 const struct METHOD *data;
3665 const rb_callable_method_entry_t *cme = rb_callable_method_entry(
CLASS_OF(recv), data->me->called_id);
3666 if (data->me == (
const rb_method_entry_t *)cme) {
3667 vm_passed_block_handler_set(ec, proc_to_block_handler(passed_procval));
3671 VALUE methclass, klass, iclass;
3672 const rb_method_entry_t *me;
3673 convert_umethod_to_method_components(data, recv, &methclass, &klass, &iclass, &me,
false);
3674 struct METHOD bound = { recv, klass, 0, methclass, me };
3686method_def_min_max_arity(
const rb_method_definition_t *def,
int *max)
3689 if (!def)
return *max = 0;
3690 switch (def->type) {
3691 case VM_METHOD_TYPE_CFUNC:
3692 if (def->body.cfunc.argc < 0) {
3696 return *max = check_argc(def->body.cfunc.argc);
3697 case VM_METHOD_TYPE_ZSUPER:
3700 case VM_METHOD_TYPE_ATTRSET:
3702 case VM_METHOD_TYPE_IVAR:
3704 case VM_METHOD_TYPE_ALIAS:
3705 def = rb_method_entry_def_acquire(rb_method_alias_original_me(def));
3707 case VM_METHOD_TYPE_BMETHOD:
3708 return rb_proc_min_max_arity(def->body.bmethod.proc, max);
3709 case VM_METHOD_TYPE_ISEQ:
3710 return rb_iseq_min_max_arity(rb_iseq_check(def->body.iseq.
iseqptr), max);
3711 case VM_METHOD_TYPE_UNDEF:
3712 case VM_METHOD_TYPE_NOTIMPLEMENTED:
3714 case VM_METHOD_TYPE_MISSING:
3717 case VM_METHOD_TYPE_OPTIMIZED: {
3718 switch (def->body.optimized.type) {
3719 case OPTIMIZED_METHOD_TYPE_SEND:
3722 case OPTIMIZED_METHOD_TYPE_CALL:
3725 case OPTIMIZED_METHOD_TYPE_BLOCK_CALL:
3728 case OPTIMIZED_METHOD_TYPE_STRUCT_AREF:
3731 case OPTIMIZED_METHOD_TYPE_STRUCT_ASET:
3739 case VM_METHOD_TYPE_REFINED:
3743 rb_bug(
"method_def_min_max_arity: invalid method entry type (%d)", def->type);
3748method_def_arity(
const rb_method_definition_t *def)
3750 int max, min = method_def_min_max_arity(def, &max);
3751 return min == max ? min : -min-1;
3755rb_method_entry_arity(
const rb_method_entry_t *me)
3757 return method_def_arity(rb_method_entry_def_acquire(me));
3804method_arity_m(
VALUE method)
3806 int n = method_arity(method);
3811method_arity(
VALUE method)
3816 return rb_method_entry_arity(data->me);
3819static const rb_method_entry_t *
3820original_method_entry(
VALUE mod,
ID id)
3822 const rb_method_entry_t *me;
3824 while ((me = rb_method_entry(mod,
id)) != 0) {
3825 const rb_method_definition_t *def = me->def;
3827 if (def->type != VM_METHOD_TYPE_ZSUPER &&
3828 (def->type != VM_METHOD_TYPE_CFUNC ||
3829 def->body.cfunc.func != (rb_cfunc_t)rb_zsuper_to_super))
break;
3832 id = def->original_id;
3838method_min_max_arity(
VALUE method,
int *max)
3840 const struct METHOD *data;
3843 return method_def_min_max_arity(rb_method_entry_def_acquire(data->me), max);
3849 const rb_method_entry_t *me = original_method_entry(mod,
id);
3851 return rb_method_entry_arity(me);
3861rb_callable_receiver(
VALUE callable)
3864 VALUE binding = proc_binding(callable);
3865 return rb_funcall(binding, rb_intern(
"receiver"), 0);
3868 return method_receiver(callable);
3875const rb_method_definition_t *
3876rb_method_def(
VALUE method)
3878 const struct METHOD *data;
3881 return rb_method_entry_def_acquire(data->me);
3884static const rb_iseq_t *
3885method_def_iseq(
const rb_method_definition_t *def)
3887 switch (def->type) {
3888 case VM_METHOD_TYPE_ISEQ:
3889 return rb_iseq_check(def->body.iseq.
iseqptr);
3890 case VM_METHOD_TYPE_BMETHOD:
3891 return rb_proc_get_iseq(def->body.bmethod.proc, 0);
3892 case VM_METHOD_TYPE_ALIAS:
3893 return method_def_iseq(rb_method_entry_def_acquire(rb_method_alias_original_me(def)));
3894 case VM_METHOD_TYPE_CFUNC:
3895 case VM_METHOD_TYPE_ATTRSET:
3896 case VM_METHOD_TYPE_IVAR:
3897 case VM_METHOD_TYPE_ZSUPER:
3898 case VM_METHOD_TYPE_UNDEF:
3899 case VM_METHOD_TYPE_NOTIMPLEMENTED:
3900 case VM_METHOD_TYPE_OPTIMIZED:
3901 case VM_METHOD_TYPE_MISSING:
3902 case VM_METHOD_TYPE_REFINED:
3909rb_method_iseq(
VALUE method)
3911 return method_def_iseq(rb_method_def(method));
3914static const rb_cref_t *
3915method_cref(
VALUE method)
3917 const rb_method_definition_t *def = rb_method_def(method);
3920 switch (def->type) {
3921 case VM_METHOD_TYPE_ISEQ:
3922 return def->body.iseq.
cref;
3923 case VM_METHOD_TYPE_ALIAS:
3924 def = rb_method_entry_def_acquire(rb_method_alias_original_me(def));
3932method_def_location(
const rb_method_definition_t *def)
3934 if (def->type == VM_METHOD_TYPE_ATTRSET || def->type == VM_METHOD_TYPE_IVAR) {
3935 if (!def->body.attr.location)
3939 return iseq_location(method_def_iseq(def));
3943rb_method_entry_location(
const rb_method_entry_t *me)
3945 if (!me)
return Qnil;
3946 return method_def_location(rb_method_entry_def_acquire(me));
3966rb_method_location(
VALUE method)
3968 return method_def_location(rb_method_def(method));
3972method_def_source_range(
const rb_method_definition_t *def)
3974 return source_range_new(method_def_iseq(def));
3991rb_method_source_range(
VALUE method)
3993 return method_def_source_range(rb_method_def(method));
3996static const rb_method_definition_t *
3997vm_proc_method_def(
VALUE procval)
4003 GetProcPtr(procval, proc);
4004 block = &proc->block;
4006 if (vm_block_type(block) == block_type_ifunc &&
4007 IS_METHOD_PROC_IFUNC(ifunc = block->as.captured.code.ifunc)) {
4008 return rb_method_def((
VALUE)ifunc->data);
4016method_def_parameters(
const rb_method_definition_t *def)
4018 const rb_iseq_t *iseq;
4019 const rb_method_definition_t *bmethod_def;
4021 switch (def->type) {
4022 case VM_METHOD_TYPE_ISEQ:
4023 iseq = method_def_iseq(def);
4024 return rb_iseq_parameters(iseq, 0);
4025 case VM_METHOD_TYPE_BMETHOD:
4026 if ((iseq = method_def_iseq(def)) != NULL) {
4027 return rb_iseq_parameters(iseq, 0);
4029 else if ((bmethod_def = vm_proc_method_def(def->body.bmethod.proc)) != NULL) {
4030 return method_def_parameters(bmethod_def);
4034 case VM_METHOD_TYPE_ALIAS:
4035 return method_def_parameters(rb_method_entry_def_acquire(rb_method_alias_original_me(def)));
4037 case VM_METHOD_TYPE_OPTIMIZED:
4038 if (def->body.optimized.type == OPTIMIZED_METHOD_TYPE_STRUCT_ASET) {
4039 VALUE param = rb_ary_new_from_args(2,
ID2SYM(rb_intern(
"req")),
ID2SYM(rb_intern(
"_")));
4040 return rb_ary_new_from_args(1, param);
4044 case VM_METHOD_TYPE_CFUNC:
4045 case VM_METHOD_TYPE_ATTRSET:
4046 case VM_METHOD_TYPE_IVAR:
4047 case VM_METHOD_TYPE_ZSUPER:
4048 case VM_METHOD_TYPE_UNDEF:
4049 case VM_METHOD_TYPE_NOTIMPLEMENTED:
4050 case VM_METHOD_TYPE_MISSING:
4051 case VM_METHOD_TYPE_REFINED:
4055 return rb_unnamed_parameters(method_def_arity(def));
4079rb_method_parameters(
VALUE method)
4081 return method_def_parameters(rb_method_def(method));
4085append_param_name(
VALUE str,
VALUE name,
const char *unnamed)
4130method_inspect(
VALUE method)
4134 const char *sharp =
"#";
4136 VALUE defined_class;
4139 str = rb_sprintf(
"#<% "PRIsVALUE
": ",
rb_obj_class(method));
4141 mklass = data->iclass;
4142 if (!mklass) mklass = data->klass;
4152 const rb_method_definition_t *def = rb_method_entry_def_acquire(data->me);
4153 if (def->type == VM_METHOD_TYPE_ALIAS) {
4154 defined_class = rb_method_alias_original_me(def)->owner;
4157 defined_class = method_entry_defined_class(data->me);
4164 if (UNDEF_P(data->recv)) {
4168 else if (RCLASS_SINGLETON_P(mklass)) {
4169 VALUE v = RCLASS_ATTACHED_OBJECT(mklass);
4171 if (UNDEF_P(data->recv)) {
4174 else if (data->recv == v) {
4187 mklass = data->klass;
4191 if (RCLASS_SINGLETON_P(mklass)) {
4192 VALUE v = RCLASS_ATTACHED_OBJECT(mklass);
4200 if (defined_class != mklass) {
4201 rb_str_catf(str,
"(% "PRIsVALUE
")", defined_class);
4206 if (data->me->called_id != def->original_id) {
4207 rb_str_catf(str,
"(%"PRIsVALUE
")",
4208 rb_id2str(def->original_id));
4210 if (def->type == VM_METHOD_TYPE_NOTIMPLEMENTED) {
4216 VALUE params = rb_method_parameters(method);
4217 VALUE pair, name, kind;
4223 const VALUE keyrest =
ID2SYM(rb_intern(
"keyrest"));
4226 const VALUE noblock =
ID2SYM(rb_intern(
"noblock"));
4241 for (
int i = 0; i <
RARRAY_LEN(params); i++) {
4252 append_param_name(str, name,
"_");
4254 else if (kind == opt) {
4257 else if (kind == keyreq) {
4260 else if (kind == key) {
4263 else if (kind == rest) {
4265 if (name !=
ID2SYM(
'*')) {
4266 append_param_name(str, name, NULL);
4269 else if (kind == keyrest) {
4270 if (name !=
ID2SYM(idPow)) {
4280 else if (kind == block) {
4281 if (name ==
ID2SYM(
'&')) {
4293 else if (kind == nokey) {
4296 else if (kind == noblock) {
4308 VALUE loc = rb_method_location(method);
4310 rb_str_catf(str,
" %"PRIsVALUE
":%"PRIsVALUE,
4343method_to_proc(
VALUE method)
4357 procval =
rb_block_call(rb_mRubyVMFrozenCore, idLambda, 0, 0, bmcall, method);
4358 GetProcPtr(procval, proc);
4359 proc->header.is_from_method = 1;
4363extern VALUE rb_find_defined_class_by_owner(
VALUE current_class,
VALUE target_owner);
4364extern int rb_method_definition_eq(
const rb_method_definition_t *d1,
const rb_method_definition_t *d2);
4365rb_cref_t * rb_vm_get_cref(
const VALUE *ep);
4376method_super_method(
VALUE method)
4378 const struct METHOD *data;
4379 VALUE super_class, iclass;
4381 const rb_method_entry_t *me;
4384 iclass = data->iclass;
4385 if (!iclass)
return Qnil;
4386 bool is_refinement_method = refinement_module_p(data->me->owner);
4387 const rb_method_definition_t *def = rb_method_entry_def_acquire(data->me);
4388 if (def->type == VM_METHOD_TYPE_ALIAS && data->me->defined_class) {
4389 const rb_method_entry_t *orig_me = rb_method_alias_original_me(def);
4390 super_class =
RCLASS_SUPER(rb_find_defined_class_by_owner(data->me->defined_class,
4392 mid = rb_method_entry_def_acquire(orig_me)->original_id;
4394 else if (is_refinement_method) {
4395 if (RICLASS_FOR_REFINEMENT_P(iclass)) {
4398 iclass = super_class;
4399 }
while (RICLASS_FOR_REFINEMENT_P(super_class));
4402 super_class = find_refined_target_ancestor(iclass, rb_refinement_module_get_refined_class(data->me->owner));
4407 mid = def->original_id;
4410 VALUE klass = iclass;
4411 if (RICLASS_FOR_REFINEMENT_P(klass)) {
4413 klass =
RBASIC(klass)->klass;
4416 mid = def->original_id;
4418 if (!super_class)
return Qnil;
4422 const rb_method_definition_t *skip_def = is_refinement_method ? def : NULL;
4427 const rb_cref_t *cref = NULL;
4428 switch (def->type) {
4429 case VM_METHOD_TYPE_ISEQ:
4430 cref = def->body.iseq.
cref;
4432 case VM_METHOD_TYPE_BMETHOD: {
4434 GetProcPtr(def->body.bmethod.proc, proc);
4435 const struct rb_block *block = &proc->block;
4436 if (vm_block_type(block) == block_type_iseq)
4437 cref = rb_vm_get_cref(block->as.captured.ep);
4443 VALUE klass = super_class;
4446 const rb_callable_method_entry_t *cme = rb_callable_method_entry(klass, mid);
4448 if (cme->def->type != VM_METHOD_TYPE_REFINED) {
4449 me = (rb_method_entry_t *)cme;
4450 iclass = cme->defined_class;
4456 for (c = cref; c; c = CREF_NEXT(c)) {
4457 VALUE refs = CREF_REFINEMENTS(c);
4458 if (
NIL_P(refs))
continue;
4459 VALUE r = rb_hash_lookup(refs, cme->owner);
4460 if (
NIL_P(r))
continue;
4461 r = rb_vm_refinement_iclass_for_cme(r, cme);
4462 const rb_callable_method_entry_t *ref_cme = rb_callable_method_entry(r, mid);
4463 if (!ref_cme)
break;
4464 if (ref_cme->def->type == VM_METHOD_TYPE_REFINED)
continue;
4465 if (skip_def && rb_method_definition_eq(ref_cme->def, skip_def))
continue;
4466 me = (rb_method_entry_t *)ref_cme;
4467 iclass = ref_cme->defined_class;
4473 const rb_method_entry_t *orig_me = cme->def->body.refined.orig_me;
4475 me = (rb_method_entry_t *)orig_me;
4476 iclass = cme->defined_class;
4481 if (!me)
return Qnil;
4483 return mnew_internal(me, mklass, iclass, data->recv, mid,
rb_obj_class(method), FALSE, FALSE);
4493localjump_xvalue(
VALUE exc)
4507localjump_reason(
VALUE exc)
4512rb_cref_t *rb_vm_cref_new_toplevel(
void);
4515env_clone(
const rb_env_t *env,
const rb_cref_t *cref)
4521 VM_ASSERT(env->ep > env->env);
4522 VM_ASSERT(VM_ENV_ESCAPED_P(env->ep));
4525 cref = rb_vm_cref_new_toplevel();
4529 new_ep = &new_body[env->ep - env->env];
4530 new_env = vm_env_new(new_ep, new_body, env->env_size, env->iseq);
4537 new_ep[VM_ENV_DATA_INDEX_ENV] = (
VALUE)new_env;
4539 VM_ASSERT(VM_ENV_ESCAPED_P(new_ep));
4557proc_binding(
VALUE self)
4562 const rb_iseq_t *iseq = NULL;
4566 GetProcPtr(self, proc);
4567 block = &proc->block;
4569 if (proc->header.is_isolated) rb_raise(rb_eArgError,
"Can't create Binding from isolated Proc");
4572 switch (vm_block_type(block)) {
4573 case block_type_iseq:
4574 iseq = block->as.captured.code.iseq;
4575 binding_self = block->as.captured.self;
4576 env = VM_ENV_ENVVAL_PTR(block->as.captured.ep);
4578 case block_type_proc:
4579 GetProcPtr(block->as.proc, proc);
4580 block = &proc->block;
4582 case block_type_ifunc:
4584 const struct vm_ifunc *ifunc = block->as.captured.code.ifunc;
4585 if (IS_METHOD_PROC_IFUNC(ifunc)) {
4587 VALUE name = rb_fstring_lit(
"<empty_iseq>");
4589 binding_self = method_receiver(method);
4590 iseq = rb_method_iseq(method);
4591 env = VM_ENV_ENVVAL_PTR(block->as.captured.ep);
4592 env = env_clone(env, method_cref(method));
4594 empty = rb_iseq_new(
Qnil, name, name,
Qnil, 0, ISEQ_TYPE_TOP);
4600 case block_type_symbol:
4601 rb_raise(rb_eArgError,
"Can't create Binding from C level Proc");
4606 GetBindingPtr(bindval, bind);
4607 RB_OBJ_WRITE(bindval, &bind->block.as.captured.self, binding_self);
4608 RB_OBJ_WRITE(bindval, &bind->block.as.captured.code.iseq, env->iseq);
4609 rb_vm_block_ep_update(bindval, &bind->block, env->ep);
4613 rb_iseq_check(iseq);
4614 RB_OBJ_WRITE(bindval, &bind->pathobj, ISEQ_BODY(iseq)->location.pathobj);
4615 bind->no_realpath = ISEQ_BODY(iseq)->no_realpath;
4616 bind->first_lineno = ISEQ_BODY(iseq)->location.first_lineno;
4621 rb_iseq_pathobj_new(rb_fstring_lit(
"(binding)"),
Qnil, &no_realpath));
4622 bind->no_realpath = no_realpath;
4623 bind->first_lineno = 1;
4638 GetProcPtr(proc, procp);
4639 is_lambda = procp->header.is_lambda;
4643 GetProcPtr(proc, procp);
4644 procp->header.is_lambda = is_lambda;
4651 VALUE proc, passed, arity;
4660 if (!
NIL_P(blockarg)) {
4661 rb_warn(
"given block not used");
4663 arity = make_curry_proc(proc, passed, arity);
4726proc_curry(
int argc,
const VALUE *argv,
VALUE self)
4728 int sarity, max_arity, min_arity = rb_proc_min_max_arity(self, &max_arity);
4742 return make_curry_proc(self,
rb_ary_new(), arity);
4778rb_method_curry(
int argc,
const VALUE *argv,
VALUE self)
4780 VALUE proc = method_to_proc(self);
4781 return proc_curry(argc, argv, proc);
4810 mesg = rb_fstring_lit(
"callable object is expected");
4834 return rb_proc_compose_to_left(self, to_callable(g));
4840 VALUE proc, args, procs[2];
4846 args = rb_ary_tmp_new_from_values(0, 2, procs);
4849 GetProcPtr(g, procp);
4850 is_lambda = procp->header.is_lambda;
4858 GetProcPtr(proc, procp);
4859 procp->header.is_lambda = is_lambda;
4893 return rb_proc_compose_to_right(self, to_callable(g));
4899 VALUE proc, args, procs[2];
4905 args = rb_ary_tmp_new_from_values(0, 2, procs);
4907 GetProcPtr(self, procp);
4908 is_lambda = procp->header.is_lambda;
4911 GetProcPtr(proc, procp);
4912 procp->header.is_lambda = is_lambda;
4933rb_method_compose_to_left(
VALUE self,
VALUE g)
4936 self = method_to_proc(self);
4937 return proc_compose_to_left(self, g);
4956rb_method_compose_to_right(
VALUE self,
VALUE g)
4959 self = method_to_proc(self);
4960 return proc_compose_to_right(self, g);
4988proc_ruby2_keywords(
VALUE procval)
4991 GetProcPtr(procval, proc);
4993 rb_check_frozen(procval);
4995 if (proc->header.is_from_method) {
4996 rb_warn(
"Skipping set of ruby2_keywords flag for proc (proc created from method)");
5000 switch (proc->block.type) {
5001 case block_type_iseq:
5002 if (ISEQ_BODY(proc->block.as.captured.code.iseq)->param.flags.has_rest &&
5003 !ISEQ_BODY(proc->block.as.captured.code.iseq)->param.flags.has_post &&
5004 !ISEQ_BODY(proc->block.as.captured.code.iseq)->param.flags.has_kw &&
5005 !ISEQ_BODY(proc->block.as.captured.code.iseq)->param.flags.has_kwrest) {
5006 if (proc->header.is_refined) {
5010 const rb_iseq_t *copy =
5011 rb_iseq_dup_with_independent_caches(proc->block.as.captured.code.iseq);
5012 ISEQ_BODY(copy)->param.flags.ruby2_keywords = 1;
5018 ISEQ_BODY(proc->block.as.captured.code.iseq)->param.flags.ruby2_keywords = 1;
5022 rb_warn(
"Skipping set of ruby2_keywords flag for proc (proc accepts keywords or post arguments or proc does not accept argument splat)");
5026 rb_warn(
"Skipping set of ruby2_keywords flag for proc (proc not defined in Ruby)");
5466 id_refinements_recipe = rb_make_internal_id();
5468 VALUE mRuby = rb_define_module(
"Ruby");
5471 rb_cSourceRange = rb_define_class_under(mRuby,
"SourceRange",
rb_cObject);
5475 rb_define_method(rb_cSourceRange,
"absolute_path", source_range_absolute_path, 0);
5476 rb_define_method(rb_cSourceRange,
"start_line", source_range_start_line, 0);
5477 rb_define_method(rb_cSourceRange,
"start_column", source_range_start_column, 0);
5479 rb_define_method(rb_cSourceRange,
"end_column", source_range_end_column, 0);
5487 rb_add_method_optimized(
rb_cProc, idCall, OPTIMIZED_METHOD_TYPE_CALL, 0, METHOD_VISI_PUBLIC);
5488 rb_add_method_optimized(
rb_cProc, rb_intern(
"[]"), OPTIMIZED_METHOD_TYPE_CALL, 0, METHOD_VISI_PUBLIC);
5489 rb_add_method_optimized(
rb_cProc, rb_intern(
"==="), OPTIMIZED_METHOD_TYPE_CALL, 0, METHOD_VISI_PUBLIC);
5490 rb_add_method_optimized(
rb_cProc, rb_intern(
"yield"), OPTIMIZED_METHOD_TYPE_CALL, 0, METHOD_VISI_PUBLIC);
5525 rb_vm_register_special_exception(ruby_error_sysstack,
rb_eSysStackError,
"stack level too deep");
5596 "define_method", top_define_method, -1);
5637 rb_gc_register_address(&sym_proc_cache);
#define rb_define_method(klass, mid, func, arity)
Defines klass#mid.
#define rb_define_singleton_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.
VALUE rb_singleton_class(VALUE obj)
Finds or creates the singleton class of the passed object.
VALUE rb_singleton_class_get(VALUE obj)
Returns the singleton class of obj, or nil if obj is not a singleton object.
void rb_define_alias(VALUE klass, const char *name1, const char *name2)
Defines an alias of a method.
void rb_undef_method(VALUE klass, const char *name)
Defines an undef of a method.
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_block_given_p(void)
Determines if the current method is given a block.
int rb_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, VALUE *values)
Keyword argument deconstructor.
#define rb_str_buf_cat2
Old name of rb_usascii_str_new_cstr.
#define Qundef
Old name of RUBY_Qundef.
#define INT2FIX
Old name of RB_INT2FIX.
#define ID2SYM
Old name of RB_ID2SYM.
#define OBJ_FREEZE
Old name of RB_OBJ_FREEZE.
#define UNREACHABLE_RETURN
Old name of RBIMPL_UNREACHABLE_RETURN.
#define SYM2ID
Old name of RB_SYM2ID.
#define ZALLOC
Old name of RB_ZALLOC.
#define CLASS_OF
Old name of rb_class_of.
#define rb_ary_new4
Old name of rb_ary_new_from_values.
#define FIX2INT
Old name of RB_FIX2INT.
#define T_MODULE
Old name of RUBY_T_MODULE.
#define ASSUME
Old name of RBIMPL_ASSUME.
#define T_ICLASS
Old name of RUBY_T_ICLASS.
#define ALLOC_N
Old name of RB_ALLOC_N.
#define FL_TEST_RAW
Old name of RB_FL_TEST_RAW.
#define rb_ary_new3
Old name of rb_ary_new_from_args.
#define Qtrue
Old name of RUBY_Qtrue.
#define ST2FIX
Old name of RB_ST2FIX.
#define NUM2INT
Old name of RB_NUM2INT.
#define INT2NUM
Old name of RB_INT2NUM.
#define Qnil
Old name of RUBY_Qnil.
#define Qfalse
Old name of RUBY_Qfalse.
#define NIL_P
Old name of RB_NIL_P.
#define T_CLASS
Old name of RUBY_T_CLASS.
#define BUILTIN_TYPE
Old name of RB_BUILTIN_TYPE.
#define Check_TypedStruct(v, t)
Old name of rb_check_typeddata.
#define CONST_ID
Old name of RUBY_CONST_ID.
#define rb_ary_new2
Old name of rb_ary_new_capa.
VALUE rb_eLocalJumpError
LocalJumpError exception.
void rb_category_warn(rb_warning_category_t category, const char *fmt,...)
Identical to rb_category_warning(), except it reports unless $VERBOSE is nil.
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
VALUE rb_eStandardError
StandardError exception.
VALUE rb_eRangeError
RangeError exception.
VALUE rb_eTypeError
TypeError exception.
void rb_warn(const char *fmt,...)
Identical to rb_warning(), except it reports unless $VERBOSE is nil.
VALUE rb_exc_new_str(VALUE etype, VALUE str)
Identical to rb_exc_new_cstr(), except it takes a Ruby's string instead of C's.
VALUE rb_eException
Mother of all exceptions.
VALUE rb_eSysStackError
SystemStackError exception.
@ RB_WARN_CATEGORY_PERFORMANCE
Warning is for performance issues (not enabled by -w).
VALUE rb_class_superclass(VALUE klass)
Queries the parent of the given class.
VALUE rb_cUnboundMethod
UnboundMethod class.
VALUE rb_mKernel
Kernel module.
VALUE rb_cObject
Object class.
VALUE rb_obj_hide(VALUE obj)
Make the object invisible from Ruby code.
VALUE rb_cBinding
Binding class.
VALUE rb_obj_class(VALUE obj)
Queries the class of an object.
VALUE rb_inspect(VALUE obj)
Generates a human-readable textual representation of the given object.
VALUE rb_cModule
Module class.
VALUE rb_class_inherited_p(VALUE scion, VALUE ascendant)
Determines if the given two modules are relatives.
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_cProc
Proc class.
VALUE rb_cMethod
Method class.
#define RB_OBJ_WRITTEN(old, oldv, young)
Identical to RB_OBJ_WRITE(), except it doesn't write any values, but only a WB declaration.
#define RB_OBJ_WRITE(old, slot, young)
Declaration of a "back" pointer.
#define RUBY_ASSERT(...)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
VALUE rb_funcall(VALUE recv, ID mid, int n,...)
Calls a method.
VALUE rb_funcallv(VALUE recv, ID mid, int argc, const VALUE *argv)
Identical to rb_funcall(), except it takes the method arguments as a C array.
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_ary_dup(VALUE ary)
Duplicates an array.
void rb_ary_store(VALUE ary, rb_len_t key, VALUE val)
Destructively stores the passed value to the passed array's passed index.
VALUE rb_ary_plus(VALUE lhs, VALUE rhs)
Creates a new array, concatenating the former to the latter.
VALUE rb_ary_new(void)
Allocates a new, empty array.
VALUE rb_ary_hidden_new(rb_len_t capa)
Allocates a hidden (no class) empty array.
VALUE rb_ary_push(VALUE ary, VALUE elem)
Special case of rb_ary_cat() that it adds only one element.
VALUE rb_ary_freeze(VALUE obj)
Freeze an array, preventing further modifications.
#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_method_call_with_block(int argc, const VALUE *argv, VALUE recv, VALUE proc)
Identical to rb_proc_call(), except you can additionally pass a proc as a block.
int rb_obj_method_arity(VALUE obj, ID mid)
Identical to rb_mod_method_arity(), except it searches for singleton methods rather than instance met...
VALUE rb_proc_call(VALUE recv, VALUE args)
Evaluates the passed proc with the passed arguments.
VALUE rb_proc_call_with_block_kw(VALUE recv, int argc, const VALUE *argv, VALUE proc, int kw_splat)
Identical to rb_proc_call_with_block(), except you can specify how to handle the last element of the ...
VALUE rb_method_call_kw(int argc, const VALUE *argv, VALUE recv, int kw_splat)
Identical to rb_method_call(), except you can specify how to handle the last element of the given arr...
VALUE rb_obj_method(VALUE recv, VALUE mid)
Creates a method object.
VALUE rb_proc_lambda_p(VALUE recv)
Queries if the given object is a lambda.
VALUE rb_block_proc(void)
Constructs a Proc object from implicitly passed components.
VALUE rb_proc_call_with_block(VALUE recv, int argc, const VALUE *argv, VALUE proc)
Identical to rb_proc_call(), except you can additionally pass another proc object,...
int rb_mod_method_arity(VALUE mod, ID mid)
Queries the number of mandatory arguments of the method defined in the given module.
VALUE rb_method_call_with_block_kw(int argc, const VALUE *argv, VALUE recv, VALUE proc, int kw_splat)
Identical to rb_method_call_with_block(), except you can specify how to handle the last element of th...
VALUE rb_obj_is_method(VALUE recv)
Queries if the given object is a method.
VALUE rb_block_lambda(void)
Identical to rb_proc_new(), except it returns a lambda.
VALUE rb_proc_call_kw(VALUE recv, VALUE args, int kw_splat)
Identical to rb_proc_call(), except you can specify how to handle the last element of the given array...
VALUE rb_binding_new(void)
Snapshots the current execution context and turn it into an instance of rb_cBinding.
int rb_proc_arity(VALUE recv)
Queries the number of mandatory arguments of the given Proc.
VALUE rb_method_call(int argc, const VALUE *argv, VALUE recv)
Evaluates the passed method with the passed arguments.
VALUE rb_obj_is_proc(VALUE recv)
Queries if the given object is a proc.
#define rb_hash_uint(h, i)
Just another name of st_hash_uint.
#define rb_hash_end(h)
Just another name of st_hash_end.
VALUE rb_str_append(VALUE dst, VALUE src)
Identical to rb_str_buf_append(), except it converts the right hand side before concatenating.
void rb_str_set_len(VALUE str, rb_len_t len)
Overwrites the length of the string.
VALUE rb_str_buf_append(VALUE dst, VALUE src)
Identical to rb_str_cat_cstr(), except it takes Ruby's string instead of C's.
st_index_t rb_hash_start(st_index_t i)
Starts a series of hashing.
#define rb_str_cat_cstr(buf, str)
Identical to rb_str_cat(), except it assumes the passed pointer is a pointer to a C string.
#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_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.
void rb_undef_alloc_func(VALUE klass)
Deletes the allocator function of a class.
int rb_method_basic_definition_p(VALUE klass, ID mid)
Well... Let us hesitate from describing what a "basic definition" is.
int rb_obj_respond_to(VALUE obj, ID mid, int private_p)
Identical to rb_respond_to(), except it additionally takes the visibility parameter.
ID rb_check_id(volatile VALUE *namep)
Detects if the given name is already interned or not.
VALUE rb_sym2str(VALUE symbol)
Obtain a frozen string representation of a symbol (not including the leading colon).
ID rb_to_id(VALUE str)
Identical to rb_intern_str(), except it tries to convert the parameter object to an instance of rb_cS...
VALUE rb_iv_get(VALUE obj, const char *name)
Obtains an instance variable.
int len
Length of the buffer.
#define RB_OBJ_SET_SHAREABLE(obj)
Wrapper of rb_obj_set_shareable().
#define RB_INT2NUM
Just another name of rb_int2num_inline.
#define RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg)
Shim for block function parameters.
rb_block_call_func * rb_block_call_func_t
Shorthand type that represents an iterator-written-in-C function pointer.
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.
#define MEMCPY(p1, p2, type, n)
Handy macro to call memcpy.
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
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_proc_new(type *q, VALUE w)
Creates a rb_cProc instance.
VALUE type(ANYARGS)
ANYARGS-ed function type.
VALUE rb_rescue(type *q, VALUE w, type *e, VALUE r)
An equivalent of rescue clause.
#define RARRAY_LEN
Just another name of rb_array_len.
static VALUE * RARRAY_PTR(VALUE ary)
Wild use of a C pointer.
#define RARRAY_AREF(a, i)
References an object in an array.
static void RARRAY_ASET(VALUE ary, rb_len_t i, VALUE v)
Assigns an object in an array.
#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 RUBY_TYPED_DEFAULT_FREE
This is a value you can set to rb_data_type_struct::dfree.
#define RUBY_TYPED_FREE_IMMEDIATELY
Macros to see if each corresponding flag is defined.
#define TypedData_Get_Struct(obj, type, data_type, sval)
Obtains a C struct from inside of a wrapper Ruby object.
struct rb_data_type_struct rb_data_type_t
This is the struct that holds necessary info for a struct.
#define TypedData_Make_Struct(klass, type, data_type, sval)
Identical to TypedData_Wrap_Struct, except it allocates a new data region internally instead of takin...
const char * rb_obj_classname(VALUE obj)
Queries the name of the class of the passed object.
#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.
rb_cref_t * cref
class reference, should be marked
const rb_iseq_t * iseqptr
iseq pointer, should be separated from iseqval
IFUNC (Internal FUNCtion).
long rb_len_t
A signed integer type for lengths and indices of objects such as String and Array.
unsigned long rb_ulen_t
An unsigned integer type that has the same width with rb_len_t.
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
#define SIZEOF_VALUE
Identical to sizeof(VALUE), except it is a macro that can also be used inside of preprocessor directi...
uintptr_t VALUE
Type that represents a Ruby object.
static void Check_Type(VALUE v, enum ruby_value_type t)
Identical to RB_TYPE_P(), except it raises exceptions on predication failure.
static bool RB_TYPE_P(VALUE obj, enum ruby_value_type t)
Queries if the given object is of given type.