Expand tabs [ci skip]

[Misc #18891]

1 files changed, 924 insertions, 924 deletions

diff --git a/ruby.c b/ruby.c
index 311e92a235..87876d5160 100644
--- a/ruby.c
+++ b/ruby.c
@@ -154,8 +154,8 @@ enum dump_flag_bits {
     dump_version_v,
     EACH_DUMPS(DEFINE_DUMP, COMMA),
     dump_exit_bits = (DUMP_BIT(yydebug) | DUMP_BIT(syntax) |
-		      DUMP_BIT(parsetree) | DUMP_BIT(parsetree_with_comment) |
-		      DUMP_BIT(insns) | DUMP_BIT(insns_without_opt))
+                      DUMP_BIT(parsetree) | DUMP_BIT(parsetree_with_comment) |
+                      DUMP_BIT(insns) | DUMP_BIT(insns_without_opt))
 };
 
 static inline void
@@ -179,18 +179,18 @@ static void init_ids(ruby_cmdline_options_t *);
 
 enum {
     COMPILATION_FEATURES = (
-	0
-	| FEATURE_BIT(frozen_string_literal)
-	| FEATURE_BIT(debug_frozen_string_literal)
-	),
+        0
+        | FEATURE_BIT(frozen_string_literal)
+        | FEATURE_BIT(debug_frozen_string_literal)
+        ),
     DEFAULT_FEATURES = (
-	(FEATURE_BIT(debug_flag_first)-1)
+        (FEATURE_BIT(debug_flag_first)-1)
 #if DISABLE_RUBYGEMS
-	& ~FEATURE_BIT(gems)
+        & ~FEATURE_BIT(gems)
 #endif
-	& ~FEATURE_BIT(frozen_string_literal)
+        & ~FEATURE_BIT(frozen_string_literal)
         & ~feature_jit_mask
-	)
+        )
 };
 
 static ruby_cmdline_options_t *
@@ -212,7 +212,7 @@ cmdline_options_init(ruby_cmdline_options_t *opt)
 }
 
 static rb_ast_t *load_file(VALUE parser, VALUE fname, VALUE f, int script,
-		       ruby_cmdline_options_t *opt);
+                       ruby_cmdline_options_t *opt);
 static VALUE open_load_file(VALUE fname_v, int *xflag);
 static void forbid_setid(const char *, const ruby_cmdline_options_t *);
 #define forbid_setid(s) forbid_setid((s), opt)
@@ -234,10 +234,10 @@ show_usage_line(const char *str, unsigned int namelen, unsigned int secondlen, i
     const char *se = highlight ? esc_reset : esc_none;
     const int wrap = help && namelen + secondlen - 1 > w;
     printf("  %s%.*s%-*.*s%s%-*s%s\n", sb, namelen-1, str,
-	   (wrap ? 0 : w - namelen + 1),
-	   (help ? secondlen-1 : 0), str + namelen, se,
-	   (wrap ? w + 3 : 0), (wrap ? "\n" : ""),
-	   str + namelen + secondlen);
+           (wrap ? 0 : w - namelen + 1),
+           (help ? secondlen-1 : 0), str + namelen, se,
+           (wrap ? w + 3 : 0), (wrap ? "\n" : ""),
+           str + namelen + secondlen);
 }
 
 static void
@@ -254,26 +254,26 @@ usage(const char *name, int help, int highlight, int columns)
 # define PLATFORM_JIT_OPTION "--mjit"
 #endif
     static const struct ruby_opt_message usage_msg[] = {
-	M("-0[octal]",	   "",			   "specify record separator (\\0, if no argument)"),
-	M("-a",		   "",			   "autosplit mode with -n or -p (splits $_ into $F)"),
-	M("-c",		   "",			   "check syntax only"),
-	M("-Cdirectory",   "",			   "cd to directory before executing your script"),
-	M("-d",		   ", --debug",		   "set debugging flags (set $DEBUG to true)"),
-	M("-e 'command'",  "",			   "one line of script. Several -e's allowed. Omit [programfile]"),
-	M("-Eex[:in]",     ", --encoding=ex[:in]", "specify the default external and internal character encodings"),
-	M("-Fpattern",	   "",			   "split() pattern for autosplit (-a)"),
-	M("-i[extension]", "",			   "edit ARGV files in place (make backup if extension supplied)"),
-	M("-Idirectory",   "",			   "specify $LOAD_PATH directory (may be used more than once)"),
-	M("-l",		   "",			   "enable line ending processing"),
-	M("-n",		   "",			   "assume 'while gets(); ... end' loop around your script"),
-	M("-p",		   "",			   "assume loop like -n but print line also like sed"),
-	M("-rlibrary",	   "",			   "require the library before executing your script"),
-	M("-s",		   "",			   "enable some switch parsing for switches after script name"),
-	M("-S",		   "",			   "look for the script using PATH environment variable"),
-	M("-v",		   "",			   "print the version number, then turn on verbose mode"),
-	M("-w",		   "",			   "turn warnings on for your script"),
-	M("-W[level=2|:category]",   "",	   "set warning level; 0=silence, 1=medium, 2=verbose"),
-	M("-x[directory]", "",			   "strip off text before #!ruby line and perhaps cd to directory"),
+        M("-0[octal]",	   "",			   "specify record separator (\\0, if no argument)"),
+        M("-a",		   "",			   "autosplit mode with -n or -p (splits $_ into $F)"),
+        M("-c",		   "",			   "check syntax only"),
+        M("-Cdirectory",   "",			   "cd to directory before executing your script"),
+        M("-d",		   ", --debug",		   "set debugging flags (set $DEBUG to true)"),
+        M("-e 'command'",  "",			   "one line of script. Several -e's allowed. Omit [programfile]"),
+        M("-Eex[:in]",     ", --encoding=ex[:in]", "specify the default external and internal character encodings"),
+        M("-Fpattern",	   "",			   "split() pattern for autosplit (-a)"),
+        M("-i[extension]", "",			   "edit ARGV files in place (make backup if extension supplied)"),
+        M("-Idirectory",   "",			   "specify $LOAD_PATH directory (may be used more than once)"),
+        M("-l",		   "",			   "enable line ending processing"),
+        M("-n",		   "",			   "assume 'while gets(); ... end' loop around your script"),
+        M("-p",		   "",			   "assume loop like -n but print line also like sed"),
+        M("-rlibrary",	   "",			   "require the library before executing your script"),
+        M("-s",		   "",			   "enable some switch parsing for switches after script name"),
+        M("-S",		   "",			   "look for the script using PATH environment variable"),
+        M("-v",		   "",			   "print the version number, then turn on verbose mode"),
+        M("-w",		   "",			   "turn warnings on for your script"),
+        M("-W[level=2|:category]",   "",	   "set warning level; 0=silence, 1=medium, 2=verbose"),
+        M("-x[directory]", "",			   "strip off text before #!ruby line and perhaps cd to directory"),
         M("--jit",         "",                     "enable JIT for the platform, same as " PLATFORM_JIT_OPTION " (experimental)"),
 #if USE_MJIT
         M("--mjit",        "",                     "enable C compiler-based JIT compiler (experimental)"),
@@ -281,34 +281,34 @@ usage(const char *name, int help, int highlight, int columns)
 #if YJIT_BUILD
         M("--yjit",        "",                     "enable in-process JIT compiler (experimental)"),
 #endif
-	M("-h",		   "",			   "show this message, --help for more info"),
+        M("-h",		   "",			   "show this message, --help for more info"),
     };
     static const struct ruby_opt_message help_msg[] = {
-	M("--copyright",                            "", "print the copyright"),
-	M("--dump={insns|parsetree|...}[,...]",     "",
+        M("--copyright",                            "", "print the copyright"),
+        M("--dump={insns|parsetree|...}[,...]",     "",
           "dump debug information. see below for available dump list"),
-	M("--enable={jit|rubyopt|...}[,...]", ", --disable={jit|rubyopt|...}[,...]",
-	  "enable or disable features. see below for available features"),
-	M("--external-encoding=encoding",           ", --internal-encoding=encoding",
-	  "specify the default external or internal character encoding"),
-	M("--backtrace-limit=num",                  "", "limit the maximum length of backtrace"),
-	M("--verbose",                              "", "turn on verbose mode and disable script from stdin"),
-	M("--version",                              "", "print the version number, then exit"),
-	M("--help",			            "", "show this message, -h for short message"),
+        M("--enable={jit|rubyopt|...}[,...]", ", --disable={jit|rubyopt|...}[,...]",
+          "enable or disable features. see below for available features"),
+        M("--external-encoding=encoding",           ", --internal-encoding=encoding",
+          "specify the default external or internal character encoding"),
+        M("--backtrace-limit=num",                  "", "limit the maximum length of backtrace"),
+        M("--verbose",                              "", "turn on verbose mode and disable script from stdin"),
+        M("--version",                              "", "print the version number, then exit"),
+        M("--help",			            "", "show this message, -h for short message"),
     };
     static const struct ruby_opt_message dumps[] = {
-	M("insns",                  "", "instruction sequences"),
-	M("insns_without_opt",      "", "instruction sequences compiled with no optimization"),
-	M("yydebug",                "", "yydebug of yacc parser generator"),
-	M("parsetree",              "", "AST"),
-	M("parsetree_with_comment", "", "AST with comments"),
+        M("insns",                  "", "instruction sequences"),
+        M("insns_without_opt",      "", "instruction sequences compiled with no optimization"),
+        M("yydebug",                "", "yydebug of yacc parser generator"),
+        M("parsetree",              "", "AST"),
+        M("parsetree_with_comment", "", "AST with comments"),
     };
     static const struct ruby_opt_message features[] = {
-	M("gems",    "",        "rubygems (only for debugging, default: "DEFAULT_RUBYGEMS_ENABLED")"),
-	M("error_highlight", "", "error_highlight (default: "DEFAULT_RUBYGEMS_ENABLED")"),
-	M("did_you_mean", "",   "did_you_mean (default: "DEFAULT_RUBYGEMS_ENABLED")"),
-	M("rubyopt", "",        "RUBYOPT environment variable (default: enabled)"),
-	M("frozen-string-literal", "", "freeze all string literals (default: disabled)"),
+        M("gems",    "",        "rubygems (only for debugging, default: "DEFAULT_RUBYGEMS_ENABLED")"),
+        M("error_highlight", "", "error_highlight (default: "DEFAULT_RUBYGEMS_ENABLED")"),
+        M("did_you_mean", "",   "did_you_mean (default: "DEFAULT_RUBYGEMS_ENABLED")"),
+        M("rubyopt", "",        "RUBYOPT environment variable (default: enabled)"),
+        M("frozen-string-literal", "", "freeze all string literals (default: disabled)"),
 #if USE_MJIT
         M("mjit", "",           "C compiler-based JIT compiler (default: disabled)"),
 #endif
@@ -343,27 +343,27 @@ usage(const char *name, int help, int highlight, int columns)
 
     printf("%sUsage:%s %s [switches] [--] [programfile] [arguments]\n", sb, se, name);
     for (i = 0; i < num; ++i)
-	SHOW(usage_msg[i]);
+        SHOW(usage_msg[i]);
 
     if (!help) return;
 
     if (highlight) sb = esc_standout;
 
     for (i = 0; i < numberof(help_msg); ++i)
-	SHOW(help_msg[i]);
+        SHOW(help_msg[i]);
     printf("%s""Dump List:%s\n", sb, se);
     for (i = 0; i < numberof(dumps); ++i)
-	SHOW(dumps[i]);
+        SHOW(dumps[i]);
     printf("%s""Features:%s\n", sb, se);
     for (i = 0; i < numberof(features); ++i)
-	SHOW(features[i]);
+        SHOW(features[i]);
     printf("%s""Warning categories:%s\n", sb, se);
     for (i = 0; i < numberof(warn_categories); ++i)
-	SHOW(warn_categories[i]);
+        SHOW(warn_categories[i]);
 #if USE_MJIT
     printf("%s""MJIT options (experimental):%s\n", sb, se);
     for (i = 0; mjit_option_messages[i].str; ++i)
-	SHOW(mjit_option_messages[i]);
+        SHOW(mjit_option_messages[i]);
 #endif
 #if YJIT_BUILD
     printf("%s""YJIT options (experimental):%s\n", sb, se);
@@ -383,12 +383,12 @@ push_include(const char *path, VALUE (*filter)(VALUE))
 
     p = path;
     while (*p) {
-	while (*p == sep)
-	    p++;
-	if (!*p) break;
-	for (s = p; *s && *s != sep; s = CharNext(s));
-	rb_ary_push(load_path, (*filter)(rubylib_path_new(p, s - p)));
-	p = s;
+        while (*p == sep)
+            p++;
+        if (!*p) break;
+        for (s = p; *s && *s != sep; s = CharNext(s));
+        rb_ary_push(load_path, (*filter)(rubylib_path_new(p, s - p)));
+        p = s;
     }
 }
 
@@ -402,33 +402,33 @@ push_include_cygwin(const char *path, VALUE (*filter)(VALUE))
 
     p = path;
     while (*p) {
-	unsigned int len;
-	while (*p == ';')
-	    p++;
-	if (!*p) break;
-	for (s = p; *s && *s != ';'; s = CharNext(s));
-	len = s - p;
-	if (*s) {
-	    if (!buf) {
-		buf = rb_str_new(p, len);
-		p = RSTRING_PTR(buf);
-	    }
-	    else {
-		rb_str_resize(buf, len);
-		p = strncpy(RSTRING_PTR(buf), p, len);
-	    }
-	}
+        unsigned int len;
+        while (*p == ';')
+            p++;
+        if (!*p) break;
+        for (s = p; *s && *s != ';'; s = CharNext(s));
+        len = s - p;
+        if (*s) {
+            if (!buf) {
+                buf = rb_str_new(p, len);
+                p = RSTRING_PTR(buf);
+            }
+            else {
+                rb_str_resize(buf, len);
+                p = strncpy(RSTRING_PTR(buf), p, len);
+            }
+        }
 #ifdef HAVE_CYGWIN_CONV_PATH
 #define CONV_TO_POSIX_PATH(p, lib) \
-	cygwin_conv_path(CCP_WIN_A_TO_POSIX|CCP_RELATIVE, (p), (lib), sizeof(lib))
+        cygwin_conv_path(CCP_WIN_A_TO_POSIX|CCP_RELATIVE, (p), (lib), sizeof(lib))
 #else
 # error no cygwin_conv_path
 #endif
-	if (CONV_TO_POSIX_PATH(p, rubylib) == 0)
-	    p = rubylib;
-	push_include(p, filter);
-	if (!*s) break;
-	p = s + 1;
+        if (CONV_TO_POSIX_PATH(p, rubylib) == 0)
+            p = rubylib;
+        push_include(p, filter);
+        if (!*s) break;
+        p = s + 1;
     }
 }
 
