common/strbuf: "\0" pointer for new buffers and squeeze.

TODO

@@ -6,8 +6,5 @@
  * Use queue in inotify_read(), tree and remove indexer
  * path:
     * normalize
- * strbuf:
-    * "\0" default string.
-    * strbuf_squeeze: squeeze repeated characters into one.
  * ini-like config support
  * fix mysql module

src/common/strbuf.c

@@ -9,42 +9,50 @@
  */
 
 #include <ctype.h>
+#include <string.h>
 #include <malloc.h>
 #include <assert.h>
 #include "strbuf.h"
 
 #define CHNK_SIZE 128
 
-static void buf_expand(strbuf_t *s, size_t l) {
+char strbuf_null = '\0';
 
-	if (l <= s->alloc_size)
+static void* xrealloc(void *ptr, size_t size) {
-		return;
 
-	do 
+    assert(size);
-		s->alloc_size += CHNK_SIZE;
+    ptr = realloc(ptr, size);
-	while(l > s->alloc_size);
+    assert(ptr != NULL);
-	
+    return ptr;
-    s->buf = realloc(s->buf, s->alloc_size);
+}
-	assert(s->buf != NULL);
+
+static void* xcalloc(size_t nmemb, size_t size) {
+
+    assert(nmemb);
+    assert(size);
+    void *ptr = calloc(nmemb, size);
+    assert(ptr != NULL);
+    return ptr;
 }
 
 void strbuf_init(strbuf_t *s) {
 
-	s->buf = NULL;
+	s->buf = &strbuf_null;
-	s->len = 0;
+	s->alloc_size = s->len = 0;
-	s->alloc_size = 0;
 }
 
-void strbuf_append(strbuf_t *s, char *str, size_t len) {
+void strbuf_expand(strbuf_t *s, size_t len) {
 
-	if (str == NULL)
+    if (s->len + len + 1 < s->alloc_size)
 		return;
+    if (!s->alloc_size)
+        s->buf = NULL;
 
-    buf_expand(s, s->len + len + 1);
+	do 
+		s->alloc_size += CHNK_SIZE;
+	while(s->len + len + 1 > s->alloc_size);
 	
-    memcpy(s->buf + s->len, str, len);
+    s->buf = xrealloc(s->buf, s->alloc_size);
-    s->len += len;
-    s->buf[s->len] = '\0';
 }
 
 void strbuf_reduce(strbuf_t *s, size_t len) {
@@ -56,6 +64,51 @@ void strbuf_reduce(strbuf_t *s, size_t len) {
     s->buf[s->len] = '\0';
 }
 
+char* strbuf_release(strbuf_t *s) {
+
+	char *ret;
+	
+	if (!s->alloc_size)
+        ret = xcalloc(1, 1);
+    else if (s->len + 1 != s->alloc_size)
+		ret = xrealloc(s->buf, s->len + 1);
+	else
+		ret = s->buf;
+	
+	strbuf_init(s);
+	
+	return ret;
+}
+
+void strbuf_free(strbuf_t *s) {
+
+    if (!s->alloc_size)
+        return;
+        
+    free(s->buf);
+    strbuf_init(s);
+}
+
+void strbuf_append(strbuf_t *s, void *ptr, size_t len) {
+
+    strbuf_expand(s, len);
+    memcpy(s->buf + s->len, ptr, len);
+    s->len += len;
+    s->buf[s->len] = '\0';
+}
+
+void strbuf_append_str(strbuf_t *s, char *str) {
+
+    strbuf_append(s, str, strlen(str));
+}
+
+void strbuf_append_ch(strbuf_t *s, char ch) {
+
+    strbuf_expand(s, 1);
+    s->buf[s->len++] = ch;
+    s->buf[s->len] = '\0';
+}
+
 void strbuf_trim(strbuf_t *s) {
 
 	strbuf_rtrim(s);
@@ -64,7 +117,7 @@ void strbuf_trim(strbuf_t *s) {
 
 void strbuf_rtrim(strbuf_t *s) {
 
-    for(; s->len > 0 && isspace(s->buf[s->len-1]); s->len--);
+    for(; s->len && isspace(s->buf[s->len-1]); s->len--);
     s->buf[s->len] = '\0';
 }
 
@@ -93,27 +146,20 @@ void strbuf_rev(strbuf_t *s) {
     }
 }
 
-char* strbuf_release(strbuf_t *s) {
+void strbuf_squeeze(strbuf_t *s, char ch) {
 
-	char *ret;
+    size_t p;
-	
+
-	if (s->len + 1 != s->alloc_size) {
+    for(p=s->len; p; p--) {
-		ret = realloc(s->buf, s->len + 1);
+
-		assert(ret != NULL);
+        if (s->buf[p] != ch)
-	} else {
+            continue;
-		ret = s->buf;
+
-	}
+        size_t np = p, of = 0;
-	
+        
-	strbuf_init(s);
+        for(; np >= 1 && s->buf[np-1] == ch; np--)
-	
+            of++;
-	return ret;
+        for(s->len -= of; np <= s->len; np++)
+            s->buf[np] = s->buf[np + of];
+    }
 }
-
-void strbuf_free(strbuf_t *s) {
-
-    if (s->alloc_size > 0)
-        free(s->buf);
-    s->buf = NULL;
-}
-
-

src/common/strbuf.h

@@ -11,9 +11,7 @@
 #ifndef __COMMON_STRBUF_H
 #define __COMMON_STRBUF_H
 
-#include <string.h>
+#include <stddef.h>
-
-#define STRBUF_INIT { 0, 0, NULL }
 
 typedef struct {
     size_t alloc_size;
@@ -21,12 +19,26 @@ typedef struct {
     char  *buf;
 } strbuf_t;
 
+extern char strbuf_null;
+
+#define STRBUF_INIT { 0, 0, &strbuf_null }
+
 void strbuf_init(strbuf_t *s);
 
-void strbuf_append(strbuf_t *s, char *str, size_t len);
+void strbuf_expand(strbuf_t *s, size_t len);
 
 void strbuf_reduce(strbuf_t *s, size_t len);
 
+char* strbuf_release(strbuf_t *s);
+
+void strbuf_free(strbuf_t *s);
+
+void strbuf_append(strbuf_t *s, void *ptr, size_t len);
+
+void strbuf_append_str(strbuf_t *s, char *str);
+
+void strbuf_append_ch(strbuf_t *s, char ch);
+
 void strbuf_trim(strbuf_t *s);
 
 void strbuf_rtrim(strbuf_t *s);
@@ -35,8 +47,6 @@ void strbuf_ltrim(strbuf_t *s);
 
 void strbuf_rev(strbuf_t *s);
 
-char* strbuf_release(strbuf_t *s);
+void strbuf_squeeze(strbuf_t *s, char ch);
-
-void strbuf_free(strbuf_t *s);
 
 #endif /* __COMMON_STRBUF_H */

test/t_strbuf.c

@@ -1,20 +1,50 @@
 
 #include <assert.h>
 #include <stdio.h>
+#include <string.h>
 #include <malloc.h>
 #include "../src/common/strbuf.h"
 
+typedef unsigned int uint;
+
 void print_strbuf(strbuf_t *s) {
 
     assert(s->len == strlen(s->buf));
 
-    printf("block: %i, len: %i |%s|\n", s->alloc_size, s->len, s->buf);
+    printf("block: %u, len: %u |%s|\n", (uint)s->alloc_size, (uint)s->len, s->buf);
 }
 
-int main() {
+void test_release_empty() {
 
     strbuf_t b = STRBUF_INIT;
-	char *str;
+
+    char *ptr = strbuf_release(&b);
+
+    assert(*ptr == '\0');
+
+    free(ptr);
+}
+
+void test_squeeze() {
+
+    strbuf_t b = STRBUF_INIT;
+
+    strbuf_append_str(&b, "aaabXXXcdefXXXXghijklXXmmmnopXXXXXqrstuXXvwxyXXz");
+    strbuf_squeeze(&b, 'X');
+    print_strbuf(&b);
+    strbuf_free(&b);
+
+    strbuf_append_str(&b, "XXXX");
+    strbuf_squeeze(&b, 'X');
+    print_strbuf(&b);
+    strbuf_free(&b);
+}
+
+void test() {
+
+    strbuf_t b = STRBUF_INIT;
+	
+    print_strbuf(&b);
 
     strbuf_append(&b, "    ", 4);
     strbuf_append(&b, "abcdef", 6);
@@ -22,7 +52,8 @@ int main() {
 	print_strbuf(&b);
 	
     strbuf_append(&b, "012345678901234567890123456789", 30);
-    strbuf_append(&b, "      ", 6);
+    strbuf_append_ch(&b, 'a'); 
+    strbuf_append_str(&b, "      ");
 
     print_strbuf(&b);
 
@@ -46,15 +77,21 @@ int main() {
 
     print_strbuf(&b);
 
-    strbuf_reduce(&b, 95);
+    /* testing release */
-
+    char *str = strbuf_release(&b);
-    print_strbuf(&b);
-	
-    str = strbuf_release(&b);
 	
 	printf("released |%s|\n", str);
 	
 	free(str);
+}
 
+int main() {
+
+    test();
+    
+    test_release_empty();
+
+    test_squeeze();
+    
     return 0;
 }