revert r62797, r62784. [Bug #13863]

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/branches/ruby_2_4@62801 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

dir.c

@@ -74,7 +74,6 @@ char *strchr(char*,char);
 #define rmdir(p) rb_w32_urmdir(p)
 #undef opendir
 #define opendir(p) rb_w32_uopendir(p)
-#define ruby_getcwd() rb_w32_ugetcwd(NULL, 0)
 #define IS_WIN32 1
 #else
 #define IS_WIN32 0
@@ -1049,52 +1048,26 @@ dir_s_chdir(int argc, VALUE *argv, VALUE obj)
 }
 
 VALUE
-rb_dir_getwd_ospath(void)
+rb_dir_getwd(void)
 {
     char *path;
     VALUE cwd;
-    VALUE path_guard;
+    int fsenc = rb_enc_to_index(rb_filesystem_encoding());
 
-#undef RUBY_UNTYPED_DATA_WARNING
+    if (fsenc == ENCINDEX_US_ASCII) fsenc = ENCINDEX_ASCII;
-#define RUBY_UNTYPED_DATA_WARNING 0
-    path_guard = Data_Wrap_Struct((VALUE)0, NULL, RUBY_DEFAULT_FREE, NULL);
     path = my_getcwd();
-    DATA_PTR(path_guard) = path;
+#ifdef __APPLE__
-#ifdef _WIN32
-    cwd = rb_utf8_str_new_cstr(path);
-    OBJ_TAINT(cwd);
-#elif defined __APPLE__
     cwd = rb_str_normalize_ospath(path, strlen(path));
     OBJ_TAINT(cwd);
 #else
     cwd = rb_tainted_str_new2(path);
 #endif
-    DATA_PTR(path_guard) = 0;
+    rb_enc_associate_index(cwd, fsenc);
 
     xfree(path);
     return cwd;
 }
 
