diff --git a/stix/kernel/Stdio.st b/stix/kernel/Stdio.st
index ed73d4e..9c97a4a 100644
--- a/stix/kernel/Stdio.st
+++ b/stix/kernel/Stdio.st
@@ -1,18 +1,24 @@
-#class(#word) Stdio(Object)
+## #class(#byte) Stdio(Object) from 'stdio'.
+
+#class(#byte) Stdio(Object)
 {
+	#method(#class) _newInstSize
+	{
+		<primitive: #stdio_newInstSize>
+	}
 
 	#method(#class) new: size
 	{
 		##self prohibited
 		##raise exception. prohibited...
-		^(super new: 1)
+		^(super new: (self _newInstSize))
 	}
 
 	#method(#class) new
 	{
 		##self prohibited
 		##raise exception. prohibited...
-		^(super new: 1)
+		^(super new: (self _newInstSize))
 	}
 
 	#method(#class) open: name for: mode
@@ -29,14 +35,17 @@
 	{
 		<primitive: #stdio_close>
 	}
+}
 
-	#method xxx
+#extend Stdio
+{
+	#method xxxx
 	{
 		self basicSize dump.
 	}
 }
 
-#class(#word) Stdio2(Stdio)
+#class(#byte) Stdio2(Stdio)
 {
 	#method(#class) new
 	{
diff --git a/stix/kernel/test-014.st b/stix/kernel/test-014.st
index 05d6986..b97a0f2 100644
--- a/stix/kernel/test-014.st
+++ b/stix/kernel/test-014.st
@@ -126,7 +126,7 @@
 
 		##v1 := Stdio2 open: '/tmp/1.txt' for: 'w+'.
 		v1 := Stdio2 new open: '/tmp/1.txt' for: 'w+'.
-		v1 xxx.
+		v1 xxxx.
 		v1 close.
 		nil isNil ifTrue: [ 'NIL NIL NIL' dump. ].
 		(Apex new) notNil ifTrue: [ 'APEX NIL NIL NIL' dump. ].
diff --git a/stix/lib/exec.c b/stix/lib/exec.c
index 50d606e..28a4d58 100644
--- a/stix/lib/exec.c
+++ b/stix/lib/exec.c
@@ -2397,7 +2397,7 @@ static int prim_ffi_open (stix_t* stix, stix_ooi_t nargs)
 		return 0;
 	}
 
-	if (!stix->vmprim.mod_open)
+	if (!stix->vmprim.dl_open)
 	{
 		/* TODO: more info on error */
 		return 0;
@@ -2405,7 +2405,7 @@ static int prim_ffi_open (stix_t* stix, stix_ooi_t nargs)
 
 
 /* TODO: check null-termination... */
-	handle = stix->vmprim.mod_open (stix, ((stix_oop_char_t)arg)->slot);
+	handle = stix->vmprim.dl_open (stix, ((stix_oop_char_t)arg)->slot);
 	if (!handle)
 	{
 		/* TODO: more info on error */
@@ -2439,7 +2439,7 @@ static int prim_ffi_close (stix_t* stix, stix_ooi_t nargs)
 	STIX_STACK_POP (stix);
 
 	handle = (void*)STIX_OOP_TO_SMOOI(arg); /* TODO: how to store void* ???. fix this not to loose accuracy */
-	if (stix->vmprim.mod_close) stix->vmprim.mod_close (stix, handle);
+	if (stix->vmprim.dl_close) stix->vmprim.dl_close (stix, handle);
 	return 1;
 }
 
@@ -2538,7 +2538,7 @@ STIX_DEBUG2 (stix, "CALL MODE 222 ERROR %d %d\n", dcGetError (dc), DC_ERROR_UNSU
 					stix_bch_t bcs[1024];
 
 					ucslen = STIX_OBJ_GET_SIZE(arr->slot[i - 2]);
-					stix_ucstoutf8 (((stix_oop_char_t)arr->slot[i - 2])->slot, &ucslen, bcs, &bcslen); /* proper string conversion */
+					stix_oocstobcs (stix, ((stix_oop_char_t)arr->slot[i - 2])->slot, &ucslen, bcs, &bcslen); /* proper string conversion */
 
 					bcs[bcslen] = '\0';
 					dcArgPointer (dc, bcs);
@@ -2594,9 +2594,9 @@ STIX_DEBUG2 (stix, "CALL ERROR %d %d\n", dcGetError (dc), DC_ERROR_UNSUPPORTED_M
 				stix_ooch_t ucs[1024];
 				stix_oop_t s;
 				char* r = dcCallPointer (dc, f);
-				
+
 				bcslen = strlen(r); 
-				stix_utf8toucs (r, &bcslen, ucs, &ucslen); /* proper string conversion */
+				stix_bcstooocs (stix, r, &bcslen, ucs, &ucslen); /* proper string conversion */
 
 				s = stix_makestring(stix, ucs, ucslen)
 				if (!s) 
@@ -2646,12 +2646,12 @@ STIX_DEBUG0 (stix, "wrong function name...\n");
 		return 0;
 	}
 
-	if (!stix->vmprim.mod_getsym)
+	if (!stix->vmprim.dl_getsym)
 	{
 		return 0;
 	}
 
-	sym = stix->vmprim.mod_getsym (stix, (void*)STIX_OOP_TO_SMOOI(hnd), ((stix_oop_char_t)fun)->slot);
+	sym = stix->vmprim.dl_getsym (stix, (void*)STIX_OOP_TO_SMOOI(hnd), ((stix_oop_char_t)fun)->slot);
 	if (!sym)
 	{
 		return 0;
@@ -2755,10 +2755,142 @@ int stix_getprimno (stix_t* stix, const stix_ooch_t* ptr, stix_oow_t len)
 	return -1;
 }
 
+#define MOD_PREFIX "stix_mod_"
+#define MOD_PREFIX_LEN 9
+
+static stix_mod_data_t* open_prim_module (stix_t* stix, const stix_ooch_t* name, stix_oow_t namelen)
+{
+	stix_rbt_pair_t* pair;
+	stix_mod_data_t* mdp;
+	stix_mod_data_t md;
+	stix_mod_load_t load = STIX_NULL;
+
+	/* maximum module name length is STIX_MOD_NAME_LEN_MAX. 
+	 *   MOD_PREFIX_LEN for MOD_PREFIX
+	 *   1 for _ at the end when stix_mod_xxx_ is attempted.
+	 *   1 for the terminating '\0'.
+	 */
+	stix_ooch_t buf[MOD_PREFIX_LEN + STIX_MOD_NAME_LEN_MAX + 1 + 1]; 
+
+	/* the terminating null isn't needed in buf here */
+	stix_copybchtooochars (buf, MOD_PREFIX, MOD_PREFIX_LEN); 
+
+	if (namelen > STIX_COUNTOF(buf) - (MOD_PREFIX_LEN + 1 + 1))
+	{
+		/* module name too long  */
+		stix->errnum = STIX_EINVAL; /* TODO: change the  error number to something more specific */
+		return STIX_NULL;
+	}
+
+	stix_copyoochars (&buf[MOD_PREFIX_LEN], name, namelen);
+	buf[MOD_PREFIX_LEN + namelen] = '\0';
+
+#if defined(STIX_ENABLE_STATIC_MODULE)
+	/* attempt to find a statically linked module */
+
+/*TODO: CHANGE THIS PART */
+
+	/* TODO: binary search ... */
+	for (n = 0; n < STIX_COUNTOF(static_modtab); n++)
+	{
+		if (stix_compoocstr (static_modtab[n].modname, name, name_len....) == 0) 
+		{
+			load = static_modtab[n].modload;
+			break;
+		}
+	}
+
+	if (n >= STIX_COUNTOF(static_modtab))
+	{
+		stix->errnum = STIX_ENOENT;
+		return STIX_NULL;
+	}
+
+	if (load)
+	{
+		/* found the module in the staic module table */
+
+		STIX_MEMSET (&md, 0, STIX_SIZEOF(md));
+		stix_copyoochars (md.name, name, namelen);
+		/* Note md.handle is STIX_NULL for a static module */
+
+		/* i copy-insert 'md' into the table before calling 'load'.
+		 * to pass the same address to load(), query(), etc */
+		pair = stix_rbt_insert (stix->modtab, name, namelen, &md, STIX_SIZEOF(md));
+		if (pair == STIX_NULL)
+		{
+			stix->errnum = STIX_ESYSMEM;
+			return STIX_NULL;
+		}
+
+		mdp = (stix_mod_data_t*)STIX_RBT_VPTR(pair);
+		if (load (&mdp->mod, stix) <= -1)
+		{
+			stix_rbt_delete (stix->modtab, segs[0].ptr, segs[0].len);
+			return STIX_NULL;
+		}
+
+		return mdp;
+	}
+#endif
+
+	/* attempt to find an external module */
+	STIX_MEMSET (&md, 0, STIX_SIZEOF(md));
+	stix_copyoochars (md.name, name, namelen);
+	if (stix->vmprim.dl_open && stix->vmprim.dl_getsym && stix->vmprim.dl_close)
+	{
+		md.handle = stix->vmprim.dl_open (stix, &buf[MOD_PREFIX_LEN]);
+	}
+
+	if (md.handle == STIX_NULL) 
+	{
+		STIX_DEBUG2 (stix, "Cannot open a module [%.*S]\n", namelen, name);
+		stix->errnum = STIX_ENOENT; /* TODO: be more descriptive about the error */
+		return STIX_NULL;
+	}
+
+	/* attempt to get stix_mod_xxx */
+	load = stix->vmprim.dl_getsym (stix, md.handle, buf);
+	if (!load) 
+	{
+		STIX_DEBUG3 (stix, "Cannot get a module symbol [%S] in [%.*S]\n", buf, namelen, name);
+		stix->errnum = STIX_ENOENT; /* TODO: be more descriptive about the error */
+		stix->vmprim.dl_close (stix, md.handle);
+		return STIX_NULL;
+	}
+
+	/* i copy-insert 'md' into the table before calling 'load'.
+	 * to pass the same address to load(), query(), etc */
+	pair = stix_rbt_insert (&stix->pmtable, (void*)name, namelen, &md, STIX_SIZEOF(md));
+	if (pair == STIX_NULL)
+	{
+		STIX_DEBUG2 (stix, "Cannot register a module [%.*S]\n", namelen, name);
+		stix->errnum = STIX_ESYSMEM;
+		stix->vmprim.dl_close (stix, md.handle);
+		return STIX_NULL;
+	}
+
+	mdp = (stix_mod_data_t*)STIX_RBT_VPTR(pair);
+	if (load (stix, &mdp->mod) <= -1)
+	{
+		STIX_DEBUG3 (stix, "Module function [%S] returned failure in [%.*S]\n", buf, namelen, name);
+		stix->errnum = STIX_ENOENT; /* TODO: proper error code and handling */
+		stix_rbt_delete (&stix->pmtable, name, namelen);
+		stix->vmprim.dl_close (stix, mdp->handle);
+		return STIX_NULL;
+	}
+
+	STIX_DEBUG2 (stix, "Opened a module [%S] - %p\n", mdp->name, mdp->handle);
+	/* the module loader must ensure to set a proper query handler */
+	STIX_ASSERT (mdp->mod.query != STIX_NULL);
+
+	return mdp;
+}
+
 static stix_prim_impl_t query_prim_module (stix_t* stix, const stix_ooch_t* name, stix_oow_t len)
 {
 	stix_rbt_pair_t* pair;
-	stix_prim_mod_data_t* mdp;
+	stix_mod_data_t* mdp;
 	const stix_ooch_t* sep;
 	stix_oow_t mod_name_len;
 	stix_prim_impl_t handler;
@@ -2771,133 +2903,24 @@ static stix_prim_impl_t query_prim_module (stix_t* stix, const stix_ooch_t* name
 	pair = stix_rbt_search (&stix->pmtable, name, mod_name_len);
 	if (pair)
 	{
-		mdp = (stix_prim_mod_data_t*)STIX_RBT_VPTR(pair);
+		mdp = (stix_mod_data_t*)STIX_RBT_VPTR(pair);
 	}
 	else
 	{
-		stix_prim_mod_data_t md;
-		stix_prim_mod_load_t load = STIX_NULL;
-
-		/* maximum module name length is STIX_MOD_NAME_LEN_MAX. 
-		 * 16 is decomposed to 14 + 1 + 1.
-		 *   14 for stix_prim_mod_.
-		 *   1 for _ at the end when stix_prim_mod_xxx_ is attempted.
-		 *   1 for the terminating '\0'.
-		 */
-		stix_ooch_t buf[STIX_MOD_NAME_LEN_MAX + 16]; 
-
-		/* the terminating null isn't needed in buf here */
-		stix_copybchtooochars (buf, "stix_prim_mod_", 14); 
-
-		if (mod_name_len > STIX_COUNTOF(buf) - 16)
-		{
-			/* module name too long  */
-			stix->errnum = STIX_EINVAL; /* TODO: change the  error number to something more specific */
-			return STIX_NULL;
-		}
-
-		stix_copyoochars (&buf[14], name, mod_name_len);
-		buf[14 + mod_name_len] = '\0';
-
-#if defined(STIX_ENABLE_STATIC_MODULE)
-		/* attempt to find a statically linked module */
-
-/*TODO: CHANGE THIS PART */
-
-		/* TODO: binary search ... */
-		for (n = 0; n < STIX_COUNTOF(static_modtab); n++)
-		{
-			if (stix_compoocstr (static_modtab[n].modname, name) == 0) 
-			{
-				load = static_modtab[n].modload;
-				break;
-			}
-		}
-
-		if (n >= STIX_COUNTOF(static_modtab))
-		{
-			stix->errnum = STIX_ENOENT;
-			return STIX_NULL;
-		}
-
-		if (load)
-		{
-			/* found the module in the staic module table */
-
-			STIX_MEMSET (&md, 0, STIX_SIZEOF(md));
-			/* Note md.handle is STIX_NULL for a static module */
-
-			/* i copy-insert 'md' into the table before calling 'load'.
-			 * to pass the same address to load(), query(), etc */
-			pair = stix_rbt_insert (stix->modtab, name, mod_name_len, &md, STIX_SIZEOF(md));
-			if (pair == STIX_NULL)
-			{
-				stix->errnum = STIX_ESYSMEM;
-				return STIX_NULL;
-			}
-
-			mdp = (stix_mod_data_t*)STIX_RBT_VPTR(pair);
-			if (load (&mdp->mod, stix) <= -1)
-			{
-				stix_rbt_delete (stix->modtab, segs[0].ptr, segs[0].len);
-				return STIX_NULL;
-			}
-
-			goto done;
-		}
-#endif
-
-		/* attempt to find an external module */
-		STIX_MEMSET (&md, 0, STIX_SIZEOF(md));
-		if (stix->vmprim.mod_open && stix->vmprim.mod_getsym && stix->vmprim.mod_close)
-		{
-			md.handle = stix->vmprim.mod_open (stix, &buf[14]);
-		}
-
-		if (md.handle == STIX_NULL) 
-		{
-			stix->errnum = STIX_ENOENT; /* TODO: be more descriptive about the error */
-			return STIX_NULL;
-		}
-
-		/* attempt to get stix_prim_mod_xxx */
-		load = stix->vmprim.mod_getsym (stix, md.handle, buf);
-		if (!load) 
-		{
-			stix->errnum = STIX_ENOENT; /* TODO: be more descriptive about the error */
-			stix->vmprim.mod_close (stix, md.handle);
-			return STIX_NULL;
-		}
-
-		/* i copy-insert 'md' into the table before calling 'load'.
-		 * to pass the same address to load(), query(), etc */
-		pair = stix_rbt_insert (&stix->pmtable, (void*)name, mod_name_len, &md, STIX_SIZEOF(md));
-		if (pair == STIX_NULL)
-		{
-			stix->errnum = STIX_ESYSMEM;
-			stix->vmprim.mod_close (stix, md.handle);
-			return STIX_NULL;
-		}
-
-		mdp = (stix_prim_mod_data_t*)STIX_RBT_VPTR(pair);
-		if (load (stix, &mdp->mod) <= -1)
-		{
-			stix->errnum = STIX_ENOENT; /* TODO: proper error code and handling */
-			stix_rbt_delete (&stix->pmtable, name, mod_name_len);
-			stix->vmprim.mod_close (stix, mdp->handle);
-			return STIX_NULL;
-		}
-
-		/* the module loader must ensure to set a proper query handler */
-		STIX_ASSERT (mdp->mod.query != STIX_NULL);
+		mdp = open_prim_module (stix, name, mod_name_len);
+		if (!mdp) return STIX_NULL;
 	}
 
 done:
 	if ((handler = mdp->mod.query (stix, &mdp->mod, sep + 1)) == STIX_NULL) 
 	{
+		/* the primitive function is not found */
+		STIX_DEBUG3 (stix, "Cannot find a primitive function [%S] in a module [%.*S]\n", sep + 1, mod_name_len, name);
 		stix->errnum = STIX_ENOENT; /* TODO: proper error code and handling */
 		return STIX_NULL;
 	}
+
+	STIX_DEBUG4 (stix, "Found a primitive function [%S] in a module [%.*S] - %p\n", sep + 1, mod_name_len, name, handler);
 	return handler;
 }
 
diff --git a/stix/lib/logfmtv.h b/stix/lib/logfmtv.h
index 6ff16ef..a931b19 100644
--- a/stix/lib/logfmtv.h
+++ b/stix/lib/logfmtv.h
@@ -425,7 +425,7 @@ reswitch:
 			/* get the length */
 			for (bslen = 0; bsp[bslen]; bslen++);
 
-			if (stix_utf8toucs (bsp, &bslen, STIX_NULL, &slen) <= -1)
+			if (stix_bcstooocs (stix, bsp, &bslen, STIX_NULL, &slen) <= -1)
 			{ 
 				/* conversion error */
 				stix->errnum = STIX_EECERR;
@@ -450,7 +450,7 @@ reswitch:
 					conv_len = STIX_COUNTOF(conv_buf);
 
 					/* this must not fail since the dry-run above was successful */
-					stix_utf8toucs (&bsp[tot_len], &src_len, conv_buf, &conv_len);
+					stix_bcstooocs (stix, &bsp[tot_len], &src_len, conv_buf, &conv_len);
 					tot_len += src_len;
 
 					if (conv_len > n) conv_len = n;
diff --git a/stix/lib/main.c b/stix/lib/main.c
index f336b0f..59b8d1c 100644
--- a/stix/lib/main.c
+++ b/stix/lib/main.c
@@ -144,7 +144,7 @@ static STIX_INLINE stix_ooi_t open_input (stix_t* stix, stix_ioarg_t* arg)
 		stix_oow_t bcslen = STIX_COUNTOF(bcs);
 		stix_oow_t ucslen = ~(stix_oow_t)0;
 
-		if (stix_ucstoutf8 (arg->name, &ucslen, bcs, &bcslen) <= -1)
+		if (stix_oocstobcs (stix, arg->name, &ucslen, bcs, &bcslen) <= -1)
 		{
 			stix_seterrnum (stix, STIX_EECERR);
 			return -1;
@@ -231,7 +231,8 @@ static STIX_INLINE stix_ooi_t read_input (stix_t* stix, stix_ioarg_t* arg)
 
 	bcslen = bb->len;
 	ucslen = STIX_COUNTOF(arg->buf);
-	x = stix_utf8toucs (bb->buf, &bcslen, arg->buf, &ucslen);
+	x = stix_bcstooocs (stix, bb->buf, &bcslen, arg->buf, &ucslen);
+	x = stix_bcstooocs (stix, bb->buf, &bcslen, arg->buf, &ucslen);
 	if (x <= -1 && ucslen <= 0)
 	{
 		stix_seterrnum (stix, STIX_EECERR);
@@ -264,7 +265,7 @@ static stix_ooi_t input_handler (stix_t* stix, stix_iocmd_t cmd, stix_ioarg_t* a
 }
 /* ========================================================================= */
 
-static void* mod_open (stix_t* stix, const stix_ooch_t* name)
+static void* dl_open (stix_t* stix, const stix_ooch_t* name)
 {
 #if defined(USE_LTDL)
 /* TODO: support various platforms */
@@ -279,7 +280,7 @@ static void* mod_open (stix_t* stix, const stix_ooch_t* name)
  * Attempting /home/hyung-hwan/xxx/lib/libstix-libc.so.6 followed by libc.so.6 is bad.
  * Need to accept the type or flags?
  *
- * mod_open (stix, "xxxx", STIX_MOD_EXTERNAL);
+ * dl_open (stix, "xxxx", STIX_MOD_EXTERNAL);
  * if external, don't use DEFAULT_MODPERFIX and MODPOSTFIX???
  */
 
@@ -288,7 +289,7 @@ static void* mod_open (stix_t* stix, const stix_ooch_t* name)
 /* TODO: proper error checking and overflow checking */
 	ucslen = ~(stix_oow_t)0;
 	bcslen = STIX_COUNTOF(buf) - len;
-	stix_ucstoutf8 (name, &ucslen, &buf[len], &bcslen);
+	stix_oocstobcs (stix, name, &ucslen, &buf[len], &bcslen);
 
 	stix_copybcstr (&buf[bcslen + len], STIX_COUNTOF(buf) - bcslen - len, STIX_DEFAULT_MODPOSTFIX);
 
@@ -312,7 +313,7 @@ static void* mod_open (stix_t* stix, const stix_ooch_t* name)
 #endif
 }
 
-static void mod_close (stix_t* stix, void* handle)
+static void dl_close (stix_t* stix, void* handle)
 {
 	STIX_DEBUG1 (stix, "Closed module handle %p\n", handle);
 #if defined(USE_LTDL)
@@ -328,7 +329,7 @@ static void mod_close (stix_t* stix, void* handle)
 #endif
 }
 
-static void* mod_getsym (stix_t* stix, void* handle, const stix_ooch_t* name)
+static void* dl_getsym (stix_t* stix, void* handle, const stix_ooch_t* name)
 {
 #if defined(USE_LTDL)
 	stix_bch_t buf[1024]; /* TODO: use a proper buffer. dynamically allocated if conversion result in too a large value */
@@ -340,7 +341,7 @@ static void* mod_getsym (stix_t* stix, void* handle, const stix_ooch_t* name)
 
 	ucslen = ~(stix_oow_t)0;
 	bcslen = STIX_COUNTOF(buf) - 2;
-	stix_ucstoutf8 (name, &ucslen, &buf[1], &bcslen);
+	stix_oocstobcs (stix, name, &ucslen, &buf[1], &bcslen); /* TODO: error check */
 	symname = &buf[1];
 	sym = lt_dlsym (handle, symname);
 	if (!sym)
@@ -435,7 +436,7 @@ static void log_write (stix_t* stix, stix_oow_t mask, const stix_ooch_t* msg, st
 		ucslen = len;
 		bcslen = STIX_COUNTOF(buf);
 
-		n = stix_ucstoutf8 (&msg[msgidx], &ucslen, buf, &bcslen);
+		n = stix_oocstobcs (stix, &msg[msgidx], &ucslen, buf, &bcslen);
 		if (n == 0 || n == -2)
 		{
 			/* n = 0: 
@@ -656,9 +657,9 @@ int main (int argc, char* argv[])
 	}
 #endif
 
-	vmprim.mod_open = mod_open;
-	vmprim.mod_close = mod_close;
-	vmprim.mod_getsym = mod_getsym;
+	vmprim.dl_open = dl_open;
+	vmprim.dl_close = dl_close;
+	vmprim.dl_getsym = dl_getsym;
 	vmprim.log_write = log_write;
 
 
@@ -728,7 +729,7 @@ int main (int argc, char* argv[])
 				{
 					bcslen = STIX_COUNTOF(bcs);
 					ucslen = ~(stix_oow_t)0;
-					if (stix_ucstoutf8 (synerr.loc.file, &ucslen, bcs, &bcslen) >= 0)
+					if (stix_oocstobcs (stix, synerr.loc.file, &ucslen, bcs, &bcslen) >= 0)
 					{
 						printf ("%.*s ", (int)bcslen, bcs);
 					}
@@ -747,7 +748,7 @@ int main (int argc, char* argv[])
 					bcslen = STIX_COUNTOF(bcs);
 					ucslen = synerr.tgt.len;
 
-					if (stix_ucstoutf8 (synerr.tgt.ptr, &ucslen, bcs, &bcslen) >= 0)
+					if (stix_oocstobcs (stix, synerr.tgt.ptr, &ucslen, bcs, &bcslen) >= 0)
 					{
 						printf (" [%.*s]", (int)bcslen, bcs);
 					}
diff --git a/stix/lib/stix-utl.h b/stix/lib/stix-utl.h
index 29309d1..de4974f 100644
--- a/stix/lib/stix-utl.h
+++ b/stix/lib/stix-utl.h
@@ -147,21 +147,8 @@ STIX_EXPORT stix_oow_t stix_countbcstr (
 	const stix_bch_t* str
 );
 
-
-
-/* ========================================================================= */
-/* utf8.c                                                                    */
-/* ========================================================================= */
-STIX_EXPORT stix_oow_t stix_uctoutf8 (
-	stix_uch_t    uc,
-	stix_bch_t*   utf8,
-	stix_oow_t    size
-);
-
-STIX_EXPORT stix_oow_t stix_utf8touc (
-	const stix_bch_t* utf8,
-	stix_oow_t        size,
-	stix_uch_t*       uc
+STIX_EXPORT stix_cmgr_t* stix_getutf8cmgr (
+	void
 );
 
 /**
@@ -235,6 +222,22 @@ STIX_EXPORT int stix_utf8toucs (
 	stix_oow_t*         ucslen
 );
 
+
+/* ========================================================================= */
+/* utf8.c                                                                    */
+/* ========================================================================= */
+STIX_EXPORT stix_oow_t stix_uctoutf8 (
+	stix_uch_t    uc,
+	stix_bch_t*   utf8,
+	stix_oow_t    size
+);
+
+STIX_EXPORT stix_oow_t stix_utf8touc (
+	const stix_bch_t* utf8,
+	stix_oow_t        size,
+	stix_uch_t*       uc
+);
+
 #if defined(__cplusplus)
 }
 #endif
diff --git a/stix/lib/stix.c b/stix/lib/stix.c
index e35101d..5b42822 100644
--- a/stix/lib/stix.c
+++ b/stix/lib/stix.c
@@ -26,7 +26,6 @@
 
 #include "stix-prv.h"
 
-
 stix_t* stix_open (stix_mmgr_t* mmgr, stix_oow_t xtnsize, stix_oow_t heapsize, const stix_vmprim_t* vmprim, stix_errnum_t* errnum)
 {
 	stix_t* stix;
@@ -87,6 +86,7 @@ int stix_init (stix_t* stix, stix_mmgr_t* mmgr, stix_oow_t heapsz, const stix_vm
 {
 	STIX_MEMSET (stix, 0, STIX_SIZEOF(*stix));
 	stix->mmgr = mmgr;
+	stix->cmgr = stix_getutf8cmgr ();
 	stix->vmprim = *vmprim;
 
 	stix->option.log_mask = ~0u;
@@ -123,11 +123,16 @@ oops:
 static stix_rbt_walk_t unload_primitive_module (stix_rbt_t* rbt, stix_rbt_pair_t* pair, void* ctx)
 {
 	stix_t* stix = (stix_t*)ctx;
-	stix_prim_mod_data_t* md;
+	stix_mod_data_t* md;
 
 	md = STIX_RBT_VPTR(pair);
 	if (md->mod.unload) md->mod.unload (stix, &md->mod);
-	if (md->handle) stix->vmprim.mod_close (stix, md->handle);
+	if (md->handle) 
+	{
+		stix->vmprim.dl_close (stix, md->handle);
+		STIX_DEBUG2 (stix, "Closed a module [%S] - %p\n", md->name, md->handle);
+		md->handle = STIX_NULL;
+	}
 
 	return STIX_RBT_WALK_FORWARD;
 }
@@ -190,6 +195,16 @@ stix_mmgr_t* stix_getmmgr (stix_t* stix)
 	return stix->mmgr;
 }
 
+stix_cmgr_t* stix_getcmgr (stix_t* stix)
+{
+	return stix->cmgr;
+}
+
+void stix_setcmgr (stix_t* stix, stix_cmgr_t* cmgr)
+{
+	stix->cmgr = cmgr;
+}
+
 void* stix_getxtn (stix_t* stix)
 {
 	return (void*)(stix + 1);
diff --git a/stix/lib/stix.h b/stix/lib/stix.h
index d9bb761..d8de702 100644
--- a/stix/lib/stix.h
+++ b/stix/lib/stix.h
@@ -681,19 +681,17 @@ typedef struct stix_t stix_t;
 /* =========================================================================
  * VIRTUAL MACHINE PRIMITIVES
  * ========================================================================= */
-#define STIX_MOD_NAME_LEN_MAX 120
-
-typedef void* (*stix_mod_open_t) (stix_t* stix, const stix_ooch_t* name);
-typedef void (*stix_mod_close_t) (stix_t* stix, void* handle);
-typedef void* (*stix_mod_getsym_t) (stix_t* stix, void* handle, const stix_ooch_t* name);
+typedef void* (*stix_vmprim_opendl_t) (stix_t* stix, const stix_ooch_t* name);
+typedef void (*stix_vmprim_closedl_t) (stix_t* stix, void* handle);
+typedef void* (*stix_vmprim_getdlsym_t) (stix_t* stix, void* handle, const stix_ooch_t* name);
 
 typedef void (*stix_log_write_t) (stix_t* stix, stix_oow_t mask, const stix_ooch_t* msg, stix_oow_t len);
 
 struct stix_vmprim_t
 {
-	stix_mod_open_t mod_open;
-	stix_mod_close_t mod_close;
-	stix_mod_getsym_t mod_getsym;
+	stix_vmprim_opendl_t dl_open;
+	stix_vmprim_closedl_t dl_close;
+	stix_vmprim_getdlsym_t dl_getsym;
 	stix_log_write_t log_write;
 };
 
@@ -725,39 +723,42 @@ struct stix_cb_t
 /* =========================================================================
  * PRIMITIVE MODULE MANIPULATION
  * ========================================================================= */
+#define STIX_MOD_NAME_LEN_MAX 120
+
 typedef int (*stix_prim_impl_t) (stix_t* stix, stix_ooi_t nargs);
 
-typedef struct stix_prim_mod_t stix_prim_mod_t;
+typedef struct stix_mod_t stix_mod_t;
 
-typedef int (*stix_prim_mod_load_t) (
-	stix_t*          stix,
-	stix_prim_mod_t* mod
+typedef int (*stix_mod_load_t) (
+	stix_t*     stix,
+	stix_mod_t* mod
 );
 
-typedef stix_prim_impl_t (*stix_prim_mod_query_t) (
+typedef stix_prim_impl_t (*stix_mod_query_t) (
 	stix_t*           stix,
-	stix_prim_mod_t*  mod,
+	stix_mod_t*       mod,
 	const stix_uch_t* name
 );
 
-typedef void (*stix_prim_mod_unload_t) (
-	stix_t*          stix,
-	stix_prim_mod_t* mod
+typedef void (*stix_mod_unload_t) (
+	stix_t*     stix,
+	stix_mod_t* mod
 );
 
-struct stix_prim_mod_t
+struct stix_mod_t
 {
-	stix_prim_mod_unload_t unload;
-	stix_prim_mod_query_t  query;
-	void*                  ctx;
+	stix_mod_unload_t unload;
+	stix_mod_query_t  query;
+	void*             ctx;
 };
 
-struct stix_prim_mod_data_t 
+struct stix_mod_data_t 
 {
-	void* handle;
-	stix_prim_mod_t mod;
+	stix_ooch_t name[STIX_MOD_NAME_LEN_MAX + 1];
+	void*       handle;
+	stix_mod_t  mod;
 };
-typedef struct stix_prim_mod_data_t stix_prim_mod_data_t;
+typedef struct stix_mod_data_t stix_mod_data_t;
 
 /* =========================================================================
  * STIX VM
@@ -769,6 +770,7 @@ typedef struct stix_compiler_t stix_compiler_t;
 struct stix_t
 {
 	stix_mmgr_t*  mmgr;
+	stix_cmgr_t*  cmgr;
 	stix_errnum_t errnum;
 
 	struct
@@ -982,18 +984,18 @@ STIX_EXPORT stix_t* stix_open (
 );
 
 STIX_EXPORT void stix_close (
-	stix_t* vm
+	stix_t* stix
 );
 
 STIX_EXPORT int stix_init (
-	stix_t*              vm,
+	stix_t*              stix,
 	stix_mmgr_t*         mmgr,
 	stix_oow_t           heapsize,
 	const stix_vmprim_t* vmprim
 );
 
 STIX_EXPORT void stix_fini (
-	stix_t* vm
+	stix_t* stix
 );
 
 
@@ -1001,6 +1003,15 @@ STIX_EXPORT stix_mmgr_t* stix_getmmgr (
 	stix_t* stix
 );
 
+STIX_EXPORT stix_cmgr_t* stix_getcmgr (
+	stix_t* stix
+);
+
+STIX_EXPORT void stix_setcmgr (
+	stix_t*      stix,
+	stix_cmgr_t* cmgr
+);
+
 STIX_EXPORT void* stix_getxtn (
 	stix_t* stix
 );
@@ -1153,6 +1164,31 @@ STIX_EXPORT void stix_freemem (
 );
 
 
+#if defined(STIX_OOCH_IS_UCH)
+#	define stix_oocstobcs(stix,oocs,oocslen,bcs,bcslen) stix_ucstobcs(stix,oocs,oocslen,bcs,bcslen)
+#	define stix_bcstooocs(stix,bcs,bcslen,oocs,oocslen) stix_bcstoucs(stix,bcs,bcslen,oocs,oocslen)
+#else
+#error TODO
+#	define stix_oocstobcs(stix,oocs,oocslen,bcs,bcslen) stix_ucstobcs(stix,oocs,oocslen,bcs,bcslen)
+#	define stix_bcstooocs(stix,bcs,bcslen,oocs,oocslen) stix_bcstoucs(stix,bcs,bcslen,oocs,oocslen)
+#endif
+
+STIX_EXPORT int stix_bcstoucs (
+	stix_t*           stix,
+	const stix_bch_t* bcs,
+	stix_oow_t*       bcslen,
+	stix_uch_t*       ucs,
+	stix_oow_t*       ucslen
+);
+
+STIX_EXPORT int stix_ucstobcs (
+	stix_t*           stix,
+	const stix_uch_t* ucs,
+	stix_oow_t*       ucslen,
+	stix_bch_t*       bcs,
+	stix_oow_t*       bcslen
+);
+
 STIX_EXPORT stix_ooi_t stix_logbfmt (
 	stix_t*           stix,
 	stix_oow_t        mask,
diff --git a/stix/lib/utf8.c b/stix/lib/utf8.c
index 68672c0..0726284 100644
--- a/stix/lib/utf8.c
+++ b/stix/lib/utf8.c
@@ -26,8 +26,6 @@
 
 #include "stix-prv.h"
 
-#define STIX_BCLEN_MAX 6
-
 /*
  * from RFC 2279 UTF-8, a transformation format of ISO 10646
  *
@@ -179,342 +177,3 @@ stix_oow_t stix_utf8touc (const stix_bch_t* utf8, stix_oow_t size, stix_uch_t* u
 	return 0; /* error - invalid sequence */
 }
 
-/* ----------------------------------------------------------------------- */
-
-static STIX_INLINE int bcsn_to_ucsn_with_cmgr (
-	const stix_bch_t* bcs, stix_oow_t* bcslen,
-	stix_uch_t* ucs, stix_oow_t* ucslen, stix_cmgr_t* cmgr, int all)
-{
-	const stix_bch_t* p;
-	int ret = 0;
-	stix_oow_t mlen;
-
-	if (ucs)
-	{
-		/* destination buffer is specified. 
-		 * copy the conversion result to the buffer */
-
-		stix_uch_t* q, * qend;
-
-		p = bcs;
-		q = ucs;
-		qend = ucs + *ucslen;
-		mlen = *bcslen;
-
-		while (mlen > 0)
-		{
-			stix_oow_t n;
-
-			if (q >= qend)
-			{
-				/* buffer too small */
-				ret = -2;
-				break;
-			}
-
-			n = cmgr->bctouc (p, mlen, q);
-			if (n == 0)
-			{
-				/* invalid sequence */
-				if (all)
-				{
-					n = 1;
-					*q = '?';
-				}
-				else
-				{
-					ret = -1;
-					break;
-				}
-			}
-			if (n > mlen)
-			{
-				/* incomplete sequence */
-				if (all)
-				{
-					n = 1;
-					*q = '?';
-				}
-				else
-				{
-					ret = -3;
-					break;
-				}
-			}
-
-			q++;
-			p += n;
-			mlen -= n;
-		}
-
-		*ucslen = q - ucs;
-		*bcslen = p - bcs;
-	}
-	else
-	{
-		/* no destination buffer is specified. perform conversion
-		 * but don't copy the result. the caller can call this function
-		 * without a buffer to find the required buffer size, allocate
-		 * a buffer with the size and call this function again with 
-		 * the buffer. */
-
-		stix_uch_t w;
-		stix_oow_t wlen = 0;
-
-		p = bcs;
-		mlen = *bcslen;
-
-		while (mlen > 0)
-		{
-			stix_oow_t n;
-
-			n = cmgr->bctouc (p, mlen, &w);
-			if (n == 0)
-			{
-				/* invalid sequence */
-				if (all) n = 1;
-				else
-				{
-					ret = -1;
-					break;
-				}
-			}
-			if (n > mlen)
-			{
-				/* incomplete sequence */
-				if (all) n = 1;
-				else
-				{
-					ret = -3;
-					break;
-				}
-			}
-
-			p += n;
-			mlen -= n;
-			wlen += 1;
-		}
-
-		*ucslen = wlen;
-		*bcslen = p - bcs;
-	}
-
-	return ret;
-}
-
-static STIX_INLINE int bcs_to_ucs_with_cmgr (
-	const stix_bch_t* bcs, stix_oow_t* bcslen,
-	stix_uch_t* ucs, stix_oow_t* ucslen, stix_cmgr_t* cmgr, int all)
-{
-	const stix_bch_t* bp;
-	stix_oow_t mlen, wlen;
-	int n;
-
-	for (bp = bcs; *bp != '\0'; bp++) /* nothing */ ;
-
-	mlen = bp - bcs; wlen = *ucslen;
-	n = bcsn_to_ucsn_with_cmgr (bcs, &mlen, ucs, &wlen, cmgr, all);
-	if (ucs)
-	{
-		/* null-terminate the target buffer if it has room for it. */
-		if (wlen < *ucslen) ucs[wlen] = '\0';
-		else n = -2; /* buffer too small */
-	}
-	*bcslen = mlen; *ucslen = wlen;
-
-	return n;
-}
-
-static STIX_INLINE int ucsn_to_bcsn_with_cmgr (
-	const stix_uch_t* ucs, stix_oow_t* ucslen,
-	stix_bch_t* bcs, stix_oow_t* bcslen, stix_cmgr_t* cmgr)
-{
-	const stix_uch_t* p = ucs;
-	const stix_uch_t* end = ucs + *ucslen;
-	int ret = 0; 
-
-	if (bcs)
-	{
-		stix_oow_t rem = *bcslen;
-
-		while (p < end) 
-		{
-			stix_oow_t n;
-
-			if (rem <= 0)
-			{
-				ret = -2; /* buffer too small */
-				break;
-			}
-
-			n = cmgr->uctobc (*p, bcs, rem);
-			if (n == 0) 
-			{
-				ret = -1;
-				break; /* illegal character */
-			}
-			if (n > rem) 
-			{
-				ret = -2; /* buffer too small */
-				break;
-			}
-			bcs += n; rem -= n; p++;
-		}
-
-		*bcslen -= rem; 
-	}
-	else
-	{
-		stix_bch_t bcsbuf[STIX_BCLEN_MAX];
-		stix_oow_t mlen = 0;
-
-		while (p < end)
-		{
-			stix_oow_t n;
-
-			n = cmgr->uctobc (*p, bcsbuf, STIX_COUNTOF(bcsbuf));
-			if (n == 0) 
-			{
-				ret = -1;
-				break; /* illegal character */
-			}
-
-			/* it assumes that bcsbuf is large enough to hold a character */
-			STIX_ASSERT (n <= STIX_COUNTOF(bcsbuf));
-
-			p++; mlen += n;
-		}
-
-		/* this length excludes the terminating null character. 
-		 * this function doesn't even null-terminate the result. */
-		*bcslen = mlen;
-	}
-
-	*ucslen = p - ucs;
-	return ret;
-}
-
-
-static int ucs_to_bcs_with_cmgr (
-	const stix_uch_t* ucs, stix_oow_t* ucslen,
-	stix_bch_t* bcs, stix_oow_t* bcslen, stix_cmgr_t* cmgr)
-{
-	const stix_uch_t* p = ucs;
-	int ret = 0;
-
-	if (bcs)
-	{
-		stix_oow_t rem = *bcslen;
-
-		while (*p != '\0')
-		{
-			stix_oow_t n;
-
-			if (rem <= 0)
-			{
-				ret = -2;
-				break;
-			}
-			
-			n = cmgr->uctobc (*p, bcs, rem);
-			if (n == 0) 
-			{
-				ret = -1;
-				break; /* illegal character */
-			}
-			if (n > rem) 
-			{
-				ret = -2;
-				break; /* buffer too small */
-			}
-
-			bcs += n; rem -= n; p++;
-		}
-
-		/* update bcslen to the length of the bcs string converted excluding
-		 * terminating null */
-		*bcslen -= rem; 
-
-		/* null-terminate the multibyte sequence if it has sufficient space */
-		if (rem > 0) *bcs = '\0';
-		else 
-		{
-			/* if ret is -2 and cs[cslen] == '\0', 
-			 * this means that the bcs buffer was lacking one
-			 * slot for the terminating null */
-			ret = -2; /* buffer too small */
-		}
-	}
-	else
-	{
-		stix_bch_t bcsbuf[STIX_BCLEN_MAX];
-		stix_oow_t mlen = 0;
-
-		while (*p != '\0')
-		{
-			stix_oow_t n;
-
-			n = cmgr->uctobc (*p, bcsbuf, STIX_COUNTOF(bcsbuf));
-			if (n == 0) 
-			{
-				ret = -1;
-				break; /* illegal character */
-			}
-
-			/* it assumes that bcs is large enough to hold a character */
-			STIX_ASSERT (n <= STIX_COUNTOF(bcs));
-
-			p++; mlen += n;
-		}
-
-		/* this length holds the number of resulting multi-byte characters 
-		 * excluding the terminating null character */
-		*bcslen = mlen;
-	}
-
-	*ucslen = p - ucs;  /* the number of wide characters handled. */
-	return ret;
-}
-
-static stix_cmgr_t utf8_cmgr =
-{
-	stix_utf8touc,
-	stix_uctoutf8
-};
-
-int stix_utf8toucs (const stix_bch_t* bcs, stix_oow_t* bcslen, stix_uch_t* ucs, stix_oow_t* ucslen)
-{
-	if (*bcslen == ~(stix_oow_t)0)
-	{
-		/* the source is null-terminated. */
-		return bcs_to_ucs_with_cmgr (bcs, bcslen, ucs, ucslen, &utf8_cmgr, 0);
-	}
-	else
-	{
-		/* the source is length bound */
-		return bcsn_to_ucsn_with_cmgr (bcs, bcslen, ucs, ucslen, &utf8_cmgr, 0);
-	}
-}
-
-int stix_ucstoutf8 (const stix_uch_t* ucs, stix_oow_t* ucslen, stix_bch_t* bcs, stix_oow_t* bcslen)
-{
-	if (*ucslen == ~(stix_oow_t)0)
-	{
-		/* null-terminated */
-		return ucs_to_bcs_with_cmgr (ucs, ucslen, bcs, bcslen, &utf8_cmgr);
-	}
-	else
-	{
-		/* length bound */
-		return ucsn_to_bcsn_with_cmgr (ucs, ucslen, bcs, bcslen, &utf8_cmgr);
-	}
-}
-
-/*
-stix_oow_t stix_ucslen (const stix_uch_t* ucs)
-{
-	const stix_uch_t* ptr = ucs;
-	while (*ptr) ptr++;
-	return ptr - ucs;
-}
-*/
diff --git a/stix/lib/utl.c b/stix/lib/utl.c
index bcab9d7..f34eb3f 100644
--- a/stix/lib/utl.c
+++ b/stix/lib/utl.c
@@ -24,7 +24,9 @@
     THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "stix-utl.h"
+#include "stix-prv.h"
+
+#define STIX_BCLEN_MAX 6
 
 stix_oow_t stix_hashbytes (const stix_oob_t* ptr, stix_oow_t len)
 {
@@ -187,3 +189,369 @@ stix_bch_t* stix_findbchar (const stix_bch_t* ptr, stix_oow_t len, stix_bch_t c)
 
 	return STIX_NULL;
 }
+
+
+/* ----------------------------------------------------------------------- */
+
+static STIX_INLINE int bcsn_to_ucsn_with_cmgr (
+	const stix_bch_t* bcs, stix_oow_t* bcslen,
+	stix_uch_t* ucs, stix_oow_t* ucslen, stix_cmgr_t* cmgr, int all)
+{
+	const stix_bch_t* p;
+	int ret = 0;
+	stix_oow_t mlen;
+
+	if (ucs)
+	{
+		/* destination buffer is specified. 
+		 * copy the conversion result to the buffer */
+
+		stix_uch_t* q, * qend;
+
+		p = bcs;
+		q = ucs;
+		qend = ucs + *ucslen;
+		mlen = *bcslen;
+
+		while (mlen > 0)
+		{
+			stix_oow_t n;
+
+			if (q >= qend)
+			{
+				/* buffer too small */
+				ret = -2;
+				break;
+			}
+
+			n = cmgr->bctouc (p, mlen, q);
+			if (n == 0)
+			{
+				/* invalid sequence */
+				if (all)
+				{
+					n = 1;
+					*q = '?';
+				}
+				else
+				{
+					ret = -1;
+					break;
+				}
+			}
+			if (n > mlen)
+			{
+				/* incomplete sequence */
+				if (all)
+				{
+					n = 1;
+					*q = '?';
+				}
+				else
+				{
+					ret = -3;
+					break;
+				}
+			}
+
+			q++;
+			p += n;
+			mlen -= n;
+		}
+
+		*ucslen = q - ucs;
+		*bcslen = p - bcs;
+	}
+	else
+	{
+		/* no destination buffer is specified. perform conversion
+		 * but don't copy the result. the caller can call this function
+		 * without a buffer to find the required buffer size, allocate
+		 * a buffer with the size and call this function again with 
+		 * the buffer. */
+
+		stix_uch_t w;
+		stix_oow_t wlen = 0;
+
+		p = bcs;
+		mlen = *bcslen;
+
+		while (mlen > 0)
+		{
+			stix_oow_t n;
+
+			n = cmgr->bctouc (p, mlen, &w);
+			if (n == 0)
+			{
+				/* invalid sequence */
+				if (all) n = 1;
+				else
+				{
+					ret = -1;
+					break;
+				}
+			}
+			if (n > mlen)
+			{
+				/* incomplete sequence */
+				if (all) n = 1;
+				else
+				{
+					ret = -3;
+					break;
+				}
+			}
+
+			p += n;
+			mlen -= n;
+			wlen += 1;
+		}
+
+		*ucslen = wlen;
+		*bcslen = p - bcs;
+	}
+
+	return ret;
+}
+
+static STIX_INLINE int bcs_to_ucs_with_cmgr (
+	const stix_bch_t* bcs, stix_oow_t* bcslen,
+	stix_uch_t* ucs, stix_oow_t* ucslen, stix_cmgr_t* cmgr, int all)
+{
+	const stix_bch_t* bp;
+	stix_oow_t mlen, wlen;
+	int n;
+
+	for (bp = bcs; *bp != '\0'; bp++) /* nothing */ ;
+
+	mlen = bp - bcs; wlen = *ucslen;
+	n = bcsn_to_ucsn_with_cmgr (bcs, &mlen, ucs, &wlen, cmgr, all);
+	if (ucs)
+	{
+		/* null-terminate the target buffer if it has room for it. */
+		if (wlen < *ucslen) ucs[wlen] = '\0';
+		else n = -2; /* buffer too small */
+	}
+	*bcslen = mlen; *ucslen = wlen;
+
+	return n;
+}
+
+static STIX_INLINE int ucsn_to_bcsn_with_cmgr (
+	const stix_uch_t* ucs, stix_oow_t* ucslen,
+	stix_bch_t* bcs, stix_oow_t* bcslen, stix_cmgr_t* cmgr)
+{
+	const stix_uch_t* p = ucs;
+	const stix_uch_t* end = ucs + *ucslen;
+	int ret = 0; 
+
+	if (bcs)
+	{
+		stix_oow_t rem = *bcslen;
+
+		while (p < end) 
+		{
+			stix_oow_t n;
+
+			if (rem <= 0)
+			{
+				ret = -2; /* buffer too small */
+				break;
+			}
+
+			n = cmgr->uctobc (*p, bcs, rem);
+			if (n == 0) 
+			{
+				ret = -1;
+				break; /* illegal character */
+			}
+			if (n > rem) 
+			{
+				ret = -2; /* buffer too small */
+				break;
+			}
+			bcs += n; rem -= n; p++;
+		}
+
+		*bcslen -= rem; 
+	}
+	else
+	{
+		stix_bch_t bcsbuf[STIX_BCLEN_MAX];
+		stix_oow_t mlen = 0;
+
+		while (p < end)
+		{
+			stix_oow_t n;
+
+			n = cmgr->uctobc (*p, bcsbuf, STIX_COUNTOF(bcsbuf));
+			if (n == 0) 
+			{
+				ret = -1;
+				break; /* illegal character */
+			}
+
+			/* it assumes that bcsbuf is large enough to hold a character */
+			STIX_ASSERT (n <= STIX_COUNTOF(bcsbuf));
+
+			p++; mlen += n;
+		}
+
+		/* this length excludes the terminating null character. 
+		 * this function doesn't even null-terminate the result. */
+		*bcslen = mlen;
+	}
+
+	*ucslen = p - ucs;
+	return ret;
+}
+
+
+static int ucs_to_bcs_with_cmgr (
+	const stix_uch_t* ucs, stix_oow_t* ucslen,
+	stix_bch_t* bcs, stix_oow_t* bcslen, stix_cmgr_t* cmgr)
+{
+	const stix_uch_t* p = ucs;
+	int ret = 0;
+
+	if (bcs)
+	{
+		stix_oow_t rem = *bcslen;
+
+		while (*p != '\0')
+		{
+			stix_oow_t n;
+
+			if (rem <= 0)
+			{
+				ret = -2;
+				break;
+			}
+			
+			n = cmgr->uctobc (*p, bcs, rem);
+			if (n == 0) 
+			{
+				ret = -1;
+				break; /* illegal character */
+			}
+			if (n > rem) 
+			{
+				ret = -2;
+				break; /* buffer too small */
+			}
+
+			bcs += n; rem -= n; p++;
+		}
+
+		/* update bcslen to the length of the bcs string converted excluding
+		 * terminating null */
+		*bcslen -= rem; 
+
+		/* null-terminate the multibyte sequence if it has sufficient space */
+		if (rem > 0) *bcs = '\0';
+		else 
+		{
+			/* if ret is -2 and cs[cslen] == '\0', 
+			 * this means that the bcs buffer was lacking one
+			 * slot for the terminating null */
+			ret = -2; /* buffer too small */
+		}
+	}
+	else
+	{
+		stix_bch_t bcsbuf[STIX_BCLEN_MAX];
+		stix_oow_t mlen = 0;
+
+		while (*p != '\0')
+		{
+			stix_oow_t n;
+
+			n = cmgr->uctobc (*p, bcsbuf, STIX_COUNTOF(bcsbuf));
+			if (n == 0) 
+			{
+				ret = -1;
+				break; /* illegal character */
+			}
+
+			/* it assumes that bcs is large enough to hold a character */
+			STIX_ASSERT (n <= STIX_COUNTOF(bcs));
+
+			p++; mlen += n;
+		}
+
+		/* this length holds the number of resulting multi-byte characters 
+		 * excluding the terminating null character */
+		*bcslen = mlen;
+	}
+
+	*ucslen = p - ucs;  /* the number of wide characters handled. */
+	return ret;
+}
+
+static stix_cmgr_t utf8_cmgr =
+{
+	stix_utf8touc,
+	stix_uctoutf8
+};
+
+stix_cmgr_t* stix_getutf8cmgr (void)
+{
+	return &utf8_cmgr;
+}
+
+int stix_utf8toucs (const stix_bch_t* bcs, stix_oow_t* bcslen, stix_uch_t* ucs, stix_oow_t* ucslen)
+{
+	if (*bcslen == ~(stix_oow_t)0)
+	{
+		/* the source is null-terminated. */
+		return bcs_to_ucs_with_cmgr (bcs, bcslen, ucs, ucslen, &utf8_cmgr, 0);
+	}
+	else
+	{
+		/* the source is length bound */
+		return bcsn_to_ucsn_with_cmgr (bcs, bcslen, ucs, ucslen, &utf8_cmgr, 0);
+	}
+}
+
+int stix_ucstoutf8 (const stix_uch_t* ucs, stix_oow_t* ucslen, stix_bch_t* bcs, stix_oow_t* bcslen)
+{
+	if (*ucslen == ~(stix_oow_t)0)
+	{
+		/* null-terminated */
+		return ucs_to_bcs_with_cmgr (ucs, ucslen, bcs, bcslen, &utf8_cmgr);
+	}
+	else
+	{
+		/* length bound */
+		return ucsn_to_bcsn_with_cmgr (ucs, ucslen, bcs, bcslen, &utf8_cmgr);
+	}
+}
+
+int stix_bcstoucs (stix_t* stix, const stix_bch_t* bcs, stix_oow_t* bcslen, stix_uch_t* ucs, stix_oow_t* ucslen)
+{
+	if (*bcslen == ~(stix_oow_t)0)
+	{
+		/* the source is null-terminated. */
+		return bcs_to_ucs_with_cmgr (bcs, bcslen, ucs, ucslen, stix->cmgr, 0);
+	}
+	else
+	{
+		/* the source is length bound */
+		return bcsn_to_ucsn_with_cmgr (bcs, bcslen, ucs, ucslen, stix->cmgr, 0);
+	}
+}
+
+int stix_ucstobcs (stix_t* stix, const stix_uch_t* ucs, stix_oow_t* ucslen, stix_bch_t* bcs, stix_oow_t* bcslen)
+{
+	if (*ucslen == ~(stix_oow_t)0)
+	{
+		/* null-terminated */
+		return ucs_to_bcs_with_cmgr (ucs, ucslen, bcs, bcslen, stix->cmgr);
+	}
+	else
+	{
+		/* length bound */
+		return ucsn_to_bcsn_with_cmgr (ucs, ucslen, bcs, bcslen, stix->cmgr);
+	}
+}
+
diff --git a/stix/mod/console.c b/stix/mod/console.c
index 6b0c8da..49d6101 100644
--- a/stix/mod/console.c
+++ b/stix/mod/console.c
@@ -166,7 +166,7 @@ static int prim_write (stix_t* stix, stix_ooi_t nargs)
 	{
 		ucslen = ucsrem;
 		bcslen = STIX_COUNTOF(bcs);
-		if ((n = stix_ucstoutf8 (&oomsg->slot[ucspos], &ucslen, bcs, &bcslen)) <= -1)
+		if ((n = stix_oocstobcs (stix, &oomsg->slot[ucspos], &ucslen, bcs, &bcslen)) <= -1)
 		{
 			if (n != -2 || ucslen <= 0) 
 			{
@@ -267,7 +267,7 @@ static fnctab_t fnctab[] =
 
 /* ------------------------------------------------------------------------ */
 
-static stix_prim_impl_t query (stix_t* stix, stix_prim_mod_t* mod, const stix_ooch_t* name)
+static stix_prim_impl_t query (stix_t* stix, stix_mod_t* mod, const stix_ooch_t* name)
 {
 	int left, right, mid, n;
 
@@ -291,13 +291,13 @@ static stix_prim_impl_t query (stix_t* stix, stix_prim_mod_t* mod, const stix_oo
 }
 
 
-static void unload (stix_t* stix, stix_prim_mod_t* mod)
+static void unload (stix_t* stix, stix_mod_t* mod)
 {
 	/* TODO: close all open handle?? */
 }
 
 
-int stix_prim_mod_console (stix_t* stix, stix_prim_mod_t* mod)
+int stix_mod_console (stix_t* stix, stix_mod_t* mod)
 {
 	mod->query = query;
 	mod->unload = unload; 
diff --git a/stix/mod/sound.c b/stix/mod/sound.c
index 62ff0ea..3a63ecc 100644
--- a/stix/mod/sound.c
+++ b/stix/mod/sound.c
@@ -59,7 +59,7 @@ static fnctab_t fnctab[] =
 
 /* ------------------------------------------------------------------------ */
 
-static stix_prim_impl_t query (stix_t* stix, stix_prim_mod_t* mod, const stix_ooch_t* name)
+static stix_prim_impl_t query (stix_t* stix, stix_mod_t* mod, const stix_ooch_t* name)
 {
 	int left, right, mid, n;
 
@@ -88,12 +88,12 @@ static stix_prim_impl_t query (stix_t* stix, stix_prim_mod_t* mod, const stix_oo
 }
 
 
-static void unload (stix_t* stix, stix_prim_mod_t* mod)
+static void unload (stix_t* stix, stix_mod_t* mod)
 {
 }
 
 
-int stix_prim_mod_sound (stix_t* stix, stix_prim_mod_t* mod)
+int stix_mod_sound (stix_t* stix, stix_mod_t* mod)
 {
 	mod->query = query;
 	mod->unload = unload;
diff --git a/stix/mod/stdio.c b/stix/mod/stdio.c
index ac2ba34..9d1d591 100644
--- a/stix/mod/stdio.c
+++ b/stix/mod/stdio.c
@@ -31,12 +31,18 @@
 #include <stdio.h>
 #include <limits.h>
 
+typedef struct stdio_t stdio_t;
+struct stdio_t
+{
+	STIX_OBJ_HEADER;
+	FILE* fp;
+};
+
 static int prim_open (stix_t* stix, stix_ooi_t nargs)
 {
-	stix_oop_word_t rcv;
 	stix_oop_char_t name;
 	stix_oop_char_t mode;
-	FILE* fp;
+	stdio_t* rcv;
 
 #if defined(STIX_OOCH_IS_UCH)
 	stix_oow_t ucslen, bcslen;
@@ -44,7 +50,7 @@ static int prim_open (stix_t* stix, stix_ooi_t nargs)
 	stix_bch_t modebuf[32]; /* TODO: dynamic-sized conversion?? */
 #endif
 
-	rcv = (stix_oop_word_t)STIX_STACK_GETRCV(stix, nargs);
+	rcv = (stdio_t*)STIX_STACK_GETRCV(stix, nargs);
 	name = (stix_oop_char_t)STIX_STACK_GETARG(stix, nargs, 0);
 	mode = (stix_oop_char_t)STIX_STACK_GETARG(stix, nargs, 1);
 
@@ -52,45 +58,46 @@ static int prim_open (stix_t* stix, stix_ooi_t nargs)
 /* TODO: error check on string conversion */
 	ucslen = STIX_OBJ_GET_SIZE(name);
 	bcslen = STIX_COUNTOF(namebuf) - 1;
-	stix_ucstoutf8 (name->slot, &ucslen, namebuf, &bcslen);
+	stix_oocstobcs (stix, name->slot, &ucslen, namebuf, &bcslen); /* TODO: error check */
 	namebuf[bcslen] = '\0';
 
 	ucslen = STIX_OBJ_GET_SIZE(mode);
 	bcslen = STIX_COUNTOF(modebuf) - 1;
-	stix_ucstoutf8 (mode->slot, &ucslen, modebuf, &bcslen);
+	stix_oocstobcs (stix, mode->slot, &ucslen, modebuf, &bcslen); /* TODO: error check */
 	modebuf[bcslen] = '\0';
 
-STIX_DEBUG2 (stix, "opening %s for %s\n", namebuf, modebuf);
-	fp = fopen (namebuf, modebuf);
+	rcv->fp = fopen (namebuf, modebuf);
 #else
-	fp = fopen (name->slot, mode->slot);
+	rcv->fp = fopen (name->slot, mode->slot);
 #endif
-	if (!fp) 
+	if (!rcv->fp) 
 	{
+STIX_DEBUG2 (stix, "cannot open %s for %s\n", namebuf, modebuf);
 		return -1;  /* TODO: return success with an object instead... */
 	}
 
-	rcv->slot[0] = (stix_oow_t)fp;
+STIX_DEBUG3 (stix, "opened %s for %s - %p\n", namebuf, modebuf, rcv->fp);
 	STIX_STACK_SETRETTORCV (stix, nargs);
 	return 1;
 }
 
 static int prim_close (stix_t* stix, stix_ooi_t nargs)
 {
-	stix_oop_word_t rcv;
+	stdio_t* rcv;
 
-	rcv = (stix_oop_word_t)STIX_STACK_GETRCV(stix, nargs);
-	if (rcv->slot[0])
+	rcv = (stdio_t*)STIX_STACK_GETRCV(stix, nargs);
+	if (rcv->fp)
 	{
-		fclose ((FILE*)rcv->slot[0]);
-		rcv->slot[0] = 0;
+STIX_DEBUG1 (stix, "closing %p\n", rcv->fp);
+		fclose (rcv->fp);
+		rcv->fp = NULL;
 	}
 
 	STIX_STACK_SETRETTORCV (stix, nargs);
 	return 1;
 }
 
-static int prim_write (stix_t* stix, stix_ooi_t nargs)
+static int prim_puts (stix_t* stix, stix_ooi_t nargs)
 {
 	/* return how many bytes have been written.. */
 
@@ -98,6 +105,12 @@ static int prim_write (stix_t* stix, stix_ooi_t nargs)
 	return 1;
 }
 
+static int prim_newinstsize (stix_t* stix, stix_ooi_t nargs)
+{
+	stix_ooi_t newinstsize = STIX_SIZEOF(stdio_t) - STIX_SIZEOF(stix_obj_t);
+	STIX_STACK_SETRET (stix, nargs, STIX_SMOOI_TO_OOP(newinstsize)); 
+	return 1;
+}
 /* ------------------------------------------------------------------------ */
 
 typedef struct fnctab_t fnctab_t;
@@ -109,14 +122,15 @@ struct fnctab_t
 
 static fnctab_t fnctab[] =
 {
-	{ "close",      prim_close     },
-	{ "open",       prim_open      },
-	{ "write",      prim_write     }
+	{ "close",       prim_close         },
+	{ "newInstSize", prim_newinstsize   },
+	{ "open",        prim_open          },
+	{ "puts",        prim_puts          }
 };
 
 /* ------------------------------------------------------------------------ */
 
-static stix_prim_impl_t query (stix_t* stix, stix_prim_mod_t* mod, const stix_ooch_t* name)
+static stix_prim_impl_t query (stix_t* stix, stix_mod_t* mod, const stix_ooch_t* name)
 {
 	int left, right, mid, n;
 
@@ -150,13 +164,12 @@ static int sanity_check (stix_t* stix)
 }
 #endif
 
-static void unload (stix_t* stix, stix_prim_mod_t* mod)
+static void unload (stix_t* stix, stix_mod_t* mod)
 {
 	/* TODO: close all open handle?? */
 }
 
-
-int stix_prim_mod_stdio (stix_t* stix, stix_prim_mod_t* mod)
+int stix_mod_stdio (stix_t* stix, stix_mod_t* mod)
 {
 	mod->query = query;
 	mod->unload = unload;