@@ -439,7 +439,7 @@ void
 ruby_push_include(const char *path, VALUE (*filter)(VALUE))
 {
     if (path == 0)
-	return;
+        return;
     push_include(path, filter);
 }
 
@@ -466,9 +466,9 @@ expand_include_path(VALUE path)
 {
     char *p = RSTRING_PTR(path);
     if (!p)
-	return path;
+        return path;
     if (*p == '.' && p[1] == '/')
-	return path;
+        return path;
     return rb_file_expand_path(path, Qnil);
 }
 
@@ -486,7 +486,7 @@ BOOL WINAPI
 DllMain(HINSTANCE dll, DWORD reason, LPVOID reserved)
 {
     if (reason == DLL_PROCESS_ATTACH)
-	libruby = dll;
+        libruby = dll;
     return TRUE;
 }
 
@@ -500,9 +500,9 @@ static inline void
 translit_char_bin(char *p, int from, int to)
 {
     while (*p) {
-	if ((unsigned char)*p == from)
-	    *p = to;
-	p++;
+        if ((unsigned char)*p == from)
+            *p = to;
+        p++;
     }
 }
 #endif
@@ -525,8 +525,8 @@ static VALUE
 str_conv_enc(VALUE str, rb_encoding *from, rb_encoding *to)
 {
     return rb_str_conv_enc_opts(str, from, to,
-				ECONV_UNDEF_REPLACE|ECONV_INVALID_REPLACE,
-				Qnil);
+                                ECONV_UNDEF_REPLACE|ECONV_INVALID_REPLACE,
+                                Qnil);
 }
 #else
 # define str_conv_enc(str, from, to) (str)
@@ -551,33 +551,33 @@ runtime_libruby_path(void)
     char *libpath;
 
     while (wlibpath = (WCHAR *)RSTRING_PTR(wsopath),
-	   ret = GetModuleFileNameW(libruby, wlibpath, len),
-	   (ret == len))
+           ret = GetModuleFileNameW(libruby, wlibpath, len),
+           (ret == len))
     {
-	rb_str_modify_expand(wsopath, len*sizeof(WCHAR));
-	rb_str_set_len(wsopath, (len += len)*sizeof(WCHAR));
+        rb_str_modify_expand(wsopath, len*sizeof(WCHAR));
+        rb_str_set_len(wsopath, (len += len)*sizeof(WCHAR));
     }
     if (!ret || ret > len) rb_fatal("failed to get module file name");
 #if defined __CYGWIN__
     {
-	const int win_to_posix = CCP_WIN_W_TO_POSIX | CCP_RELATIVE;
-	size_t newsize = cygwin_conv_path(win_to_posix, wlibpath, 0, 0);
-	if (!newsize) rb_fatal("failed to convert module path to cygwin");
-	path = rb_str_new(0, newsize);
-	libpath = RSTRING_PTR(path);
-	if (cygwin_conv_path(win_to_posix, wlibpath, libpath, newsize)) {
-	    rb_str_resize(path, 0);
-	}
+        const int win_to_posix = CCP_WIN_W_TO_POSIX | CCP_RELATIVE;
+        size_t newsize = cygwin_conv_path(win_to_posix, wlibpath, 0, 0);
+        if (!newsize) rb_fatal("failed to convert module path to cygwin");
+        path = rb_str_new(0, newsize);
+        libpath = RSTRING_PTR(path);
+        if (cygwin_conv_path(win_to_posix, wlibpath, libpath, newsize)) {
+            rb_str_resize(path, 0);
+        }
     }
 #else
     {
-	DWORD i;
-	for (len = ret, i = 0; i < len; ++i) {
-	    if (wlibpath[i] == L'\\') {
-		wlibpath[i] = L'/';
-		ret = i+1;	/* chop after the last separator */
-	    }
-	}
+        DWORD i;
+        for (len = ret, i = 0; i < len; ++i) {
+            if (wlibpath[i] == L'\\') {
+                wlibpath[i] = L'/';
+                ret = i+1;	/* chop after the last separator */
+            }
+        }
     }
     len = WideCharToMultiByte(CP_UTF8, 0, wlibpath, ret, NULL, 0, NULL, NULL);
     path = rb_utf8_str_new(0, len);
@@ -592,17 +592,17 @@ runtime_libruby_path(void)
     const void* addr = (void *)(VALUE)expand_include_path;
 
     if (!dladdr((void *)addr, &dli)) {
-	return rb_str_new(0, 0);
+        return rb_str_new(0, 0);
     }
 #ifdef __linux__
     else if (origarg.argc > 0 && origarg.argv && dli.dli_fname == origarg.argv[0]) {
-	fname = rb_str_new_cstr("/proc/self/exe");
-	path = rb_readlink(fname, NULL);
+        fname = rb_str_new_cstr("/proc/self/exe");
+        path = rb_readlink(fname, NULL);
     }
 #endif
     else {
-	fname = rb_str_new_cstr(dli.dli_fname);
-	path = rb_realpath_internal(Qnil, fname, 1);
+        fname = rb_str_new_cstr(dli.dli_fname);
+        path = rb_realpath_internal(Qnil, fname, 1);
     }
     rb_str_resize(fname, 0);
     return path;
@@ -640,44 +640,44 @@ ruby_init_loadpath(void)
 
     p = strrchr(libpath, '/');
     if (p) {
-	static const char libdir[] = "/"
+        static const char libdir[] = "/"
 #ifdef LIBDIR_BASENAME
-	    LIBDIR_BASENAME
+            LIBDIR_BASENAME
 #else
-	    "lib"
+            "lib"
 #endif
-	    RUBY_ARCH_PATH;
-	const ptrdiff_t libdir_len = (ptrdiff_t)sizeof(libdir)
-	    - rb_strlen_lit(RUBY_ARCH_PATH) - 1;
-	static const char bindir[] = "/bin";
-	const ptrdiff_t bindir_len = (ptrdiff_t)sizeof(bindir) - 1;
+            RUBY_ARCH_PATH;
+        const ptrdiff_t libdir_len = (ptrdiff_t)sizeof(libdir)
+            - rb_strlen_lit(RUBY_ARCH_PATH) - 1;
+        static const char bindir[] = "/bin";
+        const ptrdiff_t bindir_len = (ptrdiff_t)sizeof(bindir) - 1;
 
-	const char *p2 = NULL;
+        const char *p2 = NULL;
 
 #ifdef ENABLE_MULTIARCH
       multiarch:
 #endif
-	if (p - libpath >= bindir_len && !STRNCASECMP(p - bindir_len, bindir, bindir_len)) {
-	    p -= bindir_len;
-	    archlibdir = rb_str_subseq(sopath, 0, p - libpath);
-	    rb_str_cat_cstr(archlibdir, libdir);
-	    OBJ_FREEZE_RAW(archlibdir);
-	}
-	else if (p - libpath >= libdir_len && !strncmp(p - libdir_len, libdir, libdir_len)) {
-	    archlibdir = rb_str_subseq(sopath, 0, (p2 ? p2 : p) - libpath);
-	    OBJ_FREEZE_RAW(archlibdir);
-	    p -= libdir_len;
-	}
+        if (p - libpath >= bindir_len && !STRNCASECMP(p - bindir_len, bindir, bindir_len)) {
+            p -= bindir_len;
+            archlibdir = rb_str_subseq(sopath, 0, p - libpath);
+            rb_str_cat_cstr(archlibdir, libdir);
+            OBJ_FREEZE_RAW(archlibdir);
+        }
+        else if (p - libpath >= libdir_len && !strncmp(p - libdir_len, libdir, libdir_len)) {
+            archlibdir = rb_str_subseq(sopath, 0, (p2 ? p2 : p) - libpath);
+            OBJ_FREEZE_RAW(archlibdir);
+            p -= libdir_len;
+        }
 #ifdef ENABLE_MULTIARCH
-	else if (p2) {
-	    p = p2;
-	}
-	else {
-	    p2 = p;
-	    p = rb_enc_path_last_separator(libpath, p, rb_ascii8bit_encoding());
-	    if (p) goto multiarch;
-	    p = p2;
-	}
+        else if (p2) {
+            p = p2;
+        }
+        else {
+            p2 = p;
+            p = rb_enc_path_last_separator(libpath, p, rb_ascii8bit_encoding());
+            if (p) goto multiarch;
+            p = p2;
+        }
 #endif
         baselen = p - libpath;
     }
@@ -707,11 +707,11 @@ ruby_init_loadpath(void)
 
     id_initial_load_path_mark = INITIAL_LOAD_PATH_MARK;
     while (*paths) {
-	size_t len = strlen(paths);
-	VALUE path = RUBY_RELATIVE(paths, len);
-	rb_ivar_set(path, id_initial_load_path_mark, path);
-	rb_ary_push(load_path, path);
-	paths += len + 1;
+        size_t len = strlen(paths);
+        VALUE path = RUBY_RELATIVE(paths, len);
+        rb_ivar_set(path, id_initial_load_path_mark, path);
+        rb_ary_push(load_path, path);
+        paths += len + 1;
     }
 
     rb_const_set(rb_cObject, rb_intern_const("TMP_RUBY_PREFIX"), ruby_prefix_path);
@@ -725,7 +725,7 @@ add_modules(VALUE *req_list, const char *mod)
     VALUE feature;
 
     if (!list) {
-	*req_list = list = rb_ary_tmp_new(0);
+        *req_list = list = rb_ary_tmp_new(0);
     }
     feature = rb_str_cat_cstr(rb_str_tmp_new(0), mod);
     rb_ary_push(list, feature);
