diff options
Diffstat (limited to 'src/common')
| -rw-r--r-- | src/common/utf8.c | 2 | ||||
| -rw-r--r-- | src/common/utf8.h | 2 | ||||
| -rw-r--r-- | src/common/utils.c | 206 | ||||
| -rw-r--r-- | src/common/utils.h | 98 |
4 files changed, 154 insertions, 154 deletions
diff --git a/src/common/utf8.c b/src/common/utf8.c index a2f4fdd..ddd51ee 100644 --- a/src/common/utf8.c +++ b/src/common/utf8.c @@ -83,7 +83,7 @@ blogc_utf8_validate(const uint8_t *str, size_t len) bool -blogc_utf8_validate_str(sb_string_t *str) +blogc_utf8_validate_str(bc_string_t *str) { return blogc_utf8_validate((uint8_t*) str->str, str->len); } diff --git a/src/common/utf8.h b/src/common/utf8.h index 06fe07e..b37a97d 100644 --- a/src/common/utf8.h +++ b/src/common/utf8.h @@ -15,7 +15,7 @@ #include "utils.h" bool blogc_utf8_validate(const uint8_t *str, size_t len); -bool blogc_utf8_validate_str(sb_string_t *str); +bool blogc_utf8_validate_str(bc_string_t *str); size_t blogc_utf8_skip_bom(const uint8_t *str, size_t len); #endif /* _UTF_8_H */ diff --git a/src/common/utils.c b/src/common/utils.c index b42ae4e..8397419 100644 --- a/src/common/utils.c +++ b/src/common/utils.c @@ -18,7 +18,7 @@ void* -sb_malloc(size_t size) +bc_malloc(size_t size) { // simple things simple! void *rv = malloc(size); @@ -31,7 +31,7 @@ sb_malloc(size_t size) void* -sb_realloc(void *ptr, size_t size) +bc_realloc(void *ptr, size_t size) { // simple things even simpler :P void *rv = realloc(ptr, size); @@ -44,17 +44,17 @@ sb_realloc(void *ptr, size_t size) } -sb_slist_t* -sb_slist_append(sb_slist_t *l, void *data) +bc_slist_t* +bc_slist_append(bc_slist_t *l, void *data) { - sb_slist_t *node = sb_malloc(sizeof(sb_slist_t)); + bc_slist_t *node = bc_malloc(sizeof(bc_slist_t)); node->data = data; node->next = NULL; if (l == NULL) { l = node; } else { - sb_slist_t *tmp; + bc_slist_t *tmp; for (tmp = l; tmp->next != NULL; tmp = tmp->next); tmp->next = node; } @@ -62,10 +62,10 @@ sb_slist_append(sb_slist_t *l, void *data) } -sb_slist_t* -sb_slist_prepend(sb_slist_t *l, void *data) +bc_slist_t* +bc_slist_prepend(bc_slist_t *l, void *data) { - sb_slist_t *node = sb_malloc(sizeof(sb_slist_t)); + bc_slist_t *node = bc_malloc(sizeof(bc_slist_t)); node->data = data; node->next = l; l = node; @@ -74,10 +74,10 @@ sb_slist_prepend(sb_slist_t *l, void *data) void -sb_slist_free_full(sb_slist_t *l, sb_free_func_t free_func) +bc_slist_free_full(bc_slist_t *l, bc_free_func_t free_func) { while (l != NULL) { - sb_slist_t *tmp = l->next; + bc_slist_t *tmp = l->next; if ((free_func != NULL) && (l->data != NULL)) free_func(l->data); free(l); @@ -87,26 +87,26 @@ sb_slist_free_full(sb_slist_t *l, sb_free_func_t free_func) void -sb_slist_free(sb_slist_t *l) +bc_slist_free(bc_slist_t *l) { - sb_slist_free_full(l, NULL); + bc_slist_free_full(l, NULL); } size_t -sb_slist_length(sb_slist_t *l) +bc_slist_length(bc_slist_t *l) { if (l == NULL) return 0; size_t i; - sb_slist_t *tmp; + bc_slist_t *tmp; for (tmp = l, i = 0; tmp != NULL; tmp = tmp->next, i++); return i; } char* -sb_strdup(const char *s) +bc_strdup(const char *s) { if (s == NULL) return NULL; @@ -120,7 +120,7 @@ sb_strdup(const char *s) char* -sb_strndup(const char *s, size_t n) +bc_strndup(const char *s, size_t n) { if (s == NULL) return NULL; @@ -135,7 +135,7 @@ sb_strndup(const char *s, size_t n) char* -sb_strdup_vprintf(const char *format, va_list ap) +bc_strdup_vprintf(const char *format, va_list ap) { va_list ap2; va_copy(ap2, ap); @@ -156,18 +156,18 @@ sb_strdup_vprintf(const char *format, va_list ap) char* -sb_strdup_printf(const char *format, ...) +bc_strdup_printf(const char *format, ...) { va_list ap; va_start(ap, format); - char *tmp = sb_strdup_vprintf(format, ap); + char *tmp = bc_strdup_vprintf(format, ap); va_end(ap); return tmp; } bool -sb_str_starts_with(const char *str, const char *prefix) +bc_str_starts_with(const char *str, const char *prefix) { int str_l = strlen(str); int str_lp = strlen(prefix); @@ -178,7 +178,7 @@ sb_str_starts_with(const char *str, const char *prefix) bool -sb_str_ends_with(const char *str, const char *suffix) +bc_str_ends_with(const char *str, const char *suffix) { int str_l = strlen(str); int str_ls = strlen(suffix); @@ -189,7 +189,7 @@ sb_str_ends_with(const char *str, const char *suffix) char* -sb_str_lstrip(char *str) +bc_str_lstrip(char *str) { if (str == NULL) return NULL; @@ -213,7 +213,7 @@ sb_str_lstrip(char *str) char* -sb_str_rstrip(char *str) +bc_str_rstrip(char *str) { if (str == NULL) return NULL; @@ -237,52 +237,52 @@ sb_str_rstrip(char *str) char* -sb_str_strip(char *str) +bc_str_strip(char *str) { - return sb_str_lstrip(sb_str_rstrip(str)); + return bc_str_lstrip(bc_str_rstrip(str)); } char** -sb_str_split(const char *str, char c, unsigned int max_pieces) +bc_str_split(const char *str, char c, unsigned int max_pieces) { if (str == NULL) return NULL; - char **rv = sb_malloc(sizeof(char*)); + char **rv = bc_malloc(sizeof(char*)); unsigned int i, start = 0, count = 0; for (i = 0; i < strlen(str) + 1; i++) { if (str[0] == '\0') break; if ((str[i] == c && (!max_pieces || count + 1 < max_pieces)) || str[i] == '\0') { - rv = sb_realloc(rv, (count + 1) * sizeof(char*)); - rv[count] = sb_malloc(i - start + 1); + rv = bc_realloc(rv, (count + 1) * sizeof(char*)); + rv[count] = bc_malloc(i - start + 1); memcpy(rv[count], str + start, i - start); rv[count++][i - start] = '\0'; start = i + 1; } } - rv = sb_realloc(rv, (count + 1) * sizeof(char*)); + rv = bc_realloc(rv, (count + 1) * sizeof(char*)); rv[count] = NULL; return rv; } char* -sb_str_replace(const char *str, const char search, const char *replace) +bc_str_replace(const char *str, const char search, const char *replace) { - char **pieces = sb_str_split(str, search, 0); + char **pieces = bc_str_split(str, search, 0); if (pieces == NULL) return NULL; - char* rv = sb_strv_join(pieces, replace); - sb_strv_free(pieces); + char* rv = bc_strv_join(pieces, replace); + bc_strv_free(pieces); if (rv == NULL) - return sb_strdup(str); + return bc_strdup(str); return rv; } char* -sb_str_find(const char *str, char c) +bc_str_find(const char *str, char c) { // this is somewhat similar to strchr, but respects '\' escaping. if (str == NULL) @@ -303,7 +303,7 @@ sb_str_find(const char *str, char c) void -sb_strv_free(char **strv) +bc_strv_free(char **strv) { if (strv == NULL) return; @@ -314,22 +314,22 @@ sb_strv_free(char **strv) char* -sb_strv_join(char **strv, const char *separator) +bc_strv_join(char **strv, const char *separator) { if (strv == NULL || separator == NULL) return NULL; - sb_string_t *str = sb_string_new(); + bc_string_t *str = bc_string_new(); for (size_t i = 0; strv[i] != NULL; i++) { - str = sb_string_append(str, strv[i]); + str = bc_string_append(str, strv[i]); if (strv[i + 1] != NULL) - str = sb_string_append(str, separator); + str = bc_string_append(str, separator); } - return sb_string_free(str, false); + return bc_string_free(str, false); } size_t -sb_strv_length(char **strv) +bc_strv_length(char **strv) { if (strv == NULL) return 0; @@ -339,23 +339,23 @@ sb_strv_length(char **strv) } -sb_string_t* -sb_string_new(void) +bc_string_t* +bc_string_new(void) { - sb_string_t* rv = sb_malloc(sizeof(sb_string_t)); + bc_string_t* rv = bc_malloc(sizeof(bc_string_t)); rv->str = NULL; rv->len = 0; rv->allocated_len = 0; // initialize with empty string - rv = sb_string_append(rv, ""); + rv = bc_string_append(rv, ""); return rv; } char* -sb_string_free(sb_string_t *str, bool free_str) +bc_string_free(bc_string_t *str, bool free_str) { if (str == NULL) return NULL; @@ -369,18 +369,18 @@ sb_string_free(sb_string_t *str, bool free_str) } -sb_string_t* -sb_string_dup(sb_string_t *str) +bc_string_t* +bc_string_dup(bc_string_t *str) { if (str == NULL) return NULL; - sb_string_t* new = sb_string_new(); - return sb_string_append_len(new, str->str, str->len); + bc_string_t* new = bc_string_new(); + return bc_string_append_len(new, str->str, str->len); } -sb_string_t* -sb_string_append_len(sb_string_t *str, const char *suffix, size_t len) +bc_string_t* +bc_string_append_len(bc_string_t *str, const char *suffix, size_t len) { if (str == NULL) return NULL; @@ -390,7 +390,7 @@ sb_string_append_len(sb_string_t *str, const char *suffix, size_t len) str->len += len; if (str->len + 1 > str->allocated_len) { str->allocated_len = (((str->len + 1) / SB_STRING_CHUNK_SIZE) + 1) * SB_STRING_CHUNK_SIZE; - str->str = sb_realloc(str->str, str->allocated_len); + str->str = bc_realloc(str->str, str->allocated_len); } memcpy(str->str + old_len, suffix, len); str->str[str->len] = '\0'; @@ -398,18 +398,18 @@ sb_string_append_len(sb_string_t *str, const char *suffix, size_t len) } -sb_string_t* -sb_string_append(sb_string_t *str, const char *suffix) +bc_string_t* +bc_string_append(bc_string_t *str, const char *suffix) { if (str == NULL) return NULL; const char *my_suffix = suffix == NULL ? "" : suffix; - return sb_string_append_len(str, my_suffix, strlen(my_suffix)); + return bc_string_append_len(str, my_suffix, strlen(my_suffix)); } -sb_string_t* -sb_string_append_c(sb_string_t *str, char c) +bc_string_t* +bc_string_append_c(bc_string_t *str, char c) { if (str == NULL) return NULL; @@ -417,7 +417,7 @@ sb_string_append_c(sb_string_t *str, char c) str->len += 1; if (str->len + 1 > str->allocated_len) { str->allocated_len = (((str->len + 1) / SB_STRING_CHUNK_SIZE) + 1) * SB_STRING_CHUNK_SIZE; - str->str = sb_realloc(str->str, str->allocated_len); + str->str = bc_realloc(str->str, str->allocated_len); } str->str[old_len] = c; str->str[str->len] = '\0'; @@ -425,23 +425,23 @@ sb_string_append_c(sb_string_t *str, char c) } -sb_string_t* -sb_string_append_printf(sb_string_t *str, const char *format, ...) +bc_string_t* +bc_string_append_printf(bc_string_t *str, const char *format, ...) { if (str == NULL) return NULL; va_list ap; va_start(ap, format); - char *tmp = sb_strdup_vprintf(format, ap); + char *tmp = bc_strdup_vprintf(format, ap); va_end(ap); - str = sb_string_append(str, tmp); + str = bc_string_append(str, tmp); free(tmp); return str; } -sb_string_t* -sb_string_append_escaped(sb_string_t *str, const char *suffix) +bc_string_t* +bc_string_append_escaped(bc_string_t *str, const char *suffix) { if (str == NULL) return NULL; @@ -454,16 +454,16 @@ sb_string_append_escaped(sb_string_t *str, const char *suffix) continue; } escaped = false; - str = sb_string_append_c(str, suffix[i]); + str = bc_string_append_c(str, suffix[i]); } return str; } -sb_trie_t* -sb_trie_new(sb_free_func_t free_func) +bc_trie_t* +bc_trie_new(bc_free_func_t free_func) { - sb_trie_t *trie = sb_malloc(sizeof(sb_trie_t)); + bc_trie_t *trie = bc_malloc(sizeof(bc_trie_t)); trie->root = NULL; trie->free_func = free_func; return trie; @@ -471,43 +471,43 @@ sb_trie_new(sb_free_func_t free_func) static void -sb_trie_free_node(sb_trie_t *trie, sb_trie_node_t *node) +bc_trie_free_node(bc_trie_t *trie, bc_trie_node_t *node) { if (trie == NULL || node == NULL) return; if (node->data != NULL && trie->free_func != NULL) trie->free_func(node->data); - sb_trie_free_node(trie, node->next); - sb_trie_free_node(trie, node->child); + bc_trie_free_node(trie, node->next); + bc_trie_free_node(trie, node->child); free(node); } void -sb_trie_free(sb_trie_t *trie) +bc_trie_free(bc_trie_t *trie) { if (trie == NULL) return; - sb_trie_free_node(trie, trie->root); + bc_trie_free_node(trie, trie->root); free(trie); } void -sb_trie_insert(sb_trie_t *trie, const char *key, void *data) +bc_trie_insert(bc_trie_t *trie, const char *key, void *data) { if (trie == NULL || key == NULL || data == NULL) return; - sb_trie_node_t *parent = NULL; - sb_trie_node_t *previous; - sb_trie_node_t *current; - sb_trie_node_t *tmp; + bc_trie_node_t *parent = NULL; + bc_trie_node_t *previous; + bc_trie_node_t *current; + bc_trie_node_t *tmp; while (1) { if (trie->root == NULL || (parent != NULL && parent->child == NULL)) { - current = sb_malloc(sizeof(sb_trie_node_t)); + current = bc_malloc(sizeof(bc_trie_node_t)); current->key = *key; current->data = NULL; current->next = NULL; @@ -533,7 +533,7 @@ sb_trie_insert(sb_trie_t *trie, const char *key, void *data) if (previous == NULL || parent != NULL) goto clean; - current = sb_malloc(sizeof(sb_trie_node_t)); + current = bc_malloc(sizeof(bc_trie_node_t)); current->key = *key; current->data = NULL; current->next = NULL; @@ -554,13 +554,13 @@ clean: void* -sb_trie_lookup(sb_trie_t *trie, const char *key) +bc_trie_lookup(bc_trie_t *trie, const char *key) { if (trie == NULL || trie->root == NULL || key == NULL) return NULL; - sb_trie_node_t *parent = trie->root; - sb_trie_node_t *tmp; + bc_trie_node_t *parent = trie->root; + bc_trie_node_t *tmp; while (1) { for (tmp = parent; tmp != NULL; tmp = tmp->next) { @@ -583,7 +583,7 @@ sb_trie_lookup(sb_trie_t *trie, const char *key) static void -sb_trie_size_node(sb_trie_node_t *node, size_t *count) +bc_trie_size_node(bc_trie_node_t *node, size_t *count) { if (node == NULL || count == NULL) return; @@ -591,26 +591,26 @@ sb_trie_size_node(sb_trie_node_t *node, size_t *count) if (node->key == '\0') (*count)++; - sb_trie_size_node(node->next, count); - sb_trie_size_node(node->child, count); + bc_trie_size_node(node->next, count); + bc_trie_size_node(node->child, count); } size_t -sb_trie_size(sb_trie_t *trie) +bc_trie_size(bc_trie_t *trie) { if (trie == NULL) return 0; size_t count = 0; - sb_trie_size_node(trie->root, &count); + bc_trie_size_node(trie->root, &count); return count; } static void -sb_trie_foreach_node(sb_trie_node_t *node, sb_string_t *str, - sb_trie_foreach_func_t func, void *user_data) +bc_trie_foreach_node(bc_trie_node_t *node, bc_string_t *str, + bc_trie_foreach_func_t func, void *user_data) { if (node == NULL || str == NULL || func == NULL) return; @@ -621,25 +621,25 @@ sb_trie_foreach_node(sb_trie_node_t *node, sb_string_t *str, } if (node->child != NULL) { - sb_string_t *child = sb_string_dup(str); - child = sb_string_append_c(child, node->key); - sb_trie_foreach_node(node->child, child, func, user_data); - sb_string_free(child, true); + bc_string_t *child = bc_string_dup(str); + child = bc_string_append_c(child, node->key); + bc_trie_foreach_node(node->child, child, func, user_data); + bc_string_free(child, true); } if (node->next != NULL) - sb_trie_foreach_node(node->next, str, func, user_data); + bc_trie_foreach_node(node->next, str, func, user_data); } void -sb_trie_foreach(sb_trie_t *trie, sb_trie_foreach_func_t func, +bc_trie_foreach(bc_trie_t *trie, bc_trie_foreach_func_t func, void *user_data) { if (trie == NULL || trie->root == NULL || func == NULL) return; - sb_string_t *str = sb_string_new(); - sb_trie_foreach_node(trie->root, str, func, user_data); - sb_string_free(str, true); + bc_string_t *str = bc_string_new(); + bc_trie_foreach_node(trie->root, str, func, user_data); + bc_string_free(str, true); } diff --git a/src/common/utils.h b/src/common/utils.h index aca02c0..020f243 100644 --- a/src/common/utils.h +++ b/src/common/utils.h @@ -16,43 +16,43 @@ // memory -typedef void (*sb_free_func_t) (void *ptr); +typedef void (*bc_free_func_t) (void *ptr); -void* sb_malloc(size_t size); -void* sb_realloc(void *ptr, size_t size); +void* bc_malloc(size_t size); +void* bc_realloc(void *ptr, size_t size); // slist -typedef struct _sb_slist_t { - struct _sb_slist_t *next; +typedef struct _bc_slist_t { + struct _bc_slist_t *next; void *data; -} sb_slist_t; +} bc_slist_t; -sb_slist_t* sb_slist_append(sb_slist_t *l, void *data); -sb_slist_t* sb_slist_prepend(sb_slist_t *l, void *data); -void sb_slist_free(sb_slist_t *l); -void sb_slist_free_full(sb_slist_t *l, sb_free_func_t free_func); -size_t sb_slist_length(sb_slist_t *l); +bc_slist_t* bc_slist_append(bc_slist_t *l, void *data); +bc_slist_t* bc_slist_prepend(bc_slist_t *l, void *data); +void bc_slist_free(bc_slist_t *l); +void bc_slist_free_full(bc_slist_t *l, bc_free_func_t free_func); +size_t bc_slist_length(bc_slist_t *l); // strfuncs -char* sb_strdup(const char *s); -char* sb_strndup(const char *s, size_t n); -char* sb_strdup_vprintf(const char *format, va_list ap); -char* sb_strdup_printf(const char *format, ...); -bool sb_str_starts_with(const char *str, const char *prefix); -bool sb_str_ends_with(const char *str, const char *suffix); -char* sb_str_lstrip(char *str); -char* sb_str_rstrip(char *str); -char* sb_str_strip(char *str); -char** sb_str_split(const char *str, char c, unsigned int max_pieces); -char* sb_str_replace(const char *str, const char search, const char *replace); -char* sb_str_find(const char *str, char c); -void sb_strv_free(char **strv); -char* sb_strv_join(char **strv, const char *separator); -size_t sb_strv_length(char **strv); +char* bc_strdup(const char *s); +char* bc_strndup(const char *s, size_t n); +char* bc_strdup_vprintf(const char *format, va_list ap); +char* bc_strdup_printf(const char *format, ...); +bool bc_str_starts_with(const char *str, const char *prefix); +bool bc_str_ends_with(const char *str, const char *suffix); +char* bc_str_lstrip(char *str); +char* bc_str_rstrip(char *str); +char* bc_str_strip(char *str); +char** bc_str_split(const char *str, char c, unsigned int max_pieces); +char* bc_str_replace(const char *str, const char search, const char *replace); +char* bc_str_find(const char *str, char c); +void bc_strv_free(char **strv); +char* bc_strv_join(char **strv, const char *separator); +size_t bc_strv_length(char **strv); // string @@ -61,42 +61,42 @@ typedef struct { char *str; size_t len; size_t allocated_len; -} sb_string_t; +} bc_string_t; -sb_string_t* sb_string_new(void); -char* sb_string_free(sb_string_t *str, bool free_str); -sb_string_t* sb_string_dup(sb_string_t *str); -sb_string_t* sb_string_append_len(sb_string_t *str, const char *suffix, size_t len); -sb_string_t* sb_string_append(sb_string_t *str, const char *suffix); -sb_string_t* sb_string_append_c(sb_string_t *str, char c); -sb_string_t* sb_string_append_printf(sb_string_t *str, const char *format, ...); -sb_string_t* sb_string_append_escaped(sb_string_t *str, const char *suffix); +bc_string_t* bc_string_new(void); +char* bc_string_free(bc_string_t *str, bool free_str); +bc_string_t* bc_string_dup(bc_string_t *str); +bc_string_t* bc_string_append_len(bc_string_t *str, const char *suffix, size_t len); +bc_string_t* bc_string_append(bc_string_t *str, const char *suffix); +bc_string_t* bc_string_append_c(bc_string_t *str, char c); +bc_string_t* bc_string_append_printf(bc_string_t *str, const char *format, ...); +bc_string_t* bc_string_append_escaped(bc_string_t *str, const char *suffix); // trie -typedef struct _sb_trie_node_t { +typedef struct _bc_trie_node_t { char key; void *data; - struct _sb_trie_node_t *next, *child; -} sb_trie_node_t; + struct _bc_trie_node_t *next, *child; +} bc_trie_node_t; -struct _sb_trie_t { - sb_trie_node_t *root; - sb_free_func_t free_func; +struct _bc_trie_t { + bc_trie_node_t *root; + bc_free_func_t free_func; }; -typedef struct _sb_trie_t sb_trie_t; +typedef struct _bc_trie_t bc_trie_t; -typedef void (*sb_trie_foreach_func_t)(const char *key, void *data, +typedef void (*bc_trie_foreach_func_t)(const char *key, void *data, void *user_data); -sb_trie_t* sb_trie_new(sb_free_func_t free_func); -void sb_trie_free(sb_trie_t *trie); -void sb_trie_insert(sb_trie_t *trie, const char *key, void *data); -void* sb_trie_lookup(sb_trie_t *trie, const char *key); -size_t sb_trie_size(sb_trie_t *trie); -void sb_trie_foreach(sb_trie_t *trie, sb_trie_foreach_func_t func, +bc_trie_t* bc_trie_new(bc_free_func_t free_func); +void bc_trie_free(bc_trie_t *trie); +void bc_trie_insert(bc_trie_t *trie, const char *key, void *data); +void* bc_trie_lookup(bc_trie_t *trie, const char *key); +size_t bc_trie_size(bc_trie_t *trie); +void bc_trie_foreach(bc_trie_t *trie, bc_trie_foreach_func_t func, void *user_data); #endif /* _UTILS_H */ |