Merge branch 'pan/unicode_home/OTP-10160' into maint

* pan/unicode_home/OTP-10160:
  Teach release_handler_SUITE about file:native_name_encoding/0
  Add documetation about Unicode in environment
  Make get/putenv and erlexec understand Unicode

20 files changed, 694 insertions, 418 deletions

diff --git a/erts/doc/src/erl.xml b/erts/doc/src/erl.xml
index f8a92e1ec4..8c028e1d14 100644
--- a/erts/doc/src/erl.xml
+++ b/erts/doc/src/erl.xml
@@ -533,7 +533,7 @@
         <p>Force the <c>compressed</c> option on all ETS tables.
               Only intended for test and evaluation.</p>
       </item>
-      <tag><c><![CDATA[+fnl]]></c></tag>
+      <tag><marker id="file_name_encoding"></marker><c><![CDATA[+fnl]]></c></tag>
       <item>
         <p>The VM works with file names as if they are encoded using the ISO-latin-1 encoding, disallowing Unicode characters with codepoints beyond 255. This is default on operating systems that have transparent file naming, i.e. all Unixes except MacOSX.</p>
       </item>
diff --git a/erts/doc/src/erlang.xml b/erts/doc/src/erlang.xml
index e69f223897..248b755969 100644
--- a/erts/doc/src/erlang.xml
+++ b/erts/doc/src/erlang.xml
@@ -3039,8 +3039,11 @@ os_prompt% </pre>
               port process. Both <c>Name</c> and <c>Val</c> must be
               strings. The one exception is <c>Val</c> being the atom
               <c>false</c> (in analogy with <c>os:getenv/1</c>), which
-              removes the environment variable. Not available on
-              VxWorks.</p>
+              removes the environment variable.</p>
+	      <p>If Unicode filename encoding is in effect (see the <seealso
+	      marker="erts:erl#file_name_encoding">erl manual
+	      page</seealso>), the strings (both <c>Name</c> and
+	      <c>Value</c>) may contain characters with codepoints > 255.</p>
           </item>
 	  <tag><c>{args, [ string() ]}</c></tag>
           <item>
diff --git a/erts/emulator/beam/break.c b/erts/emulator/beam/break.c
index 6f5020dc14..93aa2fb8d0 100644
--- a/erts/emulator/beam/break.c
+++ b/erts/emulator/beam/break.c
@@ -678,7 +678,7 @@ erl_crash_dump_v(char *file, int line, char* fmt, va_list args)
 
     erts_sys_prepare_crash_dump();
 
-    if (erts_sys_getenv("ERL_CRASH_DUMP",&dumpnamebuf[0],&dumpnamebufsize) != 0)
+    if (erts_sys_getenv_raw("ERL_CRASH_DUMP",&dumpnamebuf[0],&dumpnamebufsize) != 0)
 	dumpname = "erl_crash.dump";
     else
 	dumpname = &dumpnamebuf[0];
diff --git a/erts/emulator/beam/dist.c b/erts/emulator/beam/dist.c
index 01fd63d5d9..025258e8de 100644
--- a/erts/emulator/beam/dist.c
+++ b/erts/emulator/beam/dist.c
@@ -968,16 +968,16 @@ erts_dsig_send_group_leader(ErtsDSigData *dsdp, Eterm leader, Eterm remote)
 #define VALGRIND_PRINTF_XML VALGRIND_PRINTF
 #endif
 
-#  define PURIFY_MSG(msg)                                                \
-    do {								 \
-	char buf__[1]; size_t bufsz__ = sizeof(buf__);			 \
-	if (erts_sys_getenv("VALGRIND_LOG_XML", buf__, &bufsz__) >= 0) { \
-	    VALGRIND_PRINTF_XML("<erlang_error_log>"			 \
-			    "%s, line %d: %s</erlang_error_log>\n",	 \
-			    __FILE__, __LINE__, msg);			 \
-	} else {							 \
-	    VALGRIND_PRINTF("%s, line %d: %s", __FILE__, __LINE__, msg); \
-	}								 \
+#  define PURIFY_MSG(msg)                                                    \
+    do {								     \
+	char buf__[1]; size_t bufsz__ = sizeof(buf__);			     \
+	if (erts_sys_getenv_raw("VALGRIND_LOG_XML", buf__, &bufsz__) >= 0) { \
+	    VALGRIND_PRINTF_XML("<erlang_error_log>"			     \
+			    "%s, line %d: %s</erlang_error_log>\n",	     \
+			    __FILE__, __LINE__, msg);			     \
+	} else {							     \
+	    VALGRIND_PRINTF("%s, line %d: %s", __FILE__, __LINE__, msg);     \
+	}								     \
     } while (0)
 #else
 #  define PURIFY_MSG(msg)
diff --git a/erts/emulator/beam/erl_bif_info.c b/erts/emulator/beam/erl_bif_info.c
index f56b00287f..45dc5fb11c 100755
--- a/erts/emulator/beam/erl_bif_info.c
+++ b/erts/emulator/beam/erl_bif_info.c
@@ -1697,7 +1697,7 @@ static int check_if_xml(void)
 {
     char buf[1];
     size_t bufsz = sizeof(buf);
-    return erts_sys_getenv("VALGRIND_LOG_XML", buf, &bufsz) >= 0;
+    return erts_sys_getenv_raw("VALGRIND_LOG_XML", buf, &bufsz) >= 0;
 }
 #else
 #define check_if_xml() 0
diff --git a/erts/emulator/beam/erl_bif_os.c b/erts/emulator/beam/erl_bif_os.c
index 58d48199fa..d076640a8b 100644
--- a/erts/emulator/beam/erl_bif_os.c
+++ b/erts/emulator/beam/erl_bif_os.c
@@ -71,15 +71,13 @@ BIF_RETTYPE os_getenv_0(BIF_ALIST_0)
     Eterm* hp;
     Eterm ret;
     Eterm str;
-    int len;
 
     init_getenv_state(&state);
 
     ret = NIL;
     while ((cp = getenv_string(&state)) != NULL) {
-	len = strlen(cp);
-	hp = HAlloc(BIF_P, len*2+2);
-	str = buf_to_intlist(&hp, cp, len, NIL);
+	str = erts_convert_native_to_filename(BIF_P,(byte *)cp);
+	hp = HAlloc(BIF_P, 2);
 	ret = CONS(hp, str, ret);
     }
 
@@ -88,32 +86,30 @@ BIF_RETTYPE os_getenv_0(BIF_ALIST_0)
     return ret;
 }
 