@@ -741,11 +741,11 @@ require_libraries(VALUE *req_list)
 
     CONST_ID(require, "require");
     while (list && RARRAY_LEN(list) > 0) {
-	VALUE feature = rb_ary_shift(list);
-	rb_enc_associate(feature, extenc);
-	RBASIC_SET_CLASS_RAW(feature, rb_cString);
-	OBJ_FREEZE(feature);
-	rb_funcallv(self, require, 1, &feature);
+        VALUE feature = rb_ary_shift(list);
+        rb_enc_associate(feature, extenc);
+        RBASIC_SET_CLASS_RAW(feature, rb_cString);
+        OBJ_FREEZE(feature);
+        rb_funcallv(self, require, 1, &feature);
     }
     *req_list = 0;
 }
@@ -760,63 +760,63 @@ static void
 process_sflag(int *sflag)
 {
     if (*sflag > 0) {
-	long n;
-	const VALUE *args;
-	VALUE argv = rb_argv;
-
-	n = RARRAY_LEN(argv);
-	args = RARRAY_CONST_PTR(argv);
-	while (n > 0) {
-	    VALUE v = *args++;
-	    char *s = StringValuePtr(v);
-	    char *p;
-	    int hyphen = FALSE;
-
-	    if (s[0] != '-')
-		break;
-	    n--;
-	    if (s[1] == '-' && s[2] == '\0')
-		break;
-
-	    v = Qtrue;
-	    /* check if valid name before replacing - with _ */
-	    for (p = s + 1; *p; p++) {
-		if (*p == '=') {
-		    *p++ = '\0';
-		    v = rb_str_new2(p);
-		    break;
-		}
-		if (*p == '-') {
-		    hyphen = TRUE;
-		}
-		else if (*p != '_' && !ISALNUM(*p)) {
-		    VALUE name_error[2];
-		    name_error[0] =
-			rb_str_new2("invalid name for global variable - ");
-		    if (!(p = strchr(p, '='))) {
-			rb_str_cat2(name_error[0], s);
-		    }
-		    else {
-			rb_str_cat(name_error[0], s, p - s);
-		    }
-		    name_error[1] = args[-1];
-		    rb_exc_raise(rb_class_new_instance(2, name_error, rb_eNameError));
-		}
-	    }
-	    s[0] = '$';
-	    if (hyphen) {
-		for (p = s + 1; *p; ++p) {
-		    if (*p == '-')
-			*p = '_';
-		}
-	    }
-	    rb_gv_set(s, v);
-	}
-	n = RARRAY_LEN(argv) - n;
-	while (n--) {
-	    rb_ary_shift(argv);
-	}
-	*sflag = -1;
+        long n;
+        const VALUE *args;
+        VALUE argv = rb_argv;
+
+        n = RARRAY_LEN(argv);
+        args = RARRAY_CONST_PTR(argv);
+        while (n > 0) {
+            VALUE v = *args++;
+            char *s = StringValuePtr(v);
+            char *p;
+            int hyphen = FALSE;
+
+            if (s[0] != '-')
+                break;
+            n--;
+            if (s[1] == '-' && s[2] == '\0')
+                break;
+
+            v = Qtrue;
+            /* check if valid name before replacing - with _ */
+            for (p = s + 1; *p; p++) {
+                if (*p == '=') {
+                    *p++ = '\0';
+                    v = rb_str_new2(p);
+                    break;
+                }
+                if (*p == '-') {
+                    hyphen = TRUE;
+                }
+                else if (*p != '_' && !ISALNUM(*p)) {
+                    VALUE name_error[2];
+                    name_error[0] =
+                        rb_str_new2("invalid name for global variable - ");
+                    if (!(p = strchr(p, '='))) {
+                        rb_str_cat2(name_error[0], s);
+                    }
+                    else {
+                        rb_str_cat(name_error[0], s, p - s);
+                    }
+                    name_error[1] = args[-1];
+                    rb_exc_raise(rb_class_new_instance(2, name_error, rb_eNameError));
+                }
+            }
+            s[0] = '$';
+            if (hyphen) {
+                for (p = s + 1; *p; ++p) {
+                    if (*p == '-')
+                        *p = '_';
+                }
+            }
+            rb_gv_set(s, v);
+        }
+        n = RARRAY_LEN(argv) - n;
+        while (n--) {
+            rb_ary_shift(argv);
+        }
+        *sflag = -1;
     }
 }
 
@@ -842,12 +842,12 @@ moreswitches(const char *s, ruby_cmdline_options_t *opt, int envopt)
     ap = 0;
     rb_str_cat(argary, (char *)&ap, sizeof(ap));
     while (*p) {
-	ap = p;
-	rb_str_cat(argary, (char *)&ap, sizeof(ap));
-	while (*p && !ISSPACE(*p)) ++p;
-	if (!*p) break;
-	*p++ = '\0';
-	while (ISSPACE(*p)) ++p;
+        ap = p;
+        rb_str_cat(argary, (char *)&ap, sizeof(ap));
+        while (*p && !ISSPACE(*p)) ++p;
+        if (!*p) break;
+        *p++ = '\0';
+        while (ISSPACE(*p)) ++p;
     }
     argc = RSTRING_LEN(argary) / sizeof(ap);
     ap = 0;
@@ -856,14 +856,14 @@ moreswitches(const char *s, ruby_cmdline_options_t *opt, int envopt)
     MEMMOVE(argv, RSTRING_PTR(argary), char *, argc);
 
     while ((i = proc_options(argc, argv, opt, envopt)) > 1 && envopt && (argc -= i) > 0) {
-	argv += i;
-	if (**argv != '-') {
-	    *--*argv = '-';
-	}
-	if ((*argv)[1]) {
-	    ++argc;
-	    --argv;
-	}
+        argv += i;
+        if (**argv != '-') {
+            *--*argv = '-';
+        }
+        if ((*argv)[1]) {
+            ++argc;
+            --argv;
+        }
     }
 
     ruby_xfree(ptr);
@@ -877,15 +877,15 @@ name_match_p(const char *name, const char *str, size_t len)
 {
     if (len == 0) return 0;
     while (1) {
-	while (TOLOWER(*str) == *name) {
-	    if (!--len || !*++str) return 1;
-	    ++name;
-	}
-	if (*str != '-' && *str != '_') return 0;
-	while (ISALNUM(*name)) name++;
-	if (*name != '-' && *name != '_') return 0;
-	++name;
-	++str;
+        while (TOLOWER(*str) == *name) {
+            if (!--len || !*++str) return 1;
+            ++name;
+        }
+        if (*str != '-' && *str != '_') return 0;
+        while (ISALNUM(*name)) name++;
+        if (*name != '-' && *name != '_') return 0;
+        ++name;
+        ++str;
     }
 }
 
@@ -894,14 +894,14 @@ name_match_p(const char *name, const char *str, size_t len)
 
 #define UNSET_WHEN(name, bit, str, len)	\
     if (NAME_MATCH_P((name), (str), (len))) { \
-	*(unsigned int *)arg &= ~(bit); \
-	return;				\
+        *(unsigned int *)arg &= ~(bit); \
+        return;				\
     }
 
 #define SET_WHEN(name, bit, str, len)	\
     if (NAME_MATCH_P((name), (str), (len))) { \
-	*(unsigned int *)arg |= (bit);	\
-	return;				\
+        *(unsigned int *)arg |= (bit);	\
+        return;				\
     }
 
 #define LITERAL_NAME_ELEMENT(name) #name
