X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/98fcf9f030a152fb946c3860abc7b7d748d6f1a5..421e2f7dd584b6aa936de631a730fb3b21ca7565:/src/xbt/dict_elm.c diff --git a/src/xbt/dict_elm.c b/src/xbt/dict_elm.c index faff55548f..a2dd56259d 100644 --- a/src/xbt/dict_elm.c +++ b/src/xbt/dict_elm.c @@ -8,15 +8,8 @@ /* This program is free software; you can redistribute it and/or modify it under the terms of the license (GNU LGPL) which comes with this package. */ - -#include "gras_private.h" #include "dict_private.h" /* prototypes of this module */ -#include /* malloc() */ -#include /* strlen() */ - -#include - GRAS_LOG_EXTERNAL_CATEGORY(dict); GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(dict_elm,dict,"Dictionaries internals"); @@ -28,64 +21,61 @@ GRAS_LOG_NEW_SUBCATEGORY(dict_multi,dict,"Dictionaries internals: dictionaries o /*####[ Private prototypes ]#################################################*/ -static inline gras_error_t _gras_dictelm_alloc(char *key, - int offset, - int key_len, - void *data, - void_f_pvoid_t *free_ctn, - /*OUT*/gras_dictelm_t **where); +static _GRAS_INLINE void _gras_dictelm_alloc(char *key, + int offset, + int key_len, + void *data, + void_f_pvoid_t *free_f, + /*OUT*/s_gras_dictelm_t **where); static void _dictelm_wrapper_free(void*); -static inline void _str_prefix_lgr(const char *key1, - int key_len1, - const char *key2, - int key_len2, - int *offset, - int *match); +static _GRAS_INLINE void _str_prefix_lgr(const char *key1, + int key_len1, + const char *key2, + int key_len2, + int *offset, + int *match); -static gras_error_t _gras_dictelm_dump_rec(gras_dictelm_t *head, - int offset, - void_f_pvoid_t *output); +static void _gras_dictelm_dump_rec(s_gras_dictelm_t *head, + int offset, + void_f_pvoid_t *output); -static gras_error_t _gras_dictelm_set_rec(gras_dictelm_t *head, - char *key, - int key_len, - int offset, - void *data, - void_f_pvoid_t *free_ctn); -static gras_error_t _gras_dictelm_get_rec(gras_dictelm_t *head, +static void _gras_dictelm_set_rec(s_gras_dictelm_t *head, + char *key, + int key_len, + int offset, + void *data, + void_f_pvoid_t *free_f); +static gras_error_t _gras_dictelm_get_rec(s_gras_dictelm_t *head, const char *key, int key_len, int offset, /* OUT */void **data); -static gras_error_t _gras_dictelm_remove_rec(gras_dictelm_t *head, +static gras_error_t _gras_dictelm_remove_rec(s_gras_dictelm_t *head, const char *key, int key_len, int offset); -static inline +static _GRAS_INLINE void -_collapse_if_need(gras_dictelm_t *p_head, +_collapse_if_need(s_gras_dictelm_t *p_head, int pos, int offset); /* ---- */ -static inline +static _GRAS_INLINE void * -memdup(const void * const ptr, - const size_t length) { +gras_memdup(const void * const ptr, + const size_t length) { void * new_ptr = NULL; - new_ptr = malloc(length); - - if (new_ptr) { - memcpy(new_ptr, ptr, length); - } - + new_ptr = gras_malloc(length); + memcpy(new_ptr, ptr, length); + return new_ptr; } @@ -95,7 +85,7 @@ memdup(const void * const ptr, * Change any byte to a printable char */ -static inline +static _GRAS_INLINE char _gras_nibble_to_char(unsigned char c) { c &= 0x0f; @@ -108,7 +98,7 @@ _gras_nibble_to_char(unsigned char c) { * Change any byte array to a printable string * The length of string_container should at least be data_len*2+1 */ -static inline +static _GRAS_INLINE char * _gras_bytes_to_string(char * const ptr, int data_len, @@ -133,45 +123,28 @@ _gras_bytes_to_string(char * const ptr, * * Alloc a dict element with no child. */ -static -inline -gras_error_t +static _GRAS_INLINE +void _gras_dictelm_alloc(char *key, int key_len, int offset, void *data, - void_f_pvoid_t *free_ctn, - /*OUT*/gras_dictelm_t **pp_elm) { + void_f_pvoid_t *free_f, + /*OUT*/s_gras_dictelm_t **pp_elm) { gras_error_t errcode = no_error; - gras_dictelm_t *p_elm = NULL; + s_gras_dictelm_t *p_elm = NULL; - if (!(p_elm = calloc(1, sizeof(gras_dictelm_t)))) { - if (free_ctn && data) { - free_ctn(data); - } - - RAISE_MALLOC; - } + p_elm = gras_new(s_gras_dictelm_t,1); p_elm->key = key; p_elm->key_len = key_len; p_elm->offset = offset; p_elm->content = data; - p_elm->free_ctn = free_ctn; - - errcode = gras_dynar_new(&(p_elm->sub), sizeof(gras_dictelm_t*), - _dictelm_wrapper_free); - if (errcode != no_error) { - if (free_ctn && data) { - free_ctn(data); - } - free(p_elm); - return errcode; - } + p_elm->free_f = free_f; + p_elm->sub = gras_dynar_new(sizeof(s_gras_dictelm_t*), _dictelm_wrapper_free); *pp_elm = p_elm; - return errcode; } /** @@ -182,23 +155,21 @@ _gras_dictelm_alloc(char *key, * Frees a dictionnary element with all its childs. */ void -gras_dictelm_free(gras_dictelm_t **pp_elm) { +gras_dictelm_free(s_gras_dictelm_t **pp_elm) { if (*pp_elm) { - gras_dictelm_t *p_elm = *pp_elm; + s_gras_dictelm_t *p_elm = *pp_elm; - gras_dynar_free(p_elm->sub); + gras_dynar_free(&(p_elm->sub)); if (p_elm->key) { - free(p_elm->key); + gras_free(p_elm->key); } - if (p_elm->free_ctn && p_elm->content) { - p_elm->free_ctn(p_elm->content); + if (p_elm->free_f && p_elm->content) { + p_elm->free_f(p_elm->content); } - memset(p_elm, 0, sizeof (*p_elm)); - - free(p_elm); + gras_free(p_elm); *pp_elm = NULL; } } @@ -212,9 +183,9 @@ static void _dictelm_wrapper_free(void *pp_elm) { DEBUG3("Free dictelm '%.*s' %p", - (*(gras_dictelm_t**)pp_elm)->key_len, (*(gras_dictelm_t**)pp_elm)->key, + (*(s_gras_dictelm_t**)pp_elm)->key_len, (*(s_gras_dictelm_t**)pp_elm)->key, *(void**)pp_elm); - gras_dictelm_free((gras_dictelm_t**)pp_elm); + gras_dictelm_free((s_gras_dictelm_t**)pp_elm); } /*####[ utility functions ]##################################################*/ @@ -225,7 +196,7 @@ _dictelm_wrapper_free(void *pp_elm) { * Returns the length of the common prefix of @str1 and @str2. * Do make sure the strings are not null */ -static inline +static _GRAS_INLINE void _str_prefix_lgr(const char *key1, int key_len1, @@ -283,21 +254,21 @@ _str_prefix_lgr(const char *key1, * Compares two dictelm keys and return their matching (using the same * convention than @_gras_dict_child_search() ) */ -static inline +static _GRAS_INLINE void -_dict_child_cmp(gras_dictelm_t *p_dict, +_dict_child_cmp(s_gras_dictelm_t *p_dict, int pos, const char *key, const int key_len, int *p_offset, int *p_match, int *p_cmp) { - gras_dictelm_t *p_child = NULL; + s_gras_dictelm_t *p_child = NULL; int cmp = 0; int o = *p_offset; int m = *p_match; - gras_dynar_get(p_dict->sub, pos, &p_child); + p_child = gras_dynar_get_as(p_dict->sub, pos, s_gras_dictelm_t*); /* Compute the length of the prefix and if the searched key is before or after cur */ @@ -348,9 +319,9 @@ _dict_child_cmp(gras_dictelm_t *p_dict, * handled by previous levels of recursion. In output, that the one counting * also this level. */ -static inline +static _GRAS_INLINE void -_gras_dictelm_child_search(gras_dictelm_t *p_elm, +_gras_dictelm_child_search(s_gras_dictelm_t *p_elm, const char *key, int key_len, int *p_pos, @@ -363,7 +334,7 @@ _gras_dictelm_child_search(gras_dictelm_t *p_elm, int len = 0; - CDEBUG5(dict_search, "search child [%.*s] under [%.*s] (len=%d)", + CDEBUG5(dict_search, "search child [%.*s] under [%.*s] (len=%lu)", key_len, key, p_elm?p_elm->key_len:6, p_elm?p_elm->key:"(head)", (p_elm&&p_elm->sub)?gras_dynar_length(p_elm->sub):0); @@ -403,17 +374,17 @@ _gras_dictelm_child_search(gras_dictelm_t *p_elm, * * Change the value of the dictelm, making sure to free the old one, if any. */ -static inline +static _GRAS_INLINE void -_gras_dictelm_change_value(gras_dictelm_t *p_elm, +_gras_dictelm_change_value(s_gras_dictelm_t *p_elm, void *data, - void_f_pvoid_t *free_ctn) { + void_f_pvoid_t *free_f) { - if (p_elm->content && p_elm->free_ctn) { - p_elm->free_ctn(p_elm->content); + if (p_elm->content && p_elm->free_f) { + p_elm->free_f(p_elm->content); } - p_elm->free_ctn = free_ctn; + p_elm->free_f = free_f; p_elm->content = data; } @@ -432,14 +403,13 @@ _gras_dictelm_change_value(gras_dictelm_t *p_elm, * This is a helper function to gras_dict_set which locks the struct and * strdup the key before action. */ -gras_error_t -_gras_dictelm_set_rec(gras_dictelm_t *p_head, +void +_gras_dictelm_set_rec(s_gras_dictelm_t *p_head, char *key, int key_len, int offset, void *data, - void_f_pvoid_t *free_ctn) { - gras_error_t errcode = no_error; + void_f_pvoid_t *free_f) { int match = 0; int pos = 0; const int old_offset = offset; @@ -448,7 +418,7 @@ _gras_dictelm_set_rec(gras_dictelm_t *p_head, key_len, key, ((p_head && p_head->key) ? p_head->key_len : 6), ((p_head && p_head->key) ? p_head->key : "(head)"), - offset, p_head); + offset, (void*)p_head); /*** The trivial cases first ***/ @@ -457,10 +427,10 @@ _gras_dictelm_set_rec(gras_dictelm_t *p_head, CDEBUG0(dict_add, "--> Change the value of head"); - _gras_dictelm_change_value(p_head, data, free_ctn); - free(key); /* Keep the key used in the tree */ + _gras_dictelm_change_value(p_head, data, free_f); + gras_free(key); /* Keep the key used in the tree */ - return errcode; + return; } /*** Search where to add this child, and how ***/ @@ -473,95 +443,94 @@ _gras_dictelm_set_rec(gras_dictelm_t *p_head, case 0: /* no child have a common prefix */ { - gras_dictelm_t *p_child = NULL; + s_gras_dictelm_t *p_child = NULL; - TRY(_gras_dictelm_alloc(key, key_len, offset, data, free_ctn, &p_child)); - CDEBUG1(dict_add, "-> Add a child %p", p_child); - TRY(gras_dynar_insert_at(p_head->sub, pos, &p_child)); + _gras_dictelm_alloc(key, key_len, offset, data, free_f, &p_child); + CDEBUG1(dict_add, "-> Add a child %p", (void*)p_child); + gras_dynar_insert_at(p_head->sub, pos, &p_child); - return errcode; + return; } case 1: /* A child have exactly this key => change its value*/ { - gras_dictelm_t *p_child = NULL; + s_gras_dictelm_t *p_child = NULL; - gras_dynar_get(p_head->sub, pos, &p_child); - CDEBUG1(dict_add, "-> Change the value of the child %p", p_child); - _gras_dictelm_change_value(p_child, data, free_ctn); + p_child = gras_dynar_get_as(p_head->sub, pos, s_gras_dictelm_t*); + CDEBUG1(dict_add, "-> Change the value of the child %p", (void*)p_child); + _gras_dictelm_change_value(p_child, data, free_f); - free(key); + gras_free(key); - return errcode; + return; } case 2: /* A child constitutes a prefix of the key => recurse */ { - gras_dictelm_t *p_child = NULL; + s_gras_dictelm_t *p_child = NULL; - gras_dynar_get(p_head->sub, pos, &p_child); - CDEBUG2(dict_add,"-> Recurse on %p (offset=%d)", p_child, offset); + p_child=gras_dynar_get_as(p_head->sub, pos, s_gras_dictelm_t*); + CDEBUG2(dict_add,"-> Recurse on %p (offset=%d)", (void*)p_child, offset); - return _gras_dictelm_set_rec(p_child, key, key_len, - offset, data, free_ctn); + _gras_dictelm_set_rec(p_child, key, key_len, + offset, data, free_f); + return; } case 3: /* The key is a prefix of the child => child becomes child of p_new */ { - gras_dictelm_t *p_new = NULL; - gras_dictelm_t *p_child = NULL; + s_gras_dictelm_t *p_new = NULL; + s_gras_dictelm_t *p_child = NULL; - gras_dynar_get(p_head->sub, pos, &p_child); - TRY(_gras_dictelm_alloc(key, key_len, old_offset, data, free_ctn, &p_new)); + p_child=gras_dynar_get_as(p_head->sub, pos, s_gras_dictelm_t*); + _gras_dictelm_alloc(key, key_len, old_offset, data, free_f, &p_new); CDEBUG2(dict_add, "-> The child %p become child of new dict (%p)", - p_child, p_new); + (void*)p_child, (void*)p_new); - TRY(gras_dynar_push(p_new->sub, &p_child)); + gras_dynar_push(p_new->sub, &p_child); p_child->offset = offset; - TRY(gras_dynar_set(p_head->sub, pos, &p_new)); + gras_dynar_set(p_head->sub, pos, &p_new); - return errcode; + return; } case 4: /* A child share a common prefix with this key => Common ancestor */ { - gras_dictelm_t *p_new = NULL; - gras_dictelm_t *p_child = NULL; - gras_dictelm_t *p_anc = NULL; + s_gras_dictelm_t *p_new = NULL; + s_gras_dictelm_t *p_child = NULL; + s_gras_dictelm_t *p_anc = NULL; char *anc_key = NULL; int anc_key_len = offset; - TRY(_gras_dictelm_alloc(key, key_len, offset, data, free_ctn, &p_new)); - gras_dynar_get(p_head->sub, pos, &p_child); + _gras_dictelm_alloc(key, key_len, offset, data, free_f, &p_new); + p_child=gras_dynar_get_as(p_head->sub, pos, s_gras_dictelm_t*); - anc_key = memdup(key, anc_key_len); + anc_key = gras_memdup(key, anc_key_len); - TRY(_gras_dictelm_alloc(anc_key, anc_key_len, old_offset, - NULL, NULL, &p_anc)); + _gras_dictelm_alloc(anc_key, anc_key_len, old_offset, NULL, NULL, &p_anc); CDEBUG3(dict_add, "-> Make a common ancestor %p (%.*s)", - p_anc, anc_key_len, anc_key); + (void*)p_anc, anc_key_len, anc_key); if (key[offset] < p_child->key[offset]) { - TRY(gras_dynar_push(p_anc->sub, &p_new)); - TRY(gras_dynar_push(p_anc->sub, &p_child)); + gras_dynar_push(p_anc->sub, &p_new); + gras_dynar_push(p_anc->sub, &p_child); } else { - TRY(gras_dynar_push(p_anc->sub, &p_child)); - TRY(gras_dynar_push(p_anc->sub, &p_new)); + gras_dynar_push(p_anc->sub, &p_child); + gras_dynar_push(p_anc->sub, &p_new); } p_child->offset = offset; - TRY(gras_dynar_set(p_head->sub, pos, &p_anc)); + gras_dynar_set(p_head->sub, pos, &p_anc); - return errcode; + return; } default: - RAISE_IMPOSSIBLE; + DIE_IMPOSSIBLE; } - } /** @@ -575,38 +544,35 @@ _gras_dictelm_set_rec(gras_dictelm_t *p_head, * set the @data in the structure under the @key, which can be any kind * of data, as long as its length is provided in @key_len. */ -gras_error_t -gras_dictelm_set_ext(gras_dictelm_t **pp_head, +void +gras_dictelm_set_ext(s_gras_dictelm_t **pp_head, const char *_key, int key_len, void *data, - void_f_pvoid_t *free_ctn) { - gras_error_t errcode = no_error; - gras_dictelm_t *p_head = *pp_head; + void_f_pvoid_t *free_f) { + s_gras_dictelm_t *p_head = *pp_head; char *key = NULL; - key = memdup(_key, key_len); - if (!key) - RAISE_MALLOC; + key = gras_memdup(_key, key_len); /* there is no head, create it */ if (!p_head) { - gras_dictelm_t *p_child = NULL; + s_gras_dictelm_t *p_child = NULL; CDEBUG0(dict_add, "Create an head"); /* The head is priviledged by being the only one with a NULL key */ - TRY(_gras_dictelm_alloc(NULL, 0, 0, NULL, NULL, &p_head)); + _gras_dictelm_alloc(NULL, 0, 0, NULL, NULL, &p_head); - TRY(_gras_dictelm_alloc(key, key_len, 0, data, free_ctn, &p_child)); - TRY(gras_dynar_insert_at(p_head->sub, 0, &p_child)); + _gras_dictelm_alloc(key, key_len, 0, data, free_f, &p_child); + gras_dynar_insert_at(p_head->sub, 0, &p_child); *pp_head = p_head; - return errcode; + return; } - return _gras_dictelm_set_rec(p_head, key, key_len, 0, data, free_ctn); + _gras_dictelm_set_rec(p_head, key, key_len, 0, data, free_f); } /** @@ -620,13 +586,13 @@ gras_dictelm_set_ext(gras_dictelm_t **pp_head, * set the @data in the structure under the @key, which is a * null terminated string. */ -gras_error_t -gras_dictelm_set(gras_dictelm_t **pp_head, +void +gras_dictelm_set(s_gras_dictelm_t **pp_head, const char *_key, void *data, - void_f_pvoid_t *free_ctn) { + void_f_pvoid_t *free_f) { - return gras_dictelm_set_ext(pp_head, _key, 1+strlen(_key), data, free_ctn); + gras_dictelm_set_ext(pp_head, _key, 1+strlen(_key), data, free_f); } /** @@ -642,14 +608,14 @@ gras_dictelm_set(gras_dictelm_t **pp_head, */ static gras_error_t -_gras_dictelm_get_rec(gras_dictelm_t *p_head, +_gras_dictelm_get_rec(s_gras_dictelm_t *p_head, const char *key, int key_len, int offset, void **data) { void *res; - CDEBUG3(dict_search, "Search %.*s in %p", key_len, key, p_head); + CDEBUG3(dict_search, "Search %.*s in %p", key_len, key, (void*)p_head); /*** The trivial case first ***/ @@ -664,7 +630,7 @@ _gras_dictelm_get_rec(gras_dictelm_t *p_head, int match = 0; int pos = 0; - *data = NULL; // Make it ready to answer 'not found' in one operation + *data = NULL; /* Make it ready to answer 'not found' in one operation */ /*** Search where is the good child, and how good it is ***/ _gras_dictelm_child_search(p_head, key, key_len, &pos, &offset, &match); @@ -676,9 +642,9 @@ _gras_dictelm_get_rec(gras_dictelm_t *p_head, case 1: /* A child have exactly this key => Got it */ { - gras_dictelm_t *p_child = NULL; + s_gras_dictelm_t *p_child = NULL; - gras_dynar_get(p_head->sub, pos, &p_child); + p_child = gras_dynar_get_as(p_head->sub, pos, s_gras_dictelm_t*); *data = p_child->content; return no_error; @@ -686,9 +652,9 @@ _gras_dictelm_get_rec(gras_dictelm_t *p_head, case 2: /* A child constitutes a prefix of the key => recurse */ { - gras_dictelm_t *p_child = NULL; + s_gras_dictelm_t *p_child = NULL; - gras_dynar_get(p_head->sub, pos, &p_child); + p_child = gras_dynar_get_as(p_head->sub, pos, s_gras_dictelm_t*); return _gras_dictelm_get_rec(p_child, key, key_len, offset, data); } @@ -716,7 +682,7 @@ _gras_dictelm_get_rec(gras_dictelm_t *p_head, * Search the given @key. mismatch_error when not found. */ gras_error_t -gras_dictelm_get_ext(gras_dictelm_t *p_head, +gras_dictelm_get_ext(s_gras_dictelm_t *p_head, const char *key, int key_len, /* OUT */void **data) { @@ -739,7 +705,7 @@ gras_dictelm_get_ext(gras_dictelm_t *p_head, * Search the given @key. mismatch_error when not found. */ gras_error_t -gras_dictelm_get(gras_dictelm_t *p_head, +gras_dictelm_get(s_gras_dictelm_t *p_head, const char *key, /* OUT */void **data) { @@ -747,56 +713,57 @@ gras_dictelm_get(gras_dictelm_t *p_head, } /*----[ _gras_dict_collapse ]------------------------------------------------*/ -static inline +static _GRAS_INLINE void -_collapse_if_need(gras_dictelm_t *p_head, - int pos, - int offset) { - gras_dictelm_t *p_child = NULL; +_collapse_if_need(gras_dictelm_t head, + int pos, + int offset) { + gras_dictelm_t child = NULL; - CDEBUG2(dict_collapse, "Collapse %d of %p... ", pos, p_head); fflush(stdout); + CDEBUG2(dict_collapse, "Collapse %d of %p... ", pos, (void*)head); if (pos >= 0) { /* Remove the child if |it's key| == 0 (meaning it's dead) */ - gras_dynar_get(p_head->sub, pos, &p_child); + child = gras_dynar_get_as(head->sub, pos, gras_dictelm_t); - if (offset >= p_child->key_len) { + if (offset >= child->key_len) { - gras_assert0(gras_dynar_length(p_child->sub) == 0, + gras_assert0(gras_dynar_length(child->sub) == 0, "Found a dead child with grand childs. Internal error"); - CDEBUG1(dict_collapse, "Remove dead child %p.... ", p_child); - gras_dynar_remove_at(p_head->sub, pos, &p_child); + CDEBUG1(dict_collapse, "Remove dead child %p.... ", (void*)child); + gras_dynar_remove_at(head->sub, pos, &child); + gras_dictelm_free(&child); } } - if (!p_head->key) { + if (!head->key) { CDEBUG0(dict_collapse, "Do not collapse the head, you stupid programm"); return; } - if (p_head->content || p_head->free_ctn || - gras_dynar_length(p_head->sub) != 1) { + if (head->content || head->free_f || + gras_dynar_length(head->sub) != 1) { CDEBUG0(dict_collapse, "Cannot collapse"); return; /* cannot collapse */ } - gras_dynar_get(p_head->sub, 0, &p_child); + child = gras_dynar_get_as(head->sub, 0, gras_dictelm_t); /* Get the child's key as new key */ CDEBUG2(dict_collapse, - "Do collapse with only child %.*s", p_child->key_len, p_child->key); + "Do collapse with only child %.*s", child->key_len, child->key); - p_head->content = p_child->content; - p_head->free_ctn = p_child->free_ctn; - free(p_head->key); - p_head->key = p_child->key; - p_head->key_len = p_child->key_len; + head->content = child->content; + head->free_f = child->free_f; + gras_free(head->key); + head->key = child->key; + head->key_len = child->key_len; - gras_dynar_free_container(p_head->sub) ; + gras_dynar_free_container(&(head->sub)) ; - p_head->sub = p_child->sub; - free(p_child); + head->sub = child->sub; + gras_free(child); } /** @@ -810,7 +777,7 @@ _collapse_if_need(gras_dictelm_t *p_head, * Remove the entry associated with the given @key */ gras_error_t -_gras_dictelm_remove_rec(gras_dictelm_t *p_head, +_gras_dictelm_remove_rec(gras_dictelm_t head, const char *key, int key_len, int offset) { @@ -820,18 +787,18 @@ _gras_dictelm_remove_rec(gras_dictelm_t *p_head, if (offset >= key_len) { int killme = 0; /* do I need to suicide me ? */ - if (p_head->content && p_head->free_ctn) { - p_head->free_ctn(p_head->content); + if (head->content && head->free_f) { + head->free_f(head->content); } - killme = !gras_dynar_length(p_head->sub); - p_head->content = NULL; - p_head->free_ctn = NULL; - _collapse_if_need(p_head, -1, offset); + killme = !gras_dynar_length(head->sub); + head->content = NULL; + head->free_f = NULL; + _collapse_if_need(head, -1, offset); if (killme) { DEBUG0("kill this node"); - p_head->key_len = 0; /* killme. Cleanup done one step higher in recursion */ + head->key_len = 0; /* killme. Cleanup done one step higher in recursion */ } return errcode; @@ -842,7 +809,7 @@ _gras_dictelm_remove_rec(gras_dictelm_t *p_head, int old_offset = offset; /*** Search where is the good child, and how good it is ***/ - _gras_dictelm_child_search(p_head, key, key_len, &pos, &offset, &match); + _gras_dictelm_child_search(head, key, key_len, &pos, &offset, &match); switch (match) { @@ -850,14 +817,14 @@ _gras_dictelm_remove_rec(gras_dictelm_t *p_head, case 2: /* A child constitutes a prefix of the key => recurse */ { - gras_dictelm_t *p_child = NULL; + s_gras_dictelm_t *p_child = NULL; - gras_dynar_get(p_head->sub, pos, &p_child); + p_child = gras_dynar_get_as(head->sub, pos, s_gras_dictelm_t*); /*DEBUG5("Recurse on child %d of %p to remove %.*s (prefix=%d)", - pos, p_child, key+offset, key_len-offset,offset);*/ + pos, (void*)p_child, key+offset, key_len-offset,offset);*/ TRY(_gras_dictelm_remove_rec(p_child, key, key_len, offset)); - _collapse_if_need(p_head, pos, old_offset); + _collapse_if_need(head, pos, old_offset); return no_error; } @@ -886,15 +853,15 @@ _gras_dictelm_remove_rec(gras_dictelm_t *p_head, * Remove the entry associated with the given @key */ gras_error_t -gras_dictelm_remove_ext(gras_dictelm_t *p_head, - const char *key, - int key_len) { +gras_dictelm_remove_ext(gras_dictelm_t head, + const char *key, + int key_len) { /* there is no head, go to hell */ - if (!p_head) { + if (!head) { RAISE0(mismatch_error, "there is no head, go to hell"); } - return _gras_dictelm_remove_rec(p_head, key, key_len, 0); + return _gras_dictelm_remove_rec(head, key, key_len, 0); } /** @@ -907,40 +874,37 @@ gras_dictelm_remove_ext(gras_dictelm_t *p_head, * Remove the entry associated with the given @key */ gras_error_t -gras_dictelm_remove(gras_dictelm_t *p_head, +gras_dictelm_remove(gras_dictelm_t head, const char *key) { - return _gras_dictelm_remove_rec(p_head, key, 1+strlen(key),0); + return _gras_dictelm_remove_rec(head, key, 1+strlen(key),0); } /*----[ _gras_dict_dump_rec ]------------------------------------------------*/ /* private function to do the job of gras_dict_dump recursively */ /*---------------------------------------------------------------------------*/ static -gras_error_t -_gras_dictelm_dump_rec(gras_dictelm_t *p_head, +void +_gras_dictelm_dump_rec(gras_dictelm_t head, int offset, void_f_pvoid_t *output) { - gras_error_t errcode = no_error; - gras_dictelm_t *p_child = NULL; - char *key = NULL; - int key_len = 0; - int i = 0; + gras_dictelm_t child = NULL; + char *key = NULL; + int key_len = 0; + int i = 0; - if (!p_head) - return no_error; + if (!head) + return; - printf("[%p] ", p_head); + printf("[%p] ", (void*)head); - key = p_head->key; - key_len = p_head->key_len; + key = head->key; + key_len = head->key_len; - if (key_len) { + if (key_len) printf (" "); - } - for (i = 0; i < offset; i++) { + for (i = 0; i < offset; i++) printf("-"); - } fflush(stdout); @@ -951,25 +915,22 @@ _gras_dictelm_dump_rec(gras_dictelm_t *p_head, } else { char *key_string = NULL; - key_string = malloc(key_len*2+1); - if (!key_string) - RAISE_MALLOC; - + key_string = gras_malloc(key_len*2+1); _gras_bytes_to_string(key, key_len, key_string); printf("%.*s|(%d)", key_len-offset, key_string + offset, offset); - free(key_string); + gras_free(key_string); } } printf(" -> "); - if (p_head->content) { + if (head->content) { if (output) { - output(p_head->content); + output(head->content); } else { printf("(data)"); } @@ -978,12 +939,11 @@ _gras_dictelm_dump_rec(gras_dictelm_t *p_head, printf("(null)"); } - printf(" \t\t\t[ %d child(s) ]\n", gras_dynar_length(p_head->sub)); + printf(" \t\t\t[ %lu child(s) ]\n", gras_dynar_length(head->sub)); - gras_dynar_foreach(p_head->sub, i, p_child) - TRY(_gras_dictelm_dump_rec(p_child, p_child->offset, output)); + gras_dynar_foreach(head->sub, i, child) + _gras_dictelm_dump_rec(child, child->offset, output); - return errcode; } /** @@ -997,10 +957,10 @@ _gras_dictelm_dump_rec(gras_dictelm_t *p_head, * function to output the data. If NULL, data won't be displayed. */ -gras_error_t -gras_dictelm_dump(gras_dictelm_t *p_head, - void_f_pvoid_t *output) { - return _gras_dictelm_dump_rec(p_head, 0, output); +void +gras_dictelm_dump(gras_dictelm_t head, + void_f_pvoid_t *output) { + _gras_dictelm_dump_rec(head, 0, output); } /** @@ -1013,6 +973,6 @@ gras_dictelm_dump(gras_dictelm_t *p_head, void gras_dictelm_print_fct(void *data) { - printf("tree %p", data); + printf("tree %p", (void*)data); }