Expand tabs [ci skip]

[Misc #18891]

1 files changed, 316 insertions, 316 deletions

diff --git a/vm_eval.c b/vm_eval.c
index 5313267b44..e490e4e32d 100644
--- a/vm_eval.c
+++ b/vm_eval.c
@@ -138,18 +138,18 @@ vm_call0_cfunc_with_frame(rb_execution_context_t* ec, struct rb_calling_info *ca
     RUBY_DTRACE_CMETHOD_ENTRY_HOOK(ec, me->owner, me->def->original_id);
     EXEC_EVENT_HOOK(ec, RUBY_EVENT_C_CALL, recv, me->def->original_id, mid, me->owner, Qnil);
     {
-	rb_control_frame_t *reg_cfp = ec->cfp;
+        rb_control_frame_t *reg_cfp = ec->cfp;
 
         vm_push_frame(ec, 0, frame_flags, recv,
-		      block_handler, (VALUE)me,
-		      0, reg_cfp->sp, 0, 0);
+                      block_handler, (VALUE)me,
+                      0, reg_cfp->sp, 0, 0);
 
-	if (len >= 0) rb_check_arity(argc, len, len);
+        if (len >= 0) rb_check_arity(argc, len, len);
 
         val = (*cfunc->invoker)(recv, argc, argv, cfunc->func);
 
-	CHECK_CFP_CONSISTENCY("vm_call0_cfunc_with_frame");
-	rb_vm_pop_frame(ec);
+        CHECK_CFP_CONSISTENCY("vm_call0_cfunc_with_frame");
+        rb_vm_pop_frame(ec);
     }
     EXEC_EVENT_HOOK(ec, RUBY_EVENT_C_RETURN, recv, me->def->original_id, mid, me->owner, val);
     RUBY_DTRACE_CMETHOD_RETURN_HOOK(ec, me->owner, me->def->original_id);
@@ -188,48 +188,48 @@ vm_call0_body(rb_execution_context_t *ec, struct rb_calling_info *calling, const
 
     switch (vm_cc_cme(cc)->def->type) {
       case VM_METHOD_TYPE_ISEQ:
-	{
-	    rb_control_frame_t *reg_cfp = ec->cfp;
-	    int i;
+        {
+            rb_control_frame_t *reg_cfp = ec->cfp;
+            int i;
 
-	    CHECK_VM_STACK_OVERFLOW(reg_cfp, calling->argc + 1);
+            CHECK_VM_STACK_OVERFLOW(reg_cfp, calling->argc + 1);
             vm_check_canary(ec, reg_cfp->sp);
 
-	    *reg_cfp->sp++ = calling->recv;
-	    for (i = 0; i < calling->argc; i++) {
-		*reg_cfp->sp++ = argv[i];
-	    }
+            *reg_cfp->sp++ = calling->recv;
+            for (i = 0; i < calling->argc; i++) {
+                *reg_cfp->sp++ = argv[i];
+            }
 
             vm_call_iseq_setup(ec, reg_cfp, calling);
-	    VM_ENV_FLAGS_SET(ec->cfp->ep, VM_FRAME_FLAG_FINISH);
+            VM_ENV_FLAGS_SET(ec->cfp->ep, VM_FRAME_FLAG_FINISH);
             return vm_exec(ec, true); /* CHECK_INTS in this function */
-	}
+        }
       case VM_METHOD_TYPE_NOTIMPLEMENTED:
       case VM_METHOD_TYPE_CFUNC:
         ret = vm_call0_cfunc(ec, calling, argv);
-	goto success;
+        goto success;
       case VM_METHOD_TYPE_ATTRSET:
         vm_call_check_arity(calling, 1, argv);
         VM_CALL_METHOD_ATTR(ret,
                             rb_ivar_set(calling->recv, vm_cc_cme(cc)->def->body.attr.id, argv[0]),
                             (void)0);
-	goto success;
+        goto success;
       case VM_METHOD_TYPE_IVAR:
         vm_call_check_arity(calling, 0, argv);
         VM_CALL_METHOD_ATTR(ret,
                             rb_attr_get(calling->recv, vm_cc_cme(cc)->def->body.attr.id),
                             (void)0);
-	goto success;
+        goto success;
       case VM_METHOD_TYPE_BMETHOD:
         ret = vm_call_bmethod_body(ec, calling, argv);
-	goto success;
+        goto success;
       case VM_METHOD_TYPE_ZSUPER:
         {
             VALUE klass = RCLASS_ORIGIN(vm_cc_cme(cc)->defined_class);
             return vm_call0_super(ec, calling, argv, klass, MISSING_SUPER);
         }
       case VM_METHOD_TYPE_REFINED:
-	{
+        {
             const rb_callable_method_entry_t *cme = vm_cc_cme(cc);
 
             if (cme->def->body.refined.orig_me) {
@@ -239,7 +239,7 @@ vm_call0_body(rb_execution_context_t *ec, struct rb_calling_info *calling, const
 
             VALUE klass = cme->defined_class;
             return vm_call0_super(ec, calling, argv, klass, 0);
-	}
+        }
       case VM_METHOD_TYPE_ALIAS:
         {
             const rb_callable_method_entry_t *cme = vm_cc_cme(cc);
@@ -256,23 +256,23 @@ vm_call0_body(rb_execution_context_t *ec, struct rb_calling_info *calling, const
             }
         }
       case VM_METHOD_TYPE_MISSING:
-	{
+        {
             vm_passed_block_handler_set(ec, calling->block_handler);
-	    return method_missing(ec, calling->recv, vm_ci_mid(ci), calling->argc,
+            return method_missing(ec, calling->recv, vm_ci_mid(ci), calling->argc,
                                   argv, MISSING_NOENTRY, calling->kw_splat);
-	}
+        }
       case VM_METHOD_TYPE_OPTIMIZED:
-	switch (vm_cc_cme(cc)->def->body.optimized.type) {
-	  case OPTIMIZED_METHOD_TYPE_SEND:
+        switch (vm_cc_cme(cc)->def->body.optimized.type) {
+          case OPTIMIZED_METHOD_TYPE_SEND:
             ret = send_internal(calling->argc, argv, calling->recv, calling->kw_splat ? CALL_FCALL_KW : CALL_FCALL);
-	    goto success;
-	  case OPTIMIZED_METHOD_TYPE_CALL:
-	    {
-		rb_proc_t *proc;
-		GetProcPtr(calling->recv, proc);
-		ret = rb_vm_invoke_proc(ec, proc, calling->argc, argv, calling->kw_splat, calling->block_handler);
-		goto success;
-	    }
+            goto success;
+          case OPTIMIZED_METHOD_TYPE_CALL:
+            {
+                rb_proc_t *proc;
+                GetProcPtr(calling->recv, proc);
+                ret = rb_vm_invoke_proc(ec, proc, calling->argc, argv, calling->kw_splat, calling->block_handler);
+                goto success;
+            }
           case OPTIMIZED_METHOD_TYPE_STRUCT_AREF:
             vm_call_check_arity(calling, 0, argv);
             ret = vm_call_opt_struct_aref0(ec, calling);
@@ -281,12 +281,12 @@ vm_call0_body(rb_execution_context_t *ec, struct rb_calling_info *calling, const
             vm_call_check_arity(calling, 1, argv);
             ret = vm_call_opt_struct_aset0(ec, calling, argv[0]);
             goto success;
-	  default:
-	    rb_bug("vm_call0: unsupported optimized method type (%d)", vm_cc_cme(cc)->def->body.optimized.type);
-	}
-	break;
+          default:
+            rb_bug("vm_call0: unsupported optimized method type (%d)", vm_cc_cme(cc)->def->body.optimized.type);
+        }
+        break;
       case VM_METHOD_TYPE_UNDEF:
-	break;
+        break;
     }
     rb_bug("vm_call0: unsupported method type (%d)", vm_cc_cme(cc)->def->type);
     return Qundef;
@@ -312,7 +312,7 @@ vm_call_super(rb_execution_context_t *ec, int argc, const VALUE *argv, int kw_sp
     const rb_callable_method_entry_t *me = rb_vm_frame_method_entry(cfp);
 
     if (VM_FRAME_RUBYFRAME_P(cfp)) {
-	rb_bug("vm_call_super: should not be reached");
+        rb_bug("vm_call_super: should not be reached");
     }
 
     klass = RCLASS_ORIGIN(me->defined_class);
@@ -346,7 +346,7 @@ rb_current_receiver(void)
     const rb_execution_context_t *ec = GET_EC();
     rb_control_frame_t *cfp;
     if (!ec || !(cfp = ec->cfp)) {
-	rb_raise(rb_eRuntimeError, "no self, no life");
+        rb_raise(rb_eRuntimeError, "no self, no life");
     }
     return cfp->self;
 }
@@ -357,9 +357,9 @@ static inline void
 stack_check(rb_execution_context_t *ec)
 {
     if (!rb_ec_raised_p(ec, RAISED_STACKOVERFLOW) &&
-	rb_ec_stack_check(ec)) {
-	rb_ec_raised_set(ec, RAISED_STACKOVERFLOW);
-	rb_ec_stack_overflow(ec, FALSE);
+        rb_ec_stack_check(ec)) {
+        rb_ec_raised_set(ec, RAISED_STACKOVERFLOW);
+        rb_ec_stack_overflow(ec, FALSE);
     }
 }
 
@@ -500,7 +500,7 @@ gccct_method_search(rb_execution_context_t *ec, VALUE recv, ID mid, int argc)
  */
 static inline VALUE
 rb_call0(rb_execution_context_t *ec,
-	 VALUE recv, ID mid, int argc, const VALUE *argv,
+         VALUE recv, ID mid, int argc, const VALUE *argv,
          call_type call_scope, VALUE self)
 {
     enum method_missing_reason call_status;
@@ -568,7 +568,7 @@ check_funcall_exec(VALUE v)
 {
     struct rescue_funcall_args *args = (void *)v;
     return call_method_entry(args->ec, args->defined_class,
-			     args->recv, idMethodMissing,
+                             args->recv, idMethodMissing,
                              args->cme, args->argc, args->argv, args->kw_splat);
 }
 
@@ -578,21 +578,21 @@ check_funcall_failed(VALUE v, VALUE e)
     struct rescue_funcall_args *args = (void *)v;
     int ret = args->respond;
     if (!ret) {
-	switch (method_boundp(args->defined_class, args->mid,
+        switch (method_boundp(args->defined_class, args->mid,
                               BOUND_PRIVATE|BOUND_RESPONDS)) {
-	  case 2:
-	    ret = TRUE;
-	    break;
-	  case 0:
-	    ret = args->respond_to_missing;
-	    break;
-	  default:
-	    ret = FALSE;
-	    break;
-	}
+          case 2:
+            ret = TRUE;
+            break;
+          case 0:
+            ret = args->respond_to_missing;
+            break;
+          default:
+            ret = FALSE;
+            break;
+        }
     }
     if (ret) {
-	rb_exc_raise(e);
+        rb_exc_raise(e);
     }
     return Qundef;
 }
@@ -617,7 +617,7 @@ check_funcall_missing(rb_execution_context_t *ec, VALUE klass, VALUE recv, ID mi
     VALUE ret = Qundef;
 
     ret = basic_obj_respond_to_missing(ec, klass, recv,
-				       ID2SYM(mid), Qtrue);
+                                       ID2SYM(mid), Qtrue);
     if (!RTEST(ret)) return def;
     args.respond = respond > 0;
     args.respond_to_missing = (ret != Qundef);
@@ -625,9 +625,9 @@ check_funcall_missing(rb_execution_context_t *ec, VALUE klass, VALUE recv, ID mi
     cme = callable_method_entry(klass, idMethodMissing, &args.defined_class);
 
     if (cme && !METHOD_ENTRY_BASIC(cme)) {
-	VALUE argbuf, *new_args = ALLOCV_N(VALUE, argbuf, argc+1);
+        VALUE argbuf, *new_args = ALLOCV_N(VALUE, argbuf, argc+1);
 
-	new_args[0] = ID2SYM(mid);
+        new_args[0] = ID2SYM(mid);
         #ifdef __GLIBC__
         if (!argv) {
             static const VALUE buf = Qfalse;
@@ -635,19 +635,19 @@ check_funcall_missing(rb_execution_context_t *ec, VALUE klass, VALUE recv, ID mi
             argv = &buf;
         }
         #endif
-	MEMCPY(new_args+1, argv, VALUE, argc);
-	ec->method_missing_reason = MISSING_NOENTRY;
-	args.ec = ec;
-	args.recv = recv;
-	args.cme = cme;
-	args.mid = mid;
-	args.argc = argc + 1;
-	args.argv = new_args;
+        MEMCPY(new_args+1, argv, VALUE, argc);
+        ec->method_missing_reason = MISSING_NOENTRY;
+        args.ec = ec;
+        args.recv = recv;
+        args.cme = cme;
+        args.mid = mid;
+        args.argc = argc + 1;
+        args.argv = new_args;
         args.kw_splat = kw_splat;
-	ret = rb_rescue2(check_funcall_exec, (VALUE)&args,
-			 check_funcall_failed, (VALUE)&args,
-			 rb_eNoMethodError, (VALUE)0);
-	ALLOCV_END(argbuf);
+        ret = rb_rescue2(check_funcall_exec, (VALUE)&args,
+                         check_funcall_failed, (VALUE)&args,
+                         rb_eNoMethodError, (VALUE)0);
+        ALLOCV_END(argbuf);
     }
     return ret;
 }
@@ -677,14 +677,14 @@ rb_check_funcall_default_kw(VALUE recv, ID mid, int argc, const VALUE *argv, VAL
     int respond = check_funcall_respond_to(ec, klass, recv, mid);
 
     if (!respond)
-	return def;
+        return def;
 
     me = rb_search_method_entry(recv, mid);
     if (!check_funcall_callable(ec, me)) {
         VALUE ret = check_funcall_missing(ec, klass, recv, mid, argc, argv,
                                           respond, def, kw_splat);
-	if (ret == Qundef) ret = def;
-	return ret;
+        if (ret == Qundef) ret = def;
+        return ret;
     }
     stack_check(ec);
     return rb_vm_call_kw(ec, recv, mid, argc, argv, me, kw_splat);
@@ -706,16 +706,16 @@ rb_check_funcall_with_hook_kw(VALUE recv, ID mid, int argc, const VALUE *argv,
     int respond = check_funcall_respond_to(ec, klass, recv, mid);
 
     if (!respond) {
-	(*hook)(FALSE, recv, mid, argc, argv, arg);
-	return Qundef;
+        (*hook)(FALSE, recv, mid, argc, argv, arg);
+        return Qundef;
     }
 
     me = rb_search_method_entry(recv, mid);
     if (!check_funcall_callable(ec, me)) {
         VALUE ret = check_funcall_missing(ec, klass, recv, mid, argc, argv,
                                           respond, Qundef, kw_splat);
-	(*hook)(ret != Qundef, recv, mid, argc, argv, arg);
-	return ret;
+        (*hook)(ret != Qundef, recv, mid, argc, argv, arg);
+        return ret;
     }
     stack_check(ec);
     (*hook)(TRUE, recv, mid, argc, argv, arg);
@@ -776,32 +776,32 @@ uncallable_object(VALUE recv, ID mid)
     VALUE mname = rb_id2str(mid);
 
     if (SPECIAL_CONST_P(recv)) {
-	rb_raise(rb_eNotImpError,
-		 "method `%"PRIsVALUE"' called on unexpected immediate object (%p)",
-		 mname, (void *)recv);
+        rb_raise(rb_eNotImpError,
+                 "method `%"PRIsVALUE"' called on unexpected immediate object (%p)",
+                 mname, (void *)recv);
     }
     else if ((flags = RBASIC(recv)->flags) == 0) {
-	rb_raise(rb_eNotImpError,
-		 "method `%"PRIsVALUE"' called on terminated object (%p)",
-		 mname, (void *)recv);
+        rb_raise(rb_eNotImpError,
+                 "method `%"PRIsVALUE"' called on terminated object (%p)",
+                 mname, (void *)recv);
     }
     else if (!(typestr = rb_type_str(type = BUILTIN_TYPE(recv)))) {
-	rb_raise(rb_eNotImpError,
-		 "method `%"PRIsVALUE"' called on broken T_?""?""?(0x%02x) object"
-		 " (%p flags=0x%"PRIxVALUE")",
-		 mname, type, (void *)recv, flags);
+        rb_raise(rb_eNotImpError,
+                 "method `%"PRIsVALUE"' called on broken T_?""?""?(0x%02x) object"
+                 " (%p flags=0x%"PRIxVALUE")",
+                 mname, type, (void *)recv, flags);
     }
     else if (T_OBJECT <= type && type < T_NIL) {
-	rb_raise(rb_eNotImpError,
-		 "method `%"PRIsVALUE"' called on hidden %s object"
-		 " (%p flags=0x%"PRIxVALUE")",
-		 mname, typestr, (void *)recv, flags);
+        rb_raise(rb_eNotImpError,
+                 "method `%"PRIsVALUE"' called on hidden %s object"
+                 " (%p flags=0x%"PRIxVALUE")",
+                 mname, typestr, (void *)recv, flags);
     }
     else {
-	rb_raise(rb_eNotImpError,
-		 "method `%"PRIsVALUE"' called on unexpected %s object"
-		 " (%p flags=0x%"PRIxVALUE")",
-		 mname, typestr, (void *)recv, flags);
+        rb_raise(rb_eNotImpError,
+                 "method `%"PRIsVALUE"' called on unexpected %s object"
+                 " (%p flags=0x%"PRIxVALUE")",
+                 mname, typestr, (void *)recv, flags);
     }
 }
 
@@ -877,7 +877,7 @@ rb_call(VALUE recv, ID mid, int argc, const VALUE *argv, call_type scope)
 }
 
 NORETURN(static void raise_method_missing(rb_execution_context_t *ec, int argc, const VALUE *argv,
-					  VALUE obj, enum method_missing_reason call_status));
+                                          VALUE obj, enum method_missing_reason call_status));
 
 /*
  *  call-seq:
@@ -928,19 +928,19 @@ rb_method_missing(int argc, const VALUE *argv, VALUE obj)
 
 MJIT_FUNC_EXPORTED VALUE
 rb_make_no_method_exception(VALUE exc, VALUE format, VALUE obj,
-			    int argc, const VALUE *argv, int priv)
+                            int argc, const VALUE *argv, int priv)
 {
     VALUE name = argv[0];
 
     if (!format) {
-	format = rb_fstring_lit("undefined method `%s' for %s%s%s");
+        format = rb_fstring_lit("undefined method `%s' for %s%s%s");
     }
     if (exc == rb_eNoMethodError) {
-	VALUE args = rb_ary_new4(argc - 1, argv + 1);
-	return rb_nomethod_err_new(format, obj, name, args, priv);
+        VALUE args = rb_ary_new4(argc - 1, argv + 1);
+        return rb_nomethod_err_new(format, obj, name, args, priv);
     }
     else {
-	return rb_name_err_new(format, obj, name);
+        return rb_name_err_new(format, obj, name);
     }
 }
 
@@ -948,49 +948,49 @@ rb_make_no_method_exception(VALUE exc, VALUE format, VALUE obj,
 
 static void
 raise_method_missing(rb_execution_context_t *ec, int argc, const VALUE *argv, VALUE obj,
-		     enum method_missing_reason last_call_status)
+                     enum method_missing_reason last_call_status)
 {
     VALUE exc = rb_eNoMethodError;
     VALUE format = 0;
 
     if (UNLIKELY(argc == 0)) {
-	rb_raise(rb_eArgError, "no method name given");
+        rb_raise(rb_eArgError, "no method name given");
     }
     else if (UNLIKELY(!SYMBOL_P(argv[0]))) {
-	const VALUE e = rb_eArgError; /* TODO: TypeError? */
-	rb_raise(e, "method name must be a Symbol but %"PRIsVALUE" is given",
-		 rb_obj_class(argv[0]));
+        const VALUE e = rb_eArgError; /* TODO: TypeError? */
+        rb_raise(e, "method name must be a Symbol but %"PRIsVALUE" is given",
+                 rb_obj_class(argv[0]));
     }
 
     stack_check(ec);
 
     if (last_call_status & MISSING_PRIVATE) {
-	format = rb_fstring_lit("private method `%s' called for %s%s%s");
+        format = rb_fstring_lit("private method `%s' called for %s%s%s");
     }
     else if (last_call_status & MISSING_PROTECTED) {
-	format = rb_fstring_lit("protected method `%s' called for %s%s%s");
+        format = rb_fstring_lit("protected method `%s' called for %s%s%s");
     }
     else if (last_call_status & MISSING_VCALL) {
-	format = rb_fstring_lit("undefined local variable or method `%s' for %s%s%s");
-	exc = rb_eNameError;
+        format = rb_fstring_lit("undefined local variable or method `%s' for %s%s%s");
+        exc = rb_eNameError;
     }
     else if (last_call_status & MISSING_SUPER) {
-	format = rb_fstring_lit("super: no superclass method `%s' for %s%s%s");
+        format = rb_fstring_lit("super: no superclass method `%s' for %s%s%s");
     }
 
     {
-	exc = rb_make_no_method_exception(exc, format, obj, argc, argv,
-					  last_call_status & (MISSING_FCALL|MISSING_VCALL));
-	if (!(last_call_status & MISSING_MISSING)) {
-	    rb_vm_pop_cfunc_frame();
-	}
-	rb_exc_raise(exc);
+        exc = rb_make_no_method_exception(exc, format, obj, argc, argv,
+                                          last_call_status & (MISSING_FCALL|MISSING_VCALL));
+        if (!(last_call_status & MISSING_MISSING)) {
+            rb_vm_pop_cfunc_frame();
+        }
+        rb_exc_raise(exc);
     }
 }
 
 static void
 vm_raise_method_missing(rb_execution_context_t *ec, int argc, const VALUE *argv,
-			VALUE obj, int call_status)
+                        VALUE obj, int call_status)
 {
     vm_passed_block_handler_set(ec, VM_BLOCK_HANDLER_NONE);
     raise_method_missing(ec, argc, argv, obj, call_status | MISSING_MISSING);
@@ -1081,12 +1081,12 @@ rb_apply(VALUE recv, ID mid, VALUE args)
 
     argc = RARRAY_LENINT(args);
     if (argc >= 0x100) {
-	args = rb_ary_subseq(args, 0, argc);
-	RBASIC_CLEAR_CLASS(args);
-	OBJ_FREEZE(args);
-	ret = rb_call(recv, mid, argc, RARRAY_CONST_PTR(args), CALL_FCALL);
-	RB_GC_GUARD(args);
-	return ret;
+        args = rb_ary_subseq(args, 0, argc);
+        RBASIC_CLEAR_CLASS(args);
+        OBJ_FREEZE(args);
+        ret = rb_call(recv, mid, argc, RARRAY_CONST_PTR(args), CALL_FCALL);
+        RB_GC_GUARD(args);
+        return ret;
     }
     argv = ALLOCA_N(VALUE, argc);
     MEMCPY(argv, RARRAY_CONST_PTR_TRANSIENT(args), VALUE, argc);
@@ -1105,19 +1105,19 @@ rb_funcall(VALUE recv, ID mid, int n, ...)
     va_list ar;
 
     if (n > 0) {
-	long i;
+        long i;
 
         va_start(ar, n);
 
-	argv = ALLOCA_N(VALUE, n);
+        argv = ALLOCA_N(VALUE, n);
 
-	for (i = 0; i < n; i++) {
-	    argv[i] = va_arg(ar, VALUE);
-	}
-	va_end(ar);
+        for (i = 0; i < n; i++) {
+            argv[i] = va_arg(ar, VALUE);
+        }
+        va_end(ar);
     }
     else {
-	argv = 0;
+        argv = 0;
     }
     return rb_funcallv(recv, mid, n, argv);
 }
@@ -1142,8 +1142,8 @@ rb_check_funcall_basic_kw(VALUE recv, ID mid, VALUE ancestor, int argc, const VA
 
     cme = rb_callable_method_entry(klass, mid);
     if (cme && METHOD_ENTRY_BASIC(cme) && RBASIC_CLASS(cme->defined_class) == ancestor) {
-	ec = GET_EC();
-	return rb_vm_call0(ec, recv, mid, argc, argv, cme, kw_splat);
+        ec = GET_EC();
+        return rb_vm_call0(ec, recv, mid, argc, argv, cme, kw_splat);
     }
 
     return Qundef;
@@ -1179,7 +1179,7 @@ VALUE
 rb_funcall_with_block(VALUE recv, ID mid, int argc, const VALUE *argv, VALUE passed_procval)
 {
     if (!NIL_P(passed_procval)) {
-	vm_passed_block_handler_set(GET_EC(), passed_procval);
+        vm_passed_block_handler_set(GET_EC(), passed_procval);
     }
 
     return rb_funcallv_public(recv, mid, argc, argv);
@@ -1215,47 +1215,47 @@ send_internal(int argc, const VALUE *argv, VALUE recv, call_type scope)
     int public = scope == CALL_PUBLIC || scope == CALL_PUBLIC_KW;
 
     if (public) {
-	self = Qundef;
+        self = Qundef;
     }
     else {
-	self = RUBY_VM_PREVIOUS_CONTROL_FRAME(ec->cfp)->self;
+        self = RUBY_VM_PREVIOUS_CONTROL_FRAME(ec->cfp)->self;
     }
 
     if (argc == 0) {
-	rb_raise(rb_eArgError, "no method name given");
+        rb_raise(rb_eArgError, "no method name given");
     }
 
     vid = *argv;
 
     id = rb_check_id(&vid);
     if (!id) {
-	if (rb_method_basic_definition_p(CLASS_OF(recv), idMethodMissing)) {
-	    VALUE exc = rb_make_no_method_exception(rb_eNoMethodError, 0,
-						    recv, argc, argv,
+        if (rb_method_basic_definition_p(CLASS_OF(recv), idMethodMissing)) {
+            VALUE exc = rb_make_no_method_exception(rb_eNoMethodError, 0,
+                                                    recv, argc, argv,
                                                     !public);
-	    rb_exc_raise(exc);
-	}
-	if (!SYMBOL_P(*argv)) {
-	    VALUE *tmp_argv = current_vm_stack_arg(ec, argv);
-	    vid = rb_str_intern(vid);
-	    if (tmp_argv) {
-		tmp_argv[0] = vid;
-	    }
-	    else if (argc > 1) {
-		tmp_argv = ALLOCV_N(VALUE, vargv, argc);
-		tmp_argv[0] = vid;
-		MEMCPY(tmp_argv+1, argv+1, VALUE, argc-1);
-		argv = tmp_argv;
-	    }
-	    else {
-		argv = &vid;
-	    }
-	}
-	id = idMethodMissing;
-	ec->method_missing_reason = MISSING_NOENTRY;
+            rb_exc_raise(exc);
+        }
+        if (!SYMBOL_P(*argv)) {
+            VALUE *tmp_argv = current_vm_stack_arg(ec, argv);
+            vid = rb_str_intern(vid);
+            if (tmp_argv) {
+                tmp_argv[0] = vid;
+            }
+            else if (argc > 1) {
+                tmp_argv = ALLOCV_N(VALUE, vargv, argc);
+                tmp_argv[0] = vid;
+                MEMCPY(tmp_argv+1, argv+1, VALUE, argc-1);
+                argv = tmp_argv;
+            }
+            else {
+                argv = &vid;
+            }
+        }
+        id = idMethodMissing;
+        ec->method_missing_reason = MISSING_NOENTRY;
     }
     else {
-	argv++; argc--;
+        argv++; argc--;
     }
     PASS_PASSED_BLOCK_HANDLER_EC(ec);
     ret = rb_call0(ec, recv, id, argc, argv, scope, self);
@@ -1357,10 +1357,10 @@ VALUE
 rb_yield(VALUE val)
 {
     if (val == Qundef) {
-	return rb_yield_0(0, NULL);
+        return rb_yield_0(0, NULL);
     }
     else {
-	return rb_yield_0(1, &val);
+        return rb_yield_0(1, &val);
     }
 }
 
@@ -1369,21 +1369,21 @@ VALUE
 rb_yield_values(int n, ...)
 {
     if (n == 0) {
-	return rb_yield_0(0, 0);
+        return rb_yield_0(0, 0);
     }
     else {
-	int i;
-	VALUE *argv;
-	va_list args;
-	argv = ALLOCA_N(VALUE, n);
+        int i;
+        VALUE *argv;
+        va_list args;
+        argv = ALLOCA_N(VALUE, n);
 
         va_start(args, n);
-	for (i=0; i<n; i++) {
-	    argv[i] = va_arg(args, VALUE);
-	}
-	va_end(args);
+        for (i=0; i<n; i++) {
+            argv[i] = va_arg(args, VALUE);
+        }
+        va_end(args);
 
-	return rb_yield_0(n, argv);
+        return rb_yield_0(n, argv);
     }
 }
 
@@ -1443,7 +1443,7 @@ static VALUE
 loop_i(VALUE _)
 {
     for (;;) {
-	rb_yield_0(0, 0);
+        rb_yield_0(0, 0);
     }
     return Qnil;
 }
@@ -1504,8 +1504,8 @@ vm_frametype_name(const rb_control_frame_t *cfp);
 
 static VALUE
 rb_iterate0(VALUE (* it_proc) (VALUE), VALUE data1,
-	    const struct vm_ifunc *const ifunc,
-	    rb_execution_context_t *ec)
+            const struct vm_ifunc *const ifunc,
+            rb_execution_context_t *ec)
 {
     enum ruby_tag_type state;
     volatile VALUE retval = Qnil;
@@ -1515,43 +1515,43 @@ rb_iterate0(VALUE (* it_proc) (VALUE), VALUE data1,
     state = EC_EXEC_TAG();
     if (state == 0) {
       iter_retry:
-	{
-	    VALUE block_handler;
-
-	    if (ifunc) {
-		struct rb_captured_block *captured = VM_CFP_TO_CAPTURED_BLOCK(cfp);
-		captured->code.ifunc = ifunc;
-		block_handler = VM_BH_FROM_IFUNC_BLOCK(captured);
-	    }
-	    else {
-		block_handler = VM_CF_BLOCK_HANDLER(cfp);
-	    }
-	    vm_passed_block_handler_set(ec, block_handler);
-	}
-	retval = (*it_proc) (data1);
+        {
+            VALUE block_handler;
+
+            if (ifunc) {
+                struct rb_captured_block *captured = VM_CFP_TO_CAPTURED_BLOCK(cfp);
+                captured->code.ifunc = ifunc;
+                block_handler = VM_BH_FROM_IFUNC_BLOCK(captured);
+            }
+            else {
+                block_handler = VM_CF_BLOCK_HANDLER(cfp);
+            }
+            vm_passed_block_handler_set(ec, block_handler);
+        }
+        retval = (*it_proc) (data1);
     }
     else if (state == TAG_BREAK || state == TAG_RETRY) {
-	const struct vm_throw_data *const err = (struct vm_throw_data *)ec->errinfo;
-	const rb_control_frame_t *const escape_cfp = THROW_DATA_CATCH_FRAME(err);
+        const struct vm_throw_data *const err = (struct vm_throw_data *)ec->errinfo;
+        const rb_control_frame_t *const escape_cfp = THROW_DATA_CATCH_FRAME(err);
 
-	if (cfp == escape_cfp) {
-	    rb_vm_rewind_cfp(ec, cfp);
+        if (cfp == escape_cfp) {
+            rb_vm_rewind_cfp(ec, cfp);
 
-	    state = 0;
-	    ec->tag->state = TAG_NONE;
-	    ec->errinfo = Qnil;
+            state = 0;
+            ec->tag->state = TAG_NONE;
+            ec->errinfo = Qnil;
 
-	    if (state == TAG_RETRY) goto iter_retry;
-	    retval = THROW_DATA_VAL(err);
-	}
-	else if (0) {
-	    SDR(); fprintf(stderr, "%p, %p\n", (void *)cfp, (void *)escape_cfp);
-	}
+            if (state == TAG_RETRY) goto iter_retry;
+            retval = THROW_DATA_VAL(err);
+        }
+        else if (0) {
+            SDR(); fprintf(stderr, "%p, %p\n", (void *)cfp, (void *)escape_cfp);
+        }
     }
     EC_POP_TAG();
 
     if (state) {
-	EC_JUMP_TAG(ec, state);
+        EC_JUMP_TAG(ec, state);
     }
     return retval;
 }
@@ -1561,8 +1561,8 @@ rb_iterate_internal(VALUE (* it_proc)(VALUE), VALUE data1,
                     rb_block_call_func_t bl_proc, VALUE data2)
 {
     return rb_iterate0(it_proc, data1,
-		       bl_proc ? rb_vm_ifunc_proc_new(bl_proc, (void *)data2) : 0,
-		       GET_EC());
+                       bl_proc ? rb_vm_ifunc_proc_new(bl_proc, (void *)data2) : 0,
+                       GET_EC());
 }
 
 VALUE
@@ -1593,7 +1593,7 @@ VALUE rb_block_call_kw(VALUE obj, ID mid, int argc, const VALUE * argv, rb_block
 
 VALUE
 rb_block_call(VALUE obj, ID mid, int argc, const VALUE * argv,
-	      rb_block_call_func_t bl_proc, VALUE data2)
+              rb_block_call_func_t bl_proc, VALUE data2)
 {
     return rb_block_call_kw(obj, mid, argc, argv, bl_proc, data2, RB_NO_KEYWORDS);
 }
@@ -1614,8 +1614,8 @@ rb_block_call_kw(VALUE obj, ID mid, int argc, const VALUE * argv,
 
 VALUE
 rb_lambda_call(VALUE obj, ID mid, int argc, const VALUE *argv,
-	       rb_block_call_func_t bl_proc, int min_argc, int max_argc,
-	       VALUE data2)
+               rb_block_call_func_t bl_proc, int min_argc, int max_argc,
+               VALUE data2)
 {
     struct iter_method_arg arg;
     struct vm_ifunc *block;
@@ -1641,7 +1641,7 @@ iterate_check_method(VALUE obj)
 
 VALUE
 rb_check_block_call(VALUE obj, ID mid, int argc, const VALUE *argv,
-		    rb_block_call_func_t bl_proc, VALUE data2)
+                    rb_block_call_func_t bl_proc, VALUE data2)
 {
     struct iter_method_arg arg;
 
@@ -1665,7 +1665,7 @@ static VALUE eval_default_path;
 
 static const rb_iseq_t *
 eval_make_iseq(VALUE src, VALUE fname, int line, const rb_binding_t *bind,
-	       const struct rb_block *base_block)
+               const struct rb_block *base_block)
 {
     const VALUE parser = rb_parser_new();
     const rb_iseq_t *const parent = vm_block_iseq(base_block);
@@ -1690,7 +1690,7 @@ eval_make_iseq(VALUE src, VALUE fname, int line, const rb_binding_t *bind,
     }
 
     if (!fname) {
-	fname = rb_source_location(&line);
+        fname = rb_source_location(&line);
     }
 
     if (fname != Qundef) {
@@ -1735,7 +1735,7 @@ eval_string_with_cref(VALUE self, VALUE src, rb_cref_t *cref, VALUE file, int li
     const rb_iseq_t *iseq;
     rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(ec, ec->cfp);
     if (!cfp) {
-	rb_raise(rb_eRuntimeError, "Can't eval on top of Fiber or Thread");
+        rb_raise(rb_eRuntimeError, "Can't eval on top of Fiber or Thread");
     }
 
     block.as.captured = *VM_CFP_TO_CAPTURED_BLOCK(cfp);
@@ -1745,13 +1745,13 @@ eval_string_with_cref(VALUE self, VALUE src, rb_cref_t *cref, VALUE file, int li
 
     iseq = eval_make_iseq(src, file, line, NULL, &block);
     if (!iseq) {
-	rb_exc_raise(ec->errinfo);
+        rb_exc_raise(ec->errinfo);
     }
 
     /* TODO: what the code checking? */
     if (!cref && block.as.captured.code.val) {
         rb_cref_t *orig_cref = vm_get_cref(vm_block_ep(&block));
-	cref = vm_cref_dup(orig_cref);
+        cref = vm_cref_dup(orig_cref);
     }
     vm_set_eval_stack(ec, iseq, cref, &block);
 
@@ -1766,14 +1766,14 @@ eval_string_with_scope(VALUE scope, VALUE src, VALUE file, int line)
     rb_binding_t *bind = Check_TypedStruct(scope, &ruby_binding_data_type);
     const rb_iseq_t *iseq = eval_make_iseq(src, file, line, bind, &bind->block);
     if (!iseq) {
-	rb_exc_raise(ec->errinfo);
+        rb_exc_raise(ec->errinfo);
     }
 
     vm_set_eval_stack(ec, iseq, NULL, &bind->block);
 
     /* save new env */
     if (ISEQ_BODY(iseq)->local_table_size > 0) {
-	vm_bind_update_env(scope, bind, vm_make_env_object(ec, ec->cfp));
+        vm_bind_update_env(scope, bind, vm_make_env_object(ec, ec->cfp));
     }
 
     /* kick */
@@ -1808,19 +1808,19 @@ rb_f_eval(int argc, const VALUE *argv, VALUE self)
     rb_scan_args(argc, argv, "13", &src, &scope, &vfile, &vline);
     SafeStringValue(src);
     if (argc >= 3) {
-	StringValue(vfile);
+        StringValue(vfile);
     }
     if (argc >= 4) {
-	line = NUM2INT(vline);
+        line = NUM2INT(vline);
     }
 
     if (!NIL_P(vfile))
-	file = vfile;
+        file = vfile;
 
     if (NIL_P(scope))
-	return eval_string_with_cref(self, src, NULL, file, line);
+        return eval_string_with_cref(self, src, NULL, file, line);
     else
-	return eval_string_with_scope(scope, src, file, line);
+        return eval_string_with_scope(scope, src, file, line);
 }
 
 /** @note This function name is not stable. */
@@ -1888,10 +1888,10 @@ rb_eval_string_wrap(const char *str, int *pstate)
     th->top_wrapper = wrapper;
 
     if (pstate) {
-	*pstate = state;
+        *pstate = state;
     }
     else if (state != TAG_NONE) {
-	EC_JUMP_TAG(th->ec, state);
+        EC_JUMP_TAG(th->ec, state);
     }
     return val;
 }
@@ -1905,13 +1905,13 @@ rb_eval_cmd_kw(VALUE cmd, VALUE arg, int kw_splat)
 
     EC_PUSH_TAG(ec);
     if ((state = EC_EXEC_TAG()) == TAG_NONE) {
-	if (!RB_TYPE_P(cmd, T_STRING)) {
+        if (!RB_TYPE_P(cmd, T_STRING)) {
             val = rb_funcallv_kw(cmd, idCall, RARRAY_LENINT(arg),
                               RARRAY_CONST_PTR(arg), kw_splat);
-	}
-	else {
-	    val = eval_string_with_cref(rb_vm_top_self(), cmd, NULL, 0, 0);
-	}
+        }
+        else {
+            val = eval_string_with_cref(rb_vm_top_self(), cmd, NULL, 0, 0);
+        }
     }
     EC_POP_TAG();
 
@@ -1936,31 +1936,31 @@ yield_under(VALUE self, int singleton, int argc, const VALUE *argv, int kw_splat
 
     if (block_handler != VM_BLOCK_HANDLER_NONE) {
       again:
-	switch (vm_block_handler_type(block_handler)) {
-	  case block_handler_type_iseq:
-	    captured = VM_BH_TO_CAPT_BLOCK(block_handler);
-	    new_captured = *captured;
-	    new_block_handler = VM_BH_FROM_ISEQ_BLOCK(&new_captured);
-	    break;
-	  case block_handler_type_ifunc:
-	    captured = VM_BH_TO_CAPT_BLOCK(block_handler);
-	    new_captured = *captured;
-	    new_block_handler = VM_BH_FROM_IFUNC_BLOCK(&new_captured);
-	    break;
-	  case block_handler_type_proc:
-	    is_lambda = rb_proc_lambda_p(block_handler) != Qfalse;
-	    block_handler = vm_proc_to_block_handler(VM_BH_TO_PROC(block_handler));
-	    goto again;
-	  case block_handler_type_symbol:
+        switch (vm_block_handler_type(block_handler)) {
+          case block_handler_type_iseq:
+            captured = VM_BH_TO_CAPT_BLOCK(block_handler);
+            new_captured = *captured;
+            new_block_handler = VM_BH_FROM_ISEQ_BLOCK(&new_captured);
+            break;
+          case block_handler_type_ifunc:
+            captured = VM_BH_TO_CAPT_BLOCK(block_handler);
+            new_captured = *captured;
+            new_block_handler = VM_BH_FROM_IFUNC_BLOCK(&new_captured);
+            break;
+          case block_handler_type_proc:
+            is_lambda = rb_proc_lambda_p(block_handler) != Qfalse;
+            block_handler = vm_proc_to_block_handler(VM_BH_TO_PROC(block_handler));
+            goto again;
+          case block_handler_type_symbol:
             return rb_sym_proc_call(SYM2ID(VM_BH_TO_SYMBOL(block_handler)),
                                     argc, argv, kw_splat,
                                     VM_BLOCK_HANDLER_NONE);
-	}
+        }
 
-	new_captured.self = self;
-	ep = captured->ep;
+        new_captured.self = self;
+        ep = captured->ep;
 
-	VM_FORCE_WRITE_SPECIAL_CONST(&VM_CF_LEP(ec->cfp)[VM_ENV_DATA_INDEX_SPECVAL], new_block_handler);
+        VM_FORCE_WRITE_SPECIAL_CONST(&VM_CF_LEP(ec->cfp)[VM_ENV_DATA_INDEX_SPECVAL], new_block_handler);
     }
 
     VM_ASSERT(singleton || RB_TYPE_P(self, T_MODULE) || RB_TYPE_P(self, T_CLASS));
@@ -1976,17 +1976,17 @@ rb_yield_refine_block(VALUE refinement, VALUE refinements)
     VALUE block_handler = VM_CF_BLOCK_HANDLER(ec->cfp);
 
     if (vm_block_handler_type(block_handler) != block_handler_type_iseq) {
-	rb_bug("rb_yield_refine_block: an iseq block is required");
+        rb_bug("rb_yield_refine_block: an iseq block is required");
     }
     else {
-	const struct rb_captured_block *captured = VM_BH_TO_ISEQ_BLOCK(block_handler);
-	struct rb_captured_block new_captured = *captured;
-	VALUE new_block_handler = VM_BH_FROM_ISEQ_BLOCK(&new_captured);
-	const VALUE *ep = captured->ep;
-	rb_cref_t *cref = vm_cref_push(ec, refinement, ep, TRUE, FALSE);
-	CREF_REFINEMENTS_SET(cref, refinements);
-	VM_FORCE_WRITE_SPECIAL_CONST(&VM_CF_LEP(ec->cfp)[VM_ENV_DATA_INDEX_SPECVAL], new_block_handler);
-	new_captured.self = refinement;
+        const struct rb_captured_block *captured = VM_BH_TO_ISEQ_BLOCK(block_handler);
+        struct rb_captured_block new_captured = *captured;
+        VALUE new_block_handler = VM_BH_FROM_ISEQ_BLOCK(&new_captured);
+        const VALUE *ep = captured->ep;
+        rb_cref_t *cref = vm_cref_push(ec, refinement, ep, TRUE, FALSE);
+        CREF_REFINEMENTS_SET(cref, refinements);
+        VM_FORCE_WRITE_SPECIAL_CONST(&VM_CF_LEP(ec->cfp)[VM_ENV_DATA_INDEX_SPECVAL], new_block_handler);
+        new_captured.self = refinement;
         return vm_yield_with_cref(ec, 0, NULL, RB_NO_KEYWORDS, cref, FALSE);
     }
 }
@@ -2005,24 +2005,24 @@ static VALUE
 specific_eval(int argc, const VALUE *argv, VALUE self, int singleton, int kw_splat)
 {
     if (rb_block_given_p()) {
-	rb_check_arity(argc, 0, 0);
+        rb_check_arity(argc, 0, 0);
         return yield_under(self, singleton, 1, &self, kw_splat);
     }
     else {
-	VALUE file = Qundef;
-	int line = 1;
-	VALUE code;
-
-	rb_check_arity(argc, 1, 3);
-	code = argv[0];
-	SafeStringValue(code);
-	if (argc > 2)
-	    line = NUM2INT(argv[2]);
-	if (argc > 1) {
-	    file = argv[1];
-	    if (!NIL_P(file)) StringValue(file);
-	}
-	return eval_under(self, singleton, code, file, line);
+        VALUE file = Qundef;
+        int line = 1;
+        VALUE code;
+
+        rb_check_arity(argc, 1, 3);
+        code = argv[0];
+        SafeStringValue(code);
+        if (argc > 2)
+            line = NUM2INT(argv[2]);
+        if (argc > 1) {
+            file = argv[1];
+            if (!NIL_P(file)) StringValue(file);
+        }
+        return eval_under(self, singleton, code, file, line);
     }
 }
 
@@ -2267,18 +2267,18 @@ rb_throw_obj(VALUE tag, VALUE value)
     struct rb_vm_tag *tt = ec->tag;
 
     while (tt) {
-	if (tt->tag == tag) {
-	    tt->retval = value;
-	    break;
-	}
-	tt = tt->prev;
+        if (tt->tag == tag) {
+            tt->retval = value;
+            break;
+        }
+        tt = tt->prev;
     }
     if (!tt) {
-	VALUE desc[3];
-	desc[0] = tag;
-	desc[1] = value;
-	desc[2] = rb_str_new_cstr("uncaught throw %p");
-	rb_exc_raise(rb_class_new_instance(numberof(desc), desc, rb_eUncaughtThrow));
+        VALUE desc[3];
+        desc[0] = tag;
+        desc[1] = value;
+        desc[2] = rb_str_new_cstr("uncaught throw %p");
+        rb_exc_raise(rb_class_new_instance(numberof(desc), desc, rb_eUncaughtThrow));
     }
 
     ec->errinfo = (VALUE)THROW_DATA_NEW(tag, NULL, TAG_THROW);
@@ -2364,7 +2364,7 @@ rb_catch(const char *tag, rb_block_call_func_t func, VALUE data)
 
 static VALUE
 vm_catch_protect(VALUE tag, rb_block_call_func *func, VALUE data,
-		 enum ruby_tag_type *stateptr, rb_execution_context_t *volatile ec)
+                 enum ruby_tag_type *stateptr, rb_execution_context_t *volatile ec)
 {
     enum ruby_tag_type state;
     VALUE val = Qnil;		/* OK */
@@ -2375,18 +2375,18 @@ vm_catch_protect(VALUE tag, rb_block_call_func *func, VALUE data,
     _tag.tag = tag;
 
     if ((state = EC_EXEC_TAG()) == TAG_NONE) {
-	/* call with argc=1, argv = [tag], block = Qnil to insure compatibility */
-	val = (*func)(tag, data, 1, (const VALUE *)&tag, Qnil);
+        /* call with argc=1, argv = [tag], block = Qnil to insure compatibility */
+        val = (*func)(tag, data, 1, (const VALUE *)&tag, Qnil);
     }
     else if (state == TAG_THROW && THROW_DATA_VAL((struct vm_throw_data *)ec->errinfo) == tag) {
-	rb_vm_rewind_cfp(ec, saved_cfp);
-	val = ec->tag->retval;
-	ec->errinfo = Qnil;
-	state = 0;
+        rb_vm_rewind_cfp(ec, saved_cfp);
+        val = ec->tag->retval;
+        ec->errinfo = Qnil;
+        state = 0;
     }
     EC_POP_TAG();
     if (stateptr)
-	*stateptr = state;
+        *stateptr = state;
 
     return val;
 }
@@ -2465,27 +2465,27 @@ rb_f_local_variables(VALUE _)
 
     local_var_list_init(&vars);
     while (cfp) {
-	if (cfp->iseq) {
+        if (cfp->iseq) {
             for (i = 0; i < ISEQ_BODY(cfp->iseq)->local_table_size; i++) {
                 local_var_list_add(&vars, ISEQ_BODY(cfp->iseq)->local_table[i]);
-	    }
-	}
-	if (!VM_ENV_LOCAL_P(cfp->ep)) {
-	    /* block */
-	    const VALUE *ep = VM_CF_PREV_EP(cfp);
-
-	    if (vm_collect_local_variables_in_heap(ep, &vars)) {
-		break;
-	    }
-	    else {
-		while (cfp->ep != ep) {
-		    cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
-		}
-	    }
-	}
-	else {
-	    break;
-	}
+            }
+        }
+        if (!VM_ENV_LOCAL_P(cfp->ep)) {
+            /* block */
+            const VALUE *ep = VM_CF_PREV_EP(cfp);
+
+            if (vm_collect_local_variables_in_heap(ep, &vars)) {
+                break;
+            }
+            else {
+                while (cfp->ep != ep) {
+                    cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
+                }
+            }
+        }
+        else {
+            break;
+        }
     }
     return local_var_list_finish(&vars);
 }
@@ -2574,9 +2574,9 @@ Init_vm_eval(void)
 
 #if 1
     rb_add_method(rb_cBasicObject, id__send__,
-		  VM_METHOD_TYPE_OPTIMIZED, (void *)OPTIMIZED_METHOD_TYPE_SEND, METHOD_VISI_PUBLIC);
+                  VM_METHOD_TYPE_OPTIMIZED, (void *)OPTIMIZED_METHOD_TYPE_SEND, METHOD_VISI_PUBLIC);
     rb_add_method(rb_mKernel, idSend,
-		  VM_METHOD_TYPE_OPTIMIZED, (void *)OPTIMIZED_METHOD_TYPE_SEND, METHOD_VISI_PUBLIC);
+                  VM_METHOD_TYPE_OPTIMIZED, (void *)OPTIMIZED_METHOD_TYPE_SEND, METHOD_VISI_PUBLIC);
 #else
     rb_define_method(rb_cBasicObject, "__send__", rb_f_send, -1);
     rb_define_method(rb_mKernel, "send", rb_f_send, -1);