diff --git a/stix/lib/comp.c b/stix/lib/comp.c
index 37b9755..772be27 100644
--- a/stix/lib/comp.c
+++ b/stix/lib/comp.c
@@ -1668,7 +1668,7 @@ retry:
 			break;
 	}
 
-STIX_DEBUG2 (stix, "TOKEN: [%.*S]\n", (stix_ooi_t)stix->c->tok.name.len, stix->c->tok.name.ptr);
+STIX_DEBUG2 (stix, "TOKEN: [%.*js]\n", (stix_ooi_t)stix->c->tok.name.len, stix->c->tok.name.ptr);
 
 	return 0;
 }
@@ -4976,7 +4976,7 @@ static int __compile_class_definition (stix_t* stix, int extend)
 	{
 		int super_is_nil = 0;
 
-		STIX_INFO2 (stix, "Defining a class %.*S\n", stix->c->cls.fqn.len, stix->c->cls.fqn.ptr);
+		STIX_INFO2 (stix, "Defining a class %.*js\n", stix->c->cls.fqn.len, stix->c->cls.fqn.ptr);
 
 		if (TOKEN_TYPE(stix) == STIX_IOTOK_LPAREN)
 		{
@@ -5338,7 +5338,7 @@ static int __compile_pooldic_definition (stix_t* stix)
 		return -1;
 	}
 
-	STIX_INFO2 (stix, "Defining a pool dictionary %.*S\n", stix->c->cls.fqn.len, stix->c->cls.fqn.ptr);
+	STIX_INFO2 (stix, "Defining a pool dictionary %.*js\n", stix->c->cls.fqn.len, stix->c->cls.fqn.ptr);
 
 	GET_TOKEN (stix);
 
diff --git a/stix/lib/decode.c b/stix/lib/decode.c
index 38d0916..41ac6bf 100644
--- a/stix/lib/decode.c
+++ b/stix/lib/decode.c
@@ -58,7 +58,7 @@ int stix_decode (stix_t* stix, stix_oop_method_t mth, const stix_oocs_t* classfq
 	cdlen = STIX_METHOD_GET_CODE_SIZE(mth); 
 
 	if (classfqn)
-		STIX_LOG3 (stix, DECODE_LOG_MASK, "%.*S>>%O\n", classfqn->len, classfqn->ptr, mth->name);
+		STIX_LOG3 (stix, DECODE_LOG_MASK, "%.*js>>%O\n", classfqn->len, classfqn->ptr, mth->name);
 	else
 		STIX_LOG2 (stix, DECODE_LOG_MASK, "%O>>%O\n", mth->owner, mth->name);
 
diff --git a/stix/lib/exec.c b/stix/lib/exec.c
index 0cc9997..0fc98ab 100644
--- a/stix/lib/exec.c
+++ b/stix/lib/exec.c
@@ -1079,7 +1079,7 @@ not_found:
 		}
 	}
 
-	STIX_DEBUG3 (stix, "Method [%.*S] not found for %O\n", message->len, message->ptr, receiver);
+	STIX_DEBUG3 (stix, "Method [%.*js] not found for %O\n", message->len, message->ptr, receiver);
 	stix->errnum = STIX_ENOENT;
 	return STIX_NULL;
 }