-
+#define STATIC_BUF_SIZE 1024
 BIF_RETTYPE os_getenv_1(BIF_ALIST_1)
 {
     Process* p = BIF_P;
-    Eterm key = BIF_ARG_1;
     Eterm str;
-    int len, res;
+    Sint len;
+    int res;
     char *key_str, *val;
-    char buf[1024];
+    char buf[STATIC_BUF_SIZE];
     size_t val_size = sizeof(buf);
 
-    len = is_string(key);
-    if (!len) {
+    key_str = erts_convert_filename_to_native(BIF_ARG_1,buf,STATIC_BUF_SIZE,
+					      ERTS_ALC_T_TMP,1,0,&len);
+
+    if (!key_str) {
 	BIF_ERROR(p, BADARG);
     }
-    /* Leave at least one byte in buf for value */
-    key_str = len < sizeof(buf)-2 ? &buf[0] : erts_alloc(ERTS_ALC_T_TMP, len+1);
-    if (intlist_to_buf(key, key_str, len) != len)
-	erl_exit(1, "%s:%d: Internal error\n", __FILE__, __LINE__);
-    key_str[len] = '\0';
 
     if (key_str != &buf[0])
 	val = &buf[0];
     else {
-	val_size -= len + 1;
-	val = &buf[len + 1];
+	/* len includes zero byte */
+	val_size -= len;
+	val = &buf[len];
     }
     res = erts_sys_getenv(key_str, val, &val_size);
 
@@ -121,7 +117,6 @@ BIF_RETTYPE os_getenv_1(BIF_ALIST_1)
     no_var:
 	str = am_false;
     } else {
-	Eterm* hp;
 	if (res > 0) {
 	    val = erts_alloc(ERTS_ALC_T_TMP, val_size);
 	    while (1) {
@@ -134,9 +129,7 @@ BIF_RETTYPE os_getenv_1(BIF_ALIST_1)
 		    val = erts_realloc(ERTS_ALC_T_TMP, val, val_size);
 	    }
 	}
-	if (val_size)
-	    hp = HAlloc(p, val_size*2);
-	str = buf_to_intlist(&hp, val, val_size, NIL);
+	str = erts_convert_native_to_filename(p,(byte *)val);
     }
     if (key_str != &buf[0])
 	erts_free(ERTS_ALC_T_TMP, key_str);
@@ -147,46 +140,43 @@ BIF_RETTYPE os_getenv_1(BIF_ALIST_1)
 
 BIF_RETTYPE os_putenv_2(BIF_ALIST_2)
 {
-    Process* p = BIF_P;
-    Eterm key = BIF_ARG_1;
-    Eterm value = BIF_ARG_2;
-    char def_buf[1024];
-    char *buf = NULL;
-    int sep_ix, i, key_len, value_len, tot_len;
-    key_len = is_string(key);
-    if (!key_len) {
-    error:
-	if (buf)
-	    erts_free(ERTS_ALC_T_TMP, (void *) buf);
-	BIF_ERROR(p, BADARG);
+    char def_buf_key[STATIC_BUF_SIZE];
+    char def_buf_value[STATIC_BUF_SIZE];
+    char *key_buf, *value_buf;
+
+    key_buf = erts_convert_filename_to_native(BIF_ARG_1,def_buf_key,
+					      STATIC_BUF_SIZE,
+					      ERTS_ALC_T_TMP,0,0,NULL);
+    if (!key_buf) {
+	BIF_ERROR(BIF_P, BADARG);
     }
-    if (is_nil(value))
-	value_len = 0;
-    else {
-	value_len = is_string(value);
-	if (!value_len)
-	    goto error;
+    value_buf = erts_convert_filename_to_native(BIF_ARG_2,def_buf_value,
+						STATIC_BUF_SIZE,
+						ERTS_ALC_T_TMP,1,0,
+						NULL);
+    if (!value_buf) {
+	if (key_buf != def_buf_key) {
+	    erts_free(ERTS_ALC_T_TMP, key_buf);
+	}
+	BIF_ERROR(BIF_P, BADARG);
+    }
+	    
+
+    if (erts_sys_putenv(key_buf, value_buf)) {
+	if (key_buf != def_buf_key) {
+	    erts_free(ERTS_ALC_T_TMP, key_buf);
+	}
+	if (value_buf != def_buf_value) {
+	    erts_free(ERTS_ALC_T_TMP, value_buf);
+	}
+	BIF_ERROR(BIF_P, BADARG);
+    }
+    if (key_buf != def_buf_key) {
+	erts_free(ERTS_ALC_T_TMP, key_buf);
     }
-    tot_len = key_len + 1 + value_len + 1;
-    if (tot_len <= sizeof(def_buf))
-	buf = &def_buf[0];
-    else
-	buf = erts_alloc(ERTS_ALC_T_TMP, tot_len);
-    i = intlist_to_buf(key, buf, key_len);
-    if (i != key_len)
-	erl_exit(1, "%s:%d: Internal error\n", __FILE__, __LINE__);	
-    sep_ix = i;
-    buf[i++] = '=';
-    if (is_not_nil(value))
-	i += intlist_to_buf(value, &buf[i], value_len);
-    if (i != key_len + 1 + value_len)
-	erl_exit(1, "%s:%d: Internal error\n", __FILE__, __LINE__);	
-    buf[i] = '\0';
-    if (erts_sys_putenv(buf, sep_ix)) {
-	goto error;
+    if (value_buf != def_buf_value) {
+	erts_free(ERTS_ALC_T_TMP, value_buf);
     }
-    if (buf != &def_buf[0])
-	erts_free(ERTS_ALC_T_TMP, (void *) buf);
     BIF_RET(am_true);
 }
 
diff --git a/erts/emulator/beam/erl_bif_port.c b/erts/emulator/beam/erl_bif_port.c
index 2a1b01b107..f9009166c0 100644
--- a/erts/emulator/beam/erl_bif_port.c
+++ b/erts/emulator/beam/erl_bif_port.c
@@ -718,7 +718,7 @@ open_port(Process* p, Eterm name, Eterm settings, int *err_nump)
 		} else if (option == am_arg0) {
 		    char *a0;
 
-		    if ((a0 = erts_convert_filename_to_native(*tp, ERTS_ALC_T_TMP, 1)) == NULL) {
+		    if ((a0 = erts_convert_filename_to_native(*tp, NULL, 0, ERTS_ALC_T_TMP, 1, 1, NULL)) == NULL) {
 			goto badarg;
 		    }
 		    if (opts.argv == NULL) {
@@ -845,7 +845,7 @@ open_port(Process* p, Eterm name, Eterm settings, int *err_nump)
 		goto badarg;
 	    }
 	    name = tp[1];
-	    if ((name_buf = erts_convert_filename_to_native(name,ERTS_ALC_T_TMP,0)) == NULL) {
+	    if ((name_buf = erts_convert_filename_to_native(name, NULL, 0, ERTS_ALC_T_TMP,0,1, NULL)) == NULL) {
 		goto badarg;
 	    }
 	    opts.spawn_type = ERTS_SPAWN_EXECUTABLE;
@@ -909,7 +909,7 @@ open_port(Process* p, Eterm name, Eterm settings, int *err_nump)
 	    }
 	    opts.wd = (char *) dir;
 	} else {
-	    if ((opts.wd = erts_convert_filename_to_native(edir,ERTS_ALC_T_TMP,0)) == NULL) {
+	    if ((opts.wd = erts_convert_filename_to_native(edir, NULL, 0, ERTS_ALC_T_TMP,0,1,NULL)) == NULL) {
 		goto badarg;
 	    }
 	}
@@ -1000,7 +1000,7 @@ static char **convert_args(Eterm l)
     pp[i++] = erts_default_arg0;
     while (is_list(l)) {
 	str = CAR(list_val(l));
-	if ((b = erts_convert_filename_to_native(str,ERTS_ALC_T_TMP,1)) == NULL) {
+	if ((b = erts_convert_filename_to_native(str,NULL,0,ERTS_ALC_T_TMP,1,1,NULL)) == NULL) {
 	    int j;
 	    for (j = 1; j < i; ++j)
 		erts_free(ERTS_ALC_T_TMP, pp[j]);
@@ -1035,8 +1035,9 @@ static byte* convert_environment(Process* p, Eterm env)
     Eterm* hp;
     Uint heap_size;
     int n;
-    Uint size;
+    Sint size;
     byte* bytes;
+    int encoding = erts_get_native_filename_encoding();
 
     if ((n = list_length(env)) < 0) {
 	return NULL;
@@ -1079,7 +1080,8 @@ static byte* convert_environment(Process* p, Eterm env)
     if (is_not_nil(env)) {
 	goto done;
     }
-    if (erts_iolist_size(all, &size)) {
+
+    if ((size = erts_native_filename_need(all,encoding)) < 0) {
 	goto done;
     }
 
@@ -1087,7 +1089,7 @@ static byte* convert_environment(Process* p, Eterm env)
      * Put the result in a binary (no risk for a memory leak that way).
      */
     (void) erts_new_heap_binary(p, NULL, size, &bytes);
-    io_list_to_buf(all, (char*)bytes, size);
+    erts_native_filename_put(all,encoding,bytes);
 
  done:
     erts_free(ERTS_ALC_T_TMP, temp_heap);
diff --git a/erts/emulator/beam/erl_init.c b/erts/emulator/beam/erl_init.c
index 02164728fe..1eb3dba240 100644
--- a/erts/emulator/beam/erl_init.c
+++ b/erts/emulator/beam/erl_init.c
@@ -623,7 +623,7 @@ early_init(int *argc, char **argv) /*
 
     envbufsz = sizeof(envbuf);
 
-    /* erts_sys_getenv() not initialized yet; need erts_sys_getenv__() */
+    /* erts_sys_getenv(_raw)() not initialized yet; need erts_sys_getenv__() */
     if (erts_sys_getenv__("ERL_THREAD_POOL_SIZE", envbuf, &envbufsz) == 0)
 	erts_async_max_threads = atoi(envbuf);
     else
@@ -846,13 +846,13 @@ erl_start(int argc, char **argv)
     int ncpu = early_init(&argc, argv);
 
     envbufsz = sizeof(envbuf);
-    if (erts_sys_getenv(ERL_MAX_ETS_TABLES_ENV, envbuf, &envbufsz) == 0)
+    if (erts_sys_getenv_raw(ERL_MAX_ETS_TABLES_ENV, envbuf, &envbufsz) == 0)
 	user_requested_db_max_tabs = atoi(envbuf);
     else
 	user_requested_db_max_tabs = 0;
 
     envbufsz = sizeof(envbuf);
-    if (erts_sys_getenv("ERL_FULLSWEEP_AFTER", envbuf, &envbufsz) == 0) {
+    if (erts_sys_getenv_raw("ERL_FULLSWEEP_AFTER", envbuf, &envbufsz) == 0) {
 	Uint16 max_gen_gcs = atoi(envbuf);
 	erts_smp_atomic32_set_nob(&erts_max_gen_gcs,
 				  (erts_aint32_t) max_gen_gcs);
diff --git a/erts/emulator/beam/erl_unicode.c b/erts/emulator/beam/erl_unicode.c
index 6d5eae73b0..127db4d4f6 100644
--- a/erts/emulator/beam/erl_unicode.c
+++ b/erts/emulator/beam/erl_unicode.c
@@ -2027,12 +2027,14 @@ BIF_RETTYPE binary_to_existing_atom_2(BIF_ALIST_2)
  * string routines, that will certainly fail on some OS.
  */
 
-char *erts_convert_filename_to_native(Eterm name, ErtsAlcType_t alloc_type, int allow_empty)
+char *erts_convert_filename_to_native(Eterm name, char *statbuf, size_t statbuf_size, ErtsAlcType_t alloc_type, int allow_empty, int allow_atom, Sint *used)
 {
     int encoding = erts_get_native_filename_encoding();
     char* name_buf = NULL;
 
-    if (is_atom(name) || is_list(name) || (allow_empty && is_nil(name))) {
+    if ((allow_atom && is_atom(name)) || 
+	is_list(name) || 
+	(allow_empty && is_nil(name))) {
 	Sint need;
 	if ((need = erts_native_filename_need(name,encoding)) < 0) {
 	    return NULL;
@@ -2042,7 +2044,13 @@ char *erts_convert_filename_to_native(Eterm name, ErtsAlcType_t alloc_type, int
 	} else {
 	    ++need;
 	}
-	name_buf = (char *) erts_alloc(alloc_type, need);
+	if (used) 
+	    *used = (Sint) need;
+	if (need > statbuf_size) {
+	    name_buf = (char *) erts_alloc(alloc_type, need);
+	} else {
+	    name_buf = statbuf;
+	}
 	erts_native_filename_put(name,encoding,(byte *)name_buf); 
 	name_buf[need-1] = 0;
 	if (encoding == ERL_FILENAME_WIN_WCHAR) {
@@ -2058,14 +2066,26 @@ char *erts_convert_filename_to_native(Eterm name, ErtsAlcType_t alloc_type, int
 	bytes = erts_get_aligned_binary_bytes(name, &temp_alloc);
 	if (encoding != ERL_FILENAME_WIN_WCHAR) {
 	    /*Add 0 termination only*/
-	    name_buf = (char *) erts_alloc(alloc_type, size+1);
+	    if (used) 
+		*used = (Sint) size+1;
+	    if (size+1 > statbuf_size) {
+		name_buf = (char *) erts_alloc(alloc_type, size+1);
+	    } else {
+		name_buf = statbuf;
+	    }
 	    memcpy(name_buf,bytes,size);
 	    name_buf[size]=0;
 	} else if (erts_analyze_utf8(bytes,size,&err_pos,&num_chars,NULL) != ERTS_UTF8_OK || 
 		   erts_get_user_requested_filename_encoding() ==  ERL_FILENAME_LATIN1) {
 	    byte *p;
 	    /* What to do now? Maybe latin1, so just take byte for byte instead */
-	    name_buf = (char *) erts_alloc(alloc_type, (size+1)*2);
+	    if (used) 
+		*used = (Sint) (size+1)*2;
+	    if ((size+1)*2 > statbuf_size) {
+		name_buf = (char *) erts_alloc(alloc_type, (size+1)*2);
+	    } else {
+		name_buf = statbuf;
+	    }
 	    p = (byte *) name_buf;
 	    while (size--) {
 		*p++ = *bytes++;
@@ -2074,7 +2094,13 @@ char *erts_convert_filename_to_native(Eterm name, ErtsAlcType_t alloc_type, int
 	    *p++ = 0;
 	    *p++ = 0;
 	} else { /* WIN_WCHAR and valid UTF8 */
-	    name_buf = (char *) erts_alloc(alloc_type, (num_chars+1)*2);
+	    if (used) 
+		*used = (Sint) (num_chars+1)*2;
+	    if ((num_chars+1)*2 > statbuf_size) {
+		name_buf = (char *) erts_alloc(alloc_type, (num_chars+1)*2);
+	    } else {
+		name_buf = statbuf;
+	    }
 	    erts_copy_utf8_to_utf16_little((byte *) name_buf, bytes, num_chars);
 	    name_buf[num_chars*2] = 0;
 	    name_buf[num_chars*2+1] = 0;
@@ -2086,6 +2112,71 @@ char *erts_convert_filename_to_native(Eterm name, ErtsAlcType_t alloc_type, int
     return name_buf;
 }
 
+static int filename_len_16bit(byte *str) 
+{
+    byte *p = str;
+    while(*p != '\0' || p[1] != '\0') {
+	p += 2;
+    }
+    return (p - str);
+}
+Eterm erts_convert_native_to_filename(Process *p, byte *bytes)
+{
+    Uint size,num_chars;
+    Eterm *hp;
+    byte *err_pos;
+    Uint num_built; /* characters */
+    Uint num_eaten; /* bytes */
+    Eterm ret;
+    int mac = 0;
+
+    switch (erts_get_native_filename_encoding()) {
+    case ERL_FILENAME_LATIN1:
+	goto noconvert;
+    case ERL_FILENAME_UTF8_MAC:
+	mac = 1;
+    case ERL_FILENAME_UTF8:
+	size = strlen((char *) bytes);
+	if (erts_analyze_utf8(bytes,size,&err_pos,&num_chars,NULL) != ERTS_UTF8_OK) {
+	    goto noconvert;
+	}
+	num_built = 0;
+	num_eaten = 0;
+	if (mac) {
+	    ret = do_utf8_to_list_normalize(p, num_chars, bytes, size);
+	} else {
+	    ret = do_utf8_to_list(p, num_chars, bytes, size, num_chars, &num_built, &num_eaten, NIL);
+	} 
+	return ret;
+    case ERL_FILENAME_WIN_WCHAR:
+	size=filename_len_16bit(bytes);
+	if ((size % 2) != 0) { /* Panic fixup to avoid crashing the emulator */
+	    size--;
+	    hp = HAlloc(p, size+2);
+	    ret = CONS(hp,make_small((Uint) bytes[size]),NIL);
+	    hp += 2;
+	} else {
+	    hp = HAlloc(p, size);
+	    ret = NIL;
+	}
+	bytes += size-1;
+	while (size > 0) {
+	    Uint x = ((Uint) *bytes--) << 8;
+	    x |= ((Uint) *bytes--);
+	    size -= 2;
+	    ret = CONS(hp,make_small(x),ret);
+	    hp += 2;
+	}	    
+	return ret;
+    default:
+	goto noconvert;
+    }
+ noconvert:
+    size = strlen((char *) bytes);
+    hp = HAlloc(p, 2 * size);
+    return erts_bin_bytes_to_list(NIL, hp, bytes, size, 0);
+}
+
 
 Sint erts_native_filename_need(Eterm ioterm, int encoding) 
 {
@@ -2619,3 +2710,4 @@ BIF_RETTYPE file_native_name_encoding_0(BIF_ALIST_0)
 	BIF_RET(am_undefined);
     }
 }
+
diff --git a/erts/emulator/beam/global.h b/erts/emulator/beam/global.h
index 1b15c4ac3b..dbf95f5bd7 100755
--- a/erts/emulator/beam/global.h
+++ b/erts/emulator/beam/global.h
@@ -1386,8 +1386,12 @@ Sint erts_native_filename_need(Eterm ioterm, int encoding);
 void erts_copy_utf8_to_utf16_little(byte *target, byte *bytes, int num_chars);
 int erts_analyze_utf8(byte *source, Uint size, 
 			byte **err_pos, Uint *num_chars, int *left);
-char *erts_convert_filename_to_native(Eterm name, ErtsAlcType_t alloc_type, int allow_empty);
-
+char *erts_convert_filename_to_native(Eterm name, char *statbuf, 
+				      size_t statbuf_size, 
+				      ErtsAlcType_t alloc_type, 
+				      int allow_empty, int allow_atom,
+				      Sint *used /* out */);
+Eterm erts_convert_native_to_filename(Process *p, byte *bytes);
 #define ERTS_UTF8_OK 0
 #define ERTS_UTF8_INCOMPLETE 1
 #define ERTS_UTF8_ERROR 2
diff --git a/erts/emulator/beam/io.c b/erts/emulator/beam/io.c
index 204bff299e..35b194f927 100644
--- a/erts/emulator/beam/io.c
+++ b/erts/emulator/beam/io.c
@@ -1314,7 +1314,7 @@ void init_io(void)
 
     pdl_init();
 
-    if (erts_sys_getenv("ERL_MAX_PORTS", maxports, &maxportssize) == 0) 
+    if (erts_sys_getenv_raw("ERL_MAX_PORTS", maxports, &maxportssize) == 0) 
 	erts_max_ports = atoi(maxports);
     else
 	erts_max_ports = sys_max_files();
@@ -5227,11 +5227,11 @@ int null_func(void)
 int
 erl_drv_putenv(char *key, char *value)
 {
-    return erts_write_env(key, value);
+    return erts_sys_putenv_raw(key, value);
 }
 
 int
 erl_drv_getenv(char *key, char *value, size_t *value_size)
 {
-    return erts_sys_getenv(key, value, value_size);
+    return erts_sys_getenv_raw(key, value, value_size);
 }
diff --git a/erts/emulator/beam/sys.h b/erts/emulator/beam/sys.h
index 7b2bb81f62..2406c52f14 100644
--- a/erts/emulator/beam/sys.h
+++ b/erts/emulator/beam/sys.h
@@ -703,18 +703,21 @@ int sys_double_to_chars(double, char*);
 void sys_get_pid(char *);
 
 /* erts_sys_putenv() returns, 0 on success and a value != 0 on failure. */
-int erts_sys_putenv(char *key_value, int sep_ix);
+int erts_sys_putenv(char *key, char *value);
+/* Simple variant used from drivers, raw eightbit interface */
+int erts_sys_putenv_raw(char *key, char *value);
 /* erts_sys_getenv() returns 0 on success (length of value string in
    *size), a value > 0 if value buffer is too small (*size is set to needed
    size), and a value < 0 on failure. */
 int erts_sys_getenv(char *key, char *value, size_t *size);
+/* Simple variant used from drivers, raw eightbit interface */
+int erts_sys_getenv_raw(char *key, char *value, size_t *size);
 /* erts_sys_getenv__() is only allowed to be used in early init phase */
 int erts_sys_getenv__(char *key, char *value, size_t *size);
 
 /* Easier to use, but not as efficient, environment functions */
 char *erts_read_env(char *key);
 void erts_free_read_env(void *value);
-int erts_write_env(char *key, char *value);
 
 /* utils.c */
 
diff --git a/erts/emulator/beam/utils.c b/erts/emulator/beam/utils.c
index a36d15204e..bd708ceee6 100644
--- a/erts/emulator/beam/utils.c
+++ b/erts/emulator/beam/utils.c
@@ -3409,7 +3409,7 @@ erts_read_env(char *key)
     char *value = erts_alloc(ERTS_ALC_T_TMP, value_len);
     int res;
     while (1) {
-	res = erts_sys_getenv(key, value, &value_len);
+	res = erts_sys_getenv_raw(key, value, &value_len);
 	if (res <= 0)
 	    break;
 	value = erts_realloc(ERTS_ALC_T_TMP, value, value_len);
@@ -3428,28 +3428,6 @@ erts_free_read_env(void *value)
 	erts_free(ERTS_ALC_T_TMP, value);
 }
 
-int
-erts_write_env(char *key, char *value)
-{
-    int ix, res;
-    size_t key_len = sys_strlen(key), value_len = sys_strlen(value);
-    char *key_value = erts_alloc_fnf(ERTS_ALC_T_TMP,
-				     key_len + 1 + value_len + 1);
-    if (!key_value) {
-	errno = ENOMEM;
-	return -1;
-    }
-    sys_memcpy((void *) key_value, (void *) key, key_len);
-    ix = key_len;
-    key_value[ix++] = '=';
-    sys_memcpy((void *) key_value, (void *) value, value_len);
-    ix += value_len;
-    key_value[ix] = '\0';
-    res = erts_sys_putenv(key_value, key_len);
-    erts_free(ERTS_ALC_T_TMP, key_value);
-    return res;
-}
-
 /*
  * To be used to silence unused result warnings, but do not abuse it.
  */
diff --git a/erts/emulator/sys/unix/sys.c b/erts/emulator/sys/unix/sys.c
index bf69f3bf90..0e8395ea8a 100644
--- a/erts/emulator/sys/unix/sys.c
+++ b/erts/emulator/sys/unix/sys.c
@@ -551,7 +551,7 @@ erl_sys_init(void)
     size_t bindirsz = sizeof(bindir);
     Uint csp_path_sz;
 
-    res = erts_sys_getenv("BINDIR", bindir, &bindirsz);
+    res = erts_sys_getenv_raw("BINDIR", bindir, &bindirsz);
     if (res != 0) {
 	if (res < 0)
 	    erl_exit(-1,
@@ -708,7 +708,7 @@ prepare_crash_dump(void)
     }
 
     envsz = sizeof(env);
-    i = erts_sys_getenv("ERL_CRASH_DUMP_NICE", env, &envsz);
+    i = erts_sys_getenv_raw("ERL_CRASH_DUMP_NICE", env, &envsz);
     if (i >= 0) {
 	int nice_val;
 	nice_val = i != 0 ? 0 : atoi(env);
@@ -719,7 +719,7 @@ prepare_crash_dump(void)
     }
     
     envsz = sizeof(env);
-    i = erts_sys_getenv("ERL_CRASH_DUMP_SECONDS", env, &envsz);
+    i = erts_sys_getenv_raw("ERL_CRASH_DUMP_SECONDS", env, &envsz);
     if (i >= 0) {
 	unsigned sec;
 	sec = (unsigned) i != 0 ? 0 : atoi(env);
@@ -1356,9 +1356,9 @@ static ErlDrvData spawn_start(ErlDrvPort port_num, char* name, SysDriverOpts* op
     int no_vfork;
     size_t no_vfork_sz = sizeof(no_vfork);
 
-    no_vfork = (erts_sys_getenv("ERL_NO_VFORK",
-				(char *) &no_vfork,
-				&no_vfork_sz) >= 0);
+    no_vfork = (erts_sys_getenv_raw("ERL_NO_VFORK",
+				    (char *) &no_vfork,
+				    &no_vfork_sz) >= 0);
 #endif
 
     switch (opts->read_write) {
@@ -2362,21 +2362,31 @@ void sys_get_pid(char *buffer){
 }
 
 int
-erts_sys_putenv(char *buffer, int sep_ix)
+erts_sys_putenv_raw(char *key, char *value) {
+    return erts_sys_putenv(key, value);
+}
+int
+erts_sys_putenv(char *key, char *value)
 {
     int res;
     char *env;
+    Uint need = strlen(key) + strlen(value) + 2;
+
 #ifdef HAVE_COPYING_PUTENV
-    env = buffer;
+    env = erts_alloc(ERTS_ALC_T_TMP, need);
 #else
-    Uint sz = strlen(buffer)+1;
-    env = erts_alloc(ERTS_ALC_T_PUTENV_STR, sz);
-    erts_smp_atomic_add_nob(&sys_misc_mem_sz, sz);
-    strcpy(env,buffer);
+    env = erts_alloc(ERTS_ALC_T_PUTENV_STR, need);
+    erts_smp_atomic_add_nob(&sys_misc_mem_sz, need);
 #endif
+    strcpy(env,key);
+    strcat(env,"=");
+    strcat(env,value);
     erts_smp_rwmtx_rwlock(&environ_rwmtx);
     res = putenv(env);
     erts_smp_rwmtx_rwunlock(&environ_rwmtx);
+#ifdef HAVE_COPYING_PUTENV
+    erts_free(ERTS_ALC_T_TMP, env);
+#endif
     return res;
 }
 
@@ -2403,6 +2413,11 @@ erts_sys_getenv__(char *key, char *value, size_t *size)
 }
 
 int
+erts_sys_getenv_raw(char *key, char *value, size_t *size) {
+    return erts_sys_getenv(key, value, size);
+}
+
+int
 erts_sys_getenv(char *key, char *value, size_t *size)
 {
     int res;
@@ -3001,7 +3016,7 @@ erl_sys_args(int* argc, char** argv)
     if (erts_use_kernel_poll) {
 	char no_kp[10];
 	size_t no_kp_sz = sizeof(no_kp);
-	int res = erts_sys_getenv("ERL_NO_KERNEL_POLL", no_kp, &no_kp_sz);
+	int res = erts_sys_getenv_raw("ERL_NO_KERNEL_POLL", no_kp, &no_kp_sz);
 	if (res > 0
 	    || (res == 0
 		&& sys_strcmp("false", no_kp) != 0
diff --git a/erts/emulator/sys/win32/erl_win_sys.h b/erts/emulator/sys/win32/erl_win_sys.h
index 03298a6c54..1e7b555f42 100644
--- a/erts/emulator/sys/win32/erl_win_sys.h
+++ b/erts/emulator/sys/win32/erl_win_sys.h
@@ -171,8 +171,8 @@ extern clock_t sys_times(SysTimes *buffer);
 extern char *win_build_environment(char *);
 
 typedef struct {
-    char *environment_strings;
-    char *next_string;
+    WCHAR *environment_strings;
+    WCHAR *next_string;
 } GETENV_STATE;
 
 void erts_sys_env_init(void);
diff --git a/erts/emulator/sys/win32/sys.c b/erts/emulator/sys/win32/sys.c
index acbbfc2ce9..29e2749800 100755
--- a/erts/emulator/sys/win32/sys.c
+++ b/erts/emulator/sys/win32/sys.c
@@ -1204,9 +1204,7 @@ spawn_start(ErlDrvPort port_num, char* name, SysDriverOpts* opts)
      */
 
     DEBUGF(("Spawning \"%s\"\n", name));
-    envir = win_build_environment(envir); /* Still an ansi environment, could be
-					     converted to unicode for spawn_executable, but
-					     that is not done (yet) */ 
+    envir = win_build_environment(envir); /* Always a unicode environment */ 
     ok = create_child_process(name, 
 			    hChildStdin, 
 			    hChildStdout,
@@ -1485,7 +1483,8 @@ create_child_process
 			    NULL, 
 			    NULL, 
 			    TRUE, 
-			    createFlags | staticCreateFlags, 
+			    createFlags | staticCreateFlags | 
+			    CREATE_UNICODE_ENVIRONMENT, 
 			    env, 
 			    wd, 
 			    &siStartInfo, 
@@ -1613,7 +1612,8 @@ create_child_process
 			    NULL, 
 			    NULL, 
 			    TRUE, 
-			    createFlags | staticCreateFlags, 
+			    createFlags | staticCreateFlags | 
+			    CREATE_UNICODE_ENVIRONMENT, 
 			    env, 
 			    (WCHAR *) wd, 
 			    &siStartInfo, 
diff --git a/erts/emulator/sys/win32/sys_env.c b/erts/emulator/sys/win32/sys_env.c
index 064745d418..658a77c824 100644
--- a/erts/emulator/sys/win32/sys_env.c
+++ b/erts/emulator/sys/win32/sys_env.c
@@ -1,271 +1,299 @@
-/*
- * %CopyrightBegin%
- *
- * Copyright Ericsson AB 2002-2011. All Rights Reserved.
- *
- * The contents of this file are subject to the Erlang Public License,
- * Version 1.1, (the "License"); you may not use this file except in
- * compliance with the License. You should have received a copy of the
- * Erlang Public License along with this software. If not, it can be
- * retrieved online at http://www.erlang.org/.
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * %CopyrightEnd%
- */
-
-#ifdef HAVE_CONFIG_H
-#  include "config.h"
-#endif
-
-#include "sys.h"
-#include "erl_sys_driver.h"
-#include "erl_alloc.h"
-
-static char* merge_environment(char *current, char *add);
-static char* arg_to_env(char **arg);
-static char** env_to_arg(char *env);
-static char** find_arg(char **arg, char *str);
-static int compare(const void *a, const void *b);
-
-static erts_smp_rwmtx_t environ_rwmtx;
-
-void
-erts_sys_env_init(void)
-{
-    erts_smp_rwmtx_init(&environ_rwmtx, "environ");
-}
-
-int
-erts_sys_putenv(char *key_value, int sep_ix)
-{
-    int res;
-    char sep = key_value[sep_ix];
-    ASSERT(sep == '=');
-    key_value[sep_ix] = '\0';
-    erts_smp_rwmtx_rwlock(&environ_rwmtx);
-    res = (SetEnvironmentVariable((LPCTSTR) key_value,
-				  (LPCTSTR) &key_value[sep_ix+1]) ? 0 : 1);
-    erts_smp_rwmtx_rwunlock(&environ_rwmtx);
-    key_value[sep_ix] = sep;
-    return res;
-}
-
-int
-erts_sys_getenv__(char *key, char *value, size_t *size)
-{
-    size_t req_size = 0;
-    int res = 0;
-    DWORD new_size;
-
-    SetLastError(0);
-    new_size = GetEnvironmentVariable((LPCTSTR) key,
-				      (LPTSTR) value,
-				      (DWORD) *size);
-    res = !new_size && GetLastError() == ERROR_ENVVAR_NOT_FOUND ? -1 : 0;
-    if (res < 0)
-	return res;
-    res = new_size > *size ? 1 : 0;
-    *size = new_size;
-    return res;
-}
-
-int
-erts_sys_getenv(char *key, char *value, size_t *size)
-{
-    int res;
-    erts_smp_rwmtx_rlock(&environ_rwmtx);
-    res = erts_sys_getenv__(key, value, size);
-    erts_smp_rwmtx_runlock(&environ_rwmtx);
-    return res;
-}
-
-struct win32_getenv_state {
-    char *env;
-    char *next;
-};
-
-
-void init_getenv_state(GETENV_STATE *state)
-{
-    erts_smp_rwmtx_rlock(&environ_rwmtx);
-    state->environment_strings = (char *) GetEnvironmentStrings();
-    state->next_string = state->environment_strings;
-}
-
-char *getenv_string(GETENV_STATE *state)
-{
-    ERTS_SMP_LC_ASSERT(erts_smp_lc_rwmtx_is_rlocked(&environ_rwmtx));
-    if (state->next_string[0] == '\0')
-	return NULL;
-    else {
-	char *res = state->next_string;
-	state->next_string += sys_strlen(res) + 1;
-	return res;
-    }
-}
-
-void fini_getenv_state(GETENV_STATE *state)
-{
-    FreeEnvironmentStrings(state->environment_strings);
-    state->environment_strings = state->next_string = NULL;
-    erts_smp_rwmtx_runlock(&environ_rwmtx);
-}
-
-char*
-win_build_environment(char* new_env)
-{
-    if (new_env == NULL) {
-	return NULL;
-    } else {
-	char *tmp, *merged;
-	
-	erts_smp_rwmtx_rlock(&environ_rwmtx);
-	tmp = GetEnvironmentStrings();
-	merged = merge_environment(tmp, new_env);
-
-	FreeEnvironmentStrings(tmp);
-	erts_smp_rwmtx_runlock(&environ_rwmtx);
-	return merged;
-    }
-}
-
-static char*
-merge_environment(char *old, char *add)
-{
-    char **a_arg = env_to_arg(add);
-    char **c_arg = env_to_arg(old);
-    char *ret;
-    int i, j;
-    
-    for(i = 0; c_arg[i] != NULL; ++i)
-	;
-
-    for(j = 0; a_arg[j] != NULL; ++j)
-	;
-
-    c_arg = erts_realloc(ERTS_ALC_T_TMP,
-			 c_arg, (i+j+1) * sizeof(char *));
-
-    for(j = 0; a_arg[j] != NULL; ++j){
-	char **tmp;
-	char *current = a_arg[j];
-	char *eq_p = strchr(current,'=');
-	int unset = (eq_p!=NULL && eq_p[1]=='\0');
-
-	if ((tmp = find_arg(c_arg, current)) != NULL) {
-	    if (!unset) {
-		*tmp = current;
-	    } else {
-		*tmp = c_arg[--i];
-		c_arg[i] = NULL;
-	    }
-	} else if (!unset) {
-	    c_arg[i++] = current;
-	    c_arg[i] = NULL;
-	}
-    }
-    ret = arg_to_env(c_arg);
-    erts_free(ERTS_ALC_T_TMP, c_arg);
-    erts_free(ERTS_ALC_T_TMP, a_arg);
-    return ret;
-}
-
-static char**
-find_arg(char **arg, char *str)
-{
-    char *tmp;
-    int len;
-
-    if ((tmp = strchr(str, '=')) != NULL) {
-	tmp++;
-	len = tmp - str;
-	while (*arg != NULL){
-	    if (_strnicmp(*arg, str, len) == 0){
-		return arg;
-	    }
-	    ++arg;
-	}
-    }
-    return NULL;
-}
-
-static int
-compare(const void *a, const void *b)
-{
-    char *s1 = *((char **) a);
-    char *s2 = *((char **) b);
-    char *e1 = strchr(s1,'=');
-    char *e2 = strchr(s2,'=');
-    int ret;
-    int len;
-  
-    if(!e1)
-	e1 = s1 + strlen(s1);
-    if(!e2)
-	e2 = s2 + strlen(s2);
-  
-    if((e1 - s1) > (e2 - s2))
-	len = (e2 - s2);
-    else
-	len = (e1 - s1);
-  
-    ret = _strnicmp(s1,s2,len);
-    if (ret == 0)
-	return ((e1 - s1) - (e2 - s2));
-    else
-	return ret;
-}
-
-static char**
-env_to_arg(char *env)
-{
-    char **ret;
-    char *tmp;
-    int i;
-    int num_strings = 0;
-
-    for(tmp = env; *tmp != '\0'; tmp += strlen(tmp)+1) {
-	++num_strings;
-    }
-    ret = erts_alloc(ERTS_ALC_T_TMP, sizeof(char *) * (num_strings + 1));
-    i = 0;
-    for(tmp = env; *tmp != '\0'; tmp += strlen(tmp)+1){
-	ret[i++] = tmp;
-    }
-    ret[i] = NULL;
-    return ret;
-}
-
-static char*
-arg_to_env(char **arg)
-{
-    char *block;
-    char *ptr;
-    int i;
-    int totlen = 1;		/* extra '\0' */
-
-    for(i = 0; arg[i] != NULL; ++i) {
-	totlen += strlen(arg[i])+1;
-    }
-
-    /* sort the environment vector */
-    qsort(arg, i, sizeof(char *), &compare);
-
-    if (totlen == 1){
-	block = erts_alloc(ERTS_ALC_T_ENVIRONMENT, 2);
-	block[0] = block[1] = '\0'; 
-    } else {
-	block = erts_alloc(ERTS_ALC_T_ENVIRONMENT, totlen);
-	ptr = block;
-	for(i=0; arg[i] != NULL; ++i){
-	    strcpy(ptr, arg[i]);
-	    ptr += strlen(ptr)+1;
-	}
-	*ptr = '\0';
-    }
-    return block;
-}
+/*

+ * %CopyrightBegin%

+ *

+ * Copyright Ericsson AB 2002-2011. All Rights Reserved.

+ *

+ * The contents of this file are subject to the Erlang Public License,

+ * Version 1.1, (the "License"); you may not use this file except in

+ * compliance with the License. You should have received a copy of the

+ * Erlang Public License along with this software. If not, it can be

+ * retrieved online at http://www.erlang.org/.

+ *

+ * Software distributed under the License is distributed on an "AS IS"

+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See

+ * the License for the specific language governing rights and limitations

+ * under the License.

+ *

+ * %CopyrightEnd%

+ */

+

+#ifdef HAVE_CONFIG_H

+#  include "config.h"

+#endif

+

+#include "sys.h"

+#include "erl_sys_driver.h"

+#include "erl_alloc.h"

+

+static WCHAR *merge_environment(WCHAR *current, WCHAR *add);

+static WCHAR *arg_to_env(WCHAR **arg);

+static WCHAR **env_to_arg(WCHAR *env);

+static WCHAR **find_arg(WCHAR **arg, WCHAR *str);

+static int compare(const void *a, const void *b);

+

+static erts_smp_rwmtx_t environ_rwmtx;

+

+void

+erts_sys_env_init(void)

+{

+    erts_smp_rwmtx_init(&environ_rwmtx, "environ");

+}

+

+int

+erts_sys_putenv_raw(char *key, char *value)

+{

+    int res;

+    erts_smp_rwmtx_rwlock(&environ_rwmtx);

+    res = (SetEnvironmentVariable((LPCTSTR) key,

+				  (LPCTSTR) value) ? 0 : 1);

+    erts_smp_rwmtx_rwunlock(&environ_rwmtx);

+    return res;

+}

+

+int

+erts_sys_putenv(char *key, char *value)

+{

+    int res;

+    WCHAR *wkey = (WCHAR *) key;

+    WCHAR *wvalue = (WCHAR *) value;

+    erts_smp_rwmtx_rwlock(&environ_rwmtx);

+    res = (SetEnvironmentVariableW(wkey,

+				   wvalue) ? 0 : 1);

+    erts_smp_rwmtx_rwunlock(&environ_rwmtx);

+    return res;

+}

+

+int

+erts_sys_getenv(char *key, char *value, size_t *size)

+{

+    size_t req_size = 0;

+    int res = 0;

+    DWORD new_size;

+    WCHAR *wkey = (WCHAR *) key;

+    WCHAR *wvalue = (WCHAR *) value;

+    DWORD wsize = *size / (sizeof(WCHAR) / sizeof(char));

+

+    SetLastError(0);

+    erts_smp_rwmtx_rlock(&environ_rwmtx);

+    new_size = GetEnvironmentVariableW(wkey,

+				       wvalue,

+				      (DWORD) wsize);

+    res = !new_size && GetLastError() == ERROR_ENVVAR_NOT_FOUND ? -1 : 0;

+    erts_smp_rwmtx_runlock(&environ_rwmtx);

+    if (res < 0)

+	return res;

+    res = new_size > wsize ? 1 : 0;

+    *size = new_size * (sizeof(WCHAR) / sizeof(char));

+    return res;

+}

+int

+erts_sys_getenv__(char *key, char *value, size_t *size)

+{

+    size_t req_size = 0;

+    int res = 0;

+    DWORD new_size;

+

+    SetLastError(0);

+    new_size = GetEnvironmentVariable((LPCTSTR) key,

+				      (LPTSTR) value,

+				      (DWORD) *size);

+    res = !new_size && GetLastError() == ERROR_ENVVAR_NOT_FOUND ? -1 : 0;

+    if (res < 0)

+	return res;

+    res = new_size > *size ? 1 : 0;

+    *size = new_size;

+    return res;

+}

+

+int

+erts_sys_getenv_raw(char *key, char *value, size_t *size)

+{

+    int res;

+    erts_smp_rwmtx_rlock(&environ_rwmtx);

+    res = erts_sys_getenv__(key, value, size);

+    erts_smp_rwmtx_runlock(&environ_rwmtx);

+    return res;

+}

+

+void init_getenv_state(GETENV_STATE *state)

+{

+    erts_smp_rwmtx_rlock(&environ_rwmtx);

+    state->environment_strings = GetEnvironmentStringsW();

+    state->next_string = state->environment_strings;

+}

+

+char *getenv_string(GETENV_STATE *state)

+{

+    ERTS_SMP_LC_ASSERT(erts_smp_lc_rwmtx_is_rlocked(&environ_rwmtx));

+    if (state->next_string[0] == L'\0') {

+	return NULL;

+    } else {

+	WCHAR *res = state->next_string;

+	state->next_string += wcslen(res) + 1;

+	return (char *) res;

+    }

+}

+

+void fini_getenv_state(GETENV_STATE *state)

+{

+    FreeEnvironmentStringsW(state->environment_strings);

+    state->environment_strings = state->next_string = NULL;

+    erts_smp_rwmtx_runlock(&environ_rwmtx);

+}

+

+char*

+win_build_environment(char* new_env)

+{

+    if (new_env == NULL) {

+	return NULL;

+    } else {

+	WCHAR *tmp, *merged, *tmp_new;

+

+	tmp_new = (WCHAR *) new_env;

+	

+	erts_smp_rwmtx_rlock(&environ_rwmtx);

+	tmp = GetEnvironmentStringsW();

+	merged = merge_environment(tmp, tmp_new);

+

+	FreeEnvironmentStringsW(tmp);

+	erts_smp_rwmtx_runlock(&environ_rwmtx);

+	return (char *) merged;

+    }

+}

+

+static WCHAR *

+merge_environment(WCHAR *old, WCHAR *add)

+{

+    WCHAR **a_arg = env_to_arg(add);

+    WCHAR **c_arg = env_to_arg(old);

+    WCHAR *ret;

+    int i, j;

+    

+    for(i = 0; c_arg[i] != NULL; ++i)

+	;

+

+    for(j = 0; a_arg[j] != NULL; ++j)

+	;

+

+    c_arg = erts_realloc(ERTS_ALC_T_TMP,

+			 c_arg, (i+j+1) * sizeof(WCHAR *));

+

+    for(j = 0; a_arg[j] != NULL; ++j){

+	WCHAR **tmp;

+	WCHAR *current = a_arg[j];

+	WCHAR *eq_p = wcschr(current,L'=');

+	int unset = (eq_p!=NULL && eq_p[1]==L'\0');

+

+	if ((tmp = find_arg(c_arg, current)) != NULL) {

+	    if (!unset) {

+		*tmp = current;

+	    } else {

+		*tmp = c_arg[--i];

+		c_arg[i] = NULL;

+	    }

+	} else if (!unset) {

+	    c_arg[i++] = current;

+	    c_arg[i] = NULL;

+	}

+    }

+    ret = arg_to_env(c_arg);

+    erts_free(ERTS_ALC_T_TMP, c_arg);

+    erts_free(ERTS_ALC_T_TMP, a_arg);

+    return ret;

+}

+

+static WCHAR**

+find_arg(WCHAR **arg, WCHAR *str)

+{

+    WCHAR *tmp;

+    int len;

+

+    if ((tmp = wcschr(str, L'=')) != NULL) {

+	tmp++;

+	len = tmp - str;

+	while (*arg != NULL){

+	    if (_wcsnicmp(*arg, str, len) == 0){

+		return arg;

+	    }

+	    ++arg;

+	}

+    }

+    return NULL;

+}

+

+static int

+compare(const void *a, const void *b)

+{

+    WCHAR *s1 = *((WCHAR **) a);

+    WCHAR *s2 = *((WCHAR **) b);

+    WCHAR *e1 = wcschr(s1,L'=');

+    WCHAR *e2 = wcschr(s2,L'=');

+    int ret;

+    int len;

+  

+    if(!e1)

+	e1 = s1 + wcslen(s1);

+    if(!e2)

+	e2 = s2 + wcslen(s2);

+  

+    if((e1 - s1) > (e2 - s2))

+	len = (e2 - s2);

+    else

+	len = (e1 - s1);

+  

+    ret = _wcsnicmp(s1,s2,len);

+    if (ret == 0)

+	return ((e1 - s1) - (e2 - s2));

+    else

+	return ret;

+}

+

+static WCHAR**

+env_to_arg(WCHAR *env)

+{

+    WCHAR **ret;

+    WCHAR *tmp;

+    int i;

+    int num_strings = 0;

+

+    for(tmp = env; *tmp != '\0'; tmp += wcslen(tmp)+1) {

+	++num_strings;

+    }

+    ret = erts_alloc(ERTS_ALC_T_TMP, sizeof(WCHAR *) * (num_strings + 1));

+    i = 0;

+    for(tmp = env; *tmp != '\0'; tmp += wcslen(tmp)+1){

+	ret[i++] = tmp;

+    }

+    ret[i] = NULL;

+    return ret;

+}

+

+static WCHAR *

+arg_to_env(WCHAR **arg)

+{

+    WCHAR *block;

+    WCHAR *ptr;

+    int i;

+    int totlen = 1;		/* extra '\0' */

+

+    for(i = 0; arg[i] != NULL; ++i) {

+	totlen += wcslen(arg[i])+1;

+    }

+

+    /* sort the environment vector */

+    qsort(arg, i, sizeof(WCHAR *), &compare);

+

+    if (totlen == 1){

+	block = erts_alloc(ERTS_ALC_T_ENVIRONMENT, 2 * sizeof(WCHAR));

+	block[0] = block[1] = '\0'; 

+    } else {

+	block = erts_alloc(ERTS_ALC_T_ENVIRONMENT, totlen * sizeof(WCHAR));

+	ptr = block;

+	for(i=0; arg[i] != NULL; ++i){

+	    wcscpy(ptr, arg[i]);

+	    ptr += wcslen(ptr)+1;

+	}

+	*ptr = '\0';

+    }

+    return block;

+}

diff --git a/erts/etc/common/erlexec.c b/erts/etc/common/erlexec.c
index 790b0ed400..cba7429fab 100644
--- a/erts/etc/common/erlexec.c
+++ b/erts/etc/common/erlexec.c
@@ -245,7 +245,9 @@ static char* config_script = NULL; /* used by option -start_erl and -config */
 
 static HANDLE this_module_handle;
 static int run_werl;
-
+static WCHAR *utf8_to_utf16(unsigned char *bytes);
+static char *utf16_to_utf8(WCHAR *wstr);
+static WCHAR *latin1_to_utf16(char *str);
 #endif
 
 /*
@@ -263,8 +265,12 @@ static void
 set_env(char *key, char *value)
 {
 #ifdef __WIN32__
-    if (!SetEnvironmentVariable((LPCTSTR) key, (LPCTSTR) value))
+    WCHAR *wkey = latin1_to_utf16(key);
+    WCHAR *wvalue = utf8_to_utf16(value);
+    if (!SetEnvironmentVariableW(wkey, wvalue))
 	error("SetEnvironmentVariable(\"%s\", \"%s\") failed!", key, value);
+    efree(wkey);
+    efree(wvalue);
 #else
     size_t size = strlen(key) + 1 + strlen(value) + 1;
     char *str = emalloc(size);
@@ -277,25 +283,33 @@ set_env(char *key, char *value)
 #endif
 }
 
+
 static char *
 get_env(char *key)
 {
 #ifdef __WIN32__
     DWORD size = 32;
-    char *value = NULL;
+    WCHAR *value = NULL;
+    WCHAR *wkey = latin1_to_utf16(key);
+    char *res;
     while (1) {
 	DWORD nsz;
 	if (value)
 	    efree(value);
-	value = emalloc(size);
+	value = emalloc(size*sizeof(WCHAR));
 	SetLastError(0);
-	nsz = GetEnvironmentVariable((LPCTSTR) key, (LPTSTR) value, size);
+	nsz = GetEnvironmentVariableW(wkey, value, size);
 	if (nsz == 0 && GetLastError() == ERROR_ENVVAR_NOT_FOUND) {
 	    efree(value);
+	    efree(wkey);
 	    return NULL;
 	}
-	if (nsz <= size)
-	    return value;
+	if (nsz <= size) {
+	    efree(wkey);
+	    res = utf16_to_utf8(value);
+	    efree(value);
+	    return res;
+	}
 	size = nsz;
     }
 #else
@@ -2080,4 +2094,147 @@ possibly_quote(char* arg)
     return narg;
 }
 
+/*
+ * Unicode helpers to handle environment and command line parameters on
+ * Windows. We internally handle all environment variables in UTF8,
+ * but put and get the environment using the WCHAR (limited UTF16) interface
+ * 
+ * These are simplified to only handle Unicode characters that can fit in 
+ * Windows simplified UTF16, i.e. characters that fit in 16 bits.
+ */
+
+static int utf8_len(unsigned char first) 
+{
+    if ((first & ((unsigned char) 0x80)) == 0) {
+	return 1;
+    } else if ((first & ((unsigned char) 0xE0)) == 0xC0) {
+	return 2;
+    } else if ((first & ((unsigned char) 0xF0)) == 0xE0) {
+	return 3;
+    } else if ((first & ((unsigned char) 0xF8)) == 0xF0) {
+	return 4;
+    } 
+    return 1; /* will be a '?' */
+}
+
+static WCHAR *utf8_to_utf16(unsigned char *bytes)
+{
+    unsigned int unipoint;
+    unsigned char *tmp = bytes;
+    WCHAR *target, *res;
+    int num = 0;
+    
+    while (*tmp) {
+	num++;
+	tmp += utf8_len(*tmp);
+    }
+    res = target = emalloc((num + 1) * sizeof(WCHAR));
+    while (*bytes) {
+	if (((*bytes) & ((unsigned char) 0x80)) == 0) {
+	    unipoint = (Uint) *bytes;
+	    ++bytes;
+	} else if (((*bytes) & ((unsigned char) 0xE0)) == 0xC0) {
+	    unipoint = 
+		(((Uint) ((*bytes) & ((unsigned char) 0x1F))) << 6) |
+		((Uint) (bytes[1] & ((unsigned char) 0x3F))); 	
+	    bytes += 2;
+	} else if (((*bytes) & ((unsigned char) 0xF0)) == 0xE0) {
+	    unipoint = 
+		(((Uint) ((*bytes) & ((unsigned char) 0xF))) << 12) |
+		(((Uint) (bytes[1] & ((unsigned char) 0x3F))) << 6) |
+		((Uint) (bytes[2] & ((unsigned char) 0x3F)));
+	    if (unipoint > 0xFFFF) {
+		 unipoint = (unsigned int) '?';
+	    }
+	    bytes +=3;
+	} else if (((*bytes) & ((unsigned char) 0xF8)) == 0xF0) {
+	    unipoint = (unsigned int) '?'; /* Cannot put in a wchar */
+	    bytes += 4;
+	} else {
+	    unipoint = (unsigned int) '?';
+	}
+	*target++ = (WCHAR) unipoint;
+    }
+    *target = L'\0';
+    return res;
+}
+
+static int put_utf8(WCHAR ch, unsigned char *target, int sz, int *pos)
+{
+    Uint x = (Uint) ch;
+    if (x < 0x80) {
+    if (*pos >= sz) {
+	return -1;
+    }
+	target[(*pos)++] = (unsigned char) x;
+    }
+    else if (x < 0x800) {
+	if (((*pos) + 1) >= sz) {
+	    return -1;
+	}
+	target[(*pos)++] = (((unsigned char) (x >> 6)) | 
+			    ((unsigned char) 0xC0));
+	target[(*pos)++] = (((unsigned char) (x & 0x3F)) | 
+			    ((unsigned char) 0x80));
+    } else {
+	if ((x >= 0xD800 && x <= 0xDFFF) ||
+	    (x == 0xFFFE) ||
+	    (x == 0xFFFF)) { /* Invalid unicode range */
+	    return -1;
+	}
+	if (((*pos) + 2) >= sz) {
+	    return -1;
+	}
+
+	target[(*pos)++] = (((unsigned char) (x >> 12)) | 
+			    ((unsigned char) 0xE0));
+	target[(*pos)++] = ((((unsigned char) (x >> 6)) & 0x3F)  | 
+			    ((unsigned char) 0x80));
+	target[(*pos)++] = (((unsigned char) (x & 0x3F)) | 
+			    ((unsigned char) 0x80));
+    }
+    return 0;
+}
+
+static int need_bytes_for_utf8(WCHAR x)
+{
+    if (x < 0x80)
+	return 1;
+    else if (x < 0x800)
+	return 2;
+    else 
+	return 3;
+}
+
+static WCHAR *latin1_to_utf16(char *str)
+{
+    int len = strlen(str);
+    int i;
+    WCHAR *wstr = emalloc((len+1) * sizeof(WCHAR));
+    for(i=0;i<len;++i)
+	wstr[i] = (WCHAR) str[i];
+    wstr[len] = L'\0';
+    return wstr;
+}
+
+static char *utf16_to_utf8(WCHAR *wstr) 
+{
+    int len = wcslen(wstr);
+    char *result;
+    int i,pos;
+    int reslen = 0;
+    for(i=0;i<len;++i) {
+	reslen += need_bytes_for_utf8(wstr[i]);
+    }
+    result = emalloc(reslen+1);
+    pos = 0;
+    for(i=0;i<len;++i) {
+	if (put_utf8((int) wstr[i], result, reslen, &pos) < 0) {
+	    break;
+	}
+    }
+    result[pos] = '\0';
+    return result;
+}
+    
 #endif
diff --git a/erts/preloaded/ebin/init.beam b/erts/preloaded/ebin/init.beam
index cc170b86b2..9f2d369af2 100644
--- a/erts/preloaded/ebin/init.beam
+++ b/erts/preloaded/ebin/init.beam
diff --git a/erts/preloaded/src/init.erl b/erts/preloaded/src/init.erl
index c9c434dea0..708991e261 100644
--- a/erts/preloaded/src/init.erl
+++ b/erts/preloaded/src/init.erl
@@ -1252,7 +1252,11 @@ get_arguments([]) ->
     [].
 
 to_strings([H|T]) when is_atom(H) -> [atom_to_list(H)|to_strings(T)];
-to_strings([H|T]) when is_binary(H) -> [binary_to_list(H)|to_strings(T)];
+to_strings([H|T]) when is_binary(H) -> [try
+					    unicode:characters_to_list(H,file:native_name_encoding())
+					catch
+					    _:_ -> binary_to_list(H)
+					end|to_strings(T)];
 to_strings([])    -> [].
 
 get_argument(Arg,Flags) ->