-VALUE
-rb_dir_getwd(void)
-{
-    rb_encoding *fs = rb_filesystem_encoding();
-    int fsenc = rb_enc_to_index(fs);
-    VALUE cwd = rb_dir_getwd_ospath();
-
-    switch (fsenc) {
-      case ENCINDEX_US_ASCII:
-	fsenc = ENCINDEX_ASCII;
-      case ENCINDEX_ASCII:
-	break;
-#if defined _WIN32 || defined __APPLE__
-      default:
-	return rb_str_conv_enc(cwd, NULL, fs);
-#endif
-    }
-    return rb_enc_associate_index(cwd, fsenc);
-}
-
 /*
  *  call-seq:
  *     Dir.getwd -> string

file.c

@@ -126,14 +126,6 @@ int flock(int, int);
 #define STAT(p, s)	stat((p), (s))
 #endif
 
-#if defined _WIN32 || defined __APPLE__
-# define USE_OSPATH 1
-# define TO_OSPATH(str) rb_str_encode_ospath(str)
-#else
-# define USE_OSPATH 0
-# define TO_OSPATH(str) (str)
-#endif
-
 VALUE rb_cFile;
 VALUE rb_mFileTest;
 VALUE rb_cStat;
@@ -230,7 +222,7 @@ rb_get_path(VALUE obj)
 VALUE
 rb_str_encode_ospath(VALUE path)
 {
-#if USE_OSPATH
+#if defined _WIN32 || defined __APPLE__
     int encidx = ENCODING_GET(path);
 #ifdef _WIN32
     if (encidx == ENCINDEX_ASCII) {
@@ -3841,10 +3833,11 @@ realpath_rec(long *prefixlenp, VALUE *resolvedp, const char *unresolved,
             else {
                 struct stat sbuf;
                 int ret;
+                VALUE testpath2 = rb_str_encode_ospath(testpath);
 #ifdef __native_client__
-                ret = stat(RSTRING_PTR(testpath), &sbuf);
+                ret = stat(RSTRING_PTR(testpath2), &sbuf);
 #else
-                ret = lstat(RSTRING_PTR(testpath), &sbuf);
+                ret = lstat(RSTRING_PTR(testpath2), &sbuf);
 #endif
                 if (ret == -1) {
 		    int e = errno;
@@ -3916,12 +3909,9 @@ rb_check_realpath_internal(VALUE basedir, VALUE path, enum rb_realpath_mode mode
 
     if (!NIL_P(basedir)) {
         FilePathValue(basedir);
-        basedir = TO_OSPATH(rb_str_dup_frozen(basedir));
+        basedir = rb_str_dup_frozen(basedir);
     }
 
-    enc = rb_enc_get(unresolved_path);
-    origenc = enc;
-    unresolved_path = TO_OSPATH(unresolved_path);
     RSTRING_GETMEM(unresolved_path, ptr, len);
     path_names = skipprefixroot(ptr, ptr + len, rb_enc_get(unresolved_path));
     if (ptr != path_names) {
@@ -3938,7 +3928,7 @@ rb_check_realpath_internal(VALUE basedir, VALUE path, enum rb_realpath_mode mode
         }
     }
 
-    curdir = rb_dir_getwd_ospath();
+    curdir = rb_dir_getwd();
     RSTRING_GETMEM(curdir, ptr, len);
     curdir_names = skipprefixroot(ptr, ptr + len, rb_enc_get(curdir));
     resolved = rb_str_subseq(curdir, 0, curdir_names - ptr);
@@ -3946,6 +3936,7 @@ rb_check_realpath_internal(VALUE basedir, VALUE path, enum rb_realpath_mode mode
   root_found:
     RSTRING_GETMEM(resolved, prefixptr, prefixlen);
     pend = prefixptr + prefixlen;
+    enc = rb_enc_get(resolved);
     ptr = chompdirsep(prefixptr, pend, enc);
     if (ptr < pend) {
         prefixlen = ++ptr - prefixptr;
@@ -3960,6 +3951,7 @@ rb_check_realpath_internal(VALUE basedir, VALUE path, enum rb_realpath_mode mode
     }
 #endif
 
+    origenc = enc;
     switch (rb_enc_to_index(enc)) {
       case ENCINDEX_ASCII:
       case ENCINDEX_US_ASCII:
@@ -3978,14 +3970,8 @@ rb_check_realpath_internal(VALUE basedir, VALUE path, enum rb_realpath_mode mode
     if (realpath_rec(&prefixlen, &resolved, path_names, loopcheck, mode, 1))
 	return Qnil;
 
-    if (origenc != rb_enc_get(resolved)) {
+    if (origenc != enc && rb_enc_str_asciionly_p(resolved))
-	if (rb_enc_str_asciionly_p(resolved)) {
 	rb_enc_associate(resolved, origenc);
-	}
-	else {
-	    resolved = rb_str_conv_enc(resolved, NULL, origenc);
-	}
-    }
 
     OBJ_TAINT(resolved);
     return resolved;

internal.h

@@ -982,9 +982,6 @@ void ruby_register_rollback_func_for_ensure(VALUE (*ensure_func)(ANYARGS), VALUE
 /* debug.c */
 PRINTF_ARGS(void ruby_debug_printf(const char*, ...), 1, 2);
 
-/* dir.c */
-VALUE rb_dir_getwd_ospath(void);
-
 /* dmyext.c */
 void Init_enc(void);
 void Init_ext(void);

load.c

@@ -95,6 +95,15 @@ rb_construct_expanded_load_path(enum expand_type type, int *has_relative, int *h
     rb_ary_replace(vm->load_path_snapshot, vm->load_path);
 }
 
+static VALUE
+load_path_getcwd(void)
+{
+    char *cwd = my_getcwd();
+    VALUE cwd_str = rb_filesystem_str_new_cstr(cwd);
+    xfree(cwd);
+    return cwd_str;
+}
+
 VALUE
 rb_get_expanded_load_path(void)
 {
@@ -106,7 +115,7 @@ rb_get_expanded_load_path(void)
 	int has_relative = 0, has_non_cache = 0;
 	rb_construct_expanded_load_path(EXPAND_ALL, &has_relative, &has_non_cache);
 	if (has_relative) {
-	    vm->load_path_check_cache = rb_dir_getwd_ospath();
+	    vm->load_path_check_cache = load_path_getcwd();
 	}
 	else if (has_non_cache) {
 	    /* Non string object. */
@@ -124,7 +133,7 @@ rb_get_expanded_load_path(void)
     }
     else if (vm->load_path_check_cache) {
 	int has_relative = 1, has_non_cache = 1;
-	VALUE cwd = rb_dir_getwd_ospath();
+	VALUE cwd = load_path_getcwd();
 	if (!rb_str_equal(vm->load_path_check_cache, cwd)) {
 	    /* Current working directory or filesystem encoding was changed.
 	       Expand relative load path and non-cacheable objects again. */

ruby.c

@@ -175,10 +175,8 @@ cmdline_options_init(ruby_cmdline_options_t *opt)
     return opt;
 }
 
-static NODE *load_file(VALUE parser, VALUE fname, VALUE f, int script,
+static NODE *load_file(VALUE, VALUE, int, ruby_cmdline_options_t *);
-		       ruby_cmdline_options_t *opt);
+static void forbid_setid(const char *, ruby_cmdline_options_t *);
-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)
 
 static struct {
@@ -425,8 +423,6 @@ str_conv_enc(VALUE str, rb_encoding *from, rb_encoding *to)
 				ECONV_UNDEF_REPLACE|ECONV_INVALID_REPLACE,
 				Qnil);
 }