@@ -1204,21 +1204,21 @@ start_over:
 	{
 		if (*ptr == '\0') 
 		{
-			n = stix_logbfmt (stix, mask, "%C", *ptr);
+			n = stix_logbfmt (stix, mask, "%jc", *ptr);
 			STIX_ASSERT (stix, n == 1);
 			rem -= n;
 			ptr += n;
 			goto start_over;
 		}
 
-		n = stix_logbfmt (stix, mask, "%.*S", rem, ptr);
+		n = stix_logbfmt (stix, mask, "%.*js", rem, ptr);
 		if (n <= -1) break;
 		if (n == 0) 
 		{
 			/* to skip the unprinted character. 
-			 * actually, this check is not needed because of '\0' skipping
+			 * actually, this check is not needed because of '\0' skipped
 			 * at the beginning  of the loop */
-			n = stix_logbfmt (stix, mask, "%C", *ptr);
+			n = stix_logbfmt (stix, mask, "%jc", *ptr);
 			STIX_ASSERT (stix, n == 1);
 		}
 		rem -= n;
@@ -3246,7 +3246,7 @@ static int send_message (stix_t* stix, stix_oop_char_t selector, int to_super, s
 			/* this must not happen as long as doesNotUnderstand: is implemented under Apex.
 			 * this check should indicate a very serious internal problem */
 			STIX_LOG4 (stix, STIX_LOG_IC | STIX_LOG_FATAL, 
-				"Fatal error - receiver [%O] of class [%O] does not understand a message [%.*S]\n", 
+				"Fatal error - receiver [%O] of class [%O] does not understand a message [%.*js]\n", 
 				receiver, STIX_CLASSOF(stix, receiver), mthname.len, mthname.ptr);
 
 			stix->errnum = STIX_EMSGSND;
@@ -3281,7 +3281,7 @@ static int send_private_message (stix_t* stix, const stix_ooch_t* nameptr, stix_
 	if (!method)
 	{
 		STIX_LOG4 (stix, STIX_LOG_IC | STIX_LOG_FATAL, 
-			"Fatal error - receiver [%O] of class [%O] does not understand a private message [%.*S]\n", 
+			"Fatal error - receiver [%O] of class [%O] does not understand a private message [%.*js]\n", 
 			receiver, STIX_CLASSOF(stix, receiver), mthname.len, mthname.ptr);
 		stix->errnum = STIX_EMSGSND;
 		return -1;
diff --git a/stix/lib/logfmt.c b/stix/lib/logfmt.c
index 16ce6a9..2f5bd0d 100644
--- a/stix/lib/logfmt.c
+++ b/stix/lib/logfmt.c
@@ -126,12 +126,12 @@ static const stix_bch_t hex2ascii_upper[] =
 	'N','O','P','Q','R','S','T','U','V','W','X','H','Z'
 };
 
-static stix_ooch_t ooch_nullstr[] = { '(','n','u','l','l', ')','\0' };
+static stix_uch_t uch_nullstr[] = { '(','n','u','l','l', ')','\0' };
 static stix_bch_t bch_nullstr[] = { '(','n','u','l','l', ')','\0' };
 
 typedef int (*stix_fmtout_putch_t) (
 	stix_t*      stix,
-	stix_oow_t mask,
+	stix_oow_t   mask,
 	stix_ooch_t  c,
 	stix_oow_t   len
 );
@@ -350,7 +350,7 @@ static void print_object (stix_t* stix, stix_oow_t mask, stix_oop_t oop)
 		{
 			if ((stix_oop_t)c == stix->_symbol) 
 			{
-				stix_logbfmt (stix, mask, "#%.*S", STIX_OBJ_GET_SIZE(oop), ((stix_oop_char_t)oop)->slot);
+				stix_logbfmt (stix, mask, "#%.*js", STIX_OBJ_GET_SIZE(oop), ((stix_oop_char_t)oop)->slot);
 			}
 			else /*if ((stix_oop_t)c == stix->_string)*/
 			{
@@ -411,11 +411,11 @@ static void print_object (stix_t* stix, stix_oow_t mask, stix_oop_t oop)
 							if (escaped == ch)
 								stix_logbfmt (stix, mask, "\\x%X", ch);
 							else
-								stix_logbfmt (stix, mask, "\\%C", escaped);
+								stix_logbfmt (stix, mask, "\\%jc", escaped);
 						}
 						else
 						{
-							stix_logbfmt (stix, mask, "%C", ch);
+							stix_logbfmt (stix, mask, "%jc", ch);
 						}
 					}
 					
@@ -423,7 +423,7 @@ static void print_object (stix_t* stix, stix_oow_t mask, stix_oop_t oop)
 				}
 				else
 				{
-					stix_logbfmt (stix, mask, "'%.*S'", STIX_OBJ_GET_SIZE(oop), ((stix_oop_char_t)oop)->slot);
+					stix_logbfmt (stix, mask, "'%.*js'", STIX_OBJ_GET_SIZE(oop), ((stix_oop_char_t)oop)->slot);
 				}
 			}
 		}