@@ -934,22 +934,22 @@ feature_option(const char *str, int len, void *arg, const unsigned int enable)
 #if AMBIGUOUS_FEATURE_NAMES
     if (matched == 1) goto found;
     if (matched > 1) {
-	VALUE mesg = rb_sprintf("ambiguous feature: `%.*s' (", len, str);
+        VALUE mesg = rb_sprintf("ambiguous feature: `%.*s' (", len, str);
 #define ADD_FEATURE_NAME(bit) \
-	if (FEATURE_BIT(bit) & set) { \
-	    rb_str_cat_cstr(mesg, #bit); \
-	    if (--matched) rb_str_cat_cstr(mesg, ", "); \
-	}
-	EACH_FEATURES(ADD_FEATURE_NAME, ;);
-	rb_str_cat_cstr(mesg, ")");
-	rb_exc_raise(rb_exc_new_str(rb_eRuntimeError, mesg));
+        if (FEATURE_BIT(bit) & set) { \
+            rb_str_cat_cstr(mesg, #bit); \
+            if (--matched) rb_str_cat_cstr(mesg, ", "); \
+        }
+        EACH_FEATURES(ADD_FEATURE_NAME, ;);
+        rb_str_cat_cstr(mesg, ")");
+        rb_exc_raise(rb_exc_new_str(rb_eRuntimeError, mesg));
 #undef ADD_FEATURE_NAME
     }
 #else
     (void)set;
 #endif
     rb_warn("unknown argument for --%s: `%.*s'",
-	    enable ? "enable" : "disable", len, str);
+            enable ? "enable" : "disable", len, str);
     rb_warn("features are [%.*s].", (int)strlen(list), list);
     return;
 
@@ -1010,9 +1010,9 @@ set_option_encoding_once(const char *type, VALUE *name, const char *e, long elen
     ename = rb_str_new(e, elen);
 
     if (*name &&
-	rb_funcall(ename, rb_intern("casecmp"), 1, *name) != INT2FIX(0)) {
-	rb_raise(rb_eRuntimeError,
-		 "%s already set to %"PRIsVALUE, type, *name);
+        rb_funcall(ename, rb_intern("casecmp"), 1, *name) != INT2FIX(0)) {
+        rb_raise(rb_eRuntimeError,
+                 "%s already set to %"PRIsVALUE, type, *name);
     }
     *name = ename;
 }
@@ -1057,61 +1057,61 @@ proc_options(long argc, char **argv, ruby_cmdline_options_t *opt, int envopt)
     int warning = opt->warning;
 
     if (argc <= 0 || !argv)
-	return 0;
+        return 0;
 
     for (argc--, argv++; argc > 0; argc--, argv++) {
-	const char *const arg = argv[0];
-	if (!arg || arg[0] != '-' || !arg[1])
-	    break;
+        const char *const arg = argv[0];
+        if (!arg || arg[0] != '-' || !arg[1])
+            break;
 
-	s = arg + 1;
+        s = arg + 1;
       reswitch:
-	switch (*s) {
-	  case 'a':
-	    if (envopt) goto noenvopt;
-	    opt->do_split = TRUE;
-	    s++;
-	    goto reswitch;
-
-	  case 'p':
-	    if (envopt) goto noenvopt;
-	    opt->do_print = TRUE;
-	    /* through */
-	  case 'n':
-	    if (envopt) goto noenvopt;
-	    opt->do_loop = TRUE;
-	    s++;
-	    goto reswitch;
-
-	  case 'd':
-	    ruby_debug = Qtrue;
-	    ruby_verbose = Qtrue;
-	    s++;
-	    goto reswitch;
-
-	  case 'y':
-	    if (envopt) goto noenvopt;
-	    opt->dump |= DUMP_BIT(yydebug);
-	    s++;
-	    goto reswitch;
-
-	  case 'v':
-	    if (opt->verbose) {
-		s++;
-		goto reswitch;
-	    }
-	    opt->dump |= DUMP_BIT(version_v);
-	    opt->verbose = 1;
-	  case 'w':
-	    if (!opt->warning) {
-		warning = 1;
-		ruby_verbose = Qtrue;
-	    }
-	    FEATURE_SET(opt->warn, RB_WARN_CATEGORY_ALL_BITS);
-	    s++;
-	    goto reswitch;
-
-	  case 'W':
+        switch (*s) {
+          case 'a':
+            if (envopt) goto noenvopt;
+            opt->do_split = TRUE;
+            s++;
+            goto reswitch;
+
+          case 'p':
+            if (envopt) goto noenvopt;
+            opt->do_print = TRUE;
+            /* through */
+          case 'n':
+            if (envopt) goto noenvopt;
+            opt->do_loop = TRUE;
+            s++;
+            goto reswitch;
+
+          case 'd':
+            ruby_debug = Qtrue;
+            ruby_verbose = Qtrue;
+            s++;
+            goto reswitch;
+
+          case 'y':
+            if (envopt) goto noenvopt;
+            opt->dump |= DUMP_BIT(yydebug);
+            s++;
+            goto reswitch;
+
+          case 'v':
+            if (opt->verbose) {
+                s++;
+                goto reswitch;
+            }
+            opt->dump |= DUMP_BIT(version_v);
+            opt->verbose = 1;
+          case 'w':
+            if (!opt->warning) {
+                warning = 1;
+                ruby_verbose = Qtrue;
+            }
+            FEATURE_SET(opt->warn, RB_WARN_CATEGORY_ALL_BITS);
+            s++;
+            goto reswitch;
+
+          case 'W':
             if (s[1] == ':') {
                 unsigned int bits = 0;
                 static const char no_prefix[] = "no-";
@@ -1130,293 +1130,293 @@ proc_options(long argc, char **argv, ruby_cmdline_options_t *opt, int envopt)
                 if (bits) FEATURE_SET_TO(opt->warn, bits, enable ? bits : 0);
                 break;
             }
-	    {
-		size_t numlen;
-		int v = 2;	/* -W as -W2 */
+            {
+                size_t numlen;
+                int v = 2;	/* -W as -W2 */
 
-		if (*++s) {
-		    v = scan_oct(s, 1, &numlen);
-		    if (numlen == 0)
+                if (*++s) {
+                    v = scan_oct(s, 1, &numlen);
+                    if (numlen == 0)
                         v = 2;
-		    s += numlen;
-		}
-		if (!opt->warning) {
-		    switch (v) {
-		      case 0:
-			ruby_verbose = Qnil;
-			break;
-		      case 1:
-			ruby_verbose = Qfalse;
-			break;
-		      default:
-			ruby_verbose = Qtrue;
-			break;
-		    }
-		}
-		warning = 1;
-		switch (v) {
-		  case 0:
-		    FEATURE_SET_TO(opt->warn, RB_WARN_CATEGORY_ALL_BITS, 0);
-		    break;
-		  case 1:
-		    FEATURE_SET_TO(opt->warn, 1U << RB_WARN_CATEGORY_DEPRECATED, 0);
-		    break;
-		  default:
-		    FEATURE_SET(opt->warn, RB_WARN_CATEGORY_ALL_BITS);
-		    break;
-		}
-	    }
-	    goto reswitch;
-
-	  case 'c':
-	    if (envopt) goto noenvopt;
-	    opt->dump |= DUMP_BIT(syntax);
-	    s++;
-	    goto reswitch;
-
-	  case 's':
-	    if (envopt) goto noenvopt;
-	    forbid_setid("-s");
-	    if (!opt->sflag) opt->sflag = 1;
-	    s++;
-	    goto reswitch;
-
-	  case 'h':
-	    if (envopt) goto noenvopt;
-	    opt->dump |= DUMP_BIT(usage);
-	    goto switch_end;
-
-	  case 'l':
-	    if (envopt) goto noenvopt;
-	    opt->do_line = TRUE;
-	    rb_output_rs = rb_rs;
-	    s++;
-	    goto reswitch;
-
-	  case 'S':
-	    if (envopt) goto noenvopt;
-	    forbid_setid("-S");
-	    opt->do_search = TRUE;
-	    s++;
-	    goto reswitch;
-
-	  case 'e':
-	    if (envopt) goto noenvopt;
-	    forbid_setid("-e");
-	    if (!*++s) {
-		if (!--argc)
-		    rb_raise(rb_eRuntimeError, "no code specified for -e");
-		s = *++argv;
-	    }
-	    if (!opt->e_script) {
-		opt->e_script = rb_str_new(0, 0);
-		if (opt->script == 0)
-		    opt->script = "-e";
-	    }
-	    rb_str_cat2(opt->e_script, s);
-	    rb_str_cat2(opt->e_script, "\n");
-	    break;
-
-	  case 'r':
-	    forbid_setid("-r");
-	    if (*++s) {
-		add_modules(&opt->req_list, s);
-	    }
-	    else if (argc > 1) {
-		add_modules(&opt->req_list, argv[1]);
-		argc--, argv++;
-	    }
-	    break;
-
-	  case 'i':
-	    if (envopt) goto noenvopt;
-	    forbid_setid("-i");
-	    ruby_set_inplace_mode(s + 1);
-	    break;
-
-	  case 'x':
-	    if (envopt) goto noenvopt;
-	    forbid_setid("-x");
-	    opt->xflag = TRUE;
-	    s++;
-	    if (*s && chdir(s) < 0) {
-		rb_fatal("Can't chdir to %s", s);
-	    }
-	    break;
-
-	  case 'C':
-	  case 'X':
-	    if (envopt) goto noenvopt;
-	    if (!*++s && (!--argc || !(s = *++argv) || !*s)) {
-		rb_fatal("Can't chdir");
-	    }
-	    if (chdir(s) < 0) {
-		rb_fatal("Can't chdir to %s", s);
-	    }
-	    break;
-
-	  case 'F':
-	    if (envopt) goto noenvopt;
-	    if (*++s) {
-		rb_fs = rb_reg_new(s, strlen(s), 0);
-	    }
-	    break;
-
-	  case 'E':
-	    if (!*++s && (!--argc || !(s = *++argv))) {
-		rb_raise(rb_eRuntimeError, "missing argument for -E");
-	    }
-	    goto encoding;
-
-	  case 'U':
-	    set_internal_encoding_once(opt, "UTF-8", 0);
-	    ++s;
-	    goto reswitch;
-
-	  case 'K':
-	    if (*++s) {
-		const char *enc_name = 0;
-		switch (*s) {
-		  case 'E': case 'e':
-		    enc_name = "EUC-JP";
-		    break;
-		  case 'S': case 's':
-		    enc_name = "Windows-31J";
-		    break;
-		  case 'U': case 'u':
-		    enc_name = "UTF-8";
-		    break;
-		  case 'N': case 'n': case 'A': case 'a':
-		    enc_name = "ASCII-8BIT";
-		    break;
-		}
-		if (enc_name) {
-		    opt->src.enc.name = rb_str_new2(enc_name);
-		    if (!opt->ext.enc.name)
-			opt->ext.enc.name = opt->src.enc.name;
-		}
-		s++;
-	    }
-	    goto reswitch;
-
-	  case 'I':
-	    forbid_setid("-I");
-	    if (*++s)
-		ruby_incpush_expand(s);
-	    else if (argc > 1) {
-		ruby_incpush_expand(argv[1]);
-		argc--, argv++;
-	    }
-	    break;
-
-	  case '0':
-	    if (envopt) goto noenvopt;
-	    {
-		size_t numlen;
-		int v;
-		char c;
-
-		v = scan_oct(s, 4, &numlen);
-		s += numlen;
-		if (v > 0377)
-		    rb_rs = Qnil;
-		else if (v == 0 && numlen >= 2) {
-		    rb_rs = rb_str_new2("");
-		}
-		else {
-		    c = v & 0xff;
-		    rb_rs = rb_str_new(&c, 1);
-		}
-	    }
-	    goto reswitch;
-
-	  case '-':
-	    if (!s[1] || (s[1] == '\r' && !s[2])) {
-		argc--, argv++;
-		goto switch_end;
-	    }
-	    s++;
+                    s += numlen;
+                }
+                if (!opt->warning) {
+                    switch (v) {
+                      case 0:
+                        ruby_verbose = Qnil;
+                        break;
+                      case 1:
+                        ruby_verbose = Qfalse;
+                        break;
+                      default:
+                        ruby_verbose = Qtrue;
+                        break;
+                    }
+                }
+                warning = 1;
+                switch (v) {
+                  case 0:
+                    FEATURE_SET_TO(opt->warn, RB_WARN_CATEGORY_ALL_BITS, 0);
+                    break;
+                  case 1:
+                    FEATURE_SET_TO(opt->warn, 1U << RB_WARN_CATEGORY_DEPRECATED, 0);
+                    break;
+                  default:
+                    FEATURE_SET(opt->warn, RB_WARN_CATEGORY_ALL_BITS);
+                    break;
+                }
+            }
+            goto reswitch;
+
+          case 'c':
+            if (envopt) goto noenvopt;
+            opt->dump |= DUMP_BIT(syntax);
+            s++;
+            goto reswitch;
+
+          case 's':
+            if (envopt) goto noenvopt;
+            forbid_setid("-s");
+            if (!opt->sflag) opt->sflag = 1;
+            s++;
+            goto reswitch;
+
+          case 'h':
+            if (envopt) goto noenvopt;
+            opt->dump |= DUMP_BIT(usage);
+            goto switch_end;
+
+          case 'l':
+            if (envopt) goto noenvopt;
+            opt->do_line = TRUE;
+            rb_output_rs = rb_rs;
+            s++;
+            goto reswitch;
+
+          case 'S':
+            if (envopt) goto noenvopt;
+            forbid_setid("-S");
+            opt->do_search = TRUE;
+            s++;
+            goto reswitch;
+
+          case 'e':
+            if (envopt) goto noenvopt;
+            forbid_setid("-e");
+            if (!*++s) {
+                if (!--argc)
+                    rb_raise(rb_eRuntimeError, "no code specified for -e");
+                s = *++argv;
+            }
+            if (!opt->e_script) {
+                opt->e_script = rb_str_new(0, 0);
+                if (opt->script == 0)
+                    opt->script = "-e";
+            }
+            rb_str_cat2(opt->e_script, s);
+            rb_str_cat2(opt->e_script, "\n");
+            break;
+
+          case 'r':
+            forbid_setid("-r");
+            if (*++s) {
+                add_modules(&opt->req_list, s);
+            }
+            else if (argc > 1) {
+                add_modules(&opt->req_list, argv[1]);
+                argc--, argv++;
+            }
+            break;
+
+          case 'i':
+            if (envopt) goto noenvopt;
+            forbid_setid("-i");
+            ruby_set_inplace_mode(s + 1);
+            break;
+
+          case 'x':
+            if (envopt) goto noenvopt;
+            forbid_setid("-x");
+            opt->xflag = TRUE;
+            s++;
+            if (*s && chdir(s) < 0) {
+                rb_fatal("Can't chdir to %s", s);
+            }
+            break;
+
+          case 'C':
+          case 'X':
+            if (envopt) goto noenvopt;
+            if (!*++s && (!--argc || !(s = *++argv) || !*s)) {
+                rb_fatal("Can't chdir");
+            }
+            if (chdir(s) < 0) {
+                rb_fatal("Can't chdir to %s", s);
+            }
+            break;
+
+          case 'F':
+            if (envopt) goto noenvopt;
+            if (*++s) {
+                rb_fs = rb_reg_new(s, strlen(s), 0);
+            }
+            break;
+
+          case 'E':
+            if (!*++s && (!--argc || !(s = *++argv))) {
+                rb_raise(rb_eRuntimeError, "missing argument for -E");
+            }
+            goto encoding;
+
+          case 'U':
+            set_internal_encoding_once(opt, "UTF-8", 0);
+            ++s;
+            goto reswitch;
+
+          case 'K':
+            if (*++s) {
+                const char *enc_name = 0;
+                switch (*s) {
+                  case 'E': case 'e':
+                    enc_name = "EUC-JP";
+                    break;
+                  case 'S': case 's':
+                    enc_name = "Windows-31J";
+                    break;
+                  case 'U': case 'u':
+                    enc_name = "UTF-8";
+                    break;
+                  case 'N': case 'n': case 'A': case 'a':
+                    enc_name = "ASCII-8BIT";
+                    break;
+                }
+                if (enc_name) {
+                    opt->src.enc.name = rb_str_new2(enc_name);
+                    if (!opt->ext.enc.name)
+                        opt->ext.enc.name = opt->src.enc.name;
+                }
+                s++;
+            }
+            goto reswitch;
+
+          case 'I':
+            forbid_setid("-I");
+            if (*++s)
+                ruby_incpush_expand(s);
+            else if (argc > 1) {
+                ruby_incpush_expand(argv[1]);
+                argc--, argv++;
+            }
+            break;
+
+          case '0':
+            if (envopt) goto noenvopt;
+            {
+                size_t numlen;
+                int v;
+                char c;
+
+                v = scan_oct(s, 4, &numlen);
+                s += numlen;
+                if (v > 0377)
+                    rb_rs = Qnil;
+                else if (v == 0 && numlen >= 2) {
+                    rb_rs = rb_str_new2("");
+                }
+                else {
+                    c = v & 0xff;
+                    rb_rs = rb_str_new(&c, 1);
+                }
+            }
+            goto reswitch;
+
+          case '-':
+            if (!s[1] || (s[1] == '\r' && !s[2])) {
+                argc--, argv++;
+                goto switch_end;
+            }
+            s++;
 
 #	define is_option_end(c, allow_hyphen) \
-	    (!(c) || ((allow_hyphen) && (c) == '-') || (c) == '=')
+            (!(c) || ((allow_hyphen) && (c) == '-') || (c) == '=')
 #	define check_envopt(name, allow_envopt) \
-	    (((allow_envopt) || !envopt) ? (void)0 : \
-	     rb_raise(rb_eRuntimeError, "invalid switch in RUBYOPT: --" name))
+            (((allow_envopt) || !envopt) ? (void)0 : \
+             rb_raise(rb_eRuntimeError, "invalid switch in RUBYOPT: --" name))
 #	define need_argument(name, s, needs_arg, next_arg)			\
-	    ((*(s) ? !*++(s) : (next_arg) && (!argc || !((s) = argv[1]) || (--argc, ++argv, 0))) && (needs_arg) ? \
-	     rb_raise(rb_eRuntimeError, "missing argument for --" name) \
-	     : (void)0)
+            ((*(s) ? !*++(s) : (next_arg) && (!argc || !((s) = argv[1]) || (--argc, ++argv, 0))) && (needs_arg) ? \
+             rb_raise(rb_eRuntimeError, "missing argument for --" name) \
+             : (void)0)
 #	define is_option_with_arg(name, allow_hyphen, allow_envopt)	\
-	    is_option_with_optarg(name, allow_hyphen, allow_envopt, Qtrue, Qtrue)
+            is_option_with_optarg(name, allow_hyphen, allow_envopt, Qtrue, Qtrue)
 #	define is_option_with_optarg(name, allow_hyphen, allow_envopt, needs_arg, next_arg) \
-	    (strncmp((name), s, n = sizeof(name) - 1) == 0 && is_option_end(s[n], (allow_hyphen)) && \
+            (strncmp((name), s, n = sizeof(name) - 1) == 0 && is_option_end(s[n], (allow_hyphen)) && \
              (s[n] != '-' || s[n+1]) ? \
-	     (check_envopt(name, (allow_envopt)), s += n, \
-	      need_argument(name, s, needs_arg, next_arg), 1) : 0)
-
-	    if (strcmp("copyright", s) == 0) {
-		if (envopt) goto noenvopt_long;
-		opt->dump |= DUMP_BIT(copyright);
-	    }
-	    else if (is_option_with_optarg("debug", Qtrue, Qtrue, Qfalse, Qfalse)) {
-		if (s && *s) {
-		    ruby_each_words(s, debug_option, &opt->features);
-		}
-		else {
-		    ruby_debug = Qtrue;
-		    ruby_verbose = Qtrue;
-		}
+             (check_envopt(name, (allow_envopt)), s += n, \
+              need_argument(name, s, needs_arg, next_arg), 1) : 0)
+
+            if (strcmp("copyright", s) == 0) {
+                if (envopt) goto noenvopt_long;
+                opt->dump |= DUMP_BIT(copyright);
             }
-	    else if (is_option_with_arg("enable", Qtrue, Qtrue)) {
-		ruby_each_words(s, enable_option, &opt->features);
-	    }
-	    else if (is_option_with_arg("disable", Qtrue, Qtrue)) {
-		ruby_each_words(s, disable_option, &opt->features);
-	    }
-	    else if (is_option_with_arg("encoding", Qfalse, Qtrue)) {
-		char *p;
-	      encoding:
-		do {
+            else if (is_option_with_optarg("debug", Qtrue, Qtrue, Qfalse, Qfalse)) {
+                if (s && *s) {
+                    ruby_each_words(s, debug_option, &opt->features);
+                }
+                else {
+                    ruby_debug = Qtrue;
+                    ruby_verbose = Qtrue;
+                }
+            }
+            else if (is_option_with_arg("enable", Qtrue, Qtrue)) {
+                ruby_each_words(s, enable_option, &opt->features);
+            }
+            else if (is_option_with_arg("disable", Qtrue, Qtrue)) {
+                ruby_each_words(s, disable_option, &opt->features);
+            }
+            else if (is_option_with_arg("encoding", Qfalse, Qtrue)) {
+                char *p;
+              encoding:
+                do {
 #	define set_encoding_part(type) \
-		    if (!(p = strchr(s, ':'))) { \
-			set_##type##_encoding_once(opt, s, 0); \
-			break; \
-		    } \
-		    else if (p > s) { \
-			set_##type##_encoding_once(opt, s, p-s); \
-		    }
-		    set_encoding_part(external);
-		    if (!*(s = ++p)) break;
-		    set_encoding_part(internal);
-		    if (!*(s = ++p)) break;
+                    if (!(p = strchr(s, ':'))) { \
+                        set_##type##_encoding_once(opt, s, 0); \
+                        break; \
+                    } \
+                    else if (p > s) { \
+                        set_##type##_encoding_once(opt, s, p-s); \
+                    }
+                    set_encoding_part(external);
+                    if (!*(s = ++p)) break;
+                    set_encoding_part(internal);
+                    if (!*(s = ++p)) break;
 #if defined ALLOW_DEFAULT_SOURCE_ENCODING && ALLOW_DEFAULT_SOURCE_ENCODING
-		    set_encoding_part(source);
-		    if (!*(s = ++p)) break;
+                    set_encoding_part(source);
+                    if (!*(s = ++p)) break;
 #endif
-		    rb_raise(rb_eRuntimeError, "extra argument for %s: %s",
-			     (arg[1] == '-' ? "--encoding" : "-E"), s);
+                    rb_raise(rb_eRuntimeError, "extra argument for %s: %s",
+                             (arg[1] == '-' ? "--encoding" : "-E"), s);
 #	undef set_encoding_part
-		} while (0);
-	    }
-	    else if (is_option_with_arg("internal-encoding", Qfalse, Qtrue)) {
-		set_internal_encoding_once(opt, s, 0);
-	    }
-	    else if (is_option_with_arg("external-encoding", Qfalse, Qtrue)) {
-		set_external_encoding_once(opt, s, 0);
-	    }
+                } while (0);
+            }
+            else if (is_option_with_arg("internal-encoding", Qfalse, Qtrue)) {
+                set_internal_encoding_once(opt, s, 0);
+            }
+            else if (is_option_with_arg("external-encoding", Qfalse, Qtrue)) {
+                set_external_encoding_once(opt, s, 0);
+            }
 #if defined ALLOW_DEFAULT_SOURCE_ENCODING && ALLOW_DEFAULT_SOURCE_ENCODING
-	    else if (is_option_with_arg("source-encoding", Qfalse, Qtrue)) {
-		set_source_encoding_once(opt, s, 0);
-	    }
-#endif
-	    else if (strcmp("version", s) == 0) {
-		if (envopt) goto noenvopt_long;
-		opt->dump |= DUMP_BIT(version);
-	    }
-	    else if (strcmp("verbose", s) == 0) {
-		opt->verbose = 1;
-		ruby_verbose = Qtrue;
-	    }
+            else if (is_option_with_arg("source-encoding", Qfalse, Qtrue)) {
+                set_source_encoding_once(opt, s, 0);
+            }
+#endif
+            else if (strcmp("version", s) == 0) {
+                if (envopt) goto noenvopt_long;
+                opt->dump |= DUMP_BIT(version);
+            }
+            else if (strcmp("verbose", s) == 0) {
+                opt->verbose = 1;
+                ruby_verbose = Qtrue;
+            }
             else if (strcmp("jit", s) == 0) {
 #if !USE_MJIT
                 rb_warn("Ruby was built without JIT support");
@@ -1441,59 +1441,59 @@ proc_options(long argc, char **argv, ruby_cmdline_options_t *opt, int envopt)
                 rb_warn("Ruby was built without YJIT support");
 #endif
             }
-	    else if (strcmp("yydebug", s) == 0) {
-		if (envopt) goto noenvopt_long;
-		opt->dump |= DUMP_BIT(yydebug);
-	    }
-	    else if (is_option_with_arg("dump", Qfalse, Qfalse)) {
-		ruby_each_words(s, dump_option, &opt->dump);
-	    }
-	    else if (strcmp("help", s) == 0) {
-		if (envopt) goto noenvopt_long;
-		opt->dump |= DUMP_BIT(help);
-		goto switch_end;
-	    }
+            else if (strcmp("yydebug", s) == 0) {
+                if (envopt) goto noenvopt_long;
+                opt->dump |= DUMP_BIT(yydebug);
+            }
+            else if (is_option_with_arg("dump", Qfalse, Qfalse)) {
+                ruby_each_words(s, dump_option, &opt->dump);
+            }
+            else if (strcmp("help", s) == 0) {
+                if (envopt) goto noenvopt_long;
+                opt->dump |= DUMP_BIT(help);
+                goto switch_end;
+            }
             else if (is_option_with_arg("backtrace-limit", Qfalse, Qfalse)) {
                 char *e;
                 long n = strtol(s, &e, 10);
                 if (errno == ERANGE || n < 0 || *e) rb_raise(rb_eRuntimeError, "wrong limit for backtrace length");
                 rb_backtrace_length_limit = n;
             }
-	    else {
-		rb_raise(rb_eRuntimeError,
-			 "invalid option --%s  (-h will show valid options)", s);
-	    }
-	    break;
-
-	  case '\r':
-	    if (!s[1])
-		break;
-
-	  default:
-	    {
+            else {
                 rb_raise(rb_eRuntimeError,
-			"invalid option -%c  (-h will show valid options)",
+                         "invalid option --%s  (-h will show valid options)", s);
+            }
+            break;
+
+          case '\r':
+            if (!s[1])
+                break;
+
+          default:
+            {
+                rb_raise(rb_eRuntimeError,
+                        "invalid option -%c  (-h will show valid options)",
                         (int)(unsigned char)*s);
-	    }
-	    goto switch_end;
+            }
+            goto switch_end;
 
-	  noenvopt:
-	    /* "EIdvwWrKU" only */
-	    rb_raise(rb_eRuntimeError, "invalid switch in RUBYOPT: -%c", *s);
-	    break;
+          noenvopt:
+            /* "EIdvwWrKU" only */
+            rb_raise(rb_eRuntimeError, "invalid switch in RUBYOPT: -%c", *s);
+            break;
 
-	  noenvopt_long:
-	    rb_raise(rb_eRuntimeError, "invalid switch in RUBYOPT: --%s", s);
-	    break;
+          noenvopt_long:
+            rb_raise(rb_eRuntimeError, "invalid switch in RUBYOPT: --%s", s);
+            break;
 
-	  case 0:
-	    break;
+          case 0:
+            break;
 #	undef is_option_end
 #	undef check_envopt
 #	undef need_argument
 #	undef is_option_with_arg
 #	undef is_option_with_optarg
-	}
+        }
     }
 
   switch_end:
@@ -1554,10 +1554,10 @@ opt_enc_index(VALUE enc_name)
     int i = rb_enc_find_index(s);
 
     if (i < 0) {
-	rb_raise(rb_eRuntimeError, "unknown encoding name - %s", s);
+        rb_raise(rb_eRuntimeError, "unknown encoding name - %s", s);
     }
     else if (rb_enc_dummy_p(rb_enc_from_index(i))) {
-	rb_raise(rb_eRuntimeError, "dummy encoding is not acceptable - %s ", s);
+        rb_raise(rb_eRuntimeError, "dummy encoding is not acceptable - %s ", s);
     }
     return i;
 }
@@ -1589,8 +1589,8 @@ uscore_get(void)
 
     line = rb_lastline_get();
     if (!RB_TYPE_P(line, T_STRING)) {
-	rb_raise(rb_eTypeError, "$_ value need to be String (%s given)",
-		 NIL_P(line) ? "nil" : rb_obj_classname(line));
+        rb_raise(rb_eTypeError, "$_ value need to be String (%s given)",
+                 NIL_P(line) ? "nil" : rb_obj_classname(line));
     }
     return line;
 }
