From f3dc7b12d65911c5afef828b1fe7ea33fac90a8e Mon Sep 17 00:00:00 2001 From: hyung-hwan Date: Wed, 8 Jun 2005 16:00:51 +0000 Subject: [PATCH] *** empty log message *** --- ase/stx/bootstrp.c | 236 ++++++++++++++++++++++----------------------- ase/stx/bootstrp.h | 4 +- ase/stx/class.c | 12 +-- ase/stx/class.h | 32 +++--- ase/stx/context.c | 22 ++--- ase/stx/context.h | 16 +-- ase/stx/extra.h | 12 +-- ase/stx/hash.c | 44 ++++----- ase/stx/hash.h | 30 +++--- ase/stx/interp.c | 18 ++-- ase/stx/memory.c | 32 +++--- ase/stx/memory.h | 8 +- ase/stx/misc.c | 46 ++++----- ase/stx/misc.h | 62 ++++++------ 14 files changed, 288 insertions(+), 286 deletions(-) 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 @@ -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 @@ -8,10 +8,10 @@ #include #include -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 @@ -7,10 +7,10 @@ #include #include -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 #include #include -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 @@ -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 #include 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_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 #include - #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 #include #include #include - #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 }