diff --git a/ase/stx/bootstrp.c b/ase/stx/bootstrp.c
index f8645d1e..6f822833 100644
--- a/ase/stx/bootstrp.c
+++ b/ase/stx/bootstrp.c
@@ -1,5 +1,5 @@
 /*
- * $Id: bootstrp.c,v 1.10 2005-05-30 07:27:29 bacon Exp $
+ * $Id: bootstrp.c,v 1.11 2005-06-08 16:00:51 bacon Exp $
  */
 
 #include <xp/stx/bootstrp.h>
@@ -13,23 +13,23 @@ static void __create_bootstrapping_objects (xp_stx_t* stx);
 static void __create_builtin_classes (xp_stx_t* stx);
 static void __filein_kernel (xp_stx_t* stx);
 
-static xp_stx_word_t __count_names (const xp_stx_char_t* str);
+static xp_word_t __count_names (const xp_char_t* str);
 static void __set_names (
-	xp_stx_t* stx, xp_stx_word_t* array, const xp_stx_char_t* str);
+	xp_stx_t* stx, xp_word_t* array, const xp_char_t* str);
 
-static xp_stx_word_t __count_subclasses (const xp_stx_char_t* str);
+static xp_word_t __count_subclasses (const xp_char_t* str);
 static void __set_subclasses (
-	xp_stx_t* stx, xp_stx_word_t* array, const xp_stx_char_t* str);
+	xp_stx_t* stx, xp_word_t* array, const xp_char_t* str);
 static void __set_metaclass_subclasses (
-	xp_stx_t* stx, xp_stx_word_t* array, const xp_stx_char_t* str);
+	xp_stx_t* stx, xp_word_t* array, const xp_char_t* str);
 
 struct class_info_t 
 {
-	const xp_stx_char_t* name;
-	const xp_stx_char_t* superclass;
-	const xp_stx_char_t* instance_variables;
-	const xp_stx_char_t* class_variables;
-	const xp_stx_char_t* pool_dictionaries;
+	const xp_char_t* name;
+	const xp_char_t* superclass;
+	const xp_char_t* instance_variables;
+	const xp_char_t* class_variables;
+	const xp_char_t* pool_dictionaries;
 	const int is_indexable;
 };
 
@@ -38,7 +38,7 @@ typedef struct class_info_t class_info_t;
 static class_info_t class_info[] =
 {
 	{
-		XP_STX_TEXT("Object"),
+		XP_TEXT("Object"),
 		XP_NULL,
 		XP_NULL,
 		XP_NULL,
@@ -46,128 +46,128 @@ static class_info_t class_info[] =
 		0
 	},
 	{
-		XP_STX_TEXT("UndefinedObject"),
-		XP_STX_TEXT("Object"),
+		XP_TEXT("UndefinedObject"),
+		XP_TEXT("Object"),
 		XP_NULL,
 		XP_NULL,
 		XP_NULL,
 		0
 	},
 	{ 
-		XP_STX_TEXT("Behavior"),
-		XP_STX_TEXT("Object"),
-		XP_STX_TEXT("spec methods superclass"),
+		XP_TEXT("Behavior"),
+		XP_TEXT("Object"),
+		XP_TEXT("spec methods superclass"),
 		XP_NULL,
 		XP_NULL,
 		0
 	},
 	{ 
-		XP_STX_TEXT("Class"),
-		XP_STX_TEXT("Behavior"),
-		XP_STX_TEXT("name variables classVariables poolDictionaries"),
+		XP_TEXT("Class"),
+		XP_TEXT("Behavior"),
+		XP_TEXT("name variables classVariables poolDictionaries"),
 		XP_NULL,
 		XP_NULL,
 		0
 	},
 	{ 
-		XP_STX_TEXT("Metaclass"),
-		XP_STX_TEXT("Behavior"),
-		XP_STX_TEXT("instanceClass"),
+		XP_TEXT("Metaclass"),
+		XP_TEXT("Behavior"),
+		XP_TEXT("instanceClass"),
 		XP_NULL,
 		XP_NULL,
 		0
 	},
 	{
-		XP_STX_TEXT("Block"),
-		XP_STX_TEXT("Object"),
-		XP_STX_TEXT("context argCount argLoc bytePointer"),
+		XP_TEXT("Block"),
+		XP_TEXT("Object"),
+		XP_TEXT("context argCount argLoc bytePointer"),
 		XP_NULL,
 		XP_NULL,
 		0
 	},
 	{
-		XP_STX_TEXT("Boolean"),
-		XP_STX_TEXT("Object"),
+		XP_TEXT("Boolean"),
+		XP_TEXT("Object"),
 		XP_NULL,
 		XP_NULL,
 		XP_NULL,
 		0
 	},
 	{
-		XP_STX_TEXT("True"),
-		XP_STX_TEXT("Boolean"),
+		XP_TEXT("True"),
+		XP_TEXT("Boolean"),
 		XP_NULL,
 		XP_NULL,
 		XP_NULL,
 		0
 	},
 	{
-		XP_STX_TEXT("False"),
-		XP_STX_TEXT("Boolean"),
+		XP_TEXT("False"),
+		XP_TEXT("Boolean"),
 		XP_NULL,
 		XP_NULL,
 		XP_NULL,
 		0
 	},
 	{
-		XP_STX_TEXT("Context"),
-		XP_STX_TEXT("Object"),
+		XP_TEXT("Context"),
+		XP_TEXT("Object"),
 		XP_NULL,
 		XP_NULL,
 		XP_NULL,
 		0
 	},
 	{
-		XP_STX_TEXT("Method"),
-		XP_STX_TEXT("Object"),
-		XP_STX_TEXT("text message bytecodes literals stackSize temporarySize class"),
+		XP_TEXT("Method"),
+		XP_TEXT("Object"),
+		XP_TEXT("text message bytecodes literals stackSize temporarySize class"),
 		XP_NULL,
 		XP_NULL,
 		0
 	},
 	{
-		XP_STX_TEXT("Magnitude"),
-		XP_STX_TEXT("Object"),
+		XP_TEXT("Magnitude"),
+		XP_TEXT("Object"),
 		XP_NULL,
 		XP_NULL,
 		XP_NULL,
 		0
 	},
 	{
-		XP_STX_TEXT("Collection"),
-		XP_STX_TEXT("Magnitude"),
+		XP_TEXT("Collection"),
+		XP_TEXT("Magnitude"),
 		XP_NULL,
 		XP_NULL,
 		XP_NULL,
 		0
 	},
 	{
-		XP_STX_TEXT("IndexedCollection"),
-		XP_STX_TEXT("Collection"),
+		XP_TEXT("IndexedCollection"),
+		XP_TEXT("Collection"),
 		XP_NULL,
 		XP_NULL,
 		XP_NULL,
 		1
 	},
 	{
-		XP_STX_TEXT("Array"),
-		XP_STX_TEXT("IndexedCollection"),
+		XP_TEXT("Array"),
+		XP_TEXT("IndexedCollection"),
 		XP_NULL,
 		XP_NULL,
 		XP_NULL,
 		1
 	},
 	{
-		XP_STX_TEXT("SymbolTable"),
-		XP_STX_TEXT("IndexedCollection"),
+		XP_TEXT("SymbolTable"),
+		XP_TEXT("IndexedCollection"),
 		XP_NULL,
 		XP_NULL,
 		XP_NULL,
 		1
 	},
 	{
-		XP_STX_TEXT("SystemDictionary"),
-		XP_STX_TEXT("IndexedCollection"),
+		XP_TEXT("SystemDictionary"),
+		XP_TEXT("IndexedCollection"),
 		XP_NULL,
 		XP_NULL,
 		XP_NULL,
@@ -183,11 +183,11 @@ static class_info_t class_info[] =
 	}
 };
 
