mirror of https://github.com/vitalif/e2fsprogs
e2fsck: clean up assertions in dict.c
The C preprocessing symbol NDEBUG is also defined (differently) by Android's build files, and this was causing compilation failures. So change assert() to dict_assert() and manually define it instead of relying on the NDEBUG and <assert.h> semantics. Also make sure the necessary debugging functions are available is DICT_NODEBUG is not defined, so that dict.c will correctly build with and without DICT_NODEBUG. Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>debian
parent
52a06740ef
commit
c379cdc334
129
e2fsck/dict.c
129
e2fsck/dict.c
|
@ -18,7 +18,7 @@
|
||||||
* $Name: kazlib_1_20 $
|
* $Name: kazlib_1_20 $
|
||||||
*/
|
*/
|
||||||
|
|
||||||
#define NDEBUG
|
#define DICT_NODEBUG
|
||||||
|
|
||||||
#ifdef __GNUC__
|
#ifdef __GNUC__
|
||||||
#define EXT2FS_ATTR(x) __attribute__(x)
|
#define EXT2FS_ATTR(x) __attribute__(x)
|
||||||
|
@ -29,7 +29,12 @@
|
||||||
#include "config.h"
|
#include "config.h"
|
||||||
#include <stdlib.h>
|
#include <stdlib.h>
|
||||||
#include <stddef.h>
|
#include <stddef.h>
|
||||||
|
#ifdef DICT_NODEBUG
|
||||||
|
#define dict_assert(x)
|
||||||
|
#else
|
||||||
#include <assert.h>
|
#include <assert.h>
|
||||||
|
#define dict_assert(x) assert(x)
|
||||||
|
#endif
|
||||||
#define DICT_IMPLEMENTATION
|
#define DICT_IMPLEMENTATION
|
||||||
#include "dict.h"
|
#include "dict.h"
|
||||||
|
|
||||||
|
@ -97,7 +102,7 @@ static void rotate_left(dnode_t *upper)
|
||||||
if (upper == upparent->left) {
|
if (upper == upparent->left) {
|
||||||
upparent->left = lower;
|
upparent->left = lower;
|
||||||
} else {
|
} else {
|
||||||
assert (upper == upparent->right);
|
dict_assert (upper == upparent->right);
|
||||||
upparent->right = lower;
|
upparent->right = lower;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -123,7 +128,7 @@ static void rotate_right(dnode_t *upper)
|
||||||
if (upper == upparent->right) {
|
if (upper == upparent->right) {
|
||||||
upparent->right = lower;
|
upparent->right = lower;
|
||||||
} else {
|
} else {
|
||||||
assert (upper == upparent->left);
|
dict_assert (upper == upparent->left);
|
||||||
upparent->left = lower;
|
upparent->left = lower;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -153,7 +158,7 @@ static void free_nodes(dict_t *dict, dnode_t *node, dnode_t *nil)
|
||||||
* or lower or equal if duplicates are allowed. This function is used for
|
* or lower or equal if duplicates are allowed. This function is used for
|
||||||
* debugging purposes.
|
* debugging purposes.
|
||||||
*/
|
*/
|
||||||
#ifndef NDEBUG
|
#ifndef DICT_NODEBUG
|
||||||
static int verify_bintree(dict_t *dict)
|
static int verify_bintree(dict_t *dict)
|
||||||
{
|
{
|
||||||
dnode_t *first, *next;
|
dnode_t *first, *next;
|
||||||
|
@ -281,8 +286,8 @@ dict_t *dict_create(dictcount_t maxcount, dict_comp_t comp)
|
||||||
void dict_set_allocator(dict_t *dict, dnode_alloc_t al,
|
void dict_set_allocator(dict_t *dict, dnode_alloc_t al,
|
||||||
dnode_free_t fr, void *context)
|
dnode_free_t fr, void *context)
|
||||||
{
|
{
|
||||||
assert (dict_count(dict) == 0);
|
dict_assert (dict_count(dict) == 0);
|
||||||
assert ((al == NULL && fr == NULL) || (al != NULL && fr != NULL));
|
dict_assert ((al == NULL && fr == NULL) || (al != NULL && fr != NULL));
|
||||||
|
|
||||||
dict->allocnode = al ? al : dnode_alloc;
|
dict->allocnode = al ? al : dnode_alloc;
|
||||||
dict->freenode = fr ? fr : dnode_free;
|
dict->freenode = fr ? fr : dnode_free;
|
||||||
|
@ -297,7 +302,7 @@ void dict_set_allocator(dict_t *dict, dnode_alloc_t al,
|
||||||
|
|
||||||
void dict_destroy(dict_t *dict)
|
void dict_destroy(dict_t *dict)
|
||||||
{
|
{
|
||||||
assert (dict_isempty(dict));
|
dict_assert (dict_isempty(dict));
|
||||||
free(dict);
|
free(dict);
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
@ -323,7 +328,7 @@ void dict_free_nodes(dict_t *dict)
|
||||||
void dict_free(dict_t *dict)
|
void dict_free(dict_t *dict)
|
||||||
{
|
{
|
||||||
#ifdef KAZLIB_OBSOLESCENT_DEBUG
|
#ifdef KAZLIB_OBSOLESCENT_DEBUG
|
||||||
assert ("call to obsolescent function dict_free()" && 0);
|
dict_assert ("call to obsolescent function dict_free()" && 0);
|
||||||
#endif
|
#endif
|
||||||
dict_free_nodes(dict);
|
dict_free_nodes(dict);
|
||||||
}
|
}
|
||||||
|
@ -368,7 +373,7 @@ void dict_init_like(dict_t *dict, const dict_t *template)
|
||||||
dict->nilnode.color = dnode_black;
|
dict->nilnode.color = dnode_black;
|
||||||
dict->dupes = template->dupes;
|
dict->dupes = template->dupes;
|
||||||
|
|
||||||
assert (dict_similar(dict, template));
|
dict_assert (dict_similar(dict, template));
|
||||||
}
|
}
|
||||||
|
|
||||||
/*
|
/*
|
||||||
|
@ -381,8 +386,9 @@ static void dict_clear(dict_t *dict)
|
||||||
dict->nilnode.left = &dict->nilnode;
|
dict->nilnode.left = &dict->nilnode;
|
||||||
dict->nilnode.right = &dict->nilnode;
|
dict->nilnode.right = &dict->nilnode;
|
||||||
dict->nilnode.parent = &dict->nilnode;
|
dict->nilnode.parent = &dict->nilnode;
|
||||||
assert (dict->nilnode.color == dnode_black);
|
dict_assert (dict->nilnode.color == dnode_black);
|
||||||
}
|
}
|
||||||
|
#endif /* E2FSCK_NOTUSED */
|
||||||
|
|
||||||
|
|
||||||
/*
|
/*
|
||||||
|
@ -391,10 +397,9 @@ static void dict_clear(dict_t *dict)
|
||||||
* this function succeeds doesn't mean that the tree is not corrupt. Certain
|
* this function succeeds doesn't mean that the tree is not corrupt. Certain
|
||||||
* corruptions in the tree may simply cause undefined behavior.
|
* corruptions in the tree may simply cause undefined behavior.
|
||||||
*/
|
*/
|
||||||
|
#ifndef DICT_NODEBUG
|
||||||
int dict_verify(dict_t *dict)
|
int dict_verify(dict_t *dict)
|
||||||
{
|
{
|
||||||
#ifndef NDEBUG
|
|
||||||
dnode_t *nil = dict_nil(dict), *root = dict_root(dict);
|
dnode_t *nil = dict_nil(dict), *root = dict_root(dict);
|
||||||
|
|
||||||
/* check that the sentinel node and root node are black */
|
/* check that the sentinel node and root node are black */
|
||||||
|
@ -415,15 +420,15 @@ int dict_verify(dict_t *dict)
|
||||||
return 0;
|
return 0;
|
||||||
if (verify_node_count(nil, root) != dict_count(dict))
|
if (verify_node_count(nil, root) != dict_count(dict))
|
||||||
return 0;
|
return 0;
|
||||||
#endif
|
|
||||||
return 1;
|
return 1;
|
||||||
}
|
}
|
||||||
|
#endif /* DICT_NODEBUG */
|
||||||
|
|
||||||
|
#ifdef E2FSCK_NOTUSED
|
||||||
/*
|
/*
|
||||||
* Determine whether two dictionaries are similar: have the same comparison and
|
* Determine whether two dictionaries are similar: have the same comparison and
|
||||||
* allocator functions, and same status as to whether duplicates are allowed.
|
* allocator functions, and same status as to whether duplicates are allowed.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
int dict_similar(const dict_t *left, const dict_t *right)
|
int dict_similar(const dict_t *left, const dict_t *right)
|
||||||
{
|
{
|
||||||
if (left->compare != right->compare)
|
if (left->compare != right->compare)
|
||||||
|
@ -567,9 +572,9 @@ void dict_insert(dict_t *dict, dnode_t *node, const void *key)
|
||||||
|
|
||||||
node->key = key;
|
node->key = key;
|
||||||
|
|
||||||
assert (!dict_isfull(dict));
|
dict_assert (!dict_isfull(dict));
|
||||||
assert (!dict_contains(dict, node));
|
dict_assert (!dict_contains(dict, node));
|
||||||
assert (!dnode_is_in_a_dict(node));
|
dict_assert (!dnode_is_in_a_dict(node));
|
||||||
|
|
||||||
/* basic binary tree insert */
|
/* basic binary tree insert */
|
||||||
|
|
||||||
|
@ -577,14 +582,14 @@ void dict_insert(dict_t *dict, dnode_t *node, const void *key)
|
||||||
parent = where;
|
parent = where;
|
||||||
result = dict->compare(key, where->key);
|
result = dict->compare(key, where->key);
|
||||||
/* trap attempts at duplicate key insertion unless it's explicitly allowed */
|
/* trap attempts at duplicate key insertion unless it's explicitly allowed */
|
||||||
assert (dict->dupes || result != 0);
|
dict_assert (dict->dupes || result != 0);
|
||||||
if (result < 0)
|
if (result < 0)
|
||||||
where = where->left;
|
where = where->left;
|
||||||
else
|
else
|
||||||
where = where->right;
|
where = where->right;
|
||||||
}
|
}
|
||||||
|
|
||||||
assert (where == nil);
|
dict_assert (where == nil);
|
||||||
|
|
||||||
if (result < 0)
|
if (result < 0)
|
||||||
parent->left = node;
|
parent->left = node;
|
||||||
|
@ -615,7 +620,7 @@ void dict_insert(dict_t *dict, dnode_t *node, const void *key)
|
||||||
if (node == parent->right) {
|
if (node == parent->right) {
|
||||||
rotate_left(parent);
|
rotate_left(parent);
|
||||||
parent = node;
|
parent = node;
|
||||||
assert (grandpa == parent->parent);
|
dict_assert (grandpa == parent->parent);
|
||||||
/* rotation between parent and child preserves grandpa */
|
/* rotation between parent and child preserves grandpa */
|
||||||
}
|
}
|
||||||
parent->color = dnode_black;
|
parent->color = dnode_black;
|
||||||
|
@ -635,7 +640,7 @@ void dict_insert(dict_t *dict, dnode_t *node, const void *key)
|
||||||
if (node == parent->left) {
|
if (node == parent->left) {
|
||||||
rotate_right(parent);
|
rotate_right(parent);
|
||||||
parent = node;
|
parent = node;
|
||||||
assert (grandpa == parent->parent);
|
dict_assert (grandpa == parent->parent);
|
||||||
}
|
}
|
||||||
parent->color = dnode_black;
|
parent->color = dnode_black;
|
||||||
grandpa->color = dnode_red;
|
grandpa->color = dnode_red;
|
||||||
|
@ -647,7 +652,7 @@ void dict_insert(dict_t *dict, dnode_t *node, const void *key)
|
||||||
|
|
||||||
dict_root(dict)->color = dnode_black;
|
dict_root(dict)->color = dnode_black;
|
||||||
|
|
||||||
assert (dict_verify(dict));
|
dict_assert (dict_verify(dict));
|
||||||
}
|
}
|
||||||
|
|
||||||
#ifdef E2FSCK_NOTUSED
|
#ifdef E2FSCK_NOTUSED
|
||||||
|
@ -663,8 +668,8 @@ dnode_t *dict_delete(dict_t *dict, dnode_t *delete)
|
||||||
|
|
||||||
/* basic deletion */
|
/* basic deletion */
|
||||||
|
|
||||||
assert (!dict_isempty(dict));
|
dict_assert (!dict_isempty(dict));
|
||||||
assert (dict_contains(dict, delete));
|
dict_assert (dict_contains(dict, delete));
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* If the node being deleted has two children, then we replace it with its
|
* If the node being deleted has two children, then we replace it with its
|
||||||
|
@ -683,9 +688,9 @@ dnode_t *dict_delete(dict_t *dict, dnode_t *delete)
|
||||||
dnode_t *nextparent = next->parent;
|
dnode_t *nextparent = next->parent;
|
||||||
dnode_color_t nextcolor = next->color;
|
dnode_color_t nextcolor = next->color;
|
||||||
|
|
||||||
assert (next != nil);
|
dict_assert (next != nil);
|
||||||
assert (next->parent != nil);
|
dict_assert (next->parent != nil);
|
||||||
assert (next->left == nil);
|
dict_assert (next->left == nil);
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* First, splice out the successor from the tree completely, by
|
* First, splice out the successor from the tree completely, by
|
||||||
|
@ -698,7 +703,7 @@ dnode_t *dict_delete(dict_t *dict, dnode_t *delete)
|
||||||
if (nextparent->left == next) {
|
if (nextparent->left == next) {
|
||||||
nextparent->left = child;
|
nextparent->left = child;
|
||||||
} else {
|
} else {
|
||||||
assert (nextparent->right == next);
|
dict_assert (nextparent->right == next);
|
||||||
nextparent->right = child;
|
nextparent->right = child;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -718,13 +723,13 @@ dnode_t *dict_delete(dict_t *dict, dnode_t *delete)
|
||||||
if (delparent->left == delete) {
|
if (delparent->left == delete) {
|
||||||
delparent->left = next;
|
delparent->left = next;
|
||||||
} else {
|
} else {
|
||||||
assert (delparent->right == delete);
|
dict_assert (delparent->right == delete);
|
||||||
delparent->right = next;
|
delparent->right = next;
|
||||||
}
|
}
|
||||||
|
|
||||||
} else {
|
} else {
|
||||||
assert (delete != nil);
|
dict_assert (delete != nil);
|
||||||
assert (delete->left == nil || delete->right == nil);
|
dict_assert (delete->left == nil || delete->right == nil);
|
||||||
|
|
||||||
child = (delete->left != nil) ? delete->left : delete->right;
|
child = (delete->left != nil) ? delete->left : delete->right;
|
||||||
|
|
||||||
|
@ -733,7 +738,7 @@ dnode_t *dict_delete(dict_t *dict, dnode_t *delete)
|
||||||
if (delete == delparent->left) {
|
if (delete == delparent->left) {
|
||||||
delparent->left = child;
|
delparent->left = child;
|
||||||
} else {
|
} else {
|
||||||
assert (delete == delparent->right);
|
dict_assert (delete == delparent->right);
|
||||||
delparent->right = child;
|
delparent->right = child;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -744,7 +749,7 @@ dnode_t *dict_delete(dict_t *dict, dnode_t *delete)
|
||||||
|
|
||||||
dict->nodecount--;
|
dict->nodecount--;
|
||||||
|
|
||||||
assert (verify_bintree(dict));
|
dict_assert (verify_bintree(dict));
|
||||||
|
|
||||||
/* red-black adjustments */
|
/* red-black adjustments */
|
||||||
|
|
||||||
|
@ -757,13 +762,13 @@ dnode_t *dict_delete(dict_t *dict, dnode_t *delete)
|
||||||
parent = child->parent;
|
parent = child->parent;
|
||||||
if (child == parent->left) {
|
if (child == parent->left) {
|
||||||
sister = parent->right;
|
sister = parent->right;
|
||||||
assert (sister != nil);
|
dict_assert (sister != nil);
|
||||||
if (sister->color == dnode_red) {
|
if (sister->color == dnode_red) {
|
||||||
sister->color = dnode_black;
|
sister->color = dnode_black;
|
||||||
parent->color = dnode_red;
|
parent->color = dnode_red;
|
||||||
rotate_left(parent);
|
rotate_left(parent);
|
||||||
sister = parent->right;
|
sister = parent->right;
|
||||||
assert (sister != nil);
|
dict_assert (sister != nil);
|
||||||
}
|
}
|
||||||
if (sister->left->color == dnode_black
|
if (sister->left->color == dnode_black
|
||||||
&& sister->right->color == dnode_black) {
|
&& sister->right->color == dnode_black) {
|
||||||
|
@ -771,12 +776,12 @@ dnode_t *dict_delete(dict_t *dict, dnode_t *delete)
|
||||||
child = parent;
|
child = parent;
|
||||||
} else {
|
} else {
|
||||||
if (sister->right->color == dnode_black) {
|
if (sister->right->color == dnode_black) {
|
||||||
assert (sister->left->color == dnode_red);
|
dict_assert (sister->left->color == dnode_red);
|
||||||
sister->left->color = dnode_black;
|
sister->left->color = dnode_black;
|
||||||
sister->color = dnode_red;
|
sister->color = dnode_red;
|
||||||
rotate_right(sister);
|
rotate_right(sister);
|
||||||
sister = parent->right;
|
sister = parent->right;
|
||||||
assert (sister != nil);
|
dict_assert (sister != nil);
|
||||||
}
|
}
|
||||||
sister->color = parent->color;
|
sister->color = parent->color;
|
||||||
sister->right->color = dnode_black;
|
sister->right->color = dnode_black;
|
||||||
|
@ -785,15 +790,15 @@ dnode_t *dict_delete(dict_t *dict, dnode_t *delete)
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
} else { /* symmetric case: child == child->parent->right */
|
} else { /* symmetric case: child == child->parent->right */
|
||||||
assert (child == parent->right);
|
dict_assert (child == parent->right);
|
||||||
sister = parent->left;
|
sister = parent->left;
|
||||||
assert (sister != nil);
|
dict_assert (sister != nil);
|
||||||
if (sister->color == dnode_red) {
|
if (sister->color == dnode_red) {
|
||||||
sister->color = dnode_black;
|
sister->color = dnode_black;
|
||||||
parent->color = dnode_red;
|
parent->color = dnode_red;
|
||||||
rotate_right(parent);
|
rotate_right(parent);
|
||||||
sister = parent->left;
|
sister = parent->left;
|
||||||
assert (sister != nil);
|
dict_assert (sister != nil);
|
||||||
}
|
}
|
||||||
if (sister->right->color == dnode_black
|
if (sister->right->color == dnode_black
|
||||||
&& sister->left->color == dnode_black) {
|
&& sister->left->color == dnode_black) {
|
||||||
|
@ -801,12 +806,12 @@ dnode_t *dict_delete(dict_t *dict, dnode_t *delete)
|
||||||
child = parent;
|
child = parent;
|
||||||
} else {
|
} else {
|
||||||
if (sister->left->color == dnode_black) {
|
if (sister->left->color == dnode_black) {
|
||||||
assert (sister->right->color == dnode_red);
|
dict_assert (sister->right->color == dnode_red);
|
||||||
sister->right->color = dnode_black;
|
sister->right->color = dnode_black;
|
||||||
sister->color = dnode_red;
|
sister->color = dnode_red;
|
||||||
rotate_left(sister);
|
rotate_left(sister);
|
||||||
sister = parent->left;
|
sister = parent->left;
|
||||||
assert (sister != nil);
|
dict_assert (sister != nil);
|
||||||
}
|
}
|
||||||
sister->color = parent->color;
|
sister->color = parent->color;
|
||||||
sister->left->color = dnode_black;
|
sister->left->color = dnode_black;
|
||||||
|
@ -821,7 +826,7 @@ dnode_t *dict_delete(dict_t *dict, dnode_t *delete)
|
||||||
dict_root(dict)->color = dnode_black;
|
dict_root(dict)->color = dnode_black;
|
||||||
}
|
}
|
||||||
|
|
||||||
assert (dict_verify(dict));
|
dict_assert (dict_verify(dict));
|
||||||
|
|
||||||
return delete;
|
return delete;
|
||||||
}
|
}
|
||||||
|
@ -1003,7 +1008,7 @@ dnode_t *dnode_init(dnode_t *dnode, void *data)
|
||||||
|
|
||||||
void dnode_destroy(dnode_t *dnode)
|
void dnode_destroy(dnode_t *dnode)
|
||||||
{
|
{
|
||||||
assert (!dnode_is_in_a_dict(dnode));
|
dict_assert (!dnode_is_in_a_dict(dnode));
|
||||||
free(dnode);
|
free(dnode);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1022,12 +1027,16 @@ void dnode_put(dnode_t *dnode, void *data)
|
||||||
{
|
{
|
||||||
dnode->data = data;
|
dnode->data = data;
|
||||||
}
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifndef DICT_NODEBUG
|
||||||
int dnode_is_in_a_dict(dnode_t *dnode)
|
int dnode_is_in_a_dict(dnode_t *dnode)
|
||||||
{
|
{
|
||||||
return (dnode->parent && dnode->left && dnode->right);
|
return (dnode->parent && dnode->left && dnode->right);
|
||||||
}
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef E2FSCK_NOTUSED
|
||||||
void dict_process(dict_t *dict, void *context, dnode_process_t function)
|
void dict_process(dict_t *dict, void *context, dnode_process_t function)
|
||||||
{
|
{
|
||||||
dnode_t *node = dict_first(dict), *next;
|
dnode_t *node = dict_first(dict), *next;
|
||||||
|
@ -1035,7 +1044,7 @@ void dict_process(dict_t *dict, void *context, dnode_process_t function)
|
||||||
while (node != NULL) {
|
while (node != NULL) {
|
||||||
/* check for callback function deleting */
|
/* check for callback function deleting */
|
||||||
/* the next node from under us */
|
/* the next node from under us */
|
||||||
assert (dict_contains(dict, node));
|
dict_assert (dict_contains(dict, node));
|
||||||
next = dict_next(dict, node);
|
next = dict_next(dict, node);
|
||||||
function(dict, node, context);
|
function(dict, node, context);
|
||||||
node = next;
|
node = next;
|
||||||
|
@ -1051,7 +1060,7 @@ static void load_begin_internal(dict_load_t *load, dict_t *dict)
|
||||||
|
|
||||||
void dict_load_begin(dict_load_t *load, dict_t *dict)
|
void dict_load_begin(dict_load_t *load, dict_t *dict)
|
||||||
{
|
{
|
||||||
assert (dict_isempty(dict));
|
dict_assert (dict_isempty(dict));
|
||||||
load_begin_internal(load, dict);
|
load_begin_internal(load, dict);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1060,15 +1069,15 @@ void dict_load_next(dict_load_t *load, dnode_t *newnode, const void *key)
|
||||||
dict_t *dict = load->dictptr;
|
dict_t *dict = load->dictptr;
|
||||||
dnode_t *nil = &load->nilnode;
|
dnode_t *nil = &load->nilnode;
|
||||||
|
|
||||||
assert (!dnode_is_in_a_dict(newnode));
|
dict_assert (!dnode_is_in_a_dict(newnode));
|
||||||
assert (dict->nodecount < dict->maxcount);
|
dict_assert (dict->nodecount < dict->maxcount);
|
||||||
|
|
||||||
#ifndef NDEBUG
|
#ifndef DICT_NODEBUG
|
||||||
if (dict->nodecount > 0) {
|
if (dict->nodecount > 0) {
|
||||||
if (dict->dupes)
|
if (dict->dupes)
|
||||||
assert (dict->compare(nil->left->key, key) <= 0);
|
dict_assert (dict->compare(nil->left->key, key) <= 0);
|
||||||
else
|
else
|
||||||
assert (dict->compare(nil->left->key, key) < 0);
|
dict_assert (dict->compare(nil->left->key, key) < 0);
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
@ -1089,7 +1098,7 @@ void dict_load_end(dict_load_t *load)
|
||||||
dictcount_t botrowcount;
|
dictcount_t botrowcount;
|
||||||
unsigned baselevel = 0, level = 0, i;
|
unsigned baselevel = 0, level = 0, i;
|
||||||
|
|
||||||
assert (dnode_red == 0 && dnode_black == 1);
|
dict_assert (dnode_red == 0 && dnode_black == 1);
|
||||||
|
|
||||||
while (fullcount >= nodecount && fullcount)
|
while (fullcount >= nodecount && fullcount)
|
||||||
fullcount >>= 1;
|
fullcount >>= 1;
|
||||||
|
@ -1100,8 +1109,8 @@ void dict_load_end(dict_load_t *load)
|
||||||
next = curr->left;
|
next = curr->left;
|
||||||
|
|
||||||
if (complete == NULL && botrowcount-- == 0) {
|
if (complete == NULL && botrowcount-- == 0) {
|
||||||
assert (baselevel == 0);
|
dict_assert (baselevel == 0);
|
||||||
assert (level == 0);
|
dict_assert (level == 0);
|
||||||
baselevel = level = 1;
|
baselevel = level = 1;
|
||||||
complete = tree[0];
|
complete = tree[0];
|
||||||
|
|
||||||
|
@ -1123,7 +1132,7 @@ void dict_load_end(dict_load_t *load)
|
||||||
curr->color = level % 2;
|
curr->color = level % 2;
|
||||||
complete = curr;
|
complete = curr;
|
||||||
|
|
||||||
assert (level == baselevel);
|
dict_assert (level == baselevel);
|
||||||
while (tree[level] != 0) {
|
while (tree[level] != 0) {
|
||||||
tree[level]->right = complete;
|
tree[level]->right = complete;
|
||||||
complete->parent = tree[level];
|
complete->parent = tree[level];
|
||||||
|
@ -1157,7 +1166,7 @@ void dict_load_end(dict_load_t *load)
|
||||||
complete->color = dnode_black;
|
complete->color = dnode_black;
|
||||||
dict_root(dict) = complete;
|
dict_root(dict) = complete;
|
||||||
|
|
||||||
assert (dict_verify(dict));
|
dict_assert (dict_verify(dict));
|
||||||
}
|
}
|
||||||
|
|
||||||
void dict_merge(dict_t *dest, dict_t *source)
|
void dict_merge(dict_t *dest, dict_t *source)
|
||||||
|
@ -1165,7 +1174,7 @@ void dict_merge(dict_t *dest, dict_t *source)
|
||||||
dict_load_t load;
|
dict_load_t load;
|
||||||
dnode_t *leftnode = dict_first(dest), *rightnode = dict_first(source);
|
dnode_t *leftnode = dict_first(dest), *rightnode = dict_first(source);
|
||||||
|
|
||||||
assert (dict_similar(dest, source));
|
dict_assert (dict_similar(dest, source));
|
||||||
|
|
||||||
if (source == dest)
|
if (source == dest)
|
||||||
return;
|
return;
|
||||||
|
@ -1184,14 +1193,14 @@ void dict_merge(dict_t *dest, dict_t *source)
|
||||||
} else if (rightnode != NULL) {
|
} else if (rightnode != NULL) {
|
||||||
goto copyright;
|
goto copyright;
|
||||||
} else {
|
} else {
|
||||||
assert (leftnode == NULL && rightnode == NULL);
|
dict_assert (leftnode == NULL && rightnode == NULL);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
||||||
copyleft:
|
copyleft:
|
||||||
{
|
{
|
||||||
dnode_t *next = dict_next(dest, leftnode);
|
dnode_t *next = dict_next(dest, leftnode);
|
||||||
#ifndef NDEBUG
|
#ifndef DICT_NODEBUG
|
||||||
leftnode->left = NULL; /* suppress assertion in dict_load_next */
|
leftnode->left = NULL; /* suppress assertion in dict_load_next */
|
||||||
#endif
|
#endif
|
||||||
dict_load_next(&load, leftnode, leftnode->key);
|
dict_load_next(&load, leftnode, leftnode->key);
|
||||||
|
@ -1202,7 +1211,7 @@ void dict_merge(dict_t *dest, dict_t *source)
|
||||||
copyright:
|
copyright:
|
||||||
{
|
{
|
||||||
dnode_t *next = dict_next(source, rightnode);
|
dnode_t *next = dict_next(source, rightnode);
|
||||||
#ifndef NDEBUG
|
#ifndef DICT_NODEBUG
|
||||||
rightnode->left = NULL;
|
rightnode->left = NULL;
|
||||||
#endif
|
#endif
|
||||||
dict_load_next(&load, rightnode, rightnode->key);
|
dict_load_next(&load, rightnode, rightnode->key);
|
||||||
|
|
Loading…
Reference in New Issue