updated c++ classes for thread-safe ENVIRON handling

README.md

@@ -1111,7 +1111,6 @@ The `sys` module provides various functions concerning the underlying operation
 
 - sys::basename
 - sys::chmod
-- sys::clearenv
 - sys::close
 - sys::closedir
 - sys::dirname
@@ -1137,14 +1136,12 @@ The `sys` module provides various functions concerning the underlying operation
 - sys::raise
 - sys::read
 - sys::readdir
-- sys::setenv
 - sys::setttime
 - sys::signal
 - sys::sleep
 - sys::strftime
 - sys::system
 - sys::unlink
-- sys::unsetenv
 - sys::wait
 - sys::write
 

lib/Hawk.cpp

@@ -1456,11 +1456,11 @@ Hawk::Value::IndexIterator Hawk::Value::getNextIndex (Index* idx, const IndexIte
 // Hawk::Run
 //////////////////////////////////////////////////////////////////
 
-Hawk::Run::Run (Hawk* hawk): hawk(hawk), rtx (HAWK_NULL)
+Hawk::Run::Run (Hawk* hawk): hawk(hawk), rtx(HAWK_NULL), envp(HAWK_NULL), env_map(HAWK_NULL), env_map_rev(0)
 {
 }
 
-Hawk::Run::Run (Hawk* hawk, hawk_rtx_t* rtx): hawk(hawk), rtx (rtx)
+Hawk::Run::Run (Hawk* hawk, hawk_rtx_t* rtx): hawk(hawk), rtx(rtx), envp(HAWK_NULL), env_map(HAWK_NULL), env_map_rev(0)
 {
 	HAWK_ASSERT(this->rtx != HAWK_NULL);
 }
@@ -2123,10 +2123,12 @@ int Hawk::init_runctx ()
 	if (this->runctx.rtx) return 0;
 
 	hawk_rio_cbs_t rio;
+	HAWK_MEMSET(&rio, 0, HAWK_SIZEOF(rio));
 
 	rio.pipe    = pipeHandler;
 	rio.file    = fileHandler;
 	rio.console = consoleHandler;
+	rio.env_mk  = HAWK_NULL;
 
 	hawk_rtx_t* rtx = hawk_rtx_open(this->hawk, HAWK_SIZEOF(rxtn_t), &rio);
 	if (HAWK_UNLIKELY(!rtx))
@@ -2151,6 +2153,14 @@ void Hawk::fini_runctx ()
 {
 	if (this->runctx.rtx)
 	{
+		if (this->runctx.envp)
+		{
+			hawk_rtx_freemem(this->runctx.rtx, this->runctx.envp);
+			this->runctx.envp = HAWK_NULL;
+			this->runctx.env_map = HAWK_NULL;
+			this->runctx.env_map_rev = 0;
+		}
+
 		hawk_rtx_close(this->runctx.rtx);
 		this->runctx.rtx = HAWK_NULL;
 	}

lib/Hawk.hpp

@@ -1327,10 +1327,35 @@ public:
 		///
 		int getGlobal (int id, Value& v) const;
 
+		void* getEnvp () const
+		{
+			return this->envp;
+		}
+
+		hawk_map_t* getEnvMap () const
+		{
+			return this->env_map;
+		}
+
+		hawk_oow_t getEnvMapRev () const
+		{
+			return this->env_map_rev;
+		}
+
+		void setEnvCache (void* envp, hawk_map_t* env_map, hawk_oow_t env_map_rev)
+		{
+			this->envp = envp;
+			this->env_map = env_map;
+			this->env_map_rev = env_map_rev;
+		}
+
 	protected:
 		Hawk* hawk;
 		hawk_rtx_t* rtx;
 		hawk_rtx_ecb_t rtx_ecb;
+		void* envp;
+		hawk_map_t* env_map;
+		hawk_oow_t env_map_rev;
 	};
 
 	///
@@ -2026,13 +2051,12 @@ public:
 
 	void clearConsoleOutputs ();
 
-protected:
+	int getEnvironGlobalId () const { return this->gbl_environ; }
-	#define HAWK_STD_ENV_CHAR_IS_BCH
-	typedef hawk_bch_t env_char_t;
 
+protected:
 	int make_additional_globals (Run* run);
 	int build_argcv (Run* run);
-	int build_environ (Run* run, env_char_t* envarr[]);
+	int build_environ (Run* run, hawk_env_char_t* envarr[]);
 
 	// intrinsic functions
 	hawk_cmgr_t* getiocmgr (const hawk_ooch_t* ioname);

lib/Std.cpp

@@ -55,6 +55,79 @@
 HAWK_BEGIN_NAMESPACE(HAWK)
 /////////////////////////////////
 
+struct std_rxtn_t
+{
+	Hawk::Run* run;
+};
+
+#if defined(HAWK_HAVE_INLINE)
+static HAWK_INLINE std_rxtn_t* GET_STD_RXTN(hawk_rtx_t* rtx)
+{
+	return (std_rxtn_t*)((hawk_uint8_t*)hawk_rtx_getxtn(rtx) - HAWK_SIZEOF(std_rxtn_t));
+}
+#else
+#	define GET_STD_RXTN(rtx) ((std_rxtn_t*)((hawk_uint8_t*)hawk_rtx_getxtn(rtx) - HAWK_SIZEOF(std_rxtn_t)))
+#endif
+
+static void* rtx_env_maker (hawk_rtx_t* rtx, hawk_rtx_env_mk_type_t env_mk_type)
+{
+	HawkStd* hawk;
+	Hawk::Run* run;
+	hawk_val_t* v_env;
+	hawk_map_t* env_map;
+	hawk_oow_t env_map_rev;
+	int gbl_id;
+
+	if (env_mk_type != HAWK_RTX_ENV_MK_BPP) return HAWK_NULL;
+
+	run = GET_STD_RXTN(rtx)->run;
+	if (HAWK_UNLIKELY(run == HAWK_NULL)) return HAWK_NULL;
+	hawk = (HawkStd*)(Hawk*)*run;
+	HAWK_ASSERT(hawk != HAWK_NULL);
+
+	gbl_id = hawk->getEnvironGlobalId();
+	if (HAWK_UNLIKELY(gbl_id <= -1)) return HAWK_NULL;
+
+	v_env = hawk_rtx_getgbl(rtx, gbl_id);
+	HAWK_ASSERT(v_env != HAWK_NULL);
+
+	if (HAWK_RTX_GETVALTYPE(rtx, v_env) == HAWK_VAL_MAP)
+	{
+		env_map = ((hawk_val_map_t*)v_env)->map;
+		HAWK_ASSERT(env_map != HAWK_NULL);
+		env_map_rev = HAWK_MAP_REV(env_map);
+	}
+	else
+	{
+		env_map = HAWK_NULL;
+		env_map_rev = 0;
+	}
+
+	if (!run->getEnvp() || run->getEnvMap() != env_map ||
+	    (env_map && run->getEnvMapRev() != env_map_rev))
+	{
+		hawk_bch_t** envp;
+
+		envp = hawk_rtx_commit_environ(rtx, gbl_id);
+		if (HAWK_UNLIKELY(!envp)) return HAWK_NULL;
+
+		if (run->getEnvp()) hawk_rtx_freemem(rtx, run->getEnvp());
+		run->setEnvCache(envp, env_map, env_map_rev);
+	}
+
+	return run->getEnvp();
+}
+
+static void* pio_env_maker (hawk_pio_env_mk_type_t env_mk_type, void* ctx)
+{
+	hawk_rtx_t* rtx = (hawk_rtx_t*)ctx;
+	hawk_rio_cbs_t rio;
+
+	hawk_rtx_getrio(rtx, &rio);
+	HAWK_ASSERT(rio.env_mk != HAWK_NULL);
+	return rio.env_mk(rtx, (hawk_rtx_env_mk_type_t)env_mk_type);
+}
+
 static int set_pending_console_state (HawkStd::Console& io)
 {
 	hawk_uint16_t uflags = io.getUflags();
@@ -249,6 +322,13 @@ void HawkStd::uponClosing ()
 HawkStd::Run* HawkStd::parse (Source& in, Source& out)
 {
 	Run* run = Hawk::parse(in, out);
+	if (run)
+	{
+		hawk_rio_cbs_t rio;
+		hawk_rtx_getrio(*run, &rio);
+		rio.env_mk = rtx_env_maker;
+		hawk_rtx_setrio(*run, &rio);
+	}
 
 	if (this->cmgrtab_inited)
 	{
@@ -292,39 +372,40 @@ int HawkStd::build_argcv (Run* run)
 }
 
 
-int HawkStd::build_environ (Run* run, env_char_t* envarr[])
+int HawkStd::build_environ (Run* run, hawk_env_char_t* envarr[])
 {
 	Value v_env (run);
+	hawk_rtx_t* rtx = *run;
 
 	if (envarr)
 	{
-		env_char_t* eq;
+		hawk_env_char_t* eq;
 		hawk_ooch_t* kptr, * vptr;
-		hawk_oow_t klen, count;
+		hawk_oow_t klen, vlen, count;
-		hawk_rtx_t* rtx = *run;
 
 		for (count = 0; envarr[count]; count++)
 		{
-		#if ((defined(HAWK_STD_ENV_CHAR_IS_BCH) && defined(HAWK_OOCH_IS_BCH)) || \
+		#if ((defined(HAWK_ENV_CHAR_IS_BCH) && defined(HAWK_OOCH_IS_BCH)) || \
-		     (defined(HAWK_STD_ENV_CHAR_IS_UCH) && defined(HAWK_OOCH_IS_UCH)))
+		     (defined(HAWK_ENV_CHAR_IS_UCH) && defined(HAWK_OOCH_IS_UCH)))
 			eq = hawk_find_oochar_in_oocstr(envarr[count], HAWK_T('='));
 			if (eq == HAWK_NULL || eq == envarr[count]) continue;
 
 			kptr = envarr[count];
 			klen = eq - envarr[count];
 			vptr = eq + 1;
-		#elif defined(HAWK_STD_ENV_CHAR_IS_BCH)
+			vlen = hawk_count_oocstr(vptr);
+		#elif defined(HAWK_ENV_CHAR_IS_BCH)
 			eq = hawk_find_bchar_in_bcstr(envarr[count], HAWK_BT('='));
 			if (eq == HAWK_NULL || eq == envarr[count]) continue;
 
 			*eq = HAWK_BT('\0');
 
 			kptr = hawk_rtx_dupbtoucstr(rtx, envarr[count], &klen, 1);
-			vptr = hawk_rtx_dupbtoucstr(rtx, eq + 1, HAWK_NULL, 1);
+			vptr = hawk_rtx_dupbtoucstr(rtx, eq + 1, &vlen, 1);
 			if (kptr == HAWK_NULL || vptr == HAWK_NULL)
 			{
 				if (kptr) hawk_rtx_freemem(rtx, kptr);
-				if (vptr) hawk_rtx_freemem(rtx, kptr);
+				if (vptr) hawk_rtx_freemem(rtx, vptr);
 
 				/* mbstowcsdup() may fail for invalid encoding.
 				 * so setting the error code to ENOMEM may not
@@ -341,11 +422,11 @@ int HawkStd::build_environ (Run* run, env_char_t* envarr[])
 			*eq = HAWK_UT('\0');
 
 			kptr = hawk_rtx_duputobcstr(rtx, envarr[count], &klen);
-			vptr = hawk_rtx_duputobcstr(rtx, eq + 1, HAWK_NULL);
+			vptr = hawk_rtx_duputobcstr(rtx, eq + 1, &vlen);
 			if (kptr == HAWK_NULL || vptr == HAWK_NULL)
 			{
-		#if ((defined(HAWK_STD_ENV_CHAR_IS_BCH) && defined(HAWK_OOCH_IS_BCH)) || \
+		#if ((defined(HAWK_ENV_CHAR_IS_BCH) && defined(HAWK_OOCH_IS_BCH)) || \
-		     (defined(HAWK_STD_ENV_CHAR_IS_UCH) && defined(HAWK_OOCH_IS_UCH)))
+		     (defined(HAWK_ENV_CHAR_IS_UCH) && defined(HAWK_OOCH_IS_UCH)))
 				/* nothing to do */
 		#else
 				if (vptr) hawk_rtx_freemem(rtx, vptr);
@@ -359,11 +440,33 @@ int HawkStd::build_environ (Run* run, env_char_t* envarr[])
 			*eq = HAWK_UT('=');
 		#endif
 
-			// numeric string
+			hawk_val_t* tmp = hawk_rtx_makenumorstrvalwithoochars(rtx, vptr, vlen, 1);
-			v_env.setIndexedStr (Value::Index(kptr, klen), vptr, true);
+			if (tmp == HAWK_NULL)
+			{
+		#if ((defined(HAWK_ENV_CHAR_IS_BCH) && defined(HAWK_OOCH_IS_BCH)) || \
+		     (defined(HAWK_ENV_CHAR_IS_UCH) && defined(HAWK_OOCH_IS_UCH)))
+				/* nothing to do */
+		#else
+				if (vptr) hawk_rtx_freemem(rtx, vptr);
+				if (kptr) hawk_rtx_freemem(rtx, kptr);
+		#endif
+				return -1;
+			}
 
-		#if ((defined(HAWK_STD_ENV_CHAR_IS_BCH) && defined(HAWK_OOCH_IS_BCH)) || \
+			if (v_env.setIndexedVal(Value::Index(kptr, klen), tmp) <= -1)
-		     (defined(HAWK_STD_ENV_CHAR_IS_UCH) && defined(HAWK_OOCH_IS_UCH)))
+			{
+		#if ((defined(HAWK_ENV_CHAR_IS_BCH) && defined(HAWK_OOCH_IS_BCH)) || \
+		     (defined(HAWK_ENV_CHAR_IS_UCH) && defined(HAWK_OOCH_IS_UCH)))
+				/* nothing to do */
+		#else
+				if (vptr) hawk_rtx_freemem(rtx, vptr);
+				if (kptr) hawk_rtx_freemem(rtx, kptr);
+		#endif
+				return -1;
+			}
+
+		#if ((defined(HAWK_ENV_CHAR_IS_BCH) && defined(HAWK_OOCH_IS_BCH)) || \
+		     (defined(HAWK_ENV_CHAR_IS_UCH) && defined(HAWK_OOCH_IS_UCH)))
 				/* nothing to do */
 		#else
 			if (vptr) hawk_rtx_freemem(rtx, vptr);
@@ -592,6 +695,7 @@ int HawkStd::open_pio (Pipe& io)
 {
 	Hawk::Pipe::Mode mode = io.getMode();
 	hawk_pio_t* pio = HAWK_NULL;
+	hawk_rio_cbs_t rio;
 	int flags = HAWK_PIO_TEXT | HAWK_PIO_SHELL | HAWK_PIO_IGNOREECERR;
 
 	switch (mode)
@@ -610,7 +714,9 @@ int HawkStd::open_pio (Pipe& io)
 			break;
 	}
 
-	pio = hawk_pio_open((hawk_gem_t*)*this, 0, io.getName(), flags, HAWK_NULL, HAWK_NULL);
+	if (!HAWK_RTX_IS_PIPECLOEXEC_ON((hawk_rtx_t*)io)) flags |= HAWK_PIO_NOCLOEXEC;
+	hawk_rtx_getrio((hawk_rtx_t*)io, &rio);
+	pio = hawk_pio_open((hawk_gem_t*)*this, 0, io.getName(), flags, (rio.env_mk? pio_env_maker: HAWK_NULL), (hawk_rtx_t*)io);
 	if (!pio) return -1;
 
 #if defined(HAWK_OOCH_IS_UCH)

lib/hawk-pio.h

@@ -122,9 +122,9 @@ typedef enum hawk_pio_hid_t hawk_pio_hid_t;
 
 enum hawk_pio_env_mk_type_t
 {
-	HAWK_PIO_ENV_MK_BCH_PP, /* P1 ... PN HAWK_NUL where P1 .. PN points to K=V */
+	HAWK_PIO_ENV_MK_BPP, /* P1 ... PN HAWK_NUL where P1 .. PN points to K=V */
-	HAWK_PIO_ENV_MK_BCH_PN, /* K1=V\0K2=V\0\0 */
+	HAWK_PIO_ENV_MK_BPN, /* K1=V\0K2=V\0\0 */
-	HAWK_PIO_ENV_MK_UCH_PP,
+	HAWK_PIO_ENV_MK_UPP,
 };
 
 typedef enum hawk_pio_env_mk_type_t hawk_pio_env_mk_type_t;

lib/hawk-prv.h

@@ -81,6 +81,7 @@ typedef struct hawk_tree_t hawk_tree_t;
 #include "err-prv.h"
 #include "misc-prv.h"
 
+
 /* ------------------------------------------------------------------------ */
 
 /* gc configuration */
@@ -559,6 +560,7 @@ struct hawk_rtx_t
 	struct
 	{
 		hawk_rio_impl_t handler[HAWK_RIO_NUM];
+		hawk_rtx_env_mk_t env_mk;
 		hawk_rio_arg_t* chain;
 	} rio;
 
@@ -712,7 +714,6 @@ static HAWK_INLINE void HAWK_RTX_STACK_POP (hawk_rtx_t* rtx)
 #	define HAWK_DEFAULT_MODPOSTFIX ""
 #endif
 
-
 #if defined(__cplusplus)
 extern "C" {
 #endif
@@ -723,6 +724,11 @@ void hawk_fini (hawk_t* hawk);
 hawk_rbt_walk_t hawk_modtab_unload_module (hawk_rbt_t* rbt, hawk_rbt_pair_t* pair, void* ctx);
 int hawk_rtx_setnamedval (hawk_rtx_t* rtx, hawk_oow_t id, hawk_val_t* val);
 
+hawk_bch_t** hawk_rtx_commit_environ (
+	hawk_rtx_t* rtx,
+	int         gbl_id
+);
+
 #if defined(__cplusplus)
 }
 #endif

lib/hawk.h

@@ -28,6 +28,7 @@
 #include <hawk-cmn.h>
 #include <hawk-ecs.h>
 #include <hawk-gem.h>
+#include <hawk-pio.h>
 #include <hawk-tre.h>
 #include <hawk-utl.h>
 
@@ -906,6 +907,20 @@ typedef struct hawk_sio_cbs_t hawk_sio_cbs_t;
 
 /* ------------------------------------------------------------------------ */
 
+/* these enumerators must be kept in sync with hawk_pio_env_mk_type_t enumerators */
+enum hawk_rtx_env_mk_type_t
+{
+	HAWK_RTX_ENV_MK_BPP = HAWK_PIO_ENV_MK_BPP,
+	HAWK_RTX_ENV_MK_BPN = HAWK_PIO_ENV_MK_BPN,
+	HAWK_RTX_ENV_MK_UPP = HAWK_PIO_ENV_MK_UPP,
+};
+typedef enum hawk_rtx_env_mk_type_t hawk_rtx_env_mk_type_t;
+
+typedef void* (*hawk_rtx_env_mk_t) (
+	hawk_rtx_t*            rtx,
+	hawk_rtx_env_mk_type_t type
+);
+
 /**
  * The hawk_rio_t type defines a runtime I/O handler set.
  * \sa hawk_rtx_t
@@ -915,6 +930,7 @@ struct hawk_rio_cbs_t
 	hawk_rio_impl_t pipe;    /**< pipe handler */
 	hawk_rio_impl_t file;    /**< file handler */
 	hawk_rio_impl_t console; /**< console handler */
+	hawk_rtx_env_mk_t env_mk; /**< environment maker - optional */
 };
 typedef struct hawk_rio_cbs_t hawk_rio_cbs_t;
 
@@ -1710,6 +1726,11 @@ struct hawk_rtx_nv_itr_t
 };
 typedef struct hawk_rtx_nv_itr_t hawk_rtx_nv_itr_t;
 
+
+/* TODO: use wenviron where it's available */
+#define HAWK_ENV_CHAR_IS_BCH
+typedef hawk_bch_t hawk_env_char_t;
+
 /* ----------------------------------------------------------------------- */
 
 #if defined(__cplusplus)

lib/mod-sys.c

@@ -24,6 +24,7 @@
 
 #include "mod-sys.h"
 #include "hawk-prv.h"
+#include <hawk-pio.h>
 #include <hawk-dir.h>
 
 #if defined(_WIN32)
@@ -2819,8 +2820,15 @@ I use 'count' to limit the maximum number of retries when 0 is returned.
 }
 
 /*
-	if (sys::getenv("PATH", v) <= -1) print "error -", sys::errmsg();
+if (sys::getenv("PATH", v) <= -1) print "error -", sys::errmsg();
-	else print v;
+else print v;
+
+for normal operations related to environment variables,
+the script must use the global variable ENVIRON. internally,
+libc's getenv/setenv/unsetenv/clearenv are not thread-safe.
+
+however, this function is provided for convenience and doesn't
+reflect the changes in ENVIRON.
 */
 static int fnc_getenv (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 {
@@ -2879,111 +2887,6 @@ static int fnc_getenv (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 	return 0;
 }
 
-#if defined(_SCO_DS)
-static int setenv(const char *name, const char* val, int overwrite);
-static int unsetenv(const char *name);
-static void clearenv(void);
-#endif
-
-static int fnc_clearenv (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
-{
-	hawk_mtx_lock(rtx->hawk->modmtx, HAWK_NULL);
-	clearenv();
-	hawk_mtx_unlock(rtx->hawk->modmtx);
-	return 0;
-}
-
-static int fnc_setenv (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
-{
-	sys_list_t* sys_list;
-	hawk_val_t* a0, * a1;
-	hawk_bch_t* var = HAWK_NULL, * val = HAWK_NULL;
-	hawk_oow_t var_len, val_len;
-	hawk_int_t rx;
-	hawk_int_t overwrite = 1;
-
-	sys_list = rtx_to_sys_list(rtx, fi);
-	a0 = hawk_rtx_getarg(rtx, 0);
-	a1 = hawk_rtx_getarg(rtx, 1);
-
-	var = hawk_rtx_getvalbcstr(rtx, a0, &var_len);
-	val = hawk_rtx_getvalbcstr(rtx, a1, &val_len);
-	if (!var || !val)
-	{
-		rx = copy_error_to_sys_list(rtx, sys_list);
-		goto done;
-	}
-
-	/* the target name contains a null character. */
-	if (hawk_find_bchar_in_bchars(var, var_len, '\0') ||
-	    hawk_find_bchar_in_bchars(val, val_len, '\0'))
-	{
-		rx = set_error_on_sys_list(rtx, sys_list, HAWK_EINVAL, HAWK_NULL);
-		goto done;
-	}
-
-	if (hawk_rtx_getnargs(rtx) >= 3 && (hawk_rtx_valtoint_inline(rtx, hawk_rtx_getarg(rtx, 2), &overwrite) <= -1)) overwrite = 0;
-
-	hawk_mtx_lock(rtx->hawk->modmtx, HAWK_NULL);
-	rx = setenv(var, val, overwrite);
-	hawk_mtx_unlock(rtx->hawk->modmtx);
-	if (rx <= -1) rx = set_error_on_sys_list_with_errno(rtx, sys_list, HAWK_NULL);
-
-done:
-	if (val) hawk_rtx_freevalbcstr(rtx, a1, val);
-	if (var) hawk_rtx_freevalbcstr(rtx, a0, var);
-
-	HAWK_ASSERT(HAWK_IN_INT_RANGE(rx));
-	hawk_rtx_setretval(rtx, hawk_rtx_makeintval_inline(rtx, rx));
-	return 0;
-}
-
-
-static int fnc_unsetenv (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
-{
-	sys_list_t* sys_list;
-	hawk_val_t* a0;
-	hawk_bch_t* str;
-	hawk_oow_t len;
-	hawk_int_t rx;
-
-	sys_list = rtx_to_sys_list(rtx, fi);
-	a0 = hawk_rtx_getarg(rtx, 0);
-
-	str = hawk_rtx_getvalbcstr(rtx, a0, &len);
-	if (!str)
-	{
-		rx = copy_error_to_sys_list(rtx, sys_list);
-		goto done;
-	}
-
-	/* the target name contains a null character. */
-	if (hawk_find_bchar_in_bchars(str, len, '\0'))
-	{
-		rx = set_error_on_sys_list(rtx, sys_list, HAWK_EINVAL, HAWK_NULL);
-		goto done;
-	}
-
-#if defined(UNSETENV_RETURNS_VOID)
-	hawk_mtx_lock(rtx->hawk->modmtx, HAWK_NULL);
-	unsetenv(str);
-	hawk_mtx_unlock(rtx->hawk->modmtx);
-	rx = 0;
-#else
-	hawk_mtx_lock(rtx->hawk->modmtx, HAWK_NULL);
-	rx = unsetenv(str);
-	hawk_mtx_unlock(rtx->hawk->modmtx);
-	if (rx <= -1) rx = set_error_on_sys_list_with_errno(rtx, sys_list, HAWK_NULL);
-#endif
-
-done:
-	if (str) hawk_rtx_freevalbcstr(rtx, a0, str);
-
-	HAWK_ASSERT(HAWK_IN_INT_RANGE(rx));
-	hawk_rtx_setretval(rtx, hawk_rtx_makeintval_inline(rtx, rx));
-	return 0;
-}
-
 /* ------------------------------------------------------------ */
 
 /*
@@ -3092,11 +2995,21 @@ static int fnc_getifcfg (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 }
 /* ------------------------------------------------------------ */
 
+static void* pio_env_maker (hawk_pio_env_mk_type_t env_mk_type, void* ctx)
+{
+	hawk_rtx_t* rtx = (hawk_rtx_t*)ctx;
+	/* fnc_system() passes this function to hawk_pio_open only if
+	 * rtx->rio.env_mk is not HAWK_NULL */
+	HAWK_ASSERT(rtx->rio.env_mk != HAWK_NULL);
+	return rtx->rio.env_mk(rtx, env_mk_type);
+}
+
 static int fnc_system (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 {
 	sys_list_t* sys_list;
 	hawk_val_t* a0;
 	hawk_ooch_t* str;
+	hawk_pio_t* pio = HAWK_NULL;
 	hawk_oow_t len;
 	hawk_int_t rx;
 
@@ -3117,32 +3030,26 @@ static int fnc_system (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 		goto done;
 	}
 
-#if defined(_WIN32)
+	pio = hawk_pio_open(
-	rx = _tsystem(str);
+		hawk_rtx_getgem(rtx),
-	if (rx <= -1) rx = set_error_on_sys_list_with_errno(rtx, sys_list, HAWK_NULL);
+		0,
-#elif defined(HAWK_OOCH_IS_BCH)
+		str,
-	rx = system(str);
+		HAWK_PIO_SHELL | HAWK_PIO_NOCLOEXEC,
-	if (rx <= -1) rx = set_error_on_sys_list_with_errno(rtx, sys_list, HAWK_NULL);
+		(rtx->rio.env_mk? pio_env_maker: HAWK_NULL),
-#else
+		rtx
+	);
 
-	{
+	if (!pio)
-		hawk_bch_t* mbs;
-		mbs = hawk_rtx_duputobcstr(rtx, str, HAWK_NULL);
-		if (mbs)
-		{
-			rx = system(mbs);
-			hawk_rtx_freemem(rtx, mbs);
-			if (rx <= -1) rx = set_error_on_sys_list_with_errno(rtx, sys_list, HAWK_NULL);
-		}
-		else
 	{
 		rx = copy_error_to_sys_list(rtx, sys_list);
-		}
+		goto done;
 	}
 
-#endif
+	rx = hawk_pio_wait(pio);
+	if (rx <= -1) rx = copy_error_to_sys_list(rtx, sys_list);
 
 done:
+	if (pio) hawk_pio_close(pio);
 	if (str) hawk_rtx_freevaloocstr(rtx, a0, str);
 
 	HAWK_ASSERT(HAWK_IN_INT_RANGE(rx));
@@ -6066,7 +5973,6 @@ static hawk_mod_fnc_tab_t fnctab[] =
 	{ HAWK_T("bind"),        { { 2, 2, HAWK_NULL       }, fnc_bind,        0  } },
 	{ HAWK_T("chmod"),       { { 2, 2, HAWK_NULL       }, fnc_chmod,       0  } },
 	{ HAWK_T("chroot"),      { { 1, 1, HAWK_NULL       }, fnc_chroot,      0  } },
-	{ HAWK_T("clearenv"),    { { 0, 0, HAWK_NULL       }, fnc_clearenv,    0  } },
 	{ HAWK_T("close"),       { { 1, 2, HAWK_NULL       }, fnc_close,       0  } },
 	{ HAWK_T("closedir"),    { { 1, 1, HAWK_NULL       }, fnc_closedir,    0  } },
 	{ HAWK_T("closelog"),    { { 0, 0, HAWK_NULL       }, fnc_closelog,    0  } },
@@ -6114,7 +6020,6 @@ static hawk_mod_fnc_tab_t fnctab[] =
 	{ HAWK_T("resetdir"),    { { 2, 2, HAWK_NULL       }, fnc_resetdir,    0  } },
 	{ HAWK_T("rmdir"),       { { 1, 1, HAWK_NULL       }, fnc_rmdir,       0  } },
 	{ HAWK_T("sendto"),      { { 2, 3, HAWK_NULL       }, fnc_sendto,      0  } },
-	{ HAWK_T("setenv"),      { { 2, 3, HAWK_NULL       }, fnc_setenv,      0  } },
 	{ HAWK_T("setsockopt"),  { { 4, 4, HAWK_NULL       }, fnc_setsockopt,  0  } },
 	{ HAWK_T("settime"),     { { 1, 1, HAWK_NULL       }, fnc_settime,     0  } },
 	{ HAWK_T("shutdown"),    { { 2, 2, HAWK_NULL       }, fnc_shutdown,    0  } },
@@ -6133,7 +6038,6 @@ static hawk_mod_fnc_tab_t fnctab[] =
 	{ HAWK_T("tcsetraw"),    { { 1, 1, HAWK_NULL       }, fnc_tcsetraw,    0  } },
 	{ HAWK_T("unlink"),      { { 1, 1, HAWK_NULL       }, fnc_unlink,      0  } },
 	{ HAWK_T("unpack"),      { { 2, A_MAX, HAWK_T("vvr")  }, fnc_unpack,   0  } },
-	{ HAWK_T("unsetenv"),    { { 1, 1, HAWK_NULL       }, fnc_unsetenv,    0  } },
 	{ HAWK_T("wait"),        { { 1, 3, HAWK_T("vrv")   }, fnc_wait,        0  } },
 	{ HAWK_T("waitonmux"),   { { 2, 2, HAWK_T("vv")    }, fnc_waitonmux,   0  } },
 	{ HAWK_T("write"),       { { 2, 4, HAWK_NULL       }, fnc_write,       0  } },
@@ -6633,84 +6537,3 @@ int hawk_mod_sys (hawk_mod_t* mod, hawk_t* hawk)
 	mod->ctx = mctx;
 	return 0;
 }
-
-
-/* ----------------------------------------------  */
-
-#if defined(_SCO_DS)
-/* declare the external environment array */
-extern char **environ;
-
-static int setenv (const char *name, const char *value, int overwrite)
-{
-	hawk_oow_t name_len;
-	hawk_oow_t value_len;
-	char* env_str;
-
-	if (name[0] == '\0')
-	{
-		errno = EINVAL;
-		return -1;
-	}
-
-	/* check if it exists */
-	if (!overwrite && getenv(name)) return 0; /* succeed without changing */
-
-	/* create "NAME=VALUE" string */
-	name_len = hawk_count_bcstr(name);
-	value_len = hawk_count_bcstr(value);
-	env_str = (char *)malloc(name_len + value_len + 2);
-	if (!env_str) return -1;
-
-	HAWK_MEMCPY(env_str, name, name_len);
-	env_str[name_len] = '=';
-	HAWK_MEMCPY(env_str + name_len + 1, value, value_len);
-	env_str[name_len + value_len + 1] = '\0';
-
-	/* putenv() takes ownership of the string memory */
-	if (putenv(env_str) != 0)
-	{
-		free(env_str); /* free only if putenv failed */
-		return -1;
-	}
-
-	return 0;
-}
-
-static int unsetenv(const char *name)
-{
-	char** ep;
-	hawk_oow_t len;
-
-	len = hawk_count_bcstr(name);
-	for (ep = environ; *ep; ep++)
-	{
-		/* check if the entry starts with name + '=' */
-		if (hawk_comp_bcstr_limited(*ep, name, len, 0) == 0 && (*ep)[len] == '=')
-		{
-			char* old;
-			/* found it. shift remaining pointers down. */
-			char** next = ep;
-			old = *ep;
-			while (*next)
-			{
-				*next = *(next + 1);
-				next++;
-			}
-
-			free(old);
-			break;
-		}
-	}
-
-	return 0;
-}
-
-static int clearenv(void)
-{
-	char** ep;
-	for (ep = environ; *ep; ep++) free(*ep);
-	environ = HAWK_NULL;
-}
-
-#endif

lib/pio.c

@@ -778,11 +778,9 @@ int hawk_pio_init (hawk_pio_t* pio, hawk_gem_t* gem, const hawk_ooch_t* cmd, int
 		maxidx = 5;
 	}
 
-	if (maxidx == -1)
+	/* allow a pure spawn/wait use case with no dedicated pipes.
-	{
+	 * a system()-style caller may still want shell execution and
-		hawk_gem_seterrnum(pio->gem, HAWK_NULL, HAWK_EINVAL);
+	 * custom environment handling without redirecting stdin/out/err. */
-		goto oops;
-	}
 
 	if ((flags & HAWK_PIO_INTONUL) ||
 	    (flags & HAWK_PIO_OUTTONUL) ||
@@ -1050,11 +1048,7 @@ create_process:
 		maxidx = 5;
 	}
 
-	if (maxidx == -1)
+	/* allow a pure spawn/wait use case with no dedicated pipes. */
-	{
-		hawk_gem_seterrnum(pio->gem, HAWK_NULL, HAWK_EINVAL);
-		goto oops;
-	}
 
 	if ((flags & HAWK_PIO_INTONUL) ||
 	    (flags & HAWK_PIO_OUTTONUL) ||
@@ -1320,11 +1314,7 @@ create_process:
 		maxidx = 5;
 	}
 
-	if (maxidx == -1)
+	/* allow a pure spawn/wait use case with no dedicated pipes. */
-	{
-		hawk_gem_seterrnum(pio->gem, HAWK_NULL, HAWK_EINVAL);
-		goto oops;
-	}
 
 	if (pio->flags & HAWK_PIO_FNCCMD)
 	{
@@ -1340,7 +1330,7 @@ create_process:
 
 		if (env_mk)
 		{
-			envp = (char*const*)env_mk(HAWK_PIO_ENV_MK_BCH_PP, env_ctx);
+			envp = (char*const*)env_mk(HAWK_PIO_ENV_MK_BPP, env_ctx);
 			if (HAWK_UNLIKELY(!envp)) goto oops;
 			/* pio doesn't free the memory block returned by the callback function.
 			 * there is no callback triggered for dealloction either.

lib/run.c

@@ -1264,6 +1264,7 @@ void hawk_rtx_getrio (hawk_rtx_t* rtx, hawk_rio_cbs_t* rio)
 	rio->pipe = rtx->rio.handler[HAWK_RIO_PIPE];
 	rio->file = rtx->rio.handler[HAWK_RIO_FILE];
 	rio->console = rtx->rio.handler[HAWK_RIO_CONSOLE];
+	rio->env_mk = rtx->rio.env_mk;
 }
 
 void hawk_rtx_setrio (hawk_rtx_t* rtx, const hawk_rio_cbs_t* rio)
@@ -1271,6 +1272,7 @@ void hawk_rtx_setrio (hawk_rtx_t* rtx, const hawk_rio_cbs_t* rio)
 	rtx->rio.handler[HAWK_RIO_PIPE] = rio->pipe;
 	rtx->rio.handler[HAWK_RIO_FILE] = rio->file;
 	rtx->rio.handler[HAWK_RIO_CONSOLE] = rio->console;
+	rtx->rio.env_mk = rio->env_mk;
 }
 
 void hawk_rtx_killecb (hawk_rtx_t* rtx, hawk_rtx_ecb_t* ecb)
@@ -1415,6 +1417,7 @@ static int init_rtx (hawk_rtx_t* rtx, hawk_t* hawk, hawk_rio_cbs_t* rio)
 		rtx->rio.handler[HAWK_RIO_PIPE] = rio->pipe;
 		rtx->rio.handler[HAWK_RIO_FILE] = rio->file;
 		rtx->rio.handler[HAWK_RIO_CONSOLE] = rio->console;
+		rtx->rio.env_mk = rio->env_mk;
 		rtx->rio.chain = HAWK_NULL;
 	}
 

lib/std.c

@@ -212,14 +212,6 @@ static HAWK_INLINE rxtn_t* GET_RXTN(hawk_rtx_t* rtx) { return (rxtn_t*)((hawk_ui
 
 /* ========================================================================= */
 
-/* TODO: use wenviron where it's available */
-typedef hawk_bch_t env_char_t;
-#define ENV_CHAR_IS_BCH
-
-
-static env_char_t** commit_environ (hawk_rtx_t* rtx, int gbl_id);
-/* ========================================================================= */
-
 static void* sys_alloc (hawk_mmgr_t* mmgr, hawk_oow_t size)
 {
 	return malloc(size);
@@ -2048,17 +2040,16 @@ static int parse_rwpipe_uri (const hawk_ooch_t* uri, int* flags, hawk_nwad_t* nw
 }
 #endif
 
-static void* envp_maker (hawk_pio_env_mk_type_t env_mk_type, void* ctx)
+static void* rtx_env_maker (hawk_rtx_t* rtx, hawk_rtx_env_mk_type_t env_mk_type)
 {
-	hawk_rtx_t* rtx = ctx;
 	hawk_t* hawk = hawk_rtx_gethawk(rtx);
 
-	if (env_mk_type == HAWK_PIO_ENV_MK_BCH_PP)
+	if (env_mk_type == HAWK_RTX_ENV_MK_BPP)
 	{
 		hawk_val_t* v_env;
 		hawk_map_t* env_map;
 		hawk_oow_t env_map_rev;
-		env_char_t** envp;
+		hawk_env_char_t** envp;
 		xtn_t* xtn;
 		rxtn_t* rxtn;
 
@@ -2079,12 +2070,11 @@ static void* envp_maker (hawk_pio_env_mk_type_t env_mk_type, void* ctx)
 			env_map_rev = 0;
 		}
 
-		if (!rxtn->envp ||
+		if (!rxtn->envp || rxtn->env_map != env_map ||
-		    rxtn->env_map != env_map ||
 		    (env_map && rxtn->env_map_rev != env_map_rev))
 		{
-			envp = commit_environ(rtx, xtn->gbl_environ);
+			envp = hawk_rtx_commit_environ(rtx, xtn->gbl_environ);
-			if (!envp) return HAWK_NULL;
+			if (HAWK_UNLIKELY(!envp)) return HAWK_NULL;
 
 			if (rxtn->envp) hawk_rtx_freemem(rtx, rxtn->envp);
 			rxtn->envp = envp;
@@ -2100,6 +2090,15 @@ static void* envp_maker (hawk_pio_env_mk_type_t env_mk_type, void* ctx)
 	return HAWK_NULL;
 }
 
+static void* pio_env_maker (hawk_pio_env_mk_type_t env_mk_type, void* ctx)
+{
+	hawk_rtx_t* rtx = (hawk_rtx_t*)ctx;
+	/* pio_handler_open passes pio_env_maker to hawk_pio_open
+	 * only if rtx->rio.env_make is not HAWK_NULL */
+	HAWK_ASSERT(rtx->rio.env_mk != HAWK_NULL);
+	return rtx->rio.env_mk(rtx, env_mk_type);
+}
+
 static hawk_ooi_t pio_handler_open (hawk_rtx_t* rtx, hawk_rio_arg_t* riod)
 {
 	hawk_pio_t* handle;
@@ -2139,7 +2138,7 @@ static hawk_ooi_t pio_handler_open (hawk_rtx_t* rtx, hawk_rio_arg_t* riod)
 		0,
 		riod->name,
 		flags | HAWK_PIO_SHELL | HAWK_PIO_TEXT | HAWK_PIO_IGNOREECERR,
-		envp_maker,
+		(rtx->rio.env_mk? pio_env_maker: HAWK_NULL),
 		rtx
 	);
 	if (!handle) return -1;
@@ -2950,7 +2949,7 @@ static int build_argcv (hawk_rtx_t* rtx, int argc_id, int argv_id, const hawk_oo
 	return 0;
 }
 
-static int build_environ (hawk_rtx_t* rtx, int gbl_id, env_char_t* envarr[])
+static int build_environ (hawk_rtx_t* rtx, int gbl_id, hawk_env_char_t* envarr[])
 {
 	hawk_val_t* v_env;
 	hawk_val_t* v_tmp;
@@ -2962,14 +2961,14 @@ static int build_environ (hawk_rtx_t* rtx, int gbl_id, env_char_t* envarr[])
 
 	if (envarr)
 	{
-		env_char_t* eq;
+		hawk_env_char_t* eq;
 		hawk_ooch_t* kptr, * vptr;
 		hawk_oow_t klen, vlen, count;
 
 		for (count = 0; envarr[count]; count++)
 		{
-		#if ((defined(ENV_CHAR_IS_BCH) && defined(HAWK_OOCH_IS_BCH)) || \
+		#if ((defined(HAWK_ENV_CHAR_IS_BCH) && defined(HAWK_OOCH_IS_BCH)) || \
-		     (defined(ENV_CHAR_IS_UCH) && defined(HAWK_OOCH_IS_UCH)))
+		     (defined(HAWK_ENV_CHAR_IS_UCH) && defined(HAWK_OOCH_IS_UCH)))
 			eq = hawk_find_oochar_in_oocstr(envarr[count], '=');
 			if (HAWK_UNLIKELY(!eq || eq == envarr[count])) continue;
 
@@ -2977,7 +2976,7 @@ static int build_environ (hawk_rtx_t* rtx, int gbl_id, env_char_t* envarr[])
 			klen = eq - envarr[count];
 			vptr = eq + 1;
 			vlen = hawk_count_oocstr(vptr);
-		#elif defined(ENV_CHAR_IS_BCH)
+		#elif defined(HAWK_ENV_CHAR_IS_BCH)
 			eq = hawk_find_bchar_in_bcstr(envarr[count], '=');
 			if (HAWK_UNLIKELY(!eq || eq == envarr[count])) continue;
 
@@ -3023,8 +3022,8 @@ static int build_environ (hawk_rtx_t* rtx, int gbl_id, env_char_t* envarr[])
 			v_tmp = hawk_rtx_makenumorstrvalwithoochars(rtx, vptr, vlen, 1);
 			if (HAWK_UNLIKELY(!v_tmp))
 			{
-		#if ((defined(ENV_CHAR_IS_BCH) && defined(HAWK_OOCH_IS_BCH)) || \
+		#if ((defined(HAWK_ENV_CHAR_IS_BCH) && defined(HAWK_OOCH_IS_BCH)) || \
-		     (defined(ENV_CHAR_IS_UCH) && defined(HAWK_OOCH_IS_UCH)))
+		     (defined(HAWK_ENV_CHAR_IS_UCH) && defined(HAWK_OOCH_IS_UCH)))
 				/* nothing to do */
 		#else
 				if (vptr) hawk_rtx_freemem(rtx, vptr);
@@ -3044,8 +3043,8 @@ static int build_environ (hawk_rtx_t* rtx, int gbl_id, env_char_t* envarr[])
 				 * the reference of v_tmp to free it */
 				hawk_rtx_refdownval_inline(rtx, v_tmp);
 
-		#if ((defined(ENV_CHAR_IS_BCH) && defined(HAWK_OOCH_IS_BCH)) || \
+		#if ((defined(HAWK_ENV_CHAR_IS_BCH) && defined(HAWK_OOCH_IS_BCH)) || \
-		     (defined(ENV_CHAR_IS_UCH) && defined(HAWK_OOCH_IS_UCH)))
+		     (defined(HAWK_ENV_CHAR_IS_UCH) && defined(HAWK_OOCH_IS_UCH)))
 				/* nothing to do */
 		#else
 				if (vptr) hawk_rtx_freemem(rtx, vptr);
@@ -3059,8 +3058,8 @@ static int build_environ (hawk_rtx_t* rtx, int gbl_id, env_char_t* envarr[])
 				return -1;
 			}
 
-		#if ((defined(ENV_CHAR_IS_BCH) && defined(HAWK_OOCH_IS_BCH)) || \
+		#if ((defined(HAWK_ENV_CHAR_IS_BCH) && defined(HAWK_OOCH_IS_BCH)) || \
-		     (defined(ENV_CHAR_IS_UCH) && defined(HAWK_OOCH_IS_UCH)))
+		     (defined(HAWK_ENV_CHAR_IS_UCH) && defined(HAWK_OOCH_IS_UCH)))
 				/* nothing to do */
 		#else
 			if (vptr) hawk_rtx_freemem(rtx, vptr);
@@ -3079,14 +3078,14 @@ static int build_environ (hawk_rtx_t* rtx, int gbl_id, env_char_t* envarr[])
 	return 0;
 }
 
-static env_char_t** commit_environ (hawk_rtx_t* rtx, int gbl_id)
+hawk_bch_t** hawk_rtx_commit_environ (hawk_rtx_t* rtx, int gbl_id)
 {
 	hawk_val_t* v_env;
 	hawk_map_t* map;
 	hawk_map_itr_t itr;
 	hawk_map_pair_t* pair;
-	env_char_t** envp;
+	hawk_env_char_t** envp;
-	env_char_t* ptr;
+	hawk_env_char_t* ptr;
 	hawk_oow_t count, ptr_bytes, str_bytes;
 
 	v_env = hawk_rtx_getgbl(rtx, gbl_id);
@@ -3096,7 +3095,7 @@ static env_char_t** commit_environ (hawk_rtx_t* rtx, int gbl_id)
 	{
 		/* it may be nil. but we can't prevent ENVIRON from being set to
 		 * other scalar types, we should handle this case gracefully */
-		envp = (env_char_t**)hawk_rtx_allocmem(rtx, HAWK_SIZEOF(*envp) * 1);
+		envp = (hawk_env_char_t**)hawk_rtx_allocmem(rtx, HAWK_SIZEOF(*envp) * 1);
 		if (HAWK_UNLIKELY(!envp)) return HAWK_NULL;
 		envp[0] = HAWK_NULL;
 		return envp;
@@ -3115,14 +3114,14 @@ static env_char_t** commit_environ (hawk_rtx_t* rtx, int gbl_id)
 		hawk_oow_t klen, vlen;
 
 		klen = HAWK_MAP_KLEN(pair);
-#if defined(ENV_CHAR_IS_BCH) && defined(HAWK_OOCH_IS_UCH)
+#if defined(HAWK_ENV_CHAR_IS_BCH) && defined(HAWK_OOCH_IS_UCH)
 		{
 			hawk_oow_t tmp_ulen, tmp_blen;
 			tmp_ulen = klen;
 			if (hawk_rtx_convutobchars(rtx, HAWK_MAP_KPTR(pair), &tmp_ulen, HAWK_NULL, &tmp_blen) <= -1) return HAWK_NULL;
 			klen = tmp_blen;
 		}
-#elif defined(ENV_CHAR_IS_UCH) && defined(HAWK_OOCH_IS_BCH)
+#elif defined(HAWK_ENV_CHAR_IS_UCH) && defined(HAWK_OOCH_IS_BCH)
 		{
 			hawk_oow_t tmp_blen, tmp_ulen;
 			tmp_blen = klen;
@@ -3131,7 +3130,7 @@ static env_char_t** commit_environ (hawk_rtx_t* rtx, int gbl_id)
 		}
 #endif
 
-#if defined(ENV_CHAR_IS_BCH)
+#if defined(HAWK_ENV_CHAR_IS_BCH)
 		{
 			hawk_bch_t* vptr;
 			vptr = hawk_rtx_getvalbcstr(rtx, HAWK_MAP_VPTR(pair), &vlen);
@@ -3153,10 +3152,10 @@ static env_char_t** commit_environ (hawk_rtx_t* rtx, int gbl_id)
 	}
 
 	ptr_bytes = HAWK_SIZEOF(*envp) * (count + 1);
-	envp = (env_char_t**)hawk_rtx_allocmem(rtx, ptr_bytes + (str_bytes * HAWK_SIZEOF(*ptr)));
+	envp = (hawk_env_char_t**)hawk_rtx_allocmem(rtx, ptr_bytes + (str_bytes * HAWK_SIZEOF(*ptr)));
 	if (HAWK_UNLIKELY(!envp)) return HAWK_NULL;
 
-	ptr = (env_char_t*)((hawk_uint8_t*)envp + ptr_bytes);
+	ptr = (hawk_env_char_t*)((hawk_uint8_t*)envp + ptr_bytes);
 	count = 0;
 
 	hawk_init_map_itr(&itr, 0);
@@ -3168,11 +3167,11 @@ static env_char_t** commit_environ (hawk_rtx_t* rtx, int gbl_id)
 		envp[count++] = ptr;
 		klen = HAWK_MAP_KLEN(pair);
 
-#if ((defined(ENV_CHAR_IS_BCH) && defined(HAWK_OOCH_IS_BCH)) || \
+#if ((defined(HAWK_ENV_CHAR_IS_BCH) && defined(HAWK_OOCH_IS_BCH)) || \
-     (defined(ENV_CHAR_IS_UCH) && defined(HAWK_OOCH_IS_UCH)))
+     (defined(HAWK_ENV_CHAR_IS_UCH) && defined(HAWK_OOCH_IS_UCH)))
 		HAWK_MEMCPY(ptr, HAWK_MAP_KPTR(pair), klen);
 		ptr += klen;
-#elif defined(ENV_CHAR_IS_BCH)
+#elif defined(HAWK_ENV_CHAR_IS_BCH)
 		{
 			hawk_oow_t tmp_ulen, tmp_blen;
 
@@ -3204,7 +3203,7 @@ static env_char_t** commit_environ (hawk_rtx_t* rtx, int gbl_id)
 
 		*ptr++ = '=';
 
-#if defined(ENV_CHAR_IS_BCH)
+#if defined(HAWK_ENV_CHAR_IS_BCH)
 		{
 			hawk_bch_t* vptr;
 
@@ -3251,7 +3250,6 @@ static int make_additional_globals (hawk_rtx_t* rtx, xtn_t* xtn, const hawk_ooch
 #else
 	extern char** environ;
 #endif
-
 	if (build_argcv(rtx, xtn->gbl_argc, xtn->gbl_argv, id, icf) <= -1 ||
 	    build_environ(rtx, xtn->gbl_environ, environ) <= -1) return -1;
 	return 0;
@@ -3276,6 +3274,7 @@ static hawk_rtx_t* open_rtx_std (
 	rio.pipe = hawk_rio_pipe;
 	rio.file = hawk_rio_file;
 	rio.console = hawk_rio_console;
+	rio.env_mk = rtx_env_maker;
 
 	rtx = hawk_rtx_open(hawk, HAWK_SIZEOF(rxtn_t) + xtnsize, &rio);
 	if (HAWK_UNLIKELY(!rtx)) return HAWK_NULL;
@@ -3528,6 +3527,8 @@ done:
 	return rtx;
 }
 
+/* ------------------------------------------------------- */
+
 static int timeout_code (const hawk_ooch_t* name)
 {
 	if (hawk_comp_oocstr(name, HAWK_T("rtimeout"), 1) == 0) return 0;

samples/hawk51.cpp

@@ -62,6 +62,7 @@ static void do_nothing (int sig);
 #endif
 static void relay_signal (int sig);
 static int setsignal (int sig, void(*handler)(int), int restart);
+static void print_debug_return (hawk_rtx_t* rtx, hawk_val_t* ret);
 
 class MyHawk: public HawkStd
 {
@@ -221,11 +222,20 @@ static void print_error(MyHawk& hawk)
 
 	if (loc.file)
 	{
-		print_error("code %d line %lu at %s - %s\n", (int)code, (unsigned long int)loc.line, hawk.getErrorLocationFileB(), hawk.getErrorMessageB());
+		print_error("Line %lu Column %lu Code %d File %s - %s\n",
+			(unsigned long int)loc.line,
+			(unsigned long int)loc.colm,
+			(int)code,
+			hawk.getErrorLocationFileB(),
+			hawk.getErrorMessageB());
 	}
 	else
 	{
-		print_error("code %d line %lu - %s\n", (int)code, (unsigned long int)loc.line, hawk.getErrorMessageB());
+		print_error("Line %lu Column %lu Code %d - %s\n",
+			(unsigned long int)loc.line,
+			(unsigned long int)loc.colm,
+			(int)code,
+			hawk.getErrorMessageB());
 	}
 }
 
@@ -307,6 +317,7 @@ static void print_usage (FILE* out, const hawk_bch_t* argv0)
 	fprintf(out, "       %s [options] [ -- ] sourcestring [datafile]*\n", argv0);
 	fprintf(out, "Where options are:\n");
 	fprintf(out, " -h                print this message\n");
+	fprintf(out, " -D                show extra information\n");
 	fprintf(out, " -f sourcefile     set the source script file\n");
 	fprintf(out, " -d deparsedfile   set the deparsing output file\n");
 	fprintf(out, " -o outputfile     set the console output file\n");
@@ -339,8 +350,99 @@ struct cmdline_t
 
 	HAWK::Hawk::Value* argv;
 	int argc;
+	int debug;
 };
 
+static void print_awk_value (hawk_rtx_t* rtx, const hawk_oocs_t* name, hawk_val_t* val)
+{
+	hawk_t* hawk = hawk_rtx_gethawk(rtx);
+	hawk_bch_t* str;
+	hawk_oow_t len;
+	hawk_errinf_t oerrinf;
+#if defined(HAWK_OOCH_IS_UCH)
+	hawk_bch_t* bcname = HAWK_NULL;
+#endif
+
+	hawk_rtx_geterrinf(rtx, &oerrinf);
+
+	str = hawk_rtx_valtobcstrdup(rtx, val, &len);
+	if (!str)
+	{
+		if (hawk_rtx_geterrnum(rtx) == HAWK_EVALTOSTR)
+		{
+		#if defined(HAWK_OOCH_IS_UCH)
+			bcname = hawk_rtx_duputobchars(rtx, name->ptr, name->len, HAWK_NULL);
+			if (bcname)
+			{
+				fprintf(stderr, "%s = [not printable]\n", bcname);
+				hawk_rtx_freemem(rtx, bcname);
+			}
+			else
+			{
+				fprintf(stderr, "***OUT OF MEMORY***\n");
+			}
+		#else
+			fprintf(stderr, "%.*s = [not printable]\n", (int)name->len, name->ptr);
+		#endif
+			hawk_rtx_seterrinf(rtx, &oerrinf);
+		}
+		else
+		{
+			fprintf(stderr, "***OUT OF MEMORY***\n");
+		}
+	}
+	else
+	{
+	#if defined(HAWK_OOCH_IS_UCH)
+		bcname = hawk_rtx_duputobchars(rtx, name->ptr, name->len, HAWK_NULL);
+		if (!bcname)
+		{
+			fprintf(stderr, "***OUT OF MEMORY***\n");
+			hawk_freemem(hawk, str);
+			return;
+		}
+		fprintf(stderr, "%s = %.*s\n", bcname, (int)len, str);
+		hawk_rtx_freemem(rtx, bcname);
+	#else
+		fprintf(stderr, "%.*s = %.*s\n", (int)name->len, name->ptr, (int)len, str);
+	#endif
+		hawk_freemem(hawk, str);
+	}
+}
+
+static void print_debug_return (hawk_rtx_t* rtx, hawk_val_t* ret)
+{
+	hawk_oow_t len;
+	hawk_bch_t* str;
+	hawk_rtx_nv_itr_t itr;
+	hawk_val_t* nv;
+
+	if (hawk_rtx_isnilval(rtx, ret))
+	{
+		fprintf(stderr, "[RETURN] - ***nil***\n");
+	}
+	else
+	{
+		str = hawk_rtx_valtobcstrdup(rtx, ret, &len);
+		if (!str)
+		{
+			fprintf(stderr, "[RETURN] - ***OUT OF MEMORY***\n");
+		}
+		else
+		{
+			fprintf(stderr, "[RETURN] - [%.*s]\n", (int)len, str);
+			hawk_freemem(hawk_rtx_gethawk(rtx), str);
+		}
+	}
+
+	fprintf(stderr, "[NAMED VARIABLES]\n");
+	for (nv = hawk_rtx_getfirstnv(rtx, &itr); nv; nv = hawk_rtx_getnextnv(rtx, &itr))
+	{
+		print_awk_value(rtx, &itr.name, nv);
+	}
+	fprintf(stderr, "[END OF NAMED VARIABLES]\n");
+}
+
 static void free_cmdline (cmdline_t* cmdline)
 {
 	if (cmdline->gvm)
@@ -398,7 +500,7 @@ static int handle_cmdline (MyHawk& hawk, int argc, hawk_bch_t* argv[], cmdline_t
 
 	static hawk_bcli_t opt =
 	{
-		"hF:f:d:o:I:v:",
+		"hDF:f:d:o:I:v:",
 		lng
 	};
 	hawk_bci_t c;
@@ -412,6 +514,10 @@ static int handle_cmdline (MyHawk& hawk, int argc, hawk_bch_t* argv[], cmdline_t
 				print_usage(stdout, argv[0]);
 				return 0;
 
+			case 'D':
+				cmdline->debug = 1;
+				break;
+
 			case 'F':
 				cmdline->fs = opt.arg;
 				break;
@@ -546,7 +652,7 @@ static int hawk_main (MyHawk& hawk, int argc, hawk_bch_t* argv[])
 	hawk.setTrait(hawk.getTrait() | HAWK_FLEXMAP | HAWK_RWPIPE | HAWK_NEXTOFILE);
 
 	// ARGV[0]
-	if (hawk.addArgument(HAWK_T("hawk51")) <= -1)
+	if (hawk.addArgument(argv[0]) <= -1)
 	{
 		print_error(hawk);
 		return -1;
@@ -653,6 +759,8 @@ static int hawk_main (MyHawk& hawk, int argc, hawk_bch_t* argv[])
 		return -1;
 	}
 
+	if (cmdline.debug) print_debug_return(*run, ret);
+
 	free_args_for_exec(&cmdline);
 	free_cmdline(&cmdline);
 	return 0;

t/err.sh

@@ -1,5 +1,26 @@
 #!/bin/sh
 
+hawk_bin="$1"
+shift
+
+hawk_lib_path="${LD_LIBRARY_PATH-}"
+case "$hawk_bin" in
+*/.libs/*)
+	libdir=$(cd "$(dirname "$hawk_bin")/../../lib/.libs" 2>/dev/null && pwd)
+	if [ -n "${libdir-}" ]
+	then
+		if [ -n "$hawk_lib_path" ]
+		then
+			hawk_lib_path="$libdir:$hawk_lib_path"
+		else
+			hawk_lib_path="$libdir"
+		fi
+	fi
+	;;
+esac
+export LD_LIBRARY_PATH="$hawk_lib_path"
+set -- "$hawk_bin" "$@"
+
 for i in $@; do :; done
 script="$i"
 
@@ -89,4 +110,3 @@ done < "$script"
 
 rm -f "$partfile"
 exit $ever_failed
-

t/regress-environ.sh

@@ -5,18 +5,47 @@
 
 set -u
 
+hawk_lib_path="${LD_LIBRARY_PATH-}"
+case "$HAWK_BIN" in
+*/.libs/*)
+	libdir=$(cd "$(dirname "$HAWK_BIN")/../../lib/.libs" 2>/dev/null && pwd)
+	if [ -n "${libdir-}" ]
+	then
+		if [ -n "$hawk_lib_path" ]
+		then
+			hawk_lib_path="$libdir:$hawk_lib_path"
+		else
+			hawk_lib_path="$libdir"
+		fi
+	fi
+	;;
+esac
+
 tmp_prog="/tmp/hawk-regress-environ-$$.hawk"
 tmp_pipe="/tmp/hawk-regress-environ-$$.pipe"
-trap 'rm -f "$tmp_prog" "$tmp_pipe"' EXIT
+tmp_sys="/tmp/hawk-regress-environ-$$.sys"
+trap 'rm -f "$tmp_prog" "$tmp_pipe" "$tmp_sys"' EXIT
 
-cat > "$tmp_prog" <<'EOF'
+cat > "$tmp_prog" <<EOF
 function emit_env(tag, cmd)
 {
-	cmd = "sh -c 'printf \"" tag ":%s\\n\" \"${HAWK_TEST_ENV_PIPE-unset}\" >&3'"
+	cmd = "sh -c 'printf \"" tag ":%s\\n\" \"\${HAWK_TEST_ENV_PIPE-unset}\" >&3'"
 	print "" | cmd
 	close(cmd)
 }
 
+function emit_env_system(tag, cmd)
+{
+	cmd = "sh -c 'printf \"" tag ":%s\\n\" \"\${HAWK_TEST_ENV_SYS-unset}\" >> $tmp_sys'"
+	return sys::system(cmd)
+}
+
+function emit_env_system_fd3(tag, cmd)
+{
+	cmd = "sh -c 'printf \"" tag ":%s\\n\" \"\${HAWK_TEST_ENV_SYS-unset}\" >&3'"
+	return sys::system(cmd)
+}
+
 BEGIN {
 	print hawk::typename(ENVIRON["HAWK_TEST_ENV_INT"]) ":" ENVIRON["HAWK_TEST_ENV_INT"];
 	print hawk::typename(ENVIRON["HAWK_TEST_ENV_NEG"]) ":" ENVIRON["HAWK_TEST_ENV_NEG"];
@@ -38,15 +67,24 @@ BEGIN {
 	print hawk::typename(ENVIRON["HAWK_TEST_ENV_STR"]) ":" hawk::isnil(ENVIRON["HAWK_TEST_ENV_STR"]);
 
 	emit_env("initial");
+	print emit_env_system("initial");
 	ENVIRON["HAWK_TEST_ENV_PIPE"] = "changed";
+	ENVIRON["HAWK_TEST_ENV_SYS"] = "changed";
 	emit_env("changed");
+	print emit_env_system("changed");
 	delete ENVIRON["HAWK_TEST_ENV_PIPE"];
+	delete ENVIRON["HAWK_TEST_ENV_SYS"];
 	emit_env("deleted");
+	print emit_env_system("deleted");
 	ENVIRON = @{};
 	ENVIRON["HAWK_TEST_ENV_PIPE"] = "replaced";
+	ENVIRON["HAWK_TEST_ENV_SYS"] = "replaced";
 	emit_env("replaced");
+	print emit_env_system("replaced");
 	ENVIRON = 123;
 	emit_env("scalar");
+	print emit_env_system("scalar");
+	print emit_env_system_fd3("fd3");
 }
 EOF
 
@@ -78,15 +116,20 @@ check_eq() {
 	fi
 }
 
-echo "1..16"
+echo "1..28"
 
 if out=$(env -i \
+	LD_LIBRARY_PATH="${hawk_lib_path-}" \
+	DYLD_LIBRARY_PATH="${DYLD_LIBRARY_PATH-}" \
+	SHLIB_PATH="${SHLIB_PATH-}" \
+	LIBPATH="${LIBPATH-}" \
 	HAWK_TEST_ENV_INT=123 \
 	HAWK_TEST_ENV_NEG=-7 \
 	HAWK_TEST_ENV_FLT=1.25 \
 	HAWK_TEST_ENV_STR=abc123 \
 	HAWK_TEST_ENV_EMPTY= \
 	HAWK_TEST_ENV_PIPE=initial \
+	HAWK_TEST_ENV_SYS=initial \
 	"$HAWK_BIN" -f "$tmp_prog" 3>"$tmp_pipe" 2>&1)
 then
 	ok "run environ regression"
@@ -105,11 +148,23 @@ line7=$(printf '%s\n' "$out" | sed -n '7p')
 line8=$(printf '%s\n' "$out" | sed -n '8p')
 line9=$(printf '%s\n' "$out" | sed -n '9p')
 line10=$(printf '%s\n' "$out" | sed -n '10p')
+line11=$(printf '%s\n' "$out" | sed -n '11p')
+line12=$(printf '%s\n' "$out" | sed -n '12p')
+line13=$(printf '%s\n' "$out" | sed -n '13p')
+line14=$(printf '%s\n' "$out" | sed -n '14p')
+line15=$(printf '%s\n' "$out" | sed -n '15p')
+line16=$(printf '%s\n' "$out" | sed -n '16p')
 pipe1=$(sed -n '1p' "$tmp_pipe")
 pipe2=$(sed -n '2p' "$tmp_pipe")
 pipe3=$(sed -n '3p' "$tmp_pipe")
 pipe4=$(sed -n '4p' "$tmp_pipe")
 pipe5=$(sed -n '5p' "$tmp_pipe")
+pipe6=$(sed -n '6p' "$tmp_pipe")
+sys1=$(sed -n '1p' "$tmp_sys")
+sys2=$(sed -n '2p' "$tmp_sys")
+sys3=$(sed -n '3p' "$tmp_sys")
+sys4=$(sed -n '4p' "$tmp_sys")
+sys5=$(sed -n '5p' "$tmp_sys")
 
 check_eq "int env imported as int" "int:123" "$line1"
 check_eq "negative int env imported as int" "int:-7" "$line2"
@@ -121,10 +176,22 @@ check_eq "assigned int remains int" "int:456" "$line7"
 check_eq "assigned float remains flt" "flt:7.5" "$line8"
 check_eq "assigned string remains str" "str:xyz" "$line9"
 check_eq "deleted env entry becomes nil" "nil:1" "$line10"
+check_eq "system initial returned success" "0" "$line11"
+check_eq "system changed returned success" "0" "$line12"
+check_eq "system deleted returned success" "0" "$line13"
+check_eq "system replaced returned success" "0" "$line14"
+check_eq "system scalar returned success" "0" "$line15"
+check_eq "system fd3 returned success" "0" "$line16"
 check_eq "pipe sees initial imported env" "initial:initial" "$pipe1"
 check_eq "pipe sees in-place env update" "changed:changed" "$pipe2"
 check_eq "pipe sees deleted env entry" "deleted:unset" "$pipe3"
 check_eq "pipe sees replaced environ map" "replaced:replaced" "$pipe4"
 check_eq "pipe sees scalar environ as empty" "scalar:unset" "$pipe5"
+check_eq "system preserves fd3 inheritance" "fd3:unset" "$pipe6"
+check_eq "system sees initial imported env" "initial:initial" "$sys1"
+check_eq "system sees in-place env update" "changed:changed" "$sys2"
+check_eq "system sees deleted env entry" "deleted:unset" "$sys3"
+check_eq "system sees replaced environ map" "replaced:replaced" "$sys4"
+check_eq "system sees scalar environ as empty" "scalar:unset" "$sys5"
 
 exit "$failed"

t/regress-extra-info.sh

@@ -5,6 +5,23 @@
 
 set -u
 
+hawk_lib_path="${LD_LIBRARY_PATH-}"
+case "$HAWK_BIN" in
+*/.libs/*)
+	libdir=$(cd "$(dirname "$HAWK_BIN")/../../lib/.libs" 2>/dev/null && pwd)
+	if [ -n "${libdir-}" ]
+	then
+		if [ -n "$hawk_lib_path" ]
+		then
+			hawk_lib_path="$libdir:$hawk_lib_path"
+		else
+			hawk_lib_path="$libdir"
+		fi
+	fi
+	;;
+esac
+export LD_LIBRARY_PATH="$hawk_lib_path"
+
 test_no=0
 failed=0
 

t/regress-filename.sh

@@ -7,6 +7,23 @@
 ## make referecing an unset variable an error
 set -u
 
+hawk_lib_path="${LD_LIBRARY_PATH-}"
+case "$HAWK_BIN" in
+*/.libs/*)
+	libdir=$(cd "$(dirname "$HAWK_BIN")/../../lib/.libs" 2>/dev/null && pwd)
+	if [ -n "${libdir-}" ]
+	then
+		if [ -n "$hawk_lib_path" ]
+		then
+			hawk_lib_path="$libdir:$hawk_lib_path"
+		else
+			hawk_lib_path="$libdir"
+		fi
+	fi
+	;;
+esac
+export LD_LIBRARY_PATH="$hawk_lib_path"
+
 tmp_in="/tmp/hawk-regress-stdin-$$.txt"
 tmp_f1="/tmp/hawk-regress-file-1-$$.txt"
 tmp_f2="/tmp/hawk regress file 2-$$.txt"

t/run-hawk-test.sh

@@ -1,12 +1,32 @@
 #!/bin/sh
 
+hawk_bin="${HAWK_TEST_COMPILER:-../bin/hawk}"
+hawk_lib_path="${LD_LIBRARY_PATH-}"
+
+case "$hawk_bin" in
+*/.libs/*)
+	libdir=$(cd "$(dirname "$hawk_bin")/../../lib/.libs" 2>/dev/null && pwd)
+	if [ -n "${libdir-}" ]
+	then
+		if [ -n "$hawk_lib_path" ]
+		then
+			hawk_lib_path="$libdir:$hawk_lib_path"
+		else
+			hawk_lib_path="$libdir"
+		fi
+	fi
+	;;
+esac
+
+export LD_LIBRARY_PATH="$hawk_lib_path"
+
 if [ "${VALGRIND:-0}" = "1" ]
 then
 	vglog="/tmp/hawk-valgrind-$$.log"
 	vgerr="${VALGRIND_ERROR_EXITCODE:-99}"
 	trap 'rm -f "$vglog"' EXIT
 
-	${VALGRIND_CMD:-valgrind} ${VALGRIND_FLAGS:-} --log-file="$vglog" "${HAWK_TEST_COMPILER:-../bin/hawk}" "$@"
+	${VALGRIND_CMD:-valgrind} ${VALGRIND_FLAGS:-} --log-file="$vglog" "$hawk_bin" "$@"
 	status=$?
 
 	if [ -f "$vglog" ]
@@ -31,5 +51,5 @@ then
 
 	exit "$status"
 else
-	exec "${HAWK_TEST_COMPILER:-../bin/hawk}" "$@"
+	exec "$hawk_bin" "$@"
 fi