Thu Apr 20 16:44:39 2006 Michael Jennings (mej)

Added mbuff and ustr to testing routines.

Fleshed out ustr class; doesn't do UTF-8 yet though.

Fixed array removal code.  I have no idea how that was working before.
----------------------------------------------------------------------


SVN revision: 22271

10 files changed, 862 insertions, 267 deletions

diff --git a/ChangeLog b/ChangeLog
index f28eaf2..5b9a8a4 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -773,3 +773,11 @@ Fri Feb 24 16:45:38 2006                        Michael Jennings (mej)
 Make removal of options from argv[] optional and off by default.
 Fixes Eterm problem with WM_COMMAND entries being empty.
 ----------------------------------------------------------------------
+Thu Apr 20 16:44:39 2006                        Michael Jennings (mej)
+
+Added mbuff and ustr to testing routines.
+
+Fleshed out ustr class; doesn't do UTF-8 yet though.
+
+Fixed array removal code.  I have no idea how that was working before.
+----------------------------------------------------------------------
diff --git a/include/libast.h b/include/libast.h
index 956d818..d397328 100644
--- a/include/libast.h
+++ b/include/libast.h
@@ -117,6 +117,7 @@ extern int re_exec();
 #include <libast/str.h>
 #include <libast/tok.h>
 #include <libast/url.h>
+#include <libast/ustr.h>
 
 #include <libast/iterator_if.h>
 #include <libast/list_if.h>
diff --git a/include/libast/Makefile.am b/include/libast/Makefile.am
index 5487746..f0e26c7 100644
--- a/include/libast/Makefile.am
+++ b/include/libast/Makefile.am
@@ -2,7 +2,7 @@
 
 EXTRA_HEADERS = array.h avl_tree.h dlinked_list.h iterator_if.h		\
 linked_list.h list_if.h map_if.h mbuff.h obj.h objpair.h regexp.h	\
-socket.h str.h sysdefs.h tok.h types.h url.h vector_if.h
+socket.h str.h sysdefs.h tok.h types.h url.h ustr.h vector_if.h
 
 install-exec-hook:
 	$(mkinstalldirs) $(DESTDIR)$(includedir)/$(PACKAGE)
diff --git a/include/libast/ustr.h b/include/libast/ustr.h
index 926daa0..8998bf5 100644
--- a/include/libast/ustr.h
+++ b/include/libast/ustr.h
@@ -70,40 +70,43 @@
 #define SPIF_USTR_RINDEX(o, x)                   SPIF_CAST(stridx) (SPIF_OBJ_CALL_METHOD((o), rindex)(o, x))
 #define SPIF_USTR_SPLICE(o, n1, n2, x)           SPIF_CAST(bool) (SPIF_OBJ_CALL_METHOD((o), splice)(o, n1, n2, x))
 #define SPIF_USTR_SPLICE_FROM_PTR(o, n1, n2, x)  SPIF_CAST(bool) (SPIF_OBJ_CALL_METHOD((o), splice_from_ptr)(o, n1, n2, x))
-#define SPIF_USTR_SUBUSTR(o, n1, n2)              SPIF_CAST(ustr) (SPIF_OBJ_CALL_METHOD((o), subustr)(o, n1, n2))
-#define SPIF_USTR_SUBUSTR_TO_PTR(o, n1, n2)       SPIF_CAST(charptr) (SPIF_OBJ_CALL_METHOD((o), subustr_to_ptr)(o, n1, n2))
+#define SPIF_USTR_SUBSTR(o, n1, n2)              SPIF_CAST(ustr) (SPIF_OBJ_CALL_METHOD((o), substr)(o, n1, n2))
+#define SPIF_USTR_SUBSTR_TO_PTR(o, n1, n2)       SPIF_CAST(charptr) (SPIF_OBJ_CALL_METHOD((o), substr_to_ptr)(o, n1, n2))
 #define SPIF_USTR_TO_FLOAT(o)                    SPIF_CAST_C(double) (SPIF_OBJ_CALL_METHOD((o), to_float)(o))
 #define SPIF_USTR_TO_NUM(o, x)                   SPIF_CAST_C(size_t) (SPIF_OBJ_CALL_METHOD((o), to_num)(o, x))
 #define SPIF_USTR_TRIM(o)                        SPIF_CAST(bool) (SPIF_OBJ_CALL_METHOD((o), trim)(o))
 #define SPIF_USTR_UPCASE(o)                      SPIF_CAST(bool) (SPIF_OBJ_CALL_METHOD((o), upcase)(o))
 
-#define SPIF_USTR_USTR(obj)  (SPIF_CONST_CAST(charptr) ((SPIF_USTR_ISNULL(obj)) \
-                                                      ? (SPIF_CAST(charptr) "") \
-                                                      : (SPIF_USTR(obj)->s)))
+#define SPIF_USTR_STR(obj)  (SPIF_CONST_CAST(charptr) ((SPIF_USTR_ISNULL(obj)) \
+                                                       ? (SPIF_CAST(charptr) "") \
+                                                       : (SPIF_USTR(obj)->s)))
+
+typedef spif_int64_t spif_ustridx_t;
 
 SPIF_DECL_OBJ(ustr) {
     SPIF_DECL_PARENT_TYPE(obj);
     spif_charptr_t s;
-    SPIF_DECL_PROPERTY_C(spif_stridx_t, size);
-    SPIF_DECL_PROPERTY_C(spif_stridx_t, len);
+    SPIF_DECL_PROPERTY_C(spif_ustridx_t, size);
+    SPIF_DECL_PROPERTY_C(spif_ustridx_t, len);
 };
 
 extern spif_class_t SPIF_CLASS_VAR(ustr);
+extern spif_strclass_t SPIF_STRCLASS_VAR(ustr);
 extern spif_ustr_t spif_ustr_new(void);
 extern spif_ustr_t spif_ustr_new_from_ptr(spif_charptr_t);
-extern spif_ustr_t spif_ustr_new_from_buff(spif_charptr_t, spif_stridx_t);
+extern spif_ustr_t spif_ustr_new_from_buff(spif_charptr_t, spif_ustridx_t);
 extern spif_ustr_t spif_ustr_new_from_fp(FILE *);
 extern spif_ustr_t spif_ustr_new_from_fd(int);
 extern spif_ustr_t spif_ustr_new_from_num(long);
 extern spif_bool_t spif_ustr_del(spif_ustr_t);
 extern spif_bool_t spif_ustr_init(spif_ustr_t);
 extern spif_bool_t spif_ustr_init_from_ptr(spif_ustr_t, spif_charptr_t);
-extern spif_bool_t spif_ustr_init_from_buff(spif_ustr_t, spif_charptr_t, spif_stridx_t);
+extern spif_bool_t spif_ustr_init_from_buff(spif_ustr_t, spif_charptr_t, spif_ustridx_t);
 extern spif_bool_t spif_ustr_init_from_fp(spif_ustr_t, FILE *);
 extern spif_bool_t spif_ustr_init_from_fd(spif_ustr_t, int);
 extern spif_bool_t spif_ustr_init_from_num(spif_ustr_t, long);
 extern spif_bool_t spif_ustr_done(spif_ustr_t);
-extern spif_ustr_t spif_ustr_show(spif_ustr_t, spif_charptr_t, spif_ustr_t, size_t);
+extern spif_str_t spif_ustr_show(spif_ustr_t, spif_charptr_t, spif_str_t, size_t);
 extern spif_cmp_t spif_ustr_comp(spif_ustr_t, spif_ustr_t);
 extern spif_ustr_t spif_ustr_dup(spif_ustr_t);
 extern spif_classname_t spif_ustr_type(spif_ustr_t);
@@ -117,27 +120,27 @@ extern spif_bool_t spif_ustr_clear(spif_ustr_t, spif_char_t);
 extern spif_cmp_t spif_ustr_cmp(spif_ustr_t, spif_ustr_t);
 extern spif_cmp_t spif_ustr_cmp_with_ptr(spif_ustr_t, spif_charptr_t);
 extern spif_bool_t spif_ustr_downcase(spif_ustr_t);
-extern spif_stridx_t spif_ustr_find(spif_ustr_t, spif_ustr_t);
-extern spif_stridx_t spif_ustr_find_from_ptr(spif_ustr_t, spif_charptr_t);
-extern spif_stridx_t spif_ustr_index(spif_ustr_t, spif_char_t);
-extern spif_cmp_t spif_ustr_ncasecmp(spif_ustr_t, spif_ustr_t, spif_stridx_t);
-extern spif_cmp_t spif_ustr_ncasecmp_with_ptr(spif_ustr_t, spif_charptr_t, spif_stridx_t);
-extern spif_cmp_t spif_ustr_ncmp(spif_ustr_t, spif_ustr_t, spif_stridx_t);
-extern spif_cmp_t spif_ustr_ncmp_with_ptr(spif_ustr_t, spif_charptr_t, spif_stridx_t);
+extern spif_ustridx_t spif_ustr_find(spif_ustr_t, spif_ustr_t);
+extern spif_ustridx_t spif_ustr_find_from_ptr(spif_ustr_t, spif_charptr_t);
+extern spif_ustridx_t spif_ustr_index(spif_ustr_t, spif_char_t);
+extern spif_cmp_t spif_ustr_ncasecmp(spif_ustr_t, spif_ustr_t, spif_ustridx_t);
+extern spif_cmp_t spif_ustr_ncasecmp_with_ptr(spif_ustr_t, spif_charptr_t, spif_ustridx_t);
+extern spif_cmp_t spif_ustr_ncmp(spif_ustr_t, spif_ustr_t, spif_ustridx_t);
+extern spif_cmp_t spif_ustr_ncmp_with_ptr(spif_ustr_t, spif_charptr_t, spif_ustridx_t);
 extern spif_bool_t spif_ustr_prepend(spif_ustr_t, spif_ustr_t);
 extern spif_bool_t spif_ustr_prepend_char(spif_ustr_t, spif_char_t);
 extern spif_bool_t spif_ustr_prepend_from_ptr(spif_ustr_t, spif_charptr_t);
 extern spif_bool_t spif_ustr_reverse(spif_ustr_t);
-extern spif_stridx_t spif_ustr_rindex(spif_ustr_t, spif_char_t);
-extern spif_bool_t spif_ustr_splice(spif_ustr_t, spif_stridx_t, spif_stridx_t, spif_ustr_t);
-extern spif_bool_t spif_ustr_splice_from_ptr(spif_ustr_t, spif_stridx_t, spif_stridx_t, spif_charptr_t);
-extern spif_ustr_t spif_ustr_subustr(spif_ustr_t, spif_stridx_t, spif_stridx_t);
-extern spif_charptr_t spif_ustr_subustr_to_ptr(spif_ustr_t, spif_stridx_t, spif_stridx_t);
+extern spif_ustridx_t spif_ustr_rindex(spif_ustr_t, spif_char_t);
+extern spif_bool_t spif_ustr_splice(spif_ustr_t, spif_ustridx_t, spif_ustridx_t, spif_ustr_t);
+extern spif_bool_t spif_ustr_splice_from_ptr(spif_ustr_t, spif_ustridx_t, spif_ustridx_t, spif_charptr_t);
+extern spif_ustr_t spif_ustr_substr(spif_ustr_t, spif_ustridx_t, spif_ustridx_t);
+extern spif_charptr_t spif_ustr_substr_to_ptr(spif_ustr_t, spif_ustridx_t, spif_ustridx_t);
 extern double spif_ustr_to_float(spif_ustr_t);
 extern size_t spif_ustr_to_num(spif_ustr_t, int);
 extern spif_bool_t spif_ustr_trim(spif_ustr_t);
 extern spif_bool_t spif_ustr_upcase(spif_ustr_t);
-SPIF_DECL_PROPERTY_FUNC_C(ustr, spif_stridx_t, size);
-SPIF_DECL_PROPERTY_FUNC_C(ustr, spif_stridx_t, len);
+SPIF_DECL_PROPERTY_FUNC_C(ustr, spif_ustridx_t, size);
+SPIF_DECL_PROPERTY_FUNC_C(ustr, spif_ustridx_t, len);
 
 #endif /* _LIBAST_USTR_H_ */
diff --git a/src/Makefile.am b/src/Makefile.am
index f27ce76..583cd55 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -7,7 +7,7 @@ INCLUDES = -I$(top_srcdir)/include -I$(top_srcdir)/include/$(PACKAGE)
 libast_la_SOURCES =							\
     array.c builtin_hashes.c conf.c debug.c dlinked_list.c file.c	\
     linked_list.c mbuff.c mem.c msgs.c obj.c objpair.c options.c	\
-    regexp.c socket.c str.c strings.c snprintf.c tok.c url.c
+    regexp.c socket.c str.c strings.c snprintf.c tok.c url.c ustr.c
 
 libast_la_LDFLAGS = -version-info 2:1:0
 MAINTAINERCLEANFILES = Makefile.in
