Merge branch 'maint'

Conflicts:
	erts/doc/src/erlang.xml
	erts/preloaded/ebin/init.beam
	lib/kernel/doc/src/os.xml
	lib/stdlib/test/filename_SUITE.erl

4 files changed, 334 insertions, 291 deletions

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 21c52ca26d..db4b9999d6 100644
--- a/erts/emulator/sys/win32/erl_win_sys.h
+++ b/erts/emulator/sys/win32/erl_win_sys.h
@@ -176,8 +176,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;

+}