-xp_stx_word_t xp_stx_new_array (xp_stx_t* stx, xp_stx_word_t size)
+xp_word_t xp_stx_new_array (xp_stx_t* stx, xp_word_t size)
 {
-	xp_stx_word_t x;
+	xp_word_t x;
 
-	xp_stx_assert (stx->class_array != stx->nil);
+	xp_assert (stx->class_array != stx->nil);
 	x = xp_stx_alloc_word_object (stx, size);
 	XP_STX_CLASS(stx,x) = stx->class_array;
 
@@ -196,16 +196,16 @@ xp_stx_word_t xp_stx_new_array (xp_stx_t* stx, xp_stx_word_t size)
 
 int xp_stx_bootstrap (xp_stx_t* stx)
 {
-	xp_stx_word_t symbol_Smalltalk;
-	xp_stx_word_t object_meta;
+	xp_word_t symbol_Smalltalk;
+	xp_word_t object_meta;
 
 	__create_bootstrapping_objects (stx);
 
 	/* object, class, and array are precreated for easier instantiation
 	 * of builtin classes */
-	stx->class_object = xp_stx_new_class (stx, XP_STX_TEXT("Object"));
-	stx->class_class = xp_stx_new_class (stx, XP_STX_TEXT("Class"));
-	stx->class_array = xp_stx_new_class (stx, XP_STX_TEXT("Array"));
+	stx->class_object = xp_stx_new_class (stx, XP_TEXT("Object"));
+	stx->class_class = xp_stx_new_class (stx, XP_TEXT("Class"));
+	stx->class_array = xp_stx_new_class (stx, XP_TEXT("Array"));
 
 	__create_builtin_classes (stx);
 
@@ -218,7 +218,7 @@ int xp_stx_bootstrap (xp_stx_t* stx)
 
 	/* for some fun here */
 	{
-		xp_stx_word_t array;
+		xp_word_t array;
 		array = xp_stx_new_array (stx, 1);
 		XP_STX_WORDAT(stx,array,0) = object_meta;
 		XP_STX_WORDAT(stx,stx->class_class,XP_STX_CLASS_SUBCLASSES) = array;
@@ -226,30 +226,30 @@ int xp_stx_bootstrap (xp_stx_t* stx)
 			
 	/* more initialization */
 	XP_STX_CLASS(stx,stx->symbol_table) = 
-		xp_stx_lookup_class (stx, XP_STX_TEXT("SymbolTable"));
+		xp_stx_lookup_class (stx, XP_TEXT("SymbolTable"));
 	XP_STX_CLASS(stx,stx->smalltalk) = 
-		xp_stx_lookup_class (stx, XP_STX_TEXT("SystemDictionary"));
+		xp_stx_lookup_class (stx, XP_TEXT("SystemDictionary"));
 
 	symbol_Smalltalk = 
-		xp_stx_new_symbol (stx, XP_STX_TEXT("Smalltalk"));
+		xp_stx_new_symbol (stx, XP_TEXT("Smalltalk"));
 	xp_stx_hash_insert (stx, stx->smalltalk,
 		xp_stx_hash_char_object(stx,symbol_Smalltalk),
 		symbol_Smalltalk, stx->smalltalk);	
 
 	/* create #nil, #true, #false */
-	xp_stx_new_symbol (stx, XP_STX_TEXT("nil"));
-	xp_stx_new_symbol (stx, XP_STX_TEXT("true"));
-	xp_stx_new_symbol (stx, XP_STX_TEXT("false"));
+	xp_stx_new_symbol (stx, XP_TEXT("nil"));
+	xp_stx_new_symbol (stx, XP_TEXT("true"));
+	xp_stx_new_symbol (stx, XP_TEXT("false"));
 
 	/* nil setClass: UndefinedObject */
 	XP_STX_CLASS(stx,stx->nil) =
-		xp_stx_lookup_class (stx, XP_STX_TEXT("UndefinedObject"));
+		xp_stx_lookup_class (stx, XP_TEXT("UndefinedObject"));
 	/* true setClass: True */
 	XP_STX_CLASS(stx,stx->true) =
-		xp_stx_lookup_class (stx, XP_STX_TEXT("True"));
+		xp_stx_lookup_class (stx, XP_TEXT("True"));
 	/* fales setClass: False */
 	XP_STX_CLASS(stx,stx->false) = 
-		xp_stx_lookup_class (stx, XP_STX_TEXT("False"));
+		xp_stx_lookup_class (stx, XP_TEXT("False"));
 
 
 	__filein_kernel (stx);
@@ -258,23 +258,23 @@ int xp_stx_bootstrap (xp_stx_t* stx)
 
 static void __create_bootstrapping_objects (xp_stx_t* stx)
 {
-	xp_stx_word_t class_SymlinkMeta;
-	xp_stx_word_t class_SymbolMeta; 
-	xp_stx_word_t class_MetaclassMeta;
-	xp_stx_word_t class_PairlinkMeta;
-	xp_stx_word_t symbol_Symlink;
-	xp_stx_word_t symbol_Symbol; 
-	xp_stx_word_t symbol_Metaclass;
-	xp_stx_word_t symbol_Pairlink;
+	xp_word_t class_SymlinkMeta;
+	xp_word_t class_SymbolMeta; 
+	xp_word_t class_MetaclassMeta;
+	xp_word_t class_PairlinkMeta;
+	xp_word_t symbol_Symlink;
+	xp_word_t symbol_Symbol; 
+	xp_word_t symbol_Metaclass;
+	xp_word_t symbol_Pairlink;
 
 	/* allocate three keyword objects */
 	stx->nil = xp_stx_alloc_word_object (stx, 0);
 	stx->true = xp_stx_alloc_word_object (stx, 0);
 	stx->false = xp_stx_alloc_word_object (stx, 0);
 
-	xp_stx_assert (stx->nil == XP_STX_NIL);
-	xp_stx_assert (stx->true == XP_STX_TRUE);
-	xp_stx_assert (stx->false == XP_STX_FALSE);
+	xp_assert (stx->nil == XP_STX_NIL);
+	xp_assert (stx->true == XP_STX_TRUE);
+	xp_assert (stx->false == XP_STX_FALSE);
 
 	/* symbol table & system dictionary */
 	/* TODO: symbol table and dictionary size */
@@ -339,13 +339,13 @@ static void __create_bootstrapping_objects (xp_stx_t* stx)
 	 * __create_builtin_classes */
 
 	/* #Symlink */
-	symbol_Symlink = xp_stx_new_symbol (stx, XP_STX_TEXT("Symlink"));
+	symbol_Symlink = xp_stx_new_symbol (stx, XP_TEXT("Symlink"));
 	/* #Symbol */
-	symbol_Symbol = xp_stx_new_symbol (stx, XP_STX_TEXT("Symbol"));
+	symbol_Symbol = xp_stx_new_symbol (stx, XP_TEXT("Symbol"));
 	/* #Metaclass */
-	symbol_Metaclass = xp_stx_new_symbol (stx, XP_STX_TEXT("Metaclass"));
+	symbol_Metaclass = xp_stx_new_symbol (stx, XP_TEXT("Metaclass"));
 	/* #Pairlink */
-	symbol_Pairlink = xp_stx_new_symbol (stx, XP_STX_TEXT("Pairlink"));
+	symbol_Pairlink = xp_stx_new_symbol (stx, XP_TEXT("Pairlink"));
 
 	/* Symlink setName: #Symlink */
 	XP_STX_WORDAT(stx,stx->class_symlink,XP_STX_CLASS_NAME) = symbol_Symlink;
@@ -374,13 +374,13 @@ static void __create_bootstrapping_objects (xp_stx_t* stx)
 static void __create_builtin_classes (xp_stx_t* stx)
 {
 	class_info_t* p;
-	xp_stx_word_t class, superclass, array;
+	xp_word_t class, superclass, array;
 	xp_stx_class_t* class_obj, * superclass_obj;
-	xp_stx_word_t metaclass;
+	xp_word_t metaclass;
 	xp_stx_metaclass_t* metaclass_obj;
-	xp_stx_word_t n, spec;
+	xp_word_t n, spec;
 
-	xp_stx_assert (stx->class_array != stx->nil);
+	xp_assert (stx->class_array != stx->nil);
 
 	for (p = class_info; p->name != XP_NULL; p++) {
 		class = xp_stx_lookup_class(stx, p->name);
@@ -388,18 +388,18 @@ static void __create_builtin_classes (xp_stx_t* stx)
 			class = xp_stx_new_class (stx, p->name);
 		}
 
-		xp_stx_assert (class != stx->nil);
+		xp_assert (class != stx->nil);
 		class_obj = (xp_stx_class_t*)XP_STX_WORD_OBJECT(stx, class);
 		class_obj->superclass = (p->superclass == XP_NULL)?
 			stx->nil: xp_stx_lookup_class(stx,p->superclass);
 
 		spec = 0;
 		if (p->superclass != XP_NULL) {
-			xp_stx_word_t meta;
+			xp_word_t meta;
 			xp_stx_metaclass_t* meta_obj;
 
 			superclass = xp_stx_lookup_class(stx,p->superclass);
-			xp_stx_assert (superclass != stx->nil);
+			xp_assert (superclass != stx->nil);
 
 			meta = class_obj->header.class;
 			meta_obj = (xp_stx_metaclass_t*)XP_STX_WORD_OBJECT(stx,meta);
@@ -445,7 +445,7 @@ static void __create_builtin_classes (xp_stx_t* stx)
 		__set_subclasses (stx, XP_STX_DATA(stx,array), p->name);
 
 		class = xp_stx_lookup_class(stx, p->name);
-		xp_stx_assert (class != stx->nil);
+		xp_assert (class != stx->nil);
 		class_obj = (xp_stx_class_t*)XP_STX_WORD_OBJECT(stx, class);
 		class_obj->subclasses = array;
 	}
@@ -457,57 +457,57 @@ static void __create_builtin_classes (xp_stx_t* stx)
 		__set_metaclass_subclasses (stx, XP_STX_DATA(stx,array), p->name);
 
 		class = xp_stx_lookup_class(stx, p->name);
-		xp_stx_assert (class != stx->nil);
+		xp_assert (class != stx->nil);
 		metaclass = XP_STX_CLASS(stx,class);
 		metaclass_obj = (xp_stx_metaclass_t*)XP_STX_WORD_OBJECT(stx, metaclass);
 		metaclass_obj->subclasses = array;
 	}
 }
 
-static xp_stx_word_t __count_names (const xp_stx_char_t* str)
+static xp_word_t __count_names (const xp_char_t* str)
 {
-	xp_stx_word_t n = 0;
-	const xp_stx_char_t* p = str;
+	xp_word_t n = 0;
+	const xp_char_t* p = str;
 
 	do {
-		while (*p == XP_STX_CHAR(' ') ||
-		       *p == XP_STX_CHAR('\t')) p++;
-		if (*p == XP_STX_CHAR('\0')) break;
+		while (*p == XP_CHAR(' ') ||
+		       *p == XP_CHAR('\t')) p++;
+		if (*p == XP_CHAR('\0')) break;
 
 		n++;
-		while (*p != XP_STX_CHAR(' ') && 
-		       *p != XP_STX_CHAR('\t') && 
-		       *p != XP_STX_CHAR('\0')) p++;
+		while (*p != XP_CHAR(' ') && 
+		       *p != XP_CHAR('\t') && 
+		       *p != XP_CHAR('\0')) p++;
 	} while (1);
 
 	return n;
 }
 
 static void __set_names (
-	xp_stx_t* stx, xp_stx_word_t* array, const xp_stx_char_t* str)
+	xp_stx_t* stx, xp_word_t* array, const xp_char_t* str)
 {
-	xp_stx_word_t n = 0;
-	const xp_stx_char_t* p = str;
-	const xp_stx_char_t* name;
+	xp_word_t n = 0;
+	const xp_char_t* p = str;
+	const xp_char_t* name;
 
 	do {
-		while (*p == XP_STX_CHAR(' ') ||
-		       *p == XP_STX_CHAR('\t')) p++;
-		if (*p == XP_STX_CHAR('\0')) break;
+		while (*p == XP_CHAR(' ') ||
+		       *p == XP_CHAR('\t')) p++;
+		if (*p == XP_CHAR('\0')) break;
 
 		name = p;
-		while (*p != XP_STX_CHAR(' ') && 
-		       *p != XP_STX_CHAR('\t') && 
-		       *p != XP_STX_CHAR('\0')) p++;
+		while (*p != XP_CHAR(' ') && 
+		       *p != XP_CHAR('\t') && 
+		       *p != XP_CHAR('\0')) p++;
 
 		array[n++] = xp_stx_new_symbolx (stx, name, p - name);
 	} while (1);
 }
 
-static xp_stx_word_t __count_subclasses (const xp_stx_char_t* str)
+static xp_word_t __count_subclasses (const xp_char_t* str)
 {
 	class_info_t* p;
-	xp_stx_word_t n = 0;
+	xp_word_t n = 0;
 
 	for (p = class_info; p->name != XP_NULL; p++) {
 		if (p->superclass == XP_NULL) continue;
@@ -518,31 +518,31 @@ static xp_stx_word_t __count_subclasses (const xp_stx_char_t* str)
 }
 
 static void __set_subclasses (
-	xp_stx_t* stx, xp_stx_word_t* array, const xp_stx_char_t* str)
+	xp_stx_t* stx, xp_word_t* array, const xp_char_t* str)
 {
 	class_info_t* p;
-	xp_stx_word_t n = 0, class;
+	xp_word_t n = 0, class;
 
 	for (p = class_info; p->name != XP_NULL; p++) {
 		if (p->superclass == XP_NULL) continue;
 		if (xp_stx_strcmp (str, p->superclass) != 0) continue;
 		class = xp_stx_lookup_class (stx, p->name);
-		xp_stx_assert (class != stx->nil);
+		xp_assert (class != stx->nil);
 		array[n++] = class;
 	}
 }
 
 static void __set_metaclass_subclasses (
-	xp_stx_t* stx, xp_stx_word_t* array, const xp_stx_char_t* str)
+	xp_stx_t* stx, xp_word_t* array, const xp_char_t* str)
 {
 	class_info_t* p;
-	xp_stx_word_t n = 0, class;
+	xp_word_t n = 0, class;
 
 	for (p = class_info; p->name != XP_NULL; p++) {
 		if (p->superclass == XP_NULL) continue;
 		if (xp_stx_strcmp (str, p->superclass) != 0) continue;
 		class = xp_stx_lookup_class (stx, p->name);
-		xp_stx_assert (class != stx->nil);
+		xp_assert (class != stx->nil);
 		array[n++] = XP_STX_CLASS(stx,class);
 	}
 }
diff --git a/ase/stx/bootstrp.h b/ase/stx/bootstrp.h
index 31e269b9..b6c72527 100644
--- a/ase/stx/bootstrp.h
+++ b/ase/stx/bootstrp.h
@@ -1,5 +1,5 @@
 /*
- * $Id: bootstrp.h,v 1.2 2005-05-23 15:51:03 bacon Exp $
+ * $Id: bootstrp.h,v 1.3 2005-06-08 16:00:51 bacon Exp $
  */
 
 #ifndef _XP_STX_BOOTSTRP_H_
@@ -12,7 +12,7 @@ extern "C" {
 #endif
 
 
-xp_stx_word_t xp_stx_new_array (xp_stx_t* stx, xp_stx_word_t size);
+xp_word_t xp_stx_new_array (xp_stx_t* stx, xp_word_t size);
 int xp_stx_bootstrap (xp_stx_t* stx);
 
 #ifdef __cplusplus
diff --git a/ase/stx/class.c b/ase/stx/class.c
index 99480b1c..1dd4cad0 100644
--- a/ase/stx/class.c
+++ b/ase/stx/class.c
@@ -1,5 +1,5 @@
 /*
- * $Id: class.c,v 1.8 2005-05-29 16:51:16 bacon Exp $
+ * $Id: class.c,v 1.9 2005-06-08 16:00:51 bacon Exp $
  */
 
 #include <xp/stx/class.h>
@@ -8,10 +8,10 @@
 #include <xp/stx/hash.h>
 #include <xp/stx/misc.h>
 
-xp_stx_word_t xp_stx_new_class (xp_stx_t* stx, const xp_stx_char_t* name)
+xp_word_t xp_stx_new_class (xp_stx_t* stx, const xp_char_t* name)
 {
-	xp_stx_word_t meta, class;
-	xp_stx_word_t class_name;
+	xp_word_t meta, class;
+	xp_word_t class_name;
 
 	meta = xp_stx_alloc_word_object (stx, XP_STX_METACLASS_SIZE);
 	XP_STX_CLASS(stx,meta) = stx->class_metaclass;
@@ -33,9 +33,9 @@ xp_stx_word_t xp_stx_new_class (xp_stx_t* stx, const xp_stx_char_t* name)
 	return class;
 }
 
-xp_stx_word_t xp_stx_lookup_class (xp_stx_t* stx, const xp_stx_char_t* name)
+xp_word_t xp_stx_lookup_class (xp_stx_t* stx, const xp_char_t* name)
 {
-	xp_stx_word_t link, meta, value;
+	xp_word_t link, meta, value;
 
 	link = xp_stx_hash_lookup_symbol (stx, stx->smalltalk, name);
 	if (link == stx->nil) return stx->nil;
diff --git a/ase/stx/class.h b/ase/stx/class.h
index 26b819c8..310ef958 100644
--- a/ase/stx/class.h
+++ b/ase/stx/class.h
@@ -1,5 +1,5 @@
 /*
- * $Id: class.h,v 1.5 2005-05-26 15:39:32 bacon Exp $
+ * $Id: class.h,v 1.6 2005-06-08 16:00:51 bacon Exp $
  */
 
 #ifndef _XP_STX_CLASS_H_
@@ -28,24 +28,24 @@
 struct xp_stx_class_t
 {
 	xp_stx_objhdr_t header;
-	xp_stx_word_t spec; /* indexable: 1, nfields: the rest */
-	xp_stx_word_t methods;
-	xp_stx_word_t superclass;
-	xp_stx_word_t subclasses;
-	xp_stx_word_t name;
-	xp_stx_word_t variables;
-	xp_stx_word_t class_variables;
-	xp_stx_word_t pool_dictonaries;
+	xp_word_t spec; /* indexable: 1, nfields: the rest */
+	xp_word_t methods;
+	xp_word_t superclass;
+	xp_word_t subclasses;
+	xp_word_t name;
+	xp_word_t variables;
+	xp_word_t class_variables;
+	xp_word_t pool_dictonaries;
 };
 
 struct xp_stx_metaclass_t
 {
 	xp_stx_objhdr_t header;
-	xp_stx_word_t spec;
-	xp_stx_word_t methods;
-	xp_stx_word_t superclass;
-	xp_stx_word_t subclasses;
-	xp_stx_word_t instance_class;
+	xp_word_t spec;
+	xp_word_t methods;
+	xp_word_t superclass;
+	xp_word_t subclasses;
+	xp_word_t instance_class;
 };
 
 typedef struct xp_stx_class_t xp_stx_class_t;
@@ -55,8 +55,8 @@ typedef struct xp_stx_metaclass_t xp_stx_metaclass_t;
 extern "C" {
 #endif
 
-xp_stx_word_t xp_stx_new_class (xp_stx_t* stx, const xp_stx_char_t* name);
-xp_stx_word_t xp_stx_lookup_class (xp_stx_t* stx, const xp_stx_char_t* name);
+xp_word_t xp_stx_new_class (xp_stx_t* stx, const xp_char_t* name);
+xp_word_t xp_stx_lookup_class (xp_stx_t* stx, const xp_char_t* name);
 
 #ifdef __cplusplus
 }
diff --git a/ase/stx/context.c b/ase/stx/context.c
index 9263e11f..8b78d125 100644
--- a/ase/stx/context.c
+++ b/ase/stx/context.c
@@ -1,5 +1,5 @@
 /*
- * $Id: context.c,v 1.7 2005-05-23 14:43:03 bacon Exp $
+ * $Id: context.c,v 1.8 2005-06-08 16:00:51 bacon Exp $
  */
 
 #include <xp/stx/context.h>
@@ -7,10 +7,10 @@
 #include <xp/stx/class.h>
 #include <xp/stx/misc.h>
 
-xp_stx_word_t xp_stx_new_context (xp_stx_t* stx, 
-	xp_stx_word_t method, xp_stx_word_t args, xp_stx_word_t temp)
+xp_word_t xp_stx_new_context (xp_stx_t* stx, 
+	xp_word_t method, xp_word_t args, xp_word_t temp)
 {
-	xp_stx_word_t context;
+	xp_word_t context;
 	xp_stx_context_t* obj;
 
 	context = xp_stx_alloc_word_object(stx,XP_STX_CONTEXT_SIZE);
@@ -23,7 +23,7 @@ xp_stx_word_t xp_stx_new_context (xp_stx_t* stx,
 	*/
 
 	obj = (xp_stx_context_t*)XP_STX_OBJECT(stx,context);
-	obj->header.class = xp_stx_lookup_class(stx,XP_STX_TEXT("Context"));
+	obj->header.class = xp_stx_lookup_class(stx,XP_TEXT("Context"));
 	obj->ip = XP_STX_TO_SMALLINT(0);
 	obj->method = method;
 	obj->arguments = args;
@@ -32,25 +32,25 @@ xp_stx_word_t xp_stx_new_context (xp_stx_t* stx,
 	return context;
 }
 
-static xp_stx_byte_t __fetch_byte (
+static xp_byte_t __fetch_byte (
 	xp_stx_t* stx, xp_stx_context_t* context_obj)
 {
-	xp_stx_word_t ip, method;
+	xp_word_t ip, method;
 
-	xp_stx_assert (XP_STX_IS_SMALLINT(context_obj->ip));
+	xp_assert (XP_STX_IS_SMALLINT(context_obj->ip));
 	ip = XP_STX_FROM_SMALLINT(context_obj->ip);
 	method = context_obj->method;
 
 	/* increment instruction pointer */
 	context_obj->ip = XP_STX_TO_SMALLINT(ip + 1);
 
-	xp_stx_assert (XP_STX_TYPE(stx,method) == XP_STX_BYTE_INDEXED);
+	xp_assert (XP_STX_TYPE(stx,method) == XP_STX_BYTE_INDEXED);
 	return XP_STX_BYTEAT(stx,method,ip);
 }
 
-int xp_stx_run_context (xp_stx_t* stx, xp_stx_word_t context)
+int xp_stx_run_context (xp_stx_t* stx, xp_word_t context)
 {
-	xp_stx_byte_t byte, operand;
+	xp_byte_t byte, operand;
 	xp_stx_context_t* context_obj;
 
 	context_obj = (xp_stx_context_t*)XP_STX_OBJECT(stx,context);
diff --git a/ase/stx/context.h b/ase/stx/context.h
index e8626cbe..50af8a97 100644
--- a/ase/stx/context.h
+++ b/ase/stx/context.h
@@ -1,5 +1,5 @@
 /* 
- * $Id: context.h,v 1.2 2005-05-21 16:11:06 bacon Exp $
+ * $Id: context.h,v 1.3 2005-06-08 16:00:51 bacon Exp $
  */
 
 #ifndef _XP_STX_CONTEXT_H_
@@ -20,10 +20,10 @@
 struct xp_stx_context_t
 {
 	xp_stx_objhdr_t header;
-	xp_stx_word_t ip;
-	xp_stx_word_t method;
-	xp_stx_word_t arguments;
-	xp_stx_word_t temporaries;
+	xp_word_t ip;
+	xp_word_t method;
+	xp_word_t arguments;
+	xp_word_t temporaries;
 };
 
 typedef struct xp_stx_context_t xp_stx_context_t;
@@ -32,9 +32,9 @@ typedef struct xp_stx_context_t xp_stx_context_t;
 extern "C" {
 #endif
 
-xp_stx_word_t xp_stx_new_context (xp_stx_t* stx, 
-	xp_stx_word_t method, xp_stx_word_t args, xp_stx_word_t temp);
-int xp_stx_run_context (xp_stx_t* stx, xp_stx_word_t context);
+xp_word_t xp_stx_new_context (xp_stx_t* stx, 
+	xp_word_t method, xp_word_t args, xp_word_t temp);
+int xp_stx_run_context (xp_stx_t* stx, xp_word_t context);
 
 #ifdef __cplusplus
 }
diff --git a/ase/stx/extra.h b/ase/stx/extra.h
index f66bd787..ebc16c96 100644
--- a/ase/stx/extra.h
+++ b/ase/stx/extra.h
@@ -1,5 +1,5 @@
 /*
- * $Id: extra.h,v 1.1 2005-05-15 18:37:00 bacon Exp $
+ * $Id: extra.h,v 1.2 2005-06-08 16:00:51 bacon Exp $
  */
 
 #ifndef _XP_STX_EXTRA_H_
@@ -11,15 +11,15 @@
 extern "C" {
 #endif
 
-xp_stx_word_t xp_stx_strlen (const xp_stx_char_t* str)
+xp_word_t xp_stx_strlen (const xp_char_t* str)
 
 int xp_stx_strcmp (
-	const xp_stx_char_t* s1, const xp_stx_char_t* s2);
+	const xp_char_t* s1, const xp_char_t* s2);
 int xp_stx_strxcmp (
-	const xp_stx_char_t* s1, xp_stx_word_t len, const xp_stx_char_t* s2);
+	const xp_char_t* s1, xp_word_t len, const xp_char_t* s2);
 
-xp_stx_word_t xp_stx_strhash (const xp_stx_char_t* str);
-xp_stx_word_t xp_stx_strxhash (const xp_stx_char_t* str, xp_stx_word_t len);
+xp_word_t xp_stx_strhash (const xp_char_t* str);
+xp_word_t xp_stx_strxhash (const xp_char_t* str, xp_word_t len);
 
 #ifdef __cplusplus
 }
diff --git a/ase/stx/hash.c b/ase/stx/hash.c
index a9c007a2..e24e3bb7 100644
--- a/ase/stx/hash.c
+++ b/ase/stx/hash.c
@@ -1,15 +1,15 @@
 /*
- * $Id: hash.c,v 1.18 2005-05-29 16:51:16 bacon Exp $
+ * $Id: hash.c,v 1.19 2005-06-08 16:00:51 bacon Exp $
  */
 
 #include <xp/stx/hash.h>
 #include <xp/stx/object.h>
 #include <xp/stx/misc.h>
 
-xp_stx_word_t xp_stx_new_pairlink (
-	xp_stx_t* stx, xp_stx_word_t key, xp_stx_word_t value)
+xp_word_t xp_stx_new_pairlink (
+	xp_stx_t* stx, xp_word_t key, xp_word_t value)
 {
-	xp_stx_word_t x;
+	xp_word_t x;
 	xp_stx_pairlink_t* obj;
 
 	x = xp_stx_alloc_word_object (stx, XP_STX_PAIRLINK_SIZE);	
@@ -29,14 +29,14 @@ xp_stx_word_t xp_stx_new_pairlink (
 }
 
 /* returns the entire link */
-xp_stx_word_t xp_stx_hash_lookup (
-	xp_stx_t* stx, xp_stx_word_t table,
-	xp_stx_word_t hash, xp_stx_word_t key)
+xp_word_t xp_stx_hash_lookup (
+	xp_stx_t* stx, xp_word_t table,
+	xp_word_t hash, xp_word_t key)
 {
-	xp_stx_word_t link;
+	xp_word_t link;
 	xp_stx_pairlink_t* obj;
 
-	xp_stx_assert (XP_STX_TYPE(stx,table) == XP_STX_WORD_INDEXED);
+	xp_assert (XP_STX_TYPE(stx,table) == XP_STX_WORD_INDEXED);
 
 	hash = hash % XP_STX_SIZE(stx,table);
 	link = XP_STX_WORDAT(stx,table,hash);
@@ -55,21 +55,21 @@ xp_stx_word_t xp_stx_hash_lookup (
 	return stx->nil; /* not found */
 }
 
-xp_stx_word_t xp_stx_hash_lookup_symbol (
-	xp_stx_t* stx, xp_stx_word_t table, const xp_stx_char_t* name)
+xp_word_t xp_stx_hash_lookup_symbol (
+	xp_stx_t* stx, xp_word_t table, const xp_char_t* name)
 {
-	xp_stx_word_t link, hash;
+	xp_word_t link, hash;
 	xp_stx_pairlink_t* obj;
 	xp_stx_char_object_t* tmp;
 
-	xp_stx_assert (XP_STX_TYPE(stx,table) == XP_STX_WORD_INDEXED);
+	xp_assert (XP_STX_TYPE(stx,table) == XP_STX_WORD_INDEXED);
 
 	hash = xp_stx_strhash(name) % XP_STX_SIZE(stx,table);
 	link = XP_STX_WORDAT(stx,table,hash);
 
 	while (link != stx->nil) {
 		obj = (xp_stx_pairlink_t*)XP_STX_WORD_OBJECT(stx,link);
-		tmp = XP_STX_CHAR_OBJECT(stx,obj->key);
+		tmp = XP_CHAR_OBJECT(stx,obj->key);
 		if (tmp->header.class == stx->class_symbol &&
 		    xp_stx_strcmp (tmp->data, name) == 0) return link;
 		link = obj->link;
@@ -79,12 +79,12 @@ xp_stx_word_t xp_stx_hash_lookup_symbol (
 }
 
 void xp_stx_hash_insert (
-	xp_stx_t* stx, xp_stx_word_t table,
-	xp_stx_word_t hash, xp_stx_word_t key, xp_stx_word_t value)
+	xp_stx_t* stx, xp_word_t table,
+	xp_word_t hash, xp_word_t key, xp_word_t value)
 {
-	xp_stx_word_t link, next;
+	xp_word_t link, next;
 
-	xp_stx_assert (XP_STX_TYPE(stx,table) == XP_STX_WORD_INDEXED);
+	xp_assert (XP_STX_TYPE(stx,table) == XP_STX_WORD_INDEXED);
 
 	hash = hash % XP_STX_SIZE(stx,table);
 	link = XP_STX_WORDAT(stx,table,hash);
@@ -113,11 +113,11 @@ void xp_stx_hash_insert (
 }
 
 void xp_stx_hash_traverse (
-	xp_stx_t* stx, xp_stx_word_t table, 
-	void (*func) (xp_stx_t*,xp_stx_word_t))
+	xp_stx_t* stx, xp_word_t table, 
+	void (*func) (xp_stx_t*,xp_word_t))
 {
-	xp_stx_word_t link;
-	xp_stx_word_t size = XP_STX_SIZE(stx,table);
+	xp_word_t link;
+	xp_word_t size = XP_STX_SIZE(stx,table);
 	
 	while (size-- > 0) {
 		link = XP_STX_WORDAT(stx,table,size);
diff --git a/ase/stx/hash.h b/ase/stx/hash.h
index fa42214c..879c3cb6 100644
--- a/ase/stx/hash.h
+++ b/ase/stx/hash.h
@@ -1,5 +1,5 @@
 /*
- * $Id: hash.h,v 1.8 2005-05-22 15:03:20 bacon Exp $
+ * $Id: hash.h,v 1.9 2005-06-08 16:00:51 bacon Exp $
  */
 
 #ifndef _XP_STX_HASH_H_
@@ -15,9 +15,9 @@
 struct xp_stx_pairlink_t
 {
 	xp_stx_objhdr_t header;
-	xp_stx_word_t link;
-	xp_stx_word_t key;
-	xp_stx_word_t value;
+	xp_word_t link;
+	xp_word_t key;
+	xp_word_t value;
 };
 
 typedef struct xp_stx_pairlink_t xp_stx_pairlink_t;
@@ -27,19 +27,19 @@ extern "C"
 #endif
 
 /* hash table manipulation */
-xp_stx_word_t xp_stx_new_plink (
-	xp_stx_t* stx, xp_stx_word_t key, xp_stx_word_t value);
-xp_stx_word_t xp_stx_hash_lookup (
-	xp_stx_t* stx, xp_stx_word_t table,
-	xp_stx_word_t hash, xp_stx_word_t key);
-xp_stx_word_t xp_stx_hash_lookup_symbol (
-	xp_stx_t* stx, xp_stx_word_t table, const xp_stx_char_t* name);
+xp_word_t xp_stx_new_plink (
+	xp_stx_t* stx, xp_word_t key, xp_word_t value);
+xp_word_t xp_stx_hash_lookup (
+	xp_stx_t* stx, xp_word_t table,
+	xp_word_t hash, xp_word_t key);
+xp_word_t xp_stx_hash_lookup_symbol (
+	xp_stx_t* stx, xp_word_t table, const xp_char_t* name);
 void xp_stx_hash_insert (
-	xp_stx_t* stx, xp_stx_word_t table,
-	xp_stx_word_t hash, xp_stx_word_t key, xp_stx_word_t value);
+	xp_stx_t* stx, xp_word_t table,
+	xp_word_t hash, xp_word_t key, xp_word_t value);
 void xp_stx_hash_traverse (
-	xp_stx_t* stx, xp_stx_word_t table, 
-	void (*func) (xp_stx_t*,xp_stx_word_t));
+	xp_stx_t* stx, xp_word_t table, 
+	void (*func) (xp_stx_t*,xp_word_t));
 
 #ifdef __cplusplus
 }
diff --git a/ase/stx/interp.c b/ase/stx/interp.c
index 111e864a..982b013b 100644
--- a/ase/stx/interp.c
+++ b/ase/stx/interp.c
@@ -1,5 +1,5 @@
 /*
- * $Id: interp.c,v 1.3 2005-05-18 04:01:51 bacon Exp $
+ * $Id: interp.c,v 1.4 2005-06-08 16:00:51 bacon Exp $
  */
 
 #include <xp/stx/interp.h>
@@ -36,18 +36,18 @@ static byte_code_func_t byte_code_funcs[] =
 	do_special
 };
 
-xp_stx_word_t xp_stx_new_method (xp_stx_t* stx)
+xp_word_t xp_stx_new_method (xp_stx_t* stx)
 {
-	xp_stx_word_t method;
+	xp_word_t method;
 	method = xp_stx_alloc_object(XP_STX_METHOD_SIZE);
 
 	return method;
 }
 
-xp_stx_word_t xp_stx_new_context (xp_stx_t* stx, 
-	xp_stx_word_t method, xp_stx_word_t args, xp_stx_word_t temp)
+xp_word_t xp_stx_new_context (xp_stx_t* stx, 
+	xp_word_t method, xp_word_t args, xp_word_t temp)
 {
-	xp_stx_word_t context;
+	xp_word_t context;
 
 	context = xp_stx_alloc_object(XP_STX_CONTEXT_SIZE);
 	XP_STX_CLASS(stx,context) = stx->class_context;
@@ -58,9 +58,9 @@ xp_stx_word_t xp_stx_new_context (xp_stx_t* stx,
 	return context;
 }
 
-xp_stx_word_t xp_stx_new_process (xp_stx_t* stx, xp_stx_word_t method)
+xp_word_t xp_stx_new_process (xp_stx_t* stx, xp_word_t method)
 {
-	xp_stx_word_t process, stx;
+	xp_word_t process, stx;
 
 	process = xp_stx_alloc_object(XP_STX_PROCESS_SIZE);
 	stack = xp_new_array(stx,50);
@@ -80,7 +80,7 @@ xp_stx_word_t xp_stx_new_process (xp_stx_t* stx, xp_stx_word_t method)
 	return process;	
 }
 
-int xp_stx_execute (xp_stx_t* stx, xp_stx_word_t process)
+int xp_stx_execute (xp_stx_t* stx, xp_word_t process)
 {
 	int low, high;
 	byte_code_func_t bcfunc;
diff --git a/ase/stx/memory.c b/ase/stx/memory.c
index b52ca563..36769150 100644
--- a/ase/stx/memory.c
+++ b/ase/stx/memory.c
@@ -1,28 +1,28 @@
 /*
- * $Id: memory.c,v 1.11 2005-05-20 04:01:12 bacon Exp $
+ * $Id: memory.c,v 1.12 2005-06-08 16:00:51 bacon Exp $
  */
 
 #include <xp/stx/memory.h>
 #include <xp/stx/misc.h>
 
 xp_stx_memory_t* xp_stx_memory_open (
-	xp_stx_memory_t* mem, xp_stx_word_t capacity)
+	xp_stx_memory_t* mem, xp_word_t capacity)
 {
 	xp_stx_object_t** slots;
-	xp_stx_word_t n;
+	xp_word_t n;
 
-	xp_stx_assert (capacity > 0);
+	xp_assert (capacity > 0);
 	if (mem == XP_NULL) {
-		mem = (xp_stx_memory_t*)xp_stx_malloc(xp_sizeof(xp_stx_memory_t));
+		mem = (xp_stx_memory_t*)xp_malloc(xp_sizeof(xp_stx_memory_t));
 		if (mem == XP_NULL) return XP_NULL;
 		mem->__malloced = xp_true;
 	}
 	else mem->__malloced = xp_false;
 
-	slots = (xp_stx_object_t**)xp_stx_malloc (
+	slots = (xp_stx_object_t**)xp_malloc (
 		capacity * xp_sizeof(xp_stx_object_t*));
 	if (slots == XP_NULL) {
-		if (mem->__malloced) xp_stx_free (mem);
+		if (mem->__malloced) xp_free (mem);
 		mem = XP_NULL;
 	}
 
@@ -43,11 +43,11 @@ void xp_stx_memory_close (xp_stx_memory_t* mem)
 {
 	/* TODO: free all linked objects...	 */
 
-	xp_stx_free (mem->slots);
+	xp_free (mem->slots);
 	mem->capacity = 0;
 	mem->slots = XP_NULL;
 	mem->free = XP_NULL;
-	if (mem->__malloced) xp_stx_free (mem);
+	if (mem->__malloced) xp_free (mem);
 }
 
 void xp_stx_memory_gc (xp_stx_memory_t* mem)
@@ -55,7 +55,7 @@ void xp_stx_memory_gc (xp_stx_memory_t* mem)
 	/* TODO: implement this function */
 }
 
-xp_stx_word_t xp_stx_memory_alloc (xp_stx_memory_t* mem, xp_stx_word_t nbytes)
+xp_word_t xp_stx_memory_alloc (xp_stx_memory_t* mem, xp_word_t nbytes)
 {
 	xp_stx_object_t** slot;
 	xp_stx_object_t* object;
@@ -66,13 +66,13 @@ xp_stx_word_t xp_stx_memory_alloc (xp_stx_memory_t* mem, xp_stx_word_t nbytes)
 		if (mem->free == XP_NULL) return mem->capacity;;
 	}
 
-	object = (xp_stx_object_t*)xp_stx_malloc (nbytes);
+	object = (xp_stx_object_t*)xp_malloc (nbytes);
 	if (object == XP_NULL) {
 		xp_stx_memory_gc (mem);
-		object = (xp_stx_object_t*)xp_stx_malloc (nbytes);
+		object = (xp_stx_object_t*)xp_malloc (nbytes);
 		/*if (object == XP_NULL) return mem->capacity;*/
 if (object == XP_NULL) {
-xp_stx_assert (XP_TEXT("MEMORY ALLOCATION ERROR\n") == XP_NULL);
+xp_assert (XP_TEXT("MEMORY ALLOCATION ERROR\n") == XP_NULL);
 exit (1);
 }
 	}
@@ -81,17 +81,17 @@ exit (1);
 	mem->free = (xp_stx_object_t**)*slot;
 	*slot = object;
 
-	return (xp_stx_word_t)(slot - mem->slots);
+	return (xp_word_t)(slot - mem->slots);
 }
 
-void xp_stx_memory_dealloc (xp_stx_memory_t* mem, xp_stx_word_t object_index)
+void xp_stx_memory_dealloc (xp_stx_memory_t* mem, xp_word_t object_index)
 {
 	/* 
 	 * THIS IS PRIMITIVE LOW-LEVEL DEALLOC. THIS WILL NOT 
 	 * DEALLOCATE MEMORY ALLOCATED FOR ITS INSTANCE VARIABLES.
 	 */
 
-	xp_stx_free (mem->slots[object_index]);
+	xp_free (mem->slots[object_index]);
 	mem->slots[object_index] = (xp_stx_object_t*)mem->free;
 	mem->free = &mem->slots[object_index];
 }
diff --git a/ase/stx/memory.h b/ase/stx/memory.h
index 0a3de40c..7f3b4319 100644
--- a/ase/stx/memory.h
+++ b/ase/stx/memory.h
@@ -1,5 +1,5 @@
 /*
- * $Id: memory.h,v 1.5 2005-05-08 10:31:24 bacon Exp $
+ * $Id: memory.h,v 1.6 2005-06-08 16:00:51 bacon Exp $
  */
 
 #ifndef _XP_STX_MEMORY_H_
@@ -12,12 +12,12 @@ extern "C" {
 #endif
 
 xp_stx_memory_t* xp_stx_memory_open (
-	xp_stx_memory_t* mem, xp_stx_word_t capacity);
+	xp_stx_memory_t* mem, xp_word_t capacity);
 void xp_stx_memory_close (xp_stx_memory_t* mem);
 
 void xp_stx_memory_gc (xp_stx_memory_t* mem);
-xp_stx_word_t xp_stx_memory_alloc (xp_stx_memory_t* mem, xp_stx_word_t size);
-void xp_stx_memory_dealloc (xp_stx_memory_t* mem, xp_stx_word_t object_index);
+xp_word_t xp_stx_memory_alloc (xp_stx_memory_t* mem, xp_word_t size);
+void xp_stx_memory_dealloc (xp_stx_memory_t* mem, xp_word_t object_index);
 
 #ifdef __cplusplus
 }
diff --git a/ase/stx/misc.c b/ase/stx/misc.c
index ee887184..8c0252ab 100644
--- a/ase/stx/misc.c
+++ b/ase/stx/misc.c
@@ -1,45 +1,45 @@
 /*
- * $Id: misc.c,v 1.2 2005-05-16 14:14:34 bacon Exp $
+ * $Id: misc.c,v 1.3 2005-06-08 16:00:51 bacon Exp $
  */
 
 #include <xp/stx/misc.h>
 
-xp_stx_word_t xp_stx_strlen (const xp_stx_char_t* str)
+xp_word_t xp_stx_strlen (const xp_char_t* str)
 {
-	const xp_stx_char_t* p = str;
-	while (*p != XP_STX_CHAR('\0')) p++;
+	const xp_char_t* p = str;
+	while (*p != XP_CHAR('\0')) p++;
 	return p - str;
 }
 
-int xp_stx_strcmp (const xp_stx_char_t* s1, const xp_stx_char_t* s2)
+int xp_stx_strcmp (const xp_char_t* s1, const xp_char_t* s2)
 {
-	while (*s1 == *s2 && *s2 != XP_STX_CHAR('\0')) s1++, s2++;
+	while (*s1 == *s2 && *s2 != XP_CHAR('\0')) s1++, s2++;
 	if (*s1 > *s2) return 1;
 	else if (*s1 < *s2) return -1;
 	return 0;
 }
 
 int xp_stx_strxcmp (
-	const xp_stx_char_t* s1, xp_stx_word_t len, const xp_stx_char_t* s2)
+	const xp_char_t* s1, xp_word_t len, const xp_char_t* s2)
 {
-	const xp_stx_char_t* end = s1 + len;
-	while (s1 < end && *s2 != XP_STX_CHAR('\0') && *s1 == *s2) {
+	const xp_char_t* end = s1 + len;
+	while (s1 < end && *s2 != XP_CHAR('\0') && *s1 == *s2) {
 		s1++; s2++;
 	}
-	if (s1 == end && *s2 == XP_STX_CHAR('\0')) return 0;
+	if (s1 == end && *s2 == XP_CHAR('\0')) return 0;
 	if (*s1 == *s2) return (s1 < end)? 1: -1;
 	return (*s1 > *s2)? 1: -1;
 }
 
-xp_stx_word_t xp_stx_strhash (const xp_stx_char_t* str)
+xp_word_t xp_stx_strhash (const xp_char_t* str)
 {
-	xp_stx_word_t h = 0;
-	xp_stx_byte_t* bp, * be;
-	const xp_stx_char_t* p = str;
+	xp_word_t h = 0;
+	xp_byte_t* bp, * be;
+	const xp_char_t* p = str;
 
-	while (*p != XP_STX_CHAR('\0')) {
-		bp = (xp_stx_byte_t*)p;
-		be = bp + xp_sizeof(xp_stx_char_t);
+	while (*p != XP_CHAR('\0')) {
+		bp = (xp_byte_t*)p;
+		be = bp + xp_sizeof(xp_char_t);
 		while (bp < be) h = h * 31 + *bp++;
 		p++;
 	}
@@ -47,15 +47,15 @@ xp_stx_word_t xp_stx_strhash (const xp_stx_char_t* str)
 	return h;
 }
 
-xp_stx_word_t xp_stx_strxhash (const xp_stx_char_t* str, xp_stx_word_t len)
+xp_word_t xp_stx_strxhash (const xp_char_t* str, xp_word_t len)
 {
-	xp_stx_word_t h = 0;
-	xp_stx_byte_t* bp, * be;
-	const xp_stx_char_t* p = str, * end = str + len;
+	xp_word_t h = 0;
+	xp_byte_t* bp, * be;
+	const xp_char_t* p = str, * end = str + len;
 
 	while (p < end) {
-		bp = (xp_stx_byte_t*)p;
-		be = bp + xp_sizeof(xp_stx_char_t);
+		bp = (xp_byte_t*)p;
+		be = bp + xp_sizeof(xp_char_t);
 		while (bp < be) h = h * 31 + *bp++;
 		p++;
 	}
diff --git a/ase/stx/misc.h b/ase/stx/misc.h
index b889b3eb..c09a918e 100644
--- a/ase/stx/misc.h
+++ b/ase/stx/misc.h
@@ -1,5 +1,5 @@
 /*
- * $Id: misc.h,v 1.4 2005-06-05 05:26:24 bacon Exp $
+ * $Id: misc.h,v 1.5 2005-06-08 16:00:51 bacon Exp $
  */
 
 #ifndef _XP_STX_MISC_H_
@@ -14,51 +14,53 @@
 	#include <stdio.h>
 	#include <ctype.h>
 
-	#define xp_stx_assert   assert
-	#define xp_stx_malloc   malloc
-	#define xp_stx_realloc  realloc
-	#define xp_stx_free     free
-	#define xp_stx_va_list  va_list
-	#define xp_stx_va_start va_start
-	#define xp_stx_va_end   va_end  
-	#define xp_stx_va_arg   va_arg
-	#define xp_stx_isspace  isspace
-	#define xp_stx_isdigit  isdigit
-	#define xp_stx_isalpha  isalpha
-	#define xp_stx_isalnum  isalnum
+	#define xp_assert   assert
+	#define xp_malloc   malloc
+	#define xp_realloc  realloc
+	#define xp_free     free
+	#define xp_va_list  va_list
+	#define xp_va_start va_start
+	#define xp_va_end   va_end  
+	#define xp_va_arg   va_arg
+	#define xp_isspace  isspace
+	#define xp_isdigit  isdigit
+	#define xp_isalpha  isalpha
+	#define xp_isalnum  isalnum
 #else
 	#include <xp/bas/memory.h>
 	#include <xp/bas/assert.h>
 	#include <xp/bas/stdarg.h>
 	#include <xp/bas/ctype.h>
 
-	#define xp_stx_assert   xp_assert
-	#define xp_stx_malloc   xp_malloc
-	#define xp_stx_realloc  xp_realloc
-	#define xp_stx_free     xp_free
-	#define xp_stx_va_list  xp_va_list
-	#define xp_stx_va_start xp_va_start
-	#define xp_stx_va_end   xp_va_end  
-	#define xp_stx_va_arg   xp_va_arg
-	#define xp_stx_isspace  xp_isspace
-	#define xp_stx_isdigit  xp_isdigit
-	#define xp_stx_isalpha  xp_isalpha
-	#define xp_stx_isalnum  xp_isalnum
+	/*
+	#define xp_assert   xp_assert
+	#define xp_malloc   xp_malloc
+	#define xp_realloc  xp_realloc
+	#define xp_free     xp_free
+	#define xp_va_list  xp_va_list
+	#define xp_va_start xp_va_start
+	#define xp_va_end   xp_va_end  
+	#define xp_va_arg   xp_va_arg
+	#define xp_isspace  xp_isspace
+	#define xp_isdigit  xp_isdigit
+	#define xp_isalpha  xp_isalpha
+	#define xp_isalnum  xp_isalnum
+	*/
 #endif
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-xp_stx_word_t xp_stx_strlen (const xp_stx_char_t* str);
+xp_word_t xp_stx_strlen (const xp_char_t* str);
 
 int xp_stx_strcmp (
-	const xp_stx_char_t* s1, const xp_stx_char_t* s2);
+	const xp_char_t* s1, const xp_char_t* s2);
 int xp_stx_strxcmp (
-	const xp_stx_char_t* s1, xp_stx_word_t len, const xp_stx_char_t* s2);
+	const xp_char_t* s1, xp_word_t len, const xp_char_t* s2);
 
-xp_stx_word_t xp_stx_strhash (const xp_stx_char_t* str);
-xp_stx_word_t xp_stx_strxhash (const xp_stx_char_t* str, xp_stx_word_t len);
+xp_word_t xp_stx_strhash (const xp_char_t* str);
+xp_word_t xp_stx_strxhash (const xp_char_t* str, xp_word_t len);
 
 #ifdef __cplusplus
 }