@@ -1725,10 +1725,10 @@ process_options(int argc, char **argv, ruby_cmdline_options_t *opt)
 
     if (opt->dump & (DUMP_BIT(usage)|DUMP_BIT(help))) {
         int tty = isatty(1);
-	const char *const progname =
-	    (argc > 0 && argv && argv[0] ? argv[0] :
-	     origarg.argc > 0 && origarg.argv && origarg.argv[0] ? origarg.argv[0] :
-	     ruby_engine);
+        const char *const progname =
+            (argc > 0 && argv && argv[0] ? argv[0] :
+             origarg.argc > 0 && origarg.argv && origarg.argv[0] ? origarg.argv[0] :
+             ruby_engine);
         int columns = 0;
         if ((opt->dump & DUMP_BIT(help)) && tty) {
             const char *pager_env = getenv("RUBY_PAGER");
@@ -1779,28 +1779,28 @@ process_options(int argc, char **argv, ruby_cmdline_options_t *opt)
 #endif
             }
         }
-	usage(progname, (opt->dump & DUMP_BIT(help)), tty, columns);
-	return Qtrue;
+        usage(progname, (opt->dump & DUMP_BIT(help)), tty, columns);
+        return Qtrue;
     }
 
     argc -= i;
     argv += i;
 
     if (FEATURE_SET_P(opt->features, rubyopt) && (s = getenv("RUBYOPT"))) {
-	VALUE src_enc_name = opt->src.enc.name;
-	VALUE ext_enc_name = opt->ext.enc.name;
-	VALUE int_enc_name = opt->intern.enc.name;
+        VALUE src_enc_name = opt->src.enc.name;
+        VALUE ext_enc_name = opt->ext.enc.name;
+        VALUE int_enc_name = opt->intern.enc.name;
         ruby_features_t feat = opt->features;
         ruby_features_t warn = opt->warn;
 
-	opt->src.enc.name = opt->ext.enc.name = opt->intern.enc.name = 0;
-	moreswitches(s, opt, 1);
-	if (src_enc_name)
-	    opt->src.enc.name = src_enc_name;
-	if (ext_enc_name)
-	    opt->ext.enc.name = ext_enc_name;
-	if (int_enc_name)
-	    opt->intern.enc.name = int_enc_name;
+        opt->src.enc.name = opt->ext.enc.name = opt->intern.enc.name = 0;
+        moreswitches(s, opt, 1);
+        if (src_enc_name)
+            opt->src.enc.name = src_enc_name;
+        if (ext_enc_name)
+            opt->ext.enc.name = ext_enc_name;
+        if (int_enc_name)
+            opt->intern.enc.name = int_enc_name;
         FEATURE_SET_RESTORE(opt->features, feat);
         FEATURE_SET_RESTORE(opt->warn, warn);
     }