@@ -468,7 +468,7 @@ static void print_object (stix_t* stix, stix_oow_t mask, stix_oop_t oop)
 		else if ((stix_oop_t)c == stix->_class)
 		{
 			/* print the class name */
-			stix_logbfmt (stix, mask, "%.*S", STIX_OBJ_GET_SIZE(((stix_oop_class_t)oop)->name), ((stix_oop_class_t)oop)->name->slot);
+			stix_logbfmt (stix, mask, "%.*js", STIX_OBJ_GET_SIZE(((stix_oop_class_t)oop)->name), ((stix_oop_class_t)oop)->name->slot);
 		}
 		else if ((stix_oop_t)c == stix->_association)
 		{
@@ -476,7 +476,7 @@ static void print_object (stix_t* stix, stix_oow_t mask, stix_oop_t oop)
 		}
 		else
 		{
-			stix_logbfmt (stix, mask, "instance of %.*S(%p)", STIX_OBJ_GET_SIZE(c->name), ((stix_oop_char_t)c->name)->slot, oop);
+			stix_logbfmt (stix, mask, "instance of %.*js(%p)", STIX_OBJ_GET_SIZE(c->name), ((stix_oop_char_t)c->name)->slot, oop);
 		}
 	}
 }
@@ -487,14 +487,21 @@ static void print_object (stix_t* stix, stix_oow_t mask, stix_oop_t oop)
 #undef logfmtv
 #define fmtchar_t stix_bch_t
 #define FMTCHAR_IS_BCH
+#if defined(STIX_OOCH_IS_BCH)
+#	define FMTCHAR_IS_OOCH
+#endif
 #define logfmtv stix_logbfmtv
+
 #include "logfmtv.h"
 
 #undef fmtchar_t
 #undef logfmtv
-#define fmtchar_t stix_ooch_t
-#define logfmtv stix_logoofmtv
-#define FMTCHAR_IS_OOCH
+#define fmtchar_t stix_uch_t
+#define logfmtv stix_logufmtv
+#define FMTCHAR_IS_UCH
+#if defined(STIX_OOCH_IS_UCH)
+#	define FMTCHAR_IS_OOCH
+#endif
 #include "logfmtv.h"
 
 stix_ooi_t stix_logbfmt (stix_t* stix, stix_oow_t mask, const stix_bch_t* fmt, ...)
@@ -519,7 +526,7 @@ stix_ooi_t stix_logbfmt (stix_t* stix, stix_oow_t mask, const stix_bch_t* fmt, .
 	return (x <= -1)? -1: fo.count;
 }
 
