Expand tabs [ci skip]

[Misc #18891]

1 files changed, 2861 insertions, 2861 deletions

diff --git a/string.c b/string.c
index 72f6dbd67c..f3f5ea92cc 100644
--- a/string.c
+++ b/string.c
@@ -132,21 +132,21 @@ VALUE rb_cSymbol;
 
 #define STR_SET_LEN(str, n) do { \
     if (STR_EMBED_P(str)) {\
-	STR_SET_EMBED_LEN((str), (n));\
+        STR_SET_EMBED_LEN((str), (n));\
     }\
     else {\
-	RSTRING(str)->as.heap.len = (n);\
+        RSTRING(str)->as.heap.len = (n);\
     }\
 } while (0)
 
 #define STR_DEC_LEN(str) do {\
     if (STR_EMBED_P(str)) {\
-	long n = RSTRING_LEN(str);\
-	n--;\
-	STR_SET_EMBED_LEN((str), n);\
+        long n = RSTRING_LEN(str);\
+        n--;\
+        STR_SET_EMBED_LEN((str), n);\
     }\
     else {\
-	RSTRING(str)->as.heap.len--;\
+        RSTRING(str)->as.heap.len--;\
     }\
 } while (0)
 
@@ -170,7 +170,7 @@ str_enc_fastpath(VALUE str)
     const int term_fill_len = (termlen);\
     *term_fill_ptr = '\0';\
     if (UNLIKELY(term_fill_len > 1))\
-	memset(term_fill_ptr, 0, term_fill_len);\
+        memset(term_fill_ptr, 0, term_fill_len);\
 } while (0)
 
 #define RESIZE_CAPA(str,capacity) do {\
@@ -179,21 +179,21 @@ str_enc_fastpath(VALUE str)
 } while (0)
 #define RESIZE_CAPA_TERM(str,capacity,termlen) do {\
     if (STR_EMBED_P(str)) {\
-	if (str_embed_capa(str) < capacity + termlen) {\
-	    char *const tmp = ALLOC_N(char, (size_t)(capacity) + (termlen));\
-	    const long tlen = RSTRING_LEN(str);\
-	    memcpy(tmp, RSTRING_PTR(str), tlen);\
-	    RSTRING(str)->as.heap.ptr = tmp;\
-	    RSTRING(str)->as.heap.len = tlen;\
+        if (str_embed_capa(str) < capacity + termlen) {\
+            char *const tmp = ALLOC_N(char, (size_t)(capacity) + (termlen));\
+            const long tlen = RSTRING_LEN(str);\
+            memcpy(tmp, RSTRING_PTR(str), tlen);\
+            RSTRING(str)->as.heap.ptr = tmp;\
+            RSTRING(str)->as.heap.len = tlen;\
             STR_SET_NOEMBED(str);\
-	    RSTRING(str)->as.heap.aux.capa = (capacity);\
-	}\
+            RSTRING(str)->as.heap.aux.capa = (capacity);\
+        }\
     }\
     else {\
-	assert(!FL_TEST((str), STR_SHARED)); \
-	SIZED_REALLOC_N(RSTRING(str)->as.heap.ptr, char, \
-			(size_t)(capacity) + (termlen), STR_HEAP_SIZE(str)); \
-	RSTRING(str)->as.heap.aux.capa = (capacity);\
+        assert(!FL_TEST((str), STR_SHARED)); \
+        SIZED_REALLOC_N(RSTRING(str)->as.heap.ptr, char, \
+                        (size_t)(capacity) + (termlen), STR_HEAP_SIZE(str)); \
+        RSTRING(str)->as.heap.aux.capa = (capacity);\
     }\
 } while (0)
 
@@ -201,11 +201,11 @@ str_enc_fastpath(VALUE str)
     if (!FL_TEST(str, STR_FAKESTR)) { \
         assert(RSTRING_PTR(shared_str) <= RSTRING_PTR(str)); \
         assert(RSTRING_PTR(str) <= RSTRING_PTR(shared_str) + RSTRING_LEN(shared_str)); \
-	RB_OBJ_WRITE((str), &RSTRING(str)->as.heap.aux.shared, (shared_str)); \
-	FL_SET((str), STR_SHARED); \
+        RB_OBJ_WRITE((str), &RSTRING(str)->as.heap.aux.shared, (shared_str)); \
+        FL_SET((str), STR_SHARED); \
         FL_SET((shared_str), STR_SHARED_ROOT); \
-	if (RBASIC_CLASS((shared_str)) == 0) /* for CoW-friendliness */ \
-	    FL_SET_RAW((shared_str), STR_BORROWED); \
+        if (RBASIC_CLASS((shared_str)) == 0) /* for CoW-friendliness */ \
+            FL_SET_RAW((shared_str), STR_BORROWED); \
     } \
 } while (0)
 
@@ -349,7 +349,7 @@ rb_debug_rstring_null_ptr(const char *func)
             "SIGSEGV is highly expected to follow immediately.\n"
             "If you could reproduce, attach your debugger here, "
             "and look at the passed string.\n",
-	    func);
+            func);
 }
 
 /* symbols for [up|down|swap]case/capitalize options */
@@ -362,25 +362,25 @@ get_actual_encoding(const int encidx, VALUE str)
 
     switch (encidx) {
       case ENCINDEX_UTF_16:
-	if (RSTRING_LEN(str) < 2) break;
-	q = (const unsigned char *)RSTRING_PTR(str);
-	if (q[0] == 0xFE && q[1] == 0xFF) {
-	    return rb_enc_get_from_index(ENCINDEX_UTF_16BE);
-	}
-	if (q[0] == 0xFF && q[1] == 0xFE) {
-	    return rb_enc_get_from_index(ENCINDEX_UTF_16LE);
-	}
-	return rb_ascii8bit_encoding();
+        if (RSTRING_LEN(str) < 2) break;
+        q = (const unsigned char *)RSTRING_PTR(str);
+        if (q[0] == 0xFE && q[1] == 0xFF) {
+            return rb_enc_get_from_index(ENCINDEX_UTF_16BE);
+        }
+        if (q[0] == 0xFF && q[1] == 0xFE) {
+            return rb_enc_get_from_index(ENCINDEX_UTF_16LE);
+        }
+        return rb_ascii8bit_encoding();
       case ENCINDEX_UTF_32:
-	if (RSTRING_LEN(str) < 4) break;
-	q = (const unsigned char *)RSTRING_PTR(str);
-	if (q[0] == 0 && q[1] == 0 && q[2] == 0xFE && q[3] == 0xFF) {
-	    return rb_enc_get_from_index(ENCINDEX_UTF_32BE);
-	}
-	if (q[3] == 0 && q[2] == 0 && q[1] == 0xFE && q[0] == 0xFF) {
-	    return rb_enc_get_from_index(ENCINDEX_UTF_32LE);
-	}
-	return rb_ascii8bit_encoding();
+        if (RSTRING_LEN(str) < 4) break;
+        q = (const unsigned char *)RSTRING_PTR(str);
+        if (q[0] == 0 && q[1] == 0 && q[2] == 0xFE && q[3] == 0xFF) {
+            return rb_enc_get_from_index(ENCINDEX_UTF_32BE);
+        }
+        if (q[3] == 0 && q[2] == 0 && q[1] == 0xFE && q[0] == 0xFF) {
+            return rb_enc_get_from_index(ENCINDEX_UTF_32LE);
+        }
+        return rb_ascii8bit_encoding();
     }
     return rb_enc_from_index(encidx);
 }
@@ -395,7 +395,7 @@ static void
 mustnot_broken(VALUE str)
 {
     if (is_broken_string(str)) {
-	rb_raise(rb_eArgError, "invalid byte sequence in %s", rb_enc_name(STR_ENC_GET(str)));
+        rb_raise(rb_eArgError, "invalid byte sequence in %s", rb_enc_name(STR_ENC_GET(str)));
     }
 }
 
@@ -404,7 +404,7 @@ mustnot_wchar(VALUE str)
 {
     rb_encoding *enc = STR_ENC_GET(str);
     if (rb_enc_mbminlen(enc) > 1) {
-	rb_raise(rb_eArgError, "wide char encoding: %s", rb_enc_name(enc));
+        rb_raise(rb_eArgError, "wide char encoding: %s", rb_enc_name(enc));
     }
 }
 
@@ -432,47 +432,47 @@ fstr_update_callback(st_data_t *key, st_data_t *value, st_data_t data, int exist
     VALUE str = (VALUE)*key;
 
     if (existing) {
-	/* because of lazy sweep, str may be unmarked already and swept
-	 * at next time */
+        /* because of lazy sweep, str may be unmarked already and swept
+         * at next time */
 
-	if (rb_objspace_garbage_object_p(str)) {
-	    arg->fstr = Qundef;
-	    return ST_DELETE;
-	}
+        if (rb_objspace_garbage_object_p(str)) {
+            arg->fstr = Qundef;
+            return ST_DELETE;
+        }
 
-	arg->fstr = str;
-	return ST_STOP;
+        arg->fstr = str;
+        return ST_STOP;
     }
     else {
-	if (FL_TEST_RAW(str, STR_FAKESTR)) {
-	    if (arg->copy) {
-		VALUE new_str = str_new(rb_cString, RSTRING(str)->as.heap.ptr, RSTRING(str)->as.heap.len);
-		rb_enc_copy(new_str, str);
-		str = new_str;
-	    }
-	    else {
-		str = str_new_static(rb_cString, RSTRING(str)->as.heap.ptr,
-				     RSTRING(str)->as.heap.len,
-				     ENCODING_GET(str));
-	    }
-	    OBJ_FREEZE_RAW(str);
-	}
-	else {
-	    if (!OBJ_FROZEN(str))
-		str = str_new_frozen(rb_cString, str);
-	    if (STR_SHARED_P(str)) { /* str should not be shared */
-		/* shared substring  */
+        if (FL_TEST_RAW(str, STR_FAKESTR)) {
+            if (arg->copy) {
+                VALUE new_str = str_new(rb_cString, RSTRING(str)->as.heap.ptr, RSTRING(str)->as.heap.len);
+                rb_enc_copy(new_str, str);
+                str = new_str;
+            }
+            else {
+                str = str_new_static(rb_cString, RSTRING(str)->as.heap.ptr,
+                                     RSTRING(str)->as.heap.len,
+                                     ENCODING_GET(str));
+            }
+            OBJ_FREEZE_RAW(str);
+        }
+        else {
+            if (!OBJ_FROZEN(str))
+                str = str_new_frozen(rb_cString, str);
+            if (STR_SHARED_P(str)) { /* str should not be shared */
+                /* shared substring  */
                 str_make_independent(str);
-		assert(OBJ_FROZEN(str));
-	    }
-	    if (!BARE_STRING_P(str)) {
-		str = str_new_frozen(rb_cString, str);
-	    }
-	}
-	RBASIC(str)->flags |= RSTRING_FSTR;
+                assert(OBJ_FROZEN(str));
+            }
+            if (!BARE_STRING_P(str)) {
+                str = str_new_frozen(rb_cString, str);
+            }
+        }
+        RBASIC(str)->flags |= RSTRING_FSTR;
 
-	*key = *value = arg->fstr = str;
-	return ST_CONTINUE;
+        *key = *value = arg->fstr = str;
+        return ST_CONTINUE;
     }
 }
 
@@ -486,7 +486,7 @@ rb_fstring(VALUE str)
     Check_Type(str, T_STRING);
 
     if (FL_TEST(str, RSTRING_FSTR))
-	return str;
+        return str;
 
     bare = BARE_STRING_P(str);
     if (!bare) {
@@ -506,9 +506,9 @@ rb_fstring(VALUE str)
     fstr = register_fstring(str, FALSE);
 
     if (!bare) {
-	str_replace_shared_without_enc(str, fstr);
-	OBJ_FREEZE_RAW(str);
-	return str;
+        str_replace_shared_without_enc(str, fstr);
+        OBJ_FREEZE_RAW(str);
+        return str;
     }
     return fstr;
 }
@@ -543,8 +543,8 @@ setup_fake_str(struct RString *fake_str, const char *name, long len, int encidx)
     /* SHARED to be allocated by the callback */
 
     if (!name) {
-	RUBY_ASSERT_ALWAYS(len == 0);
-	name = "";
+        RUBY_ASSERT_ALWAYS(len == 0);
+        name = "";
     }
 
     ENCODING_SET_INLINED((VALUE)fake_str, encidx);
@@ -605,8 +605,8 @@ fstring_cmp(VALUE a, VALUE b)
     RSTRING_GETMEM(a, aptr, alen);
     RSTRING_GETMEM(b, bptr, blen);
     return (alen != blen ||
-	    ENCODING_GET(a) != ENCODING_GET(b) ||
-	    memcmp(aptr, bptr, alen) != 0);
+            ENCODING_GET(a) != ENCODING_GET(b) ||
+            memcmp(aptr, bptr, alen) != 0);
 }
 
 static inline int
@@ -654,23 +654,23 @@ search_nonascii(const char *p, const char *e)
 
     if (UNALIGNED_WORD_ACCESS || e - p >= SIZEOF_VOIDP) {
 #if !UNALIGNED_WORD_ACCESS
-	if ((uintptr_t)p % SIZEOF_VOIDP) {
-	    int l = SIZEOF_VOIDP - (uintptr_t)p % SIZEOF_VOIDP;
-	    p += l;
-	    switch (l) {
-	      default: UNREACHABLE;
+        if ((uintptr_t)p % SIZEOF_VOIDP) {
+            int l = SIZEOF_VOIDP - (uintptr_t)p % SIZEOF_VOIDP;
+            p += l;
+            switch (l) {
+              default: UNREACHABLE;
 #if SIZEOF_VOIDP > 4
-	      case 7: if (p[-7]&0x80) return p-7;
-	      case 6: if (p[-6]&0x80) return p-6;
-	      case 5: if (p[-5]&0x80) return p-5;
-	      case 4: if (p[-4]&0x80) return p-4;
+              case 7: if (p[-7]&0x80) return p-7;
+              case 6: if (p[-6]&0x80) return p-6;
+              case 5: if (p[-5]&0x80) return p-5;
+              case 4: if (p[-4]&0x80) return p-4;
 #endif
-	      case 3: if (p[-3]&0x80) return p-3;
-	      case 2: if (p[-2]&0x80) return p-2;
-	      case 1: if (p[-1]&0x80) return p-1;
-	      case 0: break;
-	    }
-	}
+              case 3: if (p[-3]&0x80) return p-3;
+              case 2: if (p[-2]&0x80) return p-2;
+              case 1: if (p[-1]&0x80) return p-1;
+              case 0: break;
+            }
+        }
 #endif
 #if defined(HAVE_BUILTIN___BUILTIN_ASSUME_ALIGNED) &&! UNALIGNED_WORD_ACCESS
 #define aligned_ptr(value) \
@@ -678,19 +678,19 @@ search_nonascii(const char *p, const char *e)
 #else
 #define aligned_ptr(value) (uintptr_t *)(value)
 #endif
-	s = aligned_ptr(p);
-	t = (uintptr_t *)(e - (SIZEOF_VOIDP-1));
+        s = aligned_ptr(p);
+        t = (uintptr_t *)(e - (SIZEOF_VOIDP-1));
 #undef aligned_ptr
-	for (;s < t; s++) {
-	    if (*s & NONASCII_MASK) {
+        for (;s < t; s++) {
+            if (*s & NONASCII_MASK) {
 #ifdef WORDS_BIGENDIAN
-		return (const char *)s + (nlz_intptr(*s&NONASCII_MASK)>>3);
+                return (const char *)s + (nlz_intptr(*s&NONASCII_MASK)>>3);
 #else
-		return (const char *)s + (ntz_intptr(*s&NONASCII_MASK)>>3);
+                return (const char *)s + (ntz_intptr(*s&NONASCII_MASK)>>3);
 #endif
-	    }
-	}
-	p = (const char *)s;
+            }
+        }
+        p = (const char *)s;
     }
 
     switch (e - p) {
@@ -747,42 +747,42 @@ rb_str_coderange_scan_restartable(const char *s, const char *e, rb_encoding *enc
     const char *p = s;
 
     if (*cr == ENC_CODERANGE_BROKEN)
-	return e - s;
+        return e - s;
 
     if (rb_enc_to_index(enc) == rb_ascii8bit_encindex()) {
-	/* enc is ASCII-8BIT.  ASCII-8BIT string never be broken. */
-	if (*cr == ENC_CODERANGE_VALID) return e - s;
-	p = search_nonascii(p, e);
+        /* enc is ASCII-8BIT.  ASCII-8BIT string never be broken. */
+        if (*cr == ENC_CODERANGE_VALID) return e - s;
+        p = search_nonascii(p, e);
         *cr = p ? ENC_CODERANGE_VALID : ENC_CODERANGE_7BIT;
-	return e - s;
+        return e - s;
     }
     else if (rb_enc_asciicompat(enc)) {
-	p = search_nonascii(p, e);
-	if (!p) {
-	    if (*cr != ENC_CODERANGE_VALID) *cr = ENC_CODERANGE_7BIT;
-	    return e - s;
-	}
-	for (;;) {
-	    int ret = rb_enc_precise_mbclen(p, e, enc);
-	    if (!MBCLEN_CHARFOUND_P(ret)) {
-		*cr = MBCLEN_INVALID_P(ret) ? ENC_CODERANGE_BROKEN: ENC_CODERANGE_UNKNOWN;
-		return p - s;
-	    }
-	    p += MBCLEN_CHARFOUND_LEN(ret);
-	    if (p == e) break;
-	    p = search_nonascii(p, e);
-	    if (!p) break;
-	}
+        p = search_nonascii(p, e);
+        if (!p) {
+            if (*cr != ENC_CODERANGE_VALID) *cr = ENC_CODERANGE_7BIT;
+            return e - s;
+        }
+        for (;;) {
+            int ret = rb_enc_precise_mbclen(p, e, enc);
+            if (!MBCLEN_CHARFOUND_P(ret)) {
+                *cr = MBCLEN_INVALID_P(ret) ? ENC_CODERANGE_BROKEN: ENC_CODERANGE_UNKNOWN;
+                return p - s;
+            }
+            p += MBCLEN_CHARFOUND_LEN(ret);
+            if (p == e) break;
+            p = search_nonascii(p, e);
+            if (!p) break;
+        }
     }
     else {
-	while (p < e) {
-	    int ret = rb_enc_precise_mbclen(p, e, enc);
-	    if (!MBCLEN_CHARFOUND_P(ret)) {
-		*cr = MBCLEN_INVALID_P(ret) ? ENC_CODERANGE_BROKEN: ENC_CODERANGE_UNKNOWN;
-		return p - s;
-	    }
-	    p += MBCLEN_CHARFOUND_LEN(ret);
-	}
+        while (p < e) {
+            int ret = rb_enc_precise_mbclen(p, e, enc);
+            if (!MBCLEN_CHARFOUND_P(ret)) {
+                *cr = MBCLEN_INVALID_P(ret) ? ENC_CODERANGE_BROKEN: ENC_CODERANGE_UNKNOWN;
+                return p - s;
+            }
+            p += MBCLEN_CHARFOUND_LEN(ret);
+        }
     }
     *cr = ENC_CODERANGE_VALID;
     return e - s;
@@ -802,25 +802,25 @@ rb_enc_cr_str_copy_for_substr(VALUE dest, VALUE src)
      */
     str_enc_copy(dest, src);
     if (RSTRING_LEN(dest) == 0) {
-	if (!rb_enc_asciicompat(STR_ENC_GET(src)))
-	    ENC_CODERANGE_SET(dest, ENC_CODERANGE_VALID);
-	else
-	    ENC_CODERANGE_SET(dest, ENC_CODERANGE_7BIT);
-	return;
+        if (!rb_enc_asciicompat(STR_ENC_GET(src)))
+            ENC_CODERANGE_SET(dest, ENC_CODERANGE_VALID);
+        else
+            ENC_CODERANGE_SET(dest, ENC_CODERANGE_7BIT);
+        return;
     }
     switch (ENC_CODERANGE(src)) {
       case ENC_CODERANGE_7BIT:
-	ENC_CODERANGE_SET(dest, ENC_CODERANGE_7BIT);
-	break;
+        ENC_CODERANGE_SET(dest, ENC_CODERANGE_7BIT);
+        break;
       case ENC_CODERANGE_VALID:
-	if (!rb_enc_asciicompat(STR_ENC_GET(src)) ||
-	    search_nonascii(RSTRING_PTR(dest), RSTRING_END(dest)))
-	    ENC_CODERANGE_SET(dest, ENC_CODERANGE_VALID);
-	else
-	    ENC_CODERANGE_SET(dest, ENC_CODERANGE_7BIT);
-	break;
+        if (!rb_enc_asciicompat(STR_ENC_GET(src)) ||
+            search_nonascii(RSTRING_PTR(dest), RSTRING_END(dest)))
+            ENC_CODERANGE_SET(dest, ENC_CODERANGE_VALID);
+        else
+            ENC_CODERANGE_SET(dest, ENC_CODERANGE_7BIT);
+        break;
       default:
-	break;
+        break;
     }
 }
 
@@ -835,11 +835,11 @@ static int
 enc_coderange_scan(VALUE str, rb_encoding *enc, int encidx)
 {
     if (rb_enc_mbminlen(enc) > 1 && rb_enc_dummy_p(enc) &&
-	rb_enc_mbminlen(enc = get_actual_encoding(encidx, str)) == 1) {
-	return ENC_CODERANGE_BROKEN;
+        rb_enc_mbminlen(enc = get_actual_encoding(encidx, str)) == 1) {
+        return ENC_CODERANGE_BROKEN;
     }
     else {
-	return coderange_scan(RSTRING_PTR(str), RSTRING_LEN(str), enc);
+        return coderange_scan(RSTRING_PTR(str), RSTRING_LEN(str), enc);
     }
 }
 
@@ -855,9 +855,9 @@ rb_enc_str_coderange(VALUE str)
     int cr = ENC_CODERANGE(str);
 
     if (cr == ENC_CODERANGE_UNKNOWN) {
-	int encidx = ENCODING_GET(str);
-	rb_encoding *enc = rb_enc_from_index(encidx);
-	cr = enc_coderange_scan(str, enc, encidx);
+        int encidx = ENCODING_GET(str);
+        rb_encoding *enc = rb_enc_from_index(encidx);
+        cr = enc_coderange_scan(str, enc, encidx);
         ENC_CODERANGE_SET(str, cr);
     }
     return cr;
@@ -879,7 +879,7 @@ static inline void
 str_mod_check(VALUE s, const char *p, long len)
 {
     if (RSTRING_PTR(s) != p || RSTRING_LEN(s) != len){
-	rb_raise(rb_eRuntimeError, "string modified");
+        rb_raise(rb_eRuntimeError, "string modified");
     }
 }
 
@@ -890,14 +890,14 @@ str_capacity(VALUE str, const int termlen)
 #if USE_RVARGC
         return str_embed_capa(str) - termlen;
 #else
-	return (RSTRING_EMBED_LEN_MAX + 1 - termlen);
+        return (RSTRING_EMBED_LEN_MAX + 1 - termlen);
 #endif
     }
     else if (FL_TEST(str, STR_SHARED|STR_NOFREE)) {
-	return RSTRING(str)->as.heap.len;
+        return RSTRING(str)->as.heap.len;
     }
     else {
-	return RSTRING(str)->as.heap.aux.capa;
+        return RSTRING(str)->as.heap.aux.capa;
     }
 }
 
@@ -911,7 +911,7 @@ static inline void
 must_not_null(const char *ptr)
 {
     if (!ptr) {
-	rb_raise(rb_eArgError, "NULL pointer given");
+        rb_raise(rb_eArgError, "NULL pointer given");
     }
 }
 
@@ -956,7 +956,7 @@ str_new0(VALUE klass, const char *ptr, long len, int termlen)
     VALUE str;
 
     if (len < 0) {
-	rb_raise(rb_eArgError, "negative string size (or size too big)");
+        rb_raise(rb_eArgError, "negative string size (or size too big)");
     }
 
     RUBY_DTRACE_CREATE_HOOK(STRING, len);
@@ -969,16 +969,16 @@ str_new0(VALUE klass, const char *ptr, long len, int termlen)
     }
     else {
         str = str_alloc_heap(klass);
-	RSTRING(str)->as.heap.aux.capa = len;
+        RSTRING(str)->as.heap.aux.capa = len;
         /* :FIXME: @shyouhei guesses `len + termlen` is guaranteed to never
          * integer overflow.  If we can STATIC_ASSERT that, the following
          * mul_add_mul can be reverted to a simple ALLOC_N. */
         RSTRING(str)->as.heap.ptr =
             rb_xmalloc_mul_add_mul(sizeof(char), len, sizeof(char), termlen);
-	STR_SET_NOEMBED(str);
+        STR_SET_NOEMBED(str);
     }
     if (ptr) {
-	memcpy(RSTRING_PTR(str), ptr, len);
+        memcpy(RSTRING_PTR(str), ptr, len);
     }
     STR_SET_LEN(str, len);
     TERM_FILL(RSTRING_PTR(str) + len, termlen);
@@ -1058,7 +1058,7 @@ rb_enc_str_new_cstr(const char *ptr, rb_encoding *enc)
 {
     must_not_null(ptr);
     if (rb_enc_mbminlen(enc) != 1) {
-	rb_raise(rb_eArgError, "wchar encoding given");
+        rb_raise(rb_eArgError, "wchar encoding given");
     }
     return rb_enc_str_new(ptr, strlen(ptr), enc);
 }
@@ -1069,21 +1069,21 @@ str_new_static(VALUE klass, const char *ptr, long len, int encindex)
     VALUE str;
 
     if (len < 0) {
-	rb_raise(rb_eArgError, "negative string size (or size too big)");
+        rb_raise(rb_eArgError, "negative string size (or size too big)");
     }
 
     if (!ptr) {
-	rb_encoding *enc = rb_enc_get_from_index(encindex);
-	str = str_new0(klass, ptr, len, rb_enc_mbminlen(enc));
+        rb_encoding *enc = rb_enc_get_from_index(encindex);
+        str = str_new0(klass, ptr, len, rb_enc_mbminlen(enc));
     }
     else {
-	RUBY_DTRACE_CREATE_HOOK(STRING, len);
+        RUBY_DTRACE_CREATE_HOOK(STRING, len);
         str = str_alloc_heap(klass);
-	RSTRING(str)->as.heap.len = len;
-	RSTRING(str)->as.heap.ptr = (char *)ptr;
-	RSTRING(str)->as.heap.aux.capa = len;
-	STR_SET_NOEMBED(str);
-	RBASIC(str)->flags |= STR_NOFREE;
+        RSTRING(str)->as.heap.len = len;
+        RSTRING(str)->as.heap.ptr = (char *)ptr;
+        RSTRING(str)->as.heap.aux.capa = len;
+        STR_SET_NOEMBED(str);
+        RBASIC(str)->flags |= STR_NOFREE;
     }
     rb_enc_associate_index(str, encindex);
     return str;
@@ -1114,15 +1114,15 @@ rb_enc_str_new_static(const char *ptr, long len, rb_encoding *enc)
 }
 
 static VALUE str_cat_conv_enc_opts(VALUE newstr, long ofs, const char *ptr, long len,
-				   rb_encoding *from, rb_encoding *to,
-				   int ecflags, VALUE ecopts);
+                                   rb_encoding *from, rb_encoding *to,
+                                   int ecflags, VALUE ecopts);
 
 static inline bool
 is_enc_ascii_string(VALUE str, rb_encoding *enc)
 {
     int encidx = rb_enc_to_index(enc);
     if (rb_enc_get_index(str) == encidx)
-	return is_ascii_string(str);
+        return is_ascii_string(str);
     return enc_coderange_scan(str, enc, encidx) == ENC_CODERANGE_7BIT;
 }
 
@@ -1137,27 +1137,27 @@ rb_str_conv_enc_opts(VALUE str, rb_encoding *from, rb_encoding *to, int ecflags,
     if (!from) from = rb_enc_get(str);
     if (from == to) return str;
     if ((rb_enc_asciicompat(to) && is_enc_ascii_string(str, from)) ||
-	to == rb_ascii8bit_encoding()) {
-	if (STR_ENC_GET(str) != to) {
-	    str = rb_str_dup(str);
-	    rb_enc_associate(str, to);
-	}
-	return str;
+        to == rb_ascii8bit_encoding()) {
+        if (STR_ENC_GET(str) != to) {
+            str = rb_str_dup(str);
+            rb_enc_associate(str, to);
+        }
+        return str;
     }
 
     RSTRING_GETMEM(str, ptr, len);
     newstr = str_cat_conv_enc_opts(rb_str_buf_new(len), 0, ptr, len,
-				   from, to, ecflags, ecopts);
+                                   from, to, ecflags, ecopts);
     if (NIL_P(newstr)) {
-	/* some error, return original */
-	return str;
+        /* some error, return original */
+        return str;
     }
     return newstr;
 }
 
 VALUE
 rb_str_cat_conv_enc_opts(VALUE newstr, long ofs, const char *ptr, long len,
-			 rb_encoding *from, int ecflags, VALUE ecopts)
+                         rb_encoding *from, int ecflags, VALUE ecopts)
 {
     long olen;
 
@@ -1166,14 +1166,14 @@ rb_str_cat_conv_enc_opts(VALUE newstr, long ofs, const char *ptr, long len,
         rb_raise(rb_eIndexError, "index %ld out of string", ofs);
     if (ofs < 0) ofs += olen;
     if (!from) {
-	STR_SET_LEN(newstr, ofs);
-	return rb_str_cat(newstr, ptr, len);
+        STR_SET_LEN(newstr, ofs);
+        return rb_str_cat(newstr, ptr, len);
     }
 
     rb_str_modify(newstr);
     return str_cat_conv_enc_opts(newstr, ofs, ptr, len, from,
-				 rb_enc_get(newstr),
-				 ecflags, ecopts);
+                                 rb_enc_get(newstr),
+                                 ecflags, ecopts);
 }
 
 VALUE
@@ -1187,8 +1187,8 @@ rb_str_initialize(VALUE str, const char *ptr, long len, rb_encoding *enc)
 
 static VALUE
 str_cat_conv_enc_opts(VALUE newstr, long ofs, const char *ptr, long len,
-		      rb_encoding *from, rb_encoding *to,
-		      int ecflags, VALUE ecopts)
+                      rb_encoding *from, rb_encoding *to,
+                      int ecflags, VALUE ecopts)
 {
     rb_econv_t *ec;
     rb_econv_result_t ret;
@@ -1209,35 +1209,35 @@ str_cat_conv_enc_opts(VALUE newstr, long ofs, const char *ptr, long len,
     sp = (unsigned char*)ptr;
     start = sp;
     while ((dest = (unsigned char*)RSTRING_PTR(newstr)),
-	   (dp = dest + converted_output),
-	   (ret = rb_econv_convert(ec, &sp, start + len, &dp, dest + olen, 0)),
-	   ret == econv_destination_buffer_full) {
-	/* destination buffer short */
-	size_t converted_input = sp - start;
-	size_t rest = len - converted_input;
-	converted_output = dp - dest;
-	rb_str_set_len(newstr, converted_output);
-	if (converted_input && converted_output &&
-	    rest < (LONG_MAX / converted_output)) {
-	    rest = (rest * converted_output) / converted_input;
-	}
-	else {
-	    rest = olen;
-	}
-	olen += rest < 2 ? 2 : rest;
-	rb_str_resize(newstr, olen);
+           (dp = dest + converted_output),
+           (ret = rb_econv_convert(ec, &sp, start + len, &dp, dest + olen, 0)),
+           ret == econv_destination_buffer_full) {
+        /* destination buffer short */
+        size_t converted_input = sp - start;
+        size_t rest = len - converted_input;
+        converted_output = dp - dest;
+        rb_str_set_len(newstr, converted_output);
+        if (converted_input && converted_output &&
+            rest < (LONG_MAX / converted_output)) {
+            rest = (rest * converted_output) / converted_input;
+        }
+        else {
+            rest = olen;
+        }
+        olen += rest < 2 ? 2 : rest;
+        rb_str_resize(newstr, olen);
     }
     DATA_PTR(econv_wrapper) = 0;
     rb_econv_close(ec);
     switch (ret) {
       case econv_finished:
-	len = dp - (unsigned char*)RSTRING_PTR(newstr);
-	rb_str_set_len(newstr, len);
-	rb_enc_associate(newstr, to);
-	return newstr;
+        len = dp - (unsigned char*)RSTRING_PTR(newstr);
+        rb_str_set_len(newstr, len);
+        rb_enc_associate(newstr, to);
+        return newstr;
 
       default:
-	return Qnil;
+        return Qnil;
     }
 }
 
@@ -1260,7 +1260,7 @@ rb_external_str_new_with_enc(const char *ptr, long len, rb_encoding *eenc)
 
     /* ASCII-8BIT case, no conversion */
     if ((eidx == rb_ascii8bit_encindex()) ||
-	(eidx == rb_usascii_encindex() && search_nonascii(ptr, ptr + len))) {
+        (eidx == rb_usascii_encindex() && search_nonascii(ptr, ptr + len))) {
         return rb_str_new(ptr, len);
     }
     /* no default_internal or same encoding, no conversion */
@@ -1271,8 +1271,8 @@ rb_external_str_new_with_enc(const char *ptr, long len, rb_encoding *eenc)
     /* ASCII compatible, and ASCII only string, no conversion in
      * default_internal */
     if ((eidx == rb_ascii8bit_encindex()) ||
-	(eidx == rb_usascii_encindex()) ||
-	(rb_enc_asciicompat(eenc) && !search_nonascii(ptr, ptr + len))) {
+        (eidx == rb_usascii_encindex()) ||
+        (rb_enc_asciicompat(eenc) && !search_nonascii(ptr, ptr + len))) {
         return rb_enc_str_new(ptr, len, ienc);
     }
     /* convert from the given encoding to default_internal */
@@ -1280,7 +1280,7 @@ rb_external_str_new_with_enc(const char *ptr, long len, rb_encoding *eenc)
     /* when the conversion failed for some reason, just ignore the
      * default_internal and result in the given encoding as-is. */
     if (NIL_P(rb_str_cat_conv_enc_opts(str, 0, ptr, len, eenc, 0, Qnil))) {
-	rb_str_initialize(str, ptr, len, eenc);
+        rb_str_initialize(str, ptr, len, eenc);
     }
     return str;
 }
@@ -1290,9 +1290,9 @@ rb_external_str_with_enc(VALUE str, rb_encoding *eenc)
 {
     int eidx = rb_enc_to_index(eenc);
     if (eidx == rb_usascii_encindex() &&
-	!is_ascii_string(str)) {
-	rb_enc_associate_index(str, rb_ascii8bit_encindex());
-	return str;
+        !is_ascii_string(str)) {
+        rb_enc_associate_index(str, rb_ascii8bit_encindex());
+        return str;
     }
     rb_enc_associate_index(str, eidx);
     return rb_str_conv_enc(str, eenc, rb_default_internal_encoding());
@@ -1362,10 +1362,10 @@ str_replace_shared_without_enc(VALUE str2, VALUE str)
     RSTRING_GETMEM(str, ptr, len);
     if (str_embed_capa(str2) >= len + termlen) {
         char *ptr2 = RSTRING(str2)->as.embed.ary;
-	STR_SET_EMBED(str2);
-	memcpy(ptr2, RSTRING_PTR(str), len);
-	STR_SET_EMBED_LEN(str2, len);
-	TERM_FILL(ptr2+len, termlen);
+        STR_SET_EMBED(str2);
+        memcpy(ptr2, RSTRING_PTR(str), len);
+        STR_SET_EMBED_LEN(str2, len);
+        TERM_FILL(ptr2+len, termlen);
     }
     else {
         VALUE root;
@@ -1387,9 +1387,9 @@ str_replace_shared_without_enc(VALUE str2, VALUE str)
                 ruby_sized_xfree(ptr2, STR_HEAP_SIZE(str2));
             }
         }
-	FL_SET(str2, STR_NOEMBED);
-	RSTRING(str2)->as.heap.len = len;
-	RSTRING(str2)->as.heap.ptr = ptr;
+        FL_SET(str2, STR_NOEMBED);
+        RSTRING(str2)->as.heap.len = len;
+        RSTRING(str2)->as.heap.ptr = ptr;
         STR_SET_SHARED(str2, root);
     }
     return str2;
@@ -1440,29 +1440,29 @@ void
 rb_str_tmp_frozen_release(VALUE orig, VALUE tmp)
 {
     if (RBASIC_CLASS(tmp) != 0)
-	return;
+        return;
 
     if (STR_EMBED_P(tmp)) {
-	assert(OBJ_FROZEN_RAW(tmp));
+        assert(OBJ_FROZEN_RAW(tmp));
     }
     else if (FL_TEST_RAW(orig, STR_SHARED) &&
-	    !FL_TEST_RAW(orig, STR_TMPLOCK|RUBY_FL_FREEZE)) {
-	VALUE shared = RSTRING(orig)->as.heap.aux.shared;
+            !FL_TEST_RAW(orig, STR_TMPLOCK|RUBY_FL_FREEZE)) {
+        VALUE shared = RSTRING(orig)->as.heap.aux.shared;
 
-	if (shared == tmp && !FL_TEST_RAW(tmp, STR_BORROWED)) {
+        if (shared == tmp && !FL_TEST_RAW(tmp, STR_BORROWED)) {
             assert(RSTRING(orig)->as.heap.ptr == RSTRING(tmp)->as.heap.ptr);
             assert(RSTRING(orig)->as.heap.len == RSTRING(tmp)->as.heap.len);
 
             /* Unshare orig since the root (tmp) only has this one child. */
-	    FL_UNSET_RAW(orig, STR_SHARED);
-	    RSTRING(orig)->as.heap.aux.capa = RSTRING(tmp)->as.heap.aux.capa;
-	    RBASIC(orig)->flags |= RBASIC(tmp)->flags & STR_NOFREE;
-	    assert(OBJ_FROZEN_RAW(tmp));
+            FL_UNSET_RAW(orig, STR_SHARED);
+            RSTRING(orig)->as.heap.aux.capa = RSTRING(tmp)->as.heap.aux.capa;
+            RBASIC(orig)->flags |= RBASIC(tmp)->flags & STR_NOFREE;
+            assert(OBJ_FROZEN_RAW(tmp));
 
             /* Make tmp embedded and empty so it is safe for sweeping. */
             STR_SET_EMBED(tmp);
             STR_SET_EMBED_LEN(tmp, 0);
-	}
+        }
     }
 }
 
@@ -1504,42 +1504,42 @@ str_new_frozen_buffer(VALUE klass, VALUE orig, int copy_encoding)
         assert(STR_EMBED_P(str));
     }
     else {
-	if (FL_TEST_RAW(orig, STR_SHARED)) {
-	    VALUE shared = RSTRING(orig)->as.heap.aux.shared;
+        if (FL_TEST_RAW(orig, STR_SHARED)) {
+            VALUE shared = RSTRING(orig)->as.heap.aux.shared;
             long ofs = RSTRING(orig)->as.heap.ptr - RSTRING_PTR(shared);
             long rest = RSTRING_LEN(shared) - ofs - RSTRING(orig)->as.heap.len;
             assert(ofs >= 0);
             assert(rest >= 0);
             assert(ofs + rest <= RSTRING_LEN(shared));
 #if !USE_RVARGC
-	    assert(!STR_EMBED_P(shared));
+            assert(!STR_EMBED_P(shared));
 #endif
-	    assert(OBJ_FROZEN(shared));
+            assert(OBJ_FROZEN(shared));
 
-	    if ((ofs > 0) || (rest > 0) ||
-		(klass != RBASIC(shared)->klass) ||
-		ENCODING_GET(shared) != ENCODING_GET(orig)) {
-		str = str_new_shared(klass, shared);
+            if ((ofs > 0) || (rest > 0) ||
+                (klass != RBASIC(shared)->klass) ||
+                ENCODING_GET(shared) != ENCODING_GET(orig)) {
+                str = str_new_shared(klass, shared);
                 assert(!STR_EMBED_P(str));
-		RSTRING(str)->as.heap.ptr += ofs;
-		RSTRING(str)->as.heap.len -= ofs + rest;
-	    }
-	    else {
-		if (RBASIC_CLASS(shared) == 0)
-		    FL_SET_RAW(shared, STR_BORROWED);
-		return shared;
-	    }
-	}
+                RSTRING(str)->as.heap.ptr += ofs;
+                RSTRING(str)->as.heap.len -= ofs + rest;
+            }
+            else {
+                if (RBASIC_CLASS(shared) == 0)
+                    FL_SET_RAW(shared, STR_BORROWED);
+                return shared;
+            }
+        }
         else if (STR_EMBEDDABLE_P(RSTRING_LEN(orig), TERM_LEN(orig))) {
             str = str_alloc_embed(klass, RSTRING_LEN(orig) + TERM_LEN(orig));
-	    STR_SET_EMBED(str);
-	    memcpy(RSTRING_PTR(str), RSTRING_PTR(orig), RSTRING_LEN(orig));
-	    STR_SET_EMBED_LEN(str, RSTRING_LEN(orig));
-	    TERM_FILL(RSTRING_END(str), TERM_LEN(orig));
-	}
-	else {
+            STR_SET_EMBED(str);
+            memcpy(RSTRING_PTR(str), RSTRING_PTR(orig), RSTRING_LEN(orig));
+            STR_SET_EMBED_LEN(str, RSTRING_LEN(orig));
+            TERM_FILL(RSTRING_END(str), TERM_LEN(orig));
+        }
+        else {
             str = heap_str_make_shared(klass, orig);
-	}
+        }
     }
 
     if (copy_encoding) rb_enc_cr_str_exact_copy(str, orig);
@@ -1577,7 +1577,7 @@ rb_str_buf_new(long capa)
 
 #if !USE_RVARGC
     if (capa < STR_BUF_MIN_SIZE) {
-	capa = STR_BUF_MIN_SIZE;
+        capa = STR_BUF_MIN_SIZE;
     }
 #endif
     FL_SET(str, STR_NOEMBED);
@@ -1610,7 +1610,7 @@ void
 rb_str_free(VALUE str)
 {
     if (FL_TEST(str, RSTRING_FSTR)) {
-	st_data_t fstr = (st_data_t)str;
+        st_data_t fstr = (st_data_t)str;
 
         RB_VM_LOCK_ENTER();
         {
@@ -1621,15 +1621,15 @@ rb_str_free(VALUE str)
     }
 
     if (STR_EMBED_P(str)) {
-	RB_DEBUG_COUNTER_INC(obj_str_embed);
+        RB_DEBUG_COUNTER_INC(obj_str_embed);
     }
     else if (FL_TEST(str, STR_SHARED | STR_NOFREE)) {
-	(void)RB_DEBUG_COUNTER_INC_IF(obj_str_shared, FL_TEST(str, STR_SHARED));
-	(void)RB_DEBUG_COUNTER_INC_IF(obj_str_shared, FL_TEST(str, STR_NOFREE));
+        (void)RB_DEBUG_COUNTER_INC_IF(obj_str_shared, FL_TEST(str, STR_SHARED));
+        (void)RB_DEBUG_COUNTER_INC_IF(obj_str_shared, FL_TEST(str, STR_NOFREE));
     }
     else {
-	RB_DEBUG_COUNTER_INC(obj_str_ptr);
-	ruby_sized_xfree(STR_HEAP_PTR(str), STR_HEAP_SIZE(str));
+        RB_DEBUG_COUNTER_INC(obj_str_ptr);
+        ruby_sized_xfree(STR_HEAP_PTR(str), STR_HEAP_SIZE(str));
     }
 }
 
@@ -1637,10 +1637,10 @@ RUBY_FUNC_EXPORTED size_t
 rb_str_memsize(VALUE str)
 {
     if (FL_TEST(str, STR_NOEMBED|STR_SHARED|STR_NOFREE) == STR_NOEMBED) {
-	return STR_HEAP_SIZE(str);
+        return STR_HEAP_SIZE(str);
     }
     else {
-	return 0;
+        return 0;
     }
 }
 
@@ -1673,9 +1673,9 @@ str_shared_replace(VALUE str, VALUE str2)
     termlen = rb_enc_mbminlen(enc);
 
     if (str_embed_capa(str) >= RSTRING_LEN(str2) + termlen) {
-	STR_SET_EMBED(str);
-	memcpy(RSTRING_PTR(str), RSTRING_PTR(str2), (size_t)RSTRING_LEN(str2) + termlen);
-	STR_SET_EMBED_LEN(str, RSTRING_LEN(str2));
+        STR_SET_EMBED(str);
+        memcpy(RSTRING_PTR(str), RSTRING_PTR(str2), (size_t)RSTRING_LEN(str2) + termlen);
+        STR_SET_EMBED_LEN(str, RSTRING_LEN(str2));
         rb_enc_associate(str, enc);
         ENC_CODERANGE_SET(str, cr);
     }
@@ -1695,25 +1695,25 @@ str_shared_replace(VALUE str, VALUE str2)
         }
 #endif
 
-	STR_SET_NOEMBED(str);
-	FL_UNSET(str, STR_SHARED);
-	RSTRING(str)->as.heap.ptr = RSTRING_PTR(str2);
-	RSTRING(str)->as.heap.len = RSTRING_LEN(str2);
+        STR_SET_NOEMBED(str);
+        FL_UNSET(str, STR_SHARED);
+        RSTRING(str)->as.heap.ptr = RSTRING_PTR(str2);
+        RSTRING(str)->as.heap.len = RSTRING_LEN(str2);
 
-	if (FL_TEST(str2, STR_SHARED)) {
-	    VALUE shared = RSTRING(str2)->as.heap.aux.shared;
-	    STR_SET_SHARED(str, shared);
-	}
-	else {
-	    RSTRING(str)->as.heap.aux.capa = RSTRING(str2)->as.heap.aux.capa;
-	}
+        if (FL_TEST(str2, STR_SHARED)) {
+            VALUE shared = RSTRING(str2)->as.heap.aux.shared;
+            STR_SET_SHARED(str, shared);
+        }
+        else {
+            RSTRING(str)->as.heap.aux.capa = RSTRING(str2)->as.heap.aux.capa;
+        }
 
-	/* abandon str2 */
-	STR_SET_EMBED(str2);
-	RSTRING_PTR(str2)[0] = 0;
-	STR_SET_EMBED_LEN(str2, 0);
-	rb_enc_associate(str, enc);
-	ENC_CODERANGE_SET(str, cr);
+        /* abandon str2 */
+        STR_SET_EMBED(str2);
+        RSTRING_PTR(str2)[0] = 0;
+        STR_SET_EMBED_LEN(str2, 0);
+        rb_enc_associate(str, enc);
+        ENC_CODERANGE_SET(str, cr);
     }
 }
 
@@ -1723,7 +1723,7 @@ rb_obj_as_string(VALUE obj)
     VALUE str;
 
     if (RB_TYPE_P(obj, T_STRING)) {
-	return obj;
+        return obj;
     }
     str = rb_funcall(obj, idTo_s, 0);
     return rb_obj_as_string_result(str, obj);
@@ -1733,7 +1733,7 @@ MJIT_FUNC_EXPORTED VALUE
 rb_obj_as_string_result(VALUE str, VALUE obj)
 {
     if (!RB_TYPE_P(str, T_STRING))
-	return rb_any_to_s(obj);
+        return rb_any_to_s(obj);
     return str;
 }
 
@@ -1744,16 +1744,16 @@ str_replace(VALUE str, VALUE str2)
 
     len = RSTRING_LEN(str2);
     if (STR_SHARED_P(str2)) {
-	VALUE shared = RSTRING(str2)->as.heap.aux.shared;
-	assert(OBJ_FROZEN(shared));
-	STR_SET_NOEMBED(str);
-	RSTRING(str)->as.heap.len = len;
-	RSTRING(str)->as.heap.ptr = RSTRING_PTR(str2);
-	STR_SET_SHARED(str, shared);
-	rb_enc_cr_str_exact_copy(str, str2);
+        VALUE shared = RSTRING(str2)->as.heap.aux.shared;
+        assert(OBJ_FROZEN(shared));
+        STR_SET_NOEMBED(str);
+        RSTRING(str)->as.heap.len = len;
+        RSTRING(str)->as.heap.ptr = RSTRING_PTR(str2);
+        STR_SET_SHARED(str, shared);
+        rb_enc_cr_str_exact_copy(str, str2);
     }
     else {
-	str_replace_shared(str, str2);
+        str_replace_shared(str, str2);
     }
 
     return str;
@@ -1790,11 +1790,11 @@ str_duplicate_setup(VALUE klass, VALUE str, VALUE dup)
 {
     const VALUE flag_mask =
 #if !USE_RVARGC
-	RSTRING_NOEMBED | RSTRING_EMBED_LEN_MASK |
+        RSTRING_NOEMBED | RSTRING_EMBED_LEN_MASK |
 #endif
         ENC_CODERANGE_MASK | ENCODING_MASK |
         FL_FREEZE
-	;
+        ;
     VALUE flags = FL_TEST_RAW(str, flag_mask);
     int encidx = 0;
     if (STR_EMBED_P(str)) {
@@ -1831,8 +1831,8 @@ str_duplicate_setup(VALUE klass, VALUE str, VALUE dup)
     }
 
     if ((flags & ENCODING_MASK) == (ENCODING_INLINE_MAX<<ENCODING_SHIFT)) {
-	encidx = rb_enc_get_index(str);
-	flags &= ~ENCODING_MASK;
+        encidx = rb_enc_get_index(str);
+        flags &= ~ENCODING_MASK;
     }
     FL_SET_RAW(dup, flags & ~FL_FREEZE);
     if (encidx) rb_enc_associate_index(dup, encidx);
@@ -1906,36 +1906,36 @@ rb_str_init(int argc, VALUE *argv, VALUE str)
     int n;
 
     if (!keyword_ids[0]) {
-	keyword_ids[0] = rb_id_encoding();
-	CONST_ID(keyword_ids[1], "capacity");
+        keyword_ids[0] = rb_id_encoding();
+        CONST_ID(keyword_ids[1], "capacity");
     }
 
     n = rb_scan_args(argc, argv, "01:", &orig, &opt);
     if (!NIL_P(opt)) {
-	rb_get_kwargs(opt, keyword_ids, 0, 2, kwargs);
-	venc = kwargs[0];
-	vcapa = kwargs[1];
-	if (venc != Qundef && !NIL_P(venc)) {
-	    enc = rb_to_encoding(venc);
-	}
-	if (vcapa != Qundef && !NIL_P(vcapa)) {
-	    long capa = NUM2LONG(vcapa);
-	    long len = 0;
-	    int termlen = enc ? rb_enc_mbminlen(enc) : 1;
-
-	    if (capa < STR_BUF_MIN_SIZE) {
-		capa = STR_BUF_MIN_SIZE;
-	    }
-	    if (n == 1) {
-		StringValue(orig);
-		len = RSTRING_LEN(orig);
-		if (capa < len) {
-		    capa = len;
-		}
-		if (orig == str) n = 0;
-	    }
-	    str_modifiable(str);
-	    if (STR_EMBED_P(str)) { /* make noembed always */
+        rb_get_kwargs(opt, keyword_ids, 0, 2, kwargs);
+        venc = kwargs[0];
+        vcapa = kwargs[1];
+        if (venc != Qundef && !NIL_P(venc)) {
+            enc = rb_to_encoding(venc);
+        }
+        if (vcapa != Qundef && !NIL_P(vcapa)) {
+            long capa = NUM2LONG(vcapa);
+            long len = 0;
+            int termlen = enc ? rb_enc_mbminlen(enc) : 1;
+
+            if (capa < STR_BUF_MIN_SIZE) {
+                capa = STR_BUF_MIN_SIZE;
+            }
+            if (n == 1) {
+                StringValue(orig);
+                len = RSTRING_LEN(orig);
+                if (capa < len) {
+                    capa = len;
+                }
+                if (orig == str) n = 0;
+            }
+            str_modifiable(str);
+            if (STR_EMBED_P(str)) { /* make noembed always */
                 char *new_ptr = ALLOC_N(char, (size_t)capa + termlen);
 #if USE_RVARGC
                 assert(RSTRING(str)->as.embed.len + 1 <= str_embed_capa(str));
@@ -1953,30 +1953,30 @@ rb_str_init(int argc, VALUE *argv, VALUE str)
                 memcpy(new_ptr, old_ptr, osize < size ? osize : size);
                 FL_UNSET_RAW(str, STR_SHARED|STR_NOFREE);
                 RSTRING(str)->as.heap.ptr = new_ptr;
-	    }
-	    else if (STR_HEAP_SIZE(str) != (size_t)capa + termlen) {
-		SIZED_REALLOC_N(RSTRING(str)->as.heap.ptr, char,
-			(size_t)capa + termlen, STR_HEAP_SIZE(str));
-	    }
-	    RSTRING(str)->as.heap.len = len;
-	    TERM_FILL(&RSTRING(str)->as.heap.ptr[len], termlen);
-	    if (n == 1) {
-		memcpy(RSTRING(str)->as.heap.ptr, RSTRING_PTR(orig), len);
-		rb_enc_cr_str_exact_copy(str, orig);
-	    }
-	    FL_SET(str, STR_NOEMBED);
-	    RSTRING(str)->as.heap.aux.capa = capa;
-	}
-	else if (n == 1) {
-	    rb_str_replace(str, orig);
-	}
-	if (enc) {
-	    rb_enc_associate(str, enc);
-	    ENC_CODERANGE_CLEAR(str);
-	}
+            }
+            else if (STR_HEAP_SIZE(str) != (size_t)capa + termlen) {
+                SIZED_REALLOC_N(RSTRING(str)->as.heap.ptr, char,
+                        (size_t)capa + termlen, STR_HEAP_SIZE(str));
+            }
+            RSTRING(str)->as.heap.len = len;
+            TERM_FILL(&RSTRING(str)->as.heap.ptr[len], termlen);
+            if (n == 1) {
+                memcpy(RSTRING(str)->as.heap.ptr, RSTRING_PTR(orig), len);
+                rb_enc_cr_str_exact_copy(str, orig);
+            }
+            FL_SET(str, STR_NOEMBED);
+            RSTRING(str)->as.heap.aux.capa = capa;
+        }
+        else if (n == 1) {
+            rb_str_replace(str, orig);
+        }
+        if (enc) {
+            rb_enc_associate(str, enc);
+            ENC_CODERANGE_CLEAR(str);
+        }
     }
     else if (n == 1) {
-	rb_str_replace(str, orig);
+        rb_str_replace(str, orig);
     }
     return str;
 }
@@ -2028,62 +2028,62 @@ enc_strlen(const char *p, const char *e, rb_encoding *enc, int cr)
     const char *q;
 
     if (rb_enc_mbmaxlen(enc) == rb_enc_mbminlen(enc)) {
-	long diff = (long)(e - p);
-	return diff / rb_enc_mbminlen(enc) + !!(diff % rb_enc_mbminlen(enc));
+        long diff = (long)(e - p);
+        return diff / rb_enc_mbminlen(enc) + !!(diff % rb_enc_mbminlen(enc));
     }
 #ifdef NONASCII_MASK
     else if (cr == ENC_CODERANGE_VALID && enc == rb_utf8_encoding()) {
-	uintptr_t len = 0;
-	if ((int)sizeof(uintptr_t) * 2 < e - p) {
-	    const uintptr_t *s, *t;
-	    const uintptr_t lowbits = sizeof(uintptr_t) - 1;
-	    s = (const uintptr_t*)(~lowbits & ((uintptr_t)p + lowbits));
-	    t = (const uintptr_t*)(~lowbits & (uintptr_t)e);
-	    while (p < (const char *)s) {
-		if (is_utf8_lead_byte(*p)) len++;
-		p++;
-	    }
-	    while (s < t) {
-		len += count_utf8_lead_bytes_with_word(s);
-		s++;
-	    }
-	    p = (const char *)s;
-	}
-	while (p < e) {
-	    if (is_utf8_lead_byte(*p)) len++;
-	    p++;
-	}
-	return (long)len;
+        uintptr_t len = 0;
+        if ((int)sizeof(uintptr_t) * 2 < e - p) {
+            const uintptr_t *s, *t;
+            const uintptr_t lowbits = sizeof(uintptr_t) - 1;
+            s = (const uintptr_t*)(~lowbits & ((uintptr_t)p + lowbits));
+            t = (const uintptr_t*)(~lowbits & (uintptr_t)e);
+            while (p < (const char *)s) {
+                if (is_utf8_lead_byte(*p)) len++;
+                p++;
+            }
+            while (s < t) {
+                len += count_utf8_lead_bytes_with_word(s);
+                s++;
+            }
+            p = (const char *)s;
+        }
+        while (p < e) {
+            if (is_utf8_lead_byte(*p)) len++;
+            p++;
+        }
+        return (long)len;
     }
 #endif
     else if (rb_enc_asciicompat(enc)) {
         c = 0;
-	if (ENC_CODERANGE_CLEAN_P(cr)) {
-	    while (p < e) {
-		if (ISASCII(*p)) {
-		    q = search_nonascii(p, e);
-		    if (!q)
-			return c + (e - p);
-		    c += q - p;
-		    p = q;
-		}
-		p += rb_enc_fast_mbclen(p, e, enc);
-		c++;
-	    }
-	}
-	else {
-	    while (p < e) {
-		if (ISASCII(*p)) {
-		    q = search_nonascii(p, e);
-		    if (!q)
-			return c + (e - p);
-		    c += q - p;
-		    p = q;
-		}
-		p += rb_enc_mbclen(p, e, enc);
-		c++;
-	    }
-	}
+        if (ENC_CODERANGE_CLEAN_P(cr)) {
+            while (p < e) {
+                if (ISASCII(*p)) {
+                    q = search_nonascii(p, e);
+                    if (!q)
+                        return c + (e - p);
+                    c += q - p;
+                    p = q;
+                }
+                p += rb_enc_fast_mbclen(p, e, enc);
+                c++;
+            }
+        }
+        else {
+            while (p < e) {
+                if (ISASCII(*p)) {
+                    q = search_nonascii(p, e);
+                    if (!q)
+                        return c + (e - p);
+                    c += q - p;
+                    p = q;
+                }
+                p += rb_enc_mbclen(p, e, enc);
+                c++;
+            }
+        }
         return c;
     }
 
@@ -2111,49 +2111,49 @@ rb_enc_strlen_cr(const char *p, const char *e, rb_encoding *enc, int *cr)
 
     *cr = 0;
     if (rb_enc_mbmaxlen(enc) == rb_enc_mbminlen(enc)) {
-	long diff = (long)(e - p);
-	return diff / rb_enc_mbminlen(enc) + !!(diff % rb_enc_mbminlen(enc));
+        long diff = (long)(e - p);
+        return diff / rb_enc_mbminlen(enc) + !!(diff % rb_enc_mbminlen(enc));
     }
     else if (rb_enc_asciicompat(enc)) {
-	c = 0;
-	while (p < e) {
-	    if (ISASCII(*p)) {
-		q = search_nonascii(p, e);
-		if (!q) {
-		    if (!*cr) *cr = ENC_CODERANGE_7BIT;
-		    return c + (e - p);
-		}
-		c += q - p;
-		p = q;
-	    }
-	    ret = rb_enc_precise_mbclen(p, e, enc);
-	    if (MBCLEN_CHARFOUND_P(ret)) {
-		*cr |= ENC_CODERANGE_VALID;
-		p += MBCLEN_CHARFOUND_LEN(ret);
-	    }
-	    else {
-		*cr = ENC_CODERANGE_BROKEN;
-		p++;
-	    }
-	    c++;
-	}
-	if (!*cr) *cr = ENC_CODERANGE_7BIT;
-	return c;
+        c = 0;
+        while (p < e) {
+            if (ISASCII(*p)) {
+                q = search_nonascii(p, e);
+                if (!q) {
+                    if (!*cr) *cr = ENC_CODERANGE_7BIT;
+                    return c + (e - p);
+                }
+                c += q - p;
+                p = q;
+            }
+            ret = rb_enc_precise_mbclen(p, e, enc);
+            if (MBCLEN_CHARFOUND_P(ret)) {
+                *cr |= ENC_CODERANGE_VALID;
+                p += MBCLEN_CHARFOUND_LEN(ret);
+            }
+            else {
+                *cr = ENC_CODERANGE_BROKEN;
+                p++;
+            }
+            c++;
+        }
+        if (!*cr) *cr = ENC_CODERANGE_7BIT;
+        return c;
     }
 
     for (c=0; p<e; c++) {
-	ret = rb_enc_precise_mbclen(p, e, enc);
-	if (MBCLEN_CHARFOUND_P(ret)) {
-	    *cr |= ENC_CODERANGE_VALID;
-	    p += MBCLEN_CHARFOUND_LEN(ret);
-	}
-	else {
-	    *cr = ENC_CODERANGE_BROKEN;
+        ret = rb_enc_precise_mbclen(p, e, enc);
+        if (MBCLEN_CHARFOUND_P(ret)) {
+            *cr |= ENC_CODERANGE_VALID;
+            p += MBCLEN_CHARFOUND_LEN(ret);
+        }
+        else {
+            *cr = ENC_CODERANGE_BROKEN;
             if (p + rb_enc_mbminlen(enc) <= e)
                 p += rb_enc_mbminlen(enc);
             else
                 p = e;
-	}
+        }
     }
     if (!*cr) *cr = ENC_CODERANGE_7BIT;
     return c;
@@ -2173,12 +2173,12 @@ str_strlen(VALUE str, rb_encoding *enc)
     cr = ENC_CODERANGE(str);
 
     if (cr == ENC_CODERANGE_UNKNOWN) {
-	long n = rb_enc_strlen_cr(p, e, enc, &cr);
-	if (cr) ENC_CODERANGE_SET(str, cr);
-	return n;
+        long n = rb_enc_strlen_cr(p, e, enc, &cr);
+        if (cr) ENC_CODERANGE_SET(str, cr);
+        return n;
     }
     else {
-	return enc_strlen(p, e, enc, cr);
+        return enc_strlen(p, e, enc, cr);
     }
 }
 
@@ -2259,7 +2259,7 @@ rb_str_plus(VALUE str1, VALUE str2)
     RSTRING_GETMEM(str2, ptr2, len2);
     termlen = rb_enc_mbminlen(enc);
     if (len1 > LONG_MAX - len2) {
-	rb_raise(rb_eArgError, "string size too big");
+        rb_raise(rb_eArgError, "string size too big");
     }
     str3 = str_new0(rb_cString, 0, len1+len2, termlen);
     ptr3 = RSTRING_PTR(str3);
@@ -2268,7 +2268,7 @@ rb_str_plus(VALUE str1, VALUE str2)
     TERM_FILL(&ptr3[len1+len2], termlen);
 
     ENCODING_CODERANGE_SET(str3, rb_enc_to_index(enc),
-			   ENC_CODERANGE_AND(ENC_CODERANGE(str1), ENC_CODERANGE(str2)));
+                           ENC_CODERANGE_AND(ENC_CODERANGE(str1), ENC_CODERANGE(str2)));
     RB_GC_GUARD(str1);
     RB_GC_GUARD(str2);
     return str3;
@@ -2329,12 +2329,12 @@ rb_str_times(VALUE str, VALUE times)
     }
     if (times == INT2FIX(0)) {
         str2 = str_alloc_embed(rb_cString, 0);
-	rb_enc_copy(str2, str);
-	return str2;
+        rb_enc_copy(str2, str);
+        return str2;
     }
     len = NUM2LONG(times);
     if (len < 0) {
-	rb_raise(rb_eArgError, "negative argument");
+        rb_raise(rb_eArgError, "negative argument");
     }
     if (RSTRING_LEN(str) == 1 && RSTRING_PTR(str)[0] == 0) {
         if (STR_EMBEDDABLE_P(len, 1)) {
@@ -2352,7 +2352,7 @@ rb_str_times(VALUE str, VALUE times)
         return str2;
     }
     if (len && LONG_MAX/len <  RSTRING_LEN(str)) {
-	rb_raise(rb_eArgError, "argument too big");
+        rb_raise(rb_eArgError, "argument too big");
     }
 
     len *= RSTRING_LEN(str);
@@ -2408,7 +2408,7 @@ static inline void
 rb_check_lockedtmp(VALUE str)
 {
     if (FL_TEST(str, STR_TMPLOCK)) {
-	rb_raise(rb_eRuntimeError, "can't modify string; temporarily locked");
+        rb_raise(rb_eRuntimeError, "can't modify string; temporarily locked");
     }
 }
 
@@ -2423,10 +2423,10 @@ static inline int
 str_dependent_p(VALUE str)
 {
     if (STR_EMBED_P(str) || !FL_TEST(str, STR_SHARED|STR_NOFREE)) {
-	return 0;
+        return 0;
     }
     else {
-	return 1;
+        return 1;
     }
 }
 
@@ -2447,18 +2447,18 @@ str_make_independent_expand(VALUE str, long len, long expand, const int termlen)
     if (len > capa) len = capa;
 
     if (!STR_EMBED_P(str) && str_embed_capa(str) >= capa + termlen) {
-	ptr = RSTRING(str)->as.heap.ptr;
-	STR_SET_EMBED(str);
+        ptr = RSTRING(str)->as.heap.ptr;
+        STR_SET_EMBED(str);
         memcpy(RSTRING(str)->as.embed.ary, ptr, len);
         TERM_FILL(RSTRING(str)->as.embed.ary + len, termlen);
-	STR_SET_EMBED_LEN(str, len);
-	return;
+        STR_SET_EMBED_LEN(str, len);
+        return;
     }
 
     ptr = ALLOC_N(char, (size_t)capa + termlen);
     oldptr = RSTRING_PTR(str);
     if (oldptr) {
-	memcpy(ptr, oldptr, len);
+        memcpy(ptr, oldptr, len);
     }
     if (FL_TEST_RAW(str, STR_NOEMBED|STR_NOFREE|STR_SHARED) == STR_NOEMBED) {
         xfree(oldptr);
@@ -2475,7 +2475,7 @@ void
 rb_str_modify(VALUE str)
 {
     if (!str_independent(str))
-	str_make_independent(str);
+        str_make_independent(str);
     ENC_CODERANGE_CLEAR(str);
 }
 
@@ -2486,17 +2486,17 @@ rb_str_modify_expand(VALUE str, long expand)
     long len = RSTRING_LEN(str);
 
     if (expand < 0) {
-	rb_raise(rb_eArgError, "negative expanding string size");
+        rb_raise(rb_eArgError, "negative expanding string size");
     }
     if (expand >= LONG_MAX - len) {
-	rb_raise(rb_eArgError, "string size too big");
+        rb_raise(rb_eArgError, "string size too big");
     }
 
     if (!str_independent(str)) {
-	str_make_independent_expand(str, len, expand, termlen);
+        str_make_independent_expand(str, len, expand, termlen);
     }
     else if (expand > 0) {
-	RESIZE_CAPA_TERM(str, len + expand, termlen);
+        RESIZE_CAPA_TERM(str, len + expand, termlen);
     }
     ENC_CODERANGE_CLEAR(str);
 }
@@ -2506,10 +2506,10 @@ static void
 str_modify_keep_cr(VALUE str)
 {
     if (!str_independent(str))
-	str_make_independent(str);
+        str_make_independent(str);
     if (ENC_CODERANGE(str) == ENC_CODERANGE_BROKEN)
-	/* Force re-scan later */
-	ENC_CODERANGE_CLEAR(str);
+        /* Force re-scan later */
+        ENC_CODERANGE_CLEAR(str);
 }
 
 static inline void
@@ -2517,9 +2517,9 @@ str_discard(VALUE str)
 {
     str_modifiable(str);
     if (!STR_EMBED_P(str) && !FL_TEST(str, STR_SHARED|STR_NOFREE)) {
-	ruby_sized_xfree(STR_HEAP_PTR(str), STR_HEAP_SIZE(str));
-	RSTRING(str)->as.heap.ptr = 0;
-	RSTRING(str)->as.heap.len = 0;
+        ruby_sized_xfree(STR_HEAP_PTR(str), STR_HEAP_SIZE(str));
+        RSTRING(str)->as.heap.ptr = 0;
+        RSTRING(str)->as.heap.len = 0;
     }
 }
 
@@ -2528,7 +2528,7 @@ rb_must_asciicompat(VALUE str)
 {
     rb_encoding *enc = rb_enc_get(str);
     if (!rb_enc_asciicompat(enc)) {
-	rb_raise(rb_eEncCompatError, "ASCII incompatible encoding: %s", rb_enc_name(enc));
+        rb_raise(rb_eEncCompatError, "ASCII incompatible encoding: %s", rb_enc_name(enc));
     }
 }
 
@@ -2537,8 +2537,8 @@ rb_string_value(volatile VALUE *ptr)
 {
     VALUE s = *ptr;
     if (!RB_TYPE_P(s, T_STRING)) {
-	s = rb_str_to_str(s);
-	*ptr = s;
+        s = rb_str_to_str(s);
+        *ptr = s;
     }
     return s;
 }
@@ -2554,7 +2554,7 @@ static int
 zero_filled(const char *s, int n)
 {
     for (; n > 0; --n) {
-	if (*s++) return 0;
+        if (*s++) return 0;
     }
     return 1;
 }
@@ -2565,7 +2565,7 @@ str_null_char(const char *s, long len, const int minlen, rb_encoding *enc)
     const char *e = s + len;
 
     for (; s + minlen <= e; s += rb_enc_mbclen(s, e, enc)) {
-	if (zero_filled(s, minlen)) return s;
+        if (zero_filled(s, minlen)) return s;
     }
     return 0;
 }
@@ -2577,12 +2577,12 @@ str_fill_term(VALUE str, char *s, long len, int termlen)
      * is allocated, like many other functions in this file.
      */
     if (str_dependent_p(str)) {
-	if (!zero_filled(s + len, termlen))
-	    str_make_independent_expand(str, len, 0L, termlen);
+        if (!zero_filled(s + len, termlen))
+            str_make_independent_expand(str, len, 0L, termlen);
     }
     else {
-	TERM_FILL(s + len, termlen);
-	return s;
+        TERM_FILL(s + len, termlen);
+        return s;
     }
     return RSTRING_PTR(str);
 }
@@ -2595,22 +2595,22 @@ rb_str_change_terminator_length(VALUE str, const int oldtermlen, const int terml
 
     assert(capa >= len);
     if (capa - len < termlen) {
-	rb_check_lockedtmp(str);
-	str_make_independent_expand(str, len, 0L, termlen);
+        rb_check_lockedtmp(str);
+        str_make_independent_expand(str, len, 0L, termlen);
     }
     else if (str_dependent_p(str)) {
-	if (termlen > oldtermlen)
-	    str_make_independent_expand(str, len, 0L, termlen);
+        if (termlen > oldtermlen)
+            str_make_independent_expand(str, len, 0L, termlen);
     }
     else {
-	if (!STR_EMBED_P(str)) {
-	    /* modify capa instead of realloc */
-	    assert(!FL_TEST((str), STR_SHARED));
-	    RSTRING(str)->as.heap.aux.capa = capa - termlen;
-	}
-	if (termlen > oldtermlen) {
-	    TERM_FILL(RSTRING_PTR(str) + len, termlen);
-	}
+        if (!STR_EMBED_P(str)) {
+            /* modify capa instead of realloc */
+            assert(!FL_TEST((str), STR_SHARED));
+            RSTRING(str)->as.heap.aux.capa = capa - termlen;
+        }
+        if (termlen > oldtermlen) {
+            TERM_FILL(RSTRING_PTR(str) + len, termlen);
+        }
     }
 
     return;
@@ -2625,18 +2625,18 @@ str_null_check(VALUE str, int *w)
     const int minlen = rb_enc_mbminlen(enc);
 
     if (minlen > 1) {
-	*w = 1;
-	if (str_null_char(s, len, minlen, enc)) {
-	    return NULL;
-	}
-	return str_fill_term(str, s, len, minlen);
+        *w = 1;
+        if (str_null_char(s, len, minlen, enc)) {
+            return NULL;
+        }
+        return str_fill_term(str, s, len, minlen);
     }
     *w = 0;
     if (!s || memchr(s, 0, len)) {
-	return NULL;
+        return NULL;
     }
     if (s[len]) {
-	s = str_fill_term(str, s, len, minlen);
+        s = str_fill_term(str, s, len, minlen);
     }
     return s;
 }
@@ -2655,10 +2655,10 @@ rb_string_value_cstr(volatile VALUE *ptr)
     int w;
     char *s = str_null_check(str, &w);
     if (!s) {
-	if (w) {
-	    rb_raise(rb_eArgError, "string contains null char");
-	}
-	rb_raise(rb_eArgError, "string contains null byte");
+        if (w) {
+            rb_raise(rb_eArgError, "string contains null char");
+        }
+        rb_raise(rb_eArgError, "string contains null byte");
     }
     return s;
 }
@@ -2720,8 +2720,8 @@ str_nth_len(const char *p, const char *e, long *nthp, rb_encoding *enc)
             if (ISASCII(*p)) {
                 p2 = search_nonascii(p, e2);
                 if (!p2) {
-		    nth -= e2 - p;
-		    *nthp = nth;
+                    nth -= e2 - p;
+                    *nthp = nth;
                     return (char *)e2;
                 }
                 nth -= p2 - p;
@@ -2757,9 +2757,9 @@ static char*
 str_nth(const char *p, const char *e, long nth, rb_encoding *enc, int singlebyte)
 {
     if (singlebyte)
-	p += nth;
+        p += nth;
     else {
-	p = str_nth_len(p, e, &nth, enc);
+        p = str_nth_len(p, e, &nth, enc);
     }
     if (!p) return 0;
     if (p > e) p = e;
@@ -2779,7 +2779,7 @@ long
 rb_str_offset(VALUE str, long pos)
 {
     return str_offset(RSTRING_PTR(str), RSTRING_END(str), pos,
-		      STR_ENC_GET(str), single_byte_optimizable(str));
+                      STR_ENC_GET(str), single_byte_optimizable(str));
 }
 
 #ifdef NONASCII_MASK
@@ -2788,26 +2788,26 @@ str_utf8_nth(const char *p, const char *e, long *nthp)
 {
     long nth = *nthp;
     if ((int)SIZEOF_VOIDP * 2 < e - p && (int)SIZEOF_VOIDP * 2 < nth) {
-	const uintptr_t *s, *t;
-	const uintptr_t lowbits = SIZEOF_VOIDP - 1;
-	s = (const uintptr_t*)(~lowbits & ((uintptr_t)p + lowbits));
-	t = (const uintptr_t*)(~lowbits & (uintptr_t)e);
-	while (p < (const char *)s) {
-	    if (is_utf8_lead_byte(*p)) nth--;
-	    p++;
-	}
-	do {
-	    nth -= count_utf8_lead_bytes_with_word(s);
-	    s++;
-	} while (s < t && (int)SIZEOF_VOIDP <= nth);
-	p = (char *)s;
+        const uintptr_t *s, *t;
+        const uintptr_t lowbits = SIZEOF_VOIDP - 1;
+        s = (const uintptr_t*)(~lowbits & ((uintptr_t)p + lowbits));
+        t = (const uintptr_t*)(~lowbits & (uintptr_t)e);
+        while (p < (const char *)s) {
+            if (is_utf8_lead_byte(*p)) nth--;
+            p++;
+        }
+        do {
+            nth -= count_utf8_lead_bytes_with_word(s);
+            s++;
+        } while (s < t && (int)SIZEOF_VOIDP <= nth);
+        p = (char *)s;
     }
     while (p < e) {
-	if (is_utf8_lead_byte(*p)) {
-	    if (nth == 0) break;
-	    nth--;
-	}
-	p++;
+        if (is_utf8_lead_byte(*p)) {
+            if (nth == 0) break;
+            nth--;
+        }
+        p++;
     }
     *nthp = nth;
     return (char *)p;
@@ -2828,7 +2828,7 @@ rb_str_sublen(VALUE str, long pos)
     if (single_byte_optimizable(str) || pos < 0)
         return pos;
     else {
-	char *p = RSTRING_PTR(str);
+        char *p = RSTRING_PTR(str);
         return enc_strlen(p, p + pos, STR_ENC_GET(str), ENC_CODERANGE(str));
     }
 }
@@ -2839,12 +2839,12 @@ rb_str_subseq(VALUE str, long beg, long len)
     VALUE str2;
 
     if (!STR_EMBEDDABLE_P(len, TERM_LEN(str)) &&
-	SHARABLE_SUBSTRING_P(beg, len, RSTRING_LEN(str))) {
-	long olen;
+        SHARABLE_SUBSTRING_P(beg, len, RSTRING_LEN(str))) {
+        long olen;
         str2 = rb_str_new_shared(rb_str_new_frozen_String(str));
-	RSTRING(str2)->as.heap.ptr += beg;
-	olen = RSTRING(str2)->as.heap.len;
-	if (olen > len) RSTRING(str2)->as.heap.len = len;
+        RSTRING(str2)->as.heap.ptr += beg;
+        olen = RSTRING(str2)->as.heap.len;
+        if (olen > len) RSTRING(str2)->as.heap.len = len;
     }
     else {
         str2 = rb_str_new(RSTRING_PTR(str)+beg, len);
@@ -2867,46 +2867,46 @@ rb_str_subpos(VALUE str, long beg, long *lenp)
 
     if (len < 0) return 0;
     if (!blen) {
-	len = 0;
+        len = 0;
     }
     if (single_byte_optimizable(str)) {
-	if (beg > blen) return 0;
-	if (beg < 0) {
-	    beg += blen;
-	    if (beg < 0) return 0;
-	}
-	if (len > blen - beg)
-	    len = blen - beg;
-	if (len < 0) return 0;
-	p = s + beg;
-	goto end;
+        if (beg > blen) return 0;
+        if (beg < 0) {
+            beg += blen;
+            if (beg < 0) return 0;
+        }
+        if (len > blen - beg)
+            len = blen - beg;
+        if (len < 0) return 0;
+        p = s + beg;
+        goto end;
     }
     if (beg < 0) {
-	if (len > -beg) len = -beg;
-	if (-beg * rb_enc_mbmaxlen(enc) < RSTRING_LEN(str) / 8) {
-	    beg = -beg;
-	    while (beg-- > len && (e = rb_enc_prev_char(s, e, e, enc)) != 0);
-	    p = e;
-	    if (!p) return 0;
-	    while (len-- > 0 && (p = rb_enc_prev_char(s, p, e, enc)) != 0);
-	    if (!p) return 0;
-	    len = e - p;
-	    goto end;
-	}
-	else {
-	    slen = str_strlen(str, enc);
-	    beg += slen;
-	    if (beg < 0) return 0;
-	    p = s + beg;
-	    if (len == 0) goto end;
-	}
+        if (len > -beg) len = -beg;
+        if (-beg * rb_enc_mbmaxlen(enc) < RSTRING_LEN(str) / 8) {
+            beg = -beg;
+            while (beg-- > len && (e = rb_enc_prev_char(s, e, e, enc)) != 0);
+            p = e;
+            if (!p) return 0;
+            while (len-- > 0 && (p = rb_enc_prev_char(s, p, e, enc)) != 0);
+            if (!p) return 0;
+            len = e - p;
+            goto end;
+        }
+        else {
+            slen = str_strlen(str, enc);
+            beg += slen;
+            if (beg < 0) return 0;
+            p = s + beg;
+            if (len == 0) goto end;
+        }
     }
     else if (beg > 0 && beg > RSTRING_LEN(str)) {
-	return 0;
+        return 0;
     }
     if (len == 0) {
-	if (beg > str_strlen(str, enc)) return 0; /* str's enc */
-	p = s + beg;
+        if (beg > str_strlen(str, enc)) return 0; /* str's enc */
+        p = s + beg;
     }
 #ifdef NONASCII_MASK
     else if (ENC_CODERANGE(str) == ENC_CODERANGE_VALID &&
@@ -2917,23 +2917,23 @@ rb_str_subpos(VALUE str, long beg, long *lenp)
     }
 #endif
     else if (rb_enc_mbmaxlen(enc) == rb_enc_mbminlen(enc)) {
-	int char_sz = rb_enc_mbmaxlen(enc);
+        int char_sz = rb_enc_mbmaxlen(enc);
 
-	p = s + beg * char_sz;
-	if (p > e) {
-	    return 0;
-	}
+        p = s + beg * char_sz;
+        if (p > e) {
+            return 0;
+        }
         else if (len * char_sz > e - p)
             len = e - p;
         else
-	    len *= char_sz;
+            len *= char_sz;
     }
     else if ((p = str_nth_len(s, e, &beg, enc)) == e) {
-	if (beg > 0) return 0;
-	len = 0;
+        if (beg > 0) return 0;
+        len = 0;
     }
     else {
-	len = str_offset(p, e, len, enc, 0);
+        len = str_offset(p, e, len, enc, 0);
     }
   end:
     *lenp = len;
@@ -2957,18 +2957,18 @@ str_substr(VALUE str, long beg, long len, int empty)
 
     if (!p) return Qnil;
     if (!STR_EMBEDDABLE_P(len, TERM_LEN(str)) &&
-	SHARABLE_SUBSTRING_P(p, len, RSTRING_END(str))) {
-	long ofs = p - RSTRING_PTR(str);
-	str2 = rb_str_new_frozen(str);
+        SHARABLE_SUBSTRING_P(p, len, RSTRING_END(str))) {
+        long ofs = p - RSTRING_PTR(str);
+        str2 = rb_str_new_frozen(str);
         str2 = str_new_shared(rb_cString, str2);
-	RSTRING(str2)->as.heap.ptr += ofs;
-	RSTRING(str2)->as.heap.len = len;
-	ENC_CODERANGE_CLEAR(str2);
+        RSTRING(str2)->as.heap.ptr += ofs;
+        RSTRING(str2)->as.heap.len = len;
+        ENC_CODERANGE_CLEAR(str2);
     }
     else {
-	if (!len && !empty) return Qnil;
+        if (!len && !empty) return Qnil;
         str2 = rb_str_new(p, len);
-	RB_GC_GUARD(str);
+        RB_GC_GUARD(str);
     }
     rb_enc_cr_str_copy_for_substr(str2, str);
 
@@ -2996,10 +2996,10 @@ static VALUE
 str_uplus(VALUE str)
 {
     if (OBJ_FROZEN(str)) {
-	return rb_str_dup(str);
+        return rb_str_dup(str);
     }
     else {
-	return str;
+        return str;
     }
 }
 
@@ -3030,7 +3030,7 @@ VALUE
 rb_str_locktmp(VALUE str)
 {
     if (FL_TEST(str, STR_TMPLOCK)) {
-	rb_raise(rb_eRuntimeError, "temporal locking already locked string");
+        rb_raise(rb_eRuntimeError, "temporal locking already locked string");
     }
     FL_SET(str, STR_TMPLOCK);
     return str;
@@ -3040,7 +3040,7 @@ VALUE
 rb_str_unlocktmp(VALUE str)
 {
     if (!FL_TEST(str, STR_TMPLOCK)) {
-	rb_raise(rb_eRuntimeError, "temporal unlocking already unlocked string");
+        rb_raise(rb_eRuntimeError, "temporal unlocking already unlocked string");
     }
     FL_UNSET(str, STR_TMPLOCK);
     return str;
@@ -3061,10 +3061,10 @@ rb_str_set_len(VALUE str, long len)
 
     str_modifiable(str);
     if (STR_SHARED_P(str)) {
-	rb_raise(rb_eRuntimeError, "can't set length of shared string");
+        rb_raise(rb_eRuntimeError, "can't set length of shared string");
     }
     if (len > (capa = (long)str_capacity(str, termlen)) || len < 0) {
-	rb_bug("probable buffer overflow: %ld for %ld", len, capa);
+        rb_bug("probable buffer overflow: %ld for %ld", len, capa);
     }
     STR_SET_LEN(str, len);
     TERM_FILL(&RSTRING_PTR(str)[len], termlen);
@@ -3077,7 +3077,7 @@ rb_str_resize(VALUE str, long len)
     int independent;
 
     if (len < 0) {
-	rb_raise(rb_eArgError, "negative string size (or size too big)");
+        rb_raise(rb_eArgError, "negative string size (or size too big)");
     }
 
     independent = str_independent(str);
@@ -3085,40 +3085,40 @@ rb_str_resize(VALUE str, long len)
     slen = RSTRING_LEN(str);
 
     {
-	long capa;
-	const int termlen = TERM_LEN(str);
-	if (STR_EMBED_P(str)) {
-	    if (len == slen) return str;
+        long capa;
+        const int termlen = TERM_LEN(str);
+        if (STR_EMBED_P(str)) {
+            if (len == slen) return str;
             if (str_embed_capa(str) >= len + termlen) {
-		STR_SET_EMBED_LEN(str, len);
+                STR_SET_EMBED_LEN(str, len);
                 TERM_FILL(RSTRING(str)->as.embed.ary + len, termlen);
-		return str;
-	    }
-	    str_make_independent_expand(str, slen, len - slen, termlen);
-	}
+                return str;
+            }
+            str_make_independent_expand(str, slen, len - slen, termlen);
+        }
         else if (str_embed_capa(str) >= len + termlen) {
-	    char *ptr = STR_HEAP_PTR(str);
-	    STR_SET_EMBED(str);
-	    if (slen > len) slen = len;
+            char *ptr = STR_HEAP_PTR(str);
+            STR_SET_EMBED(str);
+            if (slen > len) slen = len;
             if (slen > 0) MEMCPY(RSTRING(str)->as.embed.ary, ptr, char, slen);
             TERM_FILL(RSTRING(str)->as.embed.ary + len, termlen);
-	    STR_SET_EMBED_LEN(str, len);
-	    if (independent) ruby_xfree(ptr);
-	    return str;
-	}
-	else if (!independent) {
-	    if (len == slen) return str;
-	    str_make_independent_expand(str, slen, len - slen, termlen);
-	}
-	else if ((capa = RSTRING(str)->as.heap.aux.capa) < len ||
-		 (capa - len) > (len < 1024 ? len : 1024)) {
-	    SIZED_REALLOC_N(RSTRING(str)->as.heap.ptr, char,
-	                    (size_t)len + termlen, STR_HEAP_SIZE(str));
-	    RSTRING(str)->as.heap.aux.capa = len;
-	}
-	else if (len == slen) return str;
-	RSTRING(str)->as.heap.len = len;
-	TERM_FILL(RSTRING(str)->as.heap.ptr + len, termlen); /* sentinel */
+            STR_SET_EMBED_LEN(str, len);
+            if (independent) ruby_xfree(ptr);
+            return str;
+        }
+        else if (!independent) {
+            if (len == slen) return str;
+            str_make_independent_expand(str, slen, len - slen, termlen);
+        }
+        else if ((capa = RSTRING(str)->as.heap.aux.capa) < len ||
+                 (capa - len) > (len < 1024 ? len : 1024)) {
+            SIZED_REALLOC_N(RSTRING(str)->as.heap.ptr, char,
+                            (size_t)len + termlen, STR_HEAP_SIZE(str));
+            RSTRING(str)->as.heap.aux.capa = len;
+        }
+        else if (len == slen) return str;
+        RSTRING(str)->as.heap.len = len;
+        TERM_FILL(RSTRING(str)->as.heap.ptr + len, termlen); /* sentinel */
     }
     return str;
 }
@@ -3152,23 +3152,23 @@ str_buf_cat4(VALUE str, const char *ptr, long len, bool keep_cr)
         olen = RSTRING_EMBED_LEN(str);
     }
     else {
-	capa = RSTRING(str)->as.heap.aux.capa;
-	sptr = RSTRING(str)->as.heap.ptr;
-	olen = RSTRING(str)->as.heap.len;
+        capa = RSTRING(str)->as.heap.aux.capa;
+        sptr = RSTRING(str)->as.heap.ptr;
+        olen = RSTRING(str)->as.heap.len;
     }
     if (olen > LONG_MAX - len) {
-	rb_raise(rb_eArgError, "string sizes too big");
+        rb_raise(rb_eArgError, "string sizes too big");
     }
     total = olen + len;
     if (capa < total) {
-	if (total >= LONG_MAX / 2) {
-	    capa = total;
-	}
-	while (total > capa) {
-	    capa = 2 * capa + termlen; /* == 2*(capa+termlen)-termlen */
-	}
-	RESIZE_CAPA_TERM(str, capa, termlen);
-	sptr = RSTRING_PTR(str);
+        if (total >= LONG_MAX / 2) {
+            capa = total;
+        }
+        while (total > capa) {
+            capa = 2 * capa + termlen; /* == 2*(capa+termlen)-termlen */
+        }
+        RESIZE_CAPA_TERM(str, capa, termlen);
+        sptr = RSTRING_PTR(str);
     }
     if (off != -1) {
         ptr = sptr + off;
@@ -3188,7 +3188,7 @@ rb_str_cat(VALUE str, const char *ptr, long len)
 {
     if (len == 0) return str;
     if (len < 0) {
-	rb_raise(rb_eArgError, "negative string size (or size too big)");
+        rb_raise(rb_eArgError, "negative string size (or size too big)");
     }
     return str_buf_cat(str, ptr, len);
 }
@@ -3216,13 +3216,13 @@ rb_enc_cr_str_buf_cat(VALUE str, const char *ptr, long len,
     str_cr = RSTRING_LEN(str) ? ENC_CODERANGE(str) : ENC_CODERANGE_7BIT;
 
     if (str_encindex == ptr_encindex) {
-	if (str_cr != ENC_CODERANGE_UNKNOWN && ptr_cr == ENC_CODERANGE_UNKNOWN) {
+        if (str_cr != ENC_CODERANGE_UNKNOWN && ptr_cr == ENC_CODERANGE_UNKNOWN) {
             ptr_cr = coderange_scan(ptr, len, rb_enc_from_index(ptr_encindex));
         }
     }
     else {
-	str_enc = rb_enc_from_index(str_encindex);
-	ptr_enc = rb_enc_from_index(ptr_encindex);
+        str_enc = rb_enc_from_index(str_encindex);
+        ptr_enc = rb_enc_from_index(ptr_encindex);
         if (!rb_enc_asciicompat(str_enc) || !rb_enc_asciicompat(ptr_enc)) {
             if (len == 0)
                 return str;
@@ -3234,9 +3234,9 @@ rb_enc_cr_str_buf_cat(VALUE str, const char *ptr, long len,
             }
             goto incompatible;
         }
-	if (ptr_cr == ENC_CODERANGE_UNKNOWN) {
-	    ptr_cr = coderange_scan(ptr, len, ptr_enc);
-	}
+        if (ptr_cr == ENC_CODERANGE_UNKNOWN) {
+            ptr_cr = coderange_scan(ptr, len, ptr_enc);
+        }
         if (str_cr == ENC_CODERANGE_UNKNOWN) {
             if (ENCODING_IS_ASCII8BIT(str) || ptr_cr != ENC_CODERANGE_7BIT) {
                 str_cr = rb_enc_str_coderange(str);
@@ -3249,8 +3249,8 @@ rb_enc_cr_str_buf_cat(VALUE str, const char *ptr, long len,
     if (str_encindex != ptr_encindex &&
         str_cr != ENC_CODERANGE_7BIT &&
         ptr_cr != ENC_CODERANGE_7BIT) {
-	str_enc = rb_enc_from_index(str_encindex);
-	ptr_enc = rb_enc_from_index(ptr_encindex);
+        str_enc = rb_enc_from_index(str_encindex);
+        ptr_enc = rb_enc_from_index(ptr_encindex);
         goto incompatible;
     }
 
@@ -3270,10 +3270,10 @@ rb_enc_cr_str_buf_cat(VALUE str, const char *ptr, long len,
     }
     else if (str_cr == ENC_CODERANGE_VALID) {
         res_encindex = str_encindex;
-	if (ENC_CODERANGE_CLEAN_P(ptr_cr))
-	    res_cr = str_cr;
-	else
-	    res_cr = ptr_cr;
+        if (ENC_CODERANGE_CLEAN_P(ptr_cr))
+            res_cr = str_cr;
+        else
+            res_cr = ptr_cr;
     }
     else { /* str_cr == ENC_CODERANGE_BROKEN */
         res_encindex = str_encindex;
@@ -3282,7 +3282,7 @@ rb_enc_cr_str_buf_cat(VALUE str, const char *ptr, long len,
     }
 
     if (len < 0) {
-	rb_raise(rb_eArgError, "negative string size (or size too big)");
+        rb_raise(rb_eArgError, "negative string size (or size too big)");
     }
     str_buf_cat(str, ptr, len);
     ENCODING_CODERANGE_SET(str, res_encindex, res_cr);
@@ -3363,25 +3363,25 @@ rb_str_concat_literals(size_t num, const VALUE *strary)
 
     for (i = 0; i < num; ++i) { len += RSTRING_LEN(strary[i]); }
     if (LIKELY(len < MIN_PRE_ALLOC_SIZE)) {
-	str = rb_str_resurrect(strary[0]);
-	s = 1;
+        str = rb_str_resurrect(strary[0]);
+        s = 1;
     }
     else {
-	str = rb_str_buf_new(len);
-	rb_enc_copy(str, strary[0]);
-	s = 0;
+        str = rb_str_buf_new(len);
+        rb_enc_copy(str, strary[0]);
+        s = 0;
     }
 
     for (i = s; i < num; ++i) {
-	const VALUE v = strary[i];
-	int encidx = ENCODING_GET(v);
-
-	rb_enc_cr_str_buf_cat(str, RSTRING_PTR(v), RSTRING_LEN(v),
-			      encidx, ENC_CODERANGE(v), NULL);
-	if (encidx != ENCINDEX_US_ASCII) {
-	    if (ENCODING_GET_INLINED(str) == ENCINDEX_US_ASCII)
-		rb_enc_set_index(str, encidx);
-	}
+        const VALUE v = strary[i];
+        int encidx = ENCODING_GET(v);
+
+        rb_enc_cr_str_buf_cat(str, RSTRING_PTR(v), RSTRING_LEN(v),
+                              encidx, ENC_CODERANGE(v), NULL);
+        if (encidx != ENCINDEX_US_ASCII) {
+            if (ENCODING_GET_INLINED(str) == ENCINDEX_US_ASCII)
+                rb_enc_set_index(str, encidx);
+        }
     }
     return str;
 }
@@ -3410,16 +3410,16 @@ rb_str_concat_multi(int argc, VALUE *argv, VALUE str)
     str_modifiable(str);
 
     if (argc == 1) {
-	return rb_str_concat(str, argv[0]);
+        return rb_str_concat(str, argv[0]);
     }
     else if (argc > 1) {
-	int i;
-	VALUE arg_str = rb_str_tmp_new(0);
-	rb_enc_copy(arg_str, str);
-	for (i = 0; i < argc; i++) {
-	    rb_str_concat(arg_str, argv[i]);
-	}
-	rb_str_buf_append(str, arg_str);
+        int i;
+        VALUE arg_str = rb_str_tmp_new(0);
+        rb_enc_copy(arg_str, str);
+        for (i = 0; i < argc; i++) {
+            rb_str_concat(arg_str, argv[i]);
+        }
+        rb_str_buf_append(str, arg_str);
     }
 
     return str;
@@ -3451,58 +3451,58 @@ rb_str_concat(VALUE str1, VALUE str2)
     int encidx;
 
     if (RB_INTEGER_TYPE_P(str2)) {
-	if (rb_num_to_uint(str2, &code) == 0) {
-	}
-	else if (FIXNUM_P(str2)) {
-	    rb_raise(rb_eRangeError, "%ld out of char range", FIX2LONG(str2));
-	}
-	else {
-	    rb_raise(rb_eRangeError, "bignum out of char range");
-	}
+        if (rb_num_to_uint(str2, &code) == 0) {
+        }
+        else if (FIXNUM_P(str2)) {
+            rb_raise(rb_eRangeError, "%ld out of char range", FIX2LONG(str2));
+        }
+        else {
+            rb_raise(rb_eRangeError, "bignum out of char range");
+        }
     }
     else {
-	return rb_str_append(str1, str2);
+        return rb_str_append(str1, str2);
     }
 
     encidx = rb_enc_to_index(enc);
     if (encidx == ENCINDEX_ASCII_8BIT || encidx == ENCINDEX_US_ASCII) {
-	/* US-ASCII automatically extended to ASCII-8BIT */
-	char buf[1];
-	buf[0] = (char)code;
-	if (code > 0xFF) {
-	    rb_raise(rb_eRangeError, "%u out of char range", code);
-	}
-	rb_str_cat(str1, buf, 1);
-	if (encidx == ENCINDEX_US_ASCII && code > 127) {
-	    rb_enc_associate_index(str1, ENCINDEX_ASCII_8BIT);
-	    ENC_CODERANGE_SET(str1, ENC_CODERANGE_VALID);
-	}
+        /* US-ASCII automatically extended to ASCII-8BIT */
+        char buf[1];
+        buf[0] = (char)code;
+        if (code > 0xFF) {
+            rb_raise(rb_eRangeError, "%u out of char range", code);
+        }
+        rb_str_cat(str1, buf, 1);
+        if (encidx == ENCINDEX_US_ASCII && code > 127) {
+            rb_enc_associate_index(str1, ENCINDEX_ASCII_8BIT);
+            ENC_CODERANGE_SET(str1, ENC_CODERANGE_VALID);
+        }
     }
     else {
-	long pos = RSTRING_LEN(str1);
-	int cr = ENC_CODERANGE(str1);
-	int len;
-	char *buf;
-
-	switch (len = rb_enc_codelen(code, enc)) {
-	  case ONIGERR_INVALID_CODE_POINT_VALUE:
-	    rb_raise(rb_eRangeError, "invalid codepoint 0x%X in %s", code, rb_enc_name(enc));
-	    break;
-	  case ONIGERR_TOO_BIG_WIDE_CHAR_VALUE:
-	  case 0:
-	    rb_raise(rb_eRangeError, "%u out of char range", code);
-	    break;
-	}
-	buf = ALLOCA_N(char, len + 1);
-	rb_enc_mbcput(code, buf, enc);
-	if (rb_enc_precise_mbclen(buf, buf + len + 1, enc) != len) {
-	    rb_raise(rb_eRangeError, "invalid codepoint 0x%X in %s", code, rb_enc_name(enc));
-	}
-	rb_str_resize(str1, pos+len);
-	memcpy(RSTRING_PTR(str1) + pos, buf, len);
-	if (cr == ENC_CODERANGE_7BIT && code > 127)
-	    cr = ENC_CODERANGE_VALID;
-	ENC_CODERANGE_SET(str1, cr);
+        long pos = RSTRING_LEN(str1);
+        int cr = ENC_CODERANGE(str1);
+        int len;
+        char *buf;
+
+        switch (len = rb_enc_codelen(code, enc)) {
+          case ONIGERR_INVALID_CODE_POINT_VALUE:
+            rb_raise(rb_eRangeError, "invalid codepoint 0x%X in %s", code, rb_enc_name(enc));
+            break;
+          case ONIGERR_TOO_BIG_WIDE_CHAR_VALUE:
+          case 0:
+            rb_raise(rb_eRangeError, "%u out of char range", code);
+            break;
+        }
+        buf = ALLOCA_N(char, len + 1);
+        rb_enc_mbcput(code, buf, enc);
+        if (rb_enc_precise_mbclen(buf, buf + len + 1, enc) != len) {
+            rb_raise(rb_eRangeError, "invalid codepoint 0x%X in %s", code, rb_enc_name(enc));
+        }
+        rb_str_resize(str1, pos+len);
+        memcpy(RSTRING_PTR(str1) + pos, buf, len);
+        if (cr == ENC_CODERANGE_7BIT && code > 127)
+            cr = ENC_CODERANGE_VALID;
+        ENC_CODERANGE_SET(str1, cr);
     }
     return str1;
 }
@@ -3526,16 +3526,16 @@ rb_str_prepend_multi(int argc, VALUE *argv, VALUE str)
     str_modifiable(str);
 
     if (argc == 1) {
-	rb_str_update(str, 0L, 0L, argv[0]);
+        rb_str_update(str, 0L, 0L, argv[0]);
     }
     else if (argc > 1) {
-	int i;
-	VALUE arg_str = rb_str_tmp_new(0);
-	rb_enc_copy(arg_str, str);
-	for (i = 0; i < argc; i++) {
-	    rb_str_append(arg_str, argv[i]);
-	}
-	rb_str_update(str, 0L, 0L, arg_str);
+        int i;
+        VALUE arg_str = rb_str_tmp_new(0);
+        rb_enc_copy(arg_str, str);
+        for (i = 0; i < argc; i++) {
+            rb_str_append(arg_str, argv[i]);
+        }
+        rb_str_update(str, 0L, 0L, arg_str);
     }
 
     return str;
@@ -3546,7 +3546,7 @@ rb_str_hash(VALUE str)
 {
     int e = ENCODING_GET(str);
     if (e && is_ascii_string(str)) {
-	e = 0;
+        e = 0;
     }
     return rb_memhash((const void *)RSTRING_PTR(str), RSTRING_LEN(str)) ^ e;
 }
@@ -3559,8 +3559,8 @@ rb_str_hash_cmp(VALUE str1, VALUE str2)
     RSTRING_GETMEM(str1, ptr1, len1);
     RSTRING_GETMEM(str2, ptr2, len2);
     return (len1 != len2 ||
-	    !rb_str_comparable(str1, str2) ||
-	    memcmp(ptr1, ptr2, len1) != 0);
+            !rb_str_comparable(str1, str2) ||
+            memcmp(ptr1, ptr2, len1) != 0);
 }
 
 /*
@@ -3596,13 +3596,13 @@ rb_str_comparable(VALUE str1, VALUE str2)
     rc1 = rb_enc_str_coderange(str1);
     rc2 = rb_enc_str_coderange(str2);
     if (rc1 == ENC_CODERANGE_7BIT) {
-	if (rc2 == ENC_CODERANGE_7BIT) return TRUE;
-	if (rb_enc_asciicompat(rb_enc_from_index(idx2)))
-	    return TRUE;
+        if (rc2 == ENC_CODERANGE_7BIT) return TRUE;
+        if (rb_enc_asciicompat(rb_enc_from_index(idx2)))
+            return TRUE;
     }
     if (rc2 == ENC_CODERANGE_7BIT) {
-	if (rb_enc_asciicompat(rb_enc_from_index(idx1)))
-	    return TRUE;
+        if (rb_enc_asciicompat(rb_enc_from_index(idx1)))
+            return TRUE;
     }
     return FALSE;
 }
@@ -3618,16 +3618,16 @@ rb_str_cmp(VALUE str1, VALUE str2)
     RSTRING_GETMEM(str1, ptr1, len1);
     RSTRING_GETMEM(str2, ptr2, len2);
     if (ptr1 == ptr2 || (retval = memcmp(ptr1, ptr2, lesser(len1, len2))) == 0) {
-	if (len1 == len2) {
-	    if (!rb_str_comparable(str1, str2)) {
-		if (ENCODING_GET(str1) > ENCODING_GET(str2))
-		    return 1;
-		return -1;
-	    }
-	    return 0;
-	}
-	if (len1 > len2) return 1;
-	return -1;
+        if (len1 == len2) {
+            if (!rb_str_comparable(str1, str2)) {
+                if (ENCODING_GET(str1) > ENCODING_GET(str2))
+                    return 1;
+                return -1;
+            }
+            return 0;
+        }
+        if (len1 > len2) return 1;
+        return -1;
     }
     if (retval > 0) return 1;
     return -1;
@@ -3658,10 +3658,10 @@ rb_str_equal(VALUE str1, VALUE str2)
 {
     if (str1 == str2) return Qtrue;
     if (!RB_TYPE_P(str2, T_STRING)) {
-	if (!rb_respond_to(str2, idTo_str)) {
-	    return Qfalse;
-	}
-	return rb_equal(str2, str1);
+        if (!rb_respond_to(str2, idTo_str)) {
+            return Qfalse;
+        }
+        return rb_equal(str2, str1);
     }
     return rb_str_eql_internal(str1, str2);
 }
@@ -3720,7 +3720,7 @@ rb_str_cmp_m(VALUE str1, VALUE str2)
     int result;
     VALUE s = rb_check_string_type(str2);
     if (NIL_P(s)) {
-	return rb_invcmp(str1, str2);
+        return rb_invcmp(str1, str2);
     }
     result = rb_str_cmp(str1, s);
     return INT2FIX(result);
@@ -3760,7 +3760,7 @@ rb_str_casecmp(VALUE str1, VALUE str2)
 {
     VALUE s = rb_check_string_type(str2);
     if (NIL_P(s)) {
-	return Qnil;
+        return Qnil;
     }
     return str_casecmp(str1, s);
 }
@@ -3774,25 +3774,25 @@ str_casecmp(VALUE str1, VALUE str2)
 
     enc = rb_enc_compatible(str1, str2);
     if (!enc) {
-	return Qnil;
+        return Qnil;
     }
 
     p1 = RSTRING_PTR(str1); p1end = RSTRING_END(str1);
     p2 = RSTRING_PTR(str2); p2end = RSTRING_END(str2);
     if (single_byte_optimizable(str1) && single_byte_optimizable(str2)) {
-	while (p1 < p1end && p2 < p2end) {
-	    if (*p1 != *p2) {
+        while (p1 < p1end && p2 < p2end) {
+            if (*p1 != *p2) {
                 unsigned int c1 = TOLOWER(*p1 & 0xff);
                 unsigned int c2 = TOLOWER(*p2 & 0xff);
                 if (c1 != c2)
                     return INT2FIX(c1 < c2 ? -1 : 1);
-	    }
-	    p1++;
-	    p2++;
-	}
+            }
+            p1++;
+            p2++;
+        }
     }
     else {
-	while (p1 < p1end && p2 < p2end) {
+        while (p1 < p1end && p2 < p2end) {
             int l1, c1 = rb_enc_ascget(p1, p1end, &l1, enc);
             int l2, c2 = rb_enc_ascget(p2, p2end, &l2, enc);
 
@@ -3813,9 +3813,9 @@ str_casecmp(VALUE str1, VALUE str2)
                 if (l1 != l2)
                     return INT2FIX(l1 < l2 ? -1 : 1);
             }
-	    p1 += l1;
-	    p2 += l2;
-	}
+            p1 += l1;
+            p2 += l2;
+        }
     }
     if (RSTRING_LEN(str1) == RSTRING_LEN(str2)) return INT2FIX(0);
     if (RSTRING_LEN(str1) > RSTRING_LEN(str2)) return INT2FIX(1);
@@ -3850,7 +3850,7 @@ rb_str_casecmp_p(VALUE str1, VALUE str2)
 {
     VALUE s = rb_check_string_type(str2);
     if (NIL_P(s)) {
-	return Qnil;
+        return Qnil;
     }
     return str_casecmp_p(str1, s);
 }
@@ -3864,7 +3864,7 @@ str_casecmp_p(VALUE str1, VALUE str2)
 
     enc = rb_enc_compatible(str1, str2);
     if (!enc) {
-	return Qnil;
+        return Qnil;
     }
 
     folded_str1 = rb_str_downcase(1, &fold_opt, str1);
@@ -3875,21 +3875,21 @@ str_casecmp_p(VALUE str1, VALUE str2)
 
 static long
 strseq_core(const char *str_ptr, const char *str_ptr_end, long str_len,
-	    const char *sub_ptr, long sub_len, long offset, rb_encoding *enc)
+            const char *sub_ptr, long sub_len, long offset, rb_encoding *enc)
 {
     const char *search_start = str_ptr;
     long pos, search_len = str_len - offset;
 
     for (;;) {
-	const char *t;
-	pos = rb_memsearch(sub_ptr, sub_len, search_start, search_len, enc);
-	if (pos < 0) return pos;
-	t = rb_enc_right_char_head(search_start, search_start+pos, str_ptr_end, enc);
-	if (t == search_start + pos) break;
-	search_len -= t - search_start;
-	if (search_len <= 0) return -1;
-	offset += t - search_start;
-	search_start = t;
+        const char *t;
+        pos = rb_memsearch(sub_ptr, sub_len, search_start, search_len, enc);
+        if (pos < 0) return pos;
+        t = rb_enc_right_char_head(search_start, search_start+pos, str_ptr_end, enc);
+        if (t == search_start + pos) break;
+        search_len -= t - search_start;
+        if (search_len <= 0) return -1;
+        offset += t - search_start;
+        search_start = t;
     }
     return pos + offset;
 }
@@ -3915,17 +3915,17 @@ rb_strseq_index(VALUE str, VALUE sub, long offset, int in_byte)
     if (str_len < sub_len) return -1;
 
     if (offset != 0) {
-	long str_len_char, sub_len_char;
+        long str_len_char, sub_len_char;
         int single_byte = single_byte_optimizable(str);
-	str_len_char = (in_byte || single_byte) ? str_len : str_strlen(str, enc);
-	sub_len_char = in_byte ? sub_len : str_strlen(sub, enc);
-	if (offset < 0) {
-	    offset += str_len_char;
-	    if (offset < 0) return -1;
-	}
-	if (str_len_char - offset < sub_len_char) return -1;
-	if (!in_byte) offset = str_offset(str_ptr, str_ptr_end, offset, enc, single_byte);
-	str_ptr += offset;
+        str_len_char = (in_byte || single_byte) ? str_len : str_strlen(str, enc);
+        sub_len_char = in_byte ? sub_len : str_strlen(sub, enc);
+        if (offset < 0) {
+            offset += str_len_char;
+            if (offset < 0) return -1;
+        }
+        if (str_len_char - offset < sub_len_char) return -1;
+        if (!in_byte) offset = str_offset(str_ptr, str_ptr_end, offset, enc, single_byte);
+        str_ptr += offset;
     }
     if (sub_len == 0) return offset;
 
@@ -3951,28 +3951,28 @@ rb_str_index_m(int argc, VALUE *argv, VALUE str)
     long pos;
 
     if (rb_scan_args(argc, argv, "11", &sub, &initpos) == 2) {
-	pos = NUM2LONG(initpos);
+        pos = NUM2LONG(initpos);
     }
     else {
-	pos = 0;
+        pos = 0;
     }
     if (pos < 0) {
-	pos += str_strlen(str, NULL);
-	if (pos < 0) {
-	    if (RB_TYPE_P(sub, T_REGEXP)) {
-		rb_backref_set(Qnil);
-	    }
-	    return Qnil;
-	}
+        pos += str_strlen(str, NULL);
+        if (pos < 0) {
+            if (RB_TYPE_P(sub, T_REGEXP)) {
+                rb_backref_set(Qnil);
+            }
+            return Qnil;
+        }
     }
 
     if (RB_TYPE_P(sub, T_REGEXP)) {
-	if (pos > str_strlen(str, NULL))
-	    return Qnil;
-	pos = str_offset(RSTRING_PTR(str), RSTRING_END(str), pos,
-			 rb_enc_check(str, sub), single_byte_optimizable(str));
+        if (pos > str_strlen(str, NULL))
+            return Qnil;
+        pos = str_offset(RSTRING_PTR(str), RSTRING_END(str), pos,
+                         rb_enc_check(str, sub), single_byte_optimizable(str));
 
-	if (rb_reg_search(sub, str, pos, 0) < 0) {
+        if (rb_reg_search(sub, str, pos, 0) < 0) {
             return Qnil;
         }
         else {
@@ -3984,8 +3984,8 @@ rb_str_index_m(int argc, VALUE *argv, VALUE str)
     }
     else {
         StringValue(sub);
-	pos = rb_str_index(str, sub, pos);
-	pos = rb_str_sublen(str, pos);
+        pos = rb_str_index(str, sub, pos);
+        pos = rb_str_sublen(str, pos);
     }
 
     if (pos == -1) return Qnil;
@@ -4115,16 +4115,16 @@ str_rindex(VALUE str, VALUE sub, const char *s, rb_encoding *enc)
     searchlen = s - sbeg + 1;
 
     do {
-	hit = memrchr(sbeg, c, searchlen);
-	if (!hit) break;
-	adjusted = rb_enc_left_char_head(sbeg, hit, e, enc);
-	if (hit != adjusted) {
-	    searchlen = adjusted - sbeg;
-	    continue;
-	}
-	if (memcmp(hit, t, slen) == 0)
-	    return hit - sbeg;
-	searchlen = adjusted - sbeg;
+        hit = memrchr(sbeg, c, searchlen);
+        if (!hit) break;
+        adjusted = rb_enc_left_char_head(sbeg, hit, e, enc);
+        if (hit != adjusted) {
+            searchlen = adjusted - sbeg;
+            continue;
+        }
+        if (memcmp(hit, t, slen) == 0)
+            return hit - sbeg;
+        searchlen = adjusted - sbeg;
     } while (searchlen > 0);
 
     return -1;
@@ -4142,11 +4142,11 @@ str_rindex(VALUE str, VALUE sub, const char *s, rb_encoding *enc)
     slen = RSTRING_LEN(sub);
 
     while (s) {
-	if (memcmp(s, t, slen) == 0) {
-	    return s - sbeg;
-	}
+        if (memcmp(s, t, slen) == 0) {
+            return s - sbeg;
+        }
         if (s <= sbeg) break;
-	s = rb_enc_prev_char(sbeg, s, e, enc);
+        s = rb_enc_prev_char(sbeg, s, e, enc);
     }
 
     return -1;
@@ -4175,10 +4175,10 @@ rb_str_rindex(VALUE str, VALUE sub, long pos)
     sbeg = RSTRING_PTR(str);
 
     if (pos == 0) {
-	if (memcmp(sbeg, RSTRING_PTR(sub), RSTRING_LEN(sub)) == 0)
-	    return 0;
-	else
-	    return -1;
+        if (memcmp(sbeg, RSTRING_PTR(sub), RSTRING_LEN(sub)) == 0)
+            return 0;
+        else
+            return -1;
     }
 
     s = str_nth(sbeg, RSTRING_END(str), pos, enc, singlebyte);
@@ -4251,28 +4251,28 @@ rb_str_rindex_m(int argc, VALUE *argv, VALUE str)
     long pos, len = str_strlen(str, enc); /* str's enc */
 
     if (rb_scan_args(argc, argv, "11", &sub, &vpos) == 2) {
-	pos = NUM2LONG(vpos);
-	if (pos < 0) {
-	    pos += len;
-	    if (pos < 0) {
-		if (RB_TYPE_P(sub, T_REGEXP)) {
-		    rb_backref_set(Qnil);
-		}
-		return Qnil;
-	    }
-	}
-	if (pos > len) pos = len;
+        pos = NUM2LONG(vpos);
+        if (pos < 0) {
+            pos += len;
+            if (pos < 0) {
+                if (RB_TYPE_P(sub, T_REGEXP)) {
+                    rb_backref_set(Qnil);
+                }
+                return Qnil;
+            }
+        }
+        if (pos > len) pos = len;
     }
     else {
-	pos = len;
+        pos = len;
     }
 
     if (RB_TYPE_P(sub, T_REGEXP)) {
-	/* enc = rb_get_check(str, sub); */
-	pos = str_offset(RSTRING_PTR(str), RSTRING_END(str), pos,
-			 enc, single_byte_optimizable(str));
+        /* enc = rb_get_check(str, sub); */
+        pos = str_offset(RSTRING_PTR(str), RSTRING_END(str), pos,
+                         enc, single_byte_optimizable(str));
 
-	if (rb_reg_search(sub, str, pos, 1) >= 0) {
+        if (rb_reg_search(sub, str, pos, 1) >= 0) {
             VALUE match = rb_backref_get();
             struct re_registers *regs = RMATCH_REGS(match);
             pos = rb_str_sublen(str, BEG(0));
@@ -4281,8 +4281,8 @@ rb_str_rindex_m(int argc, VALUE *argv, VALUE str)
     }
     else {
         StringValue(sub);
-	pos = rb_str_rindex(str, sub, pos);
-	if (pos >= 0) return LONG2NUM(pos);
+        pos = rb_str_rindex(str, sub, pos);
+        if (pos >= 0) return LONG2NUM(pos);
     }
     return Qnil;
 }
@@ -4456,13 +4456,13 @@ rb_str_match(VALUE x, VALUE y)
 {
     switch (OBJ_BUILTIN_TYPE(y)) {
       case T_STRING:
-	rb_raise(rb_eTypeError, "type mismatch: String given");
+        rb_raise(rb_eTypeError, "type mismatch: String given");
 
       case T_REGEXP:
-	return rb_reg_match(y, x);
+        return rb_reg_match(y, x);
 
       default:
-	return rb_funcall(y, idEqTilde, 1, x);
+        return rb_funcall(y, idEqTilde, 1, x);
     }
 }
 
@@ -4510,12 +4510,12 @@ rb_str_match_m(int argc, VALUE *argv, VALUE str)
 {
     VALUE re, result;
     if (argc < 1)
-	rb_check_arity(argc, 1, 2);
+        rb_check_arity(argc, 1, 2);
     re = argv[0];
     argv[0] = str;
     result = rb_funcallv(get_pat(re), rb_intern("match"), argc, argv);
     if (!NIL_P(result) && rb_block_given_p()) {
-	return rb_yield(result);
+        return rb_yield(result);
     }
     return result;
 }
@@ -4566,21 +4566,21 @@ enc_succ_char(char *p, long len, rb_encoding *enc)
     int l;
 
     if (rb_enc_mbminlen(enc) > 1) {
-	/* wchar, trivial case */
-	int r = rb_enc_precise_mbclen(p, p + len, enc), c;
-	if (!MBCLEN_CHARFOUND_P(r)) {
-	    return NEIGHBOR_NOT_CHAR;
-	}
-	c = rb_enc_mbc_to_codepoint(p, p + len, enc) + 1;
-	l = rb_enc_code_to_mbclen(c, enc);
-	if (!l) return NEIGHBOR_NOT_CHAR;
-	if (l != len) return NEIGHBOR_WRAPPED;
-	rb_enc_mbcput(c, p, enc);
-	r = rb_enc_precise_mbclen(p, p + len, enc);
-	if (!MBCLEN_CHARFOUND_P(r)) {
-	    return NEIGHBOR_NOT_CHAR;
-	}
-	return NEIGHBOR_FOUND;
+        /* wchar, trivial case */
+        int r = rb_enc_precise_mbclen(p, p + len, enc), c;
+        if (!MBCLEN_CHARFOUND_P(r)) {
+            return NEIGHBOR_NOT_CHAR;
+        }
+        c = rb_enc_mbc_to_codepoint(p, p + len, enc) + 1;
+        l = rb_enc_code_to_mbclen(c, enc);
+        if (!l) return NEIGHBOR_NOT_CHAR;
+        if (l != len) return NEIGHBOR_WRAPPED;
+        rb_enc_mbcput(c, p, enc);
+        r = rb_enc_precise_mbclen(p, p + len, enc);
+        if (!MBCLEN_CHARFOUND_P(r)) {
+            return NEIGHBOR_NOT_CHAR;
+        }
+        return NEIGHBOR_FOUND;
     }
     while (1) {
         for (i = len-1; 0 <= i && (unsigned char)p[i] == 0xff; i--)
@@ -4617,23 +4617,23 @@ enc_pred_char(char *p, long len, rb_encoding *enc)
     long i;
     int l;
     if (rb_enc_mbminlen(enc) > 1) {
-	/* wchar, trivial case */
-	int r = rb_enc_precise_mbclen(p, p + len, enc), c;
-	if (!MBCLEN_CHARFOUND_P(r)) {
-	    return NEIGHBOR_NOT_CHAR;
-	}
-	c = rb_enc_mbc_to_codepoint(p, p + len, enc);
-	if (!c) return NEIGHBOR_NOT_CHAR;
-	--c;
-	l = rb_enc_code_to_mbclen(c, enc);
-	if (!l) return NEIGHBOR_NOT_CHAR;
-	if (l != len) return NEIGHBOR_WRAPPED;
-	rb_enc_mbcput(c, p, enc);
-	r = rb_enc_precise_mbclen(p, p + len, enc);
-	if (!MBCLEN_CHARFOUND_P(r)) {
-	    return NEIGHBOR_NOT_CHAR;
-	}
-	return NEIGHBOR_FOUND;
+        /* wchar, trivial case */
+        int r = rb_enc_precise_mbclen(p, p + len, enc), c;
+        if (!MBCLEN_CHARFOUND_P(r)) {
+            return NEIGHBOR_NOT_CHAR;
+        }
+        c = rb_enc_mbc_to_codepoint(p, p + len, enc);
+        if (!c) return NEIGHBOR_NOT_CHAR;
+        --c;
+        l = rb_enc_code_to_mbclen(c, enc);
+        if (!l) return NEIGHBOR_NOT_CHAR;
+        if (l != len) return NEIGHBOR_WRAPPED;
+        rb_enc_mbcput(c, p, enc);
+        r = rb_enc_precise_mbclen(p, p + len, enc);
+        if (!MBCLEN_CHARFOUND_P(r)) {
+            return NEIGHBOR_NOT_CHAR;
+        }
+        return NEIGHBOR_FOUND;
     }
     while (1) {
         for (i = len-1; 0 <= i && (unsigned char)p[i] == 0; i--)
@@ -4696,12 +4696,12 @@ enc_succ_alnum_char(char *p, long len, rb_encoding *enc, char *carry)
 
     MEMCPY(save, p, char, len);
     for (try = 0; try <= max_gaps; ++try) {
-	ret = enc_succ_char(p, len, enc);
-	if (ret == NEIGHBOR_FOUND) {
-	    c = rb_enc_mbc_to_codepoint(p, p+len, enc);
-	    if (rb_enc_isctype(c, ctype, enc))
-		return NEIGHBOR_FOUND;
-	}
+        ret = enc_succ_char(p, len, enc);
+        if (ret == NEIGHBOR_FOUND) {
+            c = rb_enc_mbc_to_codepoint(p, p+len, enc);
+            if (rb_enc_isctype(c, ctype, enc))
+                return NEIGHBOR_FOUND;
+        }
     }
     MEMCPY(p, save, char, len);
     range = 1;
@@ -4825,50 +4825,50 @@ str_succ(VALUE str)
     s = e = sbeg + slen;
 
     while ((s = rb_enc_prev_char(sbeg, s, e, enc)) != 0) {
-	if (neighbor == NEIGHBOR_NOT_CHAR && last_alnum) {
-	    if (ISALPHA(*last_alnum) ? ISDIGIT(*s) :
-		ISDIGIT(*last_alnum) ? ISALPHA(*s) : 0) {
-		break;
-	    }
-	}
-	l = rb_enc_precise_mbclen(s, e, enc);
-	if (!ONIGENC_MBCLEN_CHARFOUND_P(l)) continue;
-	l = ONIGENC_MBCLEN_CHARFOUND_LEN(l);
+        if (neighbor == NEIGHBOR_NOT_CHAR && last_alnum) {
+            if (ISALPHA(*last_alnum) ? ISDIGIT(*s) :
+                ISDIGIT(*last_alnum) ? ISALPHA(*s) : 0) {
+                break;
+            }
+        }
+        l = rb_enc_precise_mbclen(s, e, enc);
+        if (!ONIGENC_MBCLEN_CHARFOUND_P(l)) continue;
+        l = ONIGENC_MBCLEN_CHARFOUND_LEN(l);
         neighbor = enc_succ_alnum_char(s, l, enc, carry);
         switch (neighbor) {
-	  case NEIGHBOR_NOT_CHAR:
-	    continue;
-	  case NEIGHBOR_FOUND:
-	    return str;
-	  case NEIGHBOR_WRAPPED:
-	    last_alnum = s;
-	    break;
-	}
+          case NEIGHBOR_NOT_CHAR:
+            continue;
+          case NEIGHBOR_FOUND:
+            return str;
+          case NEIGHBOR_WRAPPED:
+            last_alnum = s;
+            break;
+        }
         found_alnum = 1;
         carry_pos = s - sbeg;
         carry_len = l;
     }
     if (!found_alnum) {		/* str contains no alnum */
-	s = e;
-	while ((s = rb_enc_prev_char(sbeg, s, e, enc)) != 0) {
+        s = e;
+        while ((s = rb_enc_prev_char(sbeg, s, e, enc)) != 0) {
             enum neighbor_char neighbor;
-	    char tmp[ONIGENC_CODE_TO_MBC_MAXLEN];
-	    l = rb_enc_precise_mbclen(s, e, enc);
-	    if (!ONIGENC_MBCLEN_CHARFOUND_P(l)) continue;
-	    l = ONIGENC_MBCLEN_CHARFOUND_LEN(l);
-	    MEMCPY(tmp, s, char, l);
-	    neighbor = enc_succ_char(tmp, l, enc);
-	    switch (neighbor) {
-	      case NEIGHBOR_FOUND:
-		MEMCPY(s, tmp, char, l);
+            char tmp[ONIGENC_CODE_TO_MBC_MAXLEN];
+            l = rb_enc_precise_mbclen(s, e, enc);
+            if (!ONIGENC_MBCLEN_CHARFOUND_P(l)) continue;
+            l = ONIGENC_MBCLEN_CHARFOUND_LEN(l);
+            MEMCPY(tmp, s, char, l);
+            neighbor = enc_succ_char(tmp, l, enc);
+            switch (neighbor) {
+              case NEIGHBOR_FOUND:
+                MEMCPY(s, tmp, char, l);
                 return str;
-		break;
-	      case NEIGHBOR_WRAPPED:
-		MEMCPY(s, tmp, char, l);
-		break;
-	      case NEIGHBOR_NOT_CHAR:
-		break;
-	    }
+                break;
+              case NEIGHBOR_WRAPPED:
+                MEMCPY(s, tmp, char, l);
+                break;
+              case NEIGHBOR_NOT_CHAR:
+                break;
+            }
             if (rb_enc_precise_mbclen(s, s+l, enc) != l) {
                 /* wrapped to \0...\0.  search next valid char. */
                 enc_succ_char(s, l, enc);
@@ -4878,8 +4878,8 @@ str_succ(VALUE str)
                 carry_len = l;
             }
             carry_pos = s - sbeg;
-	}
-	ENC_CODERANGE_SET(str, ENC_CODERANGE_UNKNOWN);
+        }
+        ENC_CODERANGE_SET(str, ENC_CODERANGE_UNKNOWN);
     }
     RESIZE_CAPA(str, slen + carry_len);
     sbeg = RSTRING_PTR(str);
@@ -4915,8 +4915,8 @@ static int
 all_digits_p(const char *s, long len)
 {
     while (len-- > 0) {
-	if (!ISDIGIT(*s)) return 0;
-	s++;
+        if (!ISDIGIT(*s)) return 0;
+        s++;
     }
     return 1;
 }
@@ -4987,51 +4987,51 @@ rb_str_upto_each(VALUE beg, VALUE end, int excl, int (*each)(VALUE, VALUE), VALU
     ascii = (is_ascii_string(beg) && is_ascii_string(end));
     /* single character */
     if (RSTRING_LEN(beg) == 1 && RSTRING_LEN(end) == 1 && ascii) {
-	char c = RSTRING_PTR(beg)[0];
-	char e = RSTRING_PTR(end)[0];
-
-	if (c > e || (excl && c == e)) return beg;
-	for (;;) {
-	    if ((*each)(rb_enc_str_new(&c, 1, enc), arg)) break;
-	    if (!excl && c == e) break;
-	    c++;
-	    if (excl && c == e) break;
-	}
-	return beg;
+        char c = RSTRING_PTR(beg)[0];
+        char e = RSTRING_PTR(end)[0];
+
+        if (c > e || (excl && c == e)) return beg;
+        for (;;) {
+            if ((*each)(rb_enc_str_new(&c, 1, enc), arg)) break;
+            if (!excl && c == e) break;
+            c++;
+            if (excl && c == e) break;
+        }
+        return beg;
     }
     /* both edges are all digits */
     if (ascii && ISDIGIT(RSTRING_PTR(beg)[0]) && ISDIGIT(RSTRING_PTR(end)[0]) &&
-	all_digits_p(RSTRING_PTR(beg), RSTRING_LEN(beg)) &&
-	all_digits_p(RSTRING_PTR(end), RSTRING_LEN(end))) {
-	VALUE b, e;
-	int width;
-
-	width = RSTRING_LENINT(beg);
-	b = rb_str_to_inum(beg, 10, FALSE);
-	e = rb_str_to_inum(end, 10, FALSE);
-	if (FIXNUM_P(b) && FIXNUM_P(e)) {
-	    long bi = FIX2LONG(b);
-	    long ei = FIX2LONG(e);
-	    rb_encoding *usascii = rb_usascii_encoding();
-
-	    while (bi <= ei) {
-		if (excl && bi == ei) break;
-		if ((*each)(rb_enc_sprintf(usascii, "%.*ld", width, bi), arg)) break;
-		bi++;
-	    }
-	}
-	else {
-	    ID op = excl ? '<' : idLE;
-	    VALUE args[2], fmt = rb_fstring_lit("%.*d");
-
-	    args[0] = INT2FIX(width);
-	    while (rb_funcall(b, op, 1, e)) {
-		args[1] = b;
-		if ((*each)(rb_str_format(numberof(args), args, fmt), arg)) break;
-		b = rb_funcallv(b, succ, 0, 0);
-	    }
-	}
-	return beg;
+        all_digits_p(RSTRING_PTR(beg), RSTRING_LEN(beg)) &&
+        all_digits_p(RSTRING_PTR(end), RSTRING_LEN(end))) {
+        VALUE b, e;
+        int width;
+
+        width = RSTRING_LENINT(beg);
+        b = rb_str_to_inum(beg, 10, FALSE);
+        e = rb_str_to_inum(end, 10, FALSE);
+        if (FIXNUM_P(b) && FIXNUM_P(e)) {
+            long bi = FIX2LONG(b);
+            long ei = FIX2LONG(e);
+            rb_encoding *usascii = rb_usascii_encoding();
+
+            while (bi <= ei) {
+                if (excl && bi == ei) break;
+                if ((*each)(rb_enc_sprintf(usascii, "%.*ld", width, bi), arg)) break;
+                bi++;
+            }
+        }
+        else {
+            ID op = excl ? '<' : idLE;
+            VALUE args[2], fmt = rb_fstring_lit("%.*d");
+
+            args[0] = INT2FIX(width);
+            while (rb_funcall(b, op, 1, e)) {
+                args[1] = b;
+                if ((*each)(rb_str_format(numberof(args), args, fmt), arg)) break;
+                b = rb_funcallv(b, succ, 0, 0);
+            }
+        }
+        return beg;
     }
     /* normal case */
     n = rb_str_cmp(beg, end);
@@ -5040,16 +5040,16 @@ rb_str_upto_each(VALUE beg, VALUE end, int excl, int (*each)(VALUE, VALUE), VALU
     after_end = rb_funcallv(end, succ, 0, 0);
     current = str_duplicate(rb_cString, beg);
     while (!rb_str_equal(current, after_end)) {
-	VALUE next = Qnil;
-	if (excl || !rb_str_equal(current, end))
-	    next = rb_funcallv(current, succ, 0, 0);
-	if ((*each)(current, arg)) break;
-	if (NIL_P(next)) break;
-	current = next;
-	StringValue(current);
-	if (excl && rb_str_equal(current, end)) break;
-	if (RSTRING_LEN(current) > RSTRING_LEN(end) || RSTRING_LEN(current) == 0)
-	    break;
+        VALUE next = Qnil;
+        if (excl || !rb_str_equal(current, end))
+            next = rb_funcallv(current, succ, 0, 0);
+        if ((*each)(current, arg)) break;
+        if (NIL_P(next)) break;
+        current = next;
+        StringValue(current);
+        if (excl && rb_str_equal(current, end)) break;
+        if (RSTRING_LEN(current) > RSTRING_LEN(end) || RSTRING_LEN(current) == 0)
+            break;
     }
 
     return beg;
@@ -5064,36 +5064,36 @@ rb_str_upto_endless_each(VALUE beg, int (*each)(VALUE, VALUE), VALUE arg)
     CONST_ID(succ, "succ");
     /* both edges are all digits */
     if (is_ascii_string(beg) && ISDIGIT(RSTRING_PTR(beg)[0]) &&
-	all_digits_p(RSTRING_PTR(beg), RSTRING_LEN(beg))) {
-	VALUE b, args[2], fmt = rb_fstring_lit("%.*d");
-	int width = RSTRING_LENINT(beg);
-	b = rb_str_to_inum(beg, 10, FALSE);
-	if (FIXNUM_P(b)) {
-	    long bi = FIX2LONG(b);
-	    rb_encoding *usascii = rb_usascii_encoding();
-
-	    while (FIXABLE(bi)) {
-		if ((*each)(rb_enc_sprintf(usascii, "%.*ld", width, bi), arg)) break;
-		bi++;
-	    }
-	    b = LONG2NUM(bi);
-	}
-	args[0] = INT2FIX(width);
-	while (1) {
-	    args[1] = b;
-	    if ((*each)(rb_str_format(numberof(args), args, fmt), arg)) break;
-	    b = rb_funcallv(b, succ, 0, 0);
-	}
+        all_digits_p(RSTRING_PTR(beg), RSTRING_LEN(beg))) {
+        VALUE b, args[2], fmt = rb_fstring_lit("%.*d");
+        int width = RSTRING_LENINT(beg);
+        b = rb_str_to_inum(beg, 10, FALSE);
+        if (FIXNUM_P(b)) {
+            long bi = FIX2LONG(b);
+            rb_encoding *usascii = rb_usascii_encoding();
+
+            while (FIXABLE(bi)) {
+                if ((*each)(rb_enc_sprintf(usascii, "%.*ld", width, bi), arg)) break;
+                bi++;
+            }
+            b = LONG2NUM(bi);
+        }
+        args[0] = INT2FIX(width);
+        while (1) {
+            args[1] = b;
+            if ((*each)(rb_str_format(numberof(args), args, fmt), arg)) break;
+            b = rb_funcallv(b, succ, 0, 0);
+        }
     }
     /* normal case */
     current = str_duplicate(rb_cString, beg);
     while (1) {
-	VALUE next = rb_funcallv(current, succ, 0, 0);
-	if ((*each)(current, arg)) break;
-	current = next;
-	StringValue(current);
-	if (RSTRING_LEN(current) == 0)
-	    break;
+        VALUE next = rb_funcallv(current, succ, 0, 0);
+        if ((*each)(current, arg)) break;
+        current = next;
+        StringValue(current);
+        if (RSTRING_LEN(current) == 0)
+            break;
     }
 
     return beg;
@@ -5118,32 +5118,32 @@ rb_str_include_range_p(VALUE beg, VALUE end, VALUE val, VALUE exclusive)
     val = rb_check_string_type(val);
     if (NIL_P(val)) return Qfalse;
     if (rb_enc_asciicompat(STR_ENC_GET(beg)) &&
-	rb_enc_asciicompat(STR_ENC_GET(end)) &&
-	rb_enc_asciicompat(STR_ENC_GET(val))) {
-	const char *bp = RSTRING_PTR(beg);
-	const char *ep = RSTRING_PTR(end);
-	const char *vp = RSTRING_PTR(val);
-	if (RSTRING_LEN(beg) == 1 && RSTRING_LEN(end) == 1) {
-	    if (RSTRING_LEN(val) == 0 || RSTRING_LEN(val) > 1)
-		return Qfalse;
-	    else {
-		char b = *bp;
-		char e = *ep;
-		char v = *vp;
-
-		if (ISASCII(b) && ISASCII(e) && ISASCII(v)) {
-		    if (b <= v && v < e) return Qtrue;
-		    return RBOOL(!RTEST(exclusive) && v == e);
-		}
-	    }
-	}
+        rb_enc_asciicompat(STR_ENC_GET(end)) &&
+        rb_enc_asciicompat(STR_ENC_GET(val))) {
+        const char *bp = RSTRING_PTR(beg);
+        const char *ep = RSTRING_PTR(end);
+        const char *vp = RSTRING_PTR(val);
+        if (RSTRING_LEN(beg) == 1 && RSTRING_LEN(end) == 1) {
+            if (RSTRING_LEN(val) == 0 || RSTRING_LEN(val) > 1)
+                return Qfalse;
+            else {
+                char b = *bp;
+                char e = *ep;
+                char v = *vp;
+
+                if (ISASCII(b) && ISASCII(e) && ISASCII(v)) {
+                    if (b <= v && v < e) return Qtrue;
+                    return RBOOL(!RTEST(exclusive) && v == e);
+                }
+            }
+        }
 #if 0
-	/* both edges are all digits */
-	if (ISDIGIT(*bp) && ISDIGIT(*ep) &&
-	    all_digits_p(bp, RSTRING_LEN(beg)) &&
-	    all_digits_p(ep, RSTRING_LEN(end))) {
-	    /* TODO */
-	}
+        /* both edges are all digits */
+        if (ISDIGIT(*bp) && ISDIGIT(*ep) &&
+            all_digits_p(bp, RSTRING_LEN(beg)) &&
+            all_digits_p(ep, RSTRING_LEN(end))) {
+            /* TODO */
+        }
 #endif
     }
     rb_str_upto_each(beg, end, RTEST(exclusive), include_range_i, (VALUE)&val);
@@ -5157,7 +5157,7 @@ rb_str_subpat(VALUE str, VALUE re, VALUE backref)
     if (rb_reg_search(re, str, 0, 0) >= 0) {
         VALUE match = rb_backref_get();
         int nth = rb_reg_backref_number(match, backref);
-	return rb_reg_nth_match(nth, match);
+        return rb_reg_nth_match(nth, match);
     }
     return Qnil;
 }
@@ -5168,28 +5168,28 @@ rb_str_aref(VALUE str, VALUE indx)
     long idx;
 
     if (FIXNUM_P(indx)) {
-	idx = FIX2LONG(indx);
+        idx = FIX2LONG(indx);
     }
     else if (RB_TYPE_P(indx, T_REGEXP)) {
-	return rb_str_subpat(str, indx, INT2FIX(0));
+        return rb_str_subpat(str, indx, INT2FIX(0));
     }
     else if (RB_TYPE_P(indx, T_STRING)) {
-	if (rb_str_index(str, indx, 0) != -1)
+        if (rb_str_index(str, indx, 0) != -1)
             return str_duplicate(rb_cString, indx);
-	return Qnil;
+        return Qnil;
     }
     else {
-	/* check if indx is Range */
-	long beg, len = str_strlen(str, NULL);
-	switch (rb_range_beg_len(indx, &beg, &len, len, 0)) {
-	  case Qfalse:
-	    break;
-	  case Qnil:
-	    return Qnil;
-	  default:
-	    return rb_str_substr(str, beg, len);
-	}
-	idx = NUM2LONG(indx);
+        /* check if indx is Range */
+        long beg, len = str_strlen(str, NULL);
+        switch (rb_range_beg_len(indx, &beg, &len, len, 0)) {
+          case Qfalse:
+            break;
+          case Qnil:
+            return Qnil;
+          default:
+            return rb_str_substr(str, beg, len);
+        }
+        idx = NUM2LONG(indx);
     }
 
     return str_substr(str, idx, 1, FALSE);
@@ -5214,14 +5214,14 @@ static VALUE
 rb_str_aref_m(int argc, VALUE *argv, VALUE str)
 {
     if (argc == 2) {
-	if (RB_TYPE_P(argv[0], T_REGEXP)) {
-	    return rb_str_subpat(str, argv[0], argv[1]);
-	}
-	else {
-	    long beg = NUM2LONG(argv[0]);
-	    long len = NUM2LONG(argv[1]);
-	    return rb_str_substr(str, beg, len);
-	}
+        if (RB_TYPE_P(argv[0], T_REGEXP)) {
+            return rb_str_subpat(str, argv[0], argv[1]);
+        }
+        else {
+            long beg = NUM2LONG(argv[0]);
+            long len = NUM2LONG(argv[1]);
+            return rb_str_substr(str, beg, len);
+        }
     }
     rb_check_arity(argc, 1, 2);
     return rb_str_aref(str, argv[0]);
@@ -5237,13 +5237,13 @@ rb_str_drop_bytes(VALUE str, long len)
     if (len > olen) len = olen;
     nlen = olen - len;
     if (str_embed_capa(str) >= nlen + TERM_LEN(str)) {
-	char *oldptr = ptr;
-	int fl = (int)(RBASIC(str)->flags & (STR_NOEMBED|STR_SHARED|STR_NOFREE));
-	STR_SET_EMBED(str);
-	STR_SET_EMBED_LEN(str, nlen);
+        char *oldptr = ptr;
+        int fl = (int)(RBASIC(str)->flags & (STR_NOEMBED|STR_SHARED|STR_NOFREE));
+        STR_SET_EMBED(str);
+        STR_SET_EMBED_LEN(str, nlen);
         ptr = RSTRING(str)->as.embed.ary;
-	memmove(ptr, oldptr + len, nlen);
-	if (fl == STR_NOEMBED) xfree(oldptr);
+        memmove(ptr, oldptr + len, nlen);
+        if (fl == STR_NOEMBED) xfree(oldptr);
     }
     else {
         if (!STR_SHARED_P(str)) {
@@ -5251,8 +5251,8 @@ rb_str_drop_bytes(VALUE str, long len)
             rb_enc_cr_str_exact_copy(shared, str);
             OBJ_FREEZE(shared);
         }
-	ptr = RSTRING(str)->as.heap.ptr += len;
-	RSTRING(str)->as.heap.len = nlen;
+        ptr = RSTRING(str)->as.heap.ptr += len;
+        RSTRING(str)->as.heap.len = nlen;
     }
     ptr[nlen] = 0;
     ENC_CODERANGE_CLEAR(str);
@@ -5267,33 +5267,33 @@ rb_str_splice_0(VALUE str, long beg, long len, VALUE val)
     int cr;
 
     if (beg == 0 && vlen == 0) {
-	rb_str_drop_bytes(str, len);
-	return;
+        rb_str_drop_bytes(str, len);
+        return;
     }
 
     str_modify_keep_cr(str);
     RSTRING_GETMEM(str, sptr, slen);
     if (len < vlen) {
-	/* expand string */
-	RESIZE_CAPA(str, slen + vlen - len);
-	sptr = RSTRING_PTR(str);
+        /* expand string */
+        RESIZE_CAPA(str, slen + vlen - len);
+        sptr = RSTRING_PTR(str);
     }
 
     if (ENC_CODERANGE(str) == ENC_CODERANGE_7BIT)
-	cr = rb_enc_str_coderange(val);
+        cr = rb_enc_str_coderange(val);
     else
-	cr = ENC_CODERANGE_UNKNOWN;
+        cr = ENC_CODERANGE_UNKNOWN;
 
     if (vlen != len) {
-	memmove(sptr + beg + vlen,
-		sptr + beg + len,
-		slen - (beg + len));
+        memmove(sptr + beg + vlen,
+                sptr + beg + len,
+                slen - (beg + len));
     }
     if (vlen < beg && len < 0) {
-	MEMZERO(sptr + slen, char, -len);
+        MEMZERO(sptr + slen, char, -len);
     }
     if (vlen > 0) {
-	memmove(sptr + beg, RSTRING_PTR(val), vlen);
+        memmove(sptr + beg, RSTRING_PTR(val), vlen);
     }
     slen += vlen - len;
     STR_SET_LEN(str, slen);
@@ -5317,15 +5317,15 @@ rb_str_update(VALUE str, long beg, long len, VALUE val)
     slen = str_strlen(str, enc); /* rb_enc_check */
 
     if ((slen < beg) || ((beg < 0) && (beg + slen < 0))) {
-	rb_raise(rb_eIndexError, "index %ld out of string", beg);
+        rb_raise(rb_eIndexError, "index %ld out of string", beg);
     }
     if (beg < 0) {
-	beg += slen;
+        beg += slen;
     }
     assert(beg >= 0);
     assert(beg <= slen);
     if (len > slen - beg) {
-	len = slen - beg;
+        len = slen - beg;
     }
     str_modify_keep_cr(str);
     p = str_nth(RSTRING_PTR(str), RSTRING_END(str), beg, enc, singlebyte);
@@ -5339,7 +5339,7 @@ rb_str_update(VALUE str, long beg, long len, VALUE val)
     rb_enc_associate(str, enc);
     cr = ENC_CODERANGE_AND(ENC_CODERANGE(str), ENC_CODERANGE(val));
     if (cr != ENC_CODERANGE_BROKEN)
-	ENC_CODERANGE_SET(str, cr);
+        ENC_CODERANGE_SET(str, cr);
 }
 
 #define rb_str_splice(str, beg, len, val) rb_str_update(str, beg, len, val)
@@ -5354,21 +5354,21 @@ rb_str_subpat_set(VALUE str, VALUE re, VALUE backref, VALUE val)
     struct re_registers *regs;
 
     if (rb_reg_search(re, str, 0, 0) < 0) {
-	rb_raise(rb_eIndexError, "regexp not matched");
+        rb_raise(rb_eIndexError, "regexp not matched");
     }
     match = rb_backref_get();
     nth = rb_reg_backref_number(match, backref);
     regs = RMATCH_REGS(match);
     if ((nth >= regs->num_regs) || ((nth < 0) && (-nth >= regs->num_regs))) {
-	rb_raise(rb_eIndexError, "index %d out of regexp", nth);
+        rb_raise(rb_eIndexError, "index %d out of regexp", nth);
     }
     if (nth < 0) {
-	nth += regs->num_regs;
+        nth += regs->num_regs;
     }
 
     start = BEG(nth);
     if (start == -1) {
-	rb_raise(rb_eIndexError, "regexp group %d not matched", nth);
+        rb_raise(rb_eIndexError, "regexp group %d not matched", nth);
     }
     end = END(nth);
     len = end - start;
@@ -5385,31 +5385,31 @@ rb_str_aset(VALUE str, VALUE indx, VALUE val)
 
     switch (TYPE(indx)) {
       case T_REGEXP:
-	rb_str_subpat_set(str, indx, INT2FIX(0), val);
-	return val;
+        rb_str_subpat_set(str, indx, INT2FIX(0), val);
+        return val;
 
       case T_STRING:
-	beg = rb_str_index(str, indx, 0);
-	if (beg < 0) {
-	    rb_raise(rb_eIndexError, "string not matched");
-	}
-	beg = rb_str_sublen(str, beg);
-	rb_str_splice(str, beg, str_strlen(indx, NULL), val);
-	return val;
+        beg = rb_str_index(str, indx, 0);
+        if (beg < 0) {
+            rb_raise(rb_eIndexError, "string not matched");
+        }
+        beg = rb_str_sublen(str, beg);
+        rb_str_splice(str, beg, str_strlen(indx, NULL), val);
+        return val;
 
       default:
-	/* check if indx is Range */
-	{
-	    long beg, len;
-	    if (rb_range_beg_len(indx, &beg, &len, str_strlen(str, NULL), 2)) {
-		rb_str_splice(str, beg, len, val);
-		return val;
-	    }
-	}
+        /* check if indx is Range */
+        {
+            long beg, len;
+            if (rb_range_beg_len(indx, &beg, &len, str_strlen(str, NULL), 2)) {
+                rb_str_splice(str, beg, len, val);
+                return val;
+            }
+        }
         /* FALLTHROUGH */
 
       case T_FIXNUM:
-	idx = NUM2LONG(indx);
+        idx = NUM2LONG(indx);
         rb_str_splice(str, idx, 1, val);
         return val;
     }
@@ -5448,13 +5448,13 @@ static VALUE
 rb_str_aset_m(int argc, VALUE *argv, VALUE str)
 {
     if (argc == 3) {
-	if (RB_TYPE_P(argv[0], T_REGEXP)) {
-	    rb_str_subpat_set(str, argv[0], argv[1], argv[2]);
-	}
-	else {
-	    rb_str_splice(str, NUM2LONG(argv[0]), NUM2LONG(argv[1]), argv[2]);
-	}
-	return argv[2];
+        if (RB_TYPE_P(argv[0], T_REGEXP)) {
+            rb_str_subpat_set(str, argv[0], argv[1], argv[2]);
+        }
+        else {
+            rb_str_splice(str, NUM2LONG(argv[0]), NUM2LONG(argv[1]), argv[2]);
+        }
+        return argv[2];
     }
     rb_check_arity(argc, 2, 3);
     return rb_str_aset(str, argv[0], argv[1]);
@@ -5484,10 +5484,10 @@ rb_str_insert(VALUE str, VALUE idx, VALUE str2)
     long pos = NUM2LONG(idx);
 
     if (pos == -1) {
-	return rb_str_append(str, str2);
+        return rb_str_append(str, str2);
     }
     else if (pos < 0) {
-	pos++;
+        pos++;
     }
     rb_str_splice(str, pos, 0, str2);
     return str;
@@ -5528,50 +5528,50 @@ rb_str_slice_bang(int argc, VALUE *argv, VALUE str)
     str_modify_keep_cr(str);
     indx = argv[0];
     if (RB_TYPE_P(indx, T_REGEXP)) {
-	if (rb_reg_search(indx, str, 0, 0) < 0) return Qnil;
-	VALUE match = rb_backref_get();
-	struct re_registers *regs = RMATCH_REGS(match);
-	int nth = 0;
-	if (argc > 1 && (nth = rb_reg_backref_number(match, argv[1])) < 0) {
-	    if ((nth += regs->num_regs) <= 0) return Qnil;
-	}
-	else if (nth >= regs->num_regs) return Qnil;
-	beg = BEG(nth);
-	len = END(nth) - beg;
+        if (rb_reg_search(indx, str, 0, 0) < 0) return Qnil;
+        VALUE match = rb_backref_get();
+        struct re_registers *regs = RMATCH_REGS(match);
+        int nth = 0;
+        if (argc > 1 && (nth = rb_reg_backref_number(match, argv[1])) < 0) {
+            if ((nth += regs->num_regs) <= 0) return Qnil;
+        }
+        else if (nth >= regs->num_regs) return Qnil;
+        beg = BEG(nth);
+        len = END(nth) - beg;
         goto subseq;
     }
     else if (argc == 2) {
-	beg = NUM2LONG(indx);
-	len = NUM2LONG(argv[1]);
+        beg = NUM2LONG(indx);
+        len = NUM2LONG(argv[1]);
         goto num_index;
     }
     else if (FIXNUM_P(indx)) {
-	beg = FIX2LONG(indx);
-	if (!(p = rb_str_subpos(str, beg, &len))) return Qnil;
-	if (!len) return Qnil;
-	beg = p - RSTRING_PTR(str);
-	goto subseq;
+        beg = FIX2LONG(indx);
+        if (!(p = rb_str_subpos(str, beg, &len))) return Qnil;
+        if (!len) return Qnil;
+        beg = p - RSTRING_PTR(str);
+        goto subseq;
     }
     else if (RB_TYPE_P(indx, T_STRING)) {
-	beg = rb_str_index(str, indx, 0);
-	if (beg == -1) return Qnil;
-	len = RSTRING_LEN(indx);
+        beg = rb_str_index(str, indx, 0);
+        if (beg == -1) return Qnil;
+        len = RSTRING_LEN(indx);
         result = str_duplicate(rb_cString, indx);
         goto squash;
     }
     else {
-	switch (rb_range_beg_len(indx, &beg, &len, str_strlen(str, NULL), 0)) {
-	  case Qnil:
-	    return Qnil;
-	  case Qfalse:
-	    beg = NUM2LONG(indx);
-	    if (!(p = rb_str_subpos(str, beg, &len))) return Qnil;
-	    if (!len) return Qnil;
-	    beg = p - RSTRING_PTR(str);
-	    goto subseq;
-	  default:
-	    goto num_index;
-	}
+        switch (rb_range_beg_len(indx, &beg, &len, str_strlen(str, NULL), 0)) {
+          case Qnil:
+            return Qnil;
+          case Qfalse:
+            beg = NUM2LONG(indx);
+            if (!(p = rb_str_subpos(str, beg, &len))) return Qnil;
+            if (!len) return Qnil;
+            beg = p - RSTRING_PTR(str);
+            goto subseq;
+          default:
+            goto num_index;
+        }
     }
 
   num_index:
@@ -5584,21 +5584,21 @@ rb_str_slice_bang(int argc, VALUE *argv, VALUE str)
 
   squash:
     if (len > 0) {
-	if (beg == 0) {
-	    rb_str_drop_bytes(str, len);
-	}
-	else {
-	    char *sptr = RSTRING_PTR(str);
-	    long slen = RSTRING_LEN(str);
-	    if (beg + len > slen) /* pathological check */
-		len = slen - beg;
-	    memmove(sptr + beg,
-		    sptr + beg + len,
-		    slen - (beg + len));
-	    slen -= len;
-	    STR_SET_LEN(str, slen);
-	    TERM_FILL(&sptr[slen], TERM_LEN(str));
-	}
+        if (beg == 0) {
+            rb_str_drop_bytes(str, len);
+        }
+        else {
+            char *sptr = RSTRING_PTR(str);
+            long slen = RSTRING_LEN(str);
+            if (beg + len > slen) /* pathological check */
+                len = slen - beg;
+            memmove(sptr + beg,
+                    sptr + beg + len,
+                    slen - (beg + len));
+            slen -= len;
+            STR_SET_LEN(str, slen);
+            TERM_FILL(&sptr[slen], TERM_LEN(str));
+        }
     }
     return result;
 }
@@ -5610,17 +5610,17 @@ get_pat(VALUE pat)
 
     switch (OBJ_BUILTIN_TYPE(pat)) {
       case T_REGEXP:
-	return pat;
+        return pat;
 
       case T_STRING:
-	break;
+        break;
 
       default:
-	val = rb_check_string_type(pat);
-	if (NIL_P(val)) {
-	    Check_Type(pat, T_REGEXP);
-	}
-	pat = val;
+        val = rb_check_string_type(pat);
+        if (NIL_P(val)) {
+            Check_Type(pat, T_REGEXP);
+        }
+        pat = val;
     }
 
     return rb_reg_regcomp(pat);
@@ -5633,20 +5633,20 @@ get_pat_quoted(VALUE pat, int check)
 
     switch (OBJ_BUILTIN_TYPE(pat)) {
       case T_REGEXP:
-	return pat;
+        return pat;
 
       case T_STRING:
-	break;
+        break;
 
       default:
-	val = rb_check_string_type(pat);
-	if (NIL_P(val)) {
-	    Check_Type(pat, T_REGEXP);
-	}
-	pat = val;
+        val = rb_check_string_type(pat);
+        if (NIL_P(val)) {
+            Check_Type(pat, T_REGEXP);
+        }
+        pat = val;
     }
     if (check && is_broken_string(pat)) {
-	rb_exc_raise(rb_reg_check_preprocess(pat));
+        rb_exc_raise(rb_reg_check_preprocess(pat));
     }
     return pat;
 }
@@ -5655,20 +5655,20 @@ static long
 rb_pat_search(VALUE pat, VALUE str, long pos, int set_backref_str)
 {
     if (BUILTIN_TYPE(pat) == T_STRING) {
-	pos = rb_strseq_index(str, pat, pos, 1);
-	if (set_backref_str) {
-	    if (pos >= 0) {
+        pos = rb_strseq_index(str, pat, pos, 1);
+        if (set_backref_str) {
+            if (pos >= 0) {
                 str = rb_str_new_frozen_String(str);
-		rb_backref_set_string(str, pos, RSTRING_LEN(pat));
-	    }
-	    else {
-		rb_backref_set(Qnil);
-	    }
-	}
-	return pos;
+                rb_backref_set_string(str, pos, RSTRING_LEN(pat));
+            }
+            else {
+                rb_backref_set(Qnil);
+            }
+        }
+        return pos;
     }
     else {
-	return rb_reg_search0(pat, str, pos, 0, set_backref_str);
+        return rb_reg_search0(pat, str, pos, 0, set_backref_str);
     }
 }
 
@@ -5698,14 +5698,14 @@ rb_str_sub_bang(int argc, VALUE *argv, VALUE str)
 
     rb_check_arity(argc, min_arity, 2);
     if (argc == 1) {
-	iter = 1;
+        iter = 1;
     }
     else {
-	repl = argv[1];
-	hash = rb_check_hash_type(argv[1]);
-	if (NIL_P(hash)) {
-	    StringValue(repl);
-	}
+        repl = argv[1];
+        hash = rb_check_hash_type(argv[1]);
+        if (NIL_P(hash)) {
+            StringValue(repl);
+        }
     }
 
     pat = get_pat_quoted(argv[0], 1);
@@ -5713,29 +5713,29 @@ rb_str_sub_bang(int argc, VALUE *argv, VALUE str)
     str_modifiable(str);
     beg = rb_pat_search(pat, str, 0, 1);
     if (beg >= 0) {
-	rb_encoding *enc;
-	int cr = ENC_CODERANGE(str);
-	long beg0, end0;
-	VALUE match, match0 = Qnil;
-	struct re_registers *regs;
-	char *p, *rp;
-	long len, rlen;
-
-	match = rb_backref_get();
-	regs = RMATCH_REGS(match);
-	if (RB_TYPE_P(pat, T_STRING)) {
-	    beg0 = beg;
-	    end0 = beg0 + RSTRING_LEN(pat);
-	    match0 = pat;
-	}
-	else {
-	    beg0 = BEG(0);
-	    end0 = END(0);
-	    if (iter) match0 = rb_reg_nth_match(0, match);
-	}
-
-	if (iter || !NIL_P(hash)) {
-	    p = RSTRING_PTR(str); len = RSTRING_LEN(str);
+        rb_encoding *enc;
+        int cr = ENC_CODERANGE(str);
+        long beg0, end0;
+        VALUE match, match0 = Qnil;
+        struct re_registers *regs;
+        char *p, *rp;
+        long len, rlen;
+
+        match = rb_backref_get();
+        regs = RMATCH_REGS(match);
+        if (RB_TYPE_P(pat, T_STRING)) {
+            beg0 = beg;
+            end0 = beg0 + RSTRING_LEN(pat);
+            match0 = pat;
+        }
+        else {
+            beg0 = BEG(0);
+            end0 = END(0);
+            if (iter) match0 = rb_reg_nth_match(0, match);
+        }
+
+        if (iter || !NIL_P(hash)) {
+            p = RSTRING_PTR(str); len = RSTRING_LEN(str);
 
             if (iter) {
                 repl = rb_obj_as_string(rb_yield(match0));
@@ -5744,53 +5744,53 @@ rb_str_sub_bang(int argc, VALUE *argv, VALUE str)
                 repl = rb_hash_aref(hash, rb_str_subseq(str, beg0, end0 - beg0));
                 repl = rb_obj_as_string(repl);
             }
-	    str_mod_check(str, p, len);
-	    rb_check_frozen(str);
-	}
-	else {
-	    repl = rb_reg_regsub(repl, str, regs, RB_TYPE_P(pat, T_STRING) ? Qnil : pat);
-	}
+            str_mod_check(str, p, len);
+            rb_check_frozen(str);
+        }
+        else {
+            repl = rb_reg_regsub(repl, str, regs, RB_TYPE_P(pat, T_STRING) ? Qnil : pat);
+        }
 
         enc = rb_enc_compatible(str, repl);
         if (!enc) {
             rb_encoding *str_enc = STR_ENC_GET(str);
-	    p = RSTRING_PTR(str); len = RSTRING_LEN(str);
-	    if (coderange_scan(p, beg0, str_enc) != ENC_CODERANGE_7BIT ||
-		coderange_scan(p+end0, len-end0, str_enc) != ENC_CODERANGE_7BIT) {
+            p = RSTRING_PTR(str); len = RSTRING_LEN(str);
+            if (coderange_scan(p, beg0, str_enc) != ENC_CODERANGE_7BIT ||
+                coderange_scan(p+end0, len-end0, str_enc) != ENC_CODERANGE_7BIT) {
                 rb_raise(rb_eEncCompatError, "incompatible character encodings: %s and %s",
-			 rb_enc_name(str_enc),
-			 rb_enc_name(STR_ENC_GET(repl)));
+                         rb_enc_name(str_enc),
+                         rb_enc_name(STR_ENC_GET(repl)));
             }
             enc = STR_ENC_GET(repl);
         }
-	rb_str_modify(str);
-	rb_enc_associate(str, enc);
-	if (ENC_CODERANGE_UNKNOWN < cr && cr < ENC_CODERANGE_BROKEN) {
-	    int cr2 = ENC_CODERANGE(repl);
+        rb_str_modify(str);
+        rb_enc_associate(str, enc);
+        if (ENC_CODERANGE_UNKNOWN < cr && cr < ENC_CODERANGE_BROKEN) {
+            int cr2 = ENC_CODERANGE(repl);
             if (cr2 == ENC_CODERANGE_BROKEN ||
                 (cr == ENC_CODERANGE_VALID && cr2 == ENC_CODERANGE_7BIT))
                 cr = ENC_CODERANGE_UNKNOWN;
             else
                 cr = cr2;
-	}
-	plen = end0 - beg0;
+        }
+        plen = end0 - beg0;
         rlen = RSTRING_LEN(repl);
-	len = RSTRING_LEN(str);
-	if (rlen > plen) {
-	    RESIZE_CAPA(str, len + rlen - plen);
-	}
-	p = RSTRING_PTR(str);
-	if (rlen != plen) {
-	    memmove(p + beg0 + rlen, p + beg0 + plen, len - beg0 - plen);
-	}
+        len = RSTRING_LEN(str);
+        if (rlen > plen) {
+            RESIZE_CAPA(str, len + rlen - plen);
+        }
+        p = RSTRING_PTR(str);
+        if (rlen != plen) {
+            memmove(p + beg0 + rlen, p + beg0 + plen, len - beg0 - plen);
+        }
         rp = RSTRING_PTR(repl);
         memmove(p + beg0, rp, rlen);
-	len += rlen - plen;
-	STR_SET_LEN(str, len);
-	TERM_FILL(&RSTRING_PTR(str)[len], TERM_LEN(str));
-	ENC_CODERANGE_SET(str, cr);
+        len += rlen - plen;
+        STR_SET_LEN(str, len);
+        TERM_FILL(&RSTRING_PTR(str)[len], TERM_LEN(str));
+        ENC_CODERANGE_SET(str, cr);
 
-	return str;
+        return str;
     }
     return Qnil;
 }
@@ -5832,19 +5832,19 @@ str_gsub(int argc, VALUE *argv, VALUE str, int bang)
 
     switch (argc) {
       case 1:
-	RETURN_ENUMERATOR(str, argc, argv);
-	mode = ITER;
-	break;
+        RETURN_ENUMERATOR(str, argc, argv);
+        mode = ITER;
+        break;
       case 2:
-	repl = argv[1];
-	hash = rb_check_hash_type(argv[1]);
-	if (NIL_P(hash)) {
-	    StringValue(repl);
-	}
-	else {
-	    mode = MAP;
-	}
-	break;
+        repl = argv[1];
+        hash = rb_check_hash_type(argv[1]);
+        if (NIL_P(hash)) {
+            StringValue(repl);
+        }
+        else {
+            mode = MAP;
+        }
+        break;
       default:
         rb_error_arity(argc, 1, 2);
     }
@@ -5852,7 +5852,7 @@ str_gsub(int argc, VALUE *argv, VALUE str, int bang)
     pat = get_pat_quoted(argv[0], 1);
     beg = rb_pat_search(pat, str, 0, need_backref);
     if (beg < 0) {
-	if (bang) return Qnil;	/* no match, no substitution */
+        if (bang) return Qnil;	/* no match, no substitution */
         return str_duplicate(rb_cString, str);
     }
 
@@ -5867,20 +5867,20 @@ str_gsub(int argc, VALUE *argv, VALUE str, int bang)
     ENC_CODERANGE_SET(dest, rb_enc_asciicompat(str_enc) ? ENC_CODERANGE_7BIT : ENC_CODERANGE_VALID);
 
     do {
-	match = rb_backref_get();
-	regs = RMATCH_REGS(match);
-	if (RB_TYPE_P(pat, T_STRING)) {
-	    beg0 = beg;
-	    end0 = beg0 + RSTRING_LEN(pat);
-	    match0 = pat;
-	}
-	else {
-	    beg0 = BEG(0);
-	    end0 = END(0);
-	    if (mode == ITER) match0 = rb_reg_nth_match(0, match);
-	}
-
-	if (mode) {
+        match = rb_backref_get();
+        regs = RMATCH_REGS(match);
+        if (RB_TYPE_P(pat, T_STRING)) {
+            beg0 = beg;
+            end0 = beg0 + RSTRING_LEN(pat);
+            match0 = pat;
+        }
+        else {
+            beg0 = BEG(0);
+            end0 = END(0);
+            if (mode == ITER) match0 = rb_reg_nth_match(0, match);
+        }
+
+        if (mode) {
             if (mode == ITER) {
                 val = rb_obj_as_string(rb_yield(match0));
             }
@@ -5888,43 +5888,43 @@ str_gsub(int argc, VALUE *argv, VALUE str, int bang)
                 val = rb_hash_aref(hash, rb_str_subseq(str, beg0, end0 - beg0));
                 val = rb_obj_as_string(val);
             }
-	    str_mod_check(str, sp, slen);
-	    if (val == dest) { 	/* paranoid check [ruby-dev:24827] */
-		rb_raise(rb_eRuntimeError, "block should not cheat");
-	    }
-	}
-	else if (need_backref) {
-	    val = rb_reg_regsub(repl, str, regs, RB_TYPE_P(pat, T_STRING) ? Qnil : pat);
-	    if (need_backref < 0) {
-		need_backref = val != repl;
-	    }
-	}
-	else {
-	    val = repl;
-	}
-
-	len = beg0 - offset;	/* copy pre-match substr */
+            str_mod_check(str, sp, slen);
+            if (val == dest) { 	/* paranoid check [ruby-dev:24827] */
+                rb_raise(rb_eRuntimeError, "block should not cheat");
+            }
+        }
+        else if (need_backref) {
+            val = rb_reg_regsub(repl, str, regs, RB_TYPE_P(pat, T_STRING) ? Qnil : pat);
+            if (need_backref < 0) {
+                need_backref = val != repl;
+            }
+        }
+        else {
+            val = repl;
+        }
+
+        len = beg0 - offset;	/* copy pre-match substr */
         if (len) {
             rb_enc_str_buf_cat(dest, cp, len, str_enc);
         }
 
         rb_str_buf_append(dest, val);
 
-	last = offset;
-	offset = end0;
-	if (beg0 == end0) {
-	    /*
-	     * Always consume at least one character of the input string
-	     * in order to prevent infinite loops.
-	     */
-	    if (RSTRING_LEN(str) <= end0) break;
-	    len = rb_enc_fast_mbclen(RSTRING_PTR(str)+end0, RSTRING_END(str), str_enc);
+        last = offset;
+        offset = end0;
+        if (beg0 == end0) {
+            /*
+             * Always consume at least one character of the input string
+             * in order to prevent infinite loops.
+             */
+            if (RSTRING_LEN(str) <= end0) break;
+            len = rb_enc_fast_mbclen(RSTRING_PTR(str)+end0, RSTRING_END(str), str_enc);
             rb_enc_str_buf_cat(dest, RSTRING_PTR(str)+end0, len, str_enc);
-	    offset = end0 + len;
-	}
-	cp = RSTRING_PTR(str) + offset;
-	if (offset > RSTRING_LEN(str)) break;
-	beg = rb_pat_search(pat, str, offset, need_backref);
+            offset = end0 + len;
+        }
+        cp = RSTRING_PTR(str) + offset;
+        if (offset > RSTRING_LEN(str)) break;
+        beg = rb_pat_search(pat, str, offset, need_backref);
     } while (beg >= 0);
     if (RSTRING_LEN(str) > offset) {
         rb_enc_str_buf_cat(dest, cp, RSTRING_LEN(str) - offset, str_enc);
@@ -5934,7 +5934,7 @@ str_gsub(int argc, VALUE *argv, VALUE str, int bang)
         str_shared_replace(str, dest);
     }
     else {
-	str = dest;
+        str = dest;
     }
 
     return str;
@@ -6030,9 +6030,9 @@ rb_str_clear(VALUE str)
     STR_SET_EMBED_LEN(str, 0);
     RSTRING_PTR(str)[0] = 0;
     if (rb_enc_asciicompat(STR_ENC_GET(str)))
-	ENC_CODERANGE_SET(str, ENC_CODERANGE_7BIT);
+        ENC_CODERANGE_SET(str, ENC_CODERANGE_7BIT);
     else
-	ENC_CODERANGE_SET(str, ENC_CODERANGE_VALID);
+        ENC_CODERANGE_SET(str, ENC_CODERANGE_VALID);
     return str;
 }
 
@@ -6110,34 +6110,34 @@ rb_str_setbyte(VALUE str, VALUE index, VALUE value)
     char byte = (char)(NUM2INT(w) & 0xFF);
 
     if (!str_independent(str))
-	str_make_independent(str);
+        str_make_independent(str);
     enc = STR_ENC_GET(str);
     head = RSTRING_PTR(str);
     ptr = &head[pos];
     if (!STR_EMBED_P(str)) {
-	cr = ENC_CODERANGE(str);
-	switch (cr) {
-	  case ENC_CODERANGE_7BIT:
+        cr = ENC_CODERANGE(str);
+        switch (cr) {
+          case ENC_CODERANGE_7BIT:
             left = ptr;
-	    *ptr = byte;
-	    if (ISASCII(byte)) goto end;
-	    nlen = rb_enc_precise_mbclen(left, head+len, enc);
-	    if (!MBCLEN_CHARFOUND_P(nlen))
-		ENC_CODERANGE_SET(str, ENC_CODERANGE_BROKEN);
-	    else
-		ENC_CODERANGE_SET(str, ENC_CODERANGE_VALID);
-	    goto end;
-	  case ENC_CODERANGE_VALID:
-	    left = rb_enc_left_char_head(head, ptr, head+len, enc);
-	    width = rb_enc_precise_mbclen(left, head+len, enc);
-	    *ptr = byte;
-	    nlen = rb_enc_precise_mbclen(left, head+len, enc);
-	    if (!MBCLEN_CHARFOUND_P(nlen))
-		ENC_CODERANGE_SET(str, ENC_CODERANGE_BROKEN);
-	    else if (MBCLEN_CHARFOUND_LEN(nlen) != width || ISASCII(byte))
-		ENC_CODERANGE_CLEAR(str);
-	    goto end;
-	}
+            *ptr = byte;
+            if (ISASCII(byte)) goto end;
+            nlen = rb_enc_precise_mbclen(left, head+len, enc);
+            if (!MBCLEN_CHARFOUND_P(nlen))
+                ENC_CODERANGE_SET(str, ENC_CODERANGE_BROKEN);
+            else
+                ENC_CODERANGE_SET(str, ENC_CODERANGE_VALID);
+            goto end;
+          case ENC_CODERANGE_VALID:
+            left = rb_enc_left_char_head(head, ptr, head+len, enc);
+            width = rb_enc_precise_mbclen(left, head+len, enc);
+            *ptr = byte;
+            nlen = rb_enc_precise_mbclen(left, head+len, enc);
+            if (!MBCLEN_CHARFOUND_P(nlen))
+                ENC_CODERANGE_SET(str, ENC_CODERANGE_BROKEN);
+            else if (MBCLEN_CHARFOUND_LEN(nlen) != width || ISASCII(byte))
+                ENC_CODERANGE_CLEAR(str);
+            goto end;
+        }
     }
     ENC_CODERANGE_CLEAR(str);
     *ptr = byte;
@@ -6155,24 +6155,24 @@ str_byte_substr(VALUE str, long beg, long len, int empty)
 
     if (beg > n || len < 0) return Qnil;
     if (beg < 0) {
-	beg += n;
-	if (beg < 0) return Qnil;
+        beg += n;
+        if (beg < 0) return Qnil;
     }
     if (len > n - beg)
-	len = n - beg;
+        len = n - beg;
     if (len <= 0) {
-	if (!empty) return Qnil;
-	len = 0;
-	p = 0;
+        if (!empty) return Qnil;
+        len = 0;
+        p = 0;
     }
     else
-	p = s + beg;
+        p = s + beg;
 
     if (!STR_EMBEDDABLE_P(len, TERM_LEN(str)) && SHARABLE_SUBSTRING_P(beg, len, n)) {
-	str2 = rb_str_new_frozen(str);
+        str2 = rb_str_new_frozen(str);
         str2 = str_new_shared(rb_cString, str2);
-	RSTRING(str2)->as.heap.ptr += beg;
-	RSTRING(str2)->as.heap.len = len;
+        RSTRING(str2)->as.heap.ptr += beg;
+        RSTRING(str2)->as.heap.len = len;
     }
     else {
         str2 = rb_str_new(p, len);
@@ -6181,20 +6181,20 @@ str_byte_substr(VALUE str, long beg, long len, int empty)
     str_enc_copy(str2, str);
 
     if (RSTRING_LEN(str2) == 0) {
-	if (!rb_enc_asciicompat(STR_ENC_GET(str)))
-	    ENC_CODERANGE_SET(str2, ENC_CODERANGE_VALID);
-	else
-	    ENC_CODERANGE_SET(str2, ENC_CODERANGE_7BIT);
+        if (!rb_enc_asciicompat(STR_ENC_GET(str)))
+            ENC_CODERANGE_SET(str2, ENC_CODERANGE_VALID);
+        else
+            ENC_CODERANGE_SET(str2, ENC_CODERANGE_7BIT);
     }
     else {
-	switch (ENC_CODERANGE(str)) {
-	  case ENC_CODERANGE_7BIT:
-	    ENC_CODERANGE_SET(str2, ENC_CODERANGE_7BIT);
-	    break;
-	  default:
-	    ENC_CODERANGE_SET(str2, ENC_CODERANGE_UNKNOWN);
-	    break;
-	}
+        switch (ENC_CODERANGE(str)) {
+          case ENC_CODERANGE_7BIT:
+            ENC_CODERANGE_SET(str2, ENC_CODERANGE_7BIT);
+            break;
+          default:
+            ENC_CODERANGE_SET(str2, ENC_CODERANGE_UNKNOWN);
+            break;
+        }
     }
 
     return str2;
@@ -6205,22 +6205,22 @@ str_byte_aref(VALUE str, VALUE indx)
 {
     long idx;
     if (FIXNUM_P(indx)) {
-	idx = FIX2LONG(indx);
+        idx = FIX2LONG(indx);
     }
     else {
-	/* check if indx is Range */
-	long beg, len = RSTRING_LEN(str);
+        /* check if indx is Range */
+        long beg, len = RSTRING_LEN(str);
 
-	switch (rb_range_beg_len(indx, &beg, &len, len, 0)) {
-	  case Qfalse:
-	    break;
-	  case Qnil:
-	    return Qnil;
-	  default:
-	    return str_byte_substr(str, beg, len, TRUE);
-	}
+        switch (rb_range_beg_len(indx, &beg, &len, len, 0)) {
+          case Qfalse:
+            break;
+          case Qnil:
+            return Qnil;
+          default:
+            return str_byte_substr(str, beg, len, TRUE);
+        }
 
-	idx = NUM2LONG(indx);
+        idx = NUM2LONG(indx);
     }
     return str_byte_substr(str, idx, 1, FALSE);
 }
@@ -6376,32 +6376,32 @@ rb_str_reverse(VALUE str)
     cr = ENC_CODERANGE(str);
 
     if (RSTRING_LEN(str) > 1) {
-	if (single_byte_optimizable(str)) {
-	    while (s < e) {
-		*--p = *s++;
-	    }
-	}
-	else if (cr == ENC_CODERANGE_VALID) {
-	    while (s < e) {
-		int clen = rb_enc_fast_mbclen(s, e, enc);
-
-		p -= clen;
-		memcpy(p, s, clen);
-		s += clen;
-	    }
-	}
-	else {
-	    cr = rb_enc_asciicompat(enc) ?
-		ENC_CODERANGE_7BIT : ENC_CODERANGE_VALID;
-	    while (s < e) {
-		int clen = rb_enc_mbclen(s, e, enc);
-
-		if (clen > 1 || (*s & 0x80)) cr = ENC_CODERANGE_UNKNOWN;
-		p -= clen;
-		memcpy(p, s, clen);
-		s += clen;
-	    }
-	}
+        if (single_byte_optimizable(str)) {
+            while (s < e) {
+                *--p = *s++;
+            }
+        }
+        else if (cr == ENC_CODERANGE_VALID) {
+            while (s < e) {
+                int clen = rb_enc_fast_mbclen(s, e, enc);
+
+                p -= clen;
+                memcpy(p, s, clen);
+                s += clen;
+            }
+        }
+        else {
+            cr = rb_enc_asciicompat(enc) ?
+                ENC_CODERANGE_7BIT : ENC_CODERANGE_VALID;
+            while (s < e) {
+                int clen = rb_enc_mbclen(s, e, enc);
+
+                if (clen > 1 || (*s & 0x80)) cr = ENC_CODERANGE_UNKNOWN;
+                p -= clen;
+                memcpy(p, s, clen);
+                s += clen;
+            }
+        }
     }
     STR_SET_LEN(rev, RSTRING_LEN(str));
     str_enc_copy(rev, str);
@@ -6427,24 +6427,24 @@ static VALUE
 rb_str_reverse_bang(VALUE str)
 {
     if (RSTRING_LEN(str) > 1) {
-	if (single_byte_optimizable(str)) {
-	    char *s, *e, c;
-
-	    str_modify_keep_cr(str);
-	    s = RSTRING_PTR(str);
-	    e = RSTRING_END(str) - 1;
-	    while (s < e) {
-		c = *s;
-		*s++ = *e;
-		*e-- = c;
-	    }
-	}
-	else {
-	    str_shared_replace(str, rb_str_reverse(str));
-	}
+        if (single_byte_optimizable(str)) {
+            char *s, *e, c;
+
+            str_modify_keep_cr(str);
+            s = RSTRING_PTR(str);
+            e = RSTRING_END(str) - 1;
+            while (s < e) {
+                c = *s;
+                *s++ = *e;
+                *e-- = c;
+            }
+        }
+        else {
+            str_shared_replace(str, rb_str_reverse(str));
+        }
     }
     else {
-	str_modify_keep_cr(str);
+        str_modify_keep_cr(str);
     }
     return str;
 }
@@ -6503,7 +6503,7 @@ rb_str_to_i(int argc, VALUE *argv, VALUE str)
     int base = 10;
 
     if (rb_check_arity(argc, 0, 1) && (base = NUM2INT(argv[0])) < 0) {
-	rb_raise(rb_eArgError, "invalid radix %d", base);
+        rb_raise(rb_eArgError, "invalid radix %d", base);
     }
     return rb_str_to_inum(str, base, FALSE);
 }
@@ -6550,7 +6550,7 @@ static VALUE
 rb_str_to_s(VALUE str)
 {
     if (rb_obj_class(str) != rb_cString) {
-	return str_duplicate(rb_cString, str);
+        return str_duplicate(rb_cString, str);
     }
     return str;
 }
@@ -6579,23 +6579,23 @@ rb_str_buf_cat_escaped_char(VALUE result, unsigned int c, int unicode_p)
     c &= 0xffffffff;
 #endif
     if (unicode_p) {
-	if (c < 0x7F && ISPRINT(c)) {
-	    snprintf(buf, CHAR_ESC_LEN, "%c", c);
-	}
-	else if (c < 0x10000) {
-	    snprintf(buf, CHAR_ESC_LEN, "\\u%04X", c);
-	}
-	else {
-	    snprintf(buf, CHAR_ESC_LEN, "\\u{%X}", c);
-	}
+        if (c < 0x7F && ISPRINT(c)) {
+            snprintf(buf, CHAR_ESC_LEN, "%c", c);
+        }
+        else if (c < 0x10000) {
+            snprintf(buf, CHAR_ESC_LEN, "\\u%04X", c);
+        }
+        else {
+            snprintf(buf, CHAR_ESC_LEN, "\\u{%X}", c);
+        }
     }
     else {
-	if (c < 0x100) {
-	    snprintf(buf, CHAR_ESC_LEN, "\\x%02X", c);
-	}
-	else {
-	    snprintf(buf, CHAR_ESC_LEN, "\\x{%X}", c);
-	}
+        if (c < 0x100) {
+            snprintf(buf, CHAR_ESC_LEN, "\\x%02X", c);
+        }
+        else {
+            snprintf(buf, CHAR_ESC_LEN, "\\x{%X}", c);
+        }
     }
     l = (int)strlen(buf);	/* CHAR_ESC_LEN cannot exceed INT_MAX */
     rb_str_buf_cat(result, buf, l);
@@ -6636,9 +6636,9 @@ rb_str_escape(VALUE str)
     while (p < pend) {
         unsigned int c;
         const char *cc;
-	int n = rb_enc_precise_mbclen(p, pend, enc);
+        int n = rb_enc_precise_mbclen(p, pend, enc);
         if (!MBCLEN_CHARFOUND_P(n)) {
-	    if (p > prev) str_buf_cat(result, prev, p - prev);
+            if (p > prev) str_buf_cat(result, prev, p - prev);
             n = rb_enc_mbminlen(enc);
             if (pend < p + n)
                 n = (int)(pend - p);
@@ -6647,24 +6647,24 @@ rb_str_escape(VALUE str)
                 str_buf_cat(result, buf, strlen(buf));
                 prev = ++p;
             }
-	    continue;
-	}
+            continue;
+        }
         n = MBCLEN_CHARFOUND_LEN(n);
-	c = rb_enc_mbc_to_codepoint(p, pend, enc);
-	p += n;
+        c = rb_enc_mbc_to_codepoint(p, pend, enc);
+        p += n;
         cc = ruby_escaped_char(c);
-	if (cc) {
-	    if (p - n > prev) str_buf_cat(result, prev, p - n - prev);
+        if (cc) {
+            if (p - n > prev) str_buf_cat(result, prev, p - n - prev);
             str_buf_cat(result, cc, strlen(cc));
-	    prev = p;
-	}
-	else if (asciicompat && rb_enc_isascii(c, enc) && ISPRINT(c)) {
-	}
-	else {
-	    if (p - n > prev) str_buf_cat(result, prev, p - n - prev);
-	    rb_str_buf_cat_escaped_char(result, c, unicode_p);
-	    prev = p;
-	}
+            prev = p;
+        }
+        else if (asciicompat && rb_enc_isascii(c, enc) && ISPRINT(c)) {
+        }
+        else {
+            if (p - n > prev) str_buf_cat(result, prev, p - n - prev);
+            rb_str_buf_cat_escaped_char(result, c, unicode_p);
+            prev = p;
+        }
     }
     if (p > prev) str_buf_cat(result, prev, p - prev);
     ENCODING_CODERANGE_SET(result, rb_usascii_encindex(), ENC_CODERANGE_7BIT);
@@ -6706,16 +6706,16 @@ rb_str_inspect(VALUE str)
     prev = p;
     actenc = get_actual_encoding(encidx, str);
     if (actenc != enc) {
-	enc = actenc;
-	if (unicode_p) unicode_p = rb_enc_unicode_p(enc);
+        enc = actenc;
+        if (unicode_p) unicode_p = rb_enc_unicode_p(enc);
     }
     while (p < pend) {
-	unsigned int c, cc;
-	int n;
+        unsigned int c, cc;
+        int n;
 
         n = rb_enc_precise_mbclen(p, pend, enc);
         if (!MBCLEN_CHARFOUND_P(n)) {
-	    if (p > prev) str_buf_cat(result, prev, p - prev);
+            if (p > prev) str_buf_cat(result, prev, p - prev);
             n = rb_enc_mbminlen(enc);
             if (pend < p + n)
                 n = (int)(pend - p);
@@ -6724,54 +6724,54 @@ rb_str_inspect(VALUE str)
                 str_buf_cat(result, buf, strlen(buf));
                 prev = ++p;
             }
-	    continue;
-	}
+            continue;
+        }
         n = MBCLEN_CHARFOUND_LEN(n);
-	c = rb_enc_mbc_to_codepoint(p, pend, enc);
-	p += n;
-	if ((asciicompat || unicode_p) &&
-	  (c == '"'|| c == '\\' ||
-	    (c == '#' &&
+        c = rb_enc_mbc_to_codepoint(p, pend, enc);
+        p += n;
+        if ((asciicompat || unicode_p) &&
+          (c == '"'|| c == '\\' ||
+            (c == '#' &&
              p < pend &&
              MBCLEN_CHARFOUND_P(rb_enc_precise_mbclen(p,pend,enc)) &&
              (cc = rb_enc_codepoint(p,pend,enc),
               (cc == '$' || cc == '@' || cc == '{'))))) {
-	    if (p - n > prev) str_buf_cat(result, prev, p - n - prev);
-	    str_buf_cat2(result, "\\");
-	    if (asciicompat || enc == resenc) {
-		prev = p - n;
-		continue;
-	    }
-	}
-	switch (c) {
-	  case '\n': cc = 'n'; break;
-	  case '\r': cc = 'r'; break;
-	  case '\t': cc = 't'; break;
-	  case '\f': cc = 'f'; break;
-	  case '\013': cc = 'v'; break;
-	  case '\010': cc = 'b'; break;
-	  case '\007': cc = 'a'; break;
-	  case 033: cc = 'e'; break;
-	  default: cc = 0; break;
-	}
-	if (cc) {
-	    if (p - n > prev) str_buf_cat(result, prev, p - n - prev);
-	    buf[0] = '\\';
-	    buf[1] = (char)cc;
-	    str_buf_cat(result, buf, 2);
-	    prev = p;
-	    continue;
-	}
-	if ((enc == resenc && rb_enc_isprint(c, enc)) ||
-	    (asciicompat && rb_enc_isascii(c, enc) && ISPRINT(c))) {
-	    continue;
-	}
-	else {
-	    if (p - n > prev) str_buf_cat(result, prev, p - n - prev);
-	    rb_str_buf_cat_escaped_char(result, c, unicode_p);
-	    prev = p;
-	    continue;
-	}
+            if (p - n > prev) str_buf_cat(result, prev, p - n - prev);
+            str_buf_cat2(result, "\\");
+            if (asciicompat || enc == resenc) {
+                prev = p - n;
+                continue;
+            }
+        }
+        switch (c) {
+          case '\n': cc = 'n'; break;
+          case '\r': cc = 'r'; break;
+          case '\t': cc = 't'; break;
+          case '\f': cc = 'f'; break;
+          case '\013': cc = 'v'; break;
+          case '\010': cc = 'b'; break;
+          case '\007': cc = 'a'; break;
+          case 033: cc = 'e'; break;
+          default: cc = 0; break;
+        }
+        if (cc) {
+            if (p - n > prev) str_buf_cat(result, prev, p - n - prev);
+            buf[0] = '\\';
+            buf[1] = (char)cc;
+            str_buf_cat(result, buf, 2);
+            prev = p;
+            continue;
+        }
+        if ((enc == resenc && rb_enc_isprint(c, enc)) ||
+            (asciicompat && rb_enc_isascii(c, enc) && ISPRINT(c))) {
+            continue;
+        }
+        else {
+            if (p - n > prev) str_buf_cat(result, prev, p - n - prev);
+            rb_str_buf_cat_escaped_char(result, c, unicode_p);
+            prev = p;
+            continue;
+        }
     }
     if (p > prev) str_buf_cat(result, prev, p - prev);
     str_buf_cat2(result, "\"");
@@ -6810,55 +6810,55 @@ rb_str_dump(VALUE str)
 
     len = 2;			/* "" */
     if (!rb_enc_asciicompat(enc)) {
-	len += strlen(nonascii_suffix) - rb_strlen_lit("%s");
-	len += strlen(enc->name);
+        len += strlen(nonascii_suffix) - rb_strlen_lit("%s");
+        len += strlen(enc->name);
     }
 
     p = RSTRING_PTR(str); pend = p + RSTRING_LEN(str);
     while (p < pend) {
-	int clen;
-	unsigned char c = *p++;
-
-	switch (c) {
-	  case '"':  case '\\':
-	  case '\n': case '\r':
-	  case '\t': case '\f':
-	  case '\013': case '\010': case '\007': case '\033':
-	    clen = 2;
-	    break;
-
-	  case '#':
-	    clen = IS_EVSTR(p, pend) ? 2 : 1;
-	    break;
-
-	  default:
-	    if (ISPRINT(c)) {
-		clen = 1;
-	    }
-	    else {
-		if (u8 && c > 0x7F) {	/* \u notation */
-		    int n = rb_enc_precise_mbclen(p-1, pend, enc);
-		    if (MBCLEN_CHARFOUND_P(n)) {
-			unsigned int cc = rb_enc_mbc_to_codepoint(p-1, pend, enc);
-			if (cc <= 0xFFFF)
-			    clen = 6;  /* \uXXXX */
-			else if (cc <= 0xFFFFF)
-			    clen = 9;  /* \u{XXXXX} */
-			else
-			    clen = 10; /* \u{XXXXXX} */
-			p += MBCLEN_CHARFOUND_LEN(n)-1;
-			break;
-		    }
-		}
-		clen = 4;	/* \xNN */
-	    }
-	    break;
-	}
-
-	if (clen > LONG_MAX - len) {
-	    rb_raise(rb_eRuntimeError, "string size too big");
-	}
-	len += clen;
+        int clen;
+        unsigned char c = *p++;
+
+        switch (c) {
+          case '"':  case '\\':
+          case '\n': case '\r':
+          case '\t': case '\f':
+          case '\013': case '\010': case '\007': case '\033':
+            clen = 2;
+            break;
+
+          case '#':
+            clen = IS_EVSTR(p, pend) ? 2 : 1;
+            break;
+
+          default:
+            if (ISPRINT(c)) {
+                clen = 1;
+            }
+            else {
+                if (u8 && c > 0x7F) {	/* \u notation */
+                    int n = rb_enc_precise_mbclen(p-1, pend, enc);
+                    if (MBCLEN_CHARFOUND_P(n)) {
+                        unsigned int cc = rb_enc_mbc_to_codepoint(p-1, pend, enc);
+                        if (cc <= 0xFFFF)
+                            clen = 6;  /* \uXXXX */
+                        else if (cc <= 0xFFFFF)
+                            clen = 9;  /* \u{XXXXX} */
+                        else
+                            clen = 10; /* \u{XXXXXX} */
+                        p += MBCLEN_CHARFOUND_LEN(n)-1;
+                        break;
+                    }
+                }
+                clen = 4;	/* \xNN */
+            }
+            break;
+        }
+
+        if (clen > LONG_MAX - len) {
+            rb_raise(rb_eRuntimeError, "string size too big");
+        }
+        len += clen;
     }
 
     result = rb_str_new(0, len);
@@ -6867,75 +6867,75 @@ rb_str_dump(VALUE str)
 
     *q++ = '"';
     while (p < pend) {
-	unsigned char c = *p++;
-
-	if (c == '"' || c == '\\') {
-	    *q++ = '\\';
-	    *q++ = c;
-	}
-	else if (c == '#') {
-	    if (IS_EVSTR(p, pend)) *q++ = '\\';
-	    *q++ = '#';
-	}
-	else if (c == '\n') {
-	    *q++ = '\\';
-	    *q++ = 'n';
-	}
-	else if (c == '\r') {
-	    *q++ = '\\';
-	    *q++ = 'r';
-	}
-	else if (c == '\t') {
-	    *q++ = '\\';
-	    *q++ = 't';
-	}
-	else if (c == '\f') {
-	    *q++ = '\\';
-	    *q++ = 'f';
-	}
-	else if (c == '\013') {
-	    *q++ = '\\';
-	    *q++ = 'v';
-	}
-	else if (c == '\010') {
-	    *q++ = '\\';
-	    *q++ = 'b';
-	}
-	else if (c == '\007') {
-	    *q++ = '\\';
-	    *q++ = 'a';
-	}
-	else if (c == '\033') {
-	    *q++ = '\\';
-	    *q++ = 'e';
-	}
-	else if (ISPRINT(c)) {
-	    *q++ = c;
-	}
-	else {
-	    *q++ = '\\';
-	    if (u8) {
-		int n = rb_enc_precise_mbclen(p-1, pend, enc) - 1;
-		if (MBCLEN_CHARFOUND_P(n)) {
-		    int cc = rb_enc_mbc_to_codepoint(p-1, pend, enc);
-		    p += n;
-		    if (cc <= 0xFFFF)
-			snprintf(q, qend-q, "u%04X", cc);    /* \uXXXX */
-		    else
-			snprintf(q, qend-q, "u{%X}", cc);  /* \u{XXXXX} or \u{XXXXXX} */
-		    q += strlen(q);
-		    continue;
-		}
-	    }
-	    snprintf(q, qend-q, "x%02X", c);
-	    q += 3;
-	}
+        unsigned char c = *p++;
+
+        if (c == '"' || c == '\\') {
+            *q++ = '\\';
+            *q++ = c;
+        }
+        else if (c == '#') {
+            if (IS_EVSTR(p, pend)) *q++ = '\\';
+            *q++ = '#';
+        }
+        else if (c == '\n') {
+            *q++ = '\\';
+            *q++ = 'n';
+        }
+        else if (c == '\r') {
+            *q++ = '\\';
+            *q++ = 'r';
+        }
+        else if (c == '\t') {
+            *q++ = '\\';
+            *q++ = 't';
+        }
+        else if (c == '\f') {
+            *q++ = '\\';
+            *q++ = 'f';
+        }
+        else if (c == '\013') {
+            *q++ = '\\';
+            *q++ = 'v';
+        }
+        else if (c == '\010') {
+            *q++ = '\\';
+            *q++ = 'b';
+        }
+        else if (c == '\007') {
+            *q++ = '\\';
+            *q++ = 'a';
+        }
+        else if (c == '\033') {
+            *q++ = '\\';
+            *q++ = 'e';
+        }
+        else if (ISPRINT(c)) {
+            *q++ = c;
+        }
+        else {
+            *q++ = '\\';
+            if (u8) {
+                int n = rb_enc_precise_mbclen(p-1, pend, enc) - 1;
+                if (MBCLEN_CHARFOUND_P(n)) {
+                    int cc = rb_enc_mbc_to_codepoint(p-1, pend, enc);
+                    p += n;
+                    if (cc <= 0xFFFF)
+                        snprintf(q, qend-q, "u%04X", cc);    /* \uXXXX */
+                    else
+                        snprintf(q, qend-q, "u{%X}", cc);  /* \u{XXXXX} or \u{XXXXXX} */
+                    q += strlen(q);
+                    continue;
+                }
+            }
+            snprintf(q, qend-q, "x%02X", c);
+            q += 3;
+        }
     }
     *q++ = '"';
     *q = '\0';
     if (!rb_enc_asciicompat(enc)) {
-	snprintf(q, qend-q, nonascii_suffix, enc->name);
-	encidx = rb_ascii8bit_encindex();
+        snprintf(q, qend-q, nonascii_suffix, enc->name);
+        encidx = rb_ascii8bit_encindex();
     }
     /* result from dump is ASCII */
     rb_enc_associate_index(result, encidx);
@@ -6948,21 +6948,21 @@ unescape_ascii(unsigned int c)
 {
     switch (c) {
       case 'n':
-	return '\n';
+        return '\n';
       case 'r':
-	return '\r';
+        return '\r';
       case 't':
-	return '\t';
+        return '\t';
       case 'f':
-	return '\f';
+        return '\f';
       case 'v':
-	return '\13';
+        return '\13';
       case 'b':
-	return '\010';
+        return '\010';
       case 'a':
-	return '\007';
+        return '\007';
       case 'e':
-	return 033;
+        return 033;
     }
     UNREACHABLE_RETURN(-1);
 }
@@ -6981,9 +6981,9 @@ undump_after_backslash(VALUE undumped, const char **ss, const char *s_end, rb_en
       case '\\':
       case '"':
       case '#':
-	rb_str_cat(undumped, s, 1); /* cat itself */
-	s++;
-	break;
+        rb_str_cat(undumped, s, 1); /* cat itself */
+        s++;
+        break;
       case 'n':
       case 'r':
       case 't':
@@ -6994,81 +6994,81 @@ undump_after_backslash(VALUE undumped, const char **ss, const char *s_end, rb_en
       case 'e':
         *buf = unescape_ascii(*s);
         rb_str_cat(undumped, (char *)buf, 1);
-	s++;
-	break;
+        s++;
+        break;
       case 'u':
-	if (*binary) {
-	    rb_raise(rb_eRuntimeError, "hex escape and Unicode escape are mixed");
-	}
-	*utf8 = true;
-	if (++s >= s_end) {
-	    rb_raise(rb_eRuntimeError, "invalid Unicode escape");
-	}
-	if (enc_utf8 == NULL) enc_utf8 = rb_utf8_encoding();
-	if (*penc != enc_utf8) {
-	    *penc = enc_utf8;
-	    rb_enc_associate(undumped, enc_utf8);
-	}
-	if (*s == '{') { /* handle \u{...} form */
-	    s++;
-	    for (;;) {
-		if (s >= s_end) {
-		    rb_raise(rb_eRuntimeError, "unterminated Unicode escape");
-		}
-		if (*s == '}') {
-		    s++;
-		    break;
-		}
-		if (ISSPACE(*s)) {
-		    s++;
-		    continue;
-		}
-		c = scan_hex(s, s_end-s, &hexlen);
-		if (hexlen == 0 || hexlen > 6) {
-		    rb_raise(rb_eRuntimeError, "invalid Unicode escape");
-		}
-		if (c > 0x10ffff) {
-		    rb_raise(rb_eRuntimeError, "invalid Unicode codepoint (too large)");
-		}
-		if (0xd800 <= c && c <= 0xdfff) {
-		    rb_raise(rb_eRuntimeError, "invalid Unicode codepoint");
-		}
+        if (*binary) {
+            rb_raise(rb_eRuntimeError, "hex escape and Unicode escape are mixed");
+        }
+        *utf8 = true;
+        if (++s >= s_end) {
+            rb_raise(rb_eRuntimeError, "invalid Unicode escape");
+        }
+        if (enc_utf8 == NULL) enc_utf8 = rb_utf8_encoding();
+        if (*penc != enc_utf8) {
+            *penc = enc_utf8;
+            rb_enc_associate(undumped, enc_utf8);
+        }
+        if (*s == '{') { /* handle \u{...} form */
+            s++;
+            for (;;) {
+                if (s >= s_end) {
+                    rb_raise(rb_eRuntimeError, "unterminated Unicode escape");
+                }
+                if (*s == '}') {
+                    s++;
+                    break;
+                }
+                if (ISSPACE(*s)) {
+                    s++;
+                    continue;
+                }
+                c = scan_hex(s, s_end-s, &hexlen);
+                if (hexlen == 0 || hexlen > 6) {
+                    rb_raise(rb_eRuntimeError, "invalid Unicode escape");
+                }
+                if (c > 0x10ffff) {
+                    rb_raise(rb_eRuntimeError, "invalid Unicode codepoint (too large)");
+                }
+                if (0xd800 <= c && c <= 0xdfff) {
+                    rb_raise(rb_eRuntimeError, "invalid Unicode codepoint");
+                }
                 codelen = rb_enc_mbcput(c, (char *)buf, *penc);
                 rb_str_cat(undumped, (char *)buf, codelen);
-		s += hexlen;
-	    }
-	}
-	else { /* handle \uXXXX form */
-	    c = scan_hex(s, 4, &hexlen);
-	    if (hexlen != 4) {
-		rb_raise(rb_eRuntimeError, "invalid Unicode escape");
-	    }
-	    if (0xd800 <= c && c <= 0xdfff) {
-		rb_raise(rb_eRuntimeError, "invalid Unicode codepoint");
-	    }
+                s += hexlen;
+            }
+        }
+        else { /* handle \uXXXX form */
+            c = scan_hex(s, 4, &hexlen);
+            if (hexlen != 4) {
+                rb_raise(rb_eRuntimeError, "invalid Unicode escape");
+            }
+            if (0xd800 <= c && c <= 0xdfff) {
+                rb_raise(rb_eRuntimeError, "invalid Unicode codepoint");
+            }
             codelen = rb_enc_mbcput(c, (char *)buf, *penc);
             rb_str_cat(undumped, (char *)buf, codelen);
-	    s += hexlen;
-	}
-	break;
+            s += hexlen;
+        }
+        break;
       case 'x':
-	if (*utf8) {
-	    rb_raise(rb_eRuntimeError, "hex escape and Unicode escape are mixed");
-	}
-	*binary = true;
-	if (++s >= s_end) {
-	    rb_raise(rb_eRuntimeError, "invalid hex escape");
-	}
-	*buf = scan_hex(s, 2, &hexlen);
-	if (hexlen != 2) {
-	    rb_raise(rb_eRuntimeError, "invalid hex escape");
-	}
+        if (*utf8) {
+            rb_raise(rb_eRuntimeError, "hex escape and Unicode escape are mixed");
+        }
+        *binary = true;
+        if (++s >= s_end) {
+            rb_raise(rb_eRuntimeError, "invalid hex escape");
+        }
+        *buf = scan_hex(s, 2, &hexlen);
+        if (hexlen != 2) {
+            rb_raise(rb_eRuntimeError, "invalid hex escape");
+        }
         rb_str_cat(undumped, (char *)buf, 1);
-	s += hexlen;
-	break;
+        s += hexlen;
+        break;
       default:
-	rb_str_cat(undumped, s-1, 2);
-	s++;
+        rb_str_cat(undumped, s-1, 2);
+        s++;
     }
 
     *ss = s;
@@ -7104,10 +7104,10 @@ str_undump(VALUE str)
 
     rb_must_asciicompat(str);
     if (rb_str_is_ascii_only_p(str) == Qfalse) {
-	rb_raise(rb_eRuntimeError, "non-ASCII character detected");
+        rb_raise(rb_eRuntimeError, "non-ASCII character detected");
     }
     if (!str_null_check(str, &w)) {
-	rb_raise(rb_eRuntimeError, "string contains null byte");
+        rb_raise(rb_eRuntimeError, "string contains null byte");
     }
     if (RSTRING_LEN(str) < 2) goto invalid_format;
     if (*s != '"') goto invalid_format;
@@ -7116,63 +7116,63 @@ str_undump(VALUE str)
     s++;
 
     for (;;) {
-	if (s >= s_end) {
-	    rb_raise(rb_eRuntimeError, "unterminated dumped string");
-	}
-
-	if (*s == '"') {
-	    /* epilogue */
-	    s++;
-	    if (s == s_end) {
-		/* ascii compatible dumped string */
-		break;
-	    }
-	    else {
-		static const char force_encoding_suffix[] = ".force_encoding(\""; /* "\")" */
-		static const char dup_suffix[] = ".dup";
-		const char *encname;
-		int encidx;
-		ptrdiff_t size;
-
-		/* check separately for strings dumped by older versions */
-		size = sizeof(dup_suffix) - 1;
-		if (s_end - s > size && memcmp(s, dup_suffix, size) == 0) s += size;
-
-		size = sizeof(force_encoding_suffix) - 1;
-		if (s_end - s <= size) goto invalid_format;
-		if (memcmp(s, force_encoding_suffix, size) != 0) goto invalid_format;
-		s += size;
-
-		if (utf8) {
-		    rb_raise(rb_eRuntimeError, "dumped string contained Unicode escape but used force_encoding");
-		}
-
-		encname = s;
-		s = memchr(s, '"', s_end-s);
-		size = s - encname;
-		if (!s) goto invalid_format;
-		if (s_end - s != 2) goto invalid_format;
-		if (s[0] != '"' || s[1] != ')') goto invalid_format;
-
-		encidx = rb_enc_find_index2(encname, (long)size);
-		if (encidx < 0) {
-		    rb_raise(rb_eRuntimeError, "dumped string has unknown encoding name");
-		}
-		rb_enc_associate_index(undumped, encidx);
-	    }
-	    break;
-	}
-
-	if (*s == '\\') {
-	    s++;
-	    if (s >= s_end) {
-		rb_raise(rb_eRuntimeError, "invalid escape");
-	    }
-	    undump_after_backslash(undumped, &s, s_end, &enc, &utf8, &binary);
-	}
-	else {
-	    rb_str_cat(undumped, s++, 1);
-	}
+        if (s >= s_end) {
+            rb_raise(rb_eRuntimeError, "unterminated dumped string");
+        }
+
+        if (*s == '"') {
+            /* epilogue */
+            s++;
+            if (s == s_end) {
+                /* ascii compatible dumped string */
+                break;
+            }
+            else {
+                static const char force_encoding_suffix[] = ".force_encoding(\""; /* "\")" */
+                static const char dup_suffix[] = ".dup";
+                const char *encname;
+                int encidx;
+                ptrdiff_t size;
+
+                /* check separately for strings dumped by older versions */
+                size = sizeof(dup_suffix) - 1;
+                if (s_end - s > size && memcmp(s, dup_suffix, size) == 0) s += size;
+
+                size = sizeof(force_encoding_suffix) - 1;
+                if (s_end - s <= size) goto invalid_format;
+                if (memcmp(s, force_encoding_suffix, size) != 0) goto invalid_format;
+                s += size;
+
+                if (utf8) {
+                    rb_raise(rb_eRuntimeError, "dumped string contained Unicode escape but used force_encoding");
+                }
+
+                encname = s;
+                s = memchr(s, '"', s_end-s);
+                size = s - encname;
+                if (!s) goto invalid_format;
+                if (s_end - s != 2) goto invalid_format;
+                if (s[0] != '"' || s[1] != ')') goto invalid_format;
+
+                encidx = rb_enc_find_index2(encname, (long)size);
+                if (encidx < 0) {
+                    rb_raise(rb_eRuntimeError, "dumped string has unknown encoding name");
+                }
+                rb_enc_associate_index(undumped, encidx);
+            }
+            break;
+        }
+
+        if (*s == '\\') {
+            s++;
+            if (s >= s_end) {
+                rb_raise(rb_eRuntimeError, "invalid escape");
+            }
+            undump_after_backslash(undumped, &s, s_end, &enc, &utf8, &binary);
+        }
+        else {
+            rb_str_cat(undumped, s++, 1);
+        }
     }
 
     return undumped;
@@ -7184,8 +7184,8 @@ static void
 rb_str_check_dummy_enc(rb_encoding *enc)
 {
     if (rb_enc_dummy_p(enc)) {
-	rb_raise(rb_eEncCompatError, "incompatible encoding with this operation: %s",
-		 rb_enc_name(enc));
+        rb_raise(rb_eEncCompatError, "incompatible encoding with this operation: %s",
+                 rb_enc_name(enc));
     }
 }
 
@@ -7205,35 +7205,35 @@ check_case_options(int argc, VALUE *argv, OnigCaseFoldType flags)
     if (argc>2)
         rb_raise(rb_eArgError, "too many options");
     if (argv[0]==sym_turkic) {
-	flags |= ONIGENC_CASE_FOLD_TURKISH_AZERI;
-	if (argc==2) {
-	    if (argv[1]==sym_lithuanian)
-		flags |= ONIGENC_CASE_FOLD_LITHUANIAN;
-	    else
-		rb_raise(rb_eArgError, "invalid second option");
-	}
+        flags |= ONIGENC_CASE_FOLD_TURKISH_AZERI;
+        if (argc==2) {
+            if (argv[1]==sym_lithuanian)
+                flags |= ONIGENC_CASE_FOLD_LITHUANIAN;
+            else
+                rb_raise(rb_eArgError, "invalid second option");
+        }
     }
     else if (argv[0]==sym_lithuanian) {
-	flags |= ONIGENC_CASE_FOLD_LITHUANIAN;
-	if (argc==2) {
-	    if (argv[1]==sym_turkic)
-	        flags |= ONIGENC_CASE_FOLD_TURKISH_AZERI;
-	    else
-	        rb_raise(rb_eArgError, "invalid second option");
-	}
+        flags |= ONIGENC_CASE_FOLD_LITHUANIAN;
+        if (argc==2) {
+            if (argv[1]==sym_turkic)
+                flags |= ONIGENC_CASE_FOLD_TURKISH_AZERI;
+            else
+                rb_raise(rb_eArgError, "invalid second option");
+        }
     }
     else if (argc>1)
-	rb_raise(rb_eArgError, "too many options");
+        rb_raise(rb_eArgError, "too many options");
     else if (argv[0]==sym_ascii)
-	flags |= ONIGENC_CASE_ASCII_ONLY;
+        flags |= ONIGENC_CASE_ASCII_ONLY;
     else if (argv[0]==sym_fold) {
-	if ((flags & (ONIGENC_CASE_UPCASE|ONIGENC_CASE_DOWNCASE)) == ONIGENC_CASE_DOWNCASE)
-	    flags ^= ONIGENC_CASE_FOLD|ONIGENC_CASE_DOWNCASE;
-	else
-	    rb_raise(rb_eArgError, "option :fold only allowed for downcasing");
+        if ((flags & (ONIGENC_CASE_UPCASE|ONIGENC_CASE_DOWNCASE)) == ONIGENC_CASE_DOWNCASE)
+            flags ^= ONIGENC_CASE_FOLD|ONIGENC_CASE_DOWNCASE;
+        else
+            rb_raise(rb_eArgError, "option :fold only allowed for downcasing");
     }
     else
-	rb_raise(rb_eArgError, "invalid option");
+        rb_raise(rb_eArgError, "invalid option");
     return flags;
 }
 
@@ -7297,47 +7297,47 @@ rb_str_casemap(VALUE source, OnigCaseFoldType *flags, rb_encoding *enc)
     buffer_anchor = TypedData_Wrap_Struct(0, &mapping_buffer_type, 0);
     pre_buffer = (mapping_buffer **)&DATA_PTR(buffer_anchor);
     while (source_current < source_end) {
-	/* increase multiplier using buffer count to converge quickly */
-	size_t capa = (size_t)(source_end-source_current)*++buffer_count + CASE_MAPPING_ADDITIONAL_LENGTH;
-	if (CASEMAP_DEBUG) {
-	    fprintf(stderr, "Buffer allocation, capa is %"PRIuSIZE"\n", capa); /* for tuning */
-	}
+        /* increase multiplier using buffer count to converge quickly */
+        size_t capa = (size_t)(source_end-source_current)*++buffer_count + CASE_MAPPING_ADDITIONAL_LENGTH;
+        if (CASEMAP_DEBUG) {
+            fprintf(stderr, "Buffer allocation, capa is %"PRIuSIZE"\n", capa); /* for tuning */
+        }
         current_buffer = xmalloc(offsetof(mapping_buffer, space) + capa);
         *pre_buffer = current_buffer;
         pre_buffer = &current_buffer->next;
-	current_buffer->next = NULL;
-	current_buffer->capa = capa;
-	buffer_length_or_invalid = enc->case_map(flags,
-				   &source_current, source_end,
-				   current_buffer->space,
-				   current_buffer->space+current_buffer->capa,
-				   enc);
-	if (buffer_length_or_invalid < 0) {
+        current_buffer->next = NULL;
+        current_buffer->capa = capa;
+        buffer_length_or_invalid = enc->case_map(flags,
+                                   &source_current, source_end,
+                                   current_buffer->space,
+                                   current_buffer->space+current_buffer->capa,
+                                   enc);
+        if (buffer_length_or_invalid < 0) {
             current_buffer = DATA_PTR(buffer_anchor);
             DATA_PTR(buffer_anchor) = 0;
             mapping_buffer_free(current_buffer);
-	    rb_raise(rb_eArgError, "input string invalid");
-	}
-	target_length  += current_buffer->used = buffer_length_or_invalid;
+            rb_raise(rb_eArgError, "input string invalid");
+        }
+        target_length  += current_buffer->used = buffer_length_or_invalid;
     }
     if (CASEMAP_DEBUG) {
-	fprintf(stderr, "Buffer count is %"PRIuSIZE"\n", buffer_count); /* for tuning */
+        fprintf(stderr, "Buffer count is %"PRIuSIZE"\n", buffer_count); /* for tuning */
     }
 
     if (buffer_count==1) {
         target = rb_str_new((const char*)current_buffer->space, target_length);
     }
     else {
-	char *target_current;
+        char *target_current;
 
         target = rb_str_new(0, target_length);
-	target_current = RSTRING_PTR(target);
+        target_current = RSTRING_PTR(target);
         current_buffer = DATA_PTR(buffer_anchor);
-	while (current_buffer) {
-	    memcpy(target_current, current_buffer->space, current_buffer->used);
-	    target_current += current_buffer->used;
-	    current_buffer  = current_buffer->next;
-	}
+        while (current_buffer) {
+            memcpy(target_current, current_buffer->space, current_buffer->used);
+            target_current += current_buffer->used;
+            current_buffer  = current_buffer->next;
+        }
     }
     current_buffer = DATA_PTR(buffer_anchor);
     DATA_PTR(buffer_anchor) = 0;
@@ -7377,10 +7377,10 @@ rb_str_ascii_casemap(VALUE source, VALUE target, OnigCaseFoldType *flags, rb_enc
     if (length_or_invalid < 0)
         rb_raise(rb_eArgError, "input string invalid");
     if (CASEMAP_DEBUG && length_or_invalid != old_length) {
-	fprintf(stderr, "problem with rb_str_ascii_casemap"
-		"; old_length=%ld, new_length=%d\n", old_length, length_or_invalid);
-	rb_raise(rb_eArgError, "internal problem with rb_str_ascii_casemap"
-		 "; old_length=%ld, new_length=%d\n", old_length, length_or_invalid);
+        fprintf(stderr, "problem with rb_str_ascii_casemap"
+                "; old_length=%ld, new_length=%d\n", old_length, length_or_invalid);
+        rb_raise(rb_eArgError, "internal problem with rb_str_ascii_casemap"
+                 "; old_length=%ld, new_length=%d\n", old_length, length_or_invalid);
     }
 
     str_enc_copy(target, source);
@@ -7441,7 +7441,7 @@ rb_str_upcase_bang(int argc, VALUE *argv, VALUE str)
     else if (flags&ONIGENC_CASE_ASCII_ONLY)
         rb_str_ascii_casemap(str, str, &flags, enc);
     else
-	str_shared_replace(str, rb_str_casemap(str, &flags, enc));
+        str_shared_replace(str, rb_str_casemap(str, &flags, enc));
 
     if (ONIGENC_CASE_MODIFIED&flags) return str;
     return Qnil;
@@ -7543,7 +7543,7 @@ rb_str_downcase_bang(int argc, VALUE *argv, VALUE str)
     else if (flags&ONIGENC_CASE_ASCII_ONLY)
         rb_str_ascii_casemap(str, str, &flags, enc);
     else
-	str_shared_replace(str, rb_str_casemap(str, &flags, enc));
+        str_shared_replace(str, rb_str_casemap(str, &flags, enc));
 
     if (ONIGENC_CASE_MODIFIED&flags) return str;
     return Qnil;
@@ -7625,7 +7625,7 @@ rb_str_capitalize_bang(int argc, VALUE *argv, VALUE str)
     if (flags&ONIGENC_CASE_ASCII_ONLY)
         rb_str_ascii_casemap(str, str, &flags, enc);
     else
-	str_shared_replace(str, rb_str_casemap(str, &flags, enc));
+        str_shared_replace(str, rb_str_casemap(str, &flags, enc));
 
     if (ONIGENC_CASE_MODIFIED&flags) return str;
     return Qnil;
@@ -7703,7 +7703,7 @@ rb_str_swapcase_bang(int argc, VALUE *argv, VALUE str)
     if (flags&ONIGENC_CASE_ASCII_ONLY)
         rb_str_ascii_casemap(str, str, &flags, enc);
     else
-	str_shared_replace(str, rb_str_casemap(str, &flags, enc));
+        str_shared_replace(str, rb_str_casemap(str, &flags, enc));
 
     if (ONIGENC_CASE_MODIFIED&flags) return str;
     return Qnil;
@@ -7763,50 +7763,50 @@ trnext(struct tr *t, rb_encoding *enc)
 
     for (;;) {
       nextpart:
-	if (!t->gen) {
-	    if (t->p == t->pend) return -1;
-	    if (rb_enc_ascget(t->p, t->pend, &n, enc) == '\\' && t->p + n < t->pend) {
-		t->p += n;
-	    }
-	    t->now = rb_enc_codepoint_len(t->p, t->pend, &n, enc);
-	    t->p += n;
-	    if (rb_enc_ascget(t->p, t->pend, &n, enc) == '-' && t->p + n < t->pend) {
-		t->p += n;
-		if (t->p < t->pend) {
-		    unsigned int c = rb_enc_codepoint_len(t->p, t->pend, &n, enc);
-		    t->p += n;
-		    if (t->now > c) {
-			if (t->now < 0x80 && c < 0x80) {
-			    rb_raise(rb_eArgError,
-				     "invalid range \"%c-%c\" in string transliteration",
-				     t->now, c);
-			}
-			else {
-			    rb_raise(rb_eArgError, "invalid range in string transliteration");
-			}
-			continue; /* not reached */
-		    }
-		    t->gen = 1;
-		    t->max = c;
-		}
-	    }
-	    return t->now;
-	}
-	else {
-	    while (ONIGENC_CODE_TO_MBCLEN(enc, ++t->now) <= 0) {
-		if (t->now == t->max) {
-		    t->gen = 0;
-		    goto nextpart;
-		}
-	    }
-	    if (t->now < t->max) {
-		return t->now;
-	    }
-	    else {
-		t->gen = 0;
-		return t->max;
-	    }
-	}
+        if (!t->gen) {
+            if (t->p == t->pend) return -1;
+            if (rb_enc_ascget(t->p, t->pend, &n, enc) == '\\' && t->p + n < t->pend) {
+                t->p += n;
+            }
+            t->now = rb_enc_codepoint_len(t->p, t->pend, &n, enc);
+            t->p += n;
+            if (rb_enc_ascget(t->p, t->pend, &n, enc) == '-' && t->p + n < t->pend) {
+                t->p += n;
+                if (t->p < t->pend) {
+                    unsigned int c = rb_enc_codepoint_len(t->p, t->pend, &n, enc);
+                    t->p += n;
+                    if (t->now > c) {
+                        if (t->now < 0x80 && c < 0x80) {
+                            rb_raise(rb_eArgError,
+                                     "invalid range \"%c-%c\" in string transliteration",
+                                     t->now, c);
+                        }
+                        else {
+                            rb_raise(rb_eArgError, "invalid range in string transliteration");
+                        }
+                        continue; /* not reached */
+                    }
+                    t->gen = 1;
+                    t->max = c;
+                }
+            }
+            return t->now;
+        }
+        else {
+            while (ONIGENC_CODE_TO_MBCLEN(enc, ++t->now) <= 0) {
+                if (t->now == t->max) {
+                    t->gen = 0;
+                    goto nextpart;
+                }
+            }
+            if (t->now < t->max) {
+                return t->now;
+            }
+            else {
+                t->gen = 0;
+                return t->max;
+            }
+        }
     }
 }
 
@@ -7830,30 +7830,30 @@ tr_trans(VALUE str, VALUE src, VALUE repl, int sflag)
 
 #define CHECK_IF_ASCII(c) \
     (void)((cr == ENC_CODERANGE_7BIT && !rb_isascii(c)) ? \
-	   (cr = ENC_CODERANGE_VALID) : 0)
+           (cr = ENC_CODERANGE_VALID) : 0)
 
     StringValue(src);
     StringValue(repl);
     if (RSTRING_LEN(str) == 0 || !RSTRING_PTR(str)) return Qnil;
     if (RSTRING_LEN(repl) == 0) {
-	return rb_str_delete_bang(1, &src, str);
+        return rb_str_delete_bang(1, &src, str);
     }
 
     cr = ENC_CODERANGE(str);
     e1 = rb_enc_check(str, src);
     e2 = rb_enc_check(str, repl);
     if (e1 == e2) {
-	enc = e1;
+        enc = e1;
     }
     else {
-	enc = rb_enc_check(src, repl);
+        enc = rb_enc_check(src, repl);
     }
     trsrc.p = RSTRING_PTR(src); trsrc.pend = trsrc.p + RSTRING_LEN(src);
     if (RSTRING_LEN(src) > 1 &&
-	rb_enc_ascget(trsrc.p, trsrc.pend, &l, enc) == '^' &&
-	trsrc.p + l < trsrc.pend) {
-	cflag = 1;
-	trsrc.p += l;
+        rb_enc_ascget(trsrc.p, trsrc.pend, &l, enc) == '^' &&
+        trsrc.p + l < trsrc.pend) {
+        cflag = 1;
+        trsrc.p += l;
     }
     trrepl.p = RSTRING_PTR(repl);
     trrepl.pend = trrepl.p + RSTRING_LEN(repl);
@@ -7862,198 +7862,198 @@ tr_trans(VALUE str, VALUE src, VALUE repl, int sflag)
     trsrc.max = trrepl.max = 0;
 
     if (cflag) {
-	for (i=0; i<256; i++) {
-	    trans[i] = 1;
-	}
-	while ((c = trnext(&trsrc, enc)) != errc) {
-	    if (c < 256) {
-		trans[c] = errc;
-	    }
-	    else {
-		if (!hash) hash = rb_hash_new();
-		rb_hash_aset(hash, UINT2NUM(c), Qtrue);
-	    }
-	}
-	while ((c = trnext(&trrepl, enc)) != errc)
-	    /* retrieve last replacer */;
-	last = trrepl.now;
-	for (i=0; i<256; i++) {
-	    if (trans[i] != errc) {
-		trans[i] = last;
-	    }
-	}
+        for (i=0; i<256; i++) {
+            trans[i] = 1;
+        }
+        while ((c = trnext(&trsrc, enc)) != errc) {
+            if (c < 256) {
+                trans[c] = errc;
+            }
+            else {
+                if (!hash) hash = rb_hash_new();
+                rb_hash_aset(hash, UINT2NUM(c), Qtrue);
+            }
+        }
+        while ((c = trnext(&trrepl, enc)) != errc)
+            /* retrieve last replacer */;
+        last = trrepl.now;
+        for (i=0; i<256; i++) {
+            if (trans[i] != errc) {
+                trans[i] = last;
+            }
+        }
     }
     else {
-	unsigned int r;
-
-	for (i=0; i<256; i++) {
-	    trans[i] = errc;
-	}
-	while ((c = trnext(&trsrc, enc)) != errc) {
-	    r = trnext(&trrepl, enc);
-	    if (r == errc) r = trrepl.now;
-	    if (c < 256) {
-		trans[c] = r;
-		if (rb_enc_codelen(r, enc) != 1) singlebyte = 0;
-	    }
-	    else {
-		if (!hash) hash = rb_hash_new();
-		rb_hash_aset(hash, UINT2NUM(c), UINT2NUM(r));
-	    }
-	}
+        unsigned int r;
+
+        for (i=0; i<256; i++) {
+            trans[i] = errc;
+        }
+        while ((c = trnext(&trsrc, enc)) != errc) {
+            r = trnext(&trrepl, enc);
+            if (r == errc) r = trrepl.now;
+            if (c < 256) {
+                trans[c] = r;
+                if (rb_enc_codelen(r, enc) != 1) singlebyte = 0;
+            }
+            else {
+                if (!hash) hash = rb_hash_new();
+                rb_hash_aset(hash, UINT2NUM(c), UINT2NUM(r));
+            }
+        }
     }
 
     if (cr == ENC_CODERANGE_VALID && rb_enc_asciicompat(e1))
-	cr = ENC_CODERANGE_7BIT;
+        cr = ENC_CODERANGE_7BIT;
     str_modify_keep_cr(str);
     s = (unsigned char *)RSTRING_PTR(str); send = (unsigned char *)RSTRING_END(str);
     termlen = rb_enc_mbminlen(enc);
     if (sflag) {
-	int clen, tlen;
-	long offset, max = RSTRING_LEN(str);
-	unsigned int save = -1;
+        int clen, tlen;
+        long offset, max = RSTRING_LEN(str);
+        unsigned int save = -1;
         unsigned char *buf = ALLOC_N(unsigned char, max + termlen), *t = buf;
 
-	while (s < send) {
-	    int may_modify = 0;
+        while (s < send) {
+            int may_modify = 0;
 
             c0 = c = rb_enc_codepoint_len((char *)s, (char *)send, &clen, e1);
-	    tlen = enc == e1 ? clen : rb_enc_codelen(c, enc);
-
-	    s += clen;
-	    if (c < 256) {
-		c = trans[c];
-	    }
-	    else if (hash) {
-		VALUE tmp = rb_hash_lookup(hash, UINT2NUM(c));
-		if (NIL_P(tmp)) {
-		    if (cflag) c = last;
-		    else c = errc;
-		}
-		else if (cflag) c = errc;
-		else c = NUM2INT(tmp);
-	    }
-	    else {
-		c = errc;
-	    }
-	    if (c != (unsigned int)-1) {
-		if (save == c) {
-		    CHECK_IF_ASCII(c);
-		    continue;
-		}
-		save = c;
-		tlen = rb_enc_codelen(c, enc);
-		modify = 1;
-	    }
-	    else {
-		save = -1;
-		c = c0;
-		if (enc != e1) may_modify = 1;
-	    }
-	    if ((offset = t - buf) + tlen > max) {
-		size_t MAYBE_UNUSED(old) = max + termlen;
-		max = offset + tlen + (send - s);
+            tlen = enc == e1 ? clen : rb_enc_codelen(c, enc);
+
+            s += clen;
+            if (c < 256) {
+                c = trans[c];
+            }
+            else if (hash) {
+                VALUE tmp = rb_hash_lookup(hash, UINT2NUM(c));
+                if (NIL_P(tmp)) {
+                    if (cflag) c = last;
+                    else c = errc;
+                }
+                else if (cflag) c = errc;
+                else c = NUM2INT(tmp);
+            }
+            else {
+                c = errc;
+            }
+            if (c != (unsigned int)-1) {
+                if (save == c) {
+                    CHECK_IF_ASCII(c);
+                    continue;
+                }
+                save = c;
+                tlen = rb_enc_codelen(c, enc);
+                modify = 1;
+            }
+            else {
+                save = -1;
+                c = c0;
+                if (enc != e1) may_modify = 1;
+            }
+            if ((offset = t - buf) + tlen > max) {
+                size_t MAYBE_UNUSED(old) = max + termlen;
+                max = offset + tlen + (send - s);
                 SIZED_REALLOC_N(buf, unsigned char, max + termlen, old);
-		t = buf + offset;
-	    }
-	    rb_enc_mbcput(c, t, enc);
-	    if (may_modify && memcmp(s, t, tlen) != 0) {
-		modify = 1;
-	    }
-	    CHECK_IF_ASCII(c);
-	    t += tlen;
-	}
-	if (!STR_EMBED_P(str)) {
-	    ruby_sized_xfree(STR_HEAP_PTR(str), STR_HEAP_SIZE(str));
-	}
+                t = buf + offset;
+            }
+            rb_enc_mbcput(c, t, enc);
+            if (may_modify && memcmp(s, t, tlen) != 0) {
+                modify = 1;
+            }
+            CHECK_IF_ASCII(c);
+            t += tlen;
+        }
+        if (!STR_EMBED_P(str)) {
+            ruby_sized_xfree(STR_HEAP_PTR(str), STR_HEAP_SIZE(str));
+        }
         TERM_FILL((char *)t, termlen);
         RSTRING(str)->as.heap.ptr = (char *)buf;
-	RSTRING(str)->as.heap.len = t - buf;
-	STR_SET_NOEMBED(str);
-	RSTRING(str)->as.heap.aux.capa = max;
+        RSTRING(str)->as.heap.len = t - buf;
+        STR_SET_NOEMBED(str);
+        RSTRING(str)->as.heap.aux.capa = max;
     }
     else if (rb_enc_mbmaxlen(enc) == 1 || (singlebyte && !hash)) {
-	while (s < send) {
-	    c = (unsigned char)*s;
-	    if (trans[c] != errc) {
-		if (!cflag) {
-		    c = trans[c];
-		    *s = c;
-		    modify = 1;
-		}
-		else {
-		    *s = last;
-		    modify = 1;
-		}
-	    }
-	    CHECK_IF_ASCII(c);
-	    s++;
-	}
+        while (s < send) {
+            c = (unsigned char)*s;
+            if (trans[c] != errc) {
+                if (!cflag) {
+                    c = trans[c];
+                    *s = c;
+                    modify = 1;
+                }
+                else {
+                    *s = last;
+                    modify = 1;
+                }
+            }
+            CHECK_IF_ASCII(c);
+            s++;
+        }
     }
     else {
-	int clen, tlen;
-	long offset, max = (long)((send - s) * 1.2);
+        int clen, tlen;
+        long offset, max = (long)((send - s) * 1.2);
         unsigned char *buf = ALLOC_N(unsigned char, max + termlen), *t = buf;
 
-	while (s < send) {
-	    int may_modify = 0;
+        while (s < send) {
+            int may_modify = 0;
             c0 = c = rb_enc_codepoint_len((char *)s, (char *)send, &clen, e1);
-	    tlen = enc == e1 ? clen : rb_enc_codelen(c, enc);
-
-	    if (c < 256) {
-		c = trans[c];
-	    }
-	    else if (hash) {
-		VALUE tmp = rb_hash_lookup(hash, UINT2NUM(c));
-		if (NIL_P(tmp)) {
-		    if (cflag) c = last;
-		    else c = errc;
-		}
-		else if (cflag) c = errc;
-		else c = NUM2INT(tmp);
-	    }
-	    else {
-		c = cflag ? last : errc;
-	    }
-	    if (c != errc) {
-		tlen = rb_enc_codelen(c, enc);
-		modify = 1;
-	    }
-	    else {
-		c = c0;
-		if (enc != e1) may_modify = 1;
-	    }
-	    if ((offset = t - buf) + tlen > max) {
-		size_t MAYBE_UNUSED(old) = max + termlen;
-		max = offset + tlen + (long)((send - s) * 1.2);
+            tlen = enc == e1 ? clen : rb_enc_codelen(c, enc);
+
+            if (c < 256) {
+                c = trans[c];
+            }
+            else if (hash) {
+                VALUE tmp = rb_hash_lookup(hash, UINT2NUM(c));
+                if (NIL_P(tmp)) {
+                    if (cflag) c = last;
+                    else c = errc;
+                }
+                else if (cflag) c = errc;
+                else c = NUM2INT(tmp);
+            }
+            else {
+                c = cflag ? last : errc;
+            }
+            if (c != errc) {
+                tlen = rb_enc_codelen(c, enc);
+                modify = 1;
+            }
+            else {
+                c = c0;
+                if (enc != e1) may_modify = 1;
+            }
+            if ((offset = t - buf) + tlen > max) {
+                size_t MAYBE_UNUSED(old) = max + termlen;
+                max = offset + tlen + (long)((send - s) * 1.2);
                 SIZED_REALLOC_N(buf, unsigned char, max + termlen, old);
-		t = buf + offset;
-	    }
-	    if (s != t) {
-		rb_enc_mbcput(c, t, enc);
-		if (may_modify && memcmp(s, t, tlen) != 0) {
-		    modify = 1;
-		}
-	    }
-	    CHECK_IF_ASCII(c);
-	    s += clen;
-	    t += tlen;
-	}
-	if (!STR_EMBED_P(str)) {
-	    ruby_sized_xfree(STR_HEAP_PTR(str), STR_HEAP_SIZE(str));
-	}
+                t = buf + offset;
+            }
+            if (s != t) {
+                rb_enc_mbcput(c, t, enc);
+                if (may_modify && memcmp(s, t, tlen) != 0) {
+                    modify = 1;
+                }
+            }
+            CHECK_IF_ASCII(c);
+            s += clen;
+            t += tlen;
+        }
+        if (!STR_EMBED_P(str)) {
+            ruby_sized_xfree(STR_HEAP_PTR(str), STR_HEAP_SIZE(str));
+        }
         TERM_FILL((char *)t, termlen);
         RSTRING(str)->as.heap.ptr = (char *)buf;
-	RSTRING(str)->as.heap.len = t - buf;
-	STR_SET_NOEMBED(str);
-	RSTRING(str)->as.heap.aux.capa = max;
+        RSTRING(str)->as.heap.len = t - buf;
+        STR_SET_NOEMBED(str);
+        RSTRING(str)->as.heap.aux.capa = max;
     }
 
     if (modify) {
-	if (cr != ENC_CODERANGE_BROKEN)
-	    ENC_CODERANGE_SET(str, cr);
-	rb_enc_associate(str, enc);
-	return str;
+        if (cr != ENC_CODERANGE_BROKEN)
+            ENC_CODERANGE_SET(str, cr);
+        rb_enc_associate(str, enc);
+        return str;
     }
     return Qnil;
 }
@@ -8126,7 +8126,7 @@ rb_str_tr(VALUE str, VALUE src, VALUE repl)
 #define TR_TABLE_SIZE (TR_TABLE_MAX+1)
 static void
 tr_setup_table(VALUE str, char stable[TR_TABLE_SIZE], int first,
-	       VALUE *tablep, VALUE *ctablep, rb_encoding *enc)
+               VALUE *tablep, VALUE *ctablep, rb_encoding *enc)
 {
     const unsigned int errc = -1;
     char buf[TR_TABLE_MAX];
@@ -8139,51 +8139,51 @@ tr_setup_table(VALUE str, char stable[TR_TABLE_SIZE], int first,
     tr.gen = tr.now = tr.max = 0;
 
     if (RSTRING_LEN(str) > 1 && rb_enc_ascget(tr.p, tr.pend, &l, enc) == '^') {
-	cflag = 1;
-	tr.p += l;
+        cflag = 1;
+        tr.p += l;
     }
     if (first) {
-	for (i=0; i<TR_TABLE_MAX; i++) {
-	    stable[i] = 1;
-	}
-	stable[TR_TABLE_MAX] = cflag;
+        for (i=0; i<TR_TABLE_MAX; i++) {
+            stable[i] = 1;
+        }
+        stable[TR_TABLE_MAX] = cflag;
     }
     else if (stable[TR_TABLE_MAX] && !cflag) {
-	stable[TR_TABLE_MAX] = 0;
+        stable[TR_TABLE_MAX] = 0;
     }
     for (i=0; i<TR_TABLE_MAX; i++) {
-	buf[i] = cflag;
+        buf[i] = cflag;
     }
 
     while ((c = trnext(&tr, enc)) != errc) {
-	if (c < TR_TABLE_MAX) {
-	    buf[(unsigned char)c] = !cflag;
-	}
-	else {
-	    VALUE key = UINT2NUM(c);
-
-	    if (!table && (first || *tablep || stable[TR_TABLE_MAX])) {
-		if (cflag) {
-		    ptable = *ctablep;
-		    table = ptable ? ptable : rb_hash_new();
-		    *ctablep = table;
-		}
-		else {
-		    table = rb_hash_new();
-		    ptable = *tablep;
-		    *tablep = table;
-		}
-	    }
-	    if (table && (!ptable || (cflag ^ !NIL_P(rb_hash_aref(ptable, key))))) {
-		rb_hash_aset(table, key, Qtrue);
-	    }
-	}
+        if (c < TR_TABLE_MAX) {
+            buf[(unsigned char)c] = !cflag;
+        }
+        else {
+            VALUE key = UINT2NUM(c);
+
+            if (!table && (first || *tablep || stable[TR_TABLE_MAX])) {
+                if (cflag) {
+                    ptable = *ctablep;
+                    table = ptable ? ptable : rb_hash_new();
+                    *ctablep = table;
+                }
+                else {
+                    table = rb_hash_new();
+                    ptable = *tablep;
+                    *tablep = table;
+                }
+            }
+            if (table && (!ptable || (cflag ^ !NIL_P(rb_hash_aref(ptable, key))))) {
+                rb_hash_aset(table, key, Qtrue);
+            }
+        }
     }
     for (i=0; i<TR_TABLE_MAX; i++) {
-	stable[i] = stable[i] && buf[i];
+        stable[i] = stable[i] && buf[i];
     }
     if (!table && !cflag) {
-	*tablep = 0;
+        *tablep = 0;
     }
 }
 
@@ -8192,21 +8192,21 @@ static int
 tr_find(unsigned int c, const char table[TR_TABLE_SIZE], VALUE del, VALUE nodel)
 {
     if (c < TR_TABLE_MAX) {
-	return table[c] != 0;
+        return table[c] != 0;
     }
     else {
-	VALUE v = UINT2NUM(c);
+        VALUE v = UINT2NUM(c);
 
-	if (del) {
-	    if (!NIL_P(rb_hash_lookup(del, v)) &&
-		    (!nodel || NIL_P(rb_hash_lookup(nodel, v)))) {
-		return TRUE;
-	    }
-	}
-	else if (nodel && !NIL_P(rb_hash_lookup(nodel, v))) {
-	    return FALSE;
-	}
-	return table[TR_TABLE_MAX] ? TRUE : FALSE;
+        if (del) {
+            if (!NIL_P(rb_hash_lookup(del, v)) &&
+                    (!nodel || NIL_P(rb_hash_lookup(nodel, v)))) {
+                return TRUE;
+            }
+        }
+        else if (nodel && !NIL_P(rb_hash_lookup(nodel, v))) {
+            return FALSE;
+        }
+        return table[TR_TABLE_MAX] ? TRUE : FALSE;
     }
 }
 
@@ -8232,11 +8232,11 @@ rb_str_delete_bang(int argc, VALUE *argv, VALUE str)
     if (RSTRING_LEN(str) == 0 || !RSTRING_PTR(str)) return Qnil;
     rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
     for (i=0; i<argc; i++) {
-	VALUE s = argv[i];
+        VALUE s = argv[i];
 
-	StringValue(s);
-	enc = rb_enc_check(str, s);
-	tr_setup_table(s, squeez, i==0, &del, &nodel, enc);
+        StringValue(s);
+        enc = rb_enc_check(str, s);
+        tr_setup_table(s, squeez, i==0, &del, &nodel, enc);
     }
 
     str_modify_keep_cr(str);
@@ -8245,32 +8245,32 @@ rb_str_delete_bang(int argc, VALUE *argv, VALUE str)
     send = RSTRING_END(str);
     cr = ascompat ? ENC_CODERANGE_7BIT : ENC_CODERANGE_VALID;
     while (s < send) {
-	unsigned int c;
-	int clen;
-
-	if (ascompat && (c = *(unsigned char*)s) < 0x80) {
-	    if (squeez[c]) {
-		modify = 1;
-	    }
-	    else {
-		if (t != s) *t = c;
-		t++;
-	    }
-	    s++;
-	}
-	else {
-	    c = rb_enc_codepoint_len(s, send, &clen, enc);
-
-	    if (tr_find(c, squeez, del, nodel)) {
-		modify = 1;
-	    }
-	    else {
-		if (t != s) rb_enc_mbcput(c, t, enc);
-		t += clen;
-		if (cr == ENC_CODERANGE_7BIT) cr = ENC_CODERANGE_VALID;
-	    }
-	    s += clen;
-	}
+        unsigned int c;
+        int clen;
+
+        if (ascompat && (c = *(unsigned char*)s) < 0x80) {
+            if (squeez[c]) {
+                modify = 1;
+            }
+            else {
+                if (t != s) *t = c;
+                t++;
+            }
+            s++;
+        }
+        else {
+            c = rb_enc_codepoint_len(s, send, &clen, enc);
+
+            if (tr_find(c, squeez, del, nodel)) {
+                modify = 1;
+            }
+            else {
+                if (t != s) rb_enc_mbcput(c, t, enc);
+                t += clen;
+                if (cr == ENC_CODERANGE_7BIT) cr = ENC_CODERANGE_VALID;
+            }
+            s += clen;
+        }
     }
     TERM_FILL(t, TERM_LEN(str));
     STR_SET_LEN(str, t - RSTRING_PTR(str));
@@ -8324,18 +8324,18 @@ rb_str_squeeze_bang(int argc, VALUE *argv, VALUE str)
     unsigned int save;
 
     if (argc == 0) {
-	enc = STR_ENC_GET(str);
+        enc = STR_ENC_GET(str);
     }
     else {
-	for (i=0; i<argc; i++) {
-	    VALUE s = argv[i];
-
-	    StringValue(s);
-	    enc = rb_enc_check(str, s);
-	    if (singlebyte && !single_byte_optimizable(s))
-		singlebyte = 0;
-	    tr_setup_table(s, squeez, i==0, &del, &nodel, enc);
-	}
+        for (i=0; i<argc; i++) {
+            VALUE s = argv[i];
+
+            StringValue(s);
+            enc = rb_enc_check(str, s);
+            if (singlebyte && !single_byte_optimizable(s))
+                singlebyte = 0;
+            tr_setup_table(s, squeez, i==0, &del, &nodel, enc);
+        }
     }
 
     str_modify_keep_cr(str);
@@ -8348,39 +8348,39 @@ rb_str_squeeze_bang(int argc, VALUE *argv, VALUE str)
     if (singlebyte) {
         while (s < send) {
             unsigned int c = *s++;
-	    if (c != save || (argc > 0 && !squeez[c])) {
-	        *t++ = save = c;
-	    }
-	}
+            if (c != save || (argc > 0 && !squeez[c])) {
+                *t++ = save = c;
+            }
+        }
     }
     else {
-	while (s < send) {
-	    unsigned int c;
-	    int clen;
+        while (s < send) {
+            unsigned int c;
+            int clen;
 
             if (ascompat && (c = *s) < 0x80) {
-		if (c != save || (argc > 0 && !squeez[c])) {
-		    *t++ = save = c;
-		}
-		s++;
-	    }
-	    else {
+                if (c != save || (argc > 0 && !squeez[c])) {
+                    *t++ = save = c;
+                }
+                s++;
+            }
+            else {
                 c = rb_enc_codepoint_len((char *)s, (char *)send, &clen, enc);
 
-		if (c != save || (argc > 0 && !tr_find(c, squeez, del, nodel))) {
-		    if (t != s) rb_enc_mbcput(c, t, enc);
-		    save = c;
-		    t += clen;
-		}
-		s += clen;
-	    }
-	}
+                if (c != save || (argc > 0 && !tr_find(c, squeez, del, nodel))) {
+                    if (t != s) rb_enc_mbcput(c, t, enc);
+                    save = c;
+                    t += clen;
+                }
+                s += clen;
+            }
+        }
     }
 
     TERM_FILL((char *)t, TERM_LEN(str));
     if ((char *)t - RSTRING_PTR(str) != RSTRING_LEN(str)) {
         STR_SET_LEN(str, (char *)t - RSTRING_PTR(str));
-	modify = 1;
+        modify = 1;
     }
 
     if (modify) return str;
@@ -8495,30 +8495,30 @@ rb_str_count(int argc, VALUE *argv, VALUE str)
     StringValue(tstr);
     enc = rb_enc_check(str, tstr);
     if (argc == 1) {
-	const char *ptstr;
-	if (RSTRING_LEN(tstr) == 1 && rb_enc_asciicompat(enc) &&
-	    (ptstr = RSTRING_PTR(tstr),
-	     ONIGENC_IS_ALLOWED_REVERSE_MATCH(enc, (const unsigned char *)ptstr, (const unsigned char *)ptstr+1)) &&
-	    !is_broken_string(str)) {
-	    int clen;
-	    unsigned char c = rb_enc_codepoint_len(ptstr, ptstr+1, &clen, enc);
-
-	    s = RSTRING_PTR(str);
-	    if (!s || RSTRING_LEN(str) == 0) return INT2FIX(0);
-	    send = RSTRING_END(str);
-	    while (s < send) {
-		if (*(unsigned char*)s++ == c) n++;
-	    }
-	    return SIZET2NUM(n);
-	}
+        const char *ptstr;
+        if (RSTRING_LEN(tstr) == 1 && rb_enc_asciicompat(enc) &&
+            (ptstr = RSTRING_PTR(tstr),
+             ONIGENC_IS_ALLOWED_REVERSE_MATCH(enc, (const unsigned char *)ptstr, (const unsigned char *)ptstr+1)) &&
+            !is_broken_string(str)) {
+            int clen;
+            unsigned char c = rb_enc_codepoint_len(ptstr, ptstr+1, &clen, enc);
+
+            s = RSTRING_PTR(str);
+            if (!s || RSTRING_LEN(str) == 0) return INT2FIX(0);
+            send = RSTRING_END(str);
+            while (s < send) {
+                if (*(unsigned char*)s++ == c) n++;
+            }
+            return SIZET2NUM(n);
+        }
     }
 
     tr_setup_table(tstr, table, TRUE, &del, &nodel, enc);
     for (i=1; i<argc; i++) {
-	tstr = argv[i];
-	StringValue(tstr);
-	enc = rb_enc_check(str, tstr);
-	tr_setup_table(tstr, table, FALSE, &del, &nodel, enc);
+        tstr = argv[i];
+        StringValue(tstr);
+        enc = rb_enc_check(str, tstr);
+        tr_setup_table(tstr, table, FALSE, &del, &nodel, enc);
     }
 
     s = RSTRING_PTR(str);
@@ -8526,22 +8526,22 @@ rb_str_count(int argc, VALUE *argv, VALUE str)
     send = RSTRING_END(str);
     ascompat = rb_enc_asciicompat(enc);
     while (s < send) {
-	unsigned int c;
-
-	if (ascompat && (c = *(unsigned char*)s) < 0x80) {
-	    if (table[c]) {
-		n++;
-	    }
-	    s++;
-	}
-	else {
-	    int clen;
-	    c = rb_enc_codepoint_len(s, send, &clen, enc);
-	    if (tr_find(c, table, del, nodel)) {
-		n++;
-	    }
-	    s += clen;
-	}
+        unsigned int c;
+
+        if (ascompat && (c = *(unsigned char*)s) < 0x80) {
+            if (table[c]) {
+                n++;
+            }
+            s++;
+        }
+        else {
+            int clen;
+            c = rb_enc_codepoint_len(s, send, &clen, enc);
+            if (tr_find(c, table, del, nodel)) {
+                n++;
+            }
+            s += clen;
+        }
     }
 
     return SIZET2NUM(n);
@@ -8551,8 +8551,8 @@ static VALUE
 rb_fs_check(VALUE val)
 {
     if (!NIL_P(val) && !RB_TYPE_P(val, T_STRING) && !RB_TYPE_P(val, T_REGEXP)) {
-	val = rb_check_string_type(val);
-	if (NIL_P(val)) return 0;
+        val = rb_check_string_type(val);
+        if (NIL_P(val)) return 0;
     }
     return val;
 }
@@ -8582,27 +8582,27 @@ static long
 split_string(VALUE result, VALUE str, long beg, long len, long empty_count)
 {
     if (empty_count >= 0 && len == 0) {
-	return empty_count + 1;
+        return empty_count + 1;
     }
     if (empty_count > 0) {
-	/* make different substrings */
-	if (result) {
-	    do {
+        /* make different substrings */
+        if (result) {
+            do {
                 rb_ary_push(result, str_new_empty_String(str));
-	    } while (--empty_count > 0);
-	}
-	else {
-	    do {
+            } while (--empty_count > 0);
+        }
+        else {
+            do {
                 rb_yield(str_new_empty_String(str));
-	    } while (--empty_count > 0);
-	}
+            } while (--empty_count > 0);
+        }
     }
     str = rb_str_subseq(str, beg, len);
     if (result) {
-	rb_ary_push(result, str);
+        rb_ary_push(result, str);
     }
     else {
-	rb_yield(str);
+        rb_yield(str);
     }
     return empty_count;
 }
@@ -8658,32 +8658,32 @@ rb_str_split_m(int argc, VALUE *argv, VALUE str)
 
     result = rb_block_given_p() ? Qfalse : Qnil;
     if (rb_scan_args(argc, argv, "02", &spat, &limit) == 2) {
-	lim = NUM2INT(limit);
-	if (lim <= 0) limit = Qnil;
-	else if (lim == 1) {
-	    if (RSTRING_LEN(str) == 0)
+        lim = NUM2INT(limit);
+        if (lim <= 0) limit = Qnil;
+        else if (lim == 1) {
+            if (RSTRING_LEN(str) == 0)
                 return result ? rb_ary_new2(0) : str;
             tmp = str_duplicate(rb_cString, str);
-	    if (!result) {
-		rb_yield(tmp);
+            if (!result) {
+                rb_yield(tmp);
                 return str;
-	    }
-	    return rb_ary_new3(1, tmp);
-	}
-	i = 1;
+            }
+            return rb_ary_new3(1, tmp);
+        }
+        i = 1;
     }
     if (NIL_P(limit) && !lim) empty_count = 0;
 
     enc = STR_ENC_GET(str);
     split_type = SPLIT_TYPE_REGEXP;
     if (!NIL_P(spat)) {
-	spat = get_pat_quoted(spat, 0);
+        spat = get_pat_quoted(spat, 0);
     }
     else if (NIL_P(spat = rb_fs)) {
-	split_type = SPLIT_TYPE_AWK;
+        split_type = SPLIT_TYPE_AWK;
     }
     else if (!(spat = rb_fs_check(spat))) {
-	rb_raise(rb_eTypeError, "value of $; must be String or Regexp");
+        rb_raise(rb_eTypeError, "value of $; must be String or Regexp");
     }
     else {
         rb_category_warn(RB_WARN_CATEGORY_DEPRECATED, "$; is set to non-nil value");
@@ -8701,13 +8701,13 @@ rb_str_split_m(int argc, VALUE *argv, VALUE str)
             break;
 
           case T_STRING:
-	    mustnot_broken(spat);
+            mustnot_broken(spat);
             split_type = literal_split_pattern(spat, SPLIT_TYPE_STRING);
             break;
 
           default:
             UNREACHABLE_RETURN(Qnil);
-	}
+        }
     }
 
 #define SPLIT_STR(beg, len) (empty_count = split_string(result, str, beg, len, empty_count))
@@ -8717,85 +8717,85 @@ rb_str_split_m(int argc, VALUE *argv, VALUE str)
     char *ptr = RSTRING_PTR(str);
     char *eptr = RSTRING_END(str);
     if (split_type == SPLIT_TYPE_AWK) {
-	char *bptr = ptr;
-	int skip = 1;
-	unsigned int c;
-
-	end = beg;
-	if (is_ascii_string(str)) {
-	    while (ptr < eptr) {
-		c = (unsigned char)*ptr++;
-		if (skip) {
-		    if (ascii_isspace(c)) {
-			beg = ptr - bptr;
-		    }
-		    else {
-			end = ptr - bptr;
-			skip = 0;
-			if (!NIL_P(limit) && lim <= i) break;
-		    }
-		}
-		else if (ascii_isspace(c)) {
-		    SPLIT_STR(beg, end-beg);
-		    skip = 1;
-		    beg = ptr - bptr;
-		    if (!NIL_P(limit)) ++i;
-		}
-		else {
-		    end = ptr - bptr;
-		}
-	    }
-	}
-	else {
-	    while (ptr < eptr) {
-		int n;
-
-		c = rb_enc_codepoint_len(ptr, eptr, &n, enc);
-		ptr += n;
-		if (skip) {
-		    if (rb_isspace(c)) {
-			beg = ptr - bptr;
-		    }
-		    else {
-			end = ptr - bptr;
-			skip = 0;
-			if (!NIL_P(limit) && lim <= i) break;
-		    }
-		}
-		else if (rb_isspace(c)) {
-		    SPLIT_STR(beg, end-beg);
-		    skip = 1;
-		    beg = ptr - bptr;
-		    if (!NIL_P(limit)) ++i;
-		}
-		else {
-		    end = ptr - bptr;
-		}
-	    }
-	}
+        char *bptr = ptr;
+        int skip = 1;
+        unsigned int c;
+
+        end = beg;
+        if (is_ascii_string(str)) {
+            while (ptr < eptr) {
+                c = (unsigned char)*ptr++;
+                if (skip) {
+                    if (ascii_isspace(c)) {
+                        beg = ptr - bptr;
+                    }
+                    else {
+                        end = ptr - bptr;
+                        skip = 0;
+                        if (!NIL_P(limit) && lim <= i) break;
+                    }
+                }
+                else if (ascii_isspace(c)) {
+                    SPLIT_STR(beg, end-beg);
+                    skip = 1;
+                    beg = ptr - bptr;
+                    if (!NIL_P(limit)) ++i;
+                }
+                else {
+                    end = ptr - bptr;
+                }
+            }
+        }
+        else {
+            while (ptr < eptr) {
+                int n;
+
+                c = rb_enc_codepoint_len(ptr, eptr, &n, enc);
+                ptr += n;
+                if (skip) {
+                    if (rb_isspace(c)) {
+                        beg = ptr - bptr;
+                    }
+                    else {
+                        end = ptr - bptr;
+                        skip = 0;
+                        if (!NIL_P(limit) && lim <= i) break;
+                    }
+                }
+                else if (rb_isspace(c)) {
+                    SPLIT_STR(beg, end-beg);
+                    skip = 1;
+                    beg = ptr - bptr;
+                    if (!NIL_P(limit)) ++i;
+                }
+                else {
+                    end = ptr - bptr;
+                }
+            }
+        }
     }
     else if (split_type == SPLIT_TYPE_STRING) {
-	char *str_start = ptr;
-	char *substr_start = ptr;
-	char *sptr = RSTRING_PTR(spat);
-	long slen = RSTRING_LEN(spat);
-
-	mustnot_broken(str);
-	enc = rb_enc_check(str, spat);
-	while (ptr < eptr &&
-	       (end = rb_memsearch(sptr, slen, ptr, eptr - ptr, enc)) >= 0) {
-	    /* Check we are at the start of a char */
-	    char *t = rb_enc_right_char_head(ptr, ptr + end, eptr, enc);
-	    if (t != ptr + end) {
-		ptr = t;
-		continue;
-	    }
-	    SPLIT_STR(substr_start - str_start, (ptr+end) - substr_start);
-	    ptr += end + slen;
-	    substr_start = ptr;
-	    if (!NIL_P(limit) && lim <= ++i) break;
-	}
-	beg = ptr - str_start;
+        char *str_start = ptr;
+        char *substr_start = ptr;
+        char *sptr = RSTRING_PTR(spat);
+        long slen = RSTRING_LEN(spat);
+
+        mustnot_broken(str);
+        enc = rb_enc_check(str, spat);
+        while (ptr < eptr &&
+               (end = rb_memsearch(sptr, slen, ptr, eptr - ptr, enc)) >= 0) {
+            /* Check we are at the start of a char */
+            char *t = rb_enc_right_char_head(ptr, ptr + end, eptr, enc);
+            if (t != ptr + end) {
+                ptr = t;
+                continue;
+            }
+            SPLIT_STR(substr_start - str_start, (ptr+end) - substr_start);
+            ptr += end + slen;
+            substr_start = ptr;
+            if (!NIL_P(limit) && lim <= ++i) break;
+        }
+        beg = ptr - str_start;
     }
     else if (split_type == SPLIT_TYPE_CHARS) {
         char *str_start = ptr;
@@ -8812,11 +8812,11 @@ rb_str_split_m(int argc, VALUE *argv, VALUE str)
         beg = ptr - str_start;
     }
     else {
-	long len = RSTRING_LEN(str);
-	long start = beg;
-	long idx;
-	int last_null = 0;
-	struct re_registers *regs;
+        long len = RSTRING_LEN(str);
+        long start = beg;
+        long idx;
+        int last_null = 0;
+        struct re_registers *regs;
         VALUE match = 0;
 
         for (; rb_reg_search(spat, str, start, 0) >= 0;
@@ -8825,40 +8825,40 @@ rb_str_split_m(int argc, VALUE *argv, VALUE str)
             if (!result) rb_match_busy(match);
             regs = RMATCH_REGS(match);
             end = BEG(0);
-	    if (start == end && BEG(0) == END(0)) {
-		if (!ptr) {
-		    SPLIT_STR(0, 0);
-		    break;
-		}
-		else if (last_null == 1) {
+            if (start == end && BEG(0) == END(0)) {
+                if (!ptr) {
+                    SPLIT_STR(0, 0);
+                    break;
+                }
+                else if (last_null == 1) {
                     SPLIT_STR(beg, rb_enc_fast_mbclen(ptr+beg, eptr, enc));
-		    beg = start;
-		}
-		else {
+                    beg = start;
+                }
+                else {
                     if (start == len)
                         start++;
                     else
                         start += rb_enc_fast_mbclen(ptr+start,eptr,enc);
-		    last_null = 1;
-		    continue;
-		}
-	    }
-	    else {
-		SPLIT_STR(beg, end-beg);
-		beg = start = END(0);
-	    }
-	    last_null = 0;
-
-	    for (idx=1; idx < regs->num_regs; idx++) {
-		if (BEG(idx) == -1) continue;
-		SPLIT_STR(BEG(idx), END(idx)-BEG(idx));
-	    }
-	    if (!NIL_P(limit) && lim <= ++i) break;
-	}
+                    last_null = 1;
+                    continue;
+                }
+            }
+            else {
+                SPLIT_STR(beg, end-beg);
+                beg = start = END(0);
+            }
+            last_null = 0;
+
+            for (idx=1; idx < regs->num_regs; idx++) {
+                if (BEG(idx) == -1) continue;
+                SPLIT_STR(BEG(idx), END(idx)-BEG(idx));
+            }
+            if (!NIL_P(limit) && lim <= ++i) break;
+        }
         if (match) rb_match_unbusy(match);
     }
     if (RSTRING_LEN(str) > 0 && (!NIL_P(limit) || RSTRING_LEN(str) > beg || lim < 0)) {
-	SPLIT_STR(beg, RSTRING_LEN(str)-beg);
+        SPLIT_STR(beg, RSTRING_LEN(str)-beg);
     }
 
     return result ? result : str;
@@ -8880,12 +8880,12 @@ static inline int
 enumerator_element(VALUE ary, VALUE e)
 {
     if (ary) {
-	rb_ary_push(ary, e);
-	return 0;
+        rb_ary_push(ary, e);
+        return 0;
     }
     else {
-	rb_yield(e);
-	return 1;
+        rb_yield(e);
+        return 1;
     }
 }
 
@@ -8896,10 +8896,10 @@ chomp_newline(const char *p, const char *e, rb_encoding *enc)
 {
     const char *prev = rb_enc_prev_char(p, e, e, enc);
     if (rb_enc_is_newline(prev, e, enc)) {
-	e = prev;
-	prev = rb_enc_prev_char(p, e, e, enc);
-	if (prev && rb_enc_ascget(prev, e, NULL, enc) == '\r')
-	    e = prev;
+        e = prev;
+        prev = rb_enc_prev_char(p, e, e, enc);
+        if (prev && rb_enc_ascget(prev, e, NULL, enc) == '\r')
+            e = prev;
     }
     return e;
 }
@@ -8909,9 +8909,9 @@ get_rs(void)
 {
     VALUE rs = rb_rs;
     if (!NIL_P(rs) &&
-	(!RB_TYPE_P(rs, T_STRING) ||
-	 RSTRING_LEN(rs) != 1 ||
-	 RSTRING_PTR(rs)[0] != '\n')) {
+        (!RB_TYPE_P(rs, T_STRING) ||
+         RSTRING_LEN(rs) != 1 ||
+         RSTRING_PTR(rs)[0] != '\n')) {
         rb_category_warn(RB_WARN_CATEGORY_DEPRECATED, "$/ is set to non-default value");
     }
     return rs;
@@ -8929,23 +8929,23 @@ rb_str_enumerate_lines(int argc, VALUE *argv, VALUE str, VALUE ary)
     int rsnewline = 0;
 
     if (rb_scan_args(argc, argv, "01:", &rs, &opts) == 0)
-	rs = rb_rs;
+        rs = rb_rs;
     if (!NIL_P(opts)) {
-	static ID keywords[1];
-	if (!keywords[0]) {
-	    keywords[0] = rb_intern_const("chomp");
-	}
-	rb_get_kwargs(opts, keywords, 0, 1, &chomp);
-	chomp = (chomp != Qundef && RTEST(chomp));
+        static ID keywords[1];
+        if (!keywords[0]) {
+            keywords[0] = rb_intern_const("chomp");
+        }
+        rb_get_kwargs(opts, keywords, 0, 1, &chomp);
+        chomp = (chomp != Qundef && RTEST(chomp));
     }
 
     if (NIL_P(rs)) {
-	if (!ENUM_ELEM(ary, str)) {
-	    return ary;
-	}
-	else {
-	    return orig;
-	}
+        if (!ENUM_ELEM(ary, str)) {
+            return ary;
+        }
+        else {
+            return orig;
+        }
     }
 
     if (!RSTRING_LEN(str)) goto end;
@@ -8957,106 +8957,106 @@ rb_str_enumerate_lines(int argc, VALUE *argv, VALUE str, VALUE ary)
     rslen = RSTRING_LEN(rs);
 
     if (rs == rb_default_rs)
-	enc = rb_enc_get(str);
+        enc = rb_enc_get(str);
     else
-	enc = rb_enc_check(str, rs);
+        enc = rb_enc_check(str, rs);
 
     if (rslen == 0) {
-	/* paragraph mode */
-	int n;
-	const char *eol = NULL;
-	subend = subptr;
-	while (subend < pend) {
+        /* paragraph mode */
+        int n;
+        const char *eol = NULL;
+        subend = subptr;
+        while (subend < pend) {
             long chomp_rslen = 0;
-	    do {
-		if (rb_enc_ascget(subend, pend, &n, enc) != '\r')
-		    n = 0;
-		rslen = n + rb_enc_mbclen(subend + n, pend, enc);
-		if (rb_enc_is_newline(subend + n, pend, enc)) {
-		    if (eol == subend) break;
-		    subend += rslen;
+            do {
+                if (rb_enc_ascget(subend, pend, &n, enc) != '\r')
+                    n = 0;
+                rslen = n + rb_enc_mbclen(subend + n, pend, enc);
+                if (rb_enc_is_newline(subend + n, pend, enc)) {
+                    if (eol == subend) break;
+                    subend += rslen;
                     if (subptr) {
                         eol = subend;
                         chomp_rslen = -rslen;
                     }
-		}
-		else {
-		    if (!subptr) subptr = subend;
-		    subend += rslen;
-		}
-		rslen = 0;
-	    } while (subend < pend);
-	    if (!subptr) break;
+                }
+                else {
+                    if (!subptr) subptr = subend;
+                    subend += rslen;
+                }
+                rslen = 0;
+            } while (subend < pend);
+            if (!subptr) break;
             if (rslen == 0) chomp_rslen = 0;
-	    line = rb_str_subseq(str, subptr - ptr,
+            line = rb_str_subseq(str, subptr - ptr,
                                  subend - subptr + (chomp ? chomp_rslen : rslen));
-	    if (ENUM_ELEM(ary, line)) {
-		str_mod_check(str, ptr, len);
-	    }
-	    subptr = eol = NULL;
-	}
-	goto end;
+            if (ENUM_ELEM(ary, line)) {
+                str_mod_check(str, ptr, len);
+            }
+            subptr = eol = NULL;
+        }
+        goto end;
     }
     else {
-	rsptr = RSTRING_PTR(rs);
-	if (RSTRING_LEN(rs) == rb_enc_mbminlen(enc) &&
-	    rb_enc_is_newline(rsptr, rsptr + RSTRING_LEN(rs), enc)) {
-	    rsnewline = 1;
-	}
+        rsptr = RSTRING_PTR(rs);
+        if (RSTRING_LEN(rs) == rb_enc_mbminlen(enc) &&
+            rb_enc_is_newline(rsptr, rsptr + RSTRING_LEN(rs), enc)) {
+            rsnewline = 1;
+        }
     }
 
     if ((rs == rb_default_rs) && !rb_enc_asciicompat(enc)) {
-	rs = rb_str_new(rsptr, rslen);
-	rs = rb_str_encode(rs, rb_enc_from_encoding(enc), 0, Qnil);
-	rsptr = RSTRING_PTR(rs);
-	rslen = RSTRING_LEN(rs);
+        rs = rb_str_new(rsptr, rslen);
+        rs = rb_str_encode(rs, rb_enc_from_encoding(enc), 0, Qnil);
+        rsptr = RSTRING_PTR(rs);
+        rslen = RSTRING_LEN(rs);
     }
 
     while (subptr < pend) {
-	pos = rb_memsearch(rsptr, rslen, subptr, pend - subptr, enc);
-	if (pos < 0) break;
-	hit = subptr + pos;
-	adjusted = rb_enc_right_char_head(subptr, hit, pend, enc);
-	if (hit != adjusted) {
-	    subptr = adjusted;
-	    continue;
-	}
-	subend = hit += rslen;
-	if (chomp) {
-	    if (rsnewline) {
-		subend = chomp_newline(subptr, subend, enc);
-	    }
-	    else {
-		subend -= rslen;
-	    }
-	}
-	line = rb_str_subseq(str, subptr - ptr, subend - subptr);
-	if (ENUM_ELEM(ary, line)) {
-	    str_mod_check(str, ptr, len);
-	}
-	subptr = hit;
+        pos = rb_memsearch(rsptr, rslen, subptr, pend - subptr, enc);
+        if (pos < 0) break;
+        hit = subptr + pos;
+        adjusted = rb_enc_right_char_head(subptr, hit, pend, enc);
+        if (hit != adjusted) {
+            subptr = adjusted;
+            continue;
+        }
+        subend = hit += rslen;
+        if (chomp) {
+            if (rsnewline) {
+                subend = chomp_newline(subptr, subend, enc);
+            }
+            else {
+                subend -= rslen;
+            }
+        }
+        line = rb_str_subseq(str, subptr - ptr, subend - subptr);
+        if (ENUM_ELEM(ary, line)) {
+            str_mod_check(str, ptr, len);
+        }
+        subptr = hit;
     }
 
     if (subptr != pend) {
-	if (chomp) {
-	    if (rsnewline) {
-		pend = chomp_newline(subptr, pend, enc);
-	    }
-	    else if (pend - subptr >= rslen &&
-		     memcmp(pend - rslen, rsptr, rslen) == 0) {
-		pend -= rslen;
-	    }
-	}
-	line = rb_str_subseq(str, subptr - ptr, pend - subptr);
-	ENUM_ELEM(ary, line);
-	RB_GC_GUARD(str);
+        if (chomp) {
+            if (rsnewline) {
+                pend = chomp_newline(subptr, pend, enc);
+            }
+            else if (pend - subptr >= rslen &&
+                     memcmp(pend - rslen, rsptr, rslen) == 0) {
+                pend -= rslen;
+            }
+        }
+        line = rb_str_subseq(str, subptr - ptr, pend - subptr);
+        ENUM_ELEM(ary, line);
+        RB_GC_GUARD(str);
     }
 
   end:
     if (ary)
-	return ary;
+        return ary;
     else
-	return orig;
+        return orig;
 }
 
 /*
@@ -9103,12 +9103,12 @@ rb_str_enumerate_bytes(VALUE str, VALUE ary)
     long i;
 
     for (i=0; i<RSTRING_LEN(str); i++) {
-	ENUM_ELEM(ary, INT2FIX((unsigned char)RSTRING_PTR(str)[i]));
+        ENUM_ELEM(ary, INT2FIX((unsigned char)RSTRING_PTR(str)[i]));
     }
     if (ary)
-	return ary;
+        return ary;
     else
-	return str;
+        return str;
 }
 
 /*
@@ -9162,22 +9162,22 @@ rb_str_enumerate_chars(VALUE str, VALUE ary)
     enc = rb_enc_get(str);
 
     if (ENC_CODERANGE_CLEAN_P(ENC_CODERANGE(str))) {
-	for (i = 0; i < len; i += n) {
-	    n = rb_enc_fast_mbclen(ptr + i, ptr + len, enc);
-	    ENUM_ELEM(ary, rb_str_subseq(str, i, n));
-	}
+        for (i = 0; i < len; i += n) {
+            n = rb_enc_fast_mbclen(ptr + i, ptr + len, enc);
+            ENUM_ELEM(ary, rb_str_subseq(str, i, n));
+        }
     }
     else {
-	for (i = 0; i < len; i += n) {
-	    n = rb_enc_mbclen(ptr + i, ptr + len, enc);
-	    ENUM_ELEM(ary, rb_str_subseq(str, i, n));
-	}
+        for (i = 0; i < len; i += n) {
+            n = rb_enc_mbclen(ptr + i, ptr + len, enc);
+            ENUM_ELEM(ary, rb_str_subseq(str, i, n));
+        }
     }
     RB_GC_GUARD(str);
     if (ary)
-	return ary;
+        return ary;
     else
-	return orig;
+        return orig;
 }
 
 /*
@@ -9221,7 +9221,7 @@ rb_str_enumerate_codepoints(VALUE str, VALUE ary)
     rb_encoding *enc;
 
     if (single_byte_optimizable(str))
-	return rb_str_enumerate_bytes(str, ary);
+        return rb_str_enumerate_bytes(str, ary);
 
     str = rb_str_new_frozen(str);
     ptr = RSTRING_PTR(str);
@@ -9229,15 +9229,15 @@ rb_str_enumerate_codepoints(VALUE str, VALUE ary)
     enc = STR_ENC_GET(str);
 
     while (ptr < end) {
-	c = rb_enc_codepoint_len(ptr, end, &n, enc);
-	ENUM_ELEM(ary, UINT2NUM(c));
-	ptr += n;
+        c = rb_enc_codepoint_len(ptr, end, &n, enc);
+        ENUM_ELEM(ary, UINT2NUM(c));
+        ptr += n;
     }
     RB_GC_GUARD(str);
     if (ary)
-	return ary;
+        return ary;
     else
-	return orig;
+        return orig;
 }
 
 /*
@@ -9280,7 +9280,7 @@ get_reg_grapheme_cluster(rb_encoding *enc)
 
     /* synchronize */
     if (encidx == rb_utf8_encindex() && reg_grapheme_cluster_utf8) {
-	reg_grapheme_cluster = reg_grapheme_cluster_utf8;
+        reg_grapheme_cluster = reg_grapheme_cluster_utf8;
     }
     if (!reg_grapheme_cluster) {
         const OnigUChar source_ascii[] = "\\X";
@@ -9308,14 +9308,14 @@ get_reg_grapheme_cluster(rb_encoding *enc)
         }
         int r = onig_new(&reg_grapheme_cluster, source, source + source_len,
                          ONIG_OPTION_DEFAULT, enc, OnigDefaultSyntax, &einfo);
-	if (r) {
+        if (r) {
             UChar message[ONIG_MAX_ERROR_MESSAGE_LEN];
             onig_error_code_to_str(message, r, &einfo);
             rb_fatal("cannot compile grapheme cluster regexp: %s", (char *)message);
-	}
-	if (encidx == rb_utf8_encindex()) {
-	    reg_grapheme_cluster_utf8 = reg_grapheme_cluster;
-	}
+        }
+        if (encidx == rb_utf8_encindex()) {
+            reg_grapheme_cluster_utf8 = reg_grapheme_cluster;
+        }
     }
     return reg_grapheme_cluster;
 }
@@ -9329,7 +9329,7 @@ rb_str_each_grapheme_cluster_size(VALUE str, VALUE args, VALUE eobj)
     const char *ptr, *end;
 
     if (!rb_enc_unicode_p(enc)) {
-	return rb_str_length(str);
+        return rb_str_length(str);
     }
 
     reg_grapheme_cluster = get_reg_grapheme_cluster(enc);
@@ -9337,12 +9337,12 @@ rb_str_each_grapheme_cluster_size(VALUE str, VALUE args, VALUE eobj)
     end = RSTRING_END(str);
 
     while (ptr < end) {
-	OnigPosition len = onig_match(reg_grapheme_cluster,
-				      (const OnigUChar *)ptr, (const OnigUChar *)end,
-				      (const OnigUChar *)ptr, NULL, 0);
-	if (len <= 0) break;
-	grapheme_cluster_count++;
-	ptr += len;
+        OnigPosition len = onig_match(reg_grapheme_cluster,
+                                      (const OnigUChar *)ptr, (const OnigUChar *)end,
+                                      (const OnigUChar *)ptr, NULL, 0);
+        if (len <= 0) break;
+        grapheme_cluster_count++;
+        ptr += len;
     }
 
     return SIZET2NUM(grapheme_cluster_count);
@@ -9357,7 +9357,7 @@ rb_str_enumerate_grapheme_clusters(VALUE str, VALUE ary)
     const char *ptr0, *ptr, *end;
 
     if (!rb_enc_unicode_p(enc)) {
-	return rb_str_enumerate_chars(str, ary);
+        return rb_str_enumerate_chars(str, ary);
     }
 
     if (!ary) str = rb_str_new_frozen(str);
@@ -9366,18 +9366,18 @@ rb_str_enumerate_grapheme_clusters(VALUE str, VALUE ary)
     end = RSTRING_END(str);
 
     while (ptr < end) {
-	OnigPosition len = onig_match(reg_grapheme_cluster,
-				      (const OnigUChar *)ptr, (const OnigUChar *)end,
-				      (const OnigUChar *)ptr, NULL, 0);
-	if (len <= 0) break;
+        OnigPosition len = onig_match(reg_grapheme_cluster,
+                                      (const OnigUChar *)ptr, (const OnigUChar *)end,
+                                      (const OnigUChar *)ptr, NULL, 0);
+        if (len <= 0) break;
         ENUM_ELEM(ary, rb_str_subseq(str, ptr-ptr0, len));
-	ptr += len;
+        ptr += len;
     }
     RB_GC_GUARD(str);
     if (ary)
-	return ary;
+        return ary;
     else
-	return orig;
+        return orig;
 }
 
 /*
@@ -9423,8 +9423,8 @@ chopped_length(VALUE str)
     p = rb_enc_prev_char(beg, end, end, enc);
     if (!p) return 0;
     if (p > beg && rb_enc_ascget(p, end, 0, enc) == '\n') {
-	p2 = rb_enc_prev_char(beg, p, end, enc);
-	if (p2 && rb_enc_ascget(p2, end, 0, enc) == '\r') p = p2;
+        p2 = rb_enc_prev_char(beg, p, end, enc);
+        if (p2 && rb_enc_ascget(p2, end, 0, enc) == '\r') p = p2;
     }
     return p - beg;
 }
@@ -9444,14 +9444,14 @@ rb_str_chop_bang(VALUE str)
 {
     str_modify_keep_cr(str);
     if (RSTRING_LEN(str) > 0) {
-	long len;
-	len = chopped_length(str);
-	STR_SET_LEN(str, len);
-	TERM_FILL(&RSTRING_PTR(str)[len], TERM_LEN(str));
-	if (ENC_CODERANGE(str) != ENC_CODERANGE_7BIT) {
-	    ENC_CODERANGE_CLEAR(str);
-	}
-	return str;
+        long len;
+        len = chopped_length(str);
+        STR_SET_LEN(str, len);
+        TERM_FILL(&RSTRING_PTR(str)[len], TERM_LEN(str));
+        if (ENC_CODERANGE(str) != ENC_CODERANGE_7BIT) {
+            ENC_CODERANGE_CLEAR(str);
+        }
+        return str;
     }
     return Qnil;
 }
@@ -9522,55 +9522,55 @@ chompped_length(VALUE str, VALUE rs)
     enc = rb_enc_get(str);
     RSTRING_GETMEM(rs, rsptr, rslen);
     if (rslen == 0) {
-	if (rb_enc_mbminlen(enc) > 1) {
-	    while (e > p) {
-		pp = rb_enc_left_char_head(p, e-rb_enc_mbminlen(enc), e, enc);
-		if (!rb_enc_is_newline(pp, e, enc)) break;
-		e = pp;
-		pp -= rb_enc_mbminlen(enc);
-		if (pp >= p) {
-		    pp = rb_enc_left_char_head(p, pp, e, enc);
-		    if (rb_enc_ascget(pp, e, 0, enc) == '\r') {
-			e = pp;
-		    }
-		}
-	    }
-	}
-	else {
-	    while (e > p && *(e-1) == '\n') {
-		--e;
-		if (e > p && *(e-1) == '\r')
-		    --e;
-	    }
-	}
-	return e - p;
+        if (rb_enc_mbminlen(enc) > 1) {
+            while (e > p) {
+                pp = rb_enc_left_char_head(p, e-rb_enc_mbminlen(enc), e, enc);
+                if (!rb_enc_is_newline(pp, e, enc)) break;
+                e = pp;
+                pp -= rb_enc_mbminlen(enc);
+                if (pp >= p) {
+                    pp = rb_enc_left_char_head(p, pp, e, enc);
+                    if (rb_enc_ascget(pp, e, 0, enc) == '\r') {
+                        e = pp;
+                    }
+                }
+            }
+        }
+        else {
+            while (e > p && *(e-1) == '\n') {
+                --e;
+                if (e > p && *(e-1) == '\r')
+                    --e;
+            }
+        }
+        return e - p;
     }
     if (rslen > len) return len;
 
     enc = rb_enc_get(rs);
     newline = rsptr[rslen-1];
     if (rslen == rb_enc_mbminlen(enc)) {
-	if (rslen == 1) {
-	    if (newline == '\n')
+        if (rslen == 1) {
+            if (newline == '\n')
                 return smart_chomp(str, e, p);
-	}
-	else {
-	    if (rb_enc_is_newline(rsptr, rsptr+rslen, enc))
+        }
+        else {
+            if (rb_enc_is_newline(rsptr, rsptr+rslen, enc))
                 return smart_chomp(str, e, p);
-	}
+        }
     }
 
     enc = rb_enc_check(str, rs);
     if (is_broken_string(rs)) {
-	return len;
+        return len;
     }
     pp = e - rslen;
     if (p[len-1] == newline &&
-	(rslen <= 1 ||
-	 memcmp(rsptr, pp, rslen) == 0)) {
-	if (rb_enc_left_char_head(p, pp, e, enc) == pp)
-	    return len - rslen;
-	RB_GC_GUARD(rs);
+        (rslen <= 1 ||
+         memcmp(rsptr, pp, rslen) == 0)) {
+        if (rb_enc_left_char_head(p, pp, e, enc) == pp)
+            return len - rslen;
+        RB_GC_GUARD(rs);
     }
     return len;
 }
@@ -9585,12 +9585,12 @@ chomp_rs(int argc, const VALUE *argv)
 {
     rb_check_arity(argc, 0, 1);
     if (argc > 0) {
-	VALUE rs = argv[0];
-	if (!NIL_P(rs)) StringValue(rs);
-	return rs;
+        VALUE rs = argv[0];
+        if (!NIL_P(rs)) StringValue(rs);
+        return rs;
     }
     else {
-	return rb_rs;
+        return rb_rs;
     }
 }
 
@@ -9604,7 +9604,7 @@ rb_str_chomp_string(VALUE str, VALUE rs)
     STR_SET_LEN(str, len);
     TERM_FILL(&RSTRING_PTR(str)[len], TERM_LEN(str));
     if (ENC_CODERANGE(str) != ENC_CODERANGE_7BIT) {
-	ENC_CODERANGE_CLEAR(str);
+        ENC_CODERANGE_CLEAR(str);
     }
     return str;
 }
@@ -9658,13 +9658,13 @@ lstrip_offset(VALUE str, const char *s, const char *e, rb_encoding *enc)
         while (s < e && (*s == '\0' || ascii_isspace(*s))) s++;
     }
     else {
-	while (s < e) {
-	    int n;
-	    unsigned int cc = rb_enc_codepoint_len(s, e, &n, enc);
+        while (s < e) {
+            int n;
+            unsigned int cc = rb_enc_codepoint_len(s, e, &n, enc);
 
             if (cc && !rb_isspace(cc)) break;
-	    s += n;
-	}
+            s += n;
+        }
     }
     return s - start;
 }
@@ -9691,12 +9691,12 @@ rb_str_lstrip_bang(VALUE str)
     RSTRING_GETMEM(str, start, olen);
     loffset = lstrip_offset(str, start, start+olen, enc);
     if (loffset > 0) {
-	long len = olen-loffset;
-	s = start + loffset;
-	memmove(start, s, len);
-	STR_SET_LEN(str, len);
-	TERM_FILL(start+len, rb_enc_mbminlen(enc));
-	return str;
+        long len = olen-loffset;
+        s = start + loffset;
+        memmove(start, s, len);
+        STR_SET_LEN(str, len);
+        TERM_FILL(start+len, rb_enc_mbminlen(enc));
+        return str;
     }
     return Qnil;
 }
@@ -9739,17 +9739,17 @@ rstrip_offset(VALUE str, const char *s, const char *e, rb_encoding *enc)
 
     /* remove trailing spaces or '\0's */
     if (single_byte_optimizable(str)) {
-	unsigned char c;
-	while (s < t && ((c = *(t-1)) == '\0' || ascii_isspace(c))) t--;
+        unsigned char c;
+        while (s < t && ((c = *(t-1)) == '\0' || ascii_isspace(c))) t--;
     }
     else {
-	char *tp;
+        char *tp;
 
         while ((tp = rb_enc_prev_char(s, t, e, enc)) != NULL) {
-	    unsigned int c = rb_enc_codepoint(tp, e, enc);
-	    if (c && !rb_isspace(c)) break;
-	    t = tp;
-	}
+            unsigned int c = rb_enc_codepoint(tp, e, enc);
+            if (c && !rb_isspace(c)) break;
+            t = tp;
+        }
     }
     return e - t;
 }
@@ -9776,11 +9776,11 @@ rb_str_rstrip_bang(VALUE str)
     RSTRING_GETMEM(str, start, olen);
     roffset = rstrip_offset(str, start, start+olen, enc);
     if (roffset > 0) {
-	long len = olen - roffset;
+        long len = olen - roffset;
 
-	STR_SET_LEN(str, len);
-	TERM_FILL(start+len, rb_enc_mbminlen(enc));
-	return str;
+        STR_SET_LEN(str, len);
+        TERM_FILL(start+len, rb_enc_mbminlen(enc));
+        return str;
     }
     return Qnil;
 }
@@ -9841,14 +9841,14 @@ rb_str_strip_bang(VALUE str)
     roffset = rstrip_offset(str, start+loffset, start+olen, enc);
 
     if (loffset > 0 || roffset > 0) {
-	long len = olen-roffset;
-	if (loffset > 0) {
-	    len -= loffset;
-	    memmove(start, start + loffset, len);
-	}
-	STR_SET_LEN(str, len);
-	TERM_FILL(start+len, rb_enc_mbminlen(enc));
-	return str;
+        long len = olen-roffset;
+        if (loffset > 0) {
+            len -= loffset;
+            memmove(start, start + loffset, len);
+        }
+        STR_SET_LEN(str, len);
+        TERM_FILL(start+len, rb_enc_mbminlen(enc));
+        return str;
     }
     return Qnil;
 }
@@ -9892,44 +9892,44 @@ scan_once(VALUE str, VALUE pat, long *start, int set_backref_str)
     int i;
     long end, pos = rb_pat_search(pat, str, *start, set_backref_str);
     if (pos >= 0) {
-	if (BUILTIN_TYPE(pat) == T_STRING) {
-	    regs = NULL;
-	    end = pos + RSTRING_LEN(pat);
-	}
-	else {
-	    match = rb_backref_get();
-	    regs = RMATCH_REGS(match);
-	    pos = BEG(0);
-	    end = END(0);
-	}
-	if (pos == end) {
-	    rb_encoding *enc = STR_ENC_GET(str);
-	    /*
-	     * Always consume at least one character of the input string
-	     */
-	    if (RSTRING_LEN(str) > end)
-		*start = end + rb_enc_fast_mbclen(RSTRING_PTR(str) + end,
-						  RSTRING_END(str), enc);
-	    else
-		*start = end + 1;
-	}
-	else {
-	    *start = end;
-	}
-	if (!regs || regs->num_regs == 1) {
-	    result = rb_str_subseq(str, pos, end - pos);
-	    return result;
-	}
-	result = rb_ary_new2(regs->num_regs);
-	for (i=1; i < regs->num_regs; i++) {
-	    VALUE s = Qnil;
-	    if (BEG(i) >= 0) {
-		s = rb_str_subseq(str, BEG(i), END(i)-BEG(i));
-	    }
-	    rb_ary_push(result, s);
-	}
-
-	return result;
+        if (BUILTIN_TYPE(pat) == T_STRING) {
+            regs = NULL;
+            end = pos + RSTRING_LEN(pat);
+        }
+        else {
+            match = rb_backref_get();
+            regs = RMATCH_REGS(match);
+            pos = BEG(0);
+            end = END(0);
+        }
+        if (pos == end) {
+            rb_encoding *enc = STR_ENC_GET(str);
+            /*
+             * Always consume at least one character of the input string
+             */
+            if (RSTRING_LEN(str) > end)
+                *start = end + rb_enc_fast_mbclen(RSTRING_PTR(str) + end,
+                                                  RSTRING_END(str), enc);
+            else
+                *start = end + 1;
+        }
+        else {
+            *start = end;
+        }
+        if (!regs || regs->num_regs == 1) {
+            result = rb_str_subseq(str, pos, end - pos);
+            return result;
+        }
+        result = rb_ary_new2(regs->num_regs);
+        for (i=1; i < regs->num_regs; i++) {
+            VALUE s = Qnil;
+            if (BEG(i) >= 0) {
+                s = rb_str_subseq(str, BEG(i), END(i)-BEG(i));
+            }
+            rb_ary_push(result, s);
+        }
+
+        return result;
     }
     return Qnil;
 }
@@ -9985,23 +9985,23 @@ rb_str_scan(VALUE str, VALUE pat)
     pat = get_pat_quoted(pat, 1);
     mustnot_broken(str);
     if (!rb_block_given_p()) {
-	VALUE ary = rb_ary_new();
+        VALUE ary = rb_ary_new();
 
-	while (!NIL_P(result = scan_once(str, pat, &start, 0))) {
-	    last = prev;
-	    prev = start;
-	    rb_ary_push(ary, result);
-	}
-	if (last >= 0) rb_pat_search(pat, str, last, 1);
-	else rb_backref_set(Qnil);
-	return ary;
+        while (!NIL_P(result = scan_once(str, pat, &start, 0))) {
+            last = prev;
+            prev = start;
+            rb_ary_push(ary, result);
+        }
+        if (last >= 0) rb_pat_search(pat, str, last, 1);
+        else rb_backref_set(Qnil);
+        return ary;
     }
 
     while (!NIL_P(result = scan_once(str, pat, &start, 1))) {
-	last = prev;
-	prev = start;
-	rb_yield(result);
-	str_mod_check(str, p, len);
+        last = prev;
+        prev = start;
+        rb_yield(result);
+        str_mod_check(str, p, len);
     }
     if (last >= 0) rb_pat_search(pat, str, last, 1);
     return str;
@@ -10157,15 +10157,15 @@ rb_str_crypt(VALUE str, VALUE salt)
     s = StringValueCStr(str);
     saltp = RSTRING_PTR(salt);
     if (RSTRING_LEN(salt) < 2 || !saltp[0] || !saltp[1]) {
-	rb_raise(rb_eArgError, "salt too short (need >=2 bytes)");
+        rb_raise(rb_eArgError, "salt too short (need >=2 bytes)");
     }
 
 #ifdef BROKEN_CRYPT
     if (!ISASCII((unsigned char)saltp[0]) || !ISASCII((unsigned char)saltp[1])) {
-	salt_8bit_clean[0] = saltp[0] & 0x7f;
-	salt_8bit_clean[1] = saltp[1] & 0x7f;
-	salt_8bit_clean[2] = '\0';
-	saltp = salt_8bit_clean;
+        salt_8bit_clean[0] = saltp[0] & 0x7f;
+        salt_8bit_clean[1] = saltp[1] & 0x7f;
+        salt_8bit_clean[2] = '\0';
+        saltp = salt_8bit_clean;
     }
 #endif
 #ifdef HAVE_CRYPT_R
@@ -10180,9 +10180,9 @@ rb_str_crypt(VALUE str, VALUE salt)
     res = crypt(s, saltp);
 #endif
     if (!res) {
-	int err = errno;
-	CRYPT_END();
-	rb_syserr_fail(err, "crypt");
+        int err = errno;
+        CRYPT_END();
+        rb_syserr_fail(err, "crypt");
     }
     result = rb_str_new_cstr(res);
     CRYPT_END();
@@ -10286,15 +10286,15 @@ rb_str_justify(int argc, VALUE *argv, VALUE str, char jflag)
     termlen = rb_enc_mbminlen(enc);
     width = NUM2LONG(w);
     if (argc == 2) {
-	StringValue(pad);
-	enc = rb_enc_check(str, pad);
-	f = RSTRING_PTR(pad);
-	flen = RSTRING_LEN(pad);
-	fclen = str_strlen(pad, enc); /* rb_enc_check */
-	singlebyte = single_byte_optimizable(pad);
-	if (flen == 0 || fclen == 0) {
-	    rb_raise(rb_eArgError, "zero width padding");
-	}
+        StringValue(pad);
+        enc = rb_enc_check(str, pad);
+        f = RSTRING_PTR(pad);
+        flen = RSTRING_LEN(pad);
+        fclen = str_strlen(pad, enc); /* rb_enc_check */
+        singlebyte = single_byte_optimizable(pad);
+        if (flen == 0 || fclen == 0) {
+            rb_raise(rb_eArgError, "zero width padding");
+        }
     }
     len = str_strlen(str, enc); /* rb_enc_check */
     if (width < 0 || len >= width) return str_duplicate(rb_cString, str);
@@ -10321,14 +10321,14 @@ rb_str_justify(int argc, VALUE *argv, VALUE str, char jflag)
     }
     else {
        while (llen >= fclen) {
-	    memcpy(p,f,flen);
-	    p += flen;
-	    llen -= fclen;
-	}
+            memcpy(p,f,flen);
+            p += flen;
+            llen -= fclen;
+        }
        if (llen > 0) {
            memcpy(p, f, llen2);
            p += llen2;
-	}
+        }
     }
     memcpy(p, RSTRING_PTR(str), size);
     p += size;
@@ -10338,22 +10338,22 @@ rb_str_justify(int argc, VALUE *argv, VALUE str, char jflag)
     }
     else {
        while (rlen >= fclen) {
-	    memcpy(p,f,flen);
-	    p += flen;
-	    rlen -= fclen;
-	}
+            memcpy(p,f,flen);
+            p += flen;
+            rlen -= fclen;
+        }
        if (rlen > 0) {
            memcpy(p, f, rlen2);
            p += rlen2;
-	}
+        }
     }
     TERM_FILL(p, termlen);
     STR_SET_LEN(res, p-RSTRING_PTR(res));
     rb_enc_associate(res, enc);
     if (argc == 2)
-	cr = ENC_CODERANGE_AND(cr, ENC_CODERANGE(pad));
+        cr = ENC_CODERANGE_AND(cr, ENC_CODERANGE(pad));
     if (cr != ENC_CODERANGE_BROKEN)
-	ENC_CODERANGE_SET(res, cr);
+        ENC_CODERANGE_SET(res, cr);
 
     RB_GC_GUARD(pad);
     return res;
@@ -10424,23 +10424,23 @@ rb_str_partition(VALUE str, VALUE sep)
 
     sep = get_pat_quoted(sep, 0);
     if (RB_TYPE_P(sep, T_REGEXP)) {
-	if (rb_reg_search(sep, str, 0, 0) < 0) {
+        if (rb_reg_search(sep, str, 0, 0) < 0) {
             goto failed;
-	}
-	VALUE match = rb_backref_get();
-	struct re_registers *regs = RMATCH_REGS(match);
+        }
+        VALUE match = rb_backref_get();
+        struct re_registers *regs = RMATCH_REGS(match);
 
         pos = BEG(0);
-	sep = rb_str_subseq(str, pos, END(0) - pos);
+        sep = rb_str_subseq(str, pos, END(0) - pos);
     }
     else {
-	pos = rb_str_index(str, sep, 0);
-	if (pos < 0) goto failed;
+        pos = rb_str_index(str, sep, 0);
+        if (pos < 0) goto failed;
     }
     return rb_ary_new3(3, rb_str_subseq(str, 0, pos),
-		          sep,
-		          rb_str_subseq(str, pos+RSTRING_LEN(sep),
-					     RSTRING_LEN(str)-pos-RSTRING_LEN(sep)));
+                          sep,
+                          rb_str_subseq(str, pos+RSTRING_LEN(sep),
+                                             RSTRING_LEN(str)-pos-RSTRING_LEN(sep)));
 
   failed:
     return rb_ary_new3(3, str_duplicate(rb_cString, str), str_new_empty_String(str), str_new_empty_String(str));
@@ -10465,14 +10465,14 @@ rb_str_rpartition(VALUE str, VALUE sep)
             goto failed;
         }
         VALUE match = rb_backref_get();
-	struct re_registers *regs = RMATCH_REGS(match);
+        struct re_registers *regs = RMATCH_REGS(match);
 
         pos = BEG(0);
         sep = rb_str_subseq(str, pos, END(0) - pos);
     }
     else {
-	pos = rb_str_sublen(str, pos);
-	pos = rb_str_rindex(str, sep, pos);
+        pos = rb_str_sublen(str, pos);
+        pos = rb_str_rindex(str, sep, pos);
         if (pos < 0) {
             goto failed;
         }
@@ -10480,9 +10480,9 @@ rb_str_rpartition(VALUE str, VALUE sep)
     }
 
     return rb_ary_new3(3, rb_str_subseq(str, 0, pos),
-		          sep,
-		          rb_str_subseq(str, pos+RSTRING_LEN(sep),
-					RSTRING_LEN(str)-pos-RSTRING_LEN(sep)));
+                          sep,
+                          rb_str_subseq(str, pos+RSTRING_LEN(sep),
+                                        RSTRING_LEN(str)-pos-RSTRING_LEN(sep)));
   failed:
     return rb_ary_new3(3, str_new_empty_String(str), str_new_empty_String(str), str_duplicate(rb_cString, str));
 }
@@ -10501,18 +10501,18 @@ rb_str_start_with(int argc, VALUE *argv, VALUE str)
     int i;
 
     for (i=0; i<argc; i++) {
-	VALUE tmp = argv[i];
-	if (RB_TYPE_P(tmp, T_REGEXP)) {
-	    if (rb_reg_start_with_p(tmp, str))
-		return Qtrue;
-	}
-	else {
-	    StringValue(tmp);
-	    rb_enc_check(str, tmp);
-	    if (RSTRING_LEN(str) < RSTRING_LEN(tmp)) continue;
-	    if (memcmp(RSTRING_PTR(str), RSTRING_PTR(tmp), RSTRING_LEN(tmp)) == 0)
-		return Qtrue;
-	}
+        VALUE tmp = argv[i];
+        if (RB_TYPE_P(tmp, T_REGEXP)) {
+            if (rb_reg_start_with_p(tmp, str))
+                return Qtrue;
+        }
+        else {
+            StringValue(tmp);
+            rb_enc_check(str, tmp);
+            if (RSTRING_LEN(str) < RSTRING_LEN(tmp)) continue;
+            if (memcmp(RSTRING_PTR(str), RSTRING_PTR(tmp), RSTRING_LEN(tmp)) == 0)
+                return Qtrue;
+        }
     }
     return Qfalse;
 }
@@ -10533,19 +10533,19 @@ rb_str_end_with(int argc, VALUE *argv, VALUE str)
     rb_encoding *enc;
 
     for (i=0; i<argc; i++) {
-	VALUE tmp = argv[i];
-	long slen, tlen;
-	StringValue(tmp);
-	enc = rb_enc_check(str, tmp);
-	if ((tlen = RSTRING_LEN(tmp)) == 0) return Qtrue;
-	if ((slen = RSTRING_LEN(str)) < tlen) continue;
-	p = RSTRING_PTR(str);
+        VALUE tmp = argv[i];
+        long slen, tlen;
+        StringValue(tmp);
+        enc = rb_enc_check(str, tmp);
+        if ((tlen = RSTRING_LEN(tmp)) == 0) return Qtrue;
+        if ((slen = RSTRING_LEN(str)) < tlen) continue;
+        p = RSTRING_PTR(str);
         e = p + slen;
-	s = e - tlen;
-	if (rb_enc_left_char_head(p, s, e, enc) != s)
-	    continue;
-	if (memcmp(s, RSTRING_PTR(tmp), RSTRING_LEN(tmp)) == 0)
-	    return Qtrue;
+        s = e - tlen;
+        if (rb_enc_left_char_head(p, s, e, enc) != s)
+            continue;
+        if (memcmp(s, RSTRING_PTR(tmp), RSTRING_LEN(tmp)) == 0)
+            return Qtrue;
     }
     return Qfalse;
 }
@@ -10679,7 +10679,7 @@ rb_str_delete_suffix_bang(VALUE str, VALUE suffix)
     STR_SET_LEN(str, len);
     TERM_FILL(&RSTRING_PTR(str)[len], TERM_LEN(str));
     if (ENC_CODERANGE(str) != ENC_CODERANGE_7BIT) {
-	ENC_CODERANGE_CLEAR(str);
+        ENC_CODERANGE_CLEAR(str);
     }
     return str;
 }
@@ -10707,7 +10707,7 @@ void
 rb_str_setter(VALUE val, ID id, VALUE *var)
 {
     if (!NIL_P(val) && !RB_TYPE_P(val, T_STRING)) {
-	rb_raise(rb_eTypeError, "value of %"PRIsVALUE" must be String", rb_id2str(id));
+        rb_raise(rb_eTypeError, "value of %"PRIsVALUE" must be String", rb_id2str(id));
     }
     *var = val;
 }
@@ -10717,9 +10717,9 @@ rb_fs_setter(VALUE val, ID id, VALUE *var)
 {
     val = rb_fs_check(val);
     if (!val) {
-	rb_raise(rb_eTypeError,
-		 "value of %"PRIsVALUE" must be String or Regexp",
-		 rb_id2str(id));
+        rb_raise(rb_eTypeError,
+                 "value of %"PRIsVALUE" must be String or Regexp",
+                 rb_id2str(id));
     }
     if (!NIL_P(val)) {
         rb_warn_deprecated("`$;'", NULL);
@@ -10819,27 +10819,27 @@ rb_str_ellipsize(VALUE str, long len)
 
     if (len < 0) rb_raise(rb_eIndexError, "negative length %ld", len);
     if (len * rb_enc_mbminlen(enc) >= blen ||
-	(e = rb_enc_nth(p, e, len, enc)) - p == blen) {
-	ret = str;
+        (e = rb_enc_nth(p, e, len, enc)) - p == blen) {
+        ret = str;
     }
     else if (len <= ellipsislen ||
-	     !(e = rb_enc_step_back(p, e, e, len = ellipsislen, enc))) {
-	if (rb_enc_asciicompat(enc)) {
+             !(e = rb_enc_step_back(p, e, e, len = ellipsislen, enc))) {
+        if (rb_enc_asciicompat(enc)) {
             ret = rb_str_new(ellipsis, len);
-	    rb_enc_associate(ret, enc);
-	}
-	else {
-	    estr = rb_usascii_str_new(ellipsis, len);
-	    ret = rb_str_encode(estr, rb_enc_from_encoding(enc), 0, Qnil);
-	}
+            rb_enc_associate(ret, enc);
+        }
+        else {
+            estr = rb_usascii_str_new(ellipsis, len);
+            ret = rb_str_encode(estr, rb_enc_from_encoding(enc), 0, Qnil);
+        }
     }
     else if (ret = rb_str_subseq(str, 0, e - p), rb_enc_asciicompat(enc)) {
-	rb_str_cat(ret, ellipsis, ellipsislen);
+        rb_str_cat(ret, ellipsis, ellipsislen);
     }
     else {
-	estr = rb_str_encode(rb_usascii_str_new(ellipsis, ellipsislen),
-			     rb_enc_from_encoding(enc), 0, Qnil);
-	rb_str_append(ret, estr);
+        estr = rb_str_encode(rb_usascii_str_new(ellipsis, ellipsislen),
+                             rb_enc_from_encoding(enc), 0, Qnil);
+        rb_str_append(ret, estr);
     }
     return ret;
 }
@@ -10851,14 +10851,14 @@ str_compat_and_valid(VALUE str, rb_encoding *enc)
     str = StringValue(str);
     cr = rb_enc_str_coderange(str);
     if (cr == ENC_CODERANGE_BROKEN) {
-	rb_raise(rb_eArgError, "replacement must be valid byte sequence '%+"PRIsVALUE"'", str);
+        rb_raise(rb_eArgError, "replacement must be valid byte sequence '%+"PRIsVALUE"'", str);
     }
     else {
-	rb_encoding *e = STR_ENC_GET(str);
-	if (cr == ENC_CODERANGE_7BIT ? rb_enc_mbminlen(enc) != 1 : enc != e) {
-	    rb_raise(rb_eEncCompatError, "incompatible character encodings: %s and %s",
-		     rb_enc_name(enc), rb_enc_name(e));
-	}
+        rb_encoding *e = STR_ENC_GET(str);
+        if (cr == ENC_CODERANGE_7BIT ? rb_enc_mbminlen(enc) != 1 : enc != e) {
+            rb_raise(rb_eEncCompatError, "incompatible character encodings: %s and %s",
+                     rb_enc_name(enc), rb_enc_name(e));
+        }
     }
     return str;
 }
@@ -10877,9 +10877,9 @@ rb_enc_str_scrub(rb_encoding *enc, VALUE str, VALUE repl)
 {
     int cr = ENC_CODERANGE_UNKNOWN;
     if (enc == STR_ENC_GET(str)) {
-	/* cached coderange makes sense only when enc equals the
-	 * actual encoding of str */
-	cr = ENC_CODERANGE(str);
+        /* cached coderange makes sense only when enc equals the
+         * actual encoding of str */
+        cr = ENC_CODERANGE(str);
     }
     return enc_str_scrub(enc, str, repl, cr);
 }
@@ -10894,26 +10894,26 @@ enc_str_scrub(rb_encoding *enc, VALUE str, VALUE repl, int cr)
     long slen;
 
     if (rb_block_given_p()) {
-	if (!NIL_P(repl))
-	    rb_raise(rb_eArgError, "both of block and replacement given");
-	replen = 0;
+        if (!NIL_P(repl))
+            rb_raise(rb_eArgError, "both of block and replacement given");
+        replen = 0;
     }
 
     if (ENC_CODERANGE_CLEAN_P(cr))
-	return Qnil;
+        return Qnil;
 
     if (!NIL_P(repl)) {
-	repl = str_compat_and_valid(repl, enc);
+        repl = str_compat_and_valid(repl, enc);
     }
 
     if (rb_enc_dummy_p(enc)) {
-	return Qnil;
+        return Qnil;
     }
     encidx = rb_enc_to_index(enc);
 
 #define DEFAULT_REPLACE_CHAR(str) do { \
-	static const char replace[sizeof(str)-1] = str; \
-	rep = replace; replen = (int)sizeof(replace); \
+        static const char replace[sizeof(str)-1] = str; \
+        rep = replace; replen = (int)sizeof(replace); \
     } while (0)
 
     slen = RSTRING_LEN(str);
@@ -10923,204 +10923,204 @@ enc_str_scrub(rb_encoding *enc, VALUE str, VALUE repl, int cr)
     sp = p;
 
     if (rb_enc_asciicompat(enc)) {
-	int rep7bit_p;
-	if (!replen) {
-	    rep = NULL;
-	    rep7bit_p = FALSE;
-	}
-	else if (!NIL_P(repl)) {
-	    rep = RSTRING_PTR(repl);
-	    replen = RSTRING_LEN(repl);
-	    rep7bit_p = (ENC_CODERANGE(repl) == ENC_CODERANGE_7BIT);
-	}
-	else if (encidx == rb_utf8_encindex()) {
-	    DEFAULT_REPLACE_CHAR("\xEF\xBF\xBD");
-	    rep7bit_p = FALSE;
-	}
-	else {
-	    DEFAULT_REPLACE_CHAR("?");
-	    rep7bit_p = TRUE;
-	}
-	cr = ENC_CODERANGE_7BIT;
-
-	p = search_nonascii(p, e);
-	if (!p) {
-	    p = e;
-	}
-	while (p < e) {
-	    int ret = rb_enc_precise_mbclen(p, e, enc);
-	    if (MBCLEN_NEEDMORE_P(ret)) {
-		break;
-	    }
-	    else if (MBCLEN_CHARFOUND_P(ret)) {
-		cr = ENC_CODERANGE_VALID;
-		p += MBCLEN_CHARFOUND_LEN(ret);
-	    }
-	    else if (MBCLEN_INVALID_P(ret)) {
-		/*
-		 * p1~p: valid ascii/multibyte chars
-		 * p ~e: invalid bytes + unknown bytes
-		 */
-		long clen = rb_enc_mbmaxlen(enc);
-		if (NIL_P(buf)) buf = rb_str_buf_new(RSTRING_LEN(str));
-		if (p > p1) {
-		    rb_str_buf_cat(buf, p1, p - p1);
-		}
-
-		if (e - p < clen) clen = e - p;
-		if (clen <= 2) {
-		    clen = 1;
-		}
-		else {
-		    const char *q = p;
-		    clen--;
-		    for (; clen > 1; clen--) {
-			ret = rb_enc_precise_mbclen(q, q + clen, enc);
-			if (MBCLEN_NEEDMORE_P(ret)) break;
-			if (MBCLEN_INVALID_P(ret)) continue;
-			UNREACHABLE;
-		    }
-		}
-		if (rep) {
-		    rb_str_buf_cat(buf, rep, replen);
-		    if (!rep7bit_p) cr = ENC_CODERANGE_VALID;
-		}
-		else {
-		    repl = rb_yield(rb_enc_str_new(p, clen, enc));
+        int rep7bit_p;
+        if (!replen) {
+            rep = NULL;
+            rep7bit_p = FALSE;
+        }
+        else if (!NIL_P(repl)) {
+            rep = RSTRING_PTR(repl);
+            replen = RSTRING_LEN(repl);
+            rep7bit_p = (ENC_CODERANGE(repl) == ENC_CODERANGE_7BIT);
+        }
+        else if (encidx == rb_utf8_encindex()) {
+            DEFAULT_REPLACE_CHAR("\xEF\xBF\xBD");
+            rep7bit_p = FALSE;
+        }
+        else {
+            DEFAULT_REPLACE_CHAR("?");
+            rep7bit_p = TRUE;
+        }
+        cr = ENC_CODERANGE_7BIT;
+
+        p = search_nonascii(p, e);
+        if (!p) {
+            p = e;
+        }
+        while (p < e) {
+            int ret = rb_enc_precise_mbclen(p, e, enc);
+            if (MBCLEN_NEEDMORE_P(ret)) {
+                break;
+            }
+            else if (MBCLEN_CHARFOUND_P(ret)) {
+                cr = ENC_CODERANGE_VALID;
+                p += MBCLEN_CHARFOUND_LEN(ret);
+            }
+            else if (MBCLEN_INVALID_P(ret)) {
+                /*
+                 * p1~p: valid ascii/multibyte chars
+                 * p ~e: invalid bytes + unknown bytes
+                 */
+                long clen = rb_enc_mbmaxlen(enc);
+                if (NIL_P(buf)) buf = rb_str_buf_new(RSTRING_LEN(str));
+                if (p > p1) {
+                    rb_str_buf_cat(buf, p1, p - p1);
+                }
+
+                if (e - p < clen) clen = e - p;
+                if (clen <= 2) {
+                    clen = 1;
+                }
+                else {
+                    const char *q = p;
+                    clen--;
+                    for (; clen > 1; clen--) {
+                        ret = rb_enc_precise_mbclen(q, q + clen, enc);
+                        if (MBCLEN_NEEDMORE_P(ret)) break;
+                        if (MBCLEN_INVALID_P(ret)) continue;
+                        UNREACHABLE;
+                    }
+                }
+                if (rep) {
+                    rb_str_buf_cat(buf, rep, replen);
+                    if (!rep7bit_p) cr = ENC_CODERANGE_VALID;
+                }
+                else {
+                    repl = rb_yield(rb_enc_str_new(p, clen, enc));
                     str_mod_check(str, sp, slen);
-		    repl = str_compat_and_valid(repl, enc);
-		    rb_str_buf_cat(buf, RSTRING_PTR(repl), RSTRING_LEN(repl));
-		    if (ENC_CODERANGE(repl) == ENC_CODERANGE_VALID)
-			cr = ENC_CODERANGE_VALID;
-		}
-		p += clen;
-		p1 = p;
-		p = search_nonascii(p, e);
-		if (!p) {
-		    p = e;
-		    break;
-		}
-	    }
-	    else {
-		UNREACHABLE;
-	    }
-	}
-	if (NIL_P(buf)) {
-	    if (p == e) {
-		ENC_CODERANGE_SET(str, cr);
-		return Qnil;
-	    }
-	    buf = rb_str_buf_new(RSTRING_LEN(str));
-	}
-	if (p1 < p) {
-	    rb_str_buf_cat(buf, p1, p - p1);
-	}
-	if (p < e) {
-	    if (rep) {
-		rb_str_buf_cat(buf, rep, replen);
-		if (!rep7bit_p) cr = ENC_CODERANGE_VALID;
-	    }
-	    else {
-		repl = rb_yield(rb_enc_str_new(p, e-p, enc));
+                    repl = str_compat_and_valid(repl, enc);
+                    rb_str_buf_cat(buf, RSTRING_PTR(repl), RSTRING_LEN(repl));
+                    if (ENC_CODERANGE(repl) == ENC_CODERANGE_VALID)
+                        cr = ENC_CODERANGE_VALID;
+                }
+                p += clen;
+                p1 = p;
+                p = search_nonascii(p, e);
+                if (!p) {
+                    p = e;
+                    break;
+                }
+            }
+            else {
+                UNREACHABLE;
+            }
+        }
+        if (NIL_P(buf)) {
+            if (p == e) {
+                ENC_CODERANGE_SET(str, cr);
+                return Qnil;
+            }
+            buf = rb_str_buf_new(RSTRING_LEN(str));
+        }
+        if (p1 < p) {
+            rb_str_buf_cat(buf, p1, p - p1);
+        }
+        if (p < e) {
+            if (rep) {
+                rb_str_buf_cat(buf, rep, replen);
+                if (!rep7bit_p) cr = ENC_CODERANGE_VALID;
+            }
+            else {
+                repl = rb_yield(rb_enc_str_new(p, e-p, enc));
                 str_mod_check(str, sp, slen);
-		repl = str_compat_and_valid(repl, enc);
-		rb_str_buf_cat(buf, RSTRING_PTR(repl), RSTRING_LEN(repl));
-		if (ENC_CODERANGE(repl) == ENC_CODERANGE_VALID)
-		    cr = ENC_CODERANGE_VALID;
-	    }
-	}
+                repl = str_compat_and_valid(repl, enc);
+                rb_str_buf_cat(buf, RSTRING_PTR(repl), RSTRING_LEN(repl));
+                if (ENC_CODERANGE(repl) == ENC_CODERANGE_VALID)
+                    cr = ENC_CODERANGE_VALID;
+            }
+        }
     }
     else {
-	/* ASCII incompatible */
-	long mbminlen = rb_enc_mbminlen(enc);
-	if (!replen) {
-	    rep = NULL;
-	}
-	else if (!NIL_P(repl)) {
-	    rep = RSTRING_PTR(repl);
-	    replen = RSTRING_LEN(repl);
-	}
-	else if (encidx == ENCINDEX_UTF_16BE) {
-	    DEFAULT_REPLACE_CHAR("\xFF\xFD");
-	}
-	else if (encidx == ENCINDEX_UTF_16LE) {
-	    DEFAULT_REPLACE_CHAR("\xFD\xFF");
-	}
-	else if (encidx == ENCINDEX_UTF_32BE) {
-	    DEFAULT_REPLACE_CHAR("\x00\x00\xFF\xFD");
-	}
-	else if (encidx == ENCINDEX_UTF_32LE) {
-	    DEFAULT_REPLACE_CHAR("\xFD\xFF\x00\x00");
-	}
-	else {
-	    DEFAULT_REPLACE_CHAR("?");
-	}
-
-	while (p < e) {
-	    int ret = rb_enc_precise_mbclen(p, e, enc);
-	    if (MBCLEN_NEEDMORE_P(ret)) {
-		break;
-	    }
-	    else if (MBCLEN_CHARFOUND_P(ret)) {
-		p += MBCLEN_CHARFOUND_LEN(ret);
-	    }
-	    else if (MBCLEN_INVALID_P(ret)) {
-		const char *q = p;
-		long clen = rb_enc_mbmaxlen(enc);
-		if (NIL_P(buf)) buf = rb_str_buf_new(RSTRING_LEN(str));
-		if (p > p1) rb_str_buf_cat(buf, p1, p - p1);
-
-		if (e - p < clen) clen = e - p;
-		if (clen <= mbminlen * 2) {
-		    clen = mbminlen;
-		}
-		else {
-		    clen -= mbminlen;
-		    for (; clen > mbminlen; clen-=mbminlen) {
-			ret = rb_enc_precise_mbclen(q, q + clen, enc);
-			if (MBCLEN_NEEDMORE_P(ret)) break;
-			if (MBCLEN_INVALID_P(ret)) continue;
-			UNREACHABLE;
-		    }
-		}
-		if (rep) {
-		    rb_str_buf_cat(buf, rep, replen);
-		}
-		else {
-		    repl = rb_yield(rb_enc_str_new(p, clen, enc));
+        /* ASCII incompatible */
+        long mbminlen = rb_enc_mbminlen(enc);
+        if (!replen) {
+            rep = NULL;
+        }
+        else if (!NIL_P(repl)) {
+            rep = RSTRING_PTR(repl);
+            replen = RSTRING_LEN(repl);
+        }
+        else if (encidx == ENCINDEX_UTF_16BE) {
+            DEFAULT_REPLACE_CHAR("\xFF\xFD");
+        }
+        else if (encidx == ENCINDEX_UTF_16LE) {
+            DEFAULT_REPLACE_CHAR("\xFD\xFF");
+        }
+        else if (encidx == ENCINDEX_UTF_32BE) {
+            DEFAULT_REPLACE_CHAR("\x00\x00\xFF\xFD");
+        }
+        else if (encidx == ENCINDEX_UTF_32LE) {
+            DEFAULT_REPLACE_CHAR("\xFD\xFF\x00\x00");
+        }
+        else {
+            DEFAULT_REPLACE_CHAR("?");
+        }
+
+        while (p < e) {
+            int ret = rb_enc_precise_mbclen(p, e, enc);
+            if (MBCLEN_NEEDMORE_P(ret)) {
+                break;
+            }
+            else if (MBCLEN_CHARFOUND_P(ret)) {
+                p += MBCLEN_CHARFOUND_LEN(ret);
+            }
+            else if (MBCLEN_INVALID_P(ret)) {
+                const char *q = p;
+                long clen = rb_enc_mbmaxlen(enc);
+                if (NIL_P(buf)) buf = rb_str_buf_new(RSTRING_LEN(str));
+                if (p > p1) rb_str_buf_cat(buf, p1, p - p1);
+
+                if (e - p < clen) clen = e - p;
+                if (clen <= mbminlen * 2) {
+                    clen = mbminlen;
+                }
+                else {
+                    clen -= mbminlen;
+                    for (; clen > mbminlen; clen-=mbminlen) {
+                        ret = rb_enc_precise_mbclen(q, q + clen, enc);
+                        if (MBCLEN_NEEDMORE_P(ret)) break;
+                        if (MBCLEN_INVALID_P(ret)) continue;
+                        UNREACHABLE;
+                    }
+                }
+                if (rep) {
+                    rb_str_buf_cat(buf, rep, replen);
+                }
+                else {
+                    repl = rb_yield(rb_enc_str_new(p, clen, enc));
                     str_mod_check(str, sp, slen);
-		    repl = str_compat_and_valid(repl, enc);
-		    rb_str_buf_cat(buf, RSTRING_PTR(repl), RSTRING_LEN(repl));
-		}
-		p += clen;
-		p1 = p;
-	    }
-	    else {
-		UNREACHABLE;
-	    }
-	}
-	if (NIL_P(buf)) {
-	    if (p == e) {
-		ENC_CODERANGE_SET(str, ENC_CODERANGE_VALID);
-		return Qnil;
-	    }
-	    buf = rb_str_buf_new(RSTRING_LEN(str));
-	}
-	if (p1 < p) {
-	    rb_str_buf_cat(buf, p1, p - p1);
-	}
-	if (p < e) {
-	    if (rep) {
-		rb_str_buf_cat(buf, rep, replen);
-	    }
-	    else {
-		repl = rb_yield(rb_enc_str_new(p, e-p, enc));
+                    repl = str_compat_and_valid(repl, enc);
+                    rb_str_buf_cat(buf, RSTRING_PTR(repl), RSTRING_LEN(repl));
+                }
+                p += clen;
+                p1 = p;
+            }
+            else {
+                UNREACHABLE;
+            }
+        }
+        if (NIL_P(buf)) {
+            if (p == e) {
+                ENC_CODERANGE_SET(str, ENC_CODERANGE_VALID);
+                return Qnil;
+            }
+            buf = rb_str_buf_new(RSTRING_LEN(str));
+        }
+        if (p1 < p) {
+            rb_str_buf_cat(buf, p1, p - p1);
+        }
+        if (p < e) {
+            if (rep) {
+                rb_str_buf_cat(buf, rep, replen);
+            }
+            else {
+                repl = rb_yield(rb_enc_str_new(p, e-p, enc));
                 str_mod_check(str, sp, slen);
-		repl = str_compat_and_valid(repl, enc);
-		rb_str_buf_cat(buf, RSTRING_PTR(repl), RSTRING_LEN(repl));
-	    }
-	}
-	cr = ENC_CODERANGE_VALID;
+                repl = str_compat_and_valid(repl, enc);
+                rb_str_buf_cat(buf, RSTRING_PTR(repl), RSTRING_LEN(repl));
+            }
+        }
+        cr = ENC_CODERANGE_VALID;
     }
     ENCODING_CODERANGE_SET(buf, rb_enc_to_index(enc), cr);
     return buf;
@@ -11171,8 +11171,8 @@ unicode_normalize_common(int argc, VALUE *argv, VALUE str, ID id)
     VALUE argv2[2];
 
     if (!UnicodeNormalizeRequired) {
-	rb_require("unicode_normalize/normalize.rb");
-	UnicodeNormalizeRequired = 1;
+        rb_require("unicode_normalize/normalize.rb");
+        UnicodeNormalizeRequired = 1;
     }
     argv2[0] = str;
     if (rb_check_arity(argc, 0, 1)) argv2[1] = argv[0];
@@ -11401,14 +11401,14 @@ static int
 sym_printable(const char *s, const char *send, rb_encoding *enc)
 {
     while (s < send) {
-	int n;
-	int c = rb_enc_precise_mbclen(s, send, enc);
+        int n;
+        int c = rb_enc_precise_mbclen(s, send, enc);
 
-	if (!MBCLEN_CHARFOUND_P(c)) return FALSE;
-	n = MBCLEN_CHARFOUND_LEN(c);
-	c = rb_enc_mbc_to_codepoint(s, send, enc);
-	if (!rb_enc_isprint(c, enc)) return FALSE;
-	s += n;
+        if (!MBCLEN_CHARFOUND_P(c)) return FALSE;
+        n = MBCLEN_CHARFOUND_LEN(c);
+        c = rb_enc_mbc_to_codepoint(s, send, enc);
+        if (!rb_enc_isprint(c, enc)) return FALSE;
+        s += n;
     }
     return TRUE;
 }
@@ -11426,8 +11426,8 @@ rb_str_symname_p(VALUE sym)
     ptr = RSTRING_PTR(sym);
     len = RSTRING_LEN(sym);
     if ((resenc != enc && !rb_str_is_ascii_only_p(sym)) || len != (long)strlen(ptr) ||
-	!rb_enc_symname2_p(ptr, len, enc) || !sym_printable(ptr, ptr + len, enc)) {
-	return FALSE;
+        !rb_enc_symname2_p(ptr, len, enc) || !sym_printable(ptr, ptr + len, enc)) {
+        return FALSE;
     }
     return TRUE;
 }
@@ -11447,8 +11447,8 @@ rb_str_quote_unprintable(VALUE str)
     ptr = RSTRING_PTR(str);
     len = RSTRING_LEN(str);
     if ((resenc != enc && !rb_str_is_ascii_only_p(str)) ||
-	!sym_printable(ptr, ptr + len, enc)) {
-	return rb_str_escape(str);
+        !sym_printable(ptr, ptr + len, enc)) {
+        return rb_str_escape(str);
     }
     return str;
 }
@@ -11458,7 +11458,7 @@ rb_id_quote_unprintable(ID id)
 {
     VALUE str = rb_id2str(id);
     if (!rb_str_symname_p(str)) {
-	return rb_str_escape(str);
+        return rb_str_escape(str);
     }
     return str;
 }
@@ -11484,18 +11484,18 @@ sym_inspect(VALUE sym)
     char *dest;
 
     if (!rb_str_symname_p(str)) {
-	str = rb_str_inspect(str);
-	len = RSTRING_LEN(str);
-	rb_str_resize(str, len + 1);
-	dest = RSTRING_PTR(str);
-	memmove(dest + 1, dest, len);
+        str = rb_str_inspect(str);
+        len = RSTRING_LEN(str);
+        rb_str_resize(str, len + 1);
+        dest = RSTRING_PTR(str);
+        memmove(dest + 1, dest, len);
     }
     else {
-	rb_encoding *enc = STR_ENC_GET(str);
-	RSTRING_GETMEM(str, ptr, len);
-	str = rb_enc_str_new(0, len + 1, enc);
-	dest = RSTRING_PTR(str);
-	memcpy(dest + 1, ptr, len);
+        rb_encoding *enc = STR_ENC_GET(str);
+        RSTRING_GETMEM(str, ptr, len);
+        str = rb_enc_str_new(0, len + 1, enc);
+        dest = RSTRING_PTR(str);
+        memcpy(dest + 1, ptr, len);
     }
     dest[0] = ':';
     return str;
@@ -11543,7 +11543,7 @@ rb_sym_proc_call(ID mid, int argc, const VALUE *argv, int kw_splat, VALUE passed
     VALUE obj;
 
     if (argc < 1) {
-	rb_raise(rb_eArgError, "no receiver given");
+        rb_raise(rb_eArgError, "no receiver given");
     }
     obj = argv[0];
     return rb_funcall_with_block_kw(obj, mid, argc - 1, argv + 1, passed_proc, kw_splat);
@@ -11590,7 +11590,7 @@ static VALUE
 sym_cmp(VALUE sym, VALUE other)
 {
     if (!SYMBOL_P(other)) {
-	return Qnil;
+        return Qnil;
     }
     return rb_str_cmp_m(rb_sym2str(sym), rb_sym2str(other));
 }
@@ -11607,7 +11607,7 @@ static VALUE
 sym_casecmp(VALUE sym, VALUE other)
 {
     if (!SYMBOL_P(other)) {
-	return Qnil;
+        return Qnil;
     }
     return str_casecmp(rb_sym2str(sym), rb_sym2str(other));
 }
@@ -11624,7 +11624,7 @@ static VALUE
 sym_casecmp_p(VALUE sym, VALUE other)
 {
     if (!SYMBOL_P(other)) {
-	return Qnil;
+        return Qnil;
     }
     return str_casecmp_p(rb_sym2str(sym), rb_sym2str(other));
 }
@@ -11838,12 +11838,12 @@ static VALUE
 string_for_symbol(VALUE name)
 {
     if (!RB_TYPE_P(name, T_STRING)) {
-	VALUE tmp = rb_check_string_type(name);
-	if (NIL_P(tmp)) {
-	    rb_raise(rb_eTypeError, "%+"PRIsVALUE" is not a symbol",
-		     name);
-	}
-	name = tmp;
+        VALUE tmp = rb_check_string_type(name);
+        if (NIL_P(tmp)) {
+            rb_raise(rb_eTypeError, "%+"PRIsVALUE" is not a symbol",
+                     name);
+        }
+        name = tmp;
     }
     return name;
 }
@@ -11852,7 +11852,7 @@ ID
 rb_to_id(VALUE name)
 {
     if (SYMBOL_P(name)) {
-	return SYM2ID(name);
+        return SYM2ID(name);
     }
     name = string_for_symbol(name);
     return rb_intern_str(name);
@@ -11862,7 +11862,7 @@ VALUE
 rb_to_symbol(VALUE name)
 {
     if (SYMBOL_P(name)) {
-	return name;
+        return name;
     }
     name = string_for_symbol(name);
     return rb_str_intern(name);