@@ -1838,44 +1838,44 @@ process_options(int argc, char **argv, ruby_cmdline_options_t *opt)
 #endif
     Init_ruby_description();
     if (opt->dump & (DUMP_BIT(version) | DUMP_BIT(version_v))) {
-	ruby_show_version();
-	if (opt->dump & DUMP_BIT(version)) return Qtrue;
+        ruby_show_version();
+        if (opt->dump & DUMP_BIT(version)) return Qtrue;
     }
     if (opt->dump & DUMP_BIT(copyright)) {
-	ruby_show_copyright();
-	return Qtrue;
+        ruby_show_copyright();
+        return Qtrue;
     }
 
     if (!opt->e_script) {
-	if (argc <= 0) {	/* no more args */
-	    if (opt->verbose)
-		return Qtrue;
-	    opt->script = "-";
-	}
-	else {
-	    opt->script = argv[0];
-	    if (!opt->script || opt->script[0] == '\0') {
-		opt->script = "-";
-	    }
-	    else if (opt->do_search) {
-		const char *path = getenv("RUBYPATH");
-
-		opt->script = 0;
-		if (path) {
-		    opt->script = dln_find_file_r(argv[0], path, fbuf, sizeof(fbuf));
-		}
-		if (!opt->script) {
-		    opt->script = dln_find_file_r(argv[0], getenv(PATH_ENV), fbuf, sizeof(fbuf));
-		}
-		if (!opt->script)
-		    opt->script = argv[0];
-	    }
-	    argc--;
-	    argv++;
-	}
-	if (opt->script[0] == '-' && !opt->script[1]) {
-	    forbid_setid("program input from stdin");
-	}
+        if (argc <= 0) {	/* no more args */
+            if (opt->verbose)
+                return Qtrue;
+            opt->script = "-";
+        }
+        else {
+            opt->script = argv[0];
+            if (!opt->script || opt->script[0] == '\0') {
+                opt->script = "-";
+            }
+            else if (opt->do_search) {
+                const char *path = getenv("RUBYPATH");
+
+                opt->script = 0;
+                if (path) {
+                    opt->script = dln_find_file_r(argv[0], path, fbuf, sizeof(fbuf));
+                }
+                if (!opt->script) {
+                    opt->script = dln_find_file_r(argv[0], getenv(PATH_ENV), fbuf, sizeof(fbuf));
+                }
+                if (!opt->script)
+                    opt->script = argv[0];
+            }
+            argc--;
+            argv++;
+        }
+        if (opt->script[0] == '-' && !opt->script[1]) {
+            forbid_setid("program input from stdin");
+        }
     }
 
     opt->script_name = rb_str_new_cstr(opt->script);
