diff --git a/moo/bin/main.c b/moo/bin/main.c
index 5759c9b..87a2799 100644
--- a/moo/bin/main.c
+++ b/moo/bin/main.c
@@ -241,8 +241,8 @@ int main (int argc, char* argv[])
 	}
 
 	/* TODO: don't initialize debug information if debug info is not requested.
-	 *       call moo_loaddbginfo() if loading a compiled image... */
-	if (moo_initdbginfo(moo, 102400) <= -1) /* TODO: set initial debug information size from a configurable value */
+	 *       call moo_loaddbgi() if loading a compiled image... */
+	if (moo_initdbgi(moo, 102400) <= -1) /* TODO: set initial debug information size from a configurable value */
 	{
 		moo_logbfmt (moo, MOO_LOG_STDERR, "ERROR: cannot initialize debug information - [%d] %js\n", moo_geterrnum(moo), moo_geterrstr(moo));
 		moo_close (moo);
diff --git a/moo/kernel/Except.moo b/moo/kernel/Except.moo
index 063a0b8..c0a4c2d 100644
--- a/moo/kernel/Except.moo
+++ b/moo/kernel/Except.moo
@@ -39,7 +39,7 @@ TODO: can i convert 'thisProcess primError' to a relevant exception?
 	{
 		^(self class name) & " - " & self.messageText.
 	}
-     
+
 	method signal
 	{
 		| exctx exblk retval actpos ctx |
@@ -68,13 +68,19 @@ TODO: can i convert 'thisProcess primError' to a relevant exception?
 		// -----------------------------------------------------------------
 		//thisContext unwindTo: nil return: nil.
 		//thisContext unwindTo: (Processor activeProcess initialContext) return: nil.
-		
-// TOOD: IMPROVE THIS EXPERIMENTAL BACKTRACE...
+
+// TOOD: IMPROVE THIS EXPERIMENTAL BACKTRACE... MOVE THIS TO  System>>backtrace and skip the first method context for backtrace itself.
 System logNl: "== BACKTRACE ==".
 ctx := thisContext.
 while (ctx notNil)
 {
-	if (ctx class == MethodContext) { System logNl: (" " & ctx method owner name & ">>" & ctx method name & " (" & ctx method sourceFile & " " & ctx method sourceLine asString & ")"). }.
+	if (ctx class == MethodContext) 
+	{
+		System logNl: (" " & ctx method owner name & ">>" & ctx method name &
+		               " (" & ctx method sourceFile & " " & ctx method sourceLine asString & ")"). 
+// TODO: get location of the current pc and include it... (ctx method sourceLine: ctx pc) asString dump.
+
+	}.
 	// TODO: include blockcontext???
 	ctx := ctx sender.
 }.
diff --git a/moo/kernel/test-003.moo b/moo/kernel/test-003.moo
index b41058b..affb216 100644
--- a/moo/kernel/test-003.moo
+++ b/moo/kernel/test-003.moo
@@ -92,6 +92,7 @@ class MyObject(Object)
 			tb := tc at: idx.
 			System log(System.Log.INFO, idx asString, (if (tb value) { " PASS" } else { " FAIL" }), "\n").
 		].
+Exception signal: 'xxx'.
 
 		// TODO: 
 		String format("%s", " 나	는\\\"") dump.
diff --git a/moo/lib/comp.c b/moo/lib/comp.c
index 3d2f405..852e446 100644
--- a/moo/lib/comp.c
+++ b/moo/lib/comp.c
@@ -246,6 +246,8 @@ enum voca_id_t
 };
 typedef enum voca_id_t voca_id_t;
 
+static moo_ooch_t _nul = '\0';
+
 static int compile_pooldic_definition (moo_t* moo);
 static int compile_interface_definition (moo_t* moo);
 static int compile_class_definition (moo_t* moo, int class_type);
@@ -452,22 +454,23 @@ static int copy_string_to (moo_t* moo, const moo_oocs_t* src, moo_oocs_t* dst, m
 		len = src->len;
 	}
 
-	if (len > *dst_capa)
+	if (len >= *dst_capa)
 	{
 		moo_ooch_t* tmp;
 		moo_oow_t capa;
 
-		capa = MOO_ALIGN(len, CLASS_BUFFER_ALIGN);
+		capa = MOO_ALIGN(len + 1, CLASS_BUFFER_ALIGN);
 
 		tmp = (moo_ooch_t*)moo_reallocmem(moo, dst->ptr, MOO_SIZEOF(*tmp) * capa);
 		if (!tmp)  return -1;
 
 		dst->ptr = tmp;
-		*dst_capa = capa;
+		*dst_capa = capa - 1;
 	}
 
 	if (append && delim_char != '\0') dst->ptr[pos++] = delim_char;
 	moo_copy_oochars (&dst->ptr[pos], src->ptr, src->len);
+	dst->ptr[len] = '\0';
 	dst->len = len;
 	return 0;
 }
@@ -556,7 +559,7 @@ static int add_oop_to_oopbuf (moo_t* moo, moo_oopbuf_t* oopbuf, moo_oop_t item)
 		moo_oop_t* tmp;
 		moo_oow_t new_capa;
 
-		new_capa = MOO_ALIGN (oopbuf->count + 1, ARLIT_BUFFER_ALIGN);
+		new_capa = MOO_ALIGN(oopbuf->count + 1, ARLIT_BUFFER_ALIGN);
 		tmp = (moo_oop_t*)moo_reallocmem(moo, oopbuf->ptr, new_capa * MOO_SIZEOF(*tmp));
 		if (!tmp) return -1;
 
@@ -2363,12 +2366,12 @@ static void clear_io_names (moo_t* moo)
 	}
 }
 
