aboutsummaryrefslogtreecommitdiffstats
path: root/src/common
diff options
context:
space:
mode:
Diffstat (limited to 'src/common')
-rw-r--r--src/common/utf8.c2
-rw-r--r--src/common/utf8.h2
-rw-r--r--src/common/utils.c206
-rw-r--r--src/common/utils.h98
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 */