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
Theodore Ts'o
parent
52a06740ef
commit
c379cdc334
129
e2fsck/dict.c
129
e2fsck/dict.c
|
|
@ -18,7 +18,7 @@
|
|||
* $Name: kazlib_1_20 $
|
||||
*/
|
||||
|
||||
#define NDEBUG
|
||||
#define DICT_NODEBUG
|
||||
|
||||
#ifdef __GNUC__
|
||||
#define EXT2FS_ATTR(x) __attribute__(x)
|
||||
|
|
@ -29,7 +29,12 @@
|
|||
#include "config.h"
|
||||
#include <stdlib.h>
|
||||
#include <stddef.h>
|
||||
#ifdef DICT_NODEBUG
|
||||
#define dict_assert(x)
|
||||
#else
|
||||
#include <assert.h>
|
||||
#define dict_assert(x) assert(x)
|
||||
#endif
|
||||
#define DICT_IMPLEMENTATION
|
||||
#include "dict.h"
|
||||
|
||||
|
|
@ -97,7 +102,7 @@ static void rotate_left(dnode_t *upper)
|
|||
if (upper == upparent->left) {
|
||||
upparent->left = lower;
|
||||
} else {
|
||||
assert (upper == upparent->right);
|
||||
dict_assert (upper == upparent->right);
|
||||
upparent->right = lower;
|
||||
}
|
||||
|
||||
|
|
@ -123,7 +128,7 @@ static void rotate_right(dnode_t *upper)
|
|||
if (upper == upparent->right) {
|
||||
upparent->right = lower;
|
||||
} else {
|
||||
assert (upper == upparent->left);
|
||||
dict_assert (upper == upparent->left);
|
||||
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
|
||||
* debugging purposes.
|
||||
*/
|
||||
#ifndef NDEBUG
|
||||
#ifndef DICT_NODEBUG
|
||||
static int verify_bintree(dict_t *dict)
|
||||
{
|
||||
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,
|
||||
dnode_free_t fr, void *context)
|
||||
{
|
||||
assert (dict_count(dict) == 0);
|
||||
assert ((al == NULL && fr == NULL) || (al != NULL && fr != NULL));
|
||||
dict_assert (dict_count(dict) == 0);
|
||||
dict_assert ((al == NULL && fr == NULL) || (al != NULL && fr != NULL));
|
||||
|
||||
dict->allocnode = al ? al : dnode_alloc;
|
||||
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)
|
||||
{
|
||||
assert (dict_isempty(dict));
|
||||
dict_assert (dict_isempty(dict));
|
||||
free(dict);
|
||||
}
|
||||
#endif
|
||||
|
|
@ -323,7 +328,7 @@ void dict_free_nodes(dict_t *dict)
|
|||
void dict_free(dict_t *dict)
|
||||
{
|
||||
#ifdef KAZLIB_OBSOLESCENT_DEBUG
|
||||
assert ("call to obsolescent function dict_free()" && 0);
|
||||
dict_assert ("call to obsolescent function dict_free()" && 0);
|
||||
#endif
|
||||
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->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.right = &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
|
||||
* corruptions in the tree may simply cause undefined behavior.
|
||||
*/
|
||||
|
||||
#ifndef DICT_NODEBUG
|
||||
int dict_verify(dict_t *dict)
|
||||
{
|
||||
#ifndef NDEBUG
|
||||
dnode_t *nil = dict_nil(dict), *root = dict_root(dict);
|
||||
|
||||
/* check that the sentinel node and root node are black */
|
||||
|
|
@ -415,15 +420,15 @@ int dict_verify(dict_t *dict)
|
|||
return 0;
|
||||
if (verify_node_count(nil, root) != dict_count(dict))
|
||||
return 0;
|
||||
#endif
|
||||
return 1;
|
||||
}
|
||||
#endif /* DICT_NODEBUG */
|
||||
|
||||
#ifdef E2FSCK_NOTUSED
|
||||
/*
|
||||
* Determine whether two dictionaries are similar: have the same comparison and
|
||||
* allocator functions, and same status as to whether duplicates are allowed.
|
||||
*/
|
||||
|
||||
int dict_similar(const dict_t *left, const dict_t *right)
|
||||
{
|
||||
if (left->compare != right->compare)
|
||||
|
|
@ -567,9 +572,9 @@ void dict_insert(dict_t *dict, dnode_t *node, const void *key)
|
|||
|
||||
node->key = key;
|
||||
|
||||
assert (!dict_isfull(dict));
|
||||
assert (!dict_contains(dict, node));
|
||||
assert (!dnode_is_in_a_dict(node));
|
||||
dict_assert (!dict_isfull(dict));
|
||||
dict_assert (!dict_contains(dict, node));
|
||||
dict_assert (!dnode_is_in_a_dict(node));
|
||||
|
||||
/* basic binary tree insert */
|
||||
|
||||
|
|
@ -577,14 +582,14 @@ void dict_insert(dict_t *dict, dnode_t *node, const void *key)
|
|||
parent = where;
|
||||
result = dict->compare(key, where->key);
|
||||
/* 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)
|
||||
where = where->left;
|
||||
else
|
||||
where = where->right;
|
||||
}
|
||||
|
||||
assert (where == nil);
|
||||
dict_assert (where == nil);
|
||||
|
||||
if (result < 0)
|
||||
parent->left = node;
|
||||
|
|
@ -615,7 +620,7 @@ void dict_insert(dict_t *dict, dnode_t *node, const void *key)
|
|||
if (node == parent->right) {
|
||||
rotate_left(parent);
|
||||
parent = node;
|
||||
assert (grandpa == parent->parent);
|
||||
dict_assert (grandpa == parent->parent);
|
||||
/* rotation between parent and child preserves grandpa */
|
||||
}
|
||||
parent->color = dnode_black;
|
||||
|
|
@ -635,7 +640,7 @@ void dict_insert(dict_t *dict, dnode_t *node, const void *key)
|
|||
if (node == parent->left) {
|
||||
rotate_right(parent);
|
||||
parent = node;
|
||||
assert (grandpa == parent->parent);
|
||||
dict_assert (grandpa == parent->parent);
|
||||
}
|
||||
parent->color = dnode_black;
|
||||
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;
|
||||
|
||||
assert (dict_verify(dict));
|
||||
dict_assert (dict_verify(dict));
|
||||
}
|
||||
|
||||
#ifdef E2FSCK_NOTUSED
|
||||
|
|
@ -663,8 +668,8 @@ dnode_t *dict_delete(dict_t *dict, dnode_t *delete)
|
|||
|
||||
/* basic deletion */
|
||||
|
||||
assert (!dict_isempty(dict));
|
||||
assert (dict_contains(dict, delete));
|
||||
dict_assert (!dict_isempty(dict));
|
||||
dict_assert (dict_contains(dict, delete));
|
||||
|
||||
/*
|
||||
* 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_color_t nextcolor = next->color;
|
||||
|
||||
assert (next != nil);
|
||||
assert (next->parent != nil);
|
||||
assert (next->left == nil);
|
||||
dict_assert (next != nil);
|
||||
dict_assert (next->parent != nil);
|
||||
dict_assert (next->left == nil);
|
||||
|
||||
/*
|
||||
* 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) {
|
||||
nextparent->left = child;
|
||||
} else {
|
||||
assert (nextparent->right == next);
|
||||
dict_assert (nextparent->right == next);
|
||||
nextparent->right = child;
|
||||
}
|
||||
|
||||
|
|
@ -718,13 +723,13 @@ dnode_t *dict_delete(dict_t *dict, dnode_t *delete)
|
|||
if (delparent->left == delete) {
|
||||
delparent->left = next;
|
||||
} else {
|
||||
assert (delparent->right == delete);
|
||||
dict_assert (delparent->right == delete);
|
||||
delparent->right = next;
|
||||
}
|
||||
|
||||
} else {
|
||||
assert (delete != nil);
|
||||
assert (delete->left == nil || delete->right == nil);
|
||||
dict_assert (delete != nil);
|
||||
dict_assert (delete->left == nil || delete->right == nil);
|
||||
|
||||
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) {
|
||||
delparent->left = child;
|
||||
} else {
|
||||
assert (delete == delparent->right);
|
||||
dict_assert (delete == delparent->right);
|
||||
delparent->right = child;
|
||||
}
|
||||
}
|
||||
|
|
@ -744,7 +749,7 @@ dnode_t *dict_delete(dict_t *dict, dnode_t *delete)
|
|||
|
||||
dict->nodecount--;
|
||||
|
||||
assert (verify_bintree(dict));
|
||||
dict_assert (verify_bintree(dict));
|
||||
|
||||
/* red-black adjustments */
|
||||
|
||||
|
|
@ -757,13 +762,13 @@ dnode_t *dict_delete(dict_t *dict, dnode_t *delete)
|
|||
parent = child->parent;
|
||||
if (child == parent->left) {
|
||||
sister = parent->right;
|
||||
assert (sister != nil);
|
||||
dict_assert (sister != nil);
|
||||
if (sister->color == dnode_red) {
|
||||
sister->color = dnode_black;
|
||||
parent->color = dnode_red;
|
||||
rotate_left(parent);
|
||||
sister = parent->right;
|
||||
assert (sister != nil);
|
||||
dict_assert (sister != nil);
|
||||
}
|
||||
if (sister->left->color == dnode_black
|
||||
&& sister->right->color == dnode_black) {
|
||||
|
|
@ -771,12 +776,12 @@ dnode_t *dict_delete(dict_t *dict, dnode_t *delete)
|
|||
child = parent;
|
||||
} else {
|
||||
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->color = dnode_red;
|
||||
rotate_right(sister);
|
||||
sister = parent->right;
|
||||
assert (sister != nil);
|
||||
dict_assert (sister != nil);
|
||||
}
|
||||
sister->color = parent->color;
|
||||
sister->right->color = dnode_black;
|
||||
|
|
@ -785,15 +790,15 @@ dnode_t *dict_delete(dict_t *dict, dnode_t *delete)
|
|||
break;
|
||||
}
|
||||
} else { /* symmetric case: child == child->parent->right */
|
||||
assert (child == parent->right);
|
||||
dict_assert (child == parent->right);
|
||||
sister = parent->left;
|
||||
assert (sister != nil);
|
||||
dict_assert (sister != nil);
|
||||
if (sister->color == dnode_red) {
|
||||
sister->color = dnode_black;
|
||||
parent->color = dnode_red;
|
||||
rotate_right(parent);
|
||||
sister = parent->left;
|
||||
assert (sister != nil);
|
||||
dict_assert (sister != nil);
|
||||
}
|
||||
if (sister->right->color == dnode_black
|
||||
&& sister->left->color == dnode_black) {
|
||||
|
|
@ -801,12 +806,12 @@ dnode_t *dict_delete(dict_t *dict, dnode_t *delete)
|
|||
child = parent;
|
||||
} else {
|
||||
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->color = dnode_red;
|
||||
rotate_left(sister);
|
||||
sister = parent->left;
|
||||
assert (sister != nil);
|
||||
dict_assert (sister != nil);
|
||||
}
|
||||
sister->color = parent->color;
|
||||
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;
|
||||
}
|
||||
|
||||
assert (dict_verify(dict));
|
||||
dict_assert (dict_verify(dict));
|
||||
|
||||
return delete;
|
||||
}
|
||||
|
|
@ -1003,7 +1008,7 @@ dnode_t *dnode_init(dnode_t *dnode, void *data)
|
|||
|
||||
void dnode_destroy(dnode_t *dnode)
|
||||
{
|
||||
assert (!dnode_is_in_a_dict(dnode));
|
||||
dict_assert (!dnode_is_in_a_dict(dnode));
|
||||
free(dnode);
|
||||
}
|
||||
|
||||
|
|
@ -1022,12 +1027,16 @@ void dnode_put(dnode_t *dnode, void *data)
|
|||
{
|
||||
dnode->data = data;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef DICT_NODEBUG
|
||||
int dnode_is_in_a_dict(dnode_t *dnode)
|
||||
{
|
||||
return (dnode->parent && dnode->left && dnode->right);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef E2FSCK_NOTUSED
|
||||
void dict_process(dict_t *dict, void *context, dnode_process_t function)
|
||||
{
|
||||
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) {
|
||||
/* check for callback function deleting */
|
||||
/* the next node from under us */
|
||||
assert (dict_contains(dict, node));
|
||||
dict_assert (dict_contains(dict, node));
|
||||
next = dict_next(dict, node);
|
||||
function(dict, node, context);
|
||||
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)
|
||||
{
|
||||
assert (dict_isempty(dict));
|
||||
dict_assert (dict_isempty(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;
|
||||
dnode_t *nil = &load->nilnode;
|
||||
|
||||
assert (!dnode_is_in_a_dict(newnode));
|
||||
assert (dict->nodecount < dict->maxcount);
|
||||
dict_assert (!dnode_is_in_a_dict(newnode));
|
||||
dict_assert (dict->nodecount < dict->maxcount);
|
||||
|
||||
#ifndef NDEBUG
|
||||
#ifndef DICT_NODEBUG
|
||||
if (dict->nodecount > 0) {
|
||||
if (dict->dupes)
|
||||
assert (dict->compare(nil->left->key, key) <= 0);
|
||||
dict_assert (dict->compare(nil->left->key, key) <= 0);
|
||||
else
|
||||
assert (dict->compare(nil->left->key, key) < 0);
|
||||
dict_assert (dict->compare(nil->left->key, key) < 0);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
@ -1089,7 +1098,7 @@ void dict_load_end(dict_load_t *load)
|
|||
dictcount_t botrowcount;
|
||||
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)
|
||||
fullcount >>= 1;
|
||||
|
|
@ -1100,8 +1109,8 @@ void dict_load_end(dict_load_t *load)
|
|||
next = curr->left;
|
||||
|
||||
if (complete == NULL && botrowcount-- == 0) {
|
||||
assert (baselevel == 0);
|
||||
assert (level == 0);
|
||||
dict_assert (baselevel == 0);
|
||||
dict_assert (level == 0);
|
||||
baselevel = level = 1;
|
||||
complete = tree[0];
|
||||
|
||||
|
|
@ -1123,7 +1132,7 @@ void dict_load_end(dict_load_t *load)
|
|||
curr->color = level % 2;
|
||||
complete = curr;
|
||||
|
||||
assert (level == baselevel);
|
||||
dict_assert (level == baselevel);
|
||||
while (tree[level] != 0) {
|
||||
tree[level]->right = complete;
|
||||
complete->parent = tree[level];
|
||||
|
|
@ -1157,7 +1166,7 @@ void dict_load_end(dict_load_t *load)
|
|||
complete->color = dnode_black;
|
||||
dict_root(dict) = complete;
|
||||
|
||||
assert (dict_verify(dict));
|
||||
dict_assert (dict_verify(dict));
|
||||
}
|
||||
|
||||
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;
|
||||
dnode_t *leftnode = dict_first(dest), *rightnode = dict_first(source);
|
||||
|
||||
assert (dict_similar(dest, source));
|
||||
dict_assert (dict_similar(dest, source));
|
||||
|
||||
if (source == dest)
|
||||
return;
|
||||
|
|
@ -1184,14 +1193,14 @@ void dict_merge(dict_t *dest, dict_t *source)
|
|||
} else if (rightnode != NULL) {
|
||||
goto copyright;
|
||||
} else {
|
||||
assert (leftnode == NULL && rightnode == NULL);
|
||||
dict_assert (leftnode == NULL && rightnode == NULL);
|
||||
break;
|
||||
}
|
||||
|
||||
copyleft:
|
||||
{
|
||||
dnode_t *next = dict_next(dest, leftnode);
|
||||
#ifndef NDEBUG
|
||||
#ifndef DICT_NODEBUG
|
||||
leftnode->left = NULL; /* suppress assertion in dict_load_next */
|
||||
#endif
|
||||
dict_load_next(&load, leftnode, leftnode->key);
|
||||
|
|
@ -1202,7 +1211,7 @@ void dict_merge(dict_t *dest, dict_t *source)
|
|||
copyright:
|
||||
{
|
||||
dnode_t *next = dict_next(source, rightnode);
|
||||
#ifndef NDEBUG
|
||||
#ifndef DICT_NODEBUG
|
||||
rightnode->left = NULL;
|
||||
#endif
|
||||
dict_load_next(&load, rightnode, rightnode->key);
|
||||
|
|
|
|||
Loading…
Reference in New Issue