-stix_ooi_t stix_logoofmt (stix_t* stix, stix_oow_t mask, const stix_ooch_t* fmt, ...)
+stix_ooi_t stix_logufmt (stix_t* stix, stix_oow_t mask, const stix_uch_t* fmt, ...)
 {
 	int x;
 	va_list ap;
@@ -530,7 +537,7 @@ stix_ooi_t stix_logoofmt (stix_t* stix, stix_oow_t mask, const stix_ooch_t* fmt,
 	fo.putcs = put_oocs;
 
 	va_start (ap, fmt);
-	x = stix_logoofmtv (stix, fmt, &fo, ap);
+	x = stix_logufmtv (stix, fmt, &fo, ap);
 	va_end (ap);
 
 	if (stix->log.len > 0 && stix->log.ptr[stix->log.len - 1] == '\n')
diff --git a/stix/lib/logfmtv.h b/stix/lib/logfmtv.h
index 851a215..d2997b8 100644
--- a/stix/lib/logfmtv.h
+++ b/stix/lib/logfmtv.h
@@ -378,7 +378,9 @@ reswitch:
 			/* zeropad must not take effect for 'c' */
 			if (flagc & FLAGC_ZEROPAD) padc = ' '; 
 			if (lm_flag & LF_L) goto uppercase_c;
-
+		#if defined(STIX_OOCH_IS_UCH)
+			if (lm_flag & LF_J) goto uppercase_c;
+		#endif
 		lowercase_c:
 			bch = STIX_SIZEOF(stix_bch_t) < STIX_SIZEOF(int)? va_arg(ap, int): va_arg(ap, stix_bch_t);
 
@@ -393,13 +395,16 @@ reswitch:
 
 		case 'C':
 		{
-			stix_ooch_t ooch;
+			stix_uch_t ooch;
 
 			/* zeropad must not take effect for 'C' */
 			if (flagc & FLAGC_ZEROPAD) padc = ' ';
 			if (lm_flag & LF_H) goto lowercase_c;
+		#if defined(STIX_OOCH_IS_BCH)
+			if (lm_flag & LF_J) goto lowercase_c;
+		#endif
 		uppercase_c:
-			ooch = STIX_SIZEOF(stix_ooch_t) < STIX_SIZEOF(int)? va_arg(ap, int): va_arg(ap, stix_ooch_t);
+			ooch = STIX_SIZEOF(stix_uch_t) < STIX_SIZEOF(int)? va_arg(ap, int): va_arg(ap, stix_uch_t);
 
 			/* precision 0 doesn't kill the letter */
 			width--;
@@ -417,11 +422,15 @@ reswitch:
 			/* zeropad must not take effect for 'S' */
 			if (flagc & FLAGC_ZEROPAD) padc = ' ';
 			if (lm_flag & LF_L) goto uppercase_s;
+		#if defined(STIX_OOCH_IS_UCH)
+			if (lm_flag & LF_J) goto uppercase_s;
+		#endif
 		lowercase_s:
 
 			bsp = va_arg (ap, stix_bch_t*);
 			if (bsp == STIX_NULL) bsp = bch_nullstr;
 
+		#if defined(STIX_OOCH_IS_UCH)
 			/* get the length */
 			for (bslen = 0; bsp[bslen]; bslen++);
 
@@ -461,34 +470,94 @@ reswitch:
 			}
 			
 			if ((flagc & FLAGC_LEFTADJ) && width > 0) PUT_OOCH (padc, width);
-			break;
-		}
-
-		case 'S':
-		{
-			const stix_ooch_t* sp;
-
-			/* zeropad must not take effect for 's' */
-			if (flagc & FLAGC_ZEROPAD) padc = ' ';
-			if (lm_flag & LF_H) goto lowercase_s;
-		uppercase_s:
-			sp = va_arg (ap, stix_ooch_t*);
-			if (sp == STIX_NULL) sp = ooch_nullstr;
-
+		#else
 			if (flagc & FLAGC_DOT)
 			{
-				for (n = 0; n < precision && sp[n]; n++);
+				for (n = 0; n < precision && bsp[n]; n++);
 			}
 			else
 			{
-				for (n = 0; sp[n]; n++);
+				for (n = 0; bsp[n]; n++);
 			}
 
 			width -= n;
 
 			if (!(flagc & FLAGC_LEFTADJ) && width > 0) PUT_OOCH (padc, width);
-			PUT_OOCS (sp, n);
+			PUT_OOCS (bsp, n);
 			if ((flagc & FLAGC_LEFTADJ) && width > 0) PUT_OOCH (padc, width);
+		#endif
+			break;
+		}
+
+		case 'S':
+		{
+			const stix_uch_t* usp;
+			stix_oow_t uslen, slen;
+
+			/* zeropad must not take effect for 's' */
+			if (flagc & FLAGC_ZEROPAD) padc = ' ';
+			if (lm_flag & LF_H) goto lowercase_s;
+		#if defined(STIX_OOCH_IS_UCH)
+			if (lm_flag & LF_J) goto lowercase_s;
+		#endif
+		uppercase_s:
+			usp = va_arg (ap, stix_uch_t*);
+			if (usp == STIX_NULL) usp = uch_nullstr;
+
+		#if defined(STIX_OOCH_IS_BCH)
+			/* get the length */
+			for (uslen = 0; usp[uslen]; uslen++);
+
+			if (stix_convutooochars (stix, usp, &uslen, STIX_NULL, &slen) <= -1)
+			{ 
+				/* conversion error */
+				stix->errnum = STIX_EECERR;
+				goto oops;
+			}
+
+			/* slen holds the length after conversion */
+			n = slen;
+			if ((flagc & FLAGC_DOT) && precision < slen) n = precision;
+			width -= n;
+
+			if (!(flagc & FLAGC_LEFTADJ) && width > 0) PUT_OOCH (padc, width);
+			{
+				stix_ooch_t conv_buf[32]; 
+				stix_oow_t conv_len, src_len, tot_len = 0;
+				while (n > 0)
+				{
+					STIX_ASSERT (stix, uslen > tot_len);
+
+					src_len = uslen - tot_len;
+					conv_len = STIX_COUNTOF(conv_buf);
+
+					/* this must not fail since the dry-run above was successful */
+					stix_convutooochars (stix, &usp[tot_len], &src_len, conv_buf, &conv_len);
+					tot_len += src_len;
+
+					if (conv_len > n) conv_len = n;
+					PUT_OOCS (conv_buf, conv_len);
+
+					n -= conv_len;
+				}
+			}
+			if ((flagc & FLAGC_LEFTADJ) && width > 0) PUT_OOCH (padc, width);
+		#else
+			if (flagc & FLAGC_DOT)
+			{
+				for (n = 0; n < precision && usp[n]; n++);
+			}
+			else
+			{
+				for (n = 0; usp[n]; n++);
+			}
+
+			width -= n;
+
+			if (!(flagc & FLAGC_LEFTADJ) && width > 0) PUT_OOCH (padc, width);
+			PUT_OOCS (usp, n);
+			if ((flagc & FLAGC_LEFTADJ) && width > 0) PUT_OOCH (padc, width);
+		#endif
 			break;
 		}
 
@@ -721,7 +790,7 @@ handle_nosign:
 				 * This is just a work-around for it */
 				int i;
 				for (i = 0, num = 0; i < STIX_SIZEOF(stix_uintmax_t) / STIX_SIZEOF(stix_oow_t); i++)
-				{	
+				{
 				#if defined(STIX_ENDIAN_BIG)
 					num = num << (8 * STIX_SIZEOF(stix_oow_t)) | (va_arg (ap, stix_oow_t));
 				#else
diff --git a/stix/lib/proc.c b/stix/lib/proc.c
index 419378b..32c265e 100644
--- a/stix/lib/proc.c
+++ b/stix/lib/proc.c
@@ -24,7 +24,6 @@
     THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-
 #include "stix-prv.h"
 
 stix_oop_process_t stix_addnewproc (stix_t* stix)
diff --git a/stix/lib/stix.c b/stix/lib/stix.c
index 9317974..b1dbf52 100644
--- a/stix/lib/stix.c
+++ b/stix/lib/stix.c
@@ -455,7 +455,7 @@ stix_mod_data_t* stix_openmod (stix_t* stix, const stix_ooch_t* name, stix_oow_t
 
 	if (md.handle == STIX_NULL) 
 	{
-		STIX_DEBUG2 (stix, "Cannot open a module [%.*S]\n", namelen, name);
+		STIX_DEBUG2 (stix, "Cannot open a module [%.*js]\n", namelen, name);
 		stix->errnum = STIX_ENOENT; /* TODO: be more descriptive about the error */
 		return STIX_NULL;
 	}
@@ -464,7 +464,7 @@ stix_mod_data_t* stix_openmod (stix_t* stix, const stix_ooch_t* name, stix_oow_t
 	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_DEBUG3 (stix, "Cannot get a module symbol [%js] in [%.*js]\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;
@@ -475,7 +475,7 @@ stix_mod_data_t* stix_openmod (stix_t* stix, const stix_ooch_t* name, stix_oow_t
 	pair = stix_rbt_insert (&stix->modtab, (void*)name, namelen, &md, STIX_SIZEOF(md));
 	if (pair == STIX_NULL)
 	{
-		STIX_DEBUG2 (stix, "Cannot register a module [%.*S]\n", namelen, name);
+		STIX_DEBUG2 (stix, "Cannot register a module [%.*js]\n", namelen, name);
 		stix->errnum = STIX_ESYSMEM;
 		stix->vmprim.dl_close (stix, md.handle);
 		return STIX_NULL;
@@ -484,7 +484,7 @@ stix_mod_data_t* stix_openmod (stix_t* stix, const stix_ooch_t* name, stix_oow_t
 	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_DEBUG3 (stix, "Module function [%js] returned failure in [%.*js]\n", buf, namelen, name);
 		stix->errnum = STIX_ENOENT; /* TODO: proper error code and handling */
 		stix_rbt_delete (&stix->modtab, name, namelen);
 		stix->vmprim.dl_close (stix, mdp->handle);
@@ -493,7 +493,7 @@ stix_mod_data_t* stix_openmod (stix_t* stix, const stix_ooch_t* name, stix_oow_t
 
 	mdp->pair = pair;
 
-	STIX_DEBUG2 (stix, "Opened a module [%S] - %p\n", mdp->mod.name, mdp->handle);
+	STIX_DEBUG2 (stix, "Opened a module [%js] - %p\n", mdp->mod.name, mdp->handle);
 
 	/* the module loader must ensure to set a proper query handler */
 	STIX_ASSERT (stix, mdp->mod.query != STIX_NULL);
@@ -508,7 +508,7 @@ void stix_closemod (stix_t* stix, stix_mod_data_t* mdp)
 	if (mdp->handle) 
 	{
 		stix->vmprim.dl_close (stix, mdp->handle);
-		STIX_DEBUG2 (stix, "Closed a module [%S] - %p\n", mdp->mod.name, mdp->handle);
+		STIX_DEBUG2 (stix, "Closed a module [%js] - %p\n", mdp->mod.name, mdp->handle);
 		mdp->handle = STIX_NULL;
 	}
 
@@ -548,7 +548,7 @@ int stix_importmod (stix_t* stix, stix_oop_t _class, const stix_ooch_t* name, st
 
 	if (!mdp->mod.import)
 	{
-		STIX_DEBUG1 (stix, "Cannot import module [%S] - importing not supported by the module\n", mdp->mod.name);
+		STIX_DEBUG1 (stix, "Cannot import module [%js] - importing not supported by the module\n", mdp->mod.name);
 		stix->errnum = STIX_ENOIMPL;
 		r = -1;
 		goto done;
@@ -556,7 +556,7 @@ int stix_importmod (stix_t* stix, stix_oop_t _class, const stix_ooch_t* name, st
 
 	if (mdp->mod.import (stix, &mdp->mod, _class) <= -1)
 	{
-		STIX_DEBUG1 (stix, "Cannot import module [%S] - module's import() returned failure\n", mdp->mod.name);
+		STIX_DEBUG1 (stix, "Cannot import module [%js] - module's import() returned failure\n", mdp->mod.name);
 		r = -1;
 		goto done;
 	}
@@ -593,7 +593,7 @@ stix_pfimpl_t stix_querymod (stix_t* stix, const stix_ooch_t* pfid, stix_oow_t p
 		 * guarantee that an underscore is included in an primitive identifer.
 		 * what if the compiler is broken? imagine a buggy compiler rewritten
 		 * in stix itself? */
-		STIX_DEBUG2 (stix, "Internal error - no period in a primitive function identifier [%.*S] - buggy compiler?\n", pfidlen, pfid);
+		STIX_DEBUG2 (stix, "Internal error - no period in a primitive function identifier [%.*js] - buggy compiler?\n", pfidlen, pfid);
 		stix->errnum = STIX_EINTERN;
 		return STIX_NULL;
 	}
@@ -615,12 +615,12 @@ stix_pfimpl_t stix_querymod (stix_t* stix, const stix_ooch_t* pfid, stix_oow_t p
 	if ((handler = mdp->mod.query (stix, &mdp->mod, sep + 1)) == STIX_NULL) 
 	{
 		/* the primitive function is not found. keep the module open */
-		STIX_DEBUG2 (stix, "Cannot find a primitive function [%S] in a module [%S]\n", sep + 1, mdp->mod.name);
+		STIX_DEBUG2 (stix, "Cannot find a primitive function [%js] in a module [%js]\n", sep + 1, mdp->mod.name);
 		stix->errnum = STIX_ENOENT; /* TODO: proper error code and handling */
 		return STIX_NULL;
 	}
 
-	STIX_DEBUG3 (stix, "Found a primitive function [%S] in a module [%S] - %p\n", sep + 1, mdp->mod.name, handler);
+	STIX_DEBUG3 (stix, "Found a primitive function [%js] in a module [%js] - %p\n", sep + 1, mdp->mod.name, handler);
 	return handler;
 }
 
@@ -661,7 +661,7 @@ int stix_genpfmethod (stix_t* stix, stix_mod_t* mod, stix_oop_t _class, stix_met
 	if (arg_count > 0 && mthname[i - 1] != ':') 
 	{
 	oops_inval:
-		STIX_DEBUG2 (stix, "Cannot generate primitive function method [%S] in [%O] - invalid name\n", mthname, cls->name);
+		STIX_DEBUG2 (stix, "Cannot generate primitive function method [%js] in [%O] - invalid name\n", mthname, cls->name);
 		stix->errnum = STIX_EINVAL;
 		goto oops;
 	}
@@ -670,7 +670,7 @@ int stix_genpfmethod (stix_t* stix, stix_mod_t* mod, stix_oop_t _class, stix_met
 	cs.len = i;
 	if (stix_lookupdic (stix, cls->mthdic[type], &cs) != STIX_NULL)
 	{
-		STIX_DEBUG2 (stix, "Cannot generate primitive function method [%S] in [%O] - duplicate\n", mthname, cls->name);
+		STIX_DEBUG2 (stix, "Cannot generate primitive function method [%js] in [%O] - duplicate\n", mthname, cls->name);
 		stix->errnum = STIX_EEXIST;
 		goto oops;
 	}
@@ -685,14 +685,14 @@ int stix_genpfmethod (stix_t* stix, stix_mod_t* mod, stix_oop_t _class, stix_met
 	    stix_concatoocstrtosbuf(stix, dot, 0) <= -1 ||
 	    stix_concatoocstrtosbuf(stix, pfname, 0) <=  -1) 
 	{
-		STIX_DEBUG2 (stix, "Cannot generate primitive function method [%S] in [%O] - VM memory shortage\n", mthname, cls->name);
+		STIX_DEBUG2 (stix, "Cannot generate primitive function method [%js] in [%O] - VM memory shortage\n", mthname, cls->name);
 		return -1;
 	}
 
 	pfidsym = (stix_oop_char_t)stix_makesymbol (stix, stix->sbuf[0].ptr, stix->sbuf[0].len);
 	if (!pfidsym) 
 	{
-		STIX_DEBUG2 (stix, "Cannot generate primitive function method [%S] in [%O] - symbol instantiation failure\n", mthname, cls->name);
+		STIX_DEBUG2 (stix, "Cannot generate primitive function method [%js] in [%O] - symbol instantiation failure\n", mthname, cls->name);
 		goto oops;
 	}
 	stix_pushtmp (stix, (stix_oop_t*)&pfidsym); tmp_count++;
@@ -704,7 +704,7 @@ int stix_genpfmethod (stix_t* stix, stix_mod_t* mod, stix_oop_t _class, stix_met
 #endif
 	if (!mth)
 	{
-		STIX_DEBUG2 (stix, "Cannot generate primitive function method [%S] in [%O] - method instantiation failure\n", mthname, cls->name);
+		STIX_DEBUG2 (stix, "Cannot generate primitive function method [%js] in [%O] - method instantiation failure\n", mthname, cls->name);
 		goto oops;
 	}
 
@@ -725,11 +725,11 @@ int stix_genpfmethod (stix_t* stix, stix_mod_t* mod, stix_oop_t _class, stix_met
 
 	if (!stix_putatdic (stix, cls->mthdic[type], (stix_oop_t)mnsym, (stix_oop_t)mth)) 
 	{
-		STIX_DEBUG2 (stix, "Cannot generate primitive function method [%S] in [%O] - failed to add to method dictionary\n", mthname, cls->name);
+		STIX_DEBUG2 (stix, "Cannot generate primitive function method [%js] in [%O] - failed to add to method dictionary\n", mthname, cls->name);
 		goto oops;
 	}
 
-	STIX_DEBUG2 (stix, "Generated primitive function method [%S] in [%O]\n", mthname, cls->name);
+	STIX_DEBUG2 (stix, "Generated primitive function method [%js] in [%O]\n", mthname, cls->name);
 
 	stix_poptmps (stix, tmp_count); tmp_count = 0;
 	return 0;
diff --git a/stix/lib/stix.h b/stix/lib/stix.h
index af7d382..63236d8 100644
--- a/stix/lib/stix.h
+++ b/stix/lib/stix.h
@@ -1341,10 +1341,10 @@ STIX_EXPORT int stix_genpfmethod (
 #	define stix_convootobcstr(stix,oocs,oocslen,bcs,bcslen) stix_convutobcstr(stix,oocs,oocslen,bcs,bcslen)
 #	define stix_convbtooocstr(stix,bcs,bcslen,oocs,oocslen) stix_convbtoucstr(stix,bcs,bcslen,oocs,oocslen)
 #else
-#	define stix_convootobchars(stix,oocs,oocslen,bcs,bcslen) stix_convutobchars(stix,oocs,oocslen,bcs,bcslen)
-#	define stix_convbtooochars(stix,bcs,bcslen,oocs,oocslen) stix_convbtouchars(stix,bcs,bcslen,oocs,oocslen)
-#	define stix_convootobcstr(stix,oocs,oocslen,bcs,bcslen) stix_convutobcstr(stix,oocs,oocslen,bcs,bcslen)
-#	define stix_convbtooocstr(stix,bcs,bcslen,oocs,oocslen) stix_convbtoucstr(stix,bcs,bcslen,oocs,oocslen)
+#	define stix_convootouchars(stix,oocs,oocslen,bcs,bcslen) stix_convbtouchars(stix,oocs,oocslen,bcs,bcslen)
+#	define stix_convutooochars(stix,bcs,bcslen,oocs,oocslen) stix_convutobchars(stix,bcs,bcslen,oocs,oocslen)
+#	define stix_convootoucstr(stix,oocs,oocslen,bcs,bcslen) stix_convbtoucstr(stix,oocs,oocslen,bcs,bcslen)
+#	define stix_convutooocstr(stix,bcs,bcslen,oocs,oocslen) stix_convutobcstr(stix,bcs,bcslen,oocs,oocslen)
 #endif
 
 STIX_EXPORT int stix_convbtouchars (
@@ -1400,13 +1400,19 @@ STIX_EXPORT stix_ooi_t stix_logbfmt (
 	...
 );
 
-STIX_EXPORT stix_ooi_t stix_logoofmt (
+STIX_EXPORT stix_ooi_t stix_logufmt (
 	stix_t*            stix,
 	stix_oow_t         mask,
-	const stix_ooch_t* fmt,
+	const stix_uch_t*  fmt,
 	...
 );
  
+#if defined(STIX_OOCH_IS_UCH)
+#	define stix_logoofmt stix_logufmt
+#else
+#	define stix_logoofmt stix_logbfmt
+#endif
+
 /* =========================================================================
  * MISCELLANEOUS HELPER FUNCTIONS
  * ========================================================================= */