summaryrefslogtreecommitdiff
path: root/proc.c
diff options
context:
space:
mode:
authorTakashi Kokubun <takashikkbn@gmail.com>2022-07-21 09:23:58 -0700
committerTakashi Kokubun <takashikkbn@gmail.com>2022-07-21 09:42:04 -0700
commit5b21e94bebed90180d8ff63dad03b8b948361089 (patch)
treef9f7196d84b51b7a3a8001658e4391a63b71c396 /proc.c
parent3ff53c8e04ecc91e0190de6d5950ecce2a2ea188 (diff)
Expand tabs [ci skip]
[Misc #18891]
Notes
Notes: Merged: https://github.com/ruby/ruby/pull/6094
Diffstat (limited to 'proc.c')
-rw-r--r--proc.c728
1 files changed, 364 insertions, 364 deletions
diff --git a/proc.c b/proc.c
index 9bb02a0114..1fa21a59ec 100644
--- a/proc.c
+++ b/proc.c
@@ -82,21 +82,21 @@ block_mark(const struct rb_block *block)
switch (vm_block_type(block)) {
case block_type_iseq:
case block_type_ifunc:
- {
- const struct rb_captured_block *captured = &block->as.captured;
- RUBY_MARK_MOVABLE_UNLESS_NULL(captured->self);
- RUBY_MARK_MOVABLE_UNLESS_NULL((VALUE)captured->code.val);
- if (captured->ep && captured->ep[VM_ENV_DATA_INDEX_ENV] != Qundef /* cfunc_proc_t */) {
+ {
+ const struct rb_captured_block *captured = &block->as.captured;
+ RUBY_MARK_MOVABLE_UNLESS_NULL(captured->self);
+ RUBY_MARK_MOVABLE_UNLESS_NULL((VALUE)captured->code.val);
+ if (captured->ep && captured->ep[VM_ENV_DATA_INDEX_ENV] != Qundef /* cfunc_proc_t */) {
rb_gc_mark(VM_ENV_ENVVAL(captured->ep));
- }
- }
- break;
+ }
+ }
+ break;
case block_type_symbol:
- RUBY_MARK_MOVABLE_UNLESS_NULL(block->as.symbol);
- break;
+ RUBY_MARK_MOVABLE_UNLESS_NULL(block->as.symbol);
+ break;
case block_type_proc:
- RUBY_MARK_MOVABLE_UNLESS_NULL(block->as.proc);
- break;
+ RUBY_MARK_MOVABLE_UNLESS_NULL(block->as.proc);
+ break;
}
}
@@ -106,18 +106,18 @@ block_compact(struct rb_block *block)
switch (block->type) {
case block_type_iseq:
case block_type_ifunc:
- {
- struct rb_captured_block *captured = &block->as.captured;
+ {
+ struct rb_captured_block *captured = &block->as.captured;
captured->self = rb_gc_location(captured->self);
captured->code.val = rb_gc_location(captured->code.val);
- }
- break;
+ }
+ break;
case block_type_symbol:
block->as.symbol = rb_gc_location(block->as.symbol);
- break;
+ break;
case block_type_proc:
block->as.proc = rb_gc_location(block->as.proc);
- break;
+ break;
}
}
@@ -146,17 +146,17 @@ proc_memsize(const void *ptr)
{
const rb_proc_t *proc = ptr;
if (proc->block.as.captured.ep == ((const cfunc_proc_t *)ptr)->env+1)
- return sizeof(cfunc_proc_t);
+ return sizeof(cfunc_proc_t);
return sizeof(rb_proc_t);
}
static const rb_data_type_t proc_data_type = {
"proc",
{
- proc_mark,
- RUBY_TYPED_DEFAULT_FREE,
- proc_memsize,
- proc_compact,
+ proc_mark,
+ RUBY_TYPED_DEFAULT_FREE,
+ proc_memsize,
+ proc_compact,
},
0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
};
@@ -334,10 +334,10 @@ binding_memsize(const void *ptr)
const rb_data_type_t ruby_binding_data_type = {
"binding",
{
- binding_mark,
- binding_free,
- binding_memsize,
- binding_compact,
+ binding_mark,
+ binding_free,
+ binding_memsize,
+ binding_compact,
},
0, 0, RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FREE_IMMEDIATELY
};
@@ -438,37 +438,37 @@ get_local_variable_ptr(const rb_env_t **envp, ID lid)
{
const rb_env_t *env = *envp;
do {
- if (!VM_ENV_FLAGS(env->ep, VM_FRAME_FLAG_CFRAME)) {
+ if (!VM_ENV_FLAGS(env->ep, VM_FRAME_FLAG_CFRAME)) {
if (VM_ENV_FLAGS(env->ep, VM_ENV_FLAG_ISOLATED)) {
return NULL;
}
const rb_iseq_t *iseq = env->iseq;
- unsigned int i;
+ unsigned int i;
- VM_ASSERT(rb_obj_is_iseq((VALUE)iseq));
+ VM_ASSERT(rb_obj_is_iseq((VALUE)iseq));
for (i=0; i<ISEQ_BODY(iseq)->local_table_size; i++) {
if (ISEQ_BODY(iseq)->local_table[i] == lid) {
if (ISEQ_BODY(iseq)->local_iseq == iseq &&
ISEQ_BODY(iseq)->param.flags.has_block &&
(unsigned int)ISEQ_BODY(iseq)->param.block_start == i) {
- const VALUE *ep = env->ep;
- if (!VM_ENV_FLAGS(ep, VM_FRAME_FLAG_MODIFIED_BLOCK_PARAM)) {
- RB_OBJ_WRITE(env, &env->env[i], rb_vm_bh_to_procval(GET_EC(), VM_ENV_BLOCK_HANDLER(ep)));
- VM_ENV_FLAGS_SET(ep, VM_FRAME_FLAG_MODIFIED_BLOCK_PARAM);
- }
- }
-
- *envp = env;
- return &env->env[i];
- }
- }
- }
- else {
- *envp = NULL;
- return NULL;
- }
+ const VALUE *ep = env->ep;
+ if (!VM_ENV_FLAGS(ep, VM_FRAME_FLAG_MODIFIED_BLOCK_PARAM)) {
+ RB_OBJ_WRITE(env, &env->env[i], rb_vm_bh_to_procval(GET_EC(), VM_ENV_BLOCK_HANDLER(ep)));
+ VM_ENV_FLAGS_SET(ep, VM_FRAME_FLAG_MODIFIED_BLOCK_PARAM);
+ }
+ }
+
+ *envp = env;
+ return &env->env[i];
+ }
+ }
+ }
+ else {
+ *envp = NULL;
+ return NULL;
+ }
} while ((env = rb_vm_env_prev_env(env)) != NULL);
*envp = NULL;
@@ -487,17 +487,17 @@ check_local_id(VALUE bindval, volatile VALUE *pname)
VALUE name = *pname;
if (lid) {
- if (!rb_is_local_id(lid)) {
- rb_name_err_raise("wrong local variable name `%1$s' for %2$s",
- bindval, ID2SYM(lid));
- }
+ if (!rb_is_local_id(lid)) {
+ rb_name_err_raise("wrong local variable name `%1$s' for %2$s",
+ bindval, ID2SYM(lid));
+ }
}
else {
- if (!rb_is_local_name(name)) {
- rb_name_err_raise("wrong local variable name `%1$s' for %2$s",
- bindval, name);
- }
- return 0;
+ if (!rb_is_local_name(name)) {
+ rb_name_err_raise("wrong local variable name `%1$s' for %2$s",
+ bindval, name);
+ }
+ return 0;
}
return lid;
}
@@ -610,9 +610,9 @@ bind_local_variable_set(VALUE bindval, VALUE sym, VALUE val)
GetBindingPtr(bindval, bind);
env = VM_ENV_ENVVAL_PTR(vm_block_ep(&bind->block));
if ((ptr = get_local_variable_ptr(&env, lid)) == NULL) {
- /* not found. create new env */
- ptr = rb_binding_add_dynavars(bindval, bind, 1, &lid);
- env = VM_ENV_ENVVAL_PTR(vm_block_ep(&bind->block));
+ /* not found. create new env */
+ ptr = rb_binding_add_dynavars(bindval, bind, 1, &lid);
+ env = VM_ENV_ENVVAL_PTR(vm_block_ep(&bind->block));
}
#if YJIT_STATS
@@ -727,25 +727,25 @@ struct vm_ifunc *
rb_vm_ifunc_new(rb_block_call_func_t func, const void *data, int min_argc, int max_argc)
{
union {
- struct vm_ifunc_argc argc;
- VALUE packed;
+ struct vm_ifunc_argc argc;
+ VALUE packed;
} arity;
if (min_argc < UNLIMITED_ARGUMENTS ||
#if SIZEOF_INT * 2 > SIZEOF_VALUE
- min_argc >= (int)(1U << (SIZEOF_VALUE * CHAR_BIT) / 2) ||
+ min_argc >= (int)(1U << (SIZEOF_VALUE * CHAR_BIT) / 2) ||
#endif
- 0) {
- rb_raise(rb_eRangeError, "minimum argument number out of range: %d",
- min_argc);
+ 0) {
+ rb_raise(rb_eRangeError, "minimum argument number out of range: %d",
+ min_argc);
}
if (max_argc < UNLIMITED_ARGUMENTS ||
#if SIZEOF_INT * 2 > SIZEOF_VALUE
- max_argc >= (int)(1U << (SIZEOF_VALUE * CHAR_BIT) / 2) ||
+ max_argc >= (int)(1U << (SIZEOF_VALUE * CHAR_BIT) / 2) ||
#endif
- 0) {
- rb_raise(rb_eRangeError, "maximum argument number out of range: %d",
- max_argc);
+ 0) {
+ rb_raise(rb_eRangeError, "maximum argument number out of range: %d",
+ max_argc);
}
arity.argc.min = min_argc;
arity.argc.max = max_argc;
@@ -784,26 +784,26 @@ proc_new(VALUE klass, int8_t is_lambda, int8_t kernel)
/* block is in cf */
switch (vm_block_handler_type(block_handler)) {
case block_handler_type_proc:
- procval = VM_BH_TO_PROC(block_handler);
+ procval = VM_BH_TO_PROC(block_handler);
- if (RBASIC_CLASS(procval) == klass) {
- return procval;
- }
- else {
- VALUE newprocval = rb_proc_dup(procval);
+ if (RBASIC_CLASS(procval) == klass) {
+ return procval;
+ }
+ else {
+ VALUE newprocval = rb_proc_dup(procval);
RBASIC_SET_CLASS(newprocval, klass);
- return newprocval;
- }
- break;
+ return newprocval;
+ }
+ break;
case block_handler_type_symbol:
- return (klass != rb_cProc) ?
- sym_proc_new(klass, VM_BH_TO_SYMBOL(block_handler)) :
- rb_sym_to_proc(VM_BH_TO_SYMBOL(block_handler));
- break;
+ return (klass != rb_cProc) ?
+ sym_proc_new(klass, VM_BH_TO_SYMBOL(block_handler)) :
+ rb_sym_to_proc(VM_BH_TO_SYMBOL(block_handler));
+ break;
case block_handler_type_ifunc:
- return rb_vm_make_proc_lambda(ec, VM_BH_TO_CAPT_BLOCK(block_handler), klass, is_lambda);
+ return rb_vm_make_proc_lambda(ec, VM_BH_TO_CAPT_BLOCK(block_handler), klass, is_lambda);
case block_handler_type_iseq:
{
const struct rb_captured_block *captured = VM_BH_TO_CAPT_BLOCK(block_handler);
@@ -972,8 +972,8 @@ static inline int
check_argc(long argc)
{
if (argc > INT_MAX || argc < 0) {
- rb_raise(rb_eArgError, "too many arguments (%lu)",
- (unsigned long)argc);
+ rb_raise(rb_eArgError, "too many arguments (%lu)",
+ (unsigned long)argc);
}
return (int)argc;
}
@@ -1091,20 +1091,20 @@ rb_vm_block_min_max_arity(const struct rb_block *block, int *max)
again:
switch (vm_block_type(block)) {
case block_type_iseq:
- return rb_iseq_min_max_arity(rb_iseq_check(block->as.captured.code.iseq), max);
+ return rb_iseq_min_max_arity(rb_iseq_check(block->as.captured.code.iseq), max);
case block_type_proc:
- block = vm_proc_block(block->as.proc);
- goto again;
+ block = vm_proc_block(block->as.proc);
+ goto again;
case block_type_ifunc:
- {
- const struct vm_ifunc *ifunc = block->as.captured.code.ifunc;
- if (IS_METHOD_PROC_IFUNC(ifunc)) {
- /* e.g. method(:foo).to_proc.arity */
- return method_min_max_arity((VALUE)ifunc->data, max);
- }
- *max = ifunc->argc.max;
- return ifunc->argc.min;
- }
+ {
+ const struct vm_ifunc *ifunc = block->as.captured.code.ifunc;
+ if (IS_METHOD_PROC_IFUNC(ifunc)) {
+ /* e.g. method(:foo).to_proc.arity */
+ return method_min_max_arity((VALUE)ifunc->data, max);
+ }
+ *max = ifunc->argc.max;
+ return ifunc->argc.min;
+ }
case block_type_symbol:
*max = UNLIMITED_ARGUMENTS;
return 1;
@@ -1142,20 +1142,20 @@ block_setup(struct rb_block *block, VALUE block_handler)
{
switch (vm_block_handler_type(block_handler)) {
case block_handler_type_iseq:
- block->type = block_type_iseq;
- block->as.captured = *VM_BH_TO_ISEQ_BLOCK(block_handler);
- break;
+ block->type = block_type_iseq;
+ block->as.captured = *VM_BH_TO_ISEQ_BLOCK(block_handler);
+ break;
case block_handler_type_ifunc:
- block->type = block_type_ifunc;
- block->as.captured = *VM_BH_TO_IFUNC_BLOCK(block_handler);
- break;
+ block->type = block_type_ifunc;
+ block->as.captured = *VM_BH_TO_IFUNC_BLOCK(block_handler);
+ break;
case block_handler_type_symbol:
- block->type = block_type_symbol;
- block->as.symbol = VM_BH_TO_SYMBOL(block_handler);
- break;
+ block->type = block_type_symbol;
+ block->as.symbol = VM_BH_TO_SYMBOL(block_handler);
+ break;
case block_handler_type_proc:
- block->type = block_type_proc;
- block->as.proc = VM_BH_TO_PROC(block_handler);
+ block->type = block_type_proc;
+ block->as.proc = VM_BH_TO_PROC(block_handler);
}
}
@@ -1169,7 +1169,7 @@ rb_block_pair_yield_optimizable(void)
struct rb_block block;
if (block_handler == VM_BLOCK_HANDLER_NONE) {
- rb_raise(rb_eArgError, "no block given");
+ rb_raise(rb_eArgError, "no block given");
}
block_setup(&block, block_handler);
@@ -1180,14 +1180,14 @@ rb_block_pair_yield_optimizable(void)
return 0;
case block_handler_type_proc:
- {
- VALUE procval = block_handler;
- rb_proc_t *proc;
- GetProcPtr(procval, proc);
+ {
+ VALUE procval = block_handler;
+ rb_proc_t *proc;
+ GetProcPtr(procval, proc);
if (proc->is_lambda) return 0;
if (min != max) return 0;
return min > 1;
- }
+ }
default:
return min > 1;
@@ -1204,21 +1204,21 @@ rb_block_arity(void)
struct rb_block block;
if (block_handler == VM_BLOCK_HANDLER_NONE) {
- rb_raise(rb_eArgError, "no block given");
+ rb_raise(rb_eArgError, "no block given");
}
block_setup(&block, block_handler);
switch (vm_block_type(&block)) {
case block_handler_type_symbol:
- return -1;
+ return -1;
case block_handler_type_proc:
return rb_proc_arity(block_handler);
default:
min = rb_vm_block_min_max_arity(&block, &max);
- return max != UNLIMITED_ARGUMENTS ? min : -min-1;
+ return max != UNLIMITED_ARGUMENTS ? min : -min-1;
}
}
@@ -1231,7 +1231,7 @@ rb_block_min_max_arity(int *max)
struct rb_block block;
if (block_handler == VM_BLOCK_HANDLER_NONE) {
- rb_raise(rb_eArgError, "no block given");
+ rb_raise(rb_eArgError, "no block given");
}
block_setup(&block, block_handler);
@@ -1250,23 +1250,23 @@ rb_proc_get_iseq(VALUE self, int *is_proc)
switch (vm_block_type(block)) {
case block_type_iseq:
- return rb_iseq_check(block->as.captured.code.iseq);
+ return rb_iseq_check(block->as.captured.code.iseq);
case block_type_proc:
- return rb_proc_get_iseq(block->as.proc, is_proc);
+ return rb_proc_get_iseq(block->as.proc, is_proc);
case block_type_ifunc:
- {
+ {
const struct vm_ifunc *ifunc = block->as.captured.code.ifunc;
- if (IS_METHOD_PROC_IFUNC(ifunc)) {
- /* method(:foo).to_proc */
- if (is_proc) *is_proc = 0;
- return rb_method_iseq((VALUE)ifunc->data);
- }
- else {
- return NULL;
- }
- }
+ if (IS_METHOD_PROC_IFUNC(ifunc)) {
+ /* method(:foo).to_proc */
+ if (is_proc) *is_proc = 0;
+ return rb_method_iseq((VALUE)ifunc->data);
+ }
+ else {
+ return NULL;
+ }
+ }
case block_type_symbol:
- return NULL;
+ return NULL;
}
VM_UNREACHABLE(rb_proc_get_iseq);
@@ -1399,11 +1399,11 @@ rb_unnamed_parameters(int arity)
a = rb_ary_new3(1, ID2SYM(req));
OBJ_FREEZE(a);
for (; n; --n) {
- rb_ary_push(param, a);
+ rb_ary_push(param, a);
}
if (arity < 0) {
- CONST_ID(rest, "rest");
- rb_ary_store(param, ~arity, rb_ary_new3(1, ID2SYM(rest)));
+ CONST_ID(rest, "rest");
+ rb_ary_store(param, ~arity, rb_ary_new3(1, ID2SYM(rest)));
}
return param;
}
@@ -1451,7 +1451,7 @@ rb_proc_parameters(int argc, VALUE *argv, VALUE self)
}
if (!iseq) {
- return rb_unnamed_parameters(rb_proc_arity(self));
+ return rb_unnamed_parameters(rb_proc_arity(self));
}
return rb_iseq_parameters(iseq, is_proc);
}
@@ -1491,9 +1491,9 @@ rb_sym_to_proc(VALUE sym)
ID id;
if (!sym_proc_cache) {
- sym_proc_cache = rb_ary_tmp_new(SYM_PROC_CACHE_SIZE * 2);
- rb_gc_register_mark_object(sym_proc_cache);
- rb_ary_store(sym_proc_cache, SYM_PROC_CACHE_SIZE*2 - 1, Qnil);
+ sym_proc_cache = rb_ary_tmp_new(SYM_PROC_CACHE_SIZE * 2);
+ rb_gc_register_mark_object(sym_proc_cache);
+ rb_ary_store(sym_proc_cache, SYM_PROC_CACHE_SIZE*2 - 1, Qnil);
}
id = SYM2ID(sym);
@@ -1506,7 +1506,7 @@ rb_sym_to_proc(VALUE sym)
proc = sym_proc_new(rb_cProc, ID2SYM(id));
RARRAY_ASET(sym_proc_cache, index, sym);
RARRAY_ASET(sym_proc_cache, index + 1, proc);
- return proc;
+ return proc;
}
}
@@ -1538,22 +1538,22 @@ rb_block_to_s(VALUE self, const struct rb_block *block, const char *additional_i
again:
switch (vm_block_type(block)) {
case block_type_proc:
- block = vm_proc_block(block->as.proc);
- goto again;
+ block = vm_proc_block(block->as.proc);
+ goto again;
case block_type_iseq:
- {
- const rb_iseq_t *iseq = rb_iseq_check(block->as.captured.code.iseq);
+ {
+ const rb_iseq_t *iseq = rb_iseq_check(block->as.captured.code.iseq);
rb_str_catf(str, "%p %"PRIsVALUE":%d", (void *)self,
- rb_iseq_path(iseq),
+ rb_iseq_path(iseq),
FIX2INT(ISEQ_BODY(iseq)->location.first_lineno));
- }
- break;
+ }
+ break;
case block_type_symbol:
- rb_str_catf(str, "%p(&%+"PRIsVALUE")", (void *)self, block->as.symbol);
- break;
+ rb_str_catf(str, "%p(&%+"PRIsVALUE")", (void *)self, block->as.symbol);
+ break;
case block_type_ifunc:
- rb_str_catf(str, "%p", (void *)block->as.captured.code.ifunc);
- break;
+ rb_str_catf(str, "%p", (void *)block->as.captured.code.ifunc);
+ break;
}
if (additional_info) rb_str_cat_cstr(str, additional_info);
@@ -1620,10 +1620,10 @@ bm_memsize(const void *ptr)
static const rb_data_type_t method_data_type = {
"method",
{
- bm_mark,
- RUBY_TYPED_DEFAULT_FREE,
- bm_memsize,
- bm_compact,
+ bm_mark,
+ RUBY_TYPED_DEFAULT_FREE,
+ bm_memsize,
+ bm_compact,
},
0, 0, RUBY_TYPED_FREE_IMMEDIATELY
};
@@ -1680,7 +1680,7 @@ mnew_missing_by_name(VALUE klass, VALUE obj, VALUE *name, int scope, VALUE mclas
static VALUE
mnew_internal(const rb_method_entry_t *me, VALUE klass, VALUE iclass,
- VALUE obj, ID id, VALUE mclass, int scope, int error)
+ VALUE obj, ID id, VALUE mclass, int scope, int error)
{
struct METHOD *data;
VALUE method;
@@ -1688,32 +1688,32 @@ mnew_internal(const rb_method_entry_t *me, VALUE klass, VALUE iclass,
again:
if (UNDEFINED_METHOD_ENTRY_P(me)) {
- if (respond_to_missing_p(klass, obj, ID2SYM(id), scope)) {
- return mnew_missing(klass, obj, id, mclass);
- }
- if (!error) return Qnil;
- rb_print_undef(klass, id, METHOD_VISI_UNDEF);
+ if (respond_to_missing_p(klass, obj, ID2SYM(id), scope)) {
+ return mnew_missing(klass, obj, id, mclass);
+ }
+ if (!error) return Qnil;
+ rb_print_undef(klass, id, METHOD_VISI_UNDEF);
}
if (visi == METHOD_VISI_UNDEF) {
- visi = METHOD_ENTRY_VISI(me);
- RUBY_ASSERT(visi != METHOD_VISI_UNDEF); /* !UNDEFINED_METHOD_ENTRY_P(me) */
- if (scope && (visi != METHOD_VISI_PUBLIC)) {
- if (!error) return Qnil;
- rb_print_inaccessible(klass, id, visi);
- }
+ visi = METHOD_ENTRY_VISI(me);
+ RUBY_ASSERT(visi != METHOD_VISI_UNDEF); /* !UNDEFINED_METHOD_ENTRY_P(me) */
+ if (scope && (visi != METHOD_VISI_PUBLIC)) {
+ if (!error) return Qnil;
+ rb_print_inaccessible(klass, id, visi);
+ }
}
if (me->def->type == VM_METHOD_TYPE_ZSUPER) {
- if (me->defined_class) {
+ if (me->defined_class) {
VALUE klass = RCLASS_SUPER(RCLASS_ORIGIN(me->defined_class));
- id = me->def->original_id;
+ id = me->def->original_id;
me = (rb_method_entry_t *)rb_callable_method_entry_with_refinements(klass, id, &iclass);
- }
- else {
+ }
+ else {
VALUE klass = RCLASS_SUPER(RCLASS_ORIGIN(me->owner));
- id = me->def->original_id;
- me = rb_method_entry_without_refinements(klass, id, &iclass);
- }
- goto again;
+ id = me->def->original_id;
+ me = rb_method_entry_without_refinements(klass, id, &iclass);
+ }
+ goto again;
}
method = TypedData_Make_Struct(mclass, struct METHOD, &method_data_type, data);
@@ -1729,7 +1729,7 @@ mnew_internal(const rb_method_entry_t *me, VALUE klass, VALUE iclass,
static VALUE
mnew_from_me(const rb_method_entry_t *me, VALUE klass, VALUE iclass,
- VALUE obj, ID id, VALUE mclass, int scope)
+ VALUE obj, ID id, VALUE mclass, int scope)
{
return mnew_internal(me, klass, iclass, obj, id, mclass, scope, TRUE);
}
@@ -1807,9 +1807,9 @@ method_eq(VALUE method, VALUE other)
VALUE klass1, klass2;
if (!rb_obj_is_method(other))
- return Qfalse;
+ return Qfalse;
if (CLASS_OF(method) != CLASS_OF(other))
- return Qfalse;
+ return Qfalse;
Check_TypedStruct(method, &method_data_type);
m1 = (struct METHOD *)DATA_PTR(method);
@@ -1819,11 +1819,11 @@ method_eq(VALUE method, VALUE other)
klass2 = method_entry_defined_class(m2->me);
if (!rb_method_entry_eq(m1->me, m2->me) ||
- klass1 != klass2 ||
+ klass1 != klass2 ||
m1->visibility != m2->visibility ||
- m1->klass != m2->klass ||
- m1->recv != m2->recv) {
- return Qfalse;
+ m1->klass != m2->klass ||
+ m1->recv != m2->recv) {
+ return Qfalse;
}
return Qtrue;
@@ -1869,7 +1869,7 @@ method_unbind(VALUE obj)
TypedData_Get_Struct(obj, struct METHOD, &method_data_type, orig);
method = TypedData_Make_Struct(rb_cUnboundMethod, struct METHOD,
- &method_data_type, data);
+ &method_data_type, data);
RB_OBJ_WRITE(method, &data->recv, Qundef);
RB_OBJ_WRITE(method, &data->klass, orig->klass);
RB_OBJ_WRITE(method, &data->iclass, orig->iclass);
@@ -1961,22 +1961,22 @@ rb_method_name_error(VALUE klass, VALUE str)
VALUE s = Qundef;
if (FL_TEST(c, FL_SINGLETON)) {
- VALUE obj = rb_ivar_get(klass, attached);
+ VALUE obj = rb_ivar_get(klass, attached);
- switch (BUILTIN_TYPE(obj)) {
- case T_MODULE:
- case T_CLASS:
- c = obj;
+ switch (BUILTIN_TYPE(obj)) {
+ case T_MODULE:
+ case T_CLASS:
+ c = obj;
break;
default:
- break;
- }
+ break;
+ }
}
else if (RB_TYPE_P(c, T_MODULE)) {
- s = MSG(" module");
+ s = MSG(" module");
}
if (s == Qundef) {
- s = MSG(" class");
+ s = MSG(" class");
}
rb_name_err_raise_str(s, c, str);
#undef MSG
@@ -1992,7 +1992,7 @@ obj_method(VALUE obj, VALUE vid, int scope)
if (!id) {
VALUE m = mnew_missing_by_name(klass, obj, &vid, scope, mclass);
if (m) return m;
- rb_method_name_error(klass, vid);
+ rb_method_name_error(klass, vid);
}
return mnew_callable(klass, obj, id, mclass, scope);
}
@@ -2153,7 +2153,7 @@ rb_mod_instance_method(VALUE mod, VALUE vid)
{
ID id = rb_check_id(&vid);
if (!id) {
- rb_method_name_error(mod, vid);
+ rb_method_name_error(mod, vid);
}
return mnew_unbound(mod, id, rb_cUnboundMethod, FALSE);
}
@@ -2170,7 +2170,7 @@ rb_mod_public_instance_method(VALUE mod, VALUE vid)
{
ID id = rb_check_id(&vid);
if (!id) {
- rb_method_name_error(mod, vid);
+ rb_method_name_error(mod, vid);
}
return mnew_unbound(mod, id, rb_cUnboundMethod, TRUE);
}
@@ -2187,57 +2187,57 @@ rb_mod_define_method_with_visibility(int argc, VALUE *argv, VALUE mod, const str
name = argv[0];
id = rb_check_id(&name);
if (argc == 1) {
- body = rb_block_lambda();
+ body = rb_block_lambda();
}
else {
- body = argv[1];
-
- if (rb_obj_is_method(body)) {
- is_method = TRUE;
- }
- else if (rb_obj_is_proc(body)) {
- is_method = FALSE;
- }
- else {
- rb_raise(rb_eTypeError,
- "wrong argument type %s (expected Proc/Method/UnboundMethod)",
- rb_obj_classname(body));
- }
+ body = argv[1];
+
+ if (rb_obj_is_method(body)) {
+ is_method = TRUE;
+ }
+ else if (rb_obj_is_proc(body)) {
+ is_method = FALSE;
+ }
+ else {
+ rb_raise(rb_eTypeError,
+ "wrong argument type %s (expected Proc/Method/UnboundMethod)",
+ rb_obj_classname(body));
+ }
}
if (!id) id = rb_to_id(name);
if (is_method) {
- struct METHOD *method = (struct METHOD *)DATA_PTR(body);
- if (method->me->owner != mod && !RB_TYPE_P(method->me->owner, T_MODULE) &&
- !RTEST(rb_class_inherited_p(mod, method->me->owner))) {
- if (FL_TEST(method->me->owner, FL_SINGLETON)) {
- rb_raise(rb_eTypeError,
- "can't bind singleton method to a different class");
- }
- else {
- rb_raise(rb_eTypeError,
- "bind argument must be a subclass of % "PRIsVALUE,
- method->me->owner);
- }
- }
- rb_method_entry_set(mod, id, method->me, scope_visi->method_visi);
- if (scope_visi->module_func) {
- rb_method_entry_set(rb_singleton_class(mod), id, method->me, METHOD_VISI_PUBLIC);
- }
- RB_GC_GUARD(body);
+ struct METHOD *method = (struct METHOD *)DATA_PTR(body);
+ if (method->me->owner != mod && !RB_TYPE_P(method->me->owner, T_MODULE) &&
+ !RTEST(rb_class_inherited_p(mod, method->me->owner))) {
+ if (FL_TEST(method->me->owner, FL_SINGLETON)) {
+ rb_raise(rb_eTypeError,
+ "can't bind singleton method to a different class");
+ }
+ else {
+ rb_raise(rb_eTypeError,
+ "bind argument must be a subclass of % "PRIsVALUE,
+ method->me->owner);
+ }
+ }
+ rb_method_entry_set(mod, id, method->me, scope_visi->method_visi);
+ if (scope_visi->module_func) {
+ rb_method_entry_set(rb_singleton_class(mod), id, method->me, METHOD_VISI_PUBLIC);
+ }
+ RB_GC_GUARD(body);
}
else {
- VALUE procval = rb_proc_dup(body);
- if (vm_proc_iseq(procval) != NULL) {
- rb_proc_t *proc;
- GetProcPtr(procval, proc);
- proc->is_lambda = TRUE;
- proc->is_from_method = TRUE;
- }
- rb_add_method(mod, id, VM_METHOD_TYPE_BMETHOD, (void *)procval, scope_visi->method_visi);
- if (scope_visi->module_func) {
- rb_add_method(rb_singleton_class(mod), id, VM_METHOD_TYPE_BMETHOD, (void *)body, METHOD_VISI_PUBLIC);
- }
+ VALUE procval = rb_proc_dup(body);
+ if (vm_proc_iseq(procval) != NULL) {
+ rb_proc_t *proc;
+ GetProcPtr(procval, proc);
+ proc->is_lambda = TRUE;
+ proc->is_from_method = TRUE;
+ }
+ rb_add_method(mod, id, VM_METHOD_TYPE_BMETHOD, (void *)procval, scope_visi->method_visi);
+ if (scope_visi->module_func) {
+ rb_add_method(rb_singleton_class(mod), id, VM_METHOD_TYPE_BMETHOD, (void *)body, METHOD_VISI_PUBLIC);
+ }
}
return ID2SYM(id);
@@ -2352,10 +2352,10 @@ top_define_method(int argc, VALUE *argv, VALUE obj)
klass = th->top_wrapper;
if (klass) {
- rb_warning("main.define_method in the wrapped load is effective only in wrapper module");
+ rb_warning("main.define_method in the wrapped load is effective only in wrapper module");
}
else {
- klass = rb_cObject;
+ klass = rb_cObject;
}
return rb_mod_define_method(argc, argv, klass);
}
@@ -2482,7 +2482,7 @@ rb_method_call_with_block_kw(int argc, const VALUE *argv, VALUE method, VALUE pa
TypedData_Get_Struct(method, struct METHOD, &method_data_type, data);
if (data->recv == Qundef) {
- rb_raise(rb_eTypeError, "can't call unbound method; bind first");
+ rb_raise(rb_eTypeError, "can't call unbound method; bind first");
}
return call_method_data(ec, data, argc, argv, passed_procval, kw_splat);
}
@@ -2560,28 +2560,28 @@ convert_umethod_to_method_components(const struct METHOD *data, VALUE recv, VALU
if (!NIL_P(refined_class)) methclass = refined_class;
}
if (!RB_TYPE_P(methclass, T_MODULE) &&
- methclass != CLASS_OF(recv) && !rb_obj_is_kind_of(recv, methclass)) {
- if (FL_TEST(methclass, FL_SINGLETON)) {
- rb_raise(rb_eTypeError,
- "singleton method called for a different object");
- }
- else {
- rb_raise(rb_eTypeError, "bind argument must be an instance of % "PRIsVALUE,
- methclass);
- }
+ methclass != CLASS_OF(recv) && !rb_obj_is_kind_of(recv, methclass)) {
+ if (FL_TEST(methclass, FL_SINGLETON)) {
+ rb_raise(rb_eTypeError,
+ "singleton method called for a different object");
+ }
+ else {
+ rb_raise(rb_eTypeError, "bind argument must be an instance of % "PRIsVALUE,
+ methclass);
+ }
}
const rb_method_entry_t *me = rb_method_entry_clone(data->me);
if (RB_TYPE_P(me->owner, T_MODULE)) {
- VALUE ic = rb_class_search_ancestor(klass, me->owner);
- if (ic) {
- klass = ic;
+ VALUE ic = rb_class_search_ancestor(klass, me->owner);
+ if (ic) {
+ klass = ic;
iclass = ic;
- }
- else {
- klass = rb_include_class_new(methclass, klass);
- }
+ }
+ else {
+ klass = rb_include_class_new(methclass, klass);
+ }
me = (const rb_method_entry_t *) rb_method_entry_complement_defined_class(me, me->called_id, klass);
}
@@ -2695,56 +2695,56 @@ method_def_min_max_arity(const rb_method_definition_t *def, int *max)
if (!def) return *max = 0;
switch (def->type) {
case VM_METHOD_TYPE_CFUNC:
- if (def->body.cfunc.argc < 0) {
- *max = UNLIMITED_ARGUMENTS;
- return 0;
- }
- return *max = check_argc(def->body.cfunc.argc);
+ if (def->body.cfunc.argc < 0) {
+ *max = UNLIMITED_ARGUMENTS;
+ return 0;
+ }
+ return *max = check_argc(def->body.cfunc.argc);
case VM_METHOD_TYPE_ZSUPER:
- *max = UNLIMITED_ARGUMENTS;
- return 0;
+ *max = UNLIMITED_ARGUMENTS;
+ return 0;
case VM_METHOD_TYPE_ATTRSET:
- return *max = 1;
+ return *max = 1;
case VM_METHOD_TYPE_IVAR:
- return *max = 0;
+ return *max = 0;
case VM_METHOD_TYPE_ALIAS:
- def = def->body.alias.original_me->def;
- goto again;
+ def = def->body.alias.original_me->def;
+ goto again;
case VM_METHOD_TYPE_BMETHOD:
return rb_proc_min_max_arity(def->body.bmethod.proc, max);
case VM_METHOD_TYPE_ISEQ:
- return rb_iseq_min_max_arity(rb_iseq_check(def->body.iseq.iseqptr), max);
+ return rb_iseq_min_max_arity(rb_iseq_check(def->body.iseq.iseqptr), max);
case VM_METHOD_TYPE_UNDEF:
case VM_METHOD_TYPE_NOTIMPLEMENTED:
- return *max = 0;
+ return *max = 0;
case VM_METHOD_TYPE_MISSING:
- *max = UNLIMITED_ARGUMENTS;
- return 0;
+ *max = UNLIMITED_ARGUMENTS;
+ return 0;
case VM_METHOD_TYPE_OPTIMIZED: {
- switch (def->body.optimized.type) {
- case OPTIMIZED_METHOD_TYPE_SEND:
- *max = UNLIMITED_ARGUMENTS;
- return 0;
- case OPTIMIZED_METHOD_TYPE_CALL:
- *max = UNLIMITED_ARGUMENTS;
- return 0;
- case OPTIMIZED_METHOD_TYPE_BLOCK_CALL:
- *max = UNLIMITED_ARGUMENTS;
- return 0;
+ switch (def->body.optimized.type) {
+ case OPTIMIZED_METHOD_TYPE_SEND:
+ *max = UNLIMITED_ARGUMENTS;
+ return 0;
+ case OPTIMIZED_METHOD_TYPE_CALL:
+ *max = UNLIMITED_ARGUMENTS;
+ return 0;
+ case OPTIMIZED_METHOD_TYPE_BLOCK_CALL:
+ *max = UNLIMITED_ARGUMENTS;
+ return 0;
case OPTIMIZED_METHOD_TYPE_STRUCT_AREF:
*max = 0;
return 0;
case OPTIMIZED_METHOD_TYPE_STRUCT_ASET:
*max = 1;
return 1;
- default:
- break;
- }
- break;
+ default:
+ break;
+ }
+ break;
}
case VM_METHOD_TYPE_REFINED:
- *max = UNLIMITED_ARGUMENTS;
- return 0;
+ *max = UNLIMITED_ARGUMENTS;
+ return 0;
}
rb_bug("method_def_min_max_arity: invalid method entry type (%d)", def->type);
UNREACHABLE_RETURN(Qnil);
@@ -2828,10 +2828,10 @@ original_method_entry(VALUE mod, ID id)
const rb_method_entry_t *me;
while ((me = rb_method_entry(mod, id)) != 0) {
- const rb_method_definition_t *def = me->def;
- if (def->type != VM_METHOD_TYPE_ZSUPER) break;
- mod = RCLASS_SUPER(me->owner);
- id = def->original_id;
+ const rb_method_definition_t *def = me->def;
+ if (def->type != VM_METHOD_TYPE_ZSUPER) break;
+ mod = RCLASS_SUPER(me->owner);
+ id = def->original_id;
}
return me;
}
@@ -2888,11 +2888,11 @@ method_def_iseq(const rb_method_definition_t *def)
{
switch (def->type) {
case VM_METHOD_TYPE_ISEQ:
- return rb_iseq_check(def->body.iseq.iseqptr);
+ return rb_iseq_check(def->body.iseq.iseqptr);
case VM_METHOD_TYPE_BMETHOD:
return rb_proc_get_iseq(def->body.bmethod.proc, 0);
case VM_METHOD_TYPE_ALIAS:
- return method_def_iseq(def->body.alias.original_me->def);
+ return method_def_iseq(def->body.alias.original_me->def);
case VM_METHOD_TYPE_CFUNC:
case VM_METHOD_TYPE_ATTRSET:
case VM_METHOD_TYPE_IVAR:
@@ -2902,7 +2902,7 @@ method_def_iseq(const rb_method_definition_t *def)
case VM_METHOD_TYPE_OPTIMIZED:
case VM_METHOD_TYPE_MISSING:
case VM_METHOD_TYPE_REFINED:
- break;
+ break;
}
return NULL;
}
@@ -2921,12 +2921,12 @@ method_cref(VALUE method)
again:
switch (def->type) {
case VM_METHOD_TYPE_ISEQ:
- return def->body.iseq.cref;
+ return def->body.iseq.cref;
case VM_METHOD_TYPE_ALIAS:
- def = def->body.alias.original_me->def;
- goto again;
+ def = def->body.alias.original_me->def;
+ goto again;
default:
- return NULL;
+ return NULL;
}
}
@@ -2934,9 +2934,9 @@ static VALUE
method_def_location(const rb_method_definition_t *def)
{
if (def->type == VM_METHOD_TYPE_ATTRSET || def->type == VM_METHOD_TYPE_IVAR) {
- if (!def->body.attr.location)
- return Qnil;
- return rb_ary_dup(def->body.attr.location);
+ if (!def->body.attr.location)
+ return Qnil;
+ return rb_ary_dup(def->body.attr.location);
}
return iseq_location(method_def_iseq(def));
}
@@ -3107,33 +3107,33 @@ method_inspect(VALUE method)
}
if (data->me->def->type == VM_METHOD_TYPE_ALIAS) {
- defined_class = data->me->def->body.alias.original_me->owner;
+ defined_class = data->me->def->body.alias.original_me->owner;
}
else {
- defined_class = method_entry_defined_class(data->me);
+ defined_class = method_entry_defined_class(data->me);
}
if (RB_TYPE_P(defined_class, T_ICLASS)) {
- defined_class = RBASIC_CLASS(defined_class);
+ defined_class = RBASIC_CLASS(defined_class);
}
if (FL_TEST(mklass, FL_SINGLETON)) {
- VALUE v = rb_ivar_get(mklass, attached);
-
- if (data->recv == Qundef) {
- rb_str_buf_append(str, rb_inspect(mklass));
- }
- else if (data->recv == v) {
- rb_str_buf_append(str, rb_inspect(v));
- sharp = ".";
- }
- else {
- rb_str_buf_append(str, rb_inspect(data->recv));
- rb_str_buf_cat2(str, "(");
- rb_str_buf_append(str, rb_inspect(v));
- rb_str_buf_cat2(str, ")");
- sharp = ".";
- }
+ VALUE v = rb_ivar_get(mklass, attached);
+
+ if (data->recv == Qundef) {
+ rb_str_buf_append(str, rb_inspect(mklass));
+ }
+ else if (data->recv == v) {
+ rb_str_buf_append(str, rb_inspect(v));
+ sharp = ".";
+ }
+ else {
+ rb_str_buf_append(str, rb_inspect(data->recv));
+ rb_str_buf_cat2(str, "(");
+ rb_str_buf_append(str, rb_inspect(v));
+ rb_str_buf_cat2(str, ")");
+ sharp = ".";
+ }
}
else {
mklass = data->klass;
@@ -3145,16 +3145,16 @@ method_inspect(VALUE method)
} while (RB_TYPE_P(mklass, T_ICLASS));
}
}
- rb_str_buf_append(str, rb_inspect(mklass));
- if (defined_class != mklass) {
- rb_str_catf(str, "(% "PRIsVALUE")", defined_class);
- }
+ rb_str_buf_append(str, rb_inspect(mklass));
+ if (defined_class != mklass) {
+ rb_str_catf(str, "(% "PRIsVALUE")", defined_class);
+ }
}
rb_str_buf_cat2(str, sharp);
rb_str_append(str, rb_id2str(data->me->called_id));
if (data->me->called_id != data->me->def->original_id) {
- rb_str_catf(str, "(%"PRIsVALUE")",
- rb_id2str(data->me->def->original_id));
+ rb_str_catf(str, "(%"PRIsVALUE")",
+ rb_id2str(data->me->def->original_id));
}
if (data->me->def->type == VM_METHOD_TYPE_NOTIMPLEMENTED) {
rb_str_buf_cat2(str, " (not-implemented)");
@@ -3438,7 +3438,7 @@ env_clone(const rb_env_t *env, const rb_cref_t *cref)
VM_ASSERT(VM_ENV_ESCAPED_P(env->ep));
if (cref == NULL) {
- cref = rb_vm_cref_new_toplevel();
+ cref = rb_vm_cref_new_toplevel();
}
new_body = ALLOC_N(VALUE, env->env_size);
@@ -3481,31 +3481,31 @@ proc_binding(VALUE self)
again:
switch (vm_block_type(block)) {
case block_type_iseq:
- iseq = block->as.captured.code.iseq;
- binding_self = block->as.captured.self;
- env = VM_ENV_ENVVAL_PTR(block->as.captured.ep);
- break;
+ iseq = block->as.captured.code.iseq;
+ binding_self = block->as.captured.self;
+ env = VM_ENV_ENVVAL_PTR(block->as.captured.ep);
+ break;
case block_type_proc:
- GetProcPtr(block->as.proc, proc);
- block = &proc->block;
- goto again;
+ GetProcPtr(block->as.proc, proc);
+ block = &proc->block;
+ goto again;
case block_type_ifunc:
- {
- const struct vm_ifunc *ifunc = block->as.captured.code.ifunc;
- if (IS_METHOD_PROC_IFUNC(ifunc)) {
- VALUE method = (VALUE)ifunc->data;
- VALUE name = rb_fstring_lit("<empty_iseq>");
- rb_iseq_t *empty;
- binding_self = method_receiver(method);
- iseq = rb_method_iseq(method);
- env = VM_ENV_ENVVAL_PTR(block->as.captured.ep);
- env = env_clone(env, method_cref(method));
- /* set empty iseq */
- empty = rb_iseq_new(NULL, name, name, Qnil, 0, ISEQ_TYPE_TOP);
- RB_OBJ_WRITE(env, &env->iseq, empty);
- break;
- }
- }
+ {
+ const struct vm_ifunc *ifunc = block->as.captured.code.ifunc;
+ if (IS_METHOD_PROC_IFUNC(ifunc)) {
+ VALUE method = (VALUE)ifunc->data;
+ VALUE name = rb_fstring_lit("<empty_iseq>");
+ rb_iseq_t *empty;
+ binding_self = method_receiver(method);
+ iseq = rb_method_iseq(method);
+ env = VM_ENV_ENVVAL_PTR(block->as.captured.ep);
+ env = env_clone(env, method_cref(method));
+ /* set empty iseq */
+ empty = rb_iseq_new(NULL, name, name, Qnil, 0, ISEQ_TYPE_TOP);
+ RB_OBJ_WRITE(env, &env->iseq, empty);
+ break;
+ }
+ }
/* FALLTHROUGH */
case block_type_symbol:
rb_raise(rb_eArgError, "Can't create Binding from C level Proc");
@@ -3520,14 +3520,14 @@ proc_binding(VALUE self)
RB_OBJ_WRITTEN(bindval, Qundef, VM_ENV_ENVVAL(env->ep));
if (iseq) {
- rb_iseq_check(iseq);
+ rb_iseq_check(iseq);
RB_OBJ_WRITE(bindval, &bind->pathobj, ISEQ_BODY(iseq)->location.pathobj);
- bind->first_lineno = FIX2INT(rb_iseq_first_lineno(iseq));
+ bind->first_lineno = FIX2INT(rb_iseq_first_lineno(iseq));
}
else {
- RB_OBJ_WRITE(bindval, &bind->pathobj,
- rb_iseq_pathobj_new(rb_fstring_lit("(binding)"), Qnil));
- bind->first_lineno = 1;
+ RB_OBJ_WRITE(bindval, &bind->pathobj,
+ rb_iseq_pathobj_new(rb_fstring_lit("(binding)"), Qnil));
+ bind->first_lineno = 1;
}
return bindval;
@@ -3565,10 +3565,10 @@ curry(RB_BLOCK_CALL_FUNC_ARGLIST(_, args))
if (RARRAY_LEN(passed) < FIX2INT(arity)) {
if (!NIL_P(blockarg)) {
- rb_warn("given block not used");
- }
- arity = make_curry_proc(proc, passed, arity);
- return arity;
+ rb_warn("given block not used");
+ }
+ arity = make_curry_proc(proc, passed, arity);
+ return arity;
}
else {
return rb_proc_call_with_block(proc, check_argc(RARRAY_LEN(passed)), RARRAY_CONST_PTR(passed), blockarg);
@@ -3628,13 +3628,13 @@ proc_curry(int argc, const VALUE *argv, VALUE self)
VALUE arity;
if (rb_check_arity(argc, 0, 1) == 0 || NIL_P(arity = argv[0])) {
- arity = INT2FIX(min_arity);
+ arity = INT2FIX(min_arity);
}
else {
- sarity = FIX2INT(arity);
- if (rb_proc_lambda_p(self)) {
- rb_check_arity(sarity, min_arity, max_arity);
- }
+ sarity = FIX2INT(arity);
+ if (rb_proc_lambda_p(self)) {
+ rb_check_arity(sarity, min_arity, max_arity);
+ }
}
return make_curry_proc(self, rb_ary_new(), arity);
@@ -4378,7 +4378,7 @@ Init_Proc(void)
rb_define_method(rb_mKernel, "define_singleton_method", rb_obj_define_method, -1);
rb_define_private_method(rb_singleton_class(rb_vm_top_self()),
- "define_method", top_define_method, -1);
+ "define_method", top_define_method, -1);
}
/*