diogo/libcfu
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove redundant use of extern storage class specifier

Browse Source
This commit is contained in:
Matthew Brush 2013-03-04 20:10:32 -08:00
parent b1db0ad1ee
commit 9926984543
16 changed files with 237 additions and 237 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/cfu.c
View File

@ -41,31 +41,31 @@ struct libcfu_item {
libcfu_type type; libcfu_type type;
}; };
extern libcfu_type libcfu_type
cfu_get_type(void *item) { cfu_get_type(void *item) {
if (!item) return libcfu_t_none; if (!item) return libcfu_t_none;
return ((libcfu_item_t *)item)->type; return ((libcfu_item_t *)item)->type;
} }
extern int int
cfu_is_hash(void *item) { cfu_is_hash(void *item) {
if (cfu_get_type(item) == libcfu_t_hash_table) return 1; if (cfu_get_type(item) == libcfu_t_hash_table) return 1;
return 0; return 0;
} }
extern int int
cfu_is_list(void *item) { cfu_is_list(void *item) {
if (cfu_get_type(item) == libcfu_t_list) return 1; if (cfu_get_type(item) == libcfu_t_list) return 1;
return 0; return 0;
} }
extern int int
cfu_is_string(void *item) { cfu_is_string(void *item) {
if (cfu_get_type(item) == libcfu_t_string) return 1; if (cfu_get_type(item) == libcfu_t_string) return 1;
return 0; return 0;
} }
extern int int
cfu_is_time(void *item) { cfu_is_time(void *item) {
if (cfu_get_type(item) == libcfu_t_time) return 1; if (cfu_get_type(item) == libcfu_t_time) return 1;
return 0; return 0;
@ -79,7 +79,7 @@ cfu_is_timer(void *item)
return 0; return 0;
} }
extern int int
cfu_is_conf(void *item) { cfu_is_conf(void *item) {
if (cfu_get_type(item) == libcfu_t_conf) return 1; if (cfu_get_type(item) == libcfu_t_conf) return 1;
return 0; return 0;

12
src/cfu.h
View File

@ -63,13 +63,13 @@ typedef enum { libcfu_t_none = 0, libcfu_t_hash_table, libcfu_t_list, libcfu_t_s
typedef struct libcfu_item libcfu_item_t; typedef struct libcfu_item libcfu_item_t;
extern libcfu_type cfu_get_type(void *item); libcfu_type cfu_get_type(void *item);
extern int cfu_is_hash(void *item); int cfu_is_hash(void *item);
extern int cfu_is_list(void *item); int cfu_is_list(void *item);
extern int cfu_is_string(void *item); int cfu_is_string(void *item);
extern int cfu_is_time(void *item); int cfu_is_time(void *item);
int cfu_is_timer(void *item); int cfu_is_timer(void *item);
extern int cfu_is_conf(void *item); int cfu_is_conf(void *item);
CFU_END_DECLS CFU_END_DECLS

18
src/cfuconf.c
View File

@ -132,7 +132,7 @@ _directive_free_fn(void *data) {
cfulist_destroy_with_free_fn(list, _directive_free_val_list_fn); cfulist_destroy_with_free_fn(list, _directive_free_val_list_fn);
} }
extern void void
cfuconf_destroy(cfuconf_t *conf) { cfuconf_destroy(cfuconf_t *conf) {
if (conf->containers) { if (conf->containers) {
/* cfuhash_foreach(conf->containers, _container_free_foreach_fn, NULL); */ /* cfuhash_foreach(conf->containers, _container_free_foreach_fn, NULL); */
@ -146,13 +146,13 @@ cfuconf_destroy(cfuconf_t *conf) {
free(conf); free(conf);
} }
extern cfuhash_table_t * cfuhash_table_t *
cfuconf_get_containers(cfuconf_t *conf) { cfuconf_get_containers(cfuconf_t *conf) {
if (!conf) return NULL; if (!conf) return NULL;
return conf->containers; return conf->containers;
} }
extern cfuhash_table_t * cfuhash_table_t *
cfuconf_get_directives(cfuconf_t *conf) { cfuconf_get_directives(cfuconf_t *conf) {
if (!conf) return NULL; if (!conf) return NULL;
return conf->directives; return conf->directives;
@ -188,7 +188,7 @@ _get_directive_last_val_list(cfuconf_t *conf, char *directive, cfulist_t **val_l
} }
extern int int
cfuconf_get_directive_one_arg(cfuconf_t *conf, char *directive, char **rvalue) { cfuconf_get_directive_one_arg(cfuconf_t *conf, char *directive, char **rvalue) {
cfulist_t *val_list = NULL; cfulist_t *val_list = NULL;
void *val = NULL; void *val = NULL;
@ -205,12 +205,12 @@ cfuconf_get_directive_one_arg(cfuconf_t *conf, char *directive, char **rvalue) {
return -1; return -1;
} }
extern int int
cfuconf_get_directive_two_args(cfuconf_t *conf, char *directive, char **rvalue, char **rvalue2) { cfuconf_get_directive_two_args(cfuconf_t *conf, char *directive, char **rvalue, char **rvalue2) {
return cfuconf_get_directive_n_args(conf, directive, 2, rvalue, rvalue2); return cfuconf_get_directive_n_args(conf, directive, 2, rvalue, rvalue2);
} }
extern int int
cfuconf_get_directive_n_args(cfuconf_t *conf, char *directive, size_t n, ...) { cfuconf_get_directive_n_args(cfuconf_t *conf, char *directive, size_t n, ...) {
va_list ap; va_list ap;
size_t i = 0; size_t i = 0;
@ -605,7 +605,7 @@ _cfuconf_parse_list(cfulist_t *lines, char **error) {
return conf; return conf;
} }
extern int int
cfuconf_parse_file(char *file_path, cfuconf_t **ret_conf, char **error) { cfuconf_parse_file(char *file_path, cfuconf_t **ret_conf, char **error) {
FILE *fp = NULL; FILE *fp = NULL;
cfulist_t *lines = NULL; cfulist_t *lines = NULL;
@ -630,7 +630,7 @@ cfuconf_parse_file(char *file_path, cfuconf_t **ret_conf, char **error) {
return -1; return -1;
} }
extern int int
cfuconf_parse_buffer(char *buffer, cfuconf_t **ret_conf, char **error) { cfuconf_parse_buffer(char *buffer, cfuconf_t **ret_conf, char **error) {
cfulist_t *lines = cfulist_new(); cfulist_t *lines = cfulist_new();
char **strings = NULL; char **strings = NULL;
@ -811,7 +811,7 @@ print_conf(cfuconf_t *conf, size_t depth, FILE *fp) {
free(ds); free(ds);
} }
extern void void
cfuconf_pretty_print_conf(cfuconf_t *conf, FILE *fp, size_t indent_level) { cfuconf_pretty_print_conf(cfuconf_t *conf, FILE *fp, size_t indent_level) {
print_conf(conf, indent_level, fp); print_conf(conf, indent_level, fp);
} }

18
src/cfuconf.h
View File

@ -82,34 +82,34 @@ typedef struct cfuconf cfuconf_t;
* and error is not NULL, it will be set to an error message * and error is not NULL, it will be set to an error message
* (which must be free()'d by the caller). * (which must be free()'d by the caller).
*/ */
extern int cfuconf_parse_file(char *file_path, cfuconf_t **conf, char **error); int cfuconf_parse_file(char *file_path, cfuconf_t **conf, char **error);
/* Same as cfuconf_parse_file(), except assume the contents of the /* Same as cfuconf_parse_file(), except assume the contents of the
* file are already in buffer. * file are already in buffer.
*/ */
extern int cfuconf_parse_buffer(char *buffer, cfuconf_t **conf, char **error); int cfuconf_parse_buffer(char *buffer, cfuconf_t **conf, char **error);
/* Free all resources used by the cfuconf_t structure */ /* Free all resources used by the cfuconf_t structure */
extern void cfuconf_destroy(cfuconf_t *conf); void cfuconf_destroy(cfuconf_t *conf);
/* Get a hash of containers at the top level of conf */ /* Get a hash of containers at the top level of conf */
extern cfuhash_table_t * cfuconf_get_containers(cfuconf_t *conf); cfuhash_table_t * cfuconf_get_containers(cfuconf_t *conf);
/* Get a hash of directives at the to level */ /* Get a hash of directives at the to level */
extern cfuhash_table_t * cfuconf_get_directives(cfuconf_t *conf); cfuhash_table_t * cfuconf_get_directives(cfuconf_t *conf);
/* Get the value of the given directive, assuming there is only one argument */ /* Get the value of the given directive, assuming there is only one argument */
extern int cfuconf_get_directive_one_arg(cfuconf_t *conf, char *directive, char **rvalue); int cfuconf_get_directive_one_arg(cfuconf_t *conf, char *directive, char **rvalue);
/* Get the value of the given directive, assuming there are two arguments */ /* Get the value of the given directive, assuming there are two arguments */
extern int cfuconf_get_directive_two_args(cfuconf_t *conf, char *directive, char **rvalue, int cfuconf_get_directive_two_args(cfuconf_t *conf, char *directive, char **rvalue,
char **rvalue2); char **rvalue2);
/* Get the value of the given directives, with n arguments */ /* Get the value of the given directives, with n arguments */
extern int cfuconf_get_directive_n_args(cfuconf_t *conf, char *directive, size_t n, ...); int cfuconf_get_directive_n_args(cfuconf_t *conf, char *directive, size_t n, ...);
/* Print out a representation of the parsed configuration */ /* Print out a representation of the parsed configuration */
extern void cfuconf_pretty_print_conf(cfuconf_t *conf, FILE *fp, size_t indent_level); void cfuconf_pretty_print_conf(cfuconf_t *conf, FILE *fp, size_t indent_level);
CFU_END_DECLS CFU_END_DECLS

78
src/cfuhash.c
View File

@ -201,29 +201,29 @@ _cfuhash_new(size_t size, u_int32_t flags) {
return ht; return ht;
} }
extern cfuhash_table_t * cfuhash_table_t *
cfuhash_new(void) { cfuhash_new(void) {
return _cfuhash_new(8, CFUHASH_FROZEN_UNTIL_GROWS); return _cfuhash_new(8, CFUHASH_FROZEN_UNTIL_GROWS);
} }
extern cfuhash_table_t * cfuhash_table_t *
cfuhash_new_with_initial_size(size_t size) { cfuhash_new_with_initial_size(size_t size) {
if (size == 0) size = 8; if (size == 0) size = 8;
return _cfuhash_new(size, CFUHASH_FROZEN_UNTIL_GROWS); return _cfuhash_new(size, CFUHASH_FROZEN_UNTIL_GROWS);
} }
extern cfuhash_table_t * cfuhash_table_t *
cfuhash_new_with_flags(u_int32_t flags) { cfuhash_new_with_flags(u_int32_t flags) {
return _cfuhash_new(8, CFUHASH_FROZEN_UNTIL_GROWS|flags); return _cfuhash_new(8, CFUHASH_FROZEN_UNTIL_GROWS|flags);
} }
extern cfuhash_table_t * cfuhash_new_with_free_fn(cfuhash_free_fn_t ff) { cfuhash_table_t * cfuhash_new_with_free_fn(cfuhash_free_fn_t ff) {
cfuhash_table_t *ht = _cfuhash_new(8, CFUHASH_FROZEN_UNTIL_GROWS); cfuhash_table_t *ht = _cfuhash_new(8, CFUHASH_FROZEN_UNTIL_GROWS);
cfuhash_set_free_function(ht, ff); cfuhash_set_free_function(ht, ff);
return ht; return ht;
} }
extern int int
cfuhash_copy(cfuhash_table_t *src, cfuhash_table_t *dst) { cfuhash_copy(cfuhash_table_t *src, cfuhash_table_t *dst) {
size_t num_keys = 0; size_t num_keys = 0;
void **keys = NULL; void **keys = NULL;
@ -247,7 +247,7 @@ cfuhash_copy(cfuhash_table_t *src, cfuhash_table_t *dst) {
return 1; return 1;
} }
extern cfuhash_table_t * cfuhash_table_t *
cfuhash_merge(cfuhash_table_t *ht1, cfuhash_table_t *ht2, u_int32_t flags) { cfuhash_merge(cfuhash_table_t *ht1, cfuhash_table_t *ht2, u_int32_t flags) {
cfuhash_table_t *new_ht = NULL; cfuhash_table_t *new_ht = NULL;
@ -260,27 +260,27 @@ cfuhash_merge(cfuhash_table_t *ht1, cfuhash_table_t *ht2, u_int32_t flags) {
} }
/* returns the flags */ /* returns the flags */
extern u_int32_t u_int32_t
cfuhash_get_flags(cfuhash_table_t *ht) { cfuhash_get_flags(cfuhash_table_t *ht) {
return ht->flags; return ht->flags;
} }
/* sets the given flag and returns the old flags value */ /* sets the given flag and returns the old flags value */
extern u_int32_t u_int32_t
cfuhash_set_flag(cfuhash_table_t *ht, u_int32_t new_flag) { cfuhash_set_flag(cfuhash_table_t *ht, u_int32_t new_flag) {
u_int32_t flags = ht->flags; u_int32_t flags = ht->flags;
ht->flags = flags | new_flag; ht->flags = flags | new_flag;
return flags; return flags;
} }
extern u_int32_t u_int32_t
cfuhash_clear_flag(cfuhash_table_t *ht, u_int32_t new_flag) { cfuhash_clear_flag(cfuhash_table_t *ht, u_int32_t new_flag) {
u_int32_t flags = ht->flags; u_int32_t flags = ht->flags;
ht->flags = flags & ~new_flag; ht->flags = flags & ~new_flag;
return flags; return flags;
} }
extern int int
cfuhash_set_thresholds(cfuhash_table_t *ht, float low, float high) { cfuhash_set_thresholds(cfuhash_table_t *ht, float low, float high) {
float h = high < 0 ? ht->high : high; float h = high < 0 ? ht->high : high;
float l = low < 0 ? ht->low : low; float l = low < 0 ? ht->low : low;
@ -294,7 +294,7 @@ cfuhash_set_thresholds(cfuhash_table_t *ht, float low, float high) {
} }
/* Sets the hash function for the hash table ht. Pass NULL for hf to reset to the default */ /* Sets the hash function for the hash table ht. Pass NULL for hf to reset to the default */
extern int int
cfuhash_set_hash_function(cfuhash_table_t *ht, cfuhash_function_t hf) { cfuhash_set_hash_function(cfuhash_table_t *ht, cfuhash_function_t hf) {
/* can't allow changing the hash function if the hash already contains entries */ /* can't allow changing the hash function if the hash already contains entries */
if (ht->entries) return -1; if (ht->entries) return -1;
@ -303,7 +303,7 @@ cfuhash_set_hash_function(cfuhash_table_t *ht, cfuhash_function_t hf) {
return 0; return 0;
} }
extern int int
cfuhash_set_free_function(cfuhash_table_t * ht, cfuhash_free_fn_t ff) { cfuhash_set_free_function(cfuhash_table_t * ht, cfuhash_free_fn_t ff) {
if (ff) ht->free_fn = ff; if (ff) ht->free_fn = ff;
return 0; return 0;
@ -327,7 +327,7 @@ unlock_hash(cfuhash_table_t *ht) {
#endif #endif
} }
extern int int
cfuhash_lock(cfuhash_table_t *ht) { cfuhash_lock(cfuhash_table_t *ht) {
#ifdef HAVE_PTHREAD_H #ifdef HAVE_PTHREAD_H
pthread_mutex_lock(&ht->mutex); pthread_mutex_lock(&ht->mutex);
@ -335,7 +335,7 @@ cfuhash_lock(cfuhash_table_t *ht) {
return 1; return 1;
} }
extern int int
cfuhash_unlock(cfuhash_table_t *ht) { cfuhash_unlock(cfuhash_table_t *ht) {
#ifdef HAVE_PTHREAD_H #ifdef HAVE_PTHREAD_H
pthread_mutex_unlock(&ht->mutex); pthread_mutex_unlock(&ht->mutex);
@ -381,7 +381,7 @@ hash_add_entry(cfuhash_table_t *ht, unsigned int hv, const void *key, size_t key
Returns one if the entry was found, zero otherwise. If found, r is Returns one if the entry was found, zero otherwise. If found, r is
changed to point to the data in the entry. changed to point to the data in the entry.
*/ */
extern int int
cfuhash_get_data(cfuhash_table_t *ht, const void *key, size_t key_size, void **r, cfuhash_get_data(cfuhash_table_t *ht, const void *key, size_t key_size, void **r,
size_t *data_size) { size_t *data_size) {
unsigned int hv = 0; unsigned int hv = 0;
@ -417,7 +417,7 @@ cfuhash_get_data(cfuhash_table_t *ht, const void *key, size_t key_size, void **r
/* /*
Assumes the key is a null-terminated string, returns the data, or NULL if not found. Note that it is possible for the data itself to be NULL Assumes the key is a null-terminated string, returns the data, or NULL if not found. Note that it is possible for the data itself to be NULL
*/ */
extern void * void *
cfuhash_get(cfuhash_table_t *ht, const char *key) { cfuhash_get(cfuhash_table_t *ht, const char *key) {
void *r = NULL; void *r = NULL;
int rv = 0; int rv = 0;
@ -428,7 +428,7 @@ cfuhash_get(cfuhash_table_t *ht, const char *key) {
} }
/* Returns 1 if an entry exists in the table for the given key, 0 otherwise */ /* Returns 1 if an entry exists in the table for the given key, 0 otherwise */
extern int int
cfuhash_exists_data(cfuhash_table_t *ht, const void *key, size_t key_size) { cfuhash_exists_data(cfuhash_table_t *ht, const void *key, size_t key_size) {
void *r = NULL; void *r = NULL;
int rv = cfuhash_get_data(ht, key, key_size, &r, NULL); int rv = cfuhash_get_data(ht, key, key_size, &r, NULL);
@ -437,7 +437,7 @@ cfuhash_exists_data(cfuhash_table_t *ht, const void *key, size_t key_size) {
} }
/* Same as cfuhash_exists_data(), except assumes key is a null-terminated string */ /* Same as cfuhash_exists_data(), except assumes key is a null-terminated string */
extern int int
cfuhash_exists(cfuhash_table_t *ht, const char *key) { cfuhash_exists(cfuhash_table_t *ht, const char *key) {
return cfuhash_exists_data(ht, (const void *)key, -1); return cfuhash_exists_data(ht, (const void *)key, -1);
} }
@ -448,7 +448,7 @@ cfuhash_exists(cfuhash_table_t *ht, const char *key) {
value is zero. If a new entry is created for the key, the function value is zero. If a new entry is created for the key, the function
returns 1. returns 1.
*/ */
extern int int
cfuhash_put_data(cfuhash_table_t *ht, const void *key, size_t key_size, void *data, cfuhash_put_data(cfuhash_table_t *ht, const void *key, size_t key_size, void *data,
size_t data_size, void **r) { size_t data_size, void **r) {
unsigned int hv = 0; unsigned int hv = 0;
@ -499,7 +499,7 @@ cfuhash_put_data(cfuhash_table_t *ht, const void *key, size_t key_size, void *da
null-terminated string, and the old value is returned if it existed, null-terminated string, and the old value is returned if it existed,
otherwise NULL is returned. otherwise NULL is returned.
*/ */
extern void * void *
cfuhash_put(cfuhash_table_t *ht, const char *key, void *data) { cfuhash_put(cfuhash_table_t *ht, const char *key, void *data) {
void *r = NULL; void *r = NULL;
if (!cfuhash_put_data(ht, (const void *)key, -1, data, 0, &r)) { if (!cfuhash_put_data(ht, (const void *)key, -1, data, 0, &r)) {
@ -508,7 +508,7 @@ cfuhash_put(cfuhash_table_t *ht, const char *key, void *data) {
return NULL; return NULL;
} }
extern void void
cfuhash_clear(cfuhash_table_t *ht) { cfuhash_clear(cfuhash_table_t *ht) {
cfuhash_entry *he = NULL; cfuhash_entry *he = NULL;
cfuhash_entry *hep = NULL; cfuhash_entry *hep = NULL;
@ -538,7 +538,7 @@ cfuhash_clear(cfuhash_table_t *ht) {
} }
extern void * void *
cfuhash_delete_data(cfuhash_table_t *ht, const void *key, size_t key_size) { cfuhash_delete_data(cfuhash_table_t *ht, const void *key, size_t key_size) {
unsigned int hv = 0; unsigned int hv = 0;
cfuhash_entry *he = NULL; cfuhash_entry *he = NULL;
@ -579,12 +579,12 @@ cfuhash_delete_data(cfuhash_table_t *ht, const void *key, size_t key_size) {
return r; return r;
} }
extern void * void *
cfuhash_delete(cfuhash_table_t *ht, const char *key) { cfuhash_delete(cfuhash_table_t *ht, const char *key) {
return cfuhash_delete_data(ht, key, -1); return cfuhash_delete_data(ht, key, -1);
} }
extern void ** void **
cfuhash_keys_data(cfuhash_table_t *ht, size_t *num_keys, size_t **key_sizes, int fast) { cfuhash_keys_data(cfuhash_table_t *ht, size_t *num_keys, size_t **key_sizes, int fast) {
size_t *key_lengths = NULL; size_t *key_lengths = NULL;
void **keys = NULL; void **keys = NULL;
@ -630,12 +630,12 @@ cfuhash_keys_data(cfuhash_table_t *ht, size_t *num_keys, size_t **key_sizes, int
return keys; return keys;
} }
extern void ** void **
cfuhash_keys(cfuhash_table_t *ht, size_t *num_keys, int fast) { cfuhash_keys(cfuhash_table_t *ht, size_t *num_keys, int fast) {
return cfuhash_keys_data(ht, num_keys, NULL, fast); return cfuhash_keys_data(ht, num_keys, NULL, fast);
} }
extern int int
cfuhash_each_data(cfuhash_table_t *ht, void **key, size_t *key_size, void **data, cfuhash_each_data(cfuhash_table_t *ht, void **key, size_t *key_size, void **data,
size_t *data_size) { size_t *data_size) {
@ -645,7 +645,7 @@ cfuhash_each_data(cfuhash_table_t *ht, void **key, size_t *key_size, void **data
return cfuhash_next_data(ht, key, key_size, data, data_size); return cfuhash_next_data(ht, key, key_size, data, data_size);
} }
extern int int
cfuhash_next_data(cfuhash_table_t *ht, void **key, size_t *key_size, void **data, cfuhash_next_data(cfuhash_table_t *ht, void **key, size_t *key_size, void **data,
size_t *data_size) { size_t *data_size) {
@ -687,7 +687,7 @@ _cfuhash_destroy_entry(cfuhash_table_t *ht, cfuhash_entry *he, cfuhash_free_fn_t
free(he); free(he);
} }
extern size_t size_t
cfuhash_foreach_remove(cfuhash_table_t *ht, cfuhash_remove_fn_t r_fn, cfuhash_free_fn_t ff, cfuhash_foreach_remove(cfuhash_table_t *ht, cfuhash_remove_fn_t r_fn, cfuhash_free_fn_t ff,
void *arg) { void *arg) {
cfuhash_entry *entry = NULL; cfuhash_entry *entry = NULL;
@ -732,7 +732,7 @@ cfuhash_foreach_remove(cfuhash_table_t *ht, cfuhash_remove_fn_t r_fn, cfuhash_fr
return num_removed; return num_removed;
} }
extern size_t size_t
cfuhash_foreach(cfuhash_table_t *ht, cfuhash_foreach_fn_t fe_fn, void *arg) { cfuhash_foreach(cfuhash_table_t *ht, cfuhash_foreach_fn_t fe_fn, void *arg) {
cfuhash_entry *entry = NULL; cfuhash_entry *entry = NULL;
size_t hv = 0; size_t hv = 0;
@ -761,19 +761,19 @@ cfuhash_foreach(cfuhash_table_t *ht, cfuhash_foreach_fn_t fe_fn, void *arg) {
return num_accessed; return num_accessed;
} }
extern int int
cfuhash_each(cfuhash_table_t *ht, char **key, void **data) { cfuhash_each(cfuhash_table_t *ht, char **key, void **data) {
size_t key_size = 0; size_t key_size = 0;
return cfuhash_each_data(ht, (void **)key, &key_size, data, NULL); return cfuhash_each_data(ht, (void **)key, &key_size, data, NULL);
} }
extern int int
cfuhash_next(cfuhash_table_t *ht, char **key, void **data) { cfuhash_next(cfuhash_table_t *ht, char **key, void **data) {
size_t key_size = 0; size_t key_size = 0;
return cfuhash_next_data(ht, (void **)key, &key_size, data, NULL); return cfuhash_next_data(ht, (void **)key, &key_size, data, NULL);
} }
extern int int
cfuhash_destroy_with_free_fn(cfuhash_table_t *ht, cfuhash_free_fn_t ff) { cfuhash_destroy_with_free_fn(cfuhash_table_t *ht, cfuhash_free_fn_t ff) {
size_t i; size_t i;
if (!ht) return 0; if (!ht) return 0;
@ -799,7 +799,7 @@ cfuhash_destroy_with_free_fn(cfuhash_table_t *ht, cfuhash_free_fn_t ff) {
return 1; return 1;
} }
extern int int
cfuhash_destroy(cfuhash_table_t *ht) { cfuhash_destroy(cfuhash_table_t *ht) {
return cfuhash_destroy_with_free_fn(ht, NULL); return cfuhash_destroy_with_free_fn(ht, NULL);
} }
@ -818,7 +818,7 @@ _pretty_print_foreach(void *key, size_t key_size, void *data, size_t data_size,
return 0; return 0;
} }
extern int int
cfuhash_pretty_print(cfuhash_table_t *ht, FILE *fp) { cfuhash_pretty_print(cfuhash_table_t *ht, FILE *fp) {
int rv = 0; int rv = 0;
_pretty_print_arg parg; _pretty_print_arg parg;
@ -836,7 +836,7 @@ cfuhash_pretty_print(cfuhash_table_t *ht, FILE *fp) {
return rv; return rv;
} }
extern int int
cfuhash_rehash(cfuhash_table_t *ht) { cfuhash_rehash(cfuhash_table_t *ht) {
size_t new_size, i; size_t new_size, i;
cfuhash_entry **new_buckets = NULL; cfuhash_entry **new_buckets = NULL;
@ -869,19 +869,19 @@ cfuhash_rehash(cfuhash_table_t *ht) {
return 1; return 1;
} }
extern size_t size_t
cfuhash_num_entries(cfuhash_table_t *ht) { cfuhash_num_entries(cfuhash_table_t *ht) {
if (!ht) return 0; if (!ht) return 0;
return ht->entries; return ht->entries;
} }
extern size_t size_t
cfuhash_num_buckets(cfuhash_table_t *ht) { cfuhash_num_buckets(cfuhash_table_t *ht) {
if (!ht) return 0; if (!ht) return 0;
return ht->num_buckets; return ht->num_buckets;
} }
extern size_t size_t
cfuhash_num_buckets_used(cfuhash_table_t *ht) { cfuhash_num_buckets_used(cfuhash_table_t *ht) {
size_t i = 0; size_t i = 0;
size_t count = 0; size_t count = 0;
@ -897,7 +897,7 @@ cfuhash_num_buckets_used(cfuhash_table_t *ht) {
return count; return count;
} }
extern char * char *
cfuhash_bencode_strings(cfuhash_table_t *ht) { cfuhash_bencode_strings(cfuhash_table_t *ht) {
cfustring_t *bencoded = cfustring_new_with_initial_size(16); cfustring_t *bencoded = cfustring_new_with_initial_size(16);
char **keys = NULL; char **keys = NULL;

78
src/cfuhash.h
View File

@ -67,68 +67,68 @@ typedef int (*cfuhash_foreach_fn_t)(void *key, size_t key_size, void *data, size
void *arg); void *arg);
/* Creates a new hash table. */ /* Creates a new hash table. */
extern cfuhash_table_t * cfuhash_new(void); cfuhash_table_t * cfuhash_new(void);
/* Creates a new hash table with the specified size (number of /* Creates a new hash table with the specified size (number of
* buckets). * buckets).
*/ */
extern cfuhash_table_t * cfuhash_new_with_initial_size(size_t size); cfuhash_table_t * cfuhash_new_with_initial_size(size_t size);
/* Creates a new hash table with the specified flags. Pass zero /* Creates a new hash table with the specified flags. Pass zero
* for flags if you want the defaults. * for flags if you want the defaults.
*/ */
extern cfuhash_table_t * cfuhash_new_with_flags(u_int32_t flags); cfuhash_table_t * cfuhash_new_with_flags(u_int32_t flags);
/* Same as cfuhash_new() except automatically calls cfuhash_set_free_fn(). */ /* Same as cfuhash_new() except automatically calls cfuhash_set_free_fn(). */
extern cfuhash_table_t * cfuhash_new_with_free_fn(cfuhash_free_fn_t ff); cfuhash_table_t * cfuhash_new_with_free_fn(cfuhash_free_fn_t ff);
/* Copies entries in src to dst */ /* Copies entries in src to dst */
extern int cfuhash_copy(cfuhash_table_t *src, cfuhash_table_t *dst); int cfuhash_copy(cfuhash_table_t *src, cfuhash_table_t *dst);
/* Returns a new hash containing entries from both hash tables. /* Returns a new hash containing entries from both hash tables.
* For any entries with the same key, the one from ht2 wins. * For any entries with the same key, the one from ht2 wins.
*/ */
extern cfuhash_table_t * cfuhash_merge(cfuhash_table_t *ht1, cfuhash_table_t *ht2, cfuhash_table_t * cfuhash_merge(cfuhash_table_t *ht1, cfuhash_table_t *ht2,
u_int32_t flags); u_int32_t flags);
/* Sets the hashing function to use when computing which bucket to add /* Sets the hashing function to use when computing which bucket to add
* entries to. It should return a 32-bit unsigned integer. By * entries to. It should return a 32-bit unsigned integer. By
* default, Perl's hashing algorithm is used. * default, Perl's hashing algorithm is used.
*/ */
extern int cfuhash_set_hash_function(cfuhash_table_t *ht, cfuhash_function_t hf); int cfuhash_set_hash_function(cfuhash_table_t *ht, cfuhash_function_t hf);
/* Sets the thresholds for when to rehash. The ratio /* Sets the thresholds for when to rehash. The ratio
* num_entries/buckets is compared against low and high. If it is * num_entries/buckets is compared against low and high. If it is
* below 'low' or above 'high', the hash will shrink or grow, * below 'low' or above 'high', the hash will shrink or grow,
* respectively, unless the flags say to do otherwise. * respectively, unless the flags say to do otherwise.
*/ */
extern int cfuhash_set_thresholds(cfuhash_table_t *ht, float low, float high); int cfuhash_set_thresholds(cfuhash_table_t *ht, float low, float high);
/* Sets the function to use when removing an entry from the hash, /* Sets the function to use when removing an entry from the hash,
* i.e., when replacing an existing entry, deleting an entry, or * i.e., when replacing an existing entry, deleting an entry, or
* clearing the hash. It is passed the value of the entry as a * clearing the hash. It is passed the value of the entry as a
* void *. * void *.
*/ */
extern int cfuhash_set_free_function(cfuhash_table_t * ht, cfuhash_free_fn_t ff); int cfuhash_set_free_function(cfuhash_table_t * ht, cfuhash_free_fn_t ff);
/* Returns the hash's flags. See below for flag definitions. */ /* Returns the hash's flags. See below for flag definitions. */
extern u_int32_t cfuhash_get_flags(cfuhash_table_t *ht); u_int32_t cfuhash_get_flags(cfuhash_table_t *ht);
/* Sets a flag. */ /* Sets a flag. */
extern u_int32_t cfuhash_set_flag(cfuhash_table_t *ht, u_int32_t flag); u_int32_t cfuhash_set_flag(cfuhash_table_t *ht, u_int32_t flag);
/* Clears a flag. */ /* Clears a flag. */
extern u_int32_t cfuhash_clear_flag(cfuhash_table_t *ht, u_int32_t new_flag); u_int32_t cfuhash_clear_flag(cfuhash_table_t *ht, u_int32_t new_flag);
/* Returns the value for the entry with given key. If key_size is -1, /* Returns the value for the entry with given key. If key_size is -1,
* key is assumed to be a null-terminated string. If data_size is not * key is assumed to be a null-terminated string. If data_size is not
* NULL, the size of the value is placed into data_size. * NULL, the size of the value is placed into data_size.
*/ */
extern int cfuhash_get_data(cfuhash_table_t *ht, const void *key, size_t key_size, int cfuhash_get_data(cfuhash_table_t *ht, const void *key, size_t key_size,
void **data, size_t *data_size); void **data, size_t *data_size);
/* Returns 1 if an entry with the given key exists in the hash, 0 otherwise. */ /* Returns 1 if an entry with the given key exists in the hash, 0 otherwise. */
extern int cfuhash_exists_data(cfuhash_table_t *ht, const void *key, size_t key_size); int cfuhash_exists_data(cfuhash_table_t *ht, const void *key, size_t key_size);
/* Inserts the given data value into the hash and associates it with /* Inserts the given data value into the hash and associates it with
* key. If key_size is -1, key is assumed to be a null-terminated * key. If key_size is -1, key is assumed to be a null-terminated
@ -137,16 +137,16 @@ extern int cfuhash_exists_data(cfuhash_table_t *ht, const void *key, size_t key_
* data_size is zero, it will be returned as zero when the value is * data_size is zero, it will be returned as zero when the value is
* requested. * requested.
*/ */
extern int cfuhash_put_data(cfuhash_table_t *ht, const void *key, size_t key_size, void *data, int cfuhash_put_data(cfuhash_table_t *ht, const void *key, size_t key_size, void *data,
size_t data_size, void **r); size_t data_size, void **r);
/* Clears the hash table (deletes all entries). */ /* Clears the hash table (deletes all entries). */
extern void cfuhash_clear(cfuhash_table_t *ht); void cfuhash_clear(cfuhash_table_t *ht);
/* Deletes the entry in the hash associated with key. If the entry /* Deletes the entry in the hash associated with key. If the entry
* existed, it's value will be returned. * existed, it's value will be returned.
*/ */
extern void * cfuhash_delete_data(cfuhash_table_t *ht, const void *key, size_t key_size); void * cfuhash_delete_data(cfuhash_table_t *ht, const void *key, size_t key_size);
/* Returns all the keys from the hash. The number of keys is placed /* Returns all the keys from the hash. The number of keys is placed
* into the value pointed to by num_keys. If key_sizes is not NULL, * into the value pointed to by num_keys. If key_sizes is not NULL,
@ -154,7 +154,7 @@ extern void * cfuhash_delete_data(cfuhash_table_t *ht, const void *key, size_t k
* of the keys are returned. Otherwise, pointers to the real keys * of the keys are returned. Otherwise, pointers to the real keys
* will be returned. * will be returned.
*/ */
extern void **cfuhash_keys_data(cfuhash_table_t *ht, size_t *num_keys, size_t **key_sizes, void **cfuhash_keys_data(cfuhash_table_t *ht, size_t *num_keys, size_t **key_sizes,
int fast); int fast);
/* Initializes a loop over all the key/value pairs in the hash. It /* Initializes a loop over all the key/value pairs in the hash. It
@ -162,7 +162,7 @@ extern void **cfuhash_keys_data(cfuhash_table_t *ht, size_t *num_keys, size_t **
* returned if there are any entries in the hash. 0 is returned * returned if there are any entries in the hash. 0 is returned
* otherwise. * otherwise.
*/ */
extern int cfuhash_each_data(cfuhash_table_t *ht, void **key, size_t *key_size, void **data, int cfuhash_each_data(cfuhash_table_t *ht, void **key, size_t *key_size, void **data,
size_t *data_size); size_t *data_size);
/* Gets the next key/value pair from the hash. You must initialize /* Gets the next key/value pair from the hash. You must initialize
@ -170,7 +170,7 @@ extern int cfuhash_each_data(cfuhash_table_t *ht, void **key, size_t *key_size,
* If a entry is left to return, 1 is returned from the function. 0 * If a entry is left to return, 1 is returned from the function. 0
* is returned if there are no more entries in the hash. * is returned if there are no more entries in the hash.
*/ */
extern int cfuhash_next_data(cfuhash_table_t *ht, void **key, size_t *key_size, void **data, int cfuhash_next_data(cfuhash_table_t *ht, void **key, size_t *key_size, void **data,
size_t *data_size); size_t *data_size);
/* Iterates over the key/value pairs in the hash, passing each one /* Iterates over the key/value pairs in the hash, passing each one
@ -178,7 +178,7 @@ extern int cfuhash_next_data(cfuhash_table_t *ht, void **key, size_t *key_size,
* If ff is not NULL, it is the passed the data to be freed. arg * If ff is not NULL, it is the passed the data to be freed. arg
* is passed to r_fn. * is passed to r_fn.
*/ */
extern size_t cfuhash_foreach_remove(cfuhash_table_t *ht, cfuhash_remove_fn_t r_fn, size_t cfuhash_foreach_remove(cfuhash_table_t *ht, cfuhash_remove_fn_t r_fn,
cfuhash_free_fn_t ff, void *arg); cfuhash_free_fn_t ff, void *arg);
/* Iterates over the key/value pairs in the hash, passing each one /* Iterates over the key/value pairs in the hash, passing each one
@ -187,38 +187,38 @@ extern size_t cfuhash_foreach_remove(cfuhash_table_t *ht, cfuhash_remove_fn_t r_
* know what you're doing. A non-zero return value from fe_fn() * know what you're doing. A non-zero return value from fe_fn()
* stops the iteration. * stops the iteration.
*/ */
extern size_t cfuhash_foreach(cfuhash_table_t *ht, cfuhash_foreach_fn_t fe_fn, void *arg); size_t cfuhash_foreach(cfuhash_table_t *ht, cfuhash_foreach_fn_t fe_fn, void *arg);
/* Frees all resources allocated by the hash. If ff is not NULL, it /* Frees all resources allocated by the hash. If ff is not NULL, it
* is called for each hash entry with the value of the entry passed as * is called for each hash entry with the value of the entry passed as
* its only argument. If ff is not NULL, it overrides any function * its only argument. If ff is not NULL, it overrides any function
* set previously with cfuhash_set_free_function(). * set previously with cfuhash_set_free_function().
*/ */
extern int cfuhash_destroy(cfuhash_table_t *ht); int cfuhash_destroy(cfuhash_table_t *ht);
extern int cfuhash_destroy_with_free_fn(cfuhash_table_t *ht, cfuhash_free_fn_t ff); int cfuhash_destroy_with_free_fn(cfuhash_table_t *ht, cfuhash_free_fn_t ff);
/* Rebuild the hash to better accomodate the number of entries. See /* Rebuild the hash to better accomodate the number of entries. See
* cfuhash_set_thresholds(). * cfuhash_set_thresholds().
*/ */
extern int cfuhash_rehash(cfuhash_table_t *ht); int cfuhash_rehash(cfuhash_table_t *ht);
/* Returns the number entries in the hash. */ /* Returns the number entries in the hash. */
extern size_t cfuhash_num_entries(cfuhash_table_t *ht); size_t cfuhash_num_entries(cfuhash_table_t *ht);
/* Returns the number of buckets allocated for the hash. */ /* Returns the number of buckets allocated for the hash. */
extern size_t cfuhash_num_buckets(cfuhash_table_t *ht); size_t cfuhash_num_buckets(cfuhash_table_t *ht);
/* Returns the number of buckets actually used out of the total number /* Returns the number of buckets actually used out of the total number
* allocated for the hash. * allocated for the hash.
*/ */
extern size_t cfuhash_num_buckets_used(cfuhash_table_t *ht); size_t cfuhash_num_buckets_used(cfuhash_table_t *ht);
/* Assumes all the keys and values are null-terminated strings and /* Assumes all the keys and values are null-terminated strings and
* returns a bencoded string representing the hash (see * returns a bencoded string representing the hash (see
* http://www.bittorrent.com/protocol.html) * http://www.bittorrent.com/protocol.html)
*/ */
extern char * cfuhash_bencode_strings(cfuhash_table_t *ht); char * cfuhash_bencode_strings(cfuhash_table_t *ht);
/* Locks the hash. Use this with the each and next functions for /* Locks the hash. Use this with the each and next functions for
* concurrency control. Note that the hash is locked automatically * concurrency control. Note that the hash is locked automatically
@ -226,18 +226,18 @@ extern char * cfuhash_bencode_strings(cfuhash_table_t *ht);
* try to insert something into it, you may get into a deadlock, * try to insert something into it, you may get into a deadlock,
* depending on your system defaults for how mutexes work. * depending on your system defaults for how mutexes work.
*/ */
extern int cfuhash_lock(cfuhash_table_t *ht); int cfuhash_lock(cfuhash_table_t *ht);
/* Unlocks the hash. Use this with the each an next functions for /* Unlocks the hash. Use this with the each an next functions for
* concurrency control. The caveat for cfuhash_lcok() also applies to * concurrency control. The caveat for cfuhash_lcok() also applies to
* this function. * this function.
*/ */
extern int cfuhash_unlock(cfuhash_table_t *ht); int cfuhash_unlock(cfuhash_table_t *ht);
/* Pretty print the hash's key/value pairs to the stream fp. It is /* Pretty print the hash's key/value pairs to the stream fp. It is
* assumed that all the keys and values are null-terminated strings. * assumed that all the keys and values are null-terminated strings.
*/ */
extern int cfuhash_pretty_print(cfuhash_table_t *ht, FILE *fp); int cfuhash_pretty_print(cfuhash_table_t *ht, FILE *fp);
/* These are like the _data versions of these functions, with the /* These are like the _data versions of these functions, with the
* following exceptions: * following exceptions:
@ -245,13 +245,13 @@ extern int cfuhash_pretty_print(cfuhash_table_t *ht, FILE *fp);
* 2) They don't worry about the size of the data. * 2) They don't worry about the size of the data.
* 3) Returned keys or values are the return value of the function. * 3) Returned keys or values are the return value of the function.
*/ */
extern void * cfuhash_get(cfuhash_table_t *ht, const char *key); void * cfuhash_get(cfuhash_table_t *ht, const char *key);
extern int cfuhash_exists(cfuhash_table_t *ht, const char *key); int cfuhash_exists(cfuhash_table_t *ht, const char *key);
extern void * cfuhash_put(cfuhash_table_t *ht, const char *key, void *data); void * cfuhash_put(cfuhash_table_t *ht, const char *key, void *data);
extern void * cfuhash_delete(cfuhash_table_t *ht, const char *key); void * cfuhash_delete(cfuhash_table_t *ht, const char *key);
extern int cfuhash_each(cfuhash_table_t *ht, char **key, void **data); int cfuhash_each(cfuhash_table_t *ht, char **key, void **data);
extern int cfuhash_next(cfuhash_table_t *ht, char **key, void **data); int cfuhash_next(cfuhash_table_t *ht, char **key, void **data);
extern void **cfuhash_keys(cfuhash_table_t *ht, size_t *num_keys, int fast); void **cfuhash_keys(cfuhash_table_t *ht, size_t *num_keys, int fast);
/* hash table flags */ /* hash table flags */

64
src/cfulist.c
View File

@ -71,7 +71,7 @@ struct cfulist {
cfulist_free_fn_t free_fn; cfulist_free_fn_t free_fn;
}; };
extern cfulist_t * cfulist_t *
cfulist_new(void) { cfulist_new(void) {
cfulist_t *list = calloc(1, sizeof(cfulist_t)); cfulist_t *list = calloc(1, sizeof(cfulist_t));
#ifdef HAVE_PTHREAD_H #ifdef HAVE_PTHREAD_H
@ -81,14 +81,14 @@ cfulist_new(void) {
return list; return list;
} }
extern cfulist_t * cfulist_t *
cfulist_new_with_free_fn(cfulist_free_fn_t free_fn) { cfulist_new_with_free_fn(cfulist_free_fn_t free_fn) {
cfulist_t *list = cfulist_new(); cfulist_t *list = cfulist_new();
list->free_fn = free_fn; list->free_fn = free_fn;
return list; return list;
} }
extern size_t size_t
cfulist_num_entries(cfulist_t *list) { cfulist_num_entries(cfulist_t *list) {
return list->num_entries; return list->num_entries;
} }
@ -112,7 +112,7 @@ new_list_entry() {
return calloc(1, sizeof(cfulist_entry)); return calloc(1, sizeof(cfulist_entry));
} }
extern int int
cfulist_push_data(cfulist_t *list, void *data, size_t data_size) { cfulist_push_data(cfulist_t *list, void *data, size_t data_size) {
cfulist_entry *entry = new_list_entry(); cfulist_entry *entry = new_list_entry();
if (!entry) return 0; if (!entry) return 0;
@ -138,7 +138,7 @@ cfulist_push_data(cfulist_t *list, void *data, size_t data_size) {
return 1; return 1;
} }
extern int int
cfulist_pop_data(cfulist_t *list, void **data, size_t *data_size) { cfulist_pop_data(cfulist_t *list, void **data, size_t *data_size) {
if (!list) { if (!list) {
*data = NULL; *data = NULL;
@ -176,7 +176,7 @@ cfulist_pop_data(cfulist_t *list, void **data, size_t *data_size) {
return 0; return 0;
} }
extern int int
cfulist_unshift_data(cfulist_t *list, void *data, size_t data_size) { cfulist_unshift_data(cfulist_t *list, void *data, size_t data_size) {
cfulist_entry *entry = new_list_entry(); cfulist_entry *entry = new_list_entry();
if (!entry) return 0; if (!entry) return 0;
@ -202,7 +202,7 @@ cfulist_unshift_data(cfulist_t *list, void *data, size_t data_size) {
return 1; return 1;
} }
extern int int
cfulist_shift_data(cfulist_t *list, void **data, size_t *data_size) { cfulist_shift_data(cfulist_t *list, void **data, size_t *data_size) {
int rv = 0; int rv = 0;
if (!list) { if (!list) {
@ -241,18 +241,18 @@ cfulist_shift_data(cfulist_t *list, void **data, size_t *data_size) {
return rv; return rv;
} }
extern int int
cfulist_enqueue_data(cfulist_t *list, void *data, size_t data_size) { cfulist_enqueue_data(cfulist_t *list, void *data, size_t data_size) {
return cfulist_push_data(list, data, data_size); return cfulist_push_data(list, data, data_size);
} }
extern int int
cfulist_dequeue_data(cfulist_t *list, void **data, size_t *data_size) { cfulist_dequeue_data(cfulist_t *list, void **data, size_t *data_size) {
return cfulist_shift_data(list, data, data_size); return cfulist_shift_data(list, data, data_size);
} }
extern int int
cfulist_first_data(cfulist_t *list, void **data, size_t *data_size) { cfulist_first_data(cfulist_t *list, void **data, size_t *data_size) {
int rv = 0; int rv = 0;
if (!list) { if (!list) {
@ -274,7 +274,7 @@ cfulist_first_data(cfulist_t *list, void **data, size_t *data_size) {
return rv; return rv;
} }
extern int int
cfulist_last_data(cfulist_t *list, void **data, size_t *data_size) { cfulist_last_data(cfulist_t *list, void **data, size_t *data_size) {
int rv = 0; int rv = 0;
if (!list) { if (!list) {
@ -296,7 +296,7 @@ cfulist_last_data(cfulist_t *list, void **data, size_t *data_size) {
return rv; return rv;
} }
extern int int
cfulist_nth_data(cfulist_t *list, void **data, size_t *data_size, size_t n) { cfulist_nth_data(cfulist_t *list, void **data, size_t *data_size, size_t n) {
int rv = 0; int rv = 0;
size_t i = 0; size_t i = 0;
@ -324,20 +324,20 @@ cfulist_nth_data(cfulist_t *list, void **data, size_t *data_size, size_t n) {
return rv; return rv;
} }
extern void void
cfulist_reset_each(cfulist_t *list) { cfulist_reset_each(cfulist_t *list) {
if (!list) return; if (!list) return;
list->each_ptr = list->entries; list->each_ptr = list->entries;
} }
extern int int
cfulist_each_data(cfulist_t *list, void **data, size_t *data_size) { cfulist_each_data(cfulist_t *list, void **data, size_t *data_size) {
if (!list) return 0; if (!list) return 0;
cfulist_reset_each(list); cfulist_reset_each(list);
return cfulist_next_data(list, data, data_size); return cfulist_next_data(list, data, data_size);
} }
extern int int
cfulist_next_data(cfulist_t *list, void **data, size_t *data_size) { cfulist_next_data(cfulist_t *list, void **data, size_t *data_size) {
if (!list) return 0; if (!list) return 0;
*data = NULL; *data = NULL;
@ -350,7 +350,7 @@ cfulist_next_data(cfulist_t *list, void **data, size_t *data_size) {
return 0; return 0;
} }
extern size_t size_t
cfulist_foreach(cfulist_t *list, cfulist_foreach_fn_t fe_fn, void *arg) { cfulist_foreach(cfulist_t *list, cfulist_foreach_fn_t fe_fn, void *arg) {
cfulist_entry *entry = NULL; cfulist_entry *entry = NULL;
size_t num_processed = 0; size_t num_processed = 0;
@ -384,7 +384,7 @@ _cfulist_map_foreach(void *data, size_t data_size, void *arg) {
return 0; return 0;
} }
extern cfulist_t * cfulist_t *
cfulist_map(cfulist_t *list, cfulist_map_fn_t map_fn, void *arg) { cfulist_map(cfulist_t *list, cfulist_map_fn_t map_fn, void *arg) {
cfulist_t *new_list = cfulist_new(); cfulist_t *new_list = cfulist_new();
_cfulist_map_ds ds; _cfulist_map_ds ds;
@ -398,12 +398,12 @@ cfulist_map(cfulist_t *list, cfulist_map_fn_t map_fn, void *arg) {
/* For when you don't care about the data size */ /* For when you don't care about the data size */
extern int int
cfulist_push(cfulist_t *list, void *data) { cfulist_push(cfulist_t *list, void *data) {
return cfulist_push_data(list, data, 0); return cfulist_push_data(list, data, 0);
} }
extern void * void *
cfulist_pop(cfulist_t *list) { cfulist_pop(cfulist_t *list) {
void *data = NULL; void *data = NULL;
if (cfulist_pop_data(list, &data, NULL)) { if (cfulist_pop_data(list, &data, NULL)) {
@ -412,12 +412,12 @@ cfulist_pop(cfulist_t *list) {
return NULL; return NULL;
} }
extern int int
cfulist_unshift(cfulist_t *list, void *data) { cfulist_unshift(cfulist_t *list, void *data) {
return cfulist_unshift_data(list, data, 0); return cfulist_unshift_data(list, data, 0);
} }
extern void * void *
cfulist_shift(cfulist_t *list) { cfulist_shift(cfulist_t *list) {
void *data = NULL; void *data = NULL;
if (cfulist_shift_data(list, &data, NULL)) { if (cfulist_shift_data(list, &data, NULL)) {
@ -426,24 +426,24 @@ cfulist_shift(cfulist_t *list) {
return NULL; return NULL;
} }
extern int int
cfulist_enqueue(cfulist_t *list, void *data) { cfulist_enqueue(cfulist_t *list, void *data) {
return cfulist_push(list, data); return cfulist_push(list, data);
} }
extern void * void *
cfulist_dequeue(cfulist_t *list) { cfulist_dequeue(cfulist_t *list) {
return cfulist_shift(list); return cfulist_shift(list);
} }
/* Dealing with strings */ /* Dealing with strings */
extern int int
cfulist_push_string(cfulist_t *list, char *data) { cfulist_push_string(cfulist_t *list, char *data) {
return cfulist_push_data(list, (void *)data, -1); return cfulist_push_data(list, (void *)data, -1);
} }
extern char * char *
cfulist_pop_string(cfulist_t *list) { cfulist_pop_string(cfulist_t *list) {
void *data = NULL; void *data = NULL;
if (cfulist_pop_data(list, &data, NULL)) { if (cfulist_pop_data(list, &data, NULL)) {
@ -452,12 +452,12 @@ cfulist_pop_string(cfulist_t *list) {
return NULL; return NULL;
} }
extern int int
cfulist_unshift_string(cfulist_t *list, char *data) { cfulist_unshift_string(cfulist_t *list, char *data) {
return cfulist_unshift_data(list, (void *)data, -1); return cfulist_unshift_data(list, (void *)data, -1);
} }
extern char * char *
cfulist_shift_string(cfulist_t *list) { cfulist_shift_string(cfulist_t *list) {
void *data = NULL; void *data = NULL;
if (cfulist_shift_data(list, &data, NULL)) { if (cfulist_shift_data(list, &data, NULL)) {
@ -466,12 +466,12 @@ cfulist_shift_string(cfulist_t *list) {
return NULL; return NULL;
} }
extern int int
cfulist_enqueue_string(cfulist_t *list, char *data) { cfulist_enqueue_string(cfulist_t *list, char *data) {
return cfulist_push_string(list, data); return cfulist_push_string(list, data);
} }
extern char * char *
cfulist_dequeue_string(cfulist_t *list) { cfulist_dequeue_string(cfulist_t *list) {
return cfulist_shift_string(list); return cfulist_shift_string(list);
} }
@ -493,7 +493,7 @@ _join_foreach_fn(void *data, size_t data_size, void *arg) {
return 0; return 0;
} }
extern char * char *
cfulist_join(cfulist_t *list, const char *delimiter) { cfulist_join(cfulist_t *list, const char *delimiter) {
_join_foreach_struct *arg = calloc(1, sizeof(_join_foreach_struct)); _join_foreach_struct *arg = calloc(1, sizeof(_join_foreach_struct));
char *str = NULL; char *str = NULL;
@ -509,7 +509,7 @@ cfulist_join(cfulist_t *list, const char *delimiter) {
return str; return str;
} }
extern void void
cfulist_destroy(cfulist_t *list) { cfulist_destroy(cfulist_t *list) {
if (!list) return; if (!list) return;
@ -536,7 +536,7 @@ cfulist_destroy(cfulist_t *list) {
free(list); free(list);
} }
extern void void
cfulist_destroy_with_free_fn(cfulist_t *list, cfulist_free_fn_t free_fn) { cfulist_destroy_with_free_fn(cfulist_t *list, cfulist_free_fn_t free_fn) {
if (!list) return; if (!list) return;

64
src/cfulist.h
View File

@ -63,92 +63,92 @@ typedef void * (*cfulist_map_fn_t)(void *data, size_t data_size, void *arg,
typedef void (*cfulist_free_fn_t)(void *data); typedef void (*cfulist_free_fn_t)(void *data);
/* Returns a new list. */ /* Returns a new list. */
extern cfulist_t * cfulist_new(void); cfulist_t * cfulist_new(void);
/* Same as cfulist_new(), but set a function to be called on each /* Same as cfulist_new(), but set a function to be called on each
* element when the list is destroyed. * element when the list is destroyed.
*/ */
extern cfulist_t * cfulist_new_with_free_fn(cfulist_free_fn_t free_fn); cfulist_t * cfulist_new_with_free_fn(cfulist_free_fn_t free_fn);
/* Returns the number of entries in the list. */ /* Returns the number of entries in the list. */
extern size_t cfulist_num_entries(cfulist_t *list); size_t cfulist_num_entries(cfulist_t *list);
/* Manipulating list entries */ /* Manipulating list entries */
/* Push a value onto the end of the list. */ /* Push a value onto the end of the list. */
extern int cfulist_push_data(cfulist_t *list, void *data, size_t data_size); int cfulist_push_data(cfulist_t *list, void *data, size_t data_size);
/* Pop a value from the end of the list. */ /* Pop a value from the end of the list. */
extern int cfulist_pop_data(cfulist_t *list, void **data, size_t *data_size); int cfulist_pop_data(cfulist_t *list, void **data, size_t *data_size);
/* Add a value at the beginning of the list. */ /* Add a value at the beginning of the list. */
extern int cfulist_unshift_data(cfulist_t *list, void *data, size_t data_size); int cfulist_unshift_data(cfulist_t *list, void *data, size_t data_size);
/* Shift a value off the beginning of the list. */ /* Shift a value off the beginning of the list. */
extern int cfulist_shift_data(cfulist_t *list, void **data, size_t *data_size); int cfulist_shift_data(cfulist_t *list, void **data, size_t *data_size);
/* Add a value at the end of the queue (equivalent to push) */ /* Add a value at the end of the queue (equivalent to push) */
extern int cfulist_enqueue_data(cfulist_t *list, void *data, size_t data_size); int cfulist_enqueue_data(cfulist_t *list, void *data, size_t data_size);
/* Remove the value at the beginning of the list (equivalent to shift). */ /* Remove the value at the beginning of the list (equivalent to shift). */
extern int cfulist_dequeue_data(cfulist_t *list, void **data, size_t *data_size); int cfulist_dequeue_data(cfulist_t *list, void **data, size_t *data_size);
/* Return the last entry from the list (without removing it from /* Return the last entry from the list (without removing it from
* the list). * the list).
*/ */
extern int cfulist_first_data(cfulist_t *list, void **data, size_t *data_size); int cfulist_first_data(cfulist_t *list, void **data, size_t *data_size);
/* Return the last entry from the list (without removing it from /* Return the last entry from the list (without removing it from
* the list). * the list).
*/ */
extern int cfulist_last_data(cfulist_t *list, void **data, size_t *data_size); int cfulist_last_data(cfulist_t *list, void **data, size_t *data_size);
/* Return the nth entry from the list (without removing it from /* Return the nth entry from the list (without removing it from
* the list). n starts at zero. * the list). n starts at zero.
*/ */
extern int cfulist_nth_data(cfulist_t *list, void **data, size_t *data_size, size_t n); int cfulist_nth_data(cfulist_t *list, void **data, size_t *data_size, size_t n);
extern void cfulist_reset_each(cfulist_t *list); void cfulist_reset_each(cfulist_t *list);
extern int cfulist_each_data(cfulist_t *list, void **data, size_t *data_size); int cfulist_each_data(cfulist_t *list, void **data, size_t *data_size);
extern int cfulist_next_data(cfulist_t *list, void **data, size_t *data_size); int cfulist_next_data(cfulist_t *list, void **data, size_t *data_size);
/* Calls fe_fn() for each element in the list. Also passes arg on /* Calls fe_fn() for each element in the list. Also passes arg on
* each call. If fe_fn() returns a non-zero value, the iteration * each call. If fe_fn() returns a non-zero value, the iteration
* over the elements stops. * over the elements stops.
*/ */
extern size_t cfulist_foreach(cfulist_t *list, cfulist_foreach_fn_t fe_fn, void *arg); size_t cfulist_foreach(cfulist_t *list, cfulist_foreach_fn_t fe_fn, void *arg);
/* Creates a new list from the list passed in. Calls map_fn() on /* Creates a new list from the list passed in. Calls map_fn() on
* each element in the list. The return value is placed in the * each element in the list. The return value is placed in the
* corresponding position in the new list. * corresponding position in the new list.
*/ */
extern cfulist_t *cfulist_map(cfulist_t *list, cfulist_map_fn_t map_fn, void *arg); cfulist_t *cfulist_map(cfulist_t *list, cfulist_map_fn_t map_fn, void *arg);
/* Free all resources used by the list. */ /* Free all resources used by the list. */
extern void cfulist_destroy(cfulist_t *list); void cfulist_destroy(cfulist_t *list);
extern void cfulist_destroy_with_free_fn(cfulist_t *list, cfulist_free_fn_t free_fn); void cfulist_destroy_with_free_fn(cfulist_t *list, cfulist_free_fn_t free_fn);
/* When you don't care about the size of the data */ /* When you don't care about the size of the data */
extern int cfulist_push(cfulist_t *list, void *data); int cfulist_push(cfulist_t *list, void *data);
extern void * cfulist_pop(cfulist_t *list); void * cfulist_pop(cfulist_t *list);
extern int cfulist_unshift(cfulist_t *list, void *data); int cfulist_unshift(cfulist_t *list, void *data);
extern void * cfulist_shift(cfulist_t *list); void * cfulist_shift(cfulist_t *list);
extern int cfulist_enqueue(cfulist_t *list, void *data); int cfulist_enqueue(cfulist_t *list, void *data);
extern void *cfulist_dequeue(cfulist_t *list); void *cfulist_dequeue(cfulist_t *list);
/* Strings -- assume data is a null-terminated string -- size is /* Strings -- assume data is a null-terminated string -- size is
* calculated by strlen(data) + 1 * calculated by strlen(data) + 1
*/ */
extern int cfulist_push_string(cfulist_t *list, char *data); int cfulist_push_string(cfulist_t *list, char *data);
extern char * cfulist_pop_string(cfulist_t *list); char * cfulist_pop_string(cfulist_t *list);
extern int cfulist_unshift_string(cfulist_t *list, char *data); int cfulist_unshift_string(cfulist_t *list, char *data);
extern char * cfulist_shift_string(cfulist_t *list); char * cfulist_shift_string(cfulist_t *list);
extern int cfulist_enqueue_string(cfulist_t *list, char *data); int cfulist_enqueue_string(cfulist_t *list, char *data);
extern char *cfulist_dequeue_string(cfulist_t *list); char *cfulist_dequeue_string(cfulist_t *list);
extern char *cfulist_join(cfulist_t *list, const char *delimiter); char *cfulist_join(cfulist_t *list, const char *delimiter);
CFU_END_DECLS CFU_END_DECLS

14
src/cfuopt.c
View File

@ -71,7 +71,7 @@ typedef struct cfuopt_list_entry {
cfulist_t *param_names; cfulist_t *param_names;
} cfuopt_list_entry_t; } cfuopt_list_entry_t;
extern cfuopt_t * cfuopt_t *
cfuopt_new(void) { cfuopt_new(void) {
cfuopt_t *context = calloc(1, sizeof(cfuopt_t)); cfuopt_t *context = calloc(1, sizeof(cfuopt_t));
context->option_list = cfulist_new(); context->option_list = cfulist_new();
@ -194,7 +194,7 @@ _add_to_option_map(void *data, size_t data_size, void *arg) {
return 0; return 0;
} }
extern void void
cfuopt_add_entry(cfuopt_t *context, const char *opt_str, void *arg_data, cfuopt_add_entry(cfuopt_t *context, const char *opt_str, void *arg_data,
const char *description, const char *arg_description) { const char *description, const char *arg_description) {
cfuopt_list_entry_t *entry = calloc(1, sizeof(cfuopt_list_entry_t)); cfuopt_list_entry_t *entry = calloc(1, sizeof(cfuopt_list_entry_t));
@ -306,7 +306,7 @@ _update_extra(void *data, size_t data_size, void *arg) {
return 0; return 0;
} }
extern void void
cfuopt_parse(cfuopt_t *context, int *argc, char ***argv, char **error) { cfuopt_parse(cfuopt_t *context, int *argc, char ***argv, char **error) {
int i = 0; int i = 0;
char **args = *argv; char **args = *argv;
@ -419,7 +419,7 @@ _opt_list_free_fn(void *data) {
free(data); free(data);
} }
extern void void
cfuopt_destroy(cfuopt_t *context) { cfuopt_destroy(cfuopt_t *context) {
if (!context) return; if (!context) return;
cfulist_destroy_with_free_fn(context->option_list, _opt_list_free_fn); cfulist_destroy_with_free_fn(context->option_list, _opt_list_free_fn);
@ -469,7 +469,7 @@ _cfuopt_pretty_print_foreach(void *key, size_t key_size, void *data, size_t data
return 0; return 0;
} }
extern void void
cfuopt_pretty_print(cfuopt_t *context) { cfuopt_pretty_print(cfuopt_t *context) {
cfuhash_foreach(context->option_map, _cfuopt_pretty_print_foreach, NULL); cfuhash_foreach(context->option_map, _cfuopt_pretty_print_foreach, NULL);
} }
@ -479,7 +479,7 @@ _list_simple_free_fn(void *data) {
free(data); free(data);
} }
extern void * void *
_param_map_fn(void *data, size_t data_size, void *arg, size_t *new_data_size) { _param_map_fn(void *data, size_t data_size, void *arg, size_t *new_data_size) {
char *name = (char *)data; char *name = (char *)data;
size_t len = 0; size_t len = 0;
@ -598,7 +598,7 @@ _desc_list_free(void *data) {
free(data); free(data);
} }
extern char * char *
cfuopt_get_help_str(cfuopt_t *context) { cfuopt_get_help_str(cfuopt_t *context) {
cfulist_t *desc_list = NULL; cfulist_t *desc_list = NULL;
size_t max_width = 0; size_t max_width = 0;

10
src/cfuopt.h
View File

@ -45,24 +45,24 @@ CFU_BEGIN_DECLS
typedef struct cfuopt_struct cfuopt_t; typedef struct cfuopt_struct cfuopt_t;
/* Returns a new options context */ /* Returns a new options context */
extern cfuopt_t *cfuopt_new(void); cfuopt_t *cfuopt_new(void);
/* Adds to the list of known options. */ /* Adds to the list of known options. */
extern void cfuopt_add_entry(cfuopt_t *context, const char *opt_str, void *arg_data, void cfuopt_add_entry(cfuopt_t *context, const char *opt_str, void *arg_data,
const char *description, const char *arg_description); const char *description, const char *arg_description);
/* Parses the command line and modifies argc and argv to account for /* Parses the command line and modifies argc and argv to account for
* left over arguments. * left over arguments.
*/ */
extern void cfuopt_parse(cfuopt_t *context, int *argc, char ***argv, char **error); void cfuopt_parse(cfuopt_t *context, int *argc, char ***argv, char **error);
/* Returns a help string built from the entries added with /* Returns a help string built from the entries added with
* cfuopt_add_entry(). * cfuopt_add_entry().
*/ */
extern char * cfuopt_get_help_str(cfuopt_t *context); char * cfuopt_get_help_str(cfuopt_t *context);
/* Frees up resources used by the option parser. */ /* Frees up resources used by the option parser. */
extern void cfuopt_destroy(cfuopt_t *context); void cfuopt_destroy(cfuopt_t *context);
CFU_END_DECLS CFU_END_DECLS

36
src/cfustring.c
View File

@ -61,12 +61,12 @@ struct cfustring {
char *str; char *str;
}; };
extern cfustring_t * cfustring_t *
cfustring_new(void) { cfustring_new(void) {
return cfustring_new_with_initial_size(0); return cfustring_new_with_initial_size(0);
} }
extern cfustring_t * cfustring_t *
cfustring_new_with_initial_size(size_t initial_size) { cfustring_new_with_initial_size(size_t initial_size) {
cfustring_t *cfu_str = calloc(1, sizeof(cfustring_t)); cfustring_t *cfu_str = calloc(1, sizeof(cfustring_t));
cfu_str->type = libcfu_t_string; cfu_str->type = libcfu_t_string;
@ -78,14 +78,14 @@ cfustring_new_with_initial_size(size_t initial_size) {
return cfu_str; return cfu_str;
} }
extern cfustring_t * cfustring_t *
cfustring_new_from_string(const char *string) { cfustring_new_from_string(const char *string) {
cfustring_t *cfu_str = cfustring_new(); cfustring_t *cfu_str = cfustring_new();
cfustring_append(cfu_str, string); cfustring_append(cfu_str, string);
return cfu_str; return cfu_str;
} }
extern int int
cfustring_dup(cfustring_t *cfu_str, const char *string) { cfustring_dup(cfustring_t *cfu_str, const char *string) {
if (!string) { if (!string) {
cfu_str->max_size = 0; cfu_str->max_size = 0;
@ -100,7 +100,7 @@ cfustring_dup(cfustring_t *cfu_str, const char *string) {
return 1; return 1;
} }
extern int int
cfustring_clear(cfustring_t *cfu_str) { cfustring_clear(cfustring_t *cfu_str) {
if (cfu_str->str) { if (cfu_str->str) {
cfu_str->str[0] = '\000'; cfu_str->str[0] = '\000';
@ -109,7 +109,7 @@ cfustring_clear(cfustring_t *cfu_str) {
return 1; return 1;
} }
extern int int
cfustring_append_n(cfustring_t *cfu_str, const char *string, size_t n) { cfustring_append_n(cfustring_t *cfu_str, const char *string, size_t n) {
size_t str_len = 0; size_t str_len = 0;
if (!string) return 1; if (!string) return 1;
@ -159,17 +159,17 @@ cfustring_append_n(cfustring_t *cfu_str, const char *string, size_t n) {
return 1; return 1;
} }
extern int int
cfustring_append(cfustring_t *cfu_str, const char *string) { cfustring_append(cfustring_t *cfu_str, const char *string) {
return cfustring_append_n(cfu_str, string, 0); return cfustring_append_n(cfu_str, string, 0);
} }
extern char * char *
cfustring_get_buffer(cfustring_t *cfu_str) { cfustring_get_buffer(cfustring_t *cfu_str) {
return cfu_str->str; return cfu_str->str;
} }
extern char * char *
cfustring_get_buffer_copy(cfustring_t *cfu_str) { cfustring_get_buffer_copy(cfustring_t *cfu_str) {
char *buffer = NULL; char *buffer = NULL;
if (!cfu_str->str) return NULL; if (!cfu_str->str) return NULL;
@ -200,12 +200,12 @@ _dup_str_n(const char *str, size_t n) {
return ns; return ns;
} }
extern char * char *
cfustring_dup_c_str(const char *str) { cfustring_dup_c_str(const char *str) {
return _dup_str(str); return _dup_str(str);
} }
extern char * char *
cfustring_dup_c_str_n(const char *str, size_t n) { cfustring_dup_c_str_n(const char *str, size_t n) {
return _dup_str_n(str, n); return _dup_str_n(str, n);
} }
@ -321,7 +321,7 @@ __cfustring_split_to_raw(cfustring_t *cfu_str, size_t *num_strings, size_t num_s
return ret_strings; return ret_strings;
} }
extern cfustring_t ** cfustring_t **
cfustring_split(cfustring_t *cfu_str, size_t *num_strings, size_t limit, ...) { cfustring_split(cfustring_t *cfu_str, size_t *num_strings, size_t limit, ...) {
va_list ap; va_list ap;
char **strings = NULL; char **strings = NULL;
@ -354,7 +354,7 @@ cfustring_split(cfustring_t *cfu_str, size_t *num_strings, size_t limit, ...) {
} }
extern char ** char **
cfustring_split_to_c_str(cfustring_t *cfu_str, size_t *num_strings, size_t limit, ...) { cfustring_split_to_c_str(cfustring_t *cfu_str, size_t *num_strings, size_t limit, ...) {
char **rv = NULL; char **rv = NULL;
va_list ap; va_list ap;
@ -376,7 +376,7 @@ cfustring_split_to_c_str(cfustring_t *cfu_str, size_t *num_strings, size_t limit
return rv; return rv;
} }
extern char * char *
cfustring_sprintf_c_str(const char *fmt, ...) { cfustring_sprintf_c_str(const char *fmt, ...) {
va_list ap; va_list ap;
char *str = NULL; char *str = NULL;
@ -391,7 +391,7 @@ cfustring_sprintf_c_str(const char *fmt, ...) {
return str; return str;
} }
extern size_t size_t
cfustring_sprintf(cfustring_t *cfu_str, const char *fmt, ...) { cfustring_sprintf(cfustring_t *cfu_str, const char *fmt, ...) {
va_list ap; va_list ap;
size_t rv = 0; size_t rv = 0;
@ -454,7 +454,7 @@ _safe_strncpy(char **buf, size_t *buf_size, const char *src, size_t size) {
return rv; return rv;
} }
extern size_t size_t
cfustring_vsprintf(cfustring_t *cfu_str, const char *fmt_in, va_list ap) { cfustring_vsprintf(cfustring_t *cfu_str, const char *fmt_in, va_list ap) {
const char *ptr = NULL; const char *ptr = NULL;
const char *start = NULL; const char *start = NULL;
@ -594,14 +594,14 @@ cfustring_vsprintf(cfustring_t *cfu_str, const char *fmt_in, va_list ap) {
return byte_count; return byte_count;
} }
extern int int
cfustring_destroy(cfustring_t *cfu_str) { cfustring_destroy(cfustring_t *cfu_str) {
free(cfu_str->str); free(cfu_str->str);
free(cfu_str); free(cfu_str);
return 1; return 1;
} }
extern char ** char **
cfustring_c_str_split(const char *c_str, size_t *num_strings, size_t limit, ...) { cfustring_c_str_split(const char *c_str, size_t *num_strings, size_t limit, ...) {
cfustring_t *cfu_str = cfustring_new_from_string(c_str); cfustring_t *cfu_str = cfustring_new_from_string(c_str);
char **rv = NULL; char **rv = NULL;

34
src/cfustring.h
View File

@ -47,70 +47,70 @@ CFU_BEGIN_DECLS
typedef struct cfustring cfustring_t; typedef struct cfustring cfustring_t;
/* Returns a new String. */ /* Returns a new String. */
extern cfustring_t * cfustring_new(void); cfustring_t * cfustring_new(void);
/* Returns a new String, but preallocates a buffer of the given size. */ /* Returns a new String, but preallocates a buffer of the given size. */
extern cfustring_t * cfustring_new_with_initial_size(size_t initial_size); cfustring_t * cfustring_new_with_initial_size(size_t initial_size);
/* Returns a new String initalized with the given string. */ /* Returns a new String initalized with the given string. */
extern cfustring_t * cfustring_new_from_string(const char *string); cfustring_t * cfustring_new_from_string(const char *string);
/* Overwrite anything currently in cfu_str with string. */ /* Overwrite anything currently in cfu_str with string. */
extern int cfustring_dup(cfustring_t *cfu_str, const char *string); int cfustring_dup(cfustring_t *cfu_str, const char *string);
/* Truncate the string. */ /* Truncate the string. */
extern int cfustring_clear(cfustring_t *cfu_str); int cfustring_clear(cfustring_t *cfu_str);
/* Append str to the end of the buffer in cfu_str. */ /* Append str to the end of the buffer in cfu_str. */
extern int cfustring_append(cfustring_t *cfu_str, const char *str); int cfustring_append(cfustring_t *cfu_str, const char *str);
/* Get the buffer used to hold the string. Do not free() it, as it is /* Get the buffer used to hold the string. Do not free() it, as it is
* used directly by cfustring and will be destroyed when * used directly by cfustring and will be destroyed when
* cfustring_destroy() is called. * cfustring_destroy() is called.
*/ */
extern char * cfustring_get_buffer(cfustring_t *cfu_str); char * cfustring_get_buffer(cfustring_t *cfu_str);
/* Same as cfustring_get_buffer(), except return a copy of the string. /* Same as cfustring_get_buffer(), except return a copy of the string.
* Caller is responsible for deallocating the buffer with free(). * Caller is responsible for deallocating the buffer with free().
*/ */
extern char * cfustring_get_buffer_copy(cfustring_t *cfu_str); char * cfustring_get_buffer_copy(cfustring_t *cfu_str);
/* Split cfu_str on one or more delimiting strings, e.g., /* Split cfu_str on one or more delimiting strings, e.g.,
* cfustring_split(cfu_str, 2, 0, "\r\n", "\n"). Use a limit > 0 if * cfustring_split(cfu_str, 2, 0, "\r\n", "\n"). Use a limit > 0 if
* you want to only get back a certain number of strings and ignore * you want to only get back a certain number of strings and ignore
* any extra delimiters. * any extra delimiters.
*/ */
extern cfustring_t ** cfustring_split(cfustring_t *cfu_str, size_t *num_strings, cfustring_t ** cfustring_split(cfustring_t *cfu_str, size_t *num_strings,
size_t limit, ...); size_t limit, ...);
/* Same as cfustring_split(), except return an array of C-strings. /* Same as cfustring_split(), except return an array of C-strings.
* Caller is responsible for deallocating the buffers. * Caller is responsible for deallocating the buffers.
*/ */
extern char ** cfustring_split_to_c_str(cfustring_t *cfu_str, size_t *num_strings, char ** cfustring_split_to_c_str(cfustring_t *cfu_str, size_t *num_strings,
size_t limit, ...); size_t limit, ...);
/* Free all resources allocated by cfu_str. */ /* Free all resources allocated by cfu_str. */
extern int cfustring_destroy(cfustring_t *cfu_str); int cfustring_destroy(cfustring_t *cfu_str);
/* Duplicate the C string str. Caller must free with free(). */ /* Duplicate the C string str. Caller must free with free(). */
extern char * cfustring_dup_c_str(const char *str); char * cfustring_dup_c_str(const char *str);
/* Same as cfustring_dup_c_str(), but only copy at most n chars */ /* Same as cfustring_dup_c_str(), but only copy at most n chars */
extern char * cfustring_dup_c_str_n(const char *str, size_t n); char * cfustring_dup_c_str_n(const char *str, size_t n);
/* Like sprintf(), but writes to a self-extending string. */ /* Like sprintf(), but writes to a self-extending string. */
extern size_t cfustring_sprintf(cfustring_t *cfu_str, const char *fmt, ...); size_t cfustring_sprintf(cfustring_t *cfu_str, const char *fmt, ...);
/* Like vsprintf(), but writes to a self-extending string. */ /* Like vsprintf(), but writes to a self-extending string. */
extern size_t cfustring_vsprintf(cfustring_t *cfu_str, const char *fmt, va_list ap); size_t cfustring_vsprintf(cfustring_t *cfu_str, const char *fmt, va_list ap);
/* Similar to sprintf(), but allocates a C string of the /* Similar to sprintf(), but allocates a C string of the
* appropriate size for you and returns it. * appropriate size for you and returns it.
*/ */
extern char * cfustring_sprintf_c_str(const char *fmt, ...); char * cfustring_sprintf_c_str(const char *fmt, ...);
/* Like cfustring_split_to_c_str(), but split a char * instead of a cfustring_t *. */ /* Like cfustring_split_to_c_str(), but split a char * instead of a cfustring_t *. */
extern char ** cfustring_c_str_split(const char *c_str, size_t *num_strings, size_t limit, ...); char ** cfustring_c_str_split(const char *c_str, size_t *num_strings, size_t limit, ...);
CFU_END_DECLS CFU_END_DECLS

8
src/cfuthread_queue.c
View File

@ -110,7 +110,7 @@ _run_queue(void *arg) {
} }
extern cfuthread_queue_t * cfuthread_queue_t *
cfuthread_queue_new_with_cleanup(cfuthread_queue_fn_t fn, cfuthread_queue_init_t init_fn, cfuthread_queue_new_with_cleanup(cfuthread_queue_fn_t fn, cfuthread_queue_init_t init_fn,
void *init_arg, cfuthread_queue_cleanup_t cleanup_fn, void *init_arg, cfuthread_queue_cleanup_t cleanup_fn,
void *cleanup_arg) { void *cleanup_arg) {
@ -134,12 +134,12 @@ cfuthread_queue_new_with_cleanup(cfuthread_queue_fn_t fn, cfuthread_queue_init_t
return tq; return tq;
} }
extern cfuthread_queue_t * cfuthread_queue_t *
cfuthread_queue_new(cfuthread_queue_fn_t fn) { cfuthread_queue_new(cfuthread_queue_fn_t fn) {
return cfuthread_queue_new_with_cleanup(fn, NULL, NULL, NULL, NULL); return cfuthread_queue_new_with_cleanup(fn, NULL, NULL, NULL, NULL);
} }
extern void * void *
cfuthread_queue_make_request(cfuthread_queue_t * tq, void *data) { cfuthread_queue_make_request(cfuthread_queue_t * tq, void *data) {
cfuthread_queue_entry *request = _new_cfuthread_entry(data); cfuthread_queue_entry *request = _new_cfuthread_entry(data);
@ -158,7 +158,7 @@ cfuthread_queue_make_request(cfuthread_queue_t * tq, void *data) {
return data; return data;
} }
extern void void
cfuthread_queue_destroy(cfuthread_queue_t *tq) { cfuthread_queue_destroy(cfuthread_queue_t *tq) {
void *rv = NULL; void *rv = NULL;

8
src/cfuthread_queue.h
View File

@ -62,7 +62,7 @@ typedef void (*cfuthread_queue_cleanup_t)(void *arg);
/* Creates a new thread queue structure that will run the given /* Creates a new thread queue structure that will run the given
* function when a request is received. * function when a request is received.
*/ */
extern cfuthread_queue_t * cfuthread_queue_new(cfuthread_queue_fn_t fn); cfuthread_queue_t * cfuthread_queue_new(cfuthread_queue_fn_t fn);
/* Same as cfuthread_queue_new(), but with an initialization /* Same as cfuthread_queue_new(), but with an initialization
* function that gets called with the argument init_arg when the * function that gets called with the argument init_arg when the
@ -70,7 +70,7 @@ extern cfuthread_queue_t * cfuthread_queue_new(cfuthread_queue_fn_t fn);
* the argument cleanup_arg when the thread exits, e.g., when * the argument cleanup_arg when the thread exits, e.g., when
* cfuthread_queue_destroy() is called. * cfuthread_queue_destroy() is called.
*/ */
extern cfuthread_queue_t * cfuthread_queue_new_with_cleanup(cfuthread_queue_fn_t fn, cfuthread_queue_t * cfuthread_queue_new_with_cleanup(cfuthread_queue_fn_t fn,
cfuthread_queue_init_t init_fn, void *init_arg, cfuthread_queue_cleanup_t cleanup_fn, cfuthread_queue_init_t init_fn, void *init_arg, cfuthread_queue_cleanup_t cleanup_fn,
void *cleanup_arg); void *cleanup_arg);
@ -78,12 +78,12 @@ extern cfuthread_queue_t * cfuthread_queue_new_with_cleanup(cfuthread_queue_fn_t
* function fn given to cfuthread_queue_new when it reaches the * function fn given to cfuthread_queue_new when it reaches the
* front of the queue. * front of the queue.
*/ */
extern void * cfuthread_queue_make_request(cfuthread_queue_t * tq, void *data); void * cfuthread_queue_make_request(cfuthread_queue_t * tq, void *data);
/* Free up resources used by the queue, in addition to canceling /* Free up resources used by the queue, in addition to canceling
* the thread. * the thread.
*/ */
extern void cfuthread_queue_destroy(cfuthread_queue_t *); void cfuthread_queue_destroy(cfuthread_queue_t *);
CFU_END_DECLS CFU_END_DECLS

10
src/cfutime.c
View File

@ -50,30 +50,30 @@ typedef struct cfutime {
struct timeval end_tv; struct timeval end_tv;
} cfutime; } cfutime;
extern cfutime_t * cfutime_t *
cfutime_new(void) { cfutime_new(void) {
cfutime_t *time = calloc(1, sizeof(cfutime)); cfutime_t *time = calloc(1, sizeof(cfutime));
time->type = libcfu_t_time; time->type = libcfu_t_time;
return time; return time;
} }
extern void void
cfutime_begin(cfutime_t *time) { cfutime_begin(cfutime_t *time) {
gettimeofday(&(time->begin_tv), NULL); gettimeofday(&(time->begin_tv), NULL);
} }
extern void void
cfutime_end(cfutime_t *time) { cfutime_end(cfutime_t *time) {
gettimeofday(&(time->end_tv), NULL); gettimeofday(&(time->end_tv), NULL);
} }
extern double double
cfutime_elapsed(cfutime_t *time) { cfutime_elapsed(cfutime_t *time) {
return (double)time->end_tv.tv_sec + ((double)time->end_tv.tv_usec)/1000000 - return (double)time->end_tv.tv_sec + ((double)time->end_tv.tv_usec)/1000000 -
((double)time->begin_tv.tv_sec + ((double)time->begin_tv.tv_usec)/1000000); ((double)time->begin_tv.tv_sec + ((double)time->begin_tv.tv_usec)/1000000);
} }
extern void void
cfutime_free(cfutime_t *time) { cfutime_free(cfutime_t *time) {
free(time); free(time);
} }

10
src/cfutime.h
View File

@ -45,19 +45,19 @@ CFU_BEGIN_DECLS
typedef struct cfutime cfutime_t; typedef struct cfutime cfutime_t;
/* Return a new cfutime structure. */ /* Return a new cfutime structure. */
extern cfutime_t *cfutime_new(void); cfutime_t *cfutime_new(void);
/* Start the timer. */ /* Start the timer. */
extern void cfutime_begin(cfutime_t *time); void cfutime_begin(cfutime_t *time);
/* Stop the timer. */ /* Stop the timer. */
extern void cfutime_end(cfutime_t *time); void cfutime_end(cfutime_t *time);
/* Return the number of seconds elapsed as a double. */ /* Return the number of seconds elapsed as a double. */
extern double cfutime_elapsed(cfutime_t *time); double cfutime_elapsed(cfutime_t *time);
/* Deallocate resources allocated for time. */ /* Deallocate resources allocated for time. */
extern void cfutime_free(cfutime_t *time); void cfutime_free(cfutime_t *time);
CFU_END_DECLS CFU_END_DECLS