@@ -1902,66 +1902,66 @@ process_options(int argc, char **argv, ruby_cmdline_options_t *opt)
     rb_obj_freeze(rb_progname);
     parser = rb_parser_new();
     if (opt->dump & DUMP_BIT(yydebug)) {
-	rb_parser_set_yydebug(parser, Qtrue);
+        rb_parser_set_yydebug(parser, Qtrue);
     }
     if (opt->ext.enc.name != 0) {
-	opt->ext.enc.index = opt_enc_index(opt->ext.enc.name);
+        opt->ext.enc.index = opt_enc_index(opt->ext.enc.name);
     }
     if (opt->intern.enc.name != 0) {
-	opt->intern.enc.index = opt_enc_index(opt->intern.enc.name);
+        opt->intern.enc.index = opt_enc_index(opt->intern.enc.name);
     }
     if (opt->src.enc.name != 0) {
-	opt->src.enc.index = opt_enc_index(opt->src.enc.name);
-	src_encoding_index = opt->src.enc.index;
+        opt->src.enc.index = opt_enc_index(opt->src.enc.name);
+        src_encoding_index = opt->src.enc.index;
     }
     if (opt->ext.enc.index >= 0) {
-	enc = rb_enc_from_index(opt->ext.enc.index);
+        enc = rb_enc_from_index(opt->ext.enc.index);
     }
     else {
-	enc = IF_UTF8_PATH(uenc, lenc);
+        enc = IF_UTF8_PATH(uenc, lenc);
     }
     rb_enc_set_default_external(rb_enc_from_encoding(enc));
     if (opt->intern.enc.index >= 0) {
-	enc = rb_enc_from_index(opt->intern.enc.index);
-	rb_enc_set_default_internal(rb_enc_from_encoding(enc));
-	opt->intern.enc.index = -1;
+        enc = rb_enc_from_index(opt->intern.enc.index);
+        rb_enc_set_default_internal(rb_enc_from_encoding(enc));
+        opt->intern.enc.index = -1;
 #if UTF8_PATH
-	ienc = enc;
+        ienc = enc;
 #endif
     }
     script_name = opt->script_name;
     rb_enc_associate(opt->script_name, IF_UTF8_PATH(uenc, lenc));
 #if UTF8_PATH
     if (uenc != lenc) {
-	opt->script_name = str_conv_enc(opt->script_name, uenc, lenc);
-	opt->script = RSTRING_PTR(opt->script_name);
+        opt->script_name = str_conv_enc(opt->script_name, uenc, lenc);
+        opt->script = RSTRING_PTR(opt->script_name);
     }
 #endif
     rb_obj_freeze(opt->script_name);
     if (IF_UTF8_PATH(uenc != lenc, 1)) {
-	long i;
+        long i;
         VALUE load_path = vm->load_path;
-	const ID id_initial_load_path_mark = INITIAL_LOAD_PATH_MARK;
+        const ID id_initial_load_path_mark = INITIAL_LOAD_PATH_MARK;
         int modifiable = FALSE;
 
         rb_get_expanded_load_path();
-	for (i = 0; i < RARRAY_LEN(load_path); ++i) {
-	    VALUE path = RARRAY_AREF(load_path, i);
-	    int mark = rb_attr_get(path, id_initial_load_path_mark) == path;
+        for (i = 0; i < RARRAY_LEN(load_path); ++i) {
+            VALUE path = RARRAY_AREF(load_path, i);
+            int mark = rb_attr_get(path, id_initial_load_path_mark) == path;
 #if UTF8_PATH
-	    VALUE newpath = rb_str_conv_enc(path, uenc, lenc);
-	    if (newpath == path) continue;
-	    path = newpath;
+            VALUE newpath = rb_str_conv_enc(path, uenc, lenc);
+            if (newpath == path) continue;
+            path = newpath;
 #else
-	    if (!(path = copy_str(path, lenc, !mark))) continue;
+            if (!(path = copy_str(path, lenc, !mark))) continue;
 #endif
-	    if (mark) rb_ivar_set(path, id_initial_load_path_mark, path);
+            if (mark) rb_ivar_set(path, id_initial_load_path_mark, path);
             if (!modifiable) {
                 rb_ary_modify(load_path);
                 modifiable = TRUE;
             }
-	    RARRAY_ASET(load_path, i, path);
-	}
+            RARRAY_ASET(load_path, i, path);
+        }
         if (modifiable) {
             rb_ary_replace(vm->load_path_snapshot, load_path);
         }
@@ -1970,13 +1970,13 @@ process_options(int argc, char **argv, ruby_cmdline_options_t *opt)
         VALUE loaded_features = vm->loaded_features;
         bool modified = false;
         for (long i = loaded_before_enc; i < RARRAY_LEN(loaded_features); ++i) {
-	    VALUE path = RARRAY_AREF(loaded_features, i);
+            VALUE path = RARRAY_AREF(loaded_features, i);
             if (!(path = copy_str(path, IF_UTF8_PATH(uenc, lenc), true))) continue;
             if (!modified) {
                 rb_ary_modify(loaded_features);
                 modified = true;
             }
-	    RARRAY_ASET(loaded_features, i, path);
+            RARRAY_ASET(loaded_features, i, path);
         }
         if (modified) {
             rb_ary_replace(vm->loaded_features_snapshot, loaded_features);
@@ -1984,13 +1984,13 @@ process_options(int argc, char **argv, ruby_cmdline_options_t *opt)
     }
 
     if (opt->features.mask & COMPILATION_FEATURES) {
-	VALUE option = rb_hash_new();
+        VALUE option = rb_hash_new();
 #define SET_COMPILE_OPTION(h, o, name) \
-	rb_hash_aset((h), ID2SYM(rb_intern_const(#name)), \
+        rb_hash_aset((h), ID2SYM(rb_intern_const(#name)), \
                      RBOOL(FEATURE_SET_P(o->features, name)))
-	SET_COMPILE_OPTION(option, opt, frozen_string_literal);
-	SET_COMPILE_OPTION(option, opt, debug_frozen_string_literal);
-	rb_funcallv(rb_cISeq, rb_intern_const("compile_option="), 1, &option);
+        SET_COMPILE_OPTION(option, opt, frozen_string_literal);
+        SET_COMPILE_OPTION(option, opt, debug_frozen_string_literal);
+        rb_funcallv(rb_cISeq, rb_intern_const("compile_option="), 1, &option);
 #undef SET_COMPILE_OPTION
     }
     ruby_set_argv(argc, argv);
@@ -1999,115 +1999,115 @@ process_options(int argc, char **argv, ruby_cmdline_options_t *opt)
     rb_parser_set_context(parser, 0, TRUE);
 
     if (opt->e_script) {
-	VALUE progname = rb_progname;
-	rb_encoding *eenc;
-	if (opt->src.enc.index >= 0) {
-	    eenc = rb_enc_from_index(opt->src.enc.index);
-	}
-	else {
-	    eenc = lenc;
+        VALUE progname = rb_progname;
+        rb_encoding *eenc;
+        if (opt->src.enc.index >= 0) {
+            eenc = rb_enc_from_index(opt->src.enc.index);
+        }
+        else {
+            eenc = lenc;
 #if UTF8_PATH
-	    if (ienc) eenc = ienc;
+            if (ienc) eenc = ienc;
 #endif
-	}
+        }
 #if UTF8_PATH
-	if (eenc != uenc) {
-	    opt->e_script = str_conv_enc(opt->e_script, uenc, eenc);
-	}
+        if (eenc != uenc) {
+            opt->e_script = str_conv_enc(opt->e_script, uenc, eenc);
+        }
 #endif
-	rb_enc_associate(opt->e_script, eenc);
+        rb_enc_associate(opt->e_script, eenc);
         ruby_opt_init(opt);
         ruby_set_script_name(progname);
-	rb_parser_set_options(parser, opt->do_print, opt->do_loop,
-			      opt->do_line, opt->do_split);
-	ast = rb_parser_compile_string(parser, opt->script, opt->e_script, 1);
+        rb_parser_set_options(parser, opt->do_print, opt->do_loop,
+                              opt->do_line, opt->do_split);
+        ast = rb_parser_compile_string(parser, opt->script, opt->e_script, 1);
     }
     else {
-	VALUE f;
-	f = open_load_file(script_name, &opt->xflag);
-	ast = load_file(parser, opt->script_name, f, 1, opt);
+        VALUE f;
+        f = open_load_file(script_name, &opt->xflag);
+        ast = load_file(parser, opt->script_name, f, 1, opt);
     }
     ruby_set_script_name(opt->script_name);
     if (dump & DUMP_BIT(yydebug)) {
-	dump &= ~DUMP_BIT(yydebug);
-	if (!dump) return Qtrue;
+        dump &= ~DUMP_BIT(yydebug);
+        if (!dump) return Qtrue;
     }
 
     if (opt->ext.enc.index >= 0) {
-	enc = rb_enc_from_index(opt->ext.enc.index);
+        enc = rb_enc_from_index(opt->ext.enc.index);
     }
     else {
-	enc = IF_UTF8_PATH(uenc, lenc);
+        enc = IF_UTF8_PATH(uenc, lenc);
     }
     rb_enc_set_default_external(rb_enc_from_encoding(enc));
     if (opt->intern.enc.index >= 0) {
-	/* Set in the shebang line */
-	enc = rb_enc_from_index(opt->intern.enc.index);
-	rb_enc_set_default_internal(rb_enc_from_encoding(enc));
+        /* Set in the shebang line */
+        enc = rb_enc_from_index(opt->intern.enc.index);
+        rb_enc_set_default_internal(rb_enc_from_encoding(enc));
     }
     else if (!rb_default_internal_encoding())
-	/* Freeze default_internal */
-	rb_enc_set_default_internal(Qnil);
+        /* Freeze default_internal */
+        rb_enc_set_default_internal(Qnil);
     rb_stdio_set_default_encoding();
 
     if (!ast->body.root) {
-	rb_ast_dispose(ast);
-	return Qfalse;
+        rb_ast_dispose(ast);
+        return Qfalse;
     }
 
     process_sflag(&opt->sflag);
     opt->xflag = 0;
 
     if (dump & DUMP_BIT(syntax)) {
-	printf("Syntax OK\n");
-	dump &= ~DUMP_BIT(syntax);
-	if (!dump) return Qtrue;
+        printf("Syntax OK\n");
+        dump &= ~DUMP_BIT(syntax);
+        if (!dump) return Qtrue;
     }
 
     if (opt->do_loop) {
-	rb_define_global_function("sub", rb_f_sub, -1);
-	rb_define_global_function("gsub", rb_f_gsub, -1);
-	rb_define_global_function("chop", rb_f_chop, 0);
-	rb_define_global_function("chomp", rb_f_chomp, -1);
+        rb_define_global_function("sub", rb_f_sub, -1);
+        rb_define_global_function("gsub", rb_f_gsub, -1);
+        rb_define_global_function("chop", rb_f_chop, 0);
+        rb_define_global_function("chomp", rb_f_chomp, -1);
     }
 
     if (dump & (DUMP_BIT(parsetree)|DUMP_BIT(parsetree_with_comment))) {
-	rb_io_write(rb_stdout, rb_parser_dump_tree(ast->body.root, dump & DUMP_BIT(parsetree_with_comment)));
-	rb_io_flush(rb_stdout);
-	dump &= ~DUMP_BIT(parsetree)&~DUMP_BIT(parsetree_with_comment);
-	if (!dump) {
-	    rb_ast_dispose(ast);
-	    return Qtrue;
-	}
+        rb_io_write(rb_stdout, rb_parser_dump_tree(ast->body.root, dump & DUMP_BIT(parsetree_with_comment)));
+        rb_io_flush(rb_stdout);
+        dump &= ~DUMP_BIT(parsetree)&~DUMP_BIT(parsetree_with_comment);
+        if (!dump) {
+            rb_ast_dispose(ast);
+            return Qtrue;
+        }
     }
 
     {
-	VALUE path = Qnil;
-	if (!opt->e_script && strcmp(opt->script, "-")) {
-	    path = rb_realpath_internal(Qnil, script_name, 1);
+        VALUE path = Qnil;
+        if (!opt->e_script && strcmp(opt->script, "-")) {
+            path = rb_realpath_internal(Qnil, script_name, 1);
 #if UTF8_PATH
-	    if (uenc != lenc) {
-		path = str_conv_enc(path, uenc, lenc);
-	    }
+            if (uenc != lenc) {
+                path = str_conv_enc(path, uenc, lenc);
+            }
 #endif
-	    if (!ENCODING_GET(path)) { /* ASCII-8BIT */
-		rb_enc_copy(path, opt->script_name);
-	    }
-	}
+            if (!ENCODING_GET(path)) { /* ASCII-8BIT */
+                rb_enc_copy(path, opt->script_name);
+            }
+        }
 
         rb_binding_t *toplevel_binding;
         GetBindingPtr(rb_const_get(rb_cObject, rb_intern("TOPLEVEL_BINDING")),
                       toplevel_binding);
         const struct rb_block *base_block = toplevel_context(toplevel_binding);
-	iseq = rb_iseq_new_main(&ast->body, opt->script_name, path, vm_block_iseq(base_block), !(dump & DUMP_BIT(insns_without_opt)));
-	rb_ast_dispose(ast);
+        iseq = rb_iseq_new_main(&ast->body, opt->script_name, path, vm_block_iseq(base_block), !(dump & DUMP_BIT(insns_without_opt)));
+        rb_ast_dispose(ast);
     }
 
     if (dump & (DUMP_BIT(insns) | DUMP_BIT(insns_without_opt))) {
-	rb_io_write(rb_stdout, rb_iseq_disasm((const rb_iseq_t *)iseq));
-	rb_io_flush(rb_stdout);
-	dump &= ~DUMP_BIT(insns);
-	if (!dump) return Qtrue;
+        rb_io_write(rb_stdout, rb_iseq_disasm((const rb_iseq_t *)iseq));
+        rb_io_flush(rb_stdout);
+        dump &= ~DUMP_BIT(insns);
+        if (!dump) return Qtrue;
     }
     if (opt->dump & dump_exit_bits) return Qtrue;
 
@@ -2144,7 +2144,7 @@ static void
 warn_cr_in_shebang(const char *str, long len)
 {
     if (str[len-1] == '\n' && str[len-2] == '\r') {
-	rb_warn("shebang line ending with \\r may cause problems");
+        rb_warn("shebang line ending with \\r may cause problems");
     }
 }
 #else
@@ -2177,115 +2177,115 @@ load_file_internal(VALUE argp_v)
 
     CONST_ID(set_encoding, "set_encoding");
     if (script) {
-	VALUE c = 1;		/* something not nil */
-	VALUE line;
-	char *p, *str;
-	long len;
-	int no_src_enc = !opt->src.enc.name;
-	int no_ext_enc = !opt->ext.enc.name;
-	int no_int_enc = !opt->intern.enc.name;
-
-	enc = rb_ascii8bit_encoding();
-	rb_funcall(f, set_encoding, 1, rb_enc_from_encoding(enc));
-
-	if (opt->xflag) {
-	    line_start--;
-	  search_shebang:
-	    while (!NIL_P(line = rb_io_gets(f))) {
-		line_start++;
-		RSTRING_GETMEM(line, str, len);
-		if (len > 2 && str[0] == '#' && str[1] == '!') {
-		    if (line_start == 1) warn_cr_in_shebang(str, len);
-		    if ((p = strstr(str+2, ruby_engine)) != 0) {
-			goto start_read;
-		    }
-		}
-	    }
-	    rb_loaderror("no Ruby script found in input");
-	}
-
-	c = rb_io_getbyte(f);
-	if (c == INT2FIX('#')) {
-	    c = rb_io_getbyte(f);
+        VALUE c = 1;		/* something not nil */
+        VALUE line;
+        char *p, *str;
+        long len;
+        int no_src_enc = !opt->src.enc.name;
+        int no_ext_enc = !opt->ext.enc.name;
+        int no_int_enc = !opt->intern.enc.name;
+
+        enc = rb_ascii8bit_encoding();
+        rb_funcall(f, set_encoding, 1, rb_enc_from_encoding(enc));
+
+        if (opt->xflag) {
+            line_start--;
+          search_shebang:
+            while (!NIL_P(line = rb_io_gets(f))) {
+                line_start++;
+                RSTRING_GETMEM(line, str, len);
+                if (len > 2 && str[0] == '#' && str[1] == '!') {
+                    if (line_start == 1) warn_cr_in_shebang(str, len);
+                    if ((p = strstr(str+2, ruby_engine)) != 0) {
+                        goto start_read;
+                    }
+                }
+            }
+            rb_loaderror("no Ruby script found in input");
+        }
+
+        c = rb_io_getbyte(f);
+        if (c == INT2FIX('#')) {
+            c = rb_io_getbyte(f);
             if (c == INT2FIX('!') && !NIL_P(line = rb_io_gets(f))) {
-		RSTRING_GETMEM(line, str, len);
-		warn_cr_in_shebang(str, len);
-		if ((p = strstr(str, ruby_engine)) == 0) {
-		    /* not ruby script, assume -x flag */
-		    goto search_shebang;
-		}
-
-	      start_read:
-		str += len - 1;
-		if (*str == '\n') *str-- = '\0';
-		if (*str == '\r') *str-- = '\0';
-		/* ruby_engine should not contain a space */
-		if ((p = strstr(p, " -")) != 0) {
-		    opt->warning = 0;
-		    moreswitches(p + 1, opt, 0);
-		}
-
-		/* push back shebang for pragma may exist in next line */
-		rb_io_ungetbyte(f, rb_str_new2("!\n"));
-	    }
-	    else if (!NIL_P(c)) {
-		rb_io_ungetbyte(f, c);
-	    }
-	    rb_io_ungetbyte(f, INT2FIX('#'));
-	    if (no_src_enc && opt->src.enc.name) {
-		opt->src.enc.index = opt_enc_index(opt->src.enc.name);
-		src_encoding_index = opt->src.enc.index;
-	    }
-	    if (no_ext_enc && opt->ext.enc.name) {
-		opt->ext.enc.index = opt_enc_index(opt->ext.enc.name);
-	    }
-	    if (no_int_enc && opt->intern.enc.name) {
-		opt->intern.enc.index = opt_enc_index(opt->intern.enc.name);
-	    }
-	}
-	else if (!NIL_P(c)) {
-	    rb_io_ungetbyte(f, c);
-	}
+                RSTRING_GETMEM(line, str, len);
+                warn_cr_in_shebang(str, len);
+                if ((p = strstr(str, ruby_engine)) == 0) {
+                    /* not ruby script, assume -x flag */
+                    goto search_shebang;
+                }
+
+              start_read:
+                str += len - 1;
+                if (*str == '\n') *str-- = '\0';
+                if (*str == '\r') *str-- = '\0';
+                /* ruby_engine should not contain a space */
+                if ((p = strstr(p, " -")) != 0) {
+                    opt->warning = 0;
+                    moreswitches(p + 1, opt, 0);
+                }
+
+                /* push back shebang for pragma may exist in next line */
+                rb_io_ungetbyte(f, rb_str_new2("!\n"));
+            }
+            else if (!NIL_P(c)) {
+                rb_io_ungetbyte(f, c);
+            }
+            rb_io_ungetbyte(f, INT2FIX('#'));
+            if (no_src_enc && opt->src.enc.name) {
+                opt->src.enc.index = opt_enc_index(opt->src.enc.name);
+                src_encoding_index = opt->src.enc.index;
+            }
+            if (no_ext_enc && opt->ext.enc.name) {
+                opt->ext.enc.index = opt_enc_index(opt->ext.enc.name);
+            }
+            if (no_int_enc && opt->intern.enc.name) {
+                opt->intern.enc.index = opt_enc_index(opt->intern.enc.name);
+            }
+        }
+        else if (!NIL_P(c)) {
+            rb_io_ungetbyte(f, c);
+        }
         if (NIL_P(c)) {
-	    argp->f = f = Qnil;
-	}
+            argp->f = f = Qnil;
+        }
         rb_reset_argf_lineno(0);
         ruby_opt_init(opt);
     }
     if (opt->src.enc.index >= 0) {
-	enc = rb_enc_from_index(opt->src.enc.index);
+        enc = rb_enc_from_index(opt->src.enc.index);
     }
     else if (f == rb_stdin) {
-	enc = rb_locale_encoding();
+        enc = rb_locale_encoding();
     }
     else {
-	enc = rb_utf8_encoding();
+        enc = rb_utf8_encoding();
     }
     rb_parser_set_options(parser, opt->do_print, opt->do_loop,
-			  opt->do_line, opt->do_split);
+                          opt->do_line, opt->do_split);
     if (NIL_P(f)) {
-	f = rb_str_new(0, 0);
-	rb_enc_associate(f, enc);
-	return (VALUE)rb_parser_compile_string_path(parser, orig_fname, f, line_start);
+        f = rb_str_new(0, 0);
+        rb_enc_associate(f, enc);
+        return (VALUE)rb_parser_compile_string_path(parser, orig_fname, f, line_start);
     }
     rb_funcall(f, set_encoding, 2, rb_enc_from_encoding(enc), rb_str_new_cstr("-"));
     ast = rb_parser_compile_file_path(parser, orig_fname, f, line_start);
     rb_funcall(f, set_encoding, 1, rb_parser_encoding(parser));
     if (script && rb_parser_end_seen_p(parser)) {
-	/*
-	 * DATA is a File that contains the data section of the executed file.
-	 * To create a data section use <tt>__END__</tt>:
-	 *
-	 *   $ cat t.rb
-	 *   puts DATA.gets
-	 *   __END__
-	 *   hello world!
-	 *
-	 *   $ ruby t.rb
-	 *   hello world!
-	 */
-	rb_define_global_const("DATA", f);
-	argp->f = Qnil;
+        /*
+         * DATA is a File that contains the data section of the executed file.
+         * To create a data section use <tt>__END__</tt>:
+         *
+         *   $ cat t.rb
+         *   puts DATA.gets
+         *   __END__
+         *   hello world!
+         *
+         *   $ ruby t.rb
+         *   hello world!
+         */
+        rb_define_global_const("DATA", f);
+        argp->f = Qnil;
     }
     return (VALUE)ast;
 }
@@ -2314,72 +2314,72 @@ static VALUE
 open_load_file(VALUE fname_v, int *xflag)
 {
     const char *fname = (fname_v = rb_str_encode_ospath(fname_v),
-			 StringValueCStr(fname_v));
+                         StringValueCStr(fname_v));
     long flen = RSTRING_LEN(fname_v);
     VALUE f;
     int e;
 
     if (flen == 1 && fname[0] == '-') {
-	f = rb_stdin;
+        f = rb_stdin;
     }
     else {
-	int fd;
-	/* open(2) may block if fname is point to FIFO and it's empty. Let's
-	   use O_NONBLOCK. */
-	const int MODE_TO_LOAD = O_RDONLY | (
+        int fd;
+        /* open(2) may block if fname is point to FIFO and it's empty. Let's
+           use O_NONBLOCK. */
+        const int MODE_TO_LOAD = O_RDONLY | (
 #if defined O_NONBLOCK && HAVE_FCNTL
-	/* TODO: fix conflicting O_NONBLOCK in ruby/win32.h */
-	    !(O_NONBLOCK & O_ACCMODE) ? O_NONBLOCK :
+        /* TODO: fix conflicting O_NONBLOCK in ruby/win32.h */
+            !(O_NONBLOCK & O_ACCMODE) ? O_NONBLOCK :
 #endif
 #if defined O_NDELAY && HAVE_FCNTL
             !(O_NDELAY & O_ACCMODE) ? O_NDELAY :
 #endif
             0);
-	int mode = MODE_TO_LOAD;
+        int mode = MODE_TO_LOAD;
 #if defined DOSISH || defined __CYGWIN__
 # define isdirsep(x) ((x) == '/' || (x) == '\\')
-	{
-	    static const char exeext[] = ".exe";
-	    enum {extlen = sizeof(exeext)-1};
-	    if (flen > extlen && !isdirsep(fname[flen-extlen-1]) &&
-		STRNCASECMP(fname+flen-extlen, exeext, extlen) == 0) {
-		mode |= O_BINARY;
-		*xflag = 1;
-	    }
-	}
-#endif
-
-	if ((fd = rb_cloexec_open(fname, mode, 0)) < 0) {
-	    e = errno;
-	    if (!rb_gc_for_fd(e)) {
-		rb_load_fail(fname_v, strerror(e));
-	    }
-	    if ((fd = rb_cloexec_open(fname, mode, 0)) < 0) {
-		rb_load_fail(fname_v, strerror(errno));
-	    }
-	}
-	rb_update_max_fd(fd);
-
-	if (MODE_TO_LOAD != O_RDONLY && (e = disable_nonblock(fd)) != 0) {
-	    (void)close(fd);
-	    rb_load_fail(fname_v, strerror(e));
-	}
-
-	e = ruby_is_fd_loadable(fd);
-	if (!e) {
-	    e = errno;
-	    (void)close(fd);
-	    rb_load_fail(fname_v, strerror(e));
-	}
-
-	f = rb_io_fdopen(fd, mode, fname);
-	if (e < 0) {
-	    /*
-	      We need to wait if FIFO is empty. It's FIFO's semantics.
-	      rb_thread_wait_fd() release GVL. So, it's safe.
-	    */
-	    rb_io_wait(f, RB_INT2NUM(RUBY_IO_READABLE), Qnil);
-	}
+        {
+            static const char exeext[] = ".exe";
+            enum {extlen = sizeof(exeext)-1};
+            if (flen > extlen && !isdirsep(fname[flen-extlen-1]) &&
+                STRNCASECMP(fname+flen-extlen, exeext, extlen) == 0) {
+                mode |= O_BINARY;
+                *xflag = 1;
+            }
+        }
+#endif
+
+        if ((fd = rb_cloexec_open(fname, mode, 0)) < 0) {
+            e = errno;
+            if (!rb_gc_for_fd(e)) {
+                rb_load_fail(fname_v, strerror(e));
+            }
+            if ((fd = rb_cloexec_open(fname, mode, 0)) < 0) {
+                rb_load_fail(fname_v, strerror(errno));
+            }
+        }
+        rb_update_max_fd(fd);
+
+        if (MODE_TO_LOAD != O_RDONLY && (e = disable_nonblock(fd)) != 0) {
+            (void)close(fd);
+            rb_load_fail(fname_v, strerror(e));
+        }
+
+        e = ruby_is_fd_loadable(fd);
+        if (!e) {
+            e = errno;
+            (void)close(fd);
+            rb_load_fail(fname_v, strerror(e));
+        }
+
+        f = rb_io_fdopen(fd, mode, fname);
+        if (e < 0) {
+            /*
+              We need to wait if FIFO is empty. It's FIFO's semantics.
+              rb_thread_wait_fd() release GVL. So, it's safe.
+            */
+            rb_io_wait(f, RB_INT2NUM(RUBY_IO_READABLE), Qnil);
+        }
     }
     return f;
 }
@@ -2391,7 +2391,7 @@ restore_load_file(VALUE arg)
     VALUE f = argp->f;
 
     if (!NIL_P(f) && f != rb_stdin) {
-	rb_io_close(f);
+        rb_io_close(f);
     }
     return Qnil;
 }
@@ -2406,7 +2406,7 @@ load_file(VALUE parser, VALUE fname, VALUE f, int script, ruby_cmdline_options_t
     arg.opt = opt;
     arg.f = f;
     return (rb_ast_t *)rb_ensure(load_file_internal, (VALUE)&arg,
-			      restore_load_file, (VALUE)&arg);
+                              restore_load_file, (VALUE)&arg);
 }
 
 void *