-#else
-# define str_conv_enc(str, from, to) (str)
 #endif
 
 void ruby_init_loadpath_safe(int safe_level);
@@ -1054,7 +1050,6 @@ proc_options(long argc, char **argv, ruby_cmdline_options_t *opt, int envopt)
 
 	  case 'x':
 	    if (envopt) goto noenvopt;
-	    forbid_setid("-x");
 	    opt->xflag = TRUE;
 	    s++;
 	    if (*s && chdir(s) < 0) {
@@ -1444,7 +1439,6 @@ process_options(int argc, char **argv, ruby_cmdline_options_t *opt)
 {
     NODE *tree = 0;
     VALUE parser;
-    VALUE script_name;
     const rb_iseq_t *iseq;
     rb_encoding *enc, *lenc;
 #if UTF8_PATH
@@ -1520,9 +1514,6 @@ process_options(int argc, char **argv, ruby_cmdline_options_t *opt)
 	    argc--;
 	    argv++;
 	}
-	if (opt->script[0] == '-' && !opt->script[1]) {
-	    forbid_setid("program input from stdin");
-	}
     }
 
     opt->script_name = rb_str_new_cstr(opt->script);
@@ -1569,17 +1560,9 @@ process_options(int argc, char **argv, ruby_cmdline_options_t *opt)
 	ienc = enc;
 #endif
     }
-    script_name = opt->script_name;
+    rb_enc_associate(opt->script_name, lenc);
-    rb_enc_associate(opt->script_name,
-		     IF_UTF8_PATH(uenc = rb_utf8_encoding(), 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);
-    }
-#endif
     rb_obj_freeze(opt->script_name);