diff --git a/src/array.c b/src/array.c
index 7b767be..09fb59e 100644
--- a/src/array.c
+++ b/src/array.c
@@ -366,7 +366,7 @@ spif_array_list_dup(spif_array_t self)
     tmp = spif_array_list_new();
     REQUIRE_RVAL(!SPIF_ARRAY_ISNULL(tmp), SPIF_NULL_TYPE(array));
     memcpy(tmp, self, SPIF_SIZEOF_TYPE(array));
-    tmp->items = SPIF_CAST_C(spif_obj_t *) MALLOC(SPIF_SIZEOF_TYPE(obj) * self->len);
+    tmp->items = SPIF_CAST_C(spif_obj_t *) MALLOC(sizeof(spif_obj_t) * self->len);
     for (i = 0; i < self->len; i++) {
         tmp->items[i] = SPIF_CAST(obj) SPIF_OBJ_DUP(SPIF_OBJ(self->items[i]));
     }
@@ -384,7 +384,7 @@ spif_array_vector_dup(spif_array_t self)
     tmp = spif_array_vector_new();
     REQUIRE_RVAL(!SPIF_ARRAY_ISNULL(tmp), SPIF_NULL_TYPE(array));
     memcpy(tmp, self, SPIF_SIZEOF_TYPE(array));
-    tmp->items = SPIF_CAST_C(spif_obj_t *) MALLOC(SPIF_SIZEOF_TYPE(obj) * self->len);
+    tmp->items = SPIF_CAST_C(spif_obj_t *) MALLOC(sizeof(spif_obj_t) * self->len);
     for (i = 0; i < self->len; i++) {
         tmp->items[i] = SPIF_CAST(obj) SPIF_OBJ_DUP(SPIF_OBJ(self->items[i]));
     }
@@ -402,7 +402,7 @@ spif_array_map_dup(spif_array_t self)
     tmp = spif_array_map_new();
     REQUIRE_RVAL(!SPIF_ARRAY_ISNULL(tmp), SPIF_NULL_TYPE(array));
     memcpy(tmp, self, SPIF_SIZEOF_TYPE(array));
-    tmp->items = SPIF_CAST_C(spif_obj_t *) MALLOC(SPIF_SIZEOF_TYPE(obj) * self->len);
+    tmp->items = SPIF_CAST_C(spif_obj_t *) MALLOC(sizeof(spif_obj_t) * self->len);
     for (i = 0; i < self->len; i++) {
         tmp->items[i] = SPIF_CAST(obj) SPIF_OBJ_DUP(SPIF_OBJ(self->items[i]));
     }
@@ -422,9 +422,9 @@ spif_array_append(spif_array_t self, spif_obj_t obj)
     ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), FALSE);
     self->len++;
     if (self->items) {
-        self->items = SPIF_CAST_C(spif_obj_t *) REALLOC(self->items, SPIF_SIZEOF_TYPE(obj) * self->len);
+        self->items = SPIF_CAST_C(spif_obj_t *) REALLOC(self->items, sizeof(spif_obj_t) * self->len);
     } else {
-        self->items = SPIF_CAST_C(spif_obj_t *) MALLOC(SPIF_SIZEOF_TYPE(obj) * self->len);
+        self->items = SPIF_CAST_C(spif_obj_t *) MALLOC(sizeof(spif_obj_t) * self->len);
     }
     self->items[self->len - 1] = obj;
     return TRUE;
@@ -635,15 +635,15 @@ spif_array_insert(spif_array_t self, spif_obj_t obj)
     ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), FALSE);
     REQUIRE_RVAL(!SPIF_OBJ_ISNULL(obj), FALSE);
     if (self->items) {
-        self->items = SPIF_CAST_C(spif_obj_t *) REALLOC(self->items, SPIF_SIZEOF_TYPE(obj) * (self->len + 1));
+        self->items = SPIF_CAST_C(spif_obj_t *) REALLOC(self->items, sizeof(spif_obj_t) * (self->len + 1));
     } else {
-        self->items = SPIF_CAST_C(spif_obj_t *) MALLOC(SPIF_SIZEOF_TYPE(obj) * (self->len + 1));
+        self->items = SPIF_CAST_C(spif_obj_t *) MALLOC(sizeof(spif_obj_t) * (self->len + 1));
     }
 
     for (i = 0; i < self->len && SPIF_CMP_IS_GREATER(SPIF_OBJ_COMP(obj, self->items[i])); i++);
     left = self->len - i;
     if (left) {
-        memmove(self->items + i + 1, self->items + i, SPIF_SIZEOF_TYPE(obj) * left);
+        memmove(self->items + i + 1, self->items + i, sizeof(spif_obj_t) * left);
     }
     self->items[i] = obj;
     self->len++;
@@ -672,18 +672,18 @@ spif_array_insert_at(spif_array_t self, spif_obj_t obj, spif_listidx_t idx)
     }
 
     if (self->items) {
-        self->items = SPIF_CAST_C(spif_obj_t *) REALLOC(self->items, SPIF_SIZEOF_TYPE(obj) * (self->len + 1));
+        self->items = SPIF_CAST_C(spif_obj_t *) REALLOC(self->items, sizeof(spif_obj_t) * (self->len + 1));
     } else {
-        self->items = SPIF_CAST_C(spif_obj_t *) MALLOC(SPIF_SIZEOF_TYPE(obj) * (self->len + 1));
+        self->items = SPIF_CAST_C(spif_obj_t *) MALLOC(sizeof(spif_obj_t) * (self->len + 1));
     }
 
     if (left > 0) {
         /* Move the stuff to the right of idx over one. */
-        memmove(self->items + idx + 1, self->items + idx, SPIF_SIZEOF_TYPE(obj) * left);
+        memmove(self->items + idx + 1, self->items + idx, sizeof(spif_obj_t) * left);
     } else if (left < 0) {
         /* NULL out the new gap in the list. */
         left = -left;
-        MEMSET(self->items + (idx - left), 0, SPIF_SIZEOF_TYPE(obj) * left);
+        MEMSET(self->items + (idx - left), 0, sizeof(spif_obj_t) * left);
     }
     self->items[idx] = obj;
     self->len++;
@@ -703,12 +703,12 @@ spif_array_prepend(spif_array_t self, spif_obj_t obj)
     ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), FALSE);
     REQUIRE_RVAL(!SPIF_OBJ_ISNULL(obj), FALSE);
     if (self->items) {
-        self->items = SPIF_CAST_C(spif_obj_t *) REALLOC(self->items, SPIF_SIZEOF_TYPE(obj) * (self->len + 1));
+        self->items = SPIF_CAST_C(spif_obj_t *) REALLOC(self->items, sizeof(spif_obj_t) * (self->len + 1));
     } else {
-        self->items = SPIF_CAST_C(spif_obj_t *) MALLOC(SPIF_SIZEOF_TYPE(obj) * (self->len + 1));
+        self->items = SPIF_CAST_C(spif_obj_t *) MALLOC(sizeof(spif_obj_t) * (self->len + 1));
     }
 
-    memmove(self->items + 1, self->items, SPIF_SIZEOF_TYPE(obj) * self->len);
+    memmove(self->items + 1, self->items, sizeof(spif_obj_t) * self->len);
     self->items[0] = obj;
     self->len++;
     return TRUE;
@@ -728,9 +728,11 @@ spif_array_remove(spif_array_t self, spif_obj_t item)
     }
 
     left = self->len - i - 1;
+    printf("%d %d %d\n", i, left, self->len);
     tmp = self->items[i];
-    memmove(self->items + i, self->items + i + 1, SPIF_SIZEOF_TYPE(obj) * left);
-    self->items = SPIF_CAST_C(spif_obj_t *) REALLOC(self->items, SPIF_SIZEOF_TYPE(obj) * (--(self->len)));
+    memmove(self->items + i, self->items + i + 1, sizeof(spif_obj_t) * left);
+    self->len--;
+    self->items = SPIF_CAST_PTR(obj) REALLOC(self->items, sizeof(spif_obj_t) * self->len);
 
     return tmp;
 }
@@ -750,8 +752,9 @@ spif_array_map_remove(spif_array_t self, spif_obj_t item)
 
     left = self->len - i - 1;
     tmp = self->items[i];
-    memmove(self->items + i, self->items + i + 1, SPIF_SIZEOF_TYPE(obj) * left);
-    self->items = SPIF_CAST_C(spif_obj_t *) REALLOC(self->items, SPIF_SIZEOF_TYPE(obj) * (--(self->len)));
+    memmove(self->items + i, self->items + i + 1, sizeof(spif_obj_t) * left);
+    self->len--;
+    self->items = SPIF_CAST_C(spif_obj_t *) REALLOC(self->items, sizeof(spif_obj_t) * self->len);
 
     return tmp;
 }
@@ -773,8 +776,9 @@ spif_array_remove_at(spif_array_t self, spif_listidx_t idx)
 
     left = self->len - idx - 1;
     tmp = self->items[idx];
-    memmove(self->items + idx, self->items + idx + 1, SPIF_SIZEOF_TYPE(obj) * left);
-    self->items = SPIF_CAST_C(spif_obj_t *) REALLOC(self->items, SPIF_SIZEOF_TYPE(obj) * (--(self->len)));
+    memmove(self->items + idx, self->items + idx + 1, sizeof(spif_obj_t) * left);
+    self->len--;
+    self->items = SPIF_CAST_C(spif_obj_t *) REALLOC(self->items, sizeof(spif_obj_t) * self->len);
 
     return tmp;
 }
@@ -821,7 +825,7 @@ spif_array_to_array(spif_array_t self)
     spif_listidx_t i;
 
     ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), SPIF_NULL_TYPE_PTR(obj));
-    tmp = SPIF_CAST_PTR(obj) MALLOC(SPIF_SIZEOF_TYPE(obj) * self->len);
+    tmp = SPIF_CAST_PTR(obj) MALLOC(sizeof(spif_obj_t) * self->len);
     for (i = 0; i < self->len; i++) {
         tmp[i] = SPIF_OBJ(self->items[i]);
     }
diff --git a/src/mbuff.c b/src/mbuff.c
index cc8e95c..da7d415 100644
--- a/src/mbuff.c
+++ b/src/mbuff.c
@@ -74,6 +74,8 @@ SPIF_TYPE(class) SPIF_CLASS_VAR(mbuff) = SPIF_CAST(class) &mb_class;
 SPIF_TYPE(mbuffclass) SPIF_MBUFFCLASS_VAR(mbuff) = &mb_class;
 /* *INDENT-ON* */
 
+static const size_t buff_inc = 4096;
+
 spif_mbuff_t
 spif_mbuff_new(void)
 {
@@ -186,7 +188,6 @@ spif_mbuff_init_from_buff(spif_mbuff_t self, spif_byteptr_t buff, spif_memidx_t
 spif_bool_t
 spif_mbuff_init_from_fp(spif_mbuff_t self, FILE *fp)
 {
-    spif_byteptr_t p;
     long file_pos;
     spif_memidx_t file_size;
 
@@ -196,20 +197,49 @@ spif_mbuff_init_from_fp(spif_mbuff_t self, FILE *fp)
     spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS(SPIF_MBUFFCLASS_VAR(mbuff)));
 
     file_pos = ftell(fp);
-    fseek(fp, 0L, SEEK_END);
-    file_size = ftell(fp);
-    fseek(fp, file_pos, SEEK_SET);
-    LOWER_BOUND(file_size, 0);
-    if (file_size == 0) {
-        spif_mbuff_init(self);
-        return FALSE;
-    }
-    self->len = self->size = file_size;
-    self->buff = SPIF_CAST(byteptr) MALLOC(self->size);
+    LOWER_BOUND(file_pos, 0);
+    if (fseek(fp, 0L, SEEK_END) < 0) {
+        spif_byteptr_t p;
+        size_t cnt = 0;
 
-    if (fread(p, file_size, 1, fp) < 1) {
-        FREE(self->buff);
-        return FALSE;
+        D_OBJ(("Unable to seek to EOF -- %s.\n", strerror(errno)));
+        self->size = buff_inc;
+        self->len = 0;
+        self->buff = SPIF_CAST(byteptr) MALLOC(self->size);
+
+        for (p = self->buff; (cnt = fread(p, 1, buff_inc, fp)) > 0; p += buff_inc) {
+            self->len += cnt;
+            if (feof(fp)) {
+                break;
+            } else if (ferror(fp)) {
+                libast_print_warning("read failed:  %s.\n", strerror(errno));
+                break;
+            } else {
+                self->size += buff_inc;
+                self->buff = SPIF_CAST(byteptr) REALLOC(self->buff, self->size);
+            }
+        }
+        self->size = self->len;
+        if (self->size) {
+            self->buff = SPIF_CAST(byteptr) REALLOC(self->buff, self->size);
+        } else {
+            FREE(self->buff);
+        }
+    } else {
+        file_size = ftell(fp);
+        fseek(fp, file_pos, SEEK_SET);
+        LOWER_BOUND(file_size, 0);
+        if (file_size <= 0) {
+            spif_mbuff_init(self);
+            return FALSE;
+        }
+        self->len = self->size = file_size;
+        self->buff = SPIF_CAST(byteptr) MALLOC(self->size);
+
+        if (fread(self->buff, file_size, 1, fp) < 1) {
+            FREE(self->buff);
+            return FALSE;
+        }
     }
     return TRUE;
 }
@@ -229,17 +259,38 @@ spif_mbuff_init_from_fd(spif_mbuff_t self, int fd)
     file_pos = lseek(fd, SPIF_CAST_C(off_t) 0, SEEK_CUR);
     file_size = SPIF_CAST(memidx) lseek(fd, SPIF_CAST_C(off_t) 0, SEEK_END);
     lseek(fd, file_pos, SEEK_SET);
-    LOWER_BOUND(file_size, 0);
-    if (file_size == 0) {
-        spif_mbuff_init(self);
-        return FALSE;
-    }
-    self->len = self->size = file_size;
-    self->buff = SPIF_CAST(byteptr) MALLOC(self->size);
+    if (file_size < 0) {
+        spif_byteptr_t p;
+        size_t cnt = 0;
 
-    if (read(fd, p, file_size) < 1) {
-        FREE(self->buff);
-        return FALSE;
+        D_OBJ(("Unable to seek to EOF -- %s.\n", strerror(errno)));
+        self->size = buff_inc;
+        self->len = 0;
+        self->buff = SPIF_CAST(byteptr) MALLOC(self->size);
+
+        for (p = self->buff; (cnt = read(fd, p, buff_inc)) > 0; p += buff_inc) {
+            self->len += cnt;
+            if (cnt < buff_inc) {
+                break;
+            } else {
+                self->size += buff_inc;
+                self->buff = SPIF_CAST(byteptr) REALLOC(self->buff, self->size);
+            }
+        }
+        self->size = self->len;
+        if (self->size) {
+            self->buff = SPIF_CAST(byteptr) REALLOC(self->buff, self->size);
+        } else {
+            FREE(self->buff);
+        }
+    } else {
+        self->len = self->size = file_size;
+        self->buff = SPIF_CAST(byteptr) MALLOC(self->size);
+
+        if (read(fd, p, file_size) < 1) {
+            FREE(self->buff);
+            return FALSE;
+        }
     }
     return TRUE;
 }
@@ -291,17 +342,23 @@ spif_mbuff_show(spif_mbuff_t self, spif_byteptr_t name, spif_str_t buff, size_t
     for (j = 0; j < self->len; j += 8) {
         spif_memidx_t k, l, len;
 
-        snprintf(SPIF_CHARPTR_C(tmp) + indent + 2, sizeof(tmp) - indent - 2, "%0lx    ", SPIF_CAST(long) j);
+        snprintf(SPIF_CHARPTR_C(tmp) + indent + 2, sizeof(tmp) - indent - 2, "0x%08lx    ", SPIF_CAST(long) j);
         len = strlen(SPIF_CHARPTR_C(tmp));
-        if (len + ((8 * 3) + 3 + 8 + 1) < sizeof(tmp)) {
+        if ((sizeof(tmp) - indent - 2) > 46) {
+            spif_char_t buffr[9];
+
             l = ((self->len - j < 8) ? (self->len - j) : (8));
+            memcpy(buffr, self->buff + j, l);
+            memset(buffr + l, 0, 9 - l);
             for (k = 0; k < l; k++) {
-                sprintf(SPIF_CHARPTR_C(tmp) + len, "%02x ", self->buff[j + k]);
+                sprintf(SPIF_CHARPTR_C(tmp) + 14 + (k * 3), "%02x ", self->buff[j + k]);
             }
             for (; k < 8; k++) {
-                strcat(SPIF_CHARPTR_C(tmp) + len, "   ");
+                strcat(SPIF_CHARPTR_C(tmp) + 14, "   ");
             }
-            sprintf(SPIF_CHARPTR_C(tmp) + len, "%-8s\n", spiftool_safe_str(SPIF_CAST(charptr) (self->buff + j), l));
+            sprintf(SPIF_CHARPTR_C(tmp) + 38, "%-8s\n", spiftool_safe_str(SPIF_CAST(charptr) (buffr), l));
+        } else {
+            snprintf(SPIF_CHARPTR_C(tmp) + indent + 2, sizeof(tmp) - indent - 2, "!X!");
         }
         spif_str_append_from_ptr(buff, tmp);
     }
@@ -432,7 +489,7 @@ spif_mbuff_index(spif_mbuff_t self, spif_uint8_t c)
     spif_memidx_t i;
 
     ASSERT_RVAL(!SPIF_MBUFF_ISNULL(self), (SPIF_CAST(memidx) -1));
-    for (tmp = self->buff, i = 0; (*tmp & (~c)) && (i < self->len); i++, tmp++);
+    for (tmp = self->buff, i = 0; ((int) *tmp != (int) (c)) && (i < self->len); i++, tmp++);
     return SPIF_CAST(memidx) (SPIF_CAST(long) tmp - SPIF_CAST(long) self->buff);
 }
 
@@ -534,7 +591,7 @@ spif_mbuff_splice(spif_mbuff_t self, spif_memidx_t idx, spif_memidx_t cnt, spif_
     REQUIRE_RVAL(cnt >= 0, FALSE);
     REQUIRE_RVAL(cnt <= (self->len - idx), FALSE);
 
-    newsize = self->len + ((SPIF_MBUFF_ISNULL(other)) ? (0) : (other->len)) - cnt + 1;
+    newsize = self->len + ((SPIF_MBUFF_ISNULL(other)) ? (0) : (other->len)) - cnt;
     ptmp = tmp = SPIF_CAST(byteptr) MALLOC(newsize);
     if (idx > 0) {
         memcpy(tmp, self->buff, idx);
@@ -650,11 +707,14 @@ spif_mbuff_trim(spif_mbuff_t self)
     if (start > end) {
         return spif_mbuff_done(self);
     }
-    *(++end) = 0;
-    self->len = (spif_memidx_t) (end - start);
-    self->size = self->len + 1;
-    memmove(self->buff, start, self->size);
-    self->buff = SPIF_CAST(byteptr) REALLOC(self->buff, self->size);
+    self->len = (spif_memidx_t) (end - start + 1);
+    if (start > self->buff) {
+        memmove(self->buff, start, self->len);
+    }
+    if (self->size != self->len) {
+        self->size = self->len;
+        self->buff = SPIF_CAST(byteptr) REALLOC(self->buff, self->size);
+    }
     return TRUE;
 }
 
diff --git a/src/str.c b/src/str.c
index c7e495f..ebae70e 100644
--- a/src/str.c
+++ b/src/str.c
@@ -86,7 +86,7 @@ SPIF_TYPE(class) SPIF_CLASS_VAR(str) = SPIF_CAST(class) &s_class;
 SPIF_TYPE(strclass) SPIF_STRCLASS_VAR(str) = &s_class;
 /* *INDENT-ON* */
 
-const size_t buff_inc = 4096;
+static const size_t buff_inc = 4096;
 
 spif_str_t
 spif_str_new(void)
diff --git a/src/ustr.c b/src/ustr.c
index ab24400..75239c6 100644
--- a/src/ustr.c
+++ b/src/ustr.c
@@ -30,106 +30,148 @@ static const char __attribute__((unused)) cvs_ident[] = "$Id$";
 #include <libast_internal.h>
 
 /* *INDENT-OFF* */
-static SPIF_CONST_TYPE(class) s_class = {
-    SPIF_DECL_CLASSNAME(str),
-    (spif_func_t) spif_str_new,
-    (spif_func_t) spif_str_init,
-    (spif_func_t) spif_str_done,
-    (spif_func_t) spif_str_del,
-    (spif_func_t) spif_str_show,
-    (spif_func_t) spif_str_comp,
-    (spif_func_t) spif_str_dup,
-    (spif_func_t) spif_str_type
+static SPIF_CONST_TYPE(strclass) s_class = {
+    {
+        SPIF_DECL_CLASSNAME(ustr),
+        (spif_func_t) spif_ustr_new,
+        (spif_func_t) spif_ustr_init,
+        (spif_func_t) spif_ustr_done,
+        (spif_func_t) spif_ustr_del,
+        (spif_func_t) spif_ustr_show,
+        (spif_func_t) spif_ustr_comp,
+        (spif_func_t) spif_ustr_dup,
+        (spif_func_t) spif_ustr_type
+    },
+    (spif_func_t) spif_ustr_new_from_ptr,
+    (spif_func_t) spif_ustr_new_from_buff,
+    (spif_func_t) spif_ustr_new_from_fp,
+    (spif_func_t) spif_ustr_new_from_fd,
+    (spif_func_t) spif_ustr_new_from_num,
+    (spif_func_t) spif_ustr_init_from_ptr,
+    (spif_func_t) spif_ustr_init_from_buff,
+    (spif_func_t) spif_ustr_init_from_fp,
+    (spif_func_t) spif_ustr_init_from_fd,
+    (spif_func_t) spif_ustr_init_from_num,
+    (spif_func_t) spif_ustr_append,
+    (spif_func_t) spif_ustr_append_char,
+    (spif_func_t) spif_ustr_append_from_ptr,
+    (spif_func_t) spif_ustr_casecmp,
+    (spif_func_t) spif_ustr_casecmp_with_ptr,
+    (spif_func_t) spif_ustr_clear,
+    (spif_func_t) spif_ustr_cmp,
+    (spif_func_t) spif_ustr_cmp_with_ptr,
+    (spif_func_t) spif_ustr_downcase,
+    (spif_func_t) spif_ustr_find,
+    (spif_func_t) spif_ustr_find_from_ptr,
+    (spif_func_t) spif_ustr_index,
+    (spif_func_t) spif_ustr_ncasecmp,
+    (spif_func_t) spif_ustr_ncasecmp_with_ptr,
+    (spif_func_t) spif_ustr_ncmp,
+    (spif_func_t) spif_ustr_ncmp_with_ptr,
+    (spif_func_t) spif_ustr_prepend,
+    (spif_func_t) spif_ustr_prepend_char,
+    (spif_func_t) spif_ustr_prepend_from_ptr,
+    (spif_func_t) spif_ustr_reverse,
+    (spif_func_t) spif_ustr_rindex,
+    (spif_func_t) spif_ustr_splice,
+    (spif_func_t) spif_ustr_splice_from_ptr,
+    (spif_func_t) spif_ustr_substr,
+    (spif_func_t) spif_ustr_substr_to_ptr,
+    (spif_func_t) spif_ustr_to_float,
+    (spif_func_t) spif_ustr_to_num,
+    (spif_func_t) spif_ustr_trim,
+    (spif_func_t) spif_ustr_upcase
 };
-SPIF_TYPE(class) SPIF_CLASS_VAR(str) = &s_class;
+SPIF_TYPE(class) SPIF_CLASS_VAR(ustr) = SPIF_CAST(class) &s_class;
+SPIF_TYPE(strclass) SPIF_STRCLASS_VAR(ustr) = &s_class;
 /* *INDENT-ON* */
 
 const size_t buff_inc = 4096;
 
-spif_str_t
-spif_str_new(void)
+spif_ustr_t
+spif_ustr_new(void)
 {
-    spif_str_t self;
+    spif_ustr_t self;
 
-    self = SPIF_ALLOC(str);
-    if (!spif_str_init(self)) {
+    self = SPIF_ALLOC(ustr);
+    if (!spif_ustr_init(self)) {
         SPIF_DEALLOC(self);
-        self = SPIF_NULL_TYPE(str);
+        self = SPIF_NULL_TYPE(ustr);
     }
     return self;
 }
 
-spif_str_t
-spif_str_new_from_ptr(spif_charptr_t old)
+spif_ustr_t
+spif_ustr_new_from_ptr(spif_charptr_t old)
 {
-    spif_str_t self;
+    spif_ustr_t self;
 
-    self = SPIF_ALLOC(str);
-    if (!spif_str_init_from_ptr(self, old)) {
+    self = SPIF_ALLOC(ustr);
+    if (!spif_ustr_init_from_ptr(self, old)) {
         SPIF_DEALLOC(self);
-        self = SPIF_NULL_TYPE(str);
+        self = SPIF_NULL_TYPE(ustr);
     }
     return self;
 }
 
-spif_str_t
-spif_str_new_from_buff(spif_charptr_t buff, spif_stridx_t size)
+spif_ustr_t
+spif_ustr_new_from_buff(spif_charptr_t buff, spif_ustridx_t size)
 {
-    spif_str_t self;
+    spif_ustr_t self;
 
-    self = SPIF_ALLOC(str);
-    if (!spif_str_init_from_buff(self, buff, size)) {
+    self = SPIF_ALLOC(ustr);
+    if (!spif_ustr_init_from_buff(self, buff, size)) {
         SPIF_DEALLOC(self);
-        self = SPIF_NULL_TYPE(str);
+        self = SPIF_NULL_TYPE(ustr);
     }
     return self;
 }
 
-spif_str_t
-spif_str_new_from_fp(FILE * fp)
+spif_ustr_t
+spif_ustr_new_from_fp(FILE * fp)
 {
-    spif_str_t self;
+    spif_ustr_t self;
 
-    self = SPIF_ALLOC(str);
-    if (!spif_str_init_from_fp(self, fp)) {
+    self = SPIF_ALLOC(ustr);
+    if (!spif_ustr_init_from_fp(self, fp)) {
         SPIF_DEALLOC(self);
-        self = SPIF_NULL_TYPE(str);
+        self = SPIF_NULL_TYPE(ustr);
     }
     return self;
 }
 
-spif_str_t
-spif_str_new_from_fd(int fd)
+spif_ustr_t
+spif_ustr_new_from_fd(int fd)
 {
-    spif_str_t self;
+    spif_ustr_t self;
 
-    self = SPIF_ALLOC(str);
-    if (!spif_str_init_from_fd(self, fd)) {
+    self = SPIF_ALLOC(ustr);
+    if (!spif_ustr_init_from_fd(self, fd)) {
         SPIF_DEALLOC(self);
-        self = SPIF_NULL_TYPE(str);
+        self = SPIF_NULL_TYPE(ustr);
     }
     return self;
 }
 
-spif_str_t
-spif_str_new_from_num(long num)
+spif_ustr_t
+spif_ustr_new_from_num(long num)
 {
-    spif_str_t self;
+    spif_ustr_t self;
 
-    self = SPIF_ALLOC(str);
-    if (!spif_str_init_from_num(self, num)) {
+    self = SPIF_ALLOC(ustr);
+    if (!spif_ustr_init_from_num(self, num)) {
         SPIF_DEALLOC(self);
-        self = SPIF_NULL_TYPE(str);
+        self = SPIF_NULL_TYPE(ustr);
     }
     return self;
 }
 
 spif_bool_t
-spif_str_init(spif_str_t self)
+spif_ustr_init(spif_ustr_t self)
 {
-    ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
+    ASSERT_RVAL(!SPIF_USTR_ISNULL(self), FALSE);
     /* ***NOT NEEDED*** spif_obj_init(SPIF_OBJ(self)); */
-    spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS_VAR(str));
+    spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS_VAR(ustr));
     self->s = SPIF_NULL_TYPE(charptr);
     self->len = 0;
     self->size = 0;
@@ -137,12 +179,12 @@ spif_str_init(spif_str_t self)
 }
 
 spif_bool_t
-spif_str_init_from_ptr(spif_str_t self, spif_charptr_t old)
+spif_ustr_init_from_ptr(spif_ustr_t self, spif_charptr_t old)
 {
-    ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
-    REQUIRE_RVAL((old != SPIF_NULL_TYPE(charptr)), spif_str_init(self));
+    ASSERT_RVAL(!SPIF_USTR_ISNULL(self), FALSE);
+    REQUIRE_RVAL((old != SPIF_NULL_TYPE(charptr)), spif_ustr_init(self));
     /* ***NOT NEEDED*** spif_obj_init(SPIF_OBJ(self)); */
-    spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS_VAR(str));
+    spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS_VAR(ustr));
     self->len = strlen(SPIF_CONST_CAST_C(char *) old);
     self->size = self->len + 1;
     self->s = SPIF_CAST(charptr) MALLOC(self->size);
@@ -151,11 +193,11 @@ spif_str_init_from_ptr(spif_str_t self, spif_charptr_t old)
 }
 
 spif_bool_t
-spif_str_init_from_buff(spif_str_t self, spif_charptr_t buff, spif_stridx_t size)
+spif_ustr_init_from_buff(spif_ustr_t self, spif_charptr_t buff, spif_ustridx_t size)
 {
-    ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
+    ASSERT_RVAL(!SPIF_USTR_ISNULL(self), FALSE);
     /* ***NOT NEEDED*** spif_obj_init(SPIF_OBJ(self)); */
-    spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS_VAR(str));
+    spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS_VAR(ustr));
     self->size = size;
     if (buff != SPIF_NULL_TYPE(charptr)) {
         self->len = strnlen(SPIF_CONST_CAST_C(char *) buff, size);
@@ -174,14 +216,14 @@ spif_str_init_from_buff(spif_str_t self, spif_charptr_t buff, spif_stridx_t size
 }
 
 spif_bool_t
-spif_str_init_from_fp(spif_str_t self, FILE *fp)
+spif_ustr_init_from_fp(spif_ustr_t self, FILE *fp)
 {
     spif_charptr_t p, end = NULL;
 
-    ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
+    ASSERT_RVAL(!SPIF_USTR_ISNULL(self), FALSE);
     ASSERT_RVAL((fp != SPIF_NULL_TYPE_C(FILE *)), FALSE);
     /* ***NOT NEEDED*** spif_obj_init(SPIF_OBJ(self)); */
-    spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS_VAR(str));
+    spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS_VAR(ustr));
     self->size = buff_inc;
     self->len = 0;
     self->s = SPIF_CAST(charptr) MALLOC(self->size);
@@ -196,7 +238,7 @@ spif_str_init_from_fp(spif_str_t self, FILE *fp)
             break;
         }
     }
-    self->len = (spif_stridx_t) ((end)
+    self->len = (spif_ustridx_t) ((end)
                           ? (end - self->s)
                           : ((int) strlen(SPIF_CONST_CAST_C(char *)self->s)));
     self->size = self->len + 1;
@@ -205,15 +247,15 @@ spif_str_init_from_fp(spif_str_t self, FILE *fp)
 }
 
 spif_bool_t
-spif_str_init_from_fd(spif_str_t self, int fd)
+spif_ustr_init_from_fd(spif_ustr_t self, int fd)
 {
     int n;
     spif_charptr_t p;
 
-    ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
+    ASSERT_RVAL(!SPIF_USTR_ISNULL(self), FALSE);
     ASSERT_RVAL((fd >= 0), FALSE);
     /* ***NOT NEEDED*** spif_obj_init(SPIF_OBJ(self)); */
-    spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS_VAR(str));
+    spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS_VAR(ustr));
     self->size = buff_inc;
     self->len = 0;
     self->s = SPIF_CAST(charptr) MALLOC(self->size);
@@ -231,13 +273,13 @@ spif_str_init_from_fd(spif_str_t self, int fd)
 }
 
 spif_bool_t
-spif_str_init_from_num(spif_str_t self, long num)
+spif_ustr_init_from_num(spif_ustr_t self, long num)
 {
     spif_char_t buff[28];
 
-    ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
+    ASSERT_RVAL(!SPIF_USTR_ISNULL(self), FALSE);
     /* ***NOT NEEDED*** spif_obj_init(SPIF_OBJ(self)); */
-    spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS_VAR(str));
+    spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS_VAR(ustr));
 
     snprintf(SPIF_CHARPTR_C(buff), sizeof(buff), "%ld", num);
     self->len = strlen(SPIF_CHARPTR_C(buff));
@@ -249,9 +291,9 @@ spif_str_init_from_num(spif_str_t self, long num)
 }
 
 spif_bool_t
-spif_str_done(spif_str_t self)
+spif_ustr_done(spif_ustr_t self)
 {
-    ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
+    ASSERT_RVAL(!SPIF_USTR_ISNULL(self), FALSE);
     if (self->size) {
         FREE(self->s);
         self->len = 0;
@@ -262,35 +304,35 @@ spif_str_done(spif_str_t self)
 }
 
 spif_bool_t
-spif_str_del(spif_str_t self)
+spif_ustr_del(spif_ustr_t self)
 {
-    ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
-    spif_str_done(self);
+    ASSERT_RVAL(!SPIF_USTR_ISNULL(self), FALSE);
+    spif_ustr_done(self);
     SPIF_DEALLOC(self);
     return TRUE;
 }
 
 spif_str_t
-spif_str_show(spif_str_t self, spif_charptr_t name, spif_str_t buff, size_t indent)
+spif_ustr_show(spif_ustr_t self, spif_charptr_t name, spif_str_t buff, size_t indent)
 {
     spif_char_t tmp[4096];
 
-    if (SPIF_STR_ISNULL(self)) {
-        SPIF_OBJ_SHOW_NULL(str, name, buff, indent, tmp);
+    if (SPIF_USTR_ISNULL(self)) {
+        SPIF_OBJ_SHOW_NULL(ustr, name, buff, indent, tmp);
         return buff;
     }
 
     memset(tmp, ' ', indent);
     snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent,
-             "(spif_str_t) %s:  %10p { \"",
+             "(spif_ustr_t) %s:  %10p { \"",
              name, SPIF_CAST(ptr) self);
-    if (SPIF_STR_ISNULL(buff)) {
+    if (SPIF_USTR_ISNULL(buff)) {
         buff = spif_str_new_from_ptr(tmp);
     } else {
         spif_str_append_from_ptr(buff, tmp);
     }
 
-    spif_str_append(buff, self);
+    /*spif_str_append(buff, self);*/
 
     snprintf(SPIF_CHARPTR_C(tmp), sizeof(tmp), "\", len %lu, size %lu }\n", (unsigned long) self->len,
              (unsigned long) self->size);
@@ -299,50 +341,50 @@ spif_str_show(spif_str_t self, spif_charptr_t name, spif_str_t buff, size_t inde
 }
 
 spif_cmp_t
-spif_str_comp(spif_str_t self, spif_str_t other)
+spif_ustr_comp(spif_ustr_t self, spif_ustr_t other)
 {
-    return spif_str_cmp(self, other);
+    return spif_ustr_cmp(self, other);
 }
 
-spif_str_t
-spif_str_dup(spif_str_t self)
+spif_ustr_t
+spif_ustr_dup(spif_ustr_t self)
 {
-    spif_str_t tmp;
+    spif_ustr_t tmp;
 
-    ASSERT_RVAL(!SPIF_STR_ISNULL(self), SPIF_NULL_TYPE(str));
-    tmp = SPIF_ALLOC(str);
-    memcpy(tmp, self, SPIF_SIZEOF_TYPE(str));
-    tmp->s = SPIF_CAST(charptr) STRDUP(SPIF_CONST_CAST_C(char *) SPIF_STR_STR(self));
+    ASSERT_RVAL(!SPIF_USTR_ISNULL(self), SPIF_NULL_TYPE(ustr));
+    tmp = SPIF_ALLOC(ustr);
+    memcpy(tmp, self, SPIF_SIZEOF_TYPE(ustr));
+    tmp->s = SPIF_CAST(charptr) STRDUP(SPIF_CONST_CAST_C(char *) SPIF_USTR_STR(self));
     tmp->len = self->len;
     tmp->size = self->size;
     return tmp;
 }
 
 spif_classname_t
-spif_str_type(spif_str_t self)
+spif_ustr_type(spif_ustr_t self)
 {
-    ASSERT_RVAL(!SPIF_STR_ISNULL(self), SPIF_CAST(classname) SPIF_NULLSTR_TYPE(classname));
+    ASSERT_RVAL(!SPIF_USTR_ISNULL(self), SPIF_CAST(classname) SPIF_NULLSTR_TYPE(classname));
     return SPIF_OBJ_CLASSNAME(self);
 }
 
 spif_bool_t
-spif_str_append(spif_str_t self, spif_str_t other)
+spif_ustr_append(spif_ustr_t self, spif_ustr_t other)
 {
-    ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
-    REQUIRE_RVAL(!SPIF_STR_ISNULL(other), FALSE);
+    ASSERT_RVAL(!SPIF_USTR_ISNULL(self), FALSE);
+    REQUIRE_RVAL(!SPIF_USTR_ISNULL(other), FALSE);
     if (other->size && other->len) {
         self->size += other->size - 1;
         self->s = SPIF_CAST(charptr) REALLOC(self->s, self->size);
-        memcpy(self->s + self->len, SPIF_STR_STR(other), other->len + 1);
+        memcpy(self->s + self->len, SPIF_USTR_STR(other), other->len + 1);
         self->len += other->len;
     }
     return TRUE;
 }
 
 spif_bool_t
-spif_str_append_char(spif_str_t self, spif_char_t c)
+spif_ustr_append_char(spif_ustr_t self, spif_char_t c)
 {
-    ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
+    ASSERT_RVAL(!SPIF_USTR_ISNULL(self), FALSE);
     self->len++;
     if (self->size <= self->len) {
         self->size++;
@@ -354,11 +396,11 @@ spif_str_append_char(spif_str_t self, spif_char_t c)
 }
 
 spif_bool_t
-spif_str_append_from_ptr(spif_str_t self, spif_charptr_t other)
+spif_ustr_append_from_ptr(spif_ustr_t self, spif_charptr_t other)
 {
-    spif_stridx_t len;
+    spif_ustridx_t len;
 
-    ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
+    ASSERT_RVAL(!SPIF_USTR_ISNULL(self), FALSE);
     REQUIRE_RVAL((other != SPIF_NULL_TYPE(charptr)), FALSE);
     len = strlen(SPIF_CONST_CAST_C(char *) other);
     if (len) {
@@ -371,171 +413,171 @@ spif_str_append_from_ptr(spif_str_t self, spif_charptr_t other)
 }
 
 spif_cmp_t
-spif_str_casecmp(spif_str_t self, spif_str_t other)
+spif_ustr_casecmp(spif_ustr_t self, spif_ustr_t other)
 {
     int c;
 
     SPIF_OBJ_COMP_CHECK_NULL(self, other);
-    c = strcasecmp(SPIF_CHARPTR_C(SPIF_STR_STR(self)), SPIF_CHARPTR_C(SPIF_STR_STR(other)));
+    c = strcasecmp(SPIF_CHARPTR_C(SPIF_USTR_STR(self)), SPIF_CHARPTR_C(SPIF_USTR_STR(other)));
     return SPIF_CMP_FROM_INT(c);
 }
 
 spif_cmp_t
-spif_str_casecmp_with_ptr(spif_str_t self, spif_charptr_t other)
+spif_ustr_casecmp_with_ptr(spif_ustr_t self, spif_charptr_t other)
 {
     int c;
 
     SPIF_OBJ_COMP_CHECK_NULL(self, other);
-    c = strcasecmp(SPIF_CHARPTR_C(SPIF_STR_STR(self)), SPIF_CHARPTR_C(other));
+    c = strcasecmp(SPIF_CHARPTR_C(SPIF_USTR_STR(self)), SPIF_CHARPTR_C(other));
     return SPIF_CMP_FROM_INT(c);
 }
 
 spif_bool_t
-spif_str_clear(spif_str_t self, spif_char_t c)
+spif_ustr_clear(spif_ustr_t self, spif_char_t c)
 {
-    ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
+    ASSERT_RVAL(!SPIF_USTR_ISNULL(self), FALSE);
     memset(self->s, c, self->size);
     self->s[self->len] = 0;
     return TRUE;
 }
 
 spif_cmp_t
-spif_str_cmp(spif_str_t self, spif_str_t other)
+spif_ustr_cmp(spif_ustr_t self, spif_ustr_t other)
 {
     int c;
 
     SPIF_OBJ_COMP_CHECK_NULL(self, other);
-    c = strcmp(SPIF_CHARPTR_C(SPIF_STR_STR(self)), SPIF_CHARPTR_C(SPIF_STR_STR(other)));
+    c = strcmp(SPIF_CHARPTR_C(SPIF_USTR_STR(self)), SPIF_CHARPTR_C(SPIF_USTR_STR(other)));
     return SPIF_CMP_FROM_INT(c);
 }
 
 spif_cmp_t
-spif_str_cmp_with_ptr(spif_str_t self, spif_charptr_t other)
+spif_ustr_cmp_with_ptr(spif_ustr_t self, spif_charptr_t other)
 {
     int c;
 
     SPIF_OBJ_COMP_CHECK_NULL(self, other);
-    c = strcmp(SPIF_CHARPTR_C(SPIF_STR_STR(self)), SPIF_CHARPTR_C(other));
+    c = strcmp(SPIF_CHARPTR_C(SPIF_USTR_STR(self)), SPIF_CHARPTR_C(other));
     return SPIF_CMP_FROM_INT(c);
 }
 
 spif_bool_t
-spif_str_downcase(spif_str_t self)
+spif_ustr_downcase(spif_ustr_t self)
 {
     spif_charptr_t tmp;
 
-    ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
+    ASSERT_RVAL(!SPIF_USTR_ISNULL(self), FALSE);
     for (tmp = self->s; *tmp; tmp++) {
         *tmp = tolower(*tmp);
     }
     return TRUE;
 }
 
-spif_stridx_t
-spif_str_find(spif_str_t self, spif_str_t other)
+spif_ustridx_t
+spif_ustr_find(spif_ustr_t self, spif_ustr_t other)
 {
     char *tmp;
 
-    ASSERT_RVAL(!SPIF_STR_ISNULL(self), (SPIF_CAST(stridx) -1));
-    REQUIRE_RVAL(!SPIF_STR_ISNULL(other), (SPIF_CAST(stridx) -1));
-    tmp = strstr(SPIF_CONST_CAST_C(char *) SPIF_STR_STR(self),
-                 SPIF_CONST_CAST_C(char *) SPIF_STR_STR(other));
+    ASSERT_RVAL(!SPIF_USTR_ISNULL(self), (SPIF_CAST(stridx) -1));
+    REQUIRE_RVAL(!SPIF_USTR_ISNULL(other), (SPIF_CAST(stridx) -1));
+    tmp = strstr(SPIF_CONST_CAST_C(char *) SPIF_USTR_STR(self),
+                 SPIF_CONST_CAST_C(char *) SPIF_USTR_STR(other));
     if (tmp) {
-        return SPIF_CAST(stridx) (SPIF_CAST(long) tmp - SPIF_CAST(long) (SPIF_STR_STR(self)));
+        return SPIF_CAST(stridx) (SPIF_CAST(long) tmp - SPIF_CAST(long) (SPIF_USTR_STR(self)));
     } else {
         return SPIF_CAST(stridx) (self->len);
     }
 }
 
-spif_stridx_t
-spif_str_find_from_ptr(spif_str_t self, spif_charptr_t other)
+spif_ustridx_t
+spif_ustr_find_from_ptr(spif_ustr_t self, spif_charptr_t other)
 {
     char *tmp;
 
-    ASSERT_RVAL(!SPIF_STR_ISNULL(self), (SPIF_CAST(stridx) -1));
+    ASSERT_RVAL(!SPIF_USTR_ISNULL(self), (SPIF_CAST(stridx) -1));
     REQUIRE_RVAL((other != SPIF_NULL_TYPE(charptr)), (SPIF_CAST(stridx) -1));
-    tmp = strstr(SPIF_CONST_CAST_C(char *) SPIF_STR_STR(self),
+    tmp = strstr(SPIF_CONST_CAST_C(char *) SPIF_USTR_STR(self),
                  SPIF_CONST_CAST_C(char *) other);
     if (tmp) {
-        return SPIF_CAST(stridx) (SPIF_CAST(long) tmp - SPIF_CAST(long) (SPIF_STR_STR(self)));
+        return SPIF_CAST(stridx) (SPIF_CAST(long) tmp - SPIF_CAST(long) (SPIF_USTR_STR(self)));
     } else {
         return SPIF_CAST(stridx) (self->len);
     }
 }
 
-spif_stridx_t
-spif_str_index(spif_str_t self, spif_char_t c)
+spif_ustridx_t
+spif_ustr_index(spif_ustr_t self, spif_char_t c)
 {
     char *tmp;
 
-    ASSERT_RVAL(!SPIF_STR_ISNULL(self), (SPIF_CAST(stridx) -1));
-    tmp = index(SPIF_CONST_CAST_C(char *) SPIF_STR_STR(self), c);
+    ASSERT_RVAL(!SPIF_USTR_ISNULL(self), (SPIF_CAST(stridx) -1));
+    tmp = index(SPIF_CONST_CAST_C(char *) SPIF_USTR_STR(self), c);
     if (tmp) {
-        return SPIF_CAST(stridx) (SPIF_CAST(long) tmp - SPIF_CAST(long) (SPIF_STR_STR(self)));
+        return SPIF_CAST(stridx) (SPIF_CAST(long) tmp - SPIF_CAST(long) (SPIF_USTR_STR(self)));
     } else {
         return SPIF_CAST(stridx) (self->len);
     }
 }
 
 spif_cmp_t
-spif_str_ncasecmp(spif_str_t self, spif_str_t other, spif_stridx_t cnt)
+spif_ustr_ncasecmp(spif_ustr_t self, spif_ustr_t other, spif_ustridx_t cnt)
 {
     int c;
 
     SPIF_OBJ_COMP_CHECK_NULL(self, other);
-    c = strncasecmp(SPIF_CHARPTR_C(SPIF_STR_STR(self)), SPIF_CHARPTR_C(SPIF_STR_STR(other)), cnt);
+    c = strncasecmp(SPIF_CHARPTR_C(SPIF_USTR_STR(self)), SPIF_CHARPTR_C(SPIF_USTR_STR(other)), cnt);
     return SPIF_CMP_FROM_INT(c);
 }
 
 spif_cmp_t
-spif_str_ncasecmp_with_ptr(spif_str_t self, spif_charptr_t other, spif_stridx_t cnt)
+spif_ustr_ncasecmp_with_ptr(spif_ustr_t self, spif_charptr_t other, spif_ustridx_t cnt)
 {
     int c;
 
     SPIF_OBJ_COMP_CHECK_NULL(self, other);
-    c = strncasecmp(SPIF_CHARPTR_C(SPIF_STR_STR(self)), SPIF_CHARPTR_C(other), cnt);
+    c = strncasecmp(SPIF_CHARPTR_C(SPIF_USTR_STR(self)), SPIF_CHARPTR_C(other), cnt);
     return SPIF_CMP_FROM_INT(c);
 }
 
 spif_cmp_t
-spif_str_ncmp(spif_str_t self, spif_str_t other, spif_stridx_t cnt)
+spif_ustr_ncmp(spif_ustr_t self, spif_ustr_t other, spif_ustridx_t cnt)
 {
     int c;
 
     SPIF_OBJ_COMP_CHECK_NULL(self, other);
-    c = strncmp(SPIF_CHARPTR_C(SPIF_STR_STR(self)), SPIF_CHARPTR_C(SPIF_STR_STR(other)), cnt);
+    c = strncmp(SPIF_CHARPTR_C(SPIF_USTR_STR(self)), SPIF_CHARPTR_C(SPIF_USTR_STR(other)), cnt);
     return SPIF_CMP_FROM_INT(c);
 }
 
 spif_cmp_t
-spif_str_ncmp_with_ptr(spif_str_t self, spif_charptr_t other, spif_stridx_t cnt)
+spif_ustr_ncmp_with_ptr(spif_ustr_t self, spif_charptr_t other, spif_ustridx_t cnt)
 {
     int c;
 
     SPIF_OBJ_COMP_CHECK_NULL(self, other);
-    c = strncmp(SPIF_CHARPTR_C(SPIF_STR_STR(self)), SPIF_CHARPTR_C(other), cnt);
+    c = strncmp(SPIF_CHARPTR_C(SPIF_USTR_STR(self)), SPIF_CHARPTR_C(other), cnt);
     return SPIF_CMP_FROM_INT(c);
 }
 
 spif_bool_t
-spif_str_prepend(spif_str_t self, spif_str_t other)
+spif_ustr_prepend(spif_ustr_t self, spif_ustr_t other)
 {
-    ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
-    REQUIRE_RVAL(!SPIF_STR_ISNULL(other), FALSE);
+    ASSERT_RVAL(!SPIF_USTR_ISNULL(self), FALSE);
+    REQUIRE_RVAL(!SPIF_USTR_ISNULL(other), FALSE);
     if (other->size && other->len) {
         self->size += other->size - 1;
         self->s = SPIF_CAST(charptr) REALLOC(self->s, self->size);
         memmove(self->s + other->len, self->s, self->len + 1);
-        memcpy(self->s, SPIF_STR_STR(other), other->len);
+        memcpy(self->s, SPIF_USTR_STR(other), other->len);
         self->len += other->len;
     }
     return TRUE;
 }
 
 spif_bool_t
-spif_str_prepend_char(spif_str_t self, spif_char_t c)
+spif_ustr_prepend_char(spif_ustr_t self, spif_char_t c)
 {
-    ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
+    ASSERT_RVAL(!SPIF_USTR_ISNULL(self), FALSE);
     self->len++;
     if (self->size <= self->len) {
         self->size++;
@@ -547,11 +589,11 @@ spif_str_prepend_char(spif_str_t self, spif_char_t c)
 }
 
 spif_bool_t
-spif_str_prepend_from_ptr(spif_str_t self, spif_charptr_t other)
+spif_ustr_prepend_from_ptr(spif_ustr_t self, spif_charptr_t other)
 {
-    spif_stridx_t len;
+    spif_ustridx_t len;
 
-    ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
+    ASSERT_RVAL(!SPIF_USTR_ISNULL(self), FALSE);
     REQUIRE_RVAL((other != SPIF_NULL_TYPE(charptr)), FALSE);
     len = strlen(SPIF_CONST_CAST_C(char *) other);
     if (len) {
@@ -565,33 +607,33 @@ spif_str_prepend_from_ptr(spif_str_t self, spif_charptr_t other)
 }
 
 spif_bool_t
-spif_str_reverse(spif_str_t self)
+spif_ustr_reverse(spif_ustr_t self)
 {
-    ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
+    ASSERT_RVAL(!SPIF_USTR_ISNULL(self), FALSE);
     return ((strrev(SPIF_CAST_C(char *) self->s)) ? TRUE : FALSE);
 }
 
-spif_stridx_t
-spif_str_rindex(spif_str_t self, spif_char_t c)
+spif_ustridx_t
+spif_ustr_rindex(spif_ustr_t self, spif_char_t c)
 {
     char *tmp;
 
-    ASSERT_RVAL(!SPIF_STR_ISNULL(self), (SPIF_CAST(stridx) -1));
-    tmp = rindex(SPIF_CONST_CAST_C(char *) SPIF_STR_STR(self), c);
+    ASSERT_RVAL(!SPIF_USTR_ISNULL(self), (SPIF_CAST(stridx) -1));
+    tmp = rindex(SPIF_CONST_CAST_C(char *) SPIF_USTR_STR(self), c);
     if (tmp) {
-        return SPIF_CAST(stridx) (SPIF_CAST(long) tmp - SPIF_CAST(long) (SPIF_STR_STR(self)));
+        return SPIF_CAST(stridx) (SPIF_CAST(long) tmp - SPIF_CAST(long) (SPIF_USTR_STR(self)));
     } else {
         return SPIF_CAST(stridx) (self->len);
     }
 }
 
 spif_bool_t
-spif_str_splice(spif_str_t self, spif_stridx_t idx, spif_stridx_t cnt, spif_str_t other)
+spif_ustr_splice(spif_ustr_t self, spif_ustridx_t idx, spif_ustridx_t cnt, spif_ustr_t other)
 {
     spif_charptr_t tmp, ptmp;
-    spif_stridx_t newsize;
+    spif_ustridx_t newsize;
 
-    ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
+    ASSERT_RVAL(!SPIF_USTR_ISNULL(self), FALSE);
     if (idx < 0) {
         idx = self->len + idx;
     }
@@ -603,7 +645,7 @@ spif_str_splice(spif_str_t self, spif_stridx_t idx, spif_stridx_t cnt, spif_str_
     REQUIRE_RVAL(cnt >= 0, FALSE);
     REQUIRE_RVAL(cnt <= (self->len - idx), FALSE);
 
-    newsize = self->len + ((SPIF_STR_ISNULL(other)) ? (0) : (other->len)) - cnt + 1;
+    newsize = self->len + ((SPIF_USTR_ISNULL(other)) ? (0) : (other->len)) - cnt + 1;
     ptmp = tmp = SPIF_CAST(charptr) MALLOC(newsize);
     if (idx > 0) {
         memcpy(tmp, self->s, idx);
@@ -625,12 +667,12 @@ spif_str_splice(spif_str_t self, spif_stridx_t idx, spif_stridx_t cnt, spif_str_
 }
 
 spif_bool_t
-spif_str_splice_from_ptr(spif_str_t self, spif_stridx_t idx, spif_stridx_t cnt, spif_charptr_t other)
+spif_ustr_splice_from_ptr(spif_ustr_t self, spif_ustridx_t idx, spif_ustridx_t cnt, spif_charptr_t other)
 {
     spif_charptr_t tmp, ptmp;
-    spif_stridx_t len, newsize;
+    spif_ustridx_t len, newsize;
 
-    ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
+    ASSERT_RVAL(!SPIF_USTR_ISNULL(self), FALSE);
     len = (other ? strlen(SPIF_CONST_CAST_C(char *) other) : 0);
     if (idx < 0) {
         idx = self->len + idx;
@@ -664,29 +706,29 @@ spif_str_splice_from_ptr(spif_str_t self, spif_stridx_t idx, spif_stridx_t cnt,
     return TRUE;
 }
 
-spif_str_t
-spif_str_substr(spif_str_t self, spif_stridx_t idx, spif_stridx_t cnt)
+spif_ustr_t
+spif_ustr_substr(spif_ustr_t self, spif_ustridx_t idx, spif_ustridx_t cnt)
 {
-    ASSERT_RVAL(!SPIF_STR_ISNULL(self), SPIF_NULL_TYPE(str));
+    ASSERT_RVAL(!SPIF_USTR_ISNULL(self), SPIF_NULL_TYPE(ustr));
     if (idx < 0) {
         idx = self->len + idx;
     }
-    REQUIRE_RVAL(idx >= 0, SPIF_NULL_TYPE(str));
-    REQUIRE_RVAL(idx < self->len, SPIF_NULL_TYPE(str));
+    REQUIRE_RVAL(idx >= 0, SPIF_NULL_TYPE(ustr));
+    REQUIRE_RVAL(idx < self->len, SPIF_NULL_TYPE(ustr));
     if (cnt <= 0) {
         cnt = self->len - idx + cnt;
     }
-    REQUIRE_RVAL(cnt >= 0, SPIF_NULL_TYPE(str));
+    REQUIRE_RVAL(cnt >= 0, SPIF_NULL_TYPE(ustr));
     UPPER_BOUND(cnt, self->len - idx);
-    return spif_str_new_from_buff(SPIF_STR_STR(self) + idx, cnt);
+    return spif_ustr_new_from_buff(SPIF_USTR_STR(self) + idx, cnt);
 }
 
 spif_charptr_t
-spif_str_substr_to_ptr(spif_str_t self, spif_stridx_t idx, spif_stridx_t cnt)
+spif_ustr_substr_to_ptr(spif_ustr_t self, spif_ustridx_t idx, spif_ustridx_t cnt)
 {
     spif_charptr_t newstr;
 
-    ASSERT_RVAL(!SPIF_STR_ISNULL(self), SPIF_NULL_TYPE(charptr));
+    ASSERT_RVAL(!SPIF_USTR_ISNULL(self), SPIF_NULL_TYPE(charptr));
     if (idx < 0) {
         idx = self->len + idx;
     }
@@ -699,40 +741,40 @@ spif_str_substr_to_ptr(spif_str_t self, spif_stridx_t idx, spif_stridx_t cnt)
     UPPER_BOUND(cnt, self->len - idx);
 
     newstr = SPIF_CAST(charptr) MALLOC(cnt + 1);
-    memcpy(newstr, SPIF_STR_STR(self) + idx, cnt);
+    memcpy(newstr, SPIF_USTR_STR(self) + idx, cnt);
     newstr[cnt] = 0;
     return newstr;
 }
 
 double
-spif_str_to_float(spif_str_t self)
+spif_ustr_to_float(spif_ustr_t self)
 {
-    ASSERT_RVAL(!SPIF_STR_ISNULL(self), SPIF_CAST_C(double) NAN);
-    return (double) (strtod(SPIF_CONST_CAST_C(char *)SPIF_STR_STR(self), (char **) NULL));
+    ASSERT_RVAL(!SPIF_USTR_ISNULL(self), SPIF_CAST_C(double) NAN);
+    return (double) (strtod(SPIF_CONST_CAST_C(char *)SPIF_USTR_STR(self), (char **) NULL));
 }
 
 size_t
-spif_str_to_num(spif_str_t self, int base)
+spif_ustr_to_num(spif_ustr_t self, int base)
 {
-    ASSERT_RVAL(!SPIF_STR_ISNULL(self), (SPIF_CAST_C(size_t) -1));
-    return (size_t) (strtoul(SPIF_CONST_CAST_C(char *) SPIF_STR_STR(self), (char **) NULL, base));
+    ASSERT_RVAL(!SPIF_USTR_ISNULL(self), (SPIF_CAST_C(size_t) -1));
+    return (size_t) (strtoul(SPIF_CONST_CAST_C(char *) SPIF_USTR_STR(self), (char **) NULL, base));
 }
 
 spif_bool_t
-spif_str_trim(spif_str_t self)
+spif_ustr_trim(spif_ustr_t self)
 {
     spif_charptr_t start, end;
 
-    ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
+    ASSERT_RVAL(!SPIF_USTR_ISNULL(self), FALSE);
     start = self->s;
     end = self->s + self->len - 1;
     for (; isspace((spif_uchar_t) (*start)) && (start < end); start++);
     for (; isspace((spif_uchar_t) (*end)) && (start < end); end--);
     if (start > end) {
-        return spif_str_done(self);
+        return spif_ustr_done(self);
     }
     *(++end) = 0;
-    self->len = (spif_stridx_t) (end - start);
+    self->len = (spif_ustridx_t) (end - start);
     self->size = self->len + 1;
     memmove(self->s, start, self->size);
     self->s = SPIF_CAST(charptr) REALLOC(self->s, self->size);
@@ -740,16 +782,16 @@ spif_str_trim(spif_str_t self)
 }
 
 spif_bool_t
-spif_str_upcase(spif_str_t self)
+spif_ustr_upcase(spif_ustr_t self)
 {
     spif_charptr_t tmp;
 
-    ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
+    ASSERT_RVAL(!SPIF_USTR_ISNULL(self), FALSE);
     for (tmp = self->s; *tmp; tmp++) {
         *tmp = toupper(*tmp);
     }
     return TRUE;
 }
 
-SPIF_DEFINE_PROPERTY_FUNC_C(str, spif_stridx_t, size)
-SPIF_DEFINE_PROPERTY_FUNC_C(str, spif_stridx_t, len)
+SPIF_DEFINE_PROPERTY_FUNC_C(ustr, spif_ustridx_t, size)
+SPIF_DEFINE_PROPERTY_FUNC_C(ustr, spif_ustridx_t, len)
diff --git a/test/test.c b/test/test.c
index c720cbf..4c8815c 100644
--- a/test/test.c
+++ b/test/test.c
@@ -41,6 +41,8 @@ int test_options(void);
 int test_obj(void);
 int test_str(void);
 int test_tok(void);
+int test_mbuff(void);
+int test_ustr(void);
 int test_url(void);
 int test_list(void);
 int test_vector(void);
@@ -1002,6 +1004,475 @@ test_tok(void)
 }
 
 int
+test_mbuff(void)
+{
+    spif_mbuff_t testmbuff, test2mbuff;
+    spif_mbuffclass_t cls;
+    char tmp[] = "this is a test";
+    spif_char_t buff[4096] = "abcde";
+    char tmp2[] = "string #1\nstring #2";
+    FILE *fp;
+    int fd, mypipe[2];
+    spif_charptr_t foo;
+
+    TEST_BEGIN("spif_mbuff_new() function");
+    testmbuff = spif_mbuff_new();
+    TEST_FAIL_IF(SPIF_MBUFF_ISNULL(testmbuff));
+    TEST_PASS();
+
+    TEST_BEGIN("spif_obj_get_classname() function");
+    cls = SPIF_MBUFF_CLASS(spif_obj_get_class(SPIF_OBJ(testmbuff)));
+    TEST_FAIL_IF(cls != SPIF_MBUFF_CLASS(SPIF_MBUFFCLASS_VAR(mbuff)));
+    TEST_PASS();
+
+    TEST_BEGIN("spif_mbuff_del() function");
+    TEST_FAIL_IF(spif_mbuff_del(testmbuff) != TRUE);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_mbuff_new_from_ptr() function");
+    testmbuff = spif_mbuff_new_from_ptr(SPIF_CHARPTR(tmp), sizeof(tmp));
+    TEST_FAIL_IF(spif_mbuff_cmp_with_ptr(testmbuff, SPIF_CHARPTR(tmp), sizeof(tmp)));
+    TEST_FAIL_IF(spif_mbuff_get_size(testmbuff) != sizeof(tmp));
+    TEST_FAIL_IF(spif_mbuff_get_len(testmbuff) != (sizeof(tmp)));
+    spif_mbuff_del(testmbuff);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_mbuff_new_from_buff() function");
+    testmbuff = spif_mbuff_new_from_buff(buff, sizeof(buff), 10240);
+    TEST_FAIL_IF(spif_mbuff_cmp_with_ptr(testmbuff, buff, sizeof(buff)));
+    TEST_FAIL_IF(spif_mbuff_get_size(testmbuff) != 10240);
+    TEST_FAIL_IF(spif_mbuff_get_len(testmbuff) != sizeof(buff));
+    spif_mbuff_del(testmbuff);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_mbuff_new_from_fp() function");
+    pipe(mypipe);
+    fd = mypipe[0];
+    fp = fdopen(fd, "r");
+    write(mypipe[1], tmp2, sizeof(tmp2));
+    close(mypipe[1]);
+    TEST_FAIL_IF(fp == NULL);
+    testmbuff = spif_mbuff_new_from_fp(fp);
+    TEST_FAIL_IF(spif_mbuff_cmp_with_ptr(testmbuff, tmp2, sizeof(tmp2)));
+    TEST_FAIL_IF(spif_mbuff_get_len(testmbuff) != sizeof(tmp2));
+    TEST_FAIL_IF(spif_mbuff_get_size(testmbuff) != sizeof(tmp2));
+    spif_mbuff_del(testmbuff);
+    fclose(fp);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_mbuff_new_from_fd() function");
+    pipe(mypipe);
+    fd = mypipe[0];
+    write(mypipe[1], tmp2, sizeof(tmp2));
+    close(mypipe[1]);
+    testmbuff = spif_mbuff_new_from_fd(fd);
+    TEST_FAIL_IF(memcmp(SPIF_MBUFF_BUFF(testmbuff), tmp2, sizeof(tmp2)));
+    TEST_FAIL_IF(spif_mbuff_get_len(testmbuff) != sizeof(tmp2));
+    TEST_FAIL_IF(spif_mbuff_get_size(testmbuff) != sizeof(tmp2));
+    spif_mbuff_del(testmbuff);
+    close(fd);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_mbuff_dup() function");
+    testmbuff = spif_mbuff_new_from_ptr(SPIF_CHARPTR(tmp), sizeof(tmp));
+    TEST_FAIL_IF(memcmp(SPIF_MBUFF_BUFF(testmbuff), tmp, sizeof(tmp)));
+    TEST_FAIL_IF(spif_mbuff_get_size(testmbuff) != sizeof(tmp));
+    TEST_FAIL_IF(spif_mbuff_get_len(testmbuff) != sizeof(tmp));
+    test2mbuff = spif_mbuff_dup(testmbuff);
+    TEST_FAIL_IF(test2mbuff == testmbuff);
+    TEST_FAIL_IF(SPIF_MBUFF_BUFF(test2mbuff) == SPIF_MBUFF_BUFF(testmbuff));
+    TEST_FAIL_IF(spif_mbuff_cmp(testmbuff, test2mbuff));
+    TEST_FAIL_IF(memcmp(SPIF_CHARPTR_C(SPIF_MBUFF_BUFF(test2mbuff)), tmp, strlen(tmp)));
+    TEST_FAIL_IF(spif_mbuff_get_size(test2mbuff) != sizeof(tmp));
+    TEST_FAIL_IF(spif_mbuff_get_len(test2mbuff) != sizeof(tmp));
+    spif_mbuff_del(testmbuff);
+    spif_mbuff_del(test2mbuff);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_mbuff_index() function");
+    testmbuff = spif_mbuff_new_from_ptr(SPIF_CHARPTR(tmp2), strlen(tmp2));
+    TEST_FAIL_IF(spif_mbuff_index(testmbuff, '#') != 7);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_mbuff_rindex() function");
+    TEST_FAIL_IF(spif_mbuff_rindex(testmbuff, '#') != 17);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_mbuff_find() function");
+    test2mbuff = spif_mbuff_new_from_ptr(SPIF_CHARPTR("ring"), 4);
+    TEST_FAIL_IF(spif_mbuff_find(testmbuff, test2mbuff) != 2);
+    spif_mbuff_del(test2mbuff);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_mbuff_find_from_ptr() function");
+    TEST_FAIL_IF(spif_mbuff_find_from_ptr(testmbuff, SPIF_CHARPTR("in"), 2) != 3);
+    spif_mbuff_del(testmbuff);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_mbuff_subbuff() function");
+    testmbuff = spif_mbuff_new_from_ptr(SPIF_CHARPTR(tmp), strlen(tmp));
+    test2mbuff = spif_mbuff_subbuff(testmbuff, 2, 6);
+    TEST_FAIL_IF(spif_mbuff_cmp_with_ptr(test2mbuff, "is is", 5));
+    TEST_FAIL_IF(spif_mbuff_get_size(test2mbuff) != 6);
+    TEST_FAIL_IF(spif_mbuff_get_len(test2mbuff) != 6);
+    spif_mbuff_del(test2mbuff);
+    test2mbuff = spif_mbuff_subbuff(testmbuff, -4, 4);
+    TEST_FAIL_IF(spif_mbuff_cmp_with_ptr(test2mbuff, SPIF_CHARPTR("test"), 4));
+    TEST_FAIL_IF(spif_mbuff_get_size(test2mbuff) != 4);
+    TEST_FAIL_IF(spif_mbuff_get_len(test2mbuff) != 4);
+    spif_mbuff_del(test2mbuff);
+    spif_mbuff_del(testmbuff);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_mbuff_subbuff_to_ptr() function");
+    testmbuff = spif_mbuff_new_from_ptr(SPIF_CHARPTR(tmp), strlen(tmp));
+    foo = spif_mbuff_subbuff_to_ptr(testmbuff, 2, 5);
+    TEST_FAIL_IF(foo == NULL);
+    TEST_FAIL_IF(memcmp(SPIF_CHARPTR_C(foo), "is is", 5));
+    FREE(foo);
+    foo = spif_mbuff_subbuff_to_ptr(testmbuff, -4, 4);
+    TEST_FAIL_IF(foo == NULL);
+    TEST_FAIL_IF(memcmp(SPIF_CHARPTR_C(foo), "test", 5));
+    FREE(foo);
+    spif_mbuff_del(testmbuff);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_mbuff_append() function");
+    testmbuff = spif_mbuff_new_from_ptr(SPIF_CHARPTR("copy"), 4);
+    test2mbuff = spif_mbuff_new_from_ptr(SPIF_CHARPTR("cat"), 3);
+    spif_mbuff_append(testmbuff, test2mbuff);
+    TEST_FAIL_IF(spif_mbuff_cmp_with_ptr(testmbuff, SPIF_CHARPTR("copycat"), 7));
+    TEST_FAIL_IF(spif_mbuff_get_size(testmbuff) != 7);
+    TEST_FAIL_IF(spif_mbuff_get_len(testmbuff) != 7);
+    spif_mbuff_del(test2mbuff);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_mbuff_append_from_ptr() function");
+    spif_mbuff_append_from_ptr(testmbuff, SPIF_CHARPTR("crime"), 5);
+    TEST_FAIL_IF(spif_mbuff_cmp_with_ptr(testmbuff, SPIF_CHARPTR("copycatcrime"), 12));
+    TEST_FAIL_IF(spif_mbuff_get_size(testmbuff) != 12);
+    TEST_FAIL_IF(spif_mbuff_get_len(testmbuff) != 12);
+    spif_mbuff_del(testmbuff);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_mbuff_clear() function");
+    testmbuff = spif_mbuff_new_from_ptr(SPIF_CHARPTR("abcdefg"), 7);
+    spif_mbuff_clear(testmbuff, 'x');
+    TEST_FAIL_IF(spif_mbuff_cmp_with_ptr(testmbuff, "xxxxxxx", 7));
+    TEST_FAIL_IF(spif_mbuff_get_size(testmbuff) != 7);
+    TEST_FAIL_IF(spif_mbuff_get_len(testmbuff) != 7);
+    spif_mbuff_del(testmbuff);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_mbuff_trim() function");
+    testmbuff = spif_mbuff_new_from_ptr(SPIF_CHARPTR("  \n \r\f       \t    testing 1 2 3    \v\r \n"), 39);
+    spif_mbuff_trim(testmbuff);
+    TEST_FAIL_IF(spif_mbuff_cmp_with_ptr(testmbuff, "testing 1 2 3", 13));
+    TEST_FAIL_IF(spif_mbuff_get_size(testmbuff) != 13);
+    TEST_FAIL_IF(spif_mbuff_get_len(testmbuff) != 13);
+    spif_mbuff_del(testmbuff);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_mbuff_splice() function");
+    testmbuff = spif_mbuff_new_from_ptr(SPIF_CHARPTR(tmp), strlen(tmp));
+    test2mbuff = spif_mbuff_new_from_ptr(SPIF_CHARPTR("lots of fun"), 11);
+    spif_mbuff_splice(testmbuff, 8, 6, test2mbuff);
+    TEST_FAIL_IF(!SPIF_CMP_IS_EQUAL(spif_mbuff_cmp_with_ptr(testmbuff, "this is lots of fun", 19)));
+    TEST_FAIL_IF(spif_mbuff_get_size(testmbuff) != 19);
+    TEST_FAIL_IF(spif_mbuff_get_len(testmbuff) != 19);
+    spif_mbuff_del(test2mbuff);
+    spif_mbuff_del(testmbuff);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_mbuff_splice_from_ptr() function");
+    testmbuff = spif_mbuff_new_from_ptr(SPIF_CHARPTR(tmp), strlen(tmp));
+    spif_mbuff_splice_from_ptr(testmbuff, 8, 0, SPIF_CHARPTR("not "), 4);
+    TEST_FAIL_IF(spif_mbuff_cmp_with_ptr(testmbuff, "this is not a test", 18));
+    TEST_FAIL_IF(spif_mbuff_get_size(testmbuff) != 18);
+    TEST_FAIL_IF(spif_mbuff_get_len(testmbuff) != 18);
+    spif_mbuff_del(testmbuff);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_mbuff_reverse() function");
+    testmbuff = spif_mbuff_new_from_buff(buff, 6, 0);
+    spif_mbuff_reverse(testmbuff);
+    TEST_FAIL_IF(spif_mbuff_cmp_with_ptr(testmbuff, "\0edcba", 6));
+    TEST_FAIL_IF(spif_mbuff_get_size(testmbuff) != 6);
+    TEST_FAIL_IF(spif_mbuff_get_len(testmbuff) != 6);
+    spif_mbuff_del(testmbuff);
+    TEST_PASS();
+
+    TEST_PASSED("spif_mbuff_t");
+    return 0;
+}
+
+int
+test_ustr(void)
+{
+    spif_ustr_t testustr, test2ustr;
+    spif_strclass_t cls;
+    char tmp[] = "this is a test";
+    spif_char_t buff[4096] = "abcde";
+    char tmp2[] = "string #1\nstring #2";
+    FILE *fp;
+    int fd, mypipe[2];
+    spif_charptr_t foo;
+
+    TEST_BEGIN("spif_ustr_new() function");
+    testustr = spif_ustr_new();
+    TEST_FAIL_IF(SPIF_USTR_ISNULL(testustr));
+    TEST_PASS();
+
+    TEST_BEGIN("spif_obj_get_classname() function");
+    cls = SPIF_STR_CLASS(spif_obj_get_class(SPIF_OBJ(testustr)));
+    TEST_FAIL_IF(cls != SPIF_STR_CLASS(SPIF_STRCLASS_VAR(ustr)));
+    TEST_PASS();
+
+    TEST_BEGIN("spif_ustr_del() function");
+    TEST_FAIL_IF(spif_ustr_del(testustr) != TRUE);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_ustr_new_from_ptr() function");
+    testustr = spif_ustr_new_from_ptr(SPIF_CHARPTR(tmp));
+    TEST_FAIL_IF(spif_ustr_cmp_with_ptr(testustr, SPIF_CHARPTR(tmp)));
+    TEST_FAIL_IF(spif_ustr_get_size(testustr) != sizeof(tmp));
+    TEST_FAIL_IF(spif_ustr_get_len(testustr) != (sizeof(tmp) - 1));
+    spif_ustr_del(testustr);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_ustr_new_from_buff() function");
+    testustr = spif_ustr_new_from_buff(buff, sizeof(buff));
+    TEST_FAIL_IF(spif_ustr_casecmp_with_ptr(testustr, buff));
+    TEST_FAIL_IF(spif_ustr_get_size(testustr) != sizeof(buff));
+    TEST_FAIL_IF(spif_ustr_get_len(testustr) != 5);
+    spif_ustr_del(testustr);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_ustr_new_from_fp() function");
+    pipe(mypipe);
+    fd = mypipe[0];
+    fp = fdopen(fd, "r");
+    write(mypipe[1], tmp2, sizeof(tmp2));
+    close(mypipe[1]);
+    TEST_FAIL_IF(fp == NULL);
+    testustr = spif_ustr_new_from_fp(fp);
+    TEST_FAIL_IF(spif_ustr_ncmp_with_ptr(testustr, SPIF_CHARPTR("string #1"), 9));
+    TEST_FAIL_IF(spif_ustr_get_len(testustr) != 9);
+    TEST_FAIL_IF(spif_ustr_get_size(testustr) != 10);
+    spif_ustr_del(testustr);
+    testustr = spif_ustr_new_from_fp(fp);
+    TEST_FAIL_IF(spif_ustr_ncasecmp_with_ptr(testustr, SPIF_CHARPTR("string #2"), 9));
+    TEST_FAIL_IF(spif_ustr_get_len(testustr) != 9);
+    TEST_FAIL_IF(spif_ustr_get_size(testustr) != 10);
+    spif_ustr_del(testustr);
+    fclose(fp);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_ustr_new_from_fd() function");
+    pipe(mypipe);
+    fd = mypipe[0];
+    write(mypipe[1], tmp2, sizeof(tmp2) - 1);
+    close(mypipe[1]);
+    testustr = spif_ustr_new_from_fd(fd);
+    TEST_FAIL_IF(strcmp(SPIF_CHARPTR_C(SPIF_USTR_STR(testustr)), tmp2));
+    TEST_FAIL_IF(spif_ustr_get_len(testustr) != (sizeof(tmp2) - 1));
+    TEST_FAIL_IF(spif_ustr_get_size(testustr) != sizeof(tmp2));
+    spif_ustr_del(testustr);
+    close(fd);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_ustr_new_from_num() function");
+    testustr = spif_ustr_new_from_num(1234567890L);
+    TEST_FAIL_IF(SPIF_USTR_ISNULL(testustr));
+    TEST_FAIL_IF(!SPIF_CMP_IS_EQUAL(spif_ustr_cmp_with_ptr(testustr, SPIF_CHARPTR("1234567890"))));
+    spif_ustr_done(testustr);
+    spif_ustr_init_from_num(testustr, 2147483647L);
+    TEST_FAIL_IF(!SPIF_CMP_IS_EQUAL(spif_ustr_cmp_with_ptr(testustr, SPIF_CHARPTR("2147483647"))));
+    spif_ustr_done(testustr);
+    spif_ustr_init_from_num(testustr, -2147483647L);
+    TEST_FAIL_IF(!SPIF_CMP_IS_EQUAL(spif_ustr_cmp_with_ptr(testustr, SPIF_CHARPTR("-2147483647"))));
+    spif_ustr_done(testustr);
+    spif_ustr_init_from_num(testustr, 0x00000000);
+    TEST_FAIL_IF(!SPIF_CMP_IS_EQUAL(spif_ustr_cmp_with_ptr(testustr, SPIF_CHARPTR("0"))));
+    spif_ustr_del(testustr);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_ustr_dup() function");
+    testustr = spif_ustr_new_from_ptr(SPIF_CHARPTR(tmp));
+    TEST_FAIL_IF(strcmp(SPIF_CHARPTR_C(SPIF_USTR_STR(testustr)), tmp));
+    TEST_FAIL_IF(spif_ustr_get_size(testustr) != sizeof(tmp));
+    TEST_FAIL_IF(spif_ustr_get_len(testustr) != (sizeof(tmp) - 1));
+    test2ustr = spif_ustr_dup(testustr);
+    TEST_FAIL_IF(test2ustr == testustr);
+    TEST_FAIL_IF(SPIF_USTR_STR(test2ustr) == SPIF_USTR_STR(testustr));
+    TEST_FAIL_IF(spif_ustr_cmp(testustr, test2ustr));
+    TEST_FAIL_IF(spif_ustr_casecmp(testustr, test2ustr));
+    TEST_FAIL_IF(spif_ustr_ncmp(testustr, test2ustr, spif_ustr_get_len(testustr)));
+    TEST_FAIL_IF(spif_ustr_ncasecmp(testustr, test2ustr, spif_ustr_get_len(test2ustr)));
+    TEST_FAIL_IF(strcmp(SPIF_CHARPTR_C(SPIF_USTR_STR(test2ustr)), tmp));
+    TEST_FAIL_IF(spif_ustr_get_size(test2ustr) != sizeof(tmp));
+    TEST_FAIL_IF(spif_ustr_get_len(test2ustr) != (sizeof(tmp) - 1));
+    spif_ustr_del(testustr);
+    spif_ustr_del(test2ustr);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_ustr_index() function");
+    testustr = spif_ustr_new_from_ptr(SPIF_CHARPTR(tmp2));
+    TEST_FAIL_IF(spif_ustr_index(testustr, '#') != 7);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_ustr_rindex() function");
+    TEST_FAIL_IF(spif_ustr_rindex(testustr, '#') != 17);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_ustr_find() function");
+    test2ustr = spif_ustr_new_from_ptr(SPIF_CHARPTR("ring"));
+    TEST_FAIL_IF(spif_ustr_find(testustr, test2ustr) != 2);
+    spif_ustr_del(test2ustr);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_ustr_find_from_ptr() function");
+    TEST_FAIL_IF(spif_ustr_find_from_ptr(testustr, SPIF_CHARPTR("in")) != 3);
+    spif_ustr_del(testustr);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_ustr_substr() function");
+    testustr = spif_ustr_new_from_ptr(SPIF_CHARPTR(tmp));
+    test2ustr = spif_ustr_substr(testustr, 2, 5);
+    TEST_FAIL_IF(spif_ustr_cmp_with_ptr(test2ustr, SPIF_CHARPTR("is is")));
+    TEST_FAIL_IF(spif_ustr_get_size(test2ustr) != 6);
+    TEST_FAIL_IF(spif_ustr_get_len(test2ustr) != 5);
+    spif_ustr_del(test2ustr);
+    test2ustr = spif_ustr_substr(testustr, -4, 4);
+    TEST_FAIL_IF(spif_ustr_cmp_with_ptr(test2ustr, SPIF_CHARPTR("test")));
+    TEST_FAIL_IF(spif_ustr_get_size(test2ustr) != 5);
+    TEST_FAIL_IF(spif_ustr_get_len(test2ustr) != 4);
+    spif_ustr_del(test2ustr);
+    spif_ustr_del(testustr);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_ustr_substr_to_ptr() function");
+    testustr = spif_ustr_new_from_ptr(SPIF_CHARPTR(tmp));
+    foo = spif_ustr_substr_to_ptr(testustr, 2, 5);
+    TEST_FAIL_IF(foo == NULL);
+    TEST_FAIL_IF(strcmp(SPIF_CHARPTR_C(foo), "is is"));
+    FREE(foo);
+    foo = spif_ustr_substr_to_ptr(testustr, -4, 4);
+    TEST_FAIL_IF(foo == NULL);
+    TEST_FAIL_IF(strcmp(SPIF_CHARPTR_C(foo), "test"));
+    FREE(foo);
+    spif_ustr_del(testustr);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_ustr_to_num() function");
+    testustr = spif_ustr_new_from_ptr(SPIF_CHARPTR("11001001"));
+    TEST_FAIL_IF(spif_ustr_to_num(testustr, 2) != 201);
+    TEST_FAIL_IF(spif_ustr_to_num(testustr, 10) != 11001001);
+    spif_ustr_del(testustr);
+    testustr = spif_ustr_new_from_ptr(SPIF_CHARPTR("0132"));
+    TEST_FAIL_IF(spif_ustr_to_num(testustr, 0) != 90);
+    TEST_FAIL_IF(spif_ustr_to_num(testustr, 8) != 90);
+    TEST_FAIL_IF(spif_ustr_to_num(testustr, 10) != 132);
+    spif_ustr_del(testustr);
+    testustr = spif_ustr_new_from_ptr(SPIF_CHARPTR("0xff"));
+    TEST_FAIL_IF(spif_ustr_to_num(testustr, 0) != 255);
+    TEST_FAIL_IF(spif_ustr_to_num(testustr, 10) != 0);
+    spif_ustr_del(testustr);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_ustr_to_float() function");
+    testustr = spif_ustr_new_from_ptr(SPIF_CHARPTR("3.1415"));
+    TEST_FAIL_IF(spif_ustr_to_float(testustr) != 3.1415);
+    spif_ustr_del(testustr);
+    testustr = spif_ustr_new_from_ptr(SPIF_CHARPTR("2.71"));
+    TEST_FAIL_IF(spif_ustr_to_float(testustr) != 2.71);
+    spif_ustr_del(testustr);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_ustr_append() function");
+    testustr = spif_ustr_new_from_ptr(SPIF_CHARPTR("copy"));
+    test2ustr = spif_ustr_new_from_ptr(SPIF_CHARPTR("cat"));
+    spif_ustr_append(testustr, test2ustr);
+    TEST_FAIL_IF(spif_ustr_cmp_with_ptr(testustr, SPIF_CHARPTR("copycat")));
+    TEST_FAIL_IF(spif_ustr_get_size(testustr) != 8);
+    TEST_FAIL_IF(spif_ustr_get_len(testustr) != 7);
+    spif_ustr_del(test2ustr);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_ustr_append_char() function");
+    test2ustr = spif_ustr_new_from_ptr(SPIF_CHARPTR("Hello"));
+    spif_ustr_append_char(test2ustr, ' ');
+    spif_ustr_append_char(test2ustr, 'w');
+    spif_ustr_append_char(test2ustr, 'o');
+    spif_ustr_append_char(test2ustr, 'r');
+    spif_ustr_append_char(test2ustr, 'l');
+    spif_ustr_append_char(test2ustr, 'd');
+    TEST_FAIL_IF(spif_ustr_cmp_with_ptr(test2ustr, SPIF_CHARPTR("Hello world")));
+    TEST_FAIL_IF(spif_ustr_get_size(test2ustr) != 12);
+    TEST_FAIL_IF(spif_ustr_get_len(test2ustr) != 11);
+    spif_ustr_del(test2ustr);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_ustr_append_from_ptr() function");
+    spif_ustr_append_from_ptr(testustr, SPIF_CHARPTR("crime"));
+    TEST_FAIL_IF(spif_ustr_cmp_with_ptr(testustr, SPIF_CHARPTR("copycatcrime")));
+    TEST_FAIL_IF(spif_ustr_get_size(testustr) != 13);
+    TEST_FAIL_IF(spif_ustr_get_len(testustr) != 12);
+    spif_ustr_del(testustr);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_ustr_clear() function");
+    testustr = spif_ustr_new_from_ptr(SPIF_CHARPTR("abcdefg"));
+    spif_ustr_clear(testustr, 'x');
+    TEST_FAIL_IF(spif_ustr_cmp_with_ptr(testustr, SPIF_CHARPTR("xxxxxxx")));
+    TEST_FAIL_IF(spif_ustr_get_size(testustr) != 8);
+    TEST_FAIL_IF(spif_ustr_get_len(testustr) != 7);
+    spif_ustr_del(testustr);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_ustr_trim() function");
+    testustr = spif_ustr_new_from_ptr(SPIF_CHARPTR("  \n \r\f       \t    testing 1 2 3    \v\r \n"));
+    spif_ustr_trim(testustr);
+    TEST_FAIL_IF(spif_ustr_cmp_with_ptr(testustr, SPIF_CHARPTR("testing 1 2 3")));
+    TEST_FAIL_IF(spif_ustr_get_size(testustr) != 14);
+    TEST_FAIL_IF(spif_ustr_get_len(testustr) != 13);
+    spif_ustr_del(testustr);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_ustr_splice() function");
+    testustr = spif_ustr_new_from_ptr(SPIF_CHARPTR(tmp));
+    test2ustr = spif_ustr_new_from_ptr(SPIF_CHARPTR("lots of fun"));
+    spif_ustr_splice(testustr, 8, 6, test2ustr);
+    TEST_FAIL_IF(!SPIF_CMP_IS_EQUAL(spif_ustr_cmp_with_ptr(testustr, SPIF_CHARPTR("this is lots of fun"))));
+    TEST_FAIL_IF(spif_ustr_get_size(testustr) != 20);
+    TEST_FAIL_IF(spif_ustr_get_len(testustr) != 19);
+    spif_ustr_del(test2ustr);
+    spif_ustr_del(testustr);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_ustr_splice_from_ptr() function");
+    testustr = spif_ustr_new_from_ptr(SPIF_CHARPTR(tmp));
+    spif_ustr_splice_from_ptr(testustr, 8, 0, SPIF_CHARPTR("not "));
+    TEST_FAIL_IF(spif_ustr_cmp_with_ptr(testustr, SPIF_CHARPTR("this is not a test")));
+    TEST_FAIL_IF(spif_ustr_get_size(testustr) != 19);
+    TEST_FAIL_IF(spif_ustr_get_len(testustr) != 18);
+    spif_ustr_del(testustr);
+    TEST_PASS();
+
+    TEST_BEGIN("spif_ustr_reverse() function");
+    testustr = spif_ustr_new_from_buff(buff, sizeof(buff));
+    spif_ustr_reverse(testustr);
+    TEST_FAIL_IF(spif_ustr_cmp_with_ptr(testustr, SPIF_CHARPTR("edcba")));
+    TEST_FAIL_IF(spif_ustr_get_size(testustr) != sizeof(buff));
+    TEST_FAIL_IF(spif_ustr_get_len(testustr) != 5);
+    spif_ustr_del(testustr);
+    TEST_PASS();
+
+    TEST_PASSED("spif_ustr_t");
+    return 0;
+}
+
+int
 test_url(void)
 {
     spif_url_t testurl, testurl2, testurl3, testurl4;
@@ -2226,6 +2697,12 @@ main(int argc, char *argv[])
     if ((ret = test_tok()) != 0) {
         return ret;
     }
+    if ((ret = test_mbuff()) != 0) {
+        return ret;
+    }
+    if ((ret = test_ustr()) != 0) {
+        return ret;
+    }
     if ((ret = test_url()) != 0) {
         return ret;
     }