From 5b21e94bebed90180d8ff63dad03b8b948361089 Mon Sep 17 00:00:00 2001 From: Takashi Kokubun Date: Thu, 21 Jul 2022 09:23:58 -0700 Subject: Expand tabs [ci skip] [Misc #18891] --- proc.c | 728 ++++++++++++++++++++++++++++++++--------------------------------- 1 file changed, 364 insertions(+), 364 deletions(-) (limited to 'proc.c') 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; ilocal_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(""); - 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(""); + 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); } /* -- cgit v1.2.3