-    if (IF_UTF8_PATH(uenc != lenc, 1)) {
+    if (IF_UTF8_PATH((uenc = rb_utf8_encoding()) != lenc, 1)) {
 	long i;
 	VALUE load_path = GET_VM()->load_path;
 	const ID id_initial_load_path_mark = INITIAL_LOAD_PATH_MARK;
@@ -1615,6 +1598,12 @@ process_options(int argc, char **argv, ruby_cmdline_options_t *opt)
 	rb_funcallv(rb_cISeq, rb_intern_const("compile_option="), 1, &option);
 #undef SET_COMPILE_OPTION
     }
+#if UTF8_PATH
+    if (uenc != lenc) {
+	opt->script_name = str_conv_enc(opt->script_name, uenc, lenc);
+	opt->script = RSTRING_PTR(opt->script_name);
+    }
+#endif
     ruby_set_argv(argc, argv);
     process_sflag(&opt->sflag);
 
@@ -1652,11 +1641,13 @@ process_options(int argc, char **argv, ruby_cmdline_options_t *opt)
 	tree = rb_parser_compile_string(parser, opt->script, opt->e_script, 1);
     }
     else {
-	VALUE f;
+	if (opt->script[0] == '-' && !opt->script[1]) {
+	    forbid_setid("program input from stdin");
+	}
+
 	base_block = toplevel_context(toplevel_binding);
 	rb_parser_set_context(parser, base_block, TRUE);
-	f = open_load_file(script_name, &opt->xflag);
+	tree = load_file(parser, opt->script_name, 1, opt);
-	tree = load_file(parser, opt->script_name, f, 1, opt);
     }
     ruby_set_script_name(opt->script_name);
     if (dump & DUMP_BIT(yydebug)) {
@@ -1713,7 +1704,7 @@ process_options(int argc, char **argv, ruby_cmdline_options_t *opt)
     {
 	VALUE path = Qnil;
 	if (!opt->e_script && strcmp(opt->script, "-")) {
-	    path = rb_realpath_internal(Qnil, script_name, 1);
+	    path = rb_realpath_internal(Qnil, opt->script_name, 1);
 	}
 	base_block = toplevel_context(toplevel_binding);
 	iseq = rb_iseq_new_main(tree, opt->script_name, path, vm_block_iseq(base_block));
@@ -1752,6 +1743,7 @@ struct load_file_arg {
     VALUE parser;
     VALUE fname;
     int script;
+    int xflag;
     ruby_cmdline_options_t *opt;
     VALUE f;
 };
@@ -1769,6 +1761,7 @@ load_file_internal(VALUE argp_v)
     NODE *tree = 0;
     rb_encoding *enc;
     ID set_encoding;
+    int xflag = argp->xflag;
 
     argp->script = 0;
     CONST_ID(set_encoding, "set_encoding");
@@ -1784,9 +1777,11 @@ load_file_internal(VALUE argp_v)
 	enc = rb_ascii8bit_encoding();
 	rb_funcall(f, set_encoding, 1, rb_enc_from_encoding(enc));
 
-	if (opt->xflag) {
+	if (xflag || opt->xflag) {
 	    line_start--;
 	  search_shebang:
+	    forbid_setid("-x");
+	    opt->xflag = FALSE;
 	    while (!NIL_P(line = rb_io_gets(f))) {
 		line_start++;
 		RSTRING_GETMEM(line, str, len);
@@ -1879,8 +1874,7 @@ load_file_internal(VALUE argp_v)
 static VALUE
 open_load_file(VALUE fname_v, int *xflag)
 {
-    const char *fname = (fname_v = rb_str_encode_ospath(fname_v),
+    const char *fname = StringValueCStr(fname_v);
-			 StringValueCStr(fname_v));
     long flen = RSTRING_LEN(fname_v);
     VALUE f;
     int e;
@@ -1981,14 +1975,15 @@ restore_load_file(VALUE arg)
 }
 
 static NODE *
-load_file(VALUE parser, VALUE fname, VALUE f, int script, ruby_cmdline_options_t *opt)
+load_file(VALUE parser, VALUE fname, int script, ruby_cmdline_options_t *opt)
 {
     struct load_file_arg arg;
     arg.parser = parser;
     arg.fname = fname;
     arg.script = script;
     arg.opt = opt;
-    arg.f = f;
+    arg.xflag = 0;
+    arg.f = open_load_file(rb_str_encode_ospath(fname), &arg.xflag);
     return (NODE *)rb_ensure(load_file_internal, (VALUE)&arg,
 			     restore_load_file, (VALUE)&arg);
 }
@@ -2003,15 +1998,17 @@ rb_load_file(const char *fname)
 void *
 rb_load_file_str(VALUE fname_v)
 {
-    return rb_parser_load_file(rb_parser_new(), fname_v);
+    ruby_cmdline_options_t opt;
+
+    return load_file(rb_parser_new(), fname_v, 0, cmdline_options_init(&opt));
 }
 
 void *
 rb_parser_load_file(VALUE parser, VALUE fname_v)
 {
     ruby_cmdline_options_t opt;
-    VALUE f = open_load_file(fname_v, &cmdline_options_init(&opt)->xflag);
+
-    return load_file(parser, fname_v, f, 0, &opt);
+    return load_file(parser, fname_v, 0, cmdline_options_init(&opt));
 }
 
 /*
@@ -2120,7 +2117,7 @@ init_ids(ruby_cmdline_options_t *opt)
 
 #undef forbid_setid
 static void
-forbid_setid(const char *s, const ruby_cmdline_options_t *opt)
+forbid_setid(const char *s, ruby_cmdline_options_t *opt)
 {
     if (opt->setids & 1)
         rb_raise(rb_eSecurityError, "no %s allowed while running setuid", s);

test/ruby/test_rubyoptions.rb

@@ -920,16 +920,4 @@ class TestRubyOptions < Test::Unit::TestCase
       end
     end
   end
-
-  def test_cwd_encoding
-    with_tmpchdir do
-      testdir = "\u30c6\u30b9\u30c8"
-      Dir.mkdir(testdir)
-      Dir.chdir(testdir) do
-        File.write("a.rb", "require './b'")
-        File.write("b.rb", "puts 'ok'")
-        assert_ruby_status([{"RUBYLIB"=>"."}, *%w[-E cp932:utf-8 a.rb]])
-      end
-    end
-  end
 end

util.c

@@ -511,10 +511,7 @@ ruby_getcwd(void)
     char *buf = xmalloc(2);
     strcpy(buf, ".");
 #elif defined HAVE_GETCWD
-# undef RUBY_UNTYPED_DATA_WARNING
-# define RUBY_UNTYPED_DATA_WARNING 0
 # if defined NO_GETCWD_MALLOC
-    VALUE guard = Data_Wrap_Struct((VALUE)0, NULL, RUBY_DEFAULT_FREE, NULL);
     int size = 200;
     char *buf = xmalloc(size);
 
@@ -522,22 +519,17 @@ ruby_getcwd(void)
 	int e = errno;
 	if (e != ERANGE) {
 	    xfree(buf);
-	    DATA_PTR(guard) = NULL;
 	    rb_syserr_fail(e, "getcwd");
 	}
 	size *= 2;
-	DATA_PTR(guard) = buf;
 	buf = xrealloc(buf, size);
     }
 # else
-    VALUE guard = Data_Wrap_Struct((VALUE)0, NULL, free, NULL);
     char *buf, *cwd = getcwd(NULL, 0);
-    DATA_PTR(guard) = cwd;
     if (!cwd) rb_sys_fail("getcwd");
     buf = ruby_strdup(cwd);	/* allocate by xmalloc */
     free(cwd);
 # endif
-    DATA_PTR(RB_GC_GUARD(guard)) = NULL;
 #else
 # ifndef PATH_MAX
 #  define PATH_MAX 8192

version.h

@@ -1,6 +1,6 @@
 #define RUBY_VERSION "2.4.4"
 #define RUBY_RELEASE_DATE "2018-03-17"
-#define RUBY_PATCHLEVEL 261
+#define RUBY_PATCHLEVEL 259
 
 #define RUBY_RELEASE_YEAR 2018
 #define RUBY_RELEASE_MONTH 3

win32/dir.h

@@ -33,7 +33,6 @@ long           rb_w32_telldir(DIR *);
 void           rb_w32_seekdir(DIR *, long);
 void           rb_w32_rewinddir(DIR *);
 void           rb_w32_closedir(DIR *);
-char          *rb_w32_ugetcwd(char *, int);
 
 #define opendir(s)   rb_w32_opendir((s))
 #define readdir(d)   rb_w32_readdir((d), 0)

win32/win32.c

@@ -4654,61 +4654,43 @@ clock_getres(clockid_t clock_id, struct timespec *sp)
 }
 
 /* License: Ruby's */
-static char *
+char *
-w32_getcwd(char *buffer, int size, UINT cp)
+rb_w32_getcwd(char *buffer, int size)
 {
-    WCHAR *p;
+    char *p = buffer;
-    int wlen, len;
+    int len;
 
-    len = GetCurrentDirectoryW(0, NULL);
+    len = GetCurrentDirectory(0, NULL);
     if (!len) {
 	errno = map_errno(GetLastError());
 	return NULL;
     }
 
-    if (buffer && size < len) {
+    if (p) {
-	errno = ERANGE;
-	return NULL;
-    }
-
-    p = ALLOCA_N(WCHAR, len);
-    if (!GetCurrentDirectoryW(len, p)) {
-	errno = map_errno(GetLastError());
-        return NULL;
-    }
-
-    wlen = translate_wchar(p, L'\\', L'/') - p + 1;
-    len = WideCharToMultiByte(cp, 0, p, wlen, NULL, 0, NULL, NULL);
-    if (buffer) {
 	if (size < len) {
 	    errno = ERANGE;
 	    return NULL;
 	}
     }
     else {
-	buffer = malloc(len);
+	p = malloc(len);
-	if (!buffer) {
+	size = len;
+	if (!p) {
 	    errno = ENOMEM;
 	    return NULL;
 	}
     }
-    WideCharToMultiByte(cp, 0, p, wlen, buffer, len, NULL, NULL);
 
-    return buffer;
+    if (!GetCurrentDirectory(size, p)) {
+	errno = map_errno(GetLastError());
+	if (!buffer)
+	    free(p);
+        return NULL;
     }
 
-/* License: Ruby's */
+    translate_char(p, '\\', '/', filecp());
-char *
-rb_w32_getcwd(char *buffer, int size)
-{
-    return w32_getcwd(buffer, size, filecp());
-}
 
-/* License: Ruby's */
+    return p;
-char *
-rb_w32_ugetcwd(char *buffer, int size)
-{
-    return w32_getcwd(buffer, size, CP_UTF8);
 }
 
 /* License: Artistic or GPL */