@@ -2484,7 +2484,7 @@ static void
 set_arg0(VALUE val, ID id, VALUE *_)
 {
     if (origarg.argv == 0)
-	rb_raise(rb_eRuntimeError, "$0 not initialized");
+        rb_raise(rb_eRuntimeError, "$0 not initialized");
 
     rb_progname = rb_str_new_frozen(ruby_setproctitle(val));
 }
@@ -2505,8 +2505,8 @@ void
 ruby_script(const char *name)
 {
     if (name) {
-	rb_orig_progname = rb_progname = external_str_new_cstr(name);
-	rb_vm_set_progname(rb_progname);
+        rb_orig_progname = rb_progname = external_str_new_cstr(name);
+        rb_vm_set_progname(rb_progname);
     }
 }
 
@@ -2562,13 +2562,13 @@ opt_W_getter(ID id, VALUE *dmy)
 
     switch (v) {
       case Qnil:
-	return INT2FIX(0);
+        return INT2FIX(0);
       case Qfalse:
-	return INT2FIX(1);
+        return INT2FIX(1);
       case Qtrue:
-	return INT2FIX(2);
+        return INT2FIX(2);
       default:
-	return Qnil;
+        return Qnil;
     }
 }
 
@@ -2624,10 +2624,10 @@ ruby_set_argv(int argc, char **argv)
 
     rb_ary_clear(av);
     for (i = 0; i < argc; i++) {
-	VALUE arg = external_str_new_cstr(argv[i]);
+        VALUE arg = external_str_new_cstr(argv[i]);
 
-	OBJ_FREEZE(arg);
-	rb_ary_push(av, arg);
+        OBJ_FREEZE(arg);
+        rb_ary_push(av, arg);
     }
 }
 
@@ -2639,8 +2639,8 @@ ruby_process_options(int argc, char **argv)
     const char *script_name = (argc > 0 && argv[0]) ? argv[0] : ruby_engine;
 
     if (!origarg.argv || origarg.argc <= 0) {
-	origarg.argc = argc;
-	origarg.argv = argv;
+        origarg.argc = argc;
+        origarg.argv = argv;
     }
     ruby_script(script_name);  /* for the time being */
     rb_argv0 = rb_str_new4(rb_progname);
@@ -2691,8 +2691,8 @@ ruby_sysinit(int *argc, char ***argv)
     rb_w32_sysinit(argc, argv);
 #endif
     if (*argc >= 0 && *argv) {
-	origarg.argc = *argc;
-	origarg.argv = *argv;
+        origarg.argc = *argc;
+        origarg.argv = *argv;
     }
     fill_standard_fds();
 }