-static const moo_ooch_t* add_io_name (moo_t* moo, const moo_oocs_t* name)
+const moo_ooch_t* moo_addcioname (moo_t* moo, const moo_oocs_t* name)
 {
 	moo_iolink_t* link;
 	moo_ooch_t* ptr;
 
-	link = (moo_iolink_t*) moo_callocmem (moo, MOO_SIZEOF(*link) + MOO_SIZEOF(moo_ooch_t) * (name->len + 1));
+	link = (moo_iolink_t*)moo_callocmem(moo, MOO_SIZEOF(*link) + MOO_SIZEOF(moo_ooch_t) * (name->len + 1));
 	if (!link) return MOO_NULL;
 
 	ptr = (moo_ooch_t*)(link + 1);
@@ -2387,10 +2390,10 @@ static int begin_include (moo_t* moo)
 	moo_ioarg_t* arg;
 	const moo_ooch_t* io_name;
 
-	io_name = add_io_name (moo, TOKEN_NAME(moo));
+	io_name = moo_addcioname(moo, TOKEN_NAME(moo));
 	if (!io_name) return -1;
 
-	arg = (moo_ioarg_t*) moo_callocmem (moo, MOO_SIZEOF(*arg));
+	arg = (moo_ioarg_t*)moo_callocmem(moo, MOO_SIZEOF(*arg));
 	if (!arg) goto oops;
 
 	arg->name = io_name;
@@ -2399,7 +2402,7 @@ static int begin_include (moo_t* moo)
 	/*arg->nl = '\0';*/
 	arg->includer = moo->c->curinp;
 
-	if (moo->c->impl (moo, MOO_IO_OPEN, arg) <= -1) 
+	if (moo->c->impl(moo, MOO_IO_OPEN, arg) <= -1) 
 	{
 		moo_setsynerr (moo, MOO_SYNERR_INCLUDE, TOKEN_LOC(moo), TOKEN_NAME(moo));
 		goto oops;
@@ -4158,7 +4161,6 @@ static int compile_method_name (moo_t* moo, moo_method_data_t* mth)
 	 * unary-selector := identifier
 	 */
 	int n;
-	static moo_ooch_t _nul = '\0';
 	moo_oocs_t dummy;
 
 	MOO_ASSERT (moo, mth->tmpr_count == 0);
@@ -4187,12 +4189,6 @@ static int compile_method_name (moo_t* moo, moo_method_data_t* mth)
 
 	if (n <= -1) return -1;
 
-	/* null terminate it for convenience */
-	dummy.ptr = &_nul;
-	dummy.len = 1;
-	if (add_method_name_fragment(moo, mth, &dummy) <= -1) return -1;
-	mth->name.len--; /* restore the method name length back */
-
 	if (method_exists(moo, &mth->name)) 
 	{
 		moo_setsynerr (moo, MOO_SYNERR_MTHNAMEDUPL, &mth->name_loc, &mth->name);
@@ -7006,36 +7002,28 @@ static int add_compiled_method (moo_t* moo)
 		mth->source_line = MOO_SMOOI_TO_OOP(0);
 	}
 
-	if (moo->dbginfo)
+	if (moo->dbgi)
 	{
 		moo_oow_t file_offset;
-		moo_oow_t class_offset;
 		moo_oow_t method_offset;
+		const moo_ooch_t* file_name;
 
-		if (cc->mth.code_start_loc.file)
+		file_name = cc->mth.code_start_loc.file;
+		if (!file_name) file_name = &_nul;
+
+		if (moo_addfiletodbgi(moo, file_name, &file_offset) <= -1) 
 		{
-			if (moo_addfiletodbginfo(moo, cc->mth.code_start_loc.file, &file_offset) <= -1) 
-			{
-				/* TODO: warning */
-				file_offset = 0;
-			}
-			else if (file_offset > MOO_SMOOI_MAX) 
-			{
-				/* TODO: warnign */
-				file_offset = 0;
-			}
+			/* TODO: warning */
+			file_offset = 0;
 		}
-		else
+		else if (file_offset > MOO_SMOOI_MAX) 
 		{
-			/* main stream */
+			/* TODO: warning */
 			file_offset = 0;
 		}
 		mth->source_file = MOO_SMOOI_TO_OOP(file_offset);
 
-/* TODO: call moo_addclasstodbginfo() */
-		class_offset = 0;
-
-		if (moo_addmethodtodbginfo(moo, file_offset, class_offset, cc->mth.name.ptr, cc->mth.code.locptr, cc->mth.code.len, &method_offset) <= -1)
+		if (moo_addmethodtodbgi(moo, file_offset, cc->dbgi_class_offset, cc->mth.name.ptr, cc->mth.code.locptr, cc->mth.code.len, &method_offset) <= -1)
 		{
 			/* TODO: warning. no debug information about this method will be available */
 		}
@@ -8517,6 +8505,33 @@ static int __compile_class_definition (moo_t* moo, int class_type)
 
 	GET_TOKEN (moo);
 
+	if (moo->dbgi)
+	{
+		moo_oow_t file_offset;
+		moo_oow_t class_offset;
+		const moo_ooch_t* file_name;
+
+		file_name = cc->fqn_loc.file;
+		if (!file_name) file_name = &_nul;
+
+		if (moo_addfiletodbgi(moo, file_name, &file_offset) <= -1) 
+		{
+			/* TODO: warning */
+			file_offset = 0;
+		}
+		else if (file_offset > MOO_SMOOI_MAX) 
+		{
+			/* TODO: warning */
+			file_offset = 0;
+		}
+
+		if (moo_addclasstodbgi(moo, cc->fqn.ptr, file_offset, cc->fqn_loc.line, &cc->dbgi_class_offset) <= -1)
+		{
+			/* TODO: warning. no debug information about this method will be available */
+		}
+/* TODO: store source file offset and class offset in the class object only for NORMAL. make_defined_class is a good candidate to do this in. */
+	}
+
 	if (class_type == CLASS_TYPE_EXTEND)
 	{
 		moo_oop_char_t pds;
@@ -9674,6 +9689,8 @@ static void fini_compiler (moo_t* moo)
 
 		while (moo->c->cunit) pop_cunit (moo);
 
+		if (moo->c->iid) moo_freemem (moo, moo->c->iid);
+
 		moo_freemem (moo, moo->c);
 		moo->c = MOO_NULL;
 	}
@@ -9730,7 +9747,7 @@ static MOO_INLINE int _compile (moo_t* moo, moo_ioimpl_t io)
 	moo->c->arg.colm = 1;
 
 	/* open the top-level stream */
-	n = moo->c->impl (moo, MOO_IO_OPEN, &moo->c->arg);
+	n = moo->c->impl(moo, MOO_IO_OPEN, &moo->c->arg);
 	if (n <= -1) return -1;
 
 	/* the stream is open. set it as the current input stream */
@@ -9770,11 +9787,11 @@ int moo_compile (moo_t* moo, moo_ioimpl_t io)
 {
 	int n;
 	int log_default_type_mask;
-	
+
 	log_default_type_mask = moo->log.default_type_mask;
 	moo->log.default_type_mask |= MOO_LOG_COMPILER;
-	n = _compile (moo, io);
+	n = _compile(moo, io);
 	moo->log.default_type_mask = log_default_type_mask;
-	
+
 	return n;
 }
diff --git a/moo/lib/debug.c b/moo/lib/debug.c
index 93ff282..1dfa635 100644
--- a/moo/lib/debug.c
+++ b/moo/lib/debug.c
@@ -68,18 +68,18 @@ void moo_dumpdic (moo_t* moo, moo_oop_dic_t dic, const moo_bch_t* title)
 }
 
 
-/* TODO: moo_loaddbginfofromimage() -> load debug information from compiled image?
-moo_storedbginfotoimage()? -> store debug information to compiled image?
-moo_compactdbginfo()? -> compact debug information by scaning dbginfo data. find class and method. if not found, drop the portion.
+/* TODO: moo_loaddbgifromimage() -> load debug information from compiled image?
+moo_storedbgitoimage()? -> store debug information to compiled image?
+moo_compactdbgi()? -> compact debug information by scaning dbgi data. find class and method. if not found, drop the portion.
 */
 
-int moo_initdbginfo (moo_t* moo, moo_oow_t capa)
+int moo_initdbgi (moo_t* moo, moo_oow_t capa)
 {
-	moo_dbginfo_t* tmp;
+	moo_dbgi_t* tmp;
 
 	if (capa < MOO_SIZEOF(*tmp)) capa = MOO_SIZEOF(*tmp);
 
-	tmp = (moo_dbginfo_t*)moo_callocmem(moo, capa);
+	tmp = (moo_dbgi_t*)moo_callocmem(moo, capa);
 	if (!tmp) return -1;
 
 	tmp->_capa = capa;
@@ -87,57 +87,57 @@ int moo_initdbginfo (moo_t* moo, moo_oow_t capa)
 	tmp->_last_class = 0;
 	tmp->_last_file = 0;
 
-	moo->dbginfo = tmp;
+	moo->dbgi = tmp;
 	return 0;
 }
 
-void moo_finidbginfo (moo_t* moo)
+void moo_finidbgi (moo_t* moo)
 {
-	if (moo->dbginfo)
+	if (moo->dbgi)
 	{
-		moo_freemem (moo, moo->dbginfo);
-		moo->dbginfo = MOO_NULL;
+		moo_freemem (moo, moo->dbgi);
+		moo->dbgi = MOO_NULL;
 	}
 }
 
-static MOO_INLINE moo_uint8_t* secure_dbginfo_space (moo_t* moo, moo_oow_t req_bytes)
+static MOO_INLINE moo_uint8_t* secure_dbgi_space (moo_t* moo, moo_oow_t req_bytes)
 {
-	if (moo->dbginfo->_capa - moo->dbginfo->_len < req_bytes)
+	if (moo->dbgi->_capa - moo->dbgi->_len < req_bytes)
 	{
-		moo_dbginfo_t* tmp;
+		moo_dbgi_t* tmp;
 		moo_oow_t newcapa;
 
-		newcapa = moo->dbginfo->_len + req_bytes;
+		newcapa = moo->dbgi->_len + req_bytes;
 		newcapa = MOO_ALIGN_POW2(newcapa, 65536); /* TODO: make the align value configurable */
-		tmp = moo_reallocmem(moo, moo->dbginfo, newcapa);
+		tmp = moo_reallocmem(moo, moo->dbgi, newcapa);
 		if (!tmp) return MOO_NULL;
 
-		moo->dbginfo = tmp;
-		moo->dbginfo->_capa = newcapa;
+		moo->dbgi = tmp;
+		moo->dbgi->_capa = newcapa;
 	}
 
-	return &((moo_uint8_t*)moo->dbginfo)[moo->dbginfo->_len];
+	return &((moo_uint8_t*)moo->dbgi)[moo->dbgi->_len];
 }
 
-int moo_addfiletodbginfo (moo_t* moo, const moo_ooch_t* file_name, moo_oow_t* start_offset)
+int moo_addfiletodbgi (moo_t* moo, const moo_ooch_t* file_name, moo_oow_t* start_offset)
 {
 	moo_oow_t name_len, name_bytes, name_bytes_aligned, req_bytes;
-	moo_dbginfo_file_t* di;
+	moo_dbgi_file_t* di;
 
-	if (!moo->dbginfo) 
+	if (!moo->dbgi) 
 	{
 		if (start_offset) *start_offset = MOO_NULL;
 		return 0; /* debug information is disabled*/
 	}
 
-	if (moo->dbginfo->_last_file > 0)
+	if (moo->dbgi->_last_file > 0)
 	{
 		/* TODO: avoid linear search. need indexing for speed up */
-		moo_oow_t offset = moo->dbginfo->_last_file;
+		moo_oow_t offset = moo->dbgi->_last_file;
 		do
 		{
-			di = &((moo_uint8_t*)moo->dbginfo)[offset];
-			if (moo_comp_oocstr(di + 1, file_name) == 0) 
+			di = (moo_dbgi_file_t*)&((moo_uint8_t*)moo->dbgi)[offset];
+			if (moo_comp_oocstr((moo_ooch_t*)(di + 1), file_name) == 0) 
 			{
 				if (start_offset) *start_offset = offset;
 				return 0;
@@ -150,38 +150,38 @@ int moo_addfiletodbginfo (moo_t* moo, const moo_ooch_t* file_name, moo_oow_t* st
 	name_len = moo_count_oocstr(file_name);
 	name_bytes = (name_len + 1) * MOO_SIZEOF(*file_name);
 	name_bytes_aligned = MOO_ALIGN_POW2(name_bytes, MOO_SIZEOF_OOW_T);
-	req_bytes = MOO_SIZEOF(moo_dbginfo_file_t) + name_bytes_aligned;
+	req_bytes = MOO_SIZEOF(moo_dbgi_file_t) + name_bytes_aligned;
 
-	di = (moo_dbginfo_file_t*)secure_dbginfo_space(moo, req_bytes);
+	di = (moo_dbgi_file_t*)secure_dbgi_space(moo, req_bytes);
 	if (!di) return -1;
 
 	di->_type = MOO_DBGINFO_MAKE_TYPE(MOO_DBGINFO_TYPE_CODE_FILE, 0);
 	di->_len = req_bytes;
-	di->_next = moo->dbginfo->_last_file;
-	moo_copy_oocstr (di + 1, name_len + 1, file_name);
+	di->_next = moo->dbgi->_last_file;
+	moo_copy_oocstr ((moo_ooch_t*)(di + 1), name_len + 1, file_name);
 
-	moo->dbginfo->_last_file = moo->dbginfo->_len;
-	moo->dbginfo->_len += req_bytes;
+	moo->dbgi->_last_file = moo->dbgi->_len;
+	moo->dbgi->_len += req_bytes;
 
-	if (start_offset) *start_offset = moo->dbginfo->_last_file;
+	if (start_offset) *start_offset = moo->dbgi->_last_file;
 	return 0;
 }
 
-int moo_addclasstodbginfo (moo_t* moo, const moo_ooch_t* class_name, moo_oow_t file_offset, moo_oow_t file_line, moo_oow_t* start_offset)
+int moo_addclasstodbgi (moo_t* moo, const moo_ooch_t* class_name, moo_oow_t file_offset, moo_oow_t file_line, moo_oow_t* start_offset)
 {
 	moo_oow_t name_len, name_bytes, name_bytes_aligned, req_bytes;
-	moo_dbginfo_class_t* di;
+	moo_dbgi_class_t* di;
 
-	if (!moo->dbginfo) return 0; /* debug information is disabled*/
+	if (!moo->dbgi) return 0; /* debug information is disabled*/
 
-	if (moo->dbginfo->_last_class > 0)
+	if (moo->dbgi->_last_class > 0)
 	{
 		/* TODO: avoid linear search. need indexing for speed up */
-		moo_oow_t offset = moo->dbginfo->_last_class;
+		moo_oow_t offset = moo->dbgi->_last_class;
 		do
 		{
-			di = &((moo_uint8_t*)moo->dbginfo)[offset];
-			if (moo_comp_oocstr(di + 1, class_name) == 0 && di->_file == file_offset && di->_line == file_line) 
+			di = (moo_dbgi_class_t*)&((moo_uint8_t*)moo->dbgi)[offset];
+			if (moo_comp_oocstr((moo_ooch_t*)(di + 1), class_name) == 0 && di->_file == file_offset && di->_line == file_line) 
 			{
 				if (start_offset) *start_offset = offset;
 				return 0;
@@ -194,55 +194,55 @@ int moo_addclasstodbginfo (moo_t* moo, const moo_ooch_t* class_name, moo_oow_t f
 	name_len = moo_count_oocstr(class_name);
 	name_bytes = (name_len + 1) * MOO_SIZEOF(*class_name);
 	name_bytes_aligned = MOO_ALIGN_POW2(name_bytes, MOO_SIZEOF_OOW_T);
-	req_bytes = MOO_SIZEOF(moo_dbginfo_class_t) + name_bytes_aligned;
+	req_bytes = MOO_SIZEOF(moo_dbgi_class_t) + name_bytes_aligned;
 
-	di = (moo_dbginfo_class_t*)secure_dbginfo_space(moo, req_bytes);
+	di = (moo_dbgi_class_t*)secure_dbgi_space(moo, req_bytes);
 	if (!di) return -1;
 
 	di->_type = MOO_DBGINFO_MAKE_TYPE(MOO_DBGINFO_TYPE_CODE_CLASS, 0);
 	di->_len = req_bytes;
-	di->_next = moo->dbginfo->_last_class;
+	di->_next = moo->dbgi->_last_class;
 	di->_file = file_offset;
 	di->_line = file_line;
-	moo_copy_oocstr (di + 1, name_len + 1, class_name);
+	moo_copy_oocstr ((moo_ooch_t*)(di + 1), name_len + 1, class_name);
 
-	moo->dbginfo->_last_class = moo->dbginfo->_len;
-	moo->dbginfo->_len += req_bytes;
+	moo->dbgi->_last_class = moo->dbgi->_len;
+	moo->dbgi->_len += req_bytes;
 
-	if (start_offset) *start_offset = moo->dbginfo->_last_class;
+	if (start_offset) *start_offset = moo->dbgi->_last_class;
 	return 0;
 }
 
-int moo_addmethodtodbginfo (moo_t* moo, moo_oow_t file_offset, moo_oow_t class_offset, const moo_ooch_t* method_name, const moo_oow_t* code_loc_ptr, moo_oow_t code_loc_len, moo_oow_t* start_offset)
+int moo_addmethodtodbgi (moo_t* moo, moo_oow_t file_offset, moo_oow_t class_offset, const moo_ooch_t* method_name, const moo_oow_t* code_loc_ptr, moo_oow_t code_loc_len, moo_oow_t* start_offset)
 {
 	moo_oow_t name_len, name_bytes, name_bytes_aligned, code_loc_bytes, code_loc_bytes_aligned, req_bytes;
-	moo_dbginfo_method_t* di;
+	moo_dbgi_method_t* di;
 
-	if (!moo->dbginfo) return 0; /* debug information is disabled*/
+	if (!moo->dbgi) return 0; /* debug information is disabled*/
 
 	name_len = moo_count_oocstr(method_name);
 	name_bytes = (name_len + 1) * MOO_SIZEOF(*method_name);
 	name_bytes_aligned = MOO_ALIGN_POW2(name_bytes, MOO_SIZEOF_OOW_T);
 	code_loc_bytes = code_loc_len * MOO_SIZEOF(*code_loc_ptr);
 	code_loc_bytes_aligned = MOO_ALIGN_POW2(code_loc_bytes, MOO_SIZEOF_OOW_T);
-	req_bytes = MOO_SIZEOF(moo_dbginfo_method_t) + name_bytes_aligned + code_loc_bytes_aligned;
+	req_bytes = MOO_SIZEOF(moo_dbgi_method_t) + name_bytes_aligned + code_loc_bytes_aligned;
 
-	di = (moo_dbginfo_method_t*)secure_dbginfo_space(moo, req_bytes);
+	di = (moo_dbgi_method_t*)secure_dbgi_space(moo, req_bytes);
 	if (!di) return -1;
 
 	di->_type = MOO_DBGINFO_MAKE_TYPE(MOO_DBGINFO_TYPE_CODE_METHOD, 0);
 	di->_len = req_bytes;
-	di->_next = moo->dbginfo->_last_method;
+	di->_next = moo->dbgi->_last_method;
 	di->_file = file_offset;
 	di->_class = class_offset;
 	di->code_loc_len = code_loc_len;
 
-	moo_copy_oocstr (di + 1, name_len + 1, method_name);
+	moo_copy_oocstr ((moo_ooch_t*)(di + 1), name_len + 1, method_name);
 	MOO_MEMCPY ((moo_uint8_t*)(di + 1) + name_bytes_aligned, code_loc_ptr, code_loc_bytes);
 
-	moo->dbginfo->_last_method = moo->dbginfo->_len;
-	moo->dbginfo->_len += req_bytes;
+	moo->dbgi->_last_method = moo->dbgi->_len;
+	moo->dbgi->_len += req_bytes;
 
-	if (start_offset) *start_offset = moo->dbginfo->_last_method;
+	if (start_offset) *start_offset = moo->dbgi->_last_method;
 	return 0;
 }
diff --git a/moo/lib/exec.c b/moo/lib/exec.c
index 8ce52f5..63d7d2e 100644
--- a/moo/lib/exec.c
+++ b/moo/lib/exec.c
@@ -2179,7 +2179,7 @@ static moo_pfrc_t pf_context_find_exception_handler (moo_t* moo, moo_mod_t* mod,
 	rcv = (moo_oop_context_t)MOO_STACK_GETRCV(moo, nargs);
 	MOO_PF_CHECK_RCV (moo, MOO_CLASSOF(moo,rcv) == moo->_method_context);
 
-	except_class = MOO_STACK_GETARG(moo, nargs, 0);
+	except_class = (moo_oop_class_t)MOO_STACK_GETARG(moo, nargs, 0);
 	MOO_PF_CHECK_ARGS (moo, nargs, MOO_CLASSOF(moo,rcv) == moo->_class);
 
 	preamble = MOO_OOP_TO_SMOOI(((moo_oop_method_t)rcv->method_or_nargs)->preamble);
@@ -2218,33 +2218,31 @@ static moo_pfrc_t pf_context_find_exception_handler (moo_t* moo, moo_mod_t* mod,
 /* ------------------------------------------------------------------ */
 static moo_pfrc_t pf_method_get_source_file (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
 {
-	moo_oop_method_t rcv;
-	moo_oop_t tmp;
+	moo_oop_t retv = moo->_nil;
 
-	if (moo->dbginfo)
+	if (moo->dbgi)
 	{
-/* TODO: return sothing else lighter-weight than a string? */
-		rcv = (moo_oop_method_t*)MOO_STACK_GETRCV(moo, nargs);
-		if (rcv->source_file == MOO_SMOOI_TO_OOP(0))
-		{
-/* TOOD: use the actual name as given by the caller ? */
-			tmp = moo_makestringwithbchars(moo, "<MAIN>", 6);
-		}
-		else
-		{
-			moo_dbginfo_file_t* di;
-			di = (moo_dbginfo_file_t*)&((moo_uint8_t*)moo->dbginfo)[MOO_OOP_TO_SMOOI(rcv->source_file)];
-			tmp = moo_makestring(moo, di + 1, moo_count_oocstr(di + 1));
-		}
-		if (!tmp) return MOO_PF_FAILURE;
+		moo_oop_method_t rcv;
 
-		MOO_STACK_SETRET (moo, nargs, tmp);
-	}
-	else
-	{
-		MOO_STACK_SETRET (moo, nargs, moo->_nil);
+/* TODO: return something else lighter-weight than a string? */
+		rcv = (moo_oop_method_t)MOO_STACK_GETRCV(moo, nargs);
+		if (MOO_OOP_IS_SMOOI(rcv->source_file) && MOO_OOP_TO_SMOOI(rcv->source_file) > 0)
+		{
+			moo_dbgi_file_t* di;
+			const moo_ooch_t* file_name;
+
+			di = (moo_dbgi_file_t*)&((moo_uint8_t*)moo->dbgi)[MOO_OOP_TO_SMOOI(rcv->source_file)];
+/* TODO: check if di is the file type... otherwise, it's internal corruption */
+
+			file_name = (const moo_ooch_t*)(di + 1);
+			moo_pushvolat (moo, &retv);
+			retv = moo_makestring(moo, file_name, moo_count_oocstr(file_name));
+			moo_popvolat (moo);
+			if (!retv) return MOO_PF_FAILURE;
+		}
 	}
 
+	MOO_STACK_SETRET (moo, nargs, retv);
 	return MOO_PF_SUCCESS;
 }
 
diff --git a/moo/lib/moo-prv.h b/moo/lib/moo-prv.h
index 43306b1..5f3fbf1 100644
--- a/moo/lib/moo-prv.h
+++ b/moo/lib/moo-prv.h
@@ -595,6 +595,8 @@ struct moo_cunit_class_t
 		moo_oow_t initv_count;  
 	} var[3];
 
+	moo_oow_t dbgi_class_offset;
+
 	moo_pooldic_import_data_t pdimp;
 	moo_method_data_t mth;
 };
@@ -620,6 +622,7 @@ struct moo_compiler_t
 
 	/* input handler */
 	moo_ioimpl_t impl;
+	moo_ooch_t*  iid; /* input id that represents the current main input file */
 
 	/* information about the last meaningful character read.
 	 * this is a copy of curinp->lxc if no ungetting is performed.
@@ -1658,18 +1661,26 @@ moo_pfrc_t moo_pf_utf8_seqlen (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs);
 moo_pfrc_t moo_pf_utf8_to_uc (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs);
 moo_pfrc_t moo_pf_uc_to_utf8 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs);
 
-/* TODO: remove the following debugging functions */
+
 /* ========================================================================= */
 /* debug.c                                                                   */
 /* ========================================================================= */
+/* TODO: remove the following dump functions */
 void moo_dumpsymtab (moo_t* moo);
 void moo_dumpdic (moo_t* moo, moo_oop_dic_t dic, const moo_bch_t* title);
 
-int moo_addfiletodbginfo (moo_t* moo, const moo_ooch_t* file_name, moo_oow_t* start_offset);
-int moo_addclasstodbginfo (moo_t* moo, const moo_ooch_t* class_name, moo_oow_t file_offset, moo_oow_t file_line, moo_oow_t* start_offset);
-int moo_addmethodtodbginfo (moo_t* moo, moo_oow_t file_offset, moo_oow_t class_offset, const moo_ooch_t* method_name, const moo_oow_t* code_loc_ptr, moo_oow_t code_loc_len, moo_oow_t* start_offset);
+int moo_addfiletodbgi (moo_t* moo, const moo_ooch_t* file_name, moo_oow_t* start_offset);
+int moo_addclasstodbgi (moo_t* moo, const moo_ooch_t* class_name, moo_oow_t file_offset, moo_oow_t file_line, moo_oow_t* start_offset);
+int moo_addmethodtodbgi (moo_t* moo, moo_oow_t file_offset, moo_oow_t class_offset, const moo_ooch_t* method_name, const moo_oow_t* code_loc_ptr, moo_oow_t code_loc_len, moo_oow_t* start_offset);
 
 
+/* ========================================================================= */
+/* comp.c                                                                   */
+/* ========================================================================= */
+#if defined(MOO_INCLUDE_COMPILER)
+const moo_ooch_t* moo_addcioname (moo_t* moo, const moo_oocs_t* name);
+#endif
+
 #if defined(__cplusplus)
 }
 #endif
diff --git a/moo/lib/moo-std.h b/moo/lib/moo-std.h
index eb70da8..6ec9d34 100644
--- a/moo/lib/moo-std.h
+++ b/moo/lib/moo-std.h
@@ -108,11 +108,13 @@ MOO_EXPORT void moo_abortstd (
 	moo_t*        moo
 );
 
+#if defined(MOO_INCLUDE_COMPILER)
 MOO_EXPORT int moo_compilestd(
 	moo_t*             moo,
 	const moo_iostd_t* in,
 	moo_oow_t          count
 );
+#endif
 
 MOO_EXPORT void moo_rcvtickstd (
 	moo_t*             moo,
diff --git a/moo/lib/moo.c b/moo/lib/moo.c
index 12bda5a..8228219 100644
--- a/moo/lib/moo.c
+++ b/moo/lib/moo.c
@@ -249,7 +249,7 @@ void moo_fini (moo_t* moo)
 	 * the heap may not exist */
 	if (moo->heap) moo_killheap (moo, moo->heap);
 
-	moo_finidbginfo (moo);
+	moo_finidbgi (moo);
 
 	for (i = 0; i < MOO_COUNTOF(moo->sbuf); i++)
 	{
diff --git a/moo/lib/moo.h b/moo/lib/moo.h
index 4d4b6ec..8df9563 100644
--- a/moo/lib/moo.h
+++ b/moo/lib/moo.h
@@ -586,7 +586,7 @@ struct moo_method_t
 #endif
 
 	moo_oop_t       source_text; /* source text. String if available. nil if not */
-	moo_oop_t       source_file; /* SmallInteger. source file path that contains the definition of this method. offset from moo->dbginfo. 0 for the main stream. */
+	moo_oop_t       source_file; /* SmallInteger. source file path that contains the definition of this method. offset from moo->dbgi. 0 for the main stream. */
 	moo_oop_t       source_line; /* SmallInteger. line of the source file where the method definition begins. valid only if source_file is not nil */
 
 	/* == variable indexed part == */
@@ -944,8 +944,8 @@ struct moo_heap_t
 	moo_space_t  newspace;
 };
 
-typedef struct moo_dbginfo_t moo_dbginfo_t;
-struct moo_dbginfo_t
+typedef struct moo_dbgi_t moo_dbgi_t;
+struct moo_dbgi_t
 {
 	moo_oow_t _capa;
 	moo_oow_t _len;
@@ -955,7 +955,7 @@ struct moo_dbginfo_t
 	/* actual information is recorded here */
 };
 
-enum moo_dbginfo_type_t
+enum moo_dbgi_type_t
 {
 	/* bit 8 to bit 15 */
 	MOO_DBGINFO_TYPE_CODE_FILE    = 0,
@@ -966,12 +966,12 @@ enum moo_dbginfo_type_t
 	/* low 8 bits */
 	MOO_DBGINFO_TYPE_FLAG_INVALID = (1 << 0)
 };
-typedef enum moo_dbginfo_type_t moo_dbginfo_type_t;
+typedef enum moo_dbgi_type_t moo_dbgi_type_t;
 
 #define MOO_DBGINFO_MAKE_TYPE(code,flags) (((code) << 8) | (flags))
 
-typedef struct moo_dbginfo_file_t moo_dbginfo_file_t;
-struct moo_dbginfo_file_t
+typedef struct moo_dbgi_file_t moo_dbgi_file_t;
+struct moo_dbgi_file_t
 {
 	moo_oow_t _type;
 	moo_oow_t _len;
@@ -979,8 +979,8 @@ struct moo_dbginfo_file_t
 	/* ... file path here ... */
 };
 
-typedef struct moo_dbginfo_class_t moo_dbginfo_class_t;
-struct moo_dbginfo_class_t
+typedef struct moo_dbgi_class_t moo_dbgi_class_t;
+struct moo_dbgi_class_t
 {
 	moo_oow_t _type;
 	moo_oow_t _len;
@@ -990,8 +990,8 @@ struct moo_dbginfo_class_t
 	/* ... class name here ... */
 };
 
-typedef struct moo_dbginfo_method_t moo_dbginfo_method_t;
-struct moo_dbginfo_method_t
+typedef struct moo_dbgi_method_t moo_dbgi_method_t;
+struct moo_dbgi_method_t
 {
 	moo_oow_t _type;
 	moo_oow_t _len;
@@ -1482,7 +1482,7 @@ struct moo_t
 	/* ========================= */
 
 	moo_heap_t* heap;
-	moo_dbginfo_t* dbginfo;
+	moo_dbgi_t* dbgi;
 
 	/* =============================================================
 	 * nil, true, false
@@ -1901,7 +1901,7 @@ extern "C" {
 #endif
 
 #if defined(MOO_HAVE_INLINE)
-	static MOO_INLINE void MOO_STORE_OOP (moo_t* moo, moo_oop_t* rcvaddr, moo_oop_t val) { *rcvaddr = val; }
+static MOO_INLINE void MOO_STORE_OOP (moo_t* moo, moo_oop_t* rcvaddr, moo_oop_t val) { *rcvaddr = val; }
 #else
 #	define MOO_STORE_OOP(moo,rcvaddr,val) (*(rcvaddr) = val)
 #endif
@@ -2124,7 +2124,7 @@ MOO_EXPORT void moo_abort (
 
 
 #if defined(MOO_HAVE_INLINE)
-	static MOO_INLINE void moo_switchprocess(moo_t* moo) { moo->switch_proc = 1; }
+static MOO_INLINE void moo_switchprocess(moo_t* moo) { moo->switch_proc = 1; }
 #else
 #	define moo_switchprocess(moo) ((moo)->switch_proc = 1)
 #endif
@@ -2133,17 +2133,17 @@ MOO_EXPORT void moo_abort (
  * DEBUG SUPPORT
  * ========================================================================= */
 
-MOO_EXPORT int moo_initdbginfo (
+MOO_EXPORT int moo_initdbgi (
 	moo_t*    moo,
 	moo_oow_t init_capa
 );
 
 /**
- * The moo_finidbginfo() function deletes the debug information.
+ * The moo_finidbgi() function deletes the debug information.
  * It is called by moo_close(). Unless you want the debug information to
  * be deleted earlier, you need not call this function explicitly.
  */
-MOO_EXPORT void moo_finidbginfo (
+MOO_EXPORT void moo_finidbgi (
 	moo_t* moo
 );
 /* =========================================================================
@@ -2365,29 +2365,6 @@ MOO_EXPORT int moo_convutobcstr (
  * STRING DUPLICATION
  * ========================================================================= */
 
-#if defined(MOO_OOCH_IS_UCH)
-#	define moo_dupootobcharswithheadroom(moo,hrb,oocs,oocslen,bcslen) moo_duputobcharswithheadroom(moo,hrb,oocs,oocslen,bcslen)
-#	define moo_dupbtooocharswithheadroom(moo,hrb,bcs,bcslen,oocslen) moo_dupbtoucharswithheadroom(moo,hrb,bcs,bcslen,oocslen)
-#	define moo_dupootobchars(moo,oocs,oocslen,bcslen) moo_duputobchars(moo,oocs,oocslen,bcslen)
-#	define moo_dupbtooochars(moo,bcs,bcslen,oocslen) moo_dupbtouchars(moo,bcs,bcslen,oocslen)
-
-#	define moo_dupootobcstrwithheadroom(moo,hrb,oocs,bcslen) moo_duputobcstrwithheadroom(moo,hrb,oocs,bcslen)
-#	define moo_dupbtooocstrwithheadroom(moo,hrb,bcs,oocslen) moo_dupbtoucstrwithheadroom(moo,hrb,bcs,oocslen)
-#	define moo_dupootobcstr(moo,oocs,bcslen) moo_duputobcstr(moo,oocs,bcslen)
-#	define moo_dupbtooocstr(moo,bcs,oocslen) moo_dupbtoucstr(moo,bcs,oocslen)
-#else
-#	define moo_dupootoucharswithheadroom(moo,hrb,oocs,oocslen,ucslen) moo_dupbtoucharswithheadroom(moo,hrb,oocs,oocslen,ucslen)
-#	define moo_duputooocharswithheadroom(moo,hrb,ucs,ucslen,oocslen) moo_duputobcharswithheadroom(moo,hrb,ucs,ucslen,oocslen)
-#	define moo_dupootouchars(moo,oocs,oocslen,ucslen) moo_dupbtouchars(moo,oocs,oocslen,ucslen)
-#	define moo_duputooochars(moo,ucs,ucslen,oocslen) moo_duputobchars(moo,ucs,ucslen,oocslen)
-
-#	define moo_dupootoucstrwithheadroom(moo,hrb,oocs,ucslen) moo_dupbtoucstrwithheadroom(moo,hrb,oocs,ucslen)
-#	define moo_duputooocstrwithheadroom(moo,hrb,ucs,oocslen) moo_duputobcstrwithheadroom(moo,hrb,ucs,oocslen)
-#	define moo_dupootoucstr(moo,oocs,ucslen) moo_dupbtoucstr(moo,oocs,ucslen)
-#	define moo_duputooocstr(moo,ucs,oocslen) moo_duputobcstr(moo,ucs,oocslen)
-#endif
-
-
 MOO_EXPORT moo_uch_t* moo_dupbtoucharswithheadroom (
 	moo_t*           moo,
 	moo_oow_t        headroom_bytes,
@@ -2404,21 +2381,6 @@ MOO_EXPORT moo_bch_t* moo_duputobcharswithheadroom (
 	moo_oow_t*       bcslen
 );
 
-MOO_EXPORT moo_uch_t* moo_dupbtouchars (
-	moo_t*           moo,
-	const moo_bch_t* bcs,
-	moo_oow_t        bcslen,
-	moo_oow_t*       ucslen
-);
-
-MOO_EXPORT moo_bch_t* moo_duputobchars (
-	moo_t*           moo,
-	const moo_uch_t* ucs,
-	moo_oow_t        ucslen,
-	moo_oow_t*       bcslen
-);
-
-
 MOO_EXPORT moo_uch_t* moo_dupbtoucstrwithheadroom (
 	moo_t*           moo,
 	moo_oow_t        headroom_bytes,
@@ -2433,25 +2395,34 @@ MOO_EXPORT moo_bch_t* moo_duputobcstrwithheadroom (
 	moo_oow_t* bcslen
 );
 
-MOO_EXPORT moo_uch_t* moo_dupbtoucstr (
-	moo_t*           moo,
-	const moo_bch_t* bcs,
-	moo_oow_t*       ucslen /* optional: length of returned string */
-);
+#if defined(MOO_HAVE_INLINE)
+static MOO_INLINE moo_bch_t* moo_duputobchars (moo_t* moo, const moo_uch_t* ucs, moo_oow_t ucslen, moo_oow_t* bcslen)
+{
+	return moo_duputobcharswithheadroom (moo, 0, ucs, ucslen, bcslen);
+}
 
-MOO_EXPORT moo_bch_t* moo_duputobcstr (
-	moo_t*           moo,
-	const moo_uch_t* ucs,
-	moo_oow_t*       bcslen /* optional: length of returned string */
-);
+static MOO_INLINE moo_uch_t* moo_dupbtouchars (moo_t* moo, const moo_bch_t* bcs, moo_oow_t bcslen, moo_oow_t* ucslen)
+{
+	return moo_dupbtoucharswithheadroom (moo, 0, bcs, bcslen, ucslen);
+}
 
+static MOO_INLINE moo_bch_t* moo_duputobcstr (moo_t* moo, const moo_uch_t* ucs, moo_oow_t* bcslen)
+{
+	return moo_duputobcstrwithheadroom (moo, 0, ucs, bcslen);
+}
 
-#if defined(MOO_OOCH_IS_UCH)
-#	define moo_dupoochars(moo,oocs,oocslen) moo_dupuchars(moo,oocs,oocslen)
+static MOO_INLINE moo_uch_t* moo_dupbtoucstr (moo_t* moo, const moo_bch_t* bcs, moo_oow_t* ucslen)
+{
+	return moo_dupbtoucstrwithheadroom(moo, 0, bcs, ucslen);
+}
 #else
-#	define moo_dupoochars(moo,oocs,oocslen) moo_dupbchars(moo,oocs,oocslen)
+#	define moo_duputobchars(moo, ucs, ucslen, bcslen) moo_duputobcharswithheadroom(moo, 0, ucs, ucslen, bcslen)
+#	define moo_dupbtouchars(moo, bcs, bcslen, ucslen) moo_dupbtoucharswithheadroom(moo, 0, bcs, bcslen, ucslen)
+#	define moo_duputobcstr(moo, ucs, bcslen) moo_duputobcstrwithheadroom(moo, 0, ucs, bcslen)
+#	define moo_dupbtoucstr(moo, bcs, ucslen) moo_dupbtoucstrwithheadroom(moo, 0, bcs, ucslen)
 #endif
 
+
 MOO_EXPORT moo_uch_t* moo_dupuchars (
 	moo_t*           moo,
 	const moo_uch_t* ucs,
@@ -2464,6 +2435,31 @@ MOO_EXPORT moo_bch_t* moo_dupbchars (
 	moo_oow_t        bcslen
 );
 
+#if defined(MOO_OOCH_IS_UCH)
+#	define moo_dupootobcharswithheadroom(moo,hrb,oocs,oocslen,bcslen) moo_duputobcharswithheadroom(moo,hrb,oocs,oocslen,bcslen)
+#	define moo_dupbtooocharswithheadroom(moo,hrb,bcs,bcslen,oocslen) moo_dupbtoucharswithheadroom(moo,hrb,bcs,bcslen,oocslen)
+#	define moo_dupootobchars(moo,oocs,oocslen,bcslen) moo_duputobchars(moo,oocs,oocslen,bcslen)
+#	define moo_dupbtooochars(moo,bcs,bcslen,oocslen) moo_dupbtouchars(moo,bcs,bcslen,oocslen)
+
+#	define moo_dupootobcstrwithheadroom(moo,hrb,oocs,bcslen) moo_duputobcstrwithheadroom(moo,hrb,oocs,bcslen)
+#	define moo_dupbtooocstrwithheadroom(moo,hrb,bcs,oocslen) moo_dupbtoucstrwithheadroom(moo,hrb,bcs,oocslen)
+#	define moo_dupootobcstr(moo,oocs,bcslen) moo_duputobcstr(moo,oocs,bcslen)
+#	define moo_dupbtooocstr(moo,bcs,oocslen) moo_dupbtoucstr(moo,bcs,oocslen)
+#	define moo_dupoochars(moo,oocs,oocslen) moo_dupuchars(moo,oocs,oocslen)
+#else
+#	define moo_dupootoucharswithheadroom(moo,hrb,oocs,oocslen,ucslen) moo_dupbtoucharswithheadroom(moo,hrb,oocs,oocslen,ucslen)
+#	define moo_duputooocharswithheadroom(moo,hrb,ucs,ucslen,oocslen) moo_duputobcharswithheadroom(moo,hrb,ucs,ucslen,oocslen)
+#	define moo_dupootouchars(moo,oocs,oocslen,ucslen) moo_dupbtouchars(moo,oocs,oocslen,ucslen)
+#	define moo_duputooochars(moo,ucs,ucslen,oocslen) moo_duputobchars(moo,ucs,ucslen,oocslen)
+
+#	define moo_dupootoucstrwithheadroom(moo,hrb,oocs,ucslen) moo_dupbtoucstrwithheadroom(moo,hrb,oocs,ucslen)
+#	define moo_duputooocstrwithheadroom(moo,hrb,ucs,oocslen) moo_duputobcstrwithheadroom(moo,hrb,ucs,oocslen)
+#	define moo_dupootoucstr(moo,oocs,ucslen) moo_dupbtoucstr(moo,oocs,ucslen)
+#	define moo_duputooocstr(moo,ucs,oocslen) moo_duputobcstr(moo,ucs,oocslen)
+#	define moo_dupoochars(moo,oocs,oocslen) moo_dupbchars(moo,oocs,oocslen)
+#endif
+
+
 /* =========================================================================
  * SBUF MANIPULATION
  * ========================================================================= */
diff --git a/moo/lib/std.c b/moo/lib/std.c
index 079ed51..ea8f381 100644
--- a/moo/lib/std.c
+++ b/moo/lib/std.c
@@ -545,6 +545,21 @@ static MOO_INLINE moo_ooi_t open_input (moo_t* moo, moo_ioarg_t* arg)
 	}
 
 	arg->handle = bb;
+	if (!arg->name)
+	{
+		/* for the top-level stream, i simply change the arg->name field
+		 * so that the compiler knows the file to be read */
+		moo_oocs_t io_name;
+
+		io_name.ptr = moo_dupbtooocstr(moo, get_base_name(bb->fn), &io_name.len);
+		if (!io_name.ptr) goto oops;
+
+		arg->name = moo_addcioname(moo, &io_name);
+		moo_freemem (moo, io_name.ptr);
+
+		if (!arg->name) goto oops;
+	}
+
 	return 0;
 
 oops:
@@ -3703,6 +3718,7 @@ void moo_abortstd (moo_t* moo)
 	moo_abort (moo);
 }
 
+#if defined(MOO_INCLUDE_COMPILER)
 int moo_compilestd (moo_t* moo, const moo_iostd_t* in, moo_oow_t count)
 {
 	xtn_t* xtn = GET_XTN(moo);
@@ -3716,6 +3732,7 @@ int moo_compilestd (moo_t* moo, const moo_iostd_t* in, moo_oow_t count)
 
 	return 0;
 }
+#endif
 
 void moo_rcvtickstd (moo_t* moo, int v)
 {
@@ -3904,4 +3921,4 @@ void moo_uncatch_termreq (void)
 	unset_signal_handler(SIGINT);
 }
 
-#endif
\ No newline at end of file
+#endif
diff --git a/moo/lib/utl.c b/moo/lib/utl.c
index 982db29..81b841c 100644
--- a/moo/lib/utl.c
+++ b/moo/lib/utl.c
@@ -914,7 +914,7 @@ int moo_convutobcstr (moo_t* moo, const moo_uch_t* ucs, moo_oow_t* ucslen, moo_b
 
 /* ----------------------------------------------------------------------- */
 
-MOO_INLINE moo_uch_t* moo_dupbtoucharswithheadroom (moo_t* moo, moo_oow_t headroom_bytes, const moo_bch_t* bcs, moo_oow_t bcslen, moo_oow_t* ucslen)
+moo_uch_t* moo_dupbtoucharswithheadroom (moo_t* moo, moo_oow_t headroom_bytes, const moo_bch_t* bcs, moo_oow_t bcslen, moo_oow_t* ucslen)
 {
 	moo_oow_t inlen, outlen;
 	moo_uch_t* ptr;
@@ -942,12 +942,7 @@ MOO_INLINE moo_uch_t* moo_dupbtoucharswithheadroom (moo_t* moo, moo_oow_t headro
 	return ptr;
 }
 
-moo_uch_t* moo_dupbtouchars (moo_t* moo, const moo_bch_t* bcs, moo_oow_t bcslen, moo_oow_t* ucslen)
-{
-	return moo_dupbtoucharswithheadroom (moo, 0, bcs, bcslen, ucslen);
-}
-
-MOO_INLINE moo_bch_t* moo_duputobcharswithheadroom (moo_t* moo, moo_oow_t headroom_bytes, const moo_uch_t* ucs, moo_oow_t ucslen, moo_oow_t* bcslen)
+moo_bch_t* moo_duputobcharswithheadroom (moo_t* moo, moo_oow_t headroom_bytes, const moo_uch_t* ucs, moo_oow_t ucslen, moo_oow_t* bcslen)
 {
 	moo_oow_t inlen, outlen;
 	moo_bch_t* ptr;
@@ -971,15 +966,9 @@ MOO_INLINE moo_bch_t* moo_duputobcharswithheadroom (moo_t* moo, moo_oow_t headro
 	return ptr;
 }
 
-moo_bch_t* moo_duputobchars (moo_t* moo, const moo_uch_t* ucs, moo_oow_t ucslen, moo_oow_t* bcslen)
-{
-	return moo_duputobcharswithheadroom (moo, 0, ucs, ucslen, bcslen);
-}
-
-
 /* ----------------------------------------------------------------------- */
 
-MOO_INLINE moo_uch_t* moo_dupbtoucstrwithheadroom (moo_t* moo, moo_oow_t headroom_bytes, const moo_bch_t* bcs, moo_oow_t* ucslen)
+moo_uch_t* moo_dupbtoucstrwithheadroom (moo_t* moo, moo_oow_t headroom_bytes, const moo_bch_t* bcs, moo_oow_t* ucslen)
 {
 	moo_oow_t inlen, outlen;
 	moo_uch_t* ptr;
@@ -999,12 +988,7 @@ MOO_INLINE moo_uch_t* moo_dupbtoucstrwithheadroom (moo_t* moo, moo_oow_t headroo
 	return ptr;
 }
 
-moo_uch_t* moo_dupbtoucstr (moo_t* moo, const moo_bch_t* bcs, moo_oow_t* ucslen)
-{
-	return moo_dupbtoucstrwithheadroom (moo, 0, bcs, ucslen);
-}
-
-MOO_INLINE moo_bch_t* moo_duputobcstrwithheadroom (moo_t* moo, moo_oow_t headroom_bytes, const moo_uch_t* ucs, moo_oow_t* bcslen)
+moo_bch_t* moo_duputobcstrwithheadroom (moo_t* moo, moo_oow_t headroom_bytes, const moo_uch_t* ucs, moo_oow_t* bcslen)
 {
 	moo_oow_t inlen, outlen;
 	moo_bch_t* ptr;
@@ -1026,10 +1010,6 @@ MOO_INLINE moo_bch_t* moo_duputobcstrwithheadroom (moo_t* moo, moo_oow_t headroo
 	return ptr;
 }
 
-moo_bch_t* moo_duputobcstr (moo_t* moo, const moo_uch_t* ucs, moo_oow_t* bcslen)
-{
-	return moo_duputobcstrwithheadroom (moo, 0, ucs, bcslen);
-}
 /* ----------------------------------------------------------------------- */
 
 moo_uch_t* moo_dupuchars (moo_t* moo, const moo_uch_t* ucs, moo_oow_t ucslen)