Changeset 815 for trunk/superstring

Timestamp:

03/28/08 22:32:22 (4 years ago)

Author:

wd

Message:

Interrim update for superstring bits.

Location:

trunk/superstring

Files:

• include/superstring/superstring.h (modified) (4 diffs)
• include/superstring_private.h (modified) (2 diffs)
• source/SConscript (modified) (1 diff)
• source/allocator.c (modified) (3 diffs)
• source/test.c (modified) (3 diffs)

trunk/superstring/include/superstring/superstring.h

@@ -114 +114 @@
 };
 
-typedef struct _superstring_jumbo_ * superstring_jumbo;
 typedef struct _superstring_small_ * superstring;
 
@@ -198 +197 @@
 /* Get the C representation of a superstring value. */
 static inline const unsigned char *ss_cstring(superstring str) {
-    if (str == NULL)
+    if (str == NULL) {
+        ss_errno = SS_ERROR_INVALID_PARAMETER;
         return NULL;
-
+    }
+
+    ss_errno = SS_ERROR_SUCCESS;
     return (str->flags & SUPERSTRING_JUMBO ?
             ((const unsigned char *)str) + sizeof(struct _superstring_jumbo_) :
@@ -208 +210 @@
 /* Retrieve the length or size of a string */
 static inline size_t ss_length(superstring str) {
-    if (str == NULL)
+    if (str == NULL) {
+        ss_errno = SS_ERROR_INVALID_PARAMETER;
         return 0; /* bad answer.. */
-
+    }
+
+    ss_errno = SS_ERROR_SUCCESS;
     return (size_t)(str->flags & SUPERSTRING_JUMBO ?
-            ((superstring_jumbo)str)->len :
+            ((struct _superstring_jumbo_ *)str)->len :
             str->len);
 }
 
 static inline size_t ss_size(superstring str) {
-    if (str == NULL)
+    if (str == NULL) {
+        ss_errno = SS_ERROR_INVALID_PARAMETER;
         return 0; /* bad answer.. */
-
+    }
+
+    ss_errno = SS_ERROR_SUCCESS;
     return (size_t)(str->flags & SUPERSTRING_JUMBO ?
-            ((superstring_jumbo)str)->size :
+            ((struct _superstring_jumbo_ *)str)->size :
             str->size);
+}
+
+/* Retrieve or set the character at 'offset' in the string */
+static inline unsigned char ss_char(superstring str, size_t index) {
+    if (str == NULL || index >= str->len) {
+        ss_errno = SS_ERROR_INVALID_PARAMETER;
+        return 0;
+    }
+    return (str->flags & SUPERSTRING_JUMBO ?
+            *((unsigned char *)str + sizeof(struct _superstring_jumbo_) + index) :
+            *((unsigned char *)str + sizeof(struct _superstring_small_) + index));
+}
+static inline int ss_setchar(superstring str, size_t index, char c) {
+    if (str == NULL || index >= str->len)
+        return (ss_errno = SS_ERROR_INVALID_PARAMETER);
+
+    if (str->flags & SUPERSTRING_JUMBO)
+        *((unsigned char *)str + sizeof(struct _superstring_jumbo_) + index) = c;
+    else
+        *((unsigned char *)str + sizeof(struct _superstring_small_) + index) = c;
+
+    return (ss_errno = SS_ERROR_SUCCESS);
 }
 
@@ -249 +279 @@
 
 /*****************************************************************************/
+/* Shorten or lengthen a superstring by trimming or appending data.  For
+ * trim, if the length is greater than the current length spaces (or a
+ * specified character) are appended as necessary. */
+int ss_trim_ex(superstring str, size_t length, char fill);
+static inline int ss_trim(superstring str, size_t length) {
+    return ss_trim_ex(str, length, ' ');
+}
+
+/*****************************************************************************/
+/* Append data to a superstring.  There are several variants provided which
+ * allow for setting maximum string length, using C strings, etc */
+#define SS_APPEND_CSTRING           (0x80000000)
+int ss_append_ex(superstring *lstr, superstring rstr, int flags, size_t length);
+
+/* Append a string with no concern for length */
+static inline int ss_append(superstring *lstr, superstring rstr) {
+    return ss_append_ex(lstr, rstr, 0, 0);
+}
+static inline int ss_append_cs(superstring *lstr, const unsigned char *rstr) {
+    return ss_append_ex(lstr, (superstring)rstr, SS_APPEND_CSTRING, 0);
+}
+
+/* Append a string but do not allow lstr to exceed 'length' */
+static inline int ss_nappend(superstring *lstr, superstring rstr,
+        size_t length) {
+    return ss_append_ex(lstr, rstr, 0, length);
+}
+static inline int ss_nappend_cs(superstring *lstr, const unsigned char *rstr,
+        size_t length) {
+    return ss_append_ex(lstr, (superstring)rstr, SS_APPEND_CSTRING, length);
+}
+
+/*****************************************************************************/
 /* Comparison function, with various wrappers:
    - ss_compare_ex: Compare with flags and length.  If length is 0 it will be

trunk/superstring/include/superstring_private.h

@@ -60 +60 @@
     str->flags = istr->flags;
     if (istr->flags & SUPERSTRING_JUMBO) {
-        superstring_jumbo jstr = (superstring_jumbo)str;
+        struct _superstring_jumbo_ *jstr = (struct _superstring_jumbo_ *)str;
         jstr->len = istr->len;
         jstr->size = istr->size;
@@ -88 +88 @@
 
 /* Function to grow strings */
-int ss_grow(ss_internal *istr);
+int ss_grow(ss_internal *istr, superstring *outstr);
 
 /* Handy stuff for handling printf-like functions and warnings in gcc (thanks

trunk/superstring/source/SConscript

@@ -17 +17 @@
 sourcelist = Split('''
 allocator.c
+append.c
 chartables.c
 compare.c

trunk/superstring/source/allocator.c

@@ -49 +49 @@
 
 /* This function will grow the data pointed to by an ss_internal structure
- * as need-be.  It will also correctly handle structure type transitioning.  */
-int ss_grow(ss_internal *istr) {
+ * as need-be.  It will also correctly handle structure type transitioning
+ * and assign the correct memory address to 'outstr' (if provided) */
+int ss_grow(ss_internal *istr, superstring *outstr) {
     size_t grow;
     size_t memsize;
@@ -115 +116 @@
     }
 
-    /* map in the updated values */
+    /* map in the updated values.  Mostly we can do this by calling
+     * ssi_to_ss, but we also need to update the data pointer of istr to
+     * reflect the new address of the data. */
     ssi_to_ss(istr, istr->str);
+    istr->data = ss_cstring(str);
+    if (outstr != NULL)
+        *outstr = istr->str;
+
     ss_returnerror(SS_ERROR_SUCCESS);
 }
@@ -151 +158 @@
     istr.size = size;
 
-    if (ss_grow(&istr) != SS_ERROR_SUCCESS)
+    if (ss_grow(&istr, NULL) != SS_ERROR_SUCCESS)
         return NULL;
 
     /* Copy our data in */
-    cstr = ss_cstring(istr.str);
+    cstr = (unsigned char *)ss_cstring(istr.str);
     memcpy((void *)cstr, value, istr.len);
     cstr[istr.len] = '\0';

trunk/superstring/source/test.c

@@ -29 +29 @@
 void test_anonymous(void);
 void test_compare(void);
+void test_setchar(void);
+void test_append(void);
 
 #define TEST_INIT_VALUE "Hello, world!"
@@ -156 +158 @@
 }
 
+void test_setchar(void) {
+    superstring str = ss_create(TEST_INIT_VALUE);
+
+    tassert(ss_char(str, 0) == TEST_INIT_VALUE[0]);
+    tassert(ss_setchar(str, 0, 'y') == SS_ERROR_SUCCESS);
+    tassert(ss_char(str, 0) == 'y');
+    tassert(ss_char(str, 0) != TEST_INIT_VALUE[0]);
+
+    tassert(ss_setchar(str, 1024, '!') == SS_ERROR_INVALID_PARAMETER);
+}
+
+void test_append(void) {
+    superstring str = ss_create("abc");
+    superstring str2 = ss_create("123");
+
+    tassert(ss_append(&str, NULL) == SS_ERROR_INVALID_PARAMETER);
+    tassert(ss_append(&str, str2) == SS_ERROR_SUCCESS);
+    tassert(ss_compare_cs(str, "abc123") == 0);
+    ss_destroy(&str);
+    ss_destroy(&str2);
+
+    /* test an allocation which forces growth */
+    size_t len;
+    str = ss_create("abc");
+    len = ss_length(str);
+    for (int i = 0;i < 100;i++) {
+        tassert(ss_append_cs(&str, "123") == SS_ERROR_SUCCESS);
+        len += 3; /* length should grow by 3 .. */
+    }
+    tassert(ss_length(str) == len);
+
+    ss_destroy(&str);
+}
+
 int main(void) {
 
@@ -162 +198 @@
     runtest(anonymous);
     runtest(compare);
+    runtest(setchar);
+    runtest(append);
 
     /* If we made it here we are at the end!  Let them know we succeeded. */