removed redundant return in a void function

refactored htb and rbt a bit

README.md

@@ -723,6 +723,9 @@ Common built-ins:
 - `NR`, `FNR`, `NF`
 - `FS`, `RS`, `OFS`, `ORS`
 - `FILENAME`, `OFILENAME`
+- `ARGC`, `ARGV`
+- `ENVIRON`
+- `PIPECLOEXEC`
 
 Example:
 
@@ -730,6 +733,27 @@ Example:
 { print NR, NF, $0 }
 ```
 
+Runtime-specific predefined variables:
+
+| Name | Type | Description |
+|------|------|-------------|
+| `ARGC` | int | number of command-line arguments available via `ARGV` |
+| `ARGV` | array | command-line argument vector. `ARGV[0]` is usually the program name |
+| `ENVIRON` | map | process environment as a map. Values imported from the host environment may become `int`, `flt`, or `str` depending on content |
+| `PIPECLOEXEC` | int/bool-like | controls whether file descriptors are opened with `CLOEXEC` when Hawk runs an external command for piping. `0` keeps the default inheritance behavior, `1` enables close-on-exec. This corresponds to `@pragma pipecloexec` |
+
+`ENVIRON` affects child processes started by piping and `sys::system()`. Modifying it changes the environment passed to those children without changing the process-global environment of the embedding application.
+
+Examples:
+
+```awk
+BEGIN {
+	print ARGC, ARGV[0]
+	print ENVIRON["HOME"]
+	PIPECLOEXEC = 1
+}
+```
+
 ## Built-in Functions
 
 Hawk includes awk built-ins (e.g., `length`, `substr`, `split`, `index`) plus extensions in modules (see below).

lib/gem-glob.c

@@ -34,6 +34,7 @@
 #include <hawk-ecs.h>
 #include <hawk-dir.h>
 #include <hawk-glob.h>
+#include <hawk-utl.h>
 
 #if defined(_WIN32)
 #	include <windows.h>
@@ -60,7 +61,7 @@ typedef enum segment_type_t segment_type_t;
 
 
 #define IS_ESC(c) HAWK_FNMAT_IS_ESC(c)
-#define IS_SEP(c) HAWK_FNMAT_IS_SEP(c)
+#define IS_SEP(c) HAWK_IS_PATH_SEP(c)
 #define IS_NIL(c) ((c) == '\0')
 #define IS_SEP_OR_NIL(c) (IS_SEP(c) || IS_NIL(c))
 #define IS_DRIVE(c) HAWK_IS_PATH_DRIVE(c)

lib/gem-glob.c.m4

@@ -34,6 +34,7 @@
 #include <hawk-ecs.h>
 #include <hawk-dir.h>
 #include <hawk-glob.h>
+#include <hawk-utl.h>
 
 #if defined(_WIN32)
 #	include <windows.h>
@@ -60,7 +61,7 @@ typedef enum segment_type_t segment_type_t;
 
 
 #define IS_ESC(c) HAWK_FNMAT_IS_ESC(c)
-#define IS_SEP(c) HAWK_FNMAT_IS_SEP(c)
+#define IS_SEP(c) HAWK_IS_PATH_SEP(c)
 #define IS_NIL(c) ((c) == '\0')
 #define IS_SEP_OR_NIL(c) (IS_SEP(c) || IS_NIL(c))
 #define IS_DRIVE(c) HAWK_IS_PATH_DRIVE(c)

lib/hawk-str.h

@@ -72,10 +72,8 @@ enum hawk_fnmat_flag_t
 #if defined(_WIN32) || defined(__OS2__) || defined(__DOS__)
 	/* i don't support escaping in these systems */
 #	define HAWK_FNMAT_IS_ESC(c) (0)
-#	define HAWK_FNMAT_IS_SEP(c) ((c) == '/' || (c) == '\\')
 #else
 #	define HAWK_FNMAT_IS_ESC(c) ((c) == '\\')
-#	define HAWK_FNMAT_IS_SEP(c) ((c) == '/')
 #endif
 
 #if defined(__cplusplus)

lib/hawk-str.h.m4

@@ -72,10 +72,8 @@ enum hawk_fnmat_flag_t
 #if defined(_WIN32) || defined(__OS2__) || defined(__DOS__)
 	/* i don't support escaping in these systems */
 #	define HAWK_FNMAT_IS_ESC(c) (0)
-#	define HAWK_FNMAT_IS_SEP(c) ((c) == '/' || (c) == '\\')
 #else
 #	define HAWK_FNMAT_IS_ESC(c) ((c) == '\\')
-#	define HAWK_FNMAT_IS_SEP(c) ((c) == '/')
 #endif
 
 #if defined(__cplusplus)

lib/htb.c

@@ -46,7 +46,7 @@
 #define KTOB(htb,len) ((len) * (htb)->scale[HAWK_HTB_KEY])
 #define VTOB(htb,len) ((len) * (htb)->scale[HAWK_HTB_VAL])
 
-HAWK_INLINE pair_t* hawk_htb_allocpair (hawk_htb_t* htb, void* kptr, hawk_oow_t klen, void* vptr, hawk_oow_t vlen)
+static HAWK_INLINE_ALWAYS pair_t* alloc_pair (hawk_htb_t* htb, void* kptr, hawk_oow_t klen, void* vptr, hawk_oow_t vlen)
 {
 	pair_t* n;
 	copier_t kcop, vcop;
@@ -115,7 +115,7 @@ HAWK_INLINE pair_t* hawk_htb_allocpair (hawk_htb_t* htb, void* kptr, hawk_oow_t
 	return n;
 }
 
-HAWK_INLINE void hawk_htb_freepair (hawk_htb_t* htb, pair_t* pair)
+static HAWK_INLINE_ALWAYS void free_pair (hawk_htb_t* htb, pair_t* pair)
 {
 	if (htb->style->freeer[HAWK_HTB_KEY] != HAWK_NULL)
 		htb->style->freeer[HAWK_HTB_KEY](htb, KPTR(pair), KLEN(pair));
@@ -124,7 +124,17 @@ HAWK_INLINE void hawk_htb_freepair (hawk_htb_t* htb, pair_t* pair)
 	hawk_gem_freemem(htb->gem, pair);
 }
 
-static HAWK_INLINE pair_t* change_pair_val (hawk_htb_t* htb, pair_t* pair, void* vptr, hawk_oow_t vlen)
+pair_t* hawk_htb_allocpair (hawk_htb_t* htb, void* kptr, hawk_oow_t klen, void* vptr, hawk_oow_t vlen)
+{
+	return alloc_pair(htb, kptr, klen, vptr, vlen);
+}
+
+void hawk_htb_freepair (hawk_htb_t* htb, pair_t* pair)
+{
+	free_pair(htb, pair);
+}
+
+static HAWK_INLINE_ALWAYS pair_t* change_pair_val (hawk_htb_t* htb, pair_t* pair, void* vptr, hawk_oow_t vlen)
 {
 	if (VPTR(pair) == vptr && VLEN(pair) == vlen)
 	{
@@ -157,9 +167,9 @@ static HAWK_INLINE pair_t* change_pair_val (hawk_htb_t* htb, pair_t* pair, void*
 			else
 			{
 				/* need to reconstruct the pair */
-				pair_t* p = hawk_htb_allocpair(htb, KPTR(pair), KLEN(pair), vptr, vlen);
+				pair_t* p = alloc_pair(htb, KPTR(pair), KLEN(pair), vptr, vlen);
 				if (HAWK_UNLIKELY(!p)) return HAWK_NULL;
-				hawk_htb_freepair(htb, pair);
+				free_pair(htb, pair);
 				return p;
 			}
 		}
@@ -436,7 +446,7 @@ static HAWK_INLINE int reorganize (hawk_htb_t* htb)
 #define ENSERT 3
 #define INSERT 4
 
-static HAWK_INLINE pair_t* insert (hawk_htb_t* htb, void* kptr, hawk_oow_t klen, void* vptr, hawk_oow_t vlen, int opt)
+static HAWK_INLINE_ALWAYS pair_t* insert (hawk_htb_t* htb, void* kptr, hawk_oow_t klen, void* vptr, hawk_oow_t vlen, int opt)
 {
 	pair_t* pair, * p, * prev, * next;
 	hawk_oow_t hc;
@@ -507,7 +517,7 @@ static HAWK_INLINE pair_t* insert (hawk_htb_t* htb, void* kptr, hawk_oow_t klen,
 
 	HAWK_ASSERT(pair == HAWK_NULL);
 
-	pair = hawk_htb_allocpair(htb, kptr, klen, vptr, vlen);
+	pair = alloc_pair(htb, kptr, klen, vptr, vlen);
 	if (HAWK_UNLIKELY(!pair)) return HAWK_NULL; /* error */
 
 	NEXT(pair) = htb->bucket[hc];
@@ -617,7 +627,7 @@ int hawk_htb_delete (hawk_htb_t* htb, const void* kptr, hawk_oow_t klen)
 				htb->bucket[hc] = NEXT(pair);
 			else NEXT(prev) = NEXT(pair);
 
-			hawk_htb_freepair(htb, pair);
+			free_pair(htb, pair);
 			htb->size--;
 			htb->rev++;
 
@@ -645,7 +655,7 @@ void hawk_htb_clear (hawk_htb_t* htb)
 		while (pair)
 		{
 			next = NEXT(pair);
-			hawk_htb_freepair(htb, pair);
+			free_pair(htb, pair);
 			htb->size--;
 			pair = next;
 		}

lib/mod-sys.c

@@ -47,6 +47,7 @@
 #	endif
 
 #	include "syscall.h"
+#	include <sys/utsname.h>
 #	if defined(HAVE_SYS_EPOLL_H)
 #		include <sys/epoll.h>
 #		if defined(HAVE_EPOLL_CREATE)
@@ -337,6 +338,42 @@ static void set_errmsg_on_sys_list (hawk_rtx_t* rtx, sys_list_t* sys_list, const
 	}
 }
 
+static const hawk_bch_t* get_machine_name_for_build (void)
+{
+#if defined(__x86_64__) || defined(_M_X64)
+	return "x86_64";
+#elif defined(__i386__) || defined(_M_IX86)
+	return "x86";
+#elif defined(__aarch64__) || defined(_M_ARM64)
+	return "aarch64";
+#elif defined(__arm__) || defined(_M_ARM)
+	return "arm";
+#elif defined(__powerpc64__) || defined(__ppc64__)
+	return "ppc64";
+#elif defined(__powerpc__) || defined(__ppc__) || defined(_M_PPC)
+	return "ppc";
+#elif defined(__mips64)
+	return "mips64";
+#elif defined(__mips__)
+	return "mips";
+#elif defined(__riscv) && (__riscv_xlen == 64)
+	return "riscv64";
+#elif defined(__riscv) && (__riscv_xlen == 32)
+	return "riscv32";
+#elif defined(__sparc64__)
+	return "sparc64";
+#elif defined(__sparc__)
+	return "sparc";
+#else
+	return "unknown";
+#endif
+}
+
+static void copy_bcstr_to_oocstr (hawk_rtx_t* rtx, hawk_ooch_t* buf, hawk_oow_t capa, const hawk_bch_t* str)
+{
+	hawk_rtx_fmttooocstr(rtx, buf, capa, HAWK_T("%hs"), str);
+}
+
 /* ------------------------------------------------------------------------ */
 
 static sys_node_t* new_sys_node_fd (hawk_rtx_t* rtx, sys_list_t* list, int fd)
@@ -2332,6 +2369,147 @@ static int fnc_gettid (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 	return 0;
 }
 
+static int fnc_uname (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
+{
+	sys_list_t* sys_list = rtx_to_sys_list(rtx, fi);
+	hawk_val_t* retv;
+	hawk_ooch_t sysname[64], nodename[256], release[64], version[128], machine[64];
+
+#if defined(_WIN32)
+	OSVERSIONINFOEXA vi;
+	SYSTEM_INFO si;
+	DWORD nsz;
+
+	hawk_copy_oocstr(sysname, HAWK_COUNTOF(sysname), HAWK_T("Windows"));
+	hawk_copy_oocstr(nodename, HAWK_COUNTOF(nodename), HAWK_T("unknown"));
+	hawk_copy_oocstr(release, HAWK_COUNTOF(release), HAWK_T("unknown"));
+	hawk_copy_oocstr(version, HAWK_COUNTOF(version), HAWK_T("unknown"));
+	hawk_copy_oocstr(machine, HAWK_COUNTOF(machine), HAWK_T("unknown"));
+
+	nsz = HAWK_COUNTOF(nodename);
+#if defined(HAWK_OOCH_IS_UCH)
+	GetComputerNameW((LPWSTR)nodename, &nsz);
+#else
+	GetComputerNameA((LPSTR)nodename, &nsz);
+#endif
+
+	HAWK_MEMSET(&vi, 0, HAWK_SIZEOF(vi));
+	vi.dwOSVersionInfoSize = HAWK_SIZEOF(vi);
+	if (GetVersionExA((OSVERSIONINFOA*)&vi))
+	{
+		hawk_rtx_fmttooocstr(rtx, release, HAWK_COUNTOF(release), HAWK_T("%u.%u.%u"),
+			(unsigned)vi.dwMajorVersion, (unsigned)vi.dwMinorVersion, (unsigned)vi.dwBuildNumber);
+		if (vi.szCSDVersion[0] != '\0')
+		{
+			hawk_rtx_fmttooocstr(rtx, version, HAWK_COUNTOF(version), HAWK_T("build %u %hs"),
+				(unsigned)vi.dwBuildNumber, vi.szCSDVersion);
+		}
+		else
+		{
+			hawk_rtx_fmttooocstr(rtx, version, HAWK_COUNTOF(version), HAWK_T("build %u"),
+				(unsigned)vi.dwBuildNumber);
+		}
+	}
+
+	GetSystemInfo(&si);
+	switch (si.wProcessorArchitecture)
+	{
+		case PROCESSOR_ARCHITECTURE_AMD64:
+			hawk_copy_oocstr(machine, HAWK_COUNTOF(machine), HAWK_T("x86_64"));
+			break;
+		case PROCESSOR_ARCHITECTURE_INTEL:
+			hawk_copy_oocstr(machine, HAWK_COUNTOF(machine), HAWK_T("x86"));
+			break;
+		case PROCESSOR_ARCHITECTURE_ARM:
+			hawk_copy_oocstr(machine, HAWK_COUNTOF(machine), HAWK_T("arm"));
+			break;
+		case PROCESSOR_ARCHITECTURE_ARM64:
+			hawk_copy_oocstr(machine, HAWK_COUNTOF(machine), HAWK_T("aarch64"));
+			break;
+		case PROCESSOR_ARCHITECTURE_IA64:
+			hawk_copy_oocstr(machine, HAWK_COUNTOF(machine), HAWK_T("ia64"));
+			break;
+		default:
+			copy_bcstr_to_oocstr(rtx, machine, HAWK_COUNTOF(machine), get_machine_name_for_build());
+			break;
+	}
+
+#elif defined(__OS2__)
+	hawk_copy_oocstr(sysname, HAWK_COUNTOF(sysname), HAWK_T("OS/2"));
+	hawk_copy_oocstr(nodename, HAWK_COUNTOF(nodename), HAWK_T("unknown"));
+	hawk_copy_oocstr(release, HAWK_COUNTOF(release), HAWK_T("unknown"));
+	hawk_copy_oocstr(version, HAWK_COUNTOF(version), HAWK_T("unknown"));
+	copy_bcstr_to_oocstr(rtx, machine, HAWK_COUNTOF(machine), get_machine_name_for_build());
+
+#elif defined(__DOS__)
+	hawk_copy_oocstr(sysname, HAWK_COUNTOF(sysname), HAWK_T("DOS"));
+	hawk_copy_oocstr(nodename, HAWK_COUNTOF(nodename), HAWK_T("unknown"));
+	hawk_copy_oocstr(release, HAWK_COUNTOF(release), HAWK_T("unknown"));
+	hawk_copy_oocstr(version, HAWK_COUNTOF(version), HAWK_T("unknown"));
+	copy_bcstr_to_oocstr(rtx, machine, HAWK_COUNTOF(machine), get_machine_name_for_build());
+
+#else
+	struct utsname u;
+
+	if (uname(&u) <= -1)
+	{
+		hawk_copy_oocstr(sysname, HAWK_COUNTOF(sysname), HAWK_T("Linux/Unix"));
+		hawk_copy_oocstr(nodename, HAWK_COUNTOF(nodename), HAWK_T("unknown"));
+		hawk_copy_oocstr(release, HAWK_COUNTOF(release), HAWK_T("unknown"));
+		hawk_copy_oocstr(version, HAWK_COUNTOF(version), HAWK_T("unknown"));
+		copy_bcstr_to_oocstr(rtx, machine, HAWK_COUNTOF(machine), get_machine_name_for_build());
+	}
+	else
+	{
+		copy_bcstr_to_oocstr(rtx, sysname, HAWK_COUNTOF(sysname), (const hawk_bch_t*)u.sysname);
+		copy_bcstr_to_oocstr(rtx, nodename, HAWK_COUNTOF(nodename), (const hawk_bch_t*)u.nodename);
+		copy_bcstr_to_oocstr(rtx, release, HAWK_COUNTOF(release), (const hawk_bch_t*)u.release);
+		copy_bcstr_to_oocstr(rtx, version, HAWK_COUNTOF(version), (const hawk_bch_t*)u.version);
+		copy_bcstr_to_oocstr(rtx, machine, HAWK_COUNTOF(machine), (const hawk_bch_t*)u.machine);
+	}
+#endif
+
+	{
+		hawk_val_map_data_t md[5];
+		HAWK_MEMSET(md, 0, HAWK_SIZEOF(md));
+
+		md[0].key.ptr = HAWK_T("sysname");
+		md[0].key.len = 7;
+		md[0].type = HAWK_VAL_MAP_DATA_OOCSTR;
+		md[0].vptr = sysname;
+
+		md[1].key.ptr = HAWK_T("nodename");
+		md[1].key.len = 8;
+		md[1].type = HAWK_VAL_MAP_DATA_OOCSTR;
+		md[1].vptr = nodename;
+
+		md[2].key.ptr = HAWK_T("release");
+		md[2].key.len = 7;
+		md[2].type = HAWK_VAL_MAP_DATA_OOCSTR;
+		md[2].vptr = release;
+
+		md[3].key.ptr = HAWK_T("version");
+		md[3].key.len = 7;
+		md[3].type = HAWK_VAL_MAP_DATA_OOCSTR;
+		md[3].vptr = version;
+
+		md[4].key.ptr = HAWK_T("machine");
+		md[4].key.len = 7;
+		md[4].type = HAWK_VAL_MAP_DATA_OOCSTR;
+		md[4].vptr = machine;
+
+		retv = hawk_rtx_makemapvalwithdata(rtx, md, HAWK_COUNTOF(md));
+		if (HAWK_UNLIKELY(!retv))
+		{
+			copy_error_to_sys_list(rtx, sys_list);
+			return -1;
+		}
+	}
+
+	hawk_rtx_setretval(rtx, retv);
+	return 0;
+}
+
 static int fnc_getppid (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 {
 	hawk_int_t rx;
@@ -3096,7 +3274,7 @@ static int fnc_system (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 		0,
 		str,
 		HAWK_PIO_SHELL | HAWK_PIO_NOCLOEXEC,
-		(rtx->rio.env_mk? pio_env_maker: HAWK_NULL),
+		(rtx->rio.env_mk? pio_env_maker: (hawk_pio_env_mk_t)HAWK_NULL),
 		rtx
 	);
 
@@ -6124,6 +6302,7 @@ static hawk_mod_fnc_tab_t fnctab[] =
 	{ HAWK_T("tcgetattr"),   { { 2, 2, HAWK_T("vr")    }, fnc_tcgetattr,   0  } },
 	{ HAWK_T("tcsetattr"),   { { 3, 3, HAWK_NULL       }, fnc_tcsetattr,   0  } },
 	{ HAWK_T("tcsetraw"),    { { 1, 1, HAWK_NULL       }, fnc_tcsetraw,    0  } },
+	{ HAWK_T("uname"),       { { 0, 0, HAWK_NULL       }, fnc_uname,       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("wait"),        { { 1, 3, HAWK_T("vrv")   }, fnc_wait,        0  } },

lib/rbt.c

@@ -53,7 +53,7 @@
 #define rotate_left(rbt,pivot) rotate(rbt,pivot,1);
 #define rotate_right(rbt,pivot) rotate(rbt,pivot,0);
 
-HAWK_INLINE hawk_rbt_pair_t* hawk_rbt_allocpair (
+static HAWK_INLINE_ALWAYS hawk_rbt_pair_t* alloc_pair (
 	hawk_rbt_t* rbt, void* kptr, hawk_oow_t klen, void* vptr, hawk_oow_t vlen)
 {
 	hawk_rbt_pair_t* pair;
@@ -120,7 +120,7 @@ HAWK_INLINE hawk_rbt_pair_t* hawk_rbt_allocpair (
 	return pair;
 }
 
-HAWK_INLINE void hawk_rbt_freepair (hawk_rbt_t* rbt, hawk_rbt_pair_t* pair)
+static HAWK_INLINE_ALWAYS void free_pair (hawk_rbt_t* rbt, hawk_rbt_pair_t* pair)
 {
 	if (rbt->style->freeer[HAWK_RBT_KEY])
 		rbt->style->freeer[HAWK_RBT_KEY](rbt, KPTR(pair), KLEN(pair));
@@ -129,6 +129,16 @@ HAWK_INLINE void hawk_rbt_freepair (hawk_rbt_t* rbt, hawk_rbt_pair_t* pair)
 	hawk_gem_freemem(rbt->gem, pair);
 }
 
+hawk_rbt_pair_t* hawk_rbt_allocpair (hawk_rbt_t* rbt, void* kptr, hawk_oow_t klen, void* vptr, hawk_oow_t vlen)
+{
+	return alloc_pair(rbt, kptr, klen, vptr, vlen);
+}
+
+void hawk_rbt_freepair (hawk_rbt_t* rbt, hawk_rbt_pair_t* pair)
+{
+	free_pair(rbt, pair);
+}
+
 static hawk_rbt_style_t style[] =
 {
 	{
@@ -450,7 +460,7 @@ static hawk_rbt_pair_t* change_pair_val (hawk_rbt_t* rbt, hawk_rbt_pair_t* pair,
 			else
 			{
 				/* need to reconstruct the pair */
-				hawk_rbt_pair_t* p = hawk_rbt_allocpair(rbt, KPTR(pair), KLEN(pair), vptr, vlen);
+				hawk_rbt_pair_t* p = alloc_pair(rbt, KPTR(pair), KLEN(pair), vptr, vlen);
 				if (HAWK_UNLIKELY(!p)) return HAWK_NULL;
 
 				p->color = pair->color;
@@ -475,7 +485,7 @@ static hawk_rbt_pair_t* change_pair_val (hawk_rbt_t* rbt, hawk_rbt_pair_t* pair,
 
 				if (pair == rbt->root) rbt->root = p;
 
-				hawk_rbt_freepair(rbt, pair);
+				free_pair(rbt, pair);
 				return p;
 			}
 		}
@@ -539,7 +549,7 @@ static hawk_rbt_pair_t* insert (hawk_rbt_t* rbt, void* kptr, hawk_oow_t klen, vo
 		return HAWK_NULL;
 	}
 
-	x_new = hawk_rbt_allocpair(rbt, kptr, klen, vptr, vlen);
+	x_new = alloc_pair(rbt, kptr, klen, vptr, vlen);
 	if (HAWK_UNLIKELY(!x_new)) return HAWK_NULL;
 
 	if (x_par == HAWK_NULL)
@@ -819,7 +829,7 @@ static void delete_pair (hawk_rbt_t* rbt, hawk_rbt_pair_t* pair)
 		if (y->color == HAWK_RBT_BLACK && !IS_NIL(rbt,x))
 			adjust_for_delete(rbt, x, parent);
 
-		hawk_rbt_freepair(rbt, y);
+		free_pair(rbt, y);
 	}
 	else
 	{
@@ -844,7 +854,7 @@ static void delete_pair (hawk_rbt_t* rbt, hawk_rbt_pair_t* pair)
 		if (pair->left->parent == pair) pair->left->parent = y;
 		if (pair->right->parent == pair) pair->right->parent = y;
 
-		hawk_rbt_freepair(rbt, pair);
+		free_pair(rbt, pair);
 	}
 
 	rbt->size--;

lib/std.c

@@ -2133,7 +2133,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,
-		(rtx->rio.env_mk? pio_env_maker: HAWK_NULL),
+		(rtx->rio.env_mk? pio_env_maker: (hawk_pio_env_mk_t)HAWK_NULL),
 		rtx
 	);
 	if (!handle) return -1;

lib/utl-str.c

@@ -3261,14 +3261,14 @@ int hawk_fnmat_uchars_i (const hawk_uch_t* str, hawk_oow_t slen, const hawk_uch_
 			 * a period in the pattern explicitly
 			 */
 			if ((!no_first_period && sp == str) ||
-			    (HAWK_FNMAT_IS_SEP(sp[-1]) && (flags & HAWK_FNMAT_PATHNAME)))
+			    (HAWK_IS_PATH_SEP(sp[-1]) && (flags & HAWK_FNMAT_PATHNAME)))
 			{
 				if (pc != '.') return 0;
 				sp++; pp++;
 				continue;
 			}
 		}
-		else if (HAWK_FNMAT_IS_SEP(sc) && (flags & HAWK_FNMAT_PATHNAME))
+		else if (HAWK_IS_PATH_SEP(sc) && (flags & HAWK_FNMAT_PATHNAME))
 		{
 			while (pc == '*')
 			{
@@ -3277,7 +3277,7 @@ int hawk_fnmat_uchars_i (const hawk_uch_t* str, hawk_oow_t slen, const hawk_uch_
 			}
 
 			/* a path separator must be matched explicitly */
-			if (!HAWK_FNMAT_IS_SEP(pc)) return 0;
+			if (!HAWK_IS_PATH_SEP(pc)) return 0;
 			sp++; pp++;
 			continue;
 		}
@@ -3307,7 +3307,7 @@ int hawk_fnmat_uchars_i (const hawk_uch_t* str, hawk_oow_t slen, const hawk_uch_
 					const hawk_uch_t* s = sp;
 					for (s = sp; s < se; s++)
 					{
-						if (HAWK_FNMAT_IS_SEP(*s)) return 0;
+						if (HAWK_IS_PATH_SEP(*s)) return 0;
 					}
 				}
 				return 1;
@@ -3317,7 +3317,7 @@ int hawk_fnmat_uchars_i (const hawk_uch_t* str, hawk_oow_t slen, const hawk_uch_
 				do
 				{
 					if (hawk_fnmat_uchars_i(sp, se - sp, pp, pe - pp, flags, 1)) return 1;
-					if (HAWK_FNMAT_IS_SEP(*sp) && (flags & HAWK_FNMAT_PATHNAME)) break;
+					if (HAWK_IS_PATH_SEP(*sp) && (flags & HAWK_FNMAT_PATHNAME)) break;
 					sp++;
 				}
 				while (sp < se);
@@ -3492,14 +3492,14 @@ int hawk_fnmat_bchars_i (const hawk_bch_t* str, hawk_oow_t slen, const hawk_bch_
 			 * a period in the pattern explicitly
 			 */
 			if ((!no_first_period && sp == str) ||
-			    (HAWK_FNMAT_IS_SEP(sp[-1]) && (flags & HAWK_FNMAT_PATHNAME)))
+			    (HAWK_IS_PATH_SEP(sp[-1]) && (flags & HAWK_FNMAT_PATHNAME)))
 			{
 				if (pc != '.') return 0;
 				sp++; pp++;
 				continue;
 			}
 		}
-		else if (HAWK_FNMAT_IS_SEP(sc) && (flags & HAWK_FNMAT_PATHNAME))
+		else if (HAWK_IS_PATH_SEP(sc) && (flags & HAWK_FNMAT_PATHNAME))
 		{
 			while (pc == '*')
 			{
@@ -3508,7 +3508,7 @@ int hawk_fnmat_bchars_i (const hawk_bch_t* str, hawk_oow_t slen, const hawk_bch_
 			}
 
 			/* a path separator must be matched explicitly */
-			if (!HAWK_FNMAT_IS_SEP(pc)) return 0;
+			if (!HAWK_IS_PATH_SEP(pc)) return 0;
 			sp++; pp++;
 			continue;
 		}
@@ -3538,7 +3538,7 @@ int hawk_fnmat_bchars_i (const hawk_bch_t* str, hawk_oow_t slen, const hawk_bch_
 					const hawk_bch_t* s = sp;
 					for (s = sp; s < se; s++)
 					{
-						if (HAWK_FNMAT_IS_SEP(*s)) return 0;
+						if (HAWK_IS_PATH_SEP(*s)) return 0;
 					}
 				}
 				return 1;
@@ -3548,7 +3548,7 @@ int hawk_fnmat_bchars_i (const hawk_bch_t* str, hawk_oow_t slen, const hawk_bch_
 				do
 				{
 					if (hawk_fnmat_bchars_i(sp, se - sp, pp, pe - pp, flags, 1)) return 1;
-					if (HAWK_FNMAT_IS_SEP(*sp) && (flags & HAWK_FNMAT_PATHNAME)) break;
+					if (HAWK_IS_PATH_SEP(*sp) && (flags & HAWK_FNMAT_PATHNAME)) break;
 					sp++;
 				}
 				while (sp < se);

lib/utl-str.m4

@@ -1621,14 +1621,14 @@ int _fn_name_ (const _char_type_* str, hawk_oow_t slen, const _char_type_* ptn,
 			 * a period in the pattern explicitly
 			 */
 			if ((!no_first_period && sp == str) ||
-			    (HAWK_FNMAT_IS_SEP(sp[-1]) && (flags & HAWK_FNMAT_PATHNAME)))
+			    (HAWK_IS_PATH_SEP(sp[-1]) && (flags & HAWK_FNMAT_PATHNAME)))
 			{
 				if (pc != '.') return 0;
 				sp++; pp++;
 				continue;
 			}
 		}
-		else if (HAWK_FNMAT_IS_SEP(sc) && (flags & HAWK_FNMAT_PATHNAME))
+		else if (HAWK_IS_PATH_SEP(sc) && (flags & HAWK_FNMAT_PATHNAME))
 		{
 			while (pc == '*')
 			{
@@ -1637,7 +1637,7 @@ int _fn_name_ (const _char_type_* str, hawk_oow_t slen, const _char_type_* ptn,
 			}
 
 			/* a path separator must be matched explicitly */
-			if (!HAWK_FNMAT_IS_SEP(pc)) return 0;
+			if (!HAWK_IS_PATH_SEP(pc)) return 0;
 			sp++; pp++;
 			continue;
 		}
@@ -1667,7 +1667,7 @@ int _fn_name_ (const _char_type_* str, hawk_oow_t slen, const _char_type_* ptn,
 					const _char_type_* s = sp;
 					for (s = sp; s < se; s++)
 					{
-						if (HAWK_FNMAT_IS_SEP(*s)) return 0;
+						if (HAWK_IS_PATH_SEP(*s)) return 0;
 					}
 				}
 				return 1;
@@ -1677,7 +1677,7 @@ int _fn_name_ (const _char_type_* str, hawk_oow_t slen, const _char_type_* ptn,
 				do
 				{
 					if (_fn_name_()(sp, se - sp, pp, pe - pp, flags, 1)) return 1;
-					if (HAWK_FNMAT_IS_SEP(*sp) && (flags & HAWK_FNMAT_PATHNAME)) break;
+					if (HAWK_IS_PATH_SEP(*sp) && (flags & HAWK_FNMAT_PATHNAME)) break;
 					sp++;
 				}
 				while (sp < se);

t/cmd-tap-driver.cmd

@@ -1,8 +1,13 @@
+@echo off
+
+REM if you are two directories down from the top source directory,
+REM you may run the command like this:
+REM ..\..\t\cmd-tap-driver.cmd  -- ..\..\t\run-hawk-test.cmd -f ..\..\t\h-001.hawk
+REM -------------------------------------------------------------------------------
 REM set HAWK_TEST_COMPILER=Z:\path\to\hawk\bld-mingw64\bin\.libs\hawk.exe
 REM Z:\path\to\hawk\t\cmd-tap-driver.cmd --test-name h-011 --log-file h-011.log --trs-file h-011.trs -- Z:\path\to\hawk\t\t\run-hawk-test.cmd -f ..\..\t\h-011.hawk
 REM
 
-@echo off
 setlocal EnableExtensions DisableDelayedExpansion
 
 set "test_name="

t/h-010.hawk

@@ -13,7 +13,7 @@ function on_sig (sig)
 
 function main ()
 {
-	@local r;
+	@local r, u;
 	@local badpid;
 
 	g_seen = 0;
@@ -84,5 +84,18 @@ function main ()
 	r = sys::kill(badpid, sys::SIGINT);
 	tap_ensure (r, sys::RC_ESYSERR, @SCRIPTNAME, @SCRIPTLINE);
 
+	u = sys::uname();
+	tap_ensure (hawk::type(u), hawk::VAL_MAP, @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure (hawk::typename(u.sysname), "str", @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure (hawk::typename(u.nodename), "str", @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure (hawk::typename(u.release), "str", @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure (hawk::typename(u.version), "str", @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure (hawk::typename(u.machine), "str", @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure (length(u.sysname) > 0, 1, @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure (length(u.nodename) > 0, 1, @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure (length(u.release) > 0, 1, @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure (length(u.version) > 0, 1, @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure (length(u.machine) > 0, 1, @SCRIPTNAME, @SCRIPTLINE);
+
 	tap_end ();
 }

t/h-012.hawk

@@ -3,7 +3,7 @@
 @include "tap.inc";
 
 BEGIN {
-	@local v, v2,  m, m2, js;
+	@local v, v2, v3,  m, m2, js;
 
 
 	v = json::parse("{\"a\":1,\"b\":true,\"c\":null,\"d\":[2,3],\"e\":{\"x\":\"y\"}}");
@@ -26,7 +26,6 @@ BEGIN {
 	m["nested"] = hawk::map();
 	m["nested"]["ok"] = 1;
 	m["nested"]["note"] = "hello\n\"world\"";
-
 	js = json::stringify(m);
 	m2 = json::parse(js);
 
@@ -41,5 +40,14 @@ BEGIN {
 	tap_ensure(v2.a.b.c, 1, @SCRIPTNAME, @SCRIPTLINE);
 	tap_ensure(v2["a"].b["c"], 1, @SCRIPTNAME, @SCRIPTLINE);
 
+	v3 = json::parse("[false,true,null,\"a\\tb\",-12.5]");
+	tap_ensure(hawk::type(v3), hawk::VAL_ARRAY, @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure(hawk::type(v3[1]), hawk::VAL_BOOL, @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure(v3[1], @false, @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure(v3[2], @true, @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure(hawk::isnil(v3[3]), 1, @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure(v3[4], "a\tb", @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure(v3[5], -12.5, @SCRIPTNAME, @SCRIPTLINE);
+
 	tap_end();
 }

t/h-013.hawk

@@ -44,10 +44,17 @@ function main()
 {
 	## if PIPCLOEXEC is turned on, the file descriptor created by the shell (3> in run_pipe_test)
 	## doesn't get inherited to the 'cat' commands in the following text
+	@local uname;
 
+	uname = sys::uname()
+	if (uname["sysname"] ~ /Linux|Unix/) {
 		run_pipe_test("inherit-default", "BEGIN { print \"hello\" | \"cat >&3\" }", "hello\n");
 		run_pipe_test("cloexec-global", "BEGIN { PIPECLOEXEC = 1; print \"hello\" | \"cat >&3\" }", "");
+		run_pipe_test("inherit-global-off", "BEGIN { PIPECLOEXEC = 0; print \"hello\" | \"cat >&3\" }", "hello\n");
 		run_pipe_test("cloexec-pragma", "@pragma pipecloexec on\nBEGIN { print \"hello\" | \"cat >&3\" }", "");
+	} else {
+		tap_skip("PIPECLOEXEC not relevant");
+	}
 
 	tap_end();
 }

t/h-014.hawk

@@ -139,6 +139,18 @@ function main()
 	tap_ensure(!!@[1], @true, @SCRIPTNAME, @SCRIPTLINE);
 	tap_ensure(!dummy, @false, @SCRIPTNAME, @SCRIPTLINE);
 	tap_ensure(!!dummy, @true, @SCRIPTNAME, @SCRIPTLINE);
+	tmp = 0;
+	tap_ensure(!tmp && 0, 0, @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure(!tmp && 1, 1, @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure(!tmp || 0, 1, @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure(!tmp || 1, 1, @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure(1 && !tmp, 1, @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure(0 || !tmp, 1, @SCRIPTNAME, @SCRIPTLINE);
+	tmp = 1;
+	tap_ensure(!tmp && 0, 0, @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure(!tmp && 1, 0, @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure(!tmp || 0, 0, @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure(!tmp || 1, 1, @SCRIPTNAME, @SCRIPTLINE);
 
 	tap_ensure(sprintf("%d", @true), "1", @SCRIPTNAME, @SCRIPTLINE);
 	tap_ensure(sprintf("%d", @false), "0", @SCRIPTNAME, @SCRIPTLINE);

t/h-015.hawk

@@ -53,5 +53,9 @@ func main() {
 	a["k"].fn = mul;
 	tap_ensure(a["k"].fn(4, 4), 16, @SCRIPTNAME, @SCRIPTLINE);
 
+	a = @[ @{} ];
+	a[1].sum = add;
+	tap_ensure(a[1].sum(8, 9), 17, @SCRIPTNAME, @SCRIPTLINE);
+
 	tap_end();
 }