From ba713c9b370261cd6263986cd9c5df29192906f3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=B3zef=20Kucia?= Date: Fri, 16 Jun 2017 22:38:21 +0200 Subject: [PATCH] include: Drop wine prefix from red-black tree functions. --- include/private/rbtree.h | 208 +++++++++++++++++++-------------------- 1 file changed, 104 insertions(+), 104 deletions(-) diff --git a/include/private/rbtree.h b/include/private/rbtree.h index 65d9a903..4c18f9cb 100644 --- a/include/private/rbtree.h +++ b/include/private/rbtree.h @@ -23,37 +23,37 @@ #ifndef __WINE_WINE_RBTREE_H #define __WINE_WINE_RBTREE_H -#define WINE_RB_ENTRY_VALUE(element, type, field) \ +#define RB_ENTRY_VALUE(element, type, field) \ ((type *)((char *)(element) - offsetof(type, field))) -struct wine_rb_entry +struct rb_entry { - struct wine_rb_entry *parent; - struct wine_rb_entry *left; - struct wine_rb_entry *right; + struct rb_entry *parent; + struct rb_entry *left; + struct rb_entry *right; unsigned int flags; }; -typedef int (*wine_rb_compare_func_t)(const void *key, const struct wine_rb_entry *entry); +typedef int (*rb_compare_func_t)(const void *key, const struct rb_entry *entry); -struct wine_rb_tree +struct rb_tree { - wine_rb_compare_func_t compare; - struct wine_rb_entry *root; + rb_compare_func_t compare; + struct rb_entry *root; }; -typedef void (wine_rb_traverse_func_t)(struct wine_rb_entry *entry, void *context); +typedef void (rb_traverse_func_t)(struct rb_entry *entry, void *context); -#define WINE_RB_FLAG_RED 0x1 +#define RB_FLAG_RED 0x1 -static inline int wine_rb_is_red(struct wine_rb_entry *entry) +static inline int rb_is_red(struct rb_entry *entry) { - return entry && (entry->flags & WINE_RB_FLAG_RED); + return entry && (entry->flags & RB_FLAG_RED); } -static inline void wine_rb_rotate_left(struct wine_rb_tree *tree, struct wine_rb_entry *e) +static inline void rb_rotate_left(struct rb_tree *tree, struct rb_entry *e) { - struct wine_rb_entry *right = e->right; + struct rb_entry *right = e->right; if (!e->parent) tree->root = right; @@ -69,9 +69,9 @@ static inline void wine_rb_rotate_left(struct wine_rb_tree *tree, struct wine_rb e->parent = right; } -static inline void wine_rb_rotate_right(struct wine_rb_tree *tree, struct wine_rb_entry *e) +static inline void rb_rotate_right(struct rb_tree *tree, struct rb_entry *e) { - struct wine_rb_entry *left = e->left; + struct rb_entry *left = e->left; if (!e->parent) tree->root = left; @@ -87,28 +87,28 @@ static inline void wine_rb_rotate_right(struct wine_rb_tree *tree, struct wine_r e->parent = left; } -static inline void wine_rb_flip_color(struct wine_rb_entry *entry) +static inline void rb_flip_color(struct rb_entry *entry) { - entry->flags ^= WINE_RB_FLAG_RED; - entry->left->flags ^= WINE_RB_FLAG_RED; - entry->right->flags ^= WINE_RB_FLAG_RED; + entry->flags ^= RB_FLAG_RED; + entry->left->flags ^= RB_FLAG_RED; + entry->right->flags ^= RB_FLAG_RED; } -static inline struct wine_rb_entry *wine_rb_head(struct wine_rb_entry *iter) +static inline struct rb_entry *rb_head(struct rb_entry *iter) { if (!iter) return NULL; while (iter->left) iter = iter->left; return iter; } -static inline struct wine_rb_entry *wine_rb_next(struct wine_rb_entry *iter) +static inline struct rb_entry *rb_next(struct rb_entry *iter) { - if (iter->right) return wine_rb_head(iter->right); + if (iter->right) return rb_head(iter->right); while (iter->parent && iter->parent->right == iter) iter = iter->parent; return iter->parent; } -static inline struct wine_rb_entry *wine_rb_postorder_head(struct wine_rb_entry *iter) +static inline struct rb_entry *rb_postorder_head(struct rb_entry *iter) { if (!iter) return NULL; @@ -119,70 +119,70 @@ static inline struct wine_rb_entry *wine_rb_postorder_head(struct wine_rb_entry } } -static inline struct wine_rb_entry *wine_rb_postorder_next(struct wine_rb_entry *iter) +static inline struct rb_entry *rb_postorder_next(struct rb_entry *iter) { if (!iter->parent) return NULL; if (iter == iter->parent->right || !iter->parent->right) return iter->parent; - return wine_rb_postorder_head(iter->parent->right); + return rb_postorder_head(iter->parent->right); } /* iterate through the tree */ -#define WINE_RB_FOR_EACH(cursor, tree) \ - for ((cursor) = wine_rb_head((tree)->root); (cursor); (cursor) = wine_rb_next(cursor)) +#define rb_FOR_EACH(cursor, tree) \ + for ((cursor) = rb_head((tree)->root); (cursor); (cursor) = rb_next(cursor)) /* iterate through the tree using a tree entry */ -#define WINE_RB_FOR_EACH_ENTRY(elem, tree, type, field) \ - for ((elem) = WINE_RB_ENTRY_VALUE(wine_rb_head((tree)->root), type, field); \ +#define rb_FOR_EACH_ENTRY(elem, tree, type, field) \ + for ((elem) = rb_ENTRY_VALUE(rb_head((tree)->root), type, field); \ &(elem)->field; \ - (elem) = WINE_RB_ENTRY_VALUE(wine_rb_next(&elem->field), type, field)) + (elem) = rb_ENTRY_VALUE(rb_next(&elem->field), type, field)) /* iterate through the tree using using postorder, making it safe to free the entry */ -#define WINE_RB_FOR_EACH_DESTRUCTOR(cursor, cursor2, tree) \ - for ((cursor) = wine_rb_postorder_head((tree)->root); \ - (cursor) && (((cursor2) = wine_rb_postorder_next(cursor)) || 1); \ +#define rb_FOR_EACH_DESTRUCTOR(cursor, cursor2, tree) \ + for ((cursor) = rb_postorder_head((tree)->root); \ + (cursor) && (((cursor2) = rb_postorder_next(cursor)) || 1); \ (cursor) = (cursor2)) /* iterate through the tree using a tree entry and postorder, making it safe to free the entry */ -#define WINE_RB_FOR_EACH_ENTRY_DESTRUCTOR(elem, elem2, tree, type, field) \ - for ((elem) = WINE_RB_ENTRY_VALUE(wine_rb_postorder_head((tree)->root), type, field); \ +#define rb_FOR_EACH_ENTRY_DESTRUCTOR(elem, elem2, tree, type, field) \ + for ((elem) = rb_ENTRY_VALUE(rb_postorder_head((tree)->root), type, field); \ &(elem)->field \ - && (((elem2) = WINE_RB_ENTRY_VALUE(wine_rb_postorder_next(&(elem)->field), type, field)) || 1); \ + && (((elem2) = rb_ENTRY_VALUE(rb_postorder_next(&(elem)->field), type, field)) || 1); \ (elem) = (elem2)) -static inline void wine_rb_postorder(struct wine_rb_tree *tree, wine_rb_traverse_func_t *callback, void *context) +static inline void rb_postorder(struct rb_tree *tree, rb_traverse_func_t *callback, void *context) { - struct wine_rb_entry *iter, *next; - WINE_RB_FOR_EACH_DESTRUCTOR(iter, next, tree) callback(iter, context); + struct rb_entry *iter, *next; + rb_FOR_EACH_DESTRUCTOR(iter, next, tree) callback(iter, context); } -static inline void wine_rb_init(struct wine_rb_tree *tree, wine_rb_compare_func_t compare) +static inline void rb_init(struct rb_tree *tree, rb_compare_func_t compare) { tree->compare = compare; tree->root = NULL; } -static inline void wine_rb_for_each_entry(struct wine_rb_tree *tree, wine_rb_traverse_func_t *callback, void *context) +static inline void rb_for_each_entry(struct rb_tree *tree, rb_traverse_func_t *callback, void *context) { - struct wine_rb_entry *iter; - WINE_RB_FOR_EACH(iter, tree) callback(iter, context); + struct rb_entry *iter; + rb_FOR_EACH(iter, tree) callback(iter, context); } -static inline void wine_rb_clear(struct wine_rb_tree *tree, wine_rb_traverse_func_t *callback, void *context) +static inline void rb_clear(struct rb_tree *tree, rb_traverse_func_t *callback, void *context) { /* Note that we use postorder here because the callback will likely free the entry. */ - if (callback) wine_rb_postorder(tree, callback, context); + if (callback) rb_postorder(tree, callback, context); tree->root = NULL; } -static inline void wine_rb_destroy(struct wine_rb_tree *tree, wine_rb_traverse_func_t *callback, void *context) +static inline void rb_destroy(struct rb_tree *tree, rb_traverse_func_t *callback, void *context) { - wine_rb_clear(tree, callback, context); + rb_clear(tree, callback, context); } -static inline struct wine_rb_entry *wine_rb_get(const struct wine_rb_tree *tree, const void *key) +static inline struct rb_entry *rb_get(const struct rb_tree *tree, const void *key) { - struct wine_rb_entry *entry = tree->root; + struct rb_entry *entry = tree->root; while (entry) { int c = tree->compare(key, entry); @@ -192,9 +192,9 @@ static inline struct wine_rb_entry *wine_rb_get(const struct wine_rb_tree *tree, return NULL; } -static inline int wine_rb_put(struct wine_rb_tree *tree, const void *key, struct wine_rb_entry *entry) +static inline int rb_put(struct rb_tree *tree, const void *key, struct rb_entry *entry) { - struct wine_rb_entry **iter = &tree->root, *parent = tree->root; + struct rb_entry **iter = &tree->root, *parent = tree->root; while (*iter) { @@ -207,19 +207,19 @@ static inline int wine_rb_put(struct wine_rb_tree *tree, const void *key, struct else iter = &parent->right; } - entry->flags = WINE_RB_FLAG_RED; + entry->flags = RB_FLAG_RED; entry->parent = parent; entry->left = NULL; entry->right = NULL; *iter = entry; - while (wine_rb_is_red(entry->parent)) + while (rb_is_red(entry->parent)) { if (entry->parent == entry->parent->parent->left) { - if (wine_rb_is_red(entry->parent->parent->right)) + if (rb_is_red(entry->parent->parent->right)) { - wine_rb_flip_color(entry->parent->parent); + rb_flip_color(entry->parent->parent); entry = entry->parent->parent; } else @@ -227,18 +227,18 @@ static inline int wine_rb_put(struct wine_rb_tree *tree, const void *key, struct if (entry == entry->parent->right) { entry = entry->parent; - wine_rb_rotate_left(tree, entry); + rb_rotate_left(tree, entry); } - entry->parent->flags &= ~WINE_RB_FLAG_RED; - entry->parent->parent->flags |= WINE_RB_FLAG_RED; - wine_rb_rotate_right(tree, entry->parent->parent); + entry->parent->flags &= ~RB_FLAG_RED; + entry->parent->parent->flags |= RB_FLAG_RED; + rb_rotate_right(tree, entry->parent->parent); } } else { - if (wine_rb_is_red(entry->parent->parent->left)) + if (rb_is_red(entry->parent->parent->left)) { - wine_rb_flip_color(entry->parent->parent); + rb_flip_color(entry->parent->parent); entry = entry->parent->parent; } else @@ -246,23 +246,23 @@ static inline int wine_rb_put(struct wine_rb_tree *tree, const void *key, struct if (entry == entry->parent->left) { entry = entry->parent; - wine_rb_rotate_right(tree, entry); + rb_rotate_right(tree, entry); } - entry->parent->flags &= ~WINE_RB_FLAG_RED; - entry->parent->parent->flags |= WINE_RB_FLAG_RED; - wine_rb_rotate_left(tree, entry->parent->parent); + entry->parent->flags &= ~RB_FLAG_RED; + entry->parent->parent->flags |= RB_FLAG_RED; + rb_rotate_left(tree, entry->parent->parent); } } } - tree->root->flags &= ~WINE_RB_FLAG_RED; + tree->root->flags &= ~RB_FLAG_RED; return 0; } -static inline void wine_rb_remove(struct wine_rb_tree *tree, struct wine_rb_entry *entry) +static inline void rb_remove(struct rb_tree *tree, struct rb_entry *entry) { - struct wine_rb_entry *iter, *child, *parent, *w; + struct rb_entry *iter, *child, *parent, *w; int need_fixup; if (entry->right && entry->left) @@ -282,7 +282,7 @@ static inline void wine_rb_remove(struct wine_rb_tree *tree, struct wine_rb_entr if (child) child->parent = iter->parent; parent = iter->parent; - need_fixup = !wine_rb_is_red(iter); + need_fixup = !rb_is_red(iter); if (entry != iter) { @@ -301,32 +301,32 @@ static inline void wine_rb_remove(struct wine_rb_tree *tree, struct wine_rb_entr if (need_fixup) { - while (parent && !wine_rb_is_red(child)) + while (parent && !rb_is_red(child)) { if (child == parent->left) { w = parent->right; - if (wine_rb_is_red(w)) + if (rb_is_red(w)) { - w->flags &= ~WINE_RB_FLAG_RED; - parent->flags |= WINE_RB_FLAG_RED; - wine_rb_rotate_left(tree, parent); + w->flags &= ~RB_FLAG_RED; + parent->flags |= RB_FLAG_RED; + rb_rotate_left(tree, parent); w = parent->right; } - if (wine_rb_is_red(w->left) || wine_rb_is_red(w->right)) + if (rb_is_red(w->left) || rb_is_red(w->right)) { - if (!wine_rb_is_red(w->right)) + if (!rb_is_red(w->right)) { - w->left->flags &= ~WINE_RB_FLAG_RED; - w->flags |= WINE_RB_FLAG_RED; - wine_rb_rotate_right(tree, w); + w->left->flags &= ~RB_FLAG_RED; + w->flags |= RB_FLAG_RED; + rb_rotate_right(tree, w); w = parent->right; } - w->flags = (w->flags & ~WINE_RB_FLAG_RED) | (parent->flags & WINE_RB_FLAG_RED); - parent->flags &= ~WINE_RB_FLAG_RED; + w->flags = (w->flags & ~RB_FLAG_RED) | (parent->flags & RB_FLAG_RED); + parent->flags &= ~RB_FLAG_RED; if (w->right) - w->right->flags &= ~WINE_RB_FLAG_RED; - wine_rb_rotate_left(tree, parent); + w->right->flags &= ~RB_FLAG_RED; + rb_rotate_left(tree, parent); child = NULL; break; } @@ -334,45 +334,45 @@ static inline void wine_rb_remove(struct wine_rb_tree *tree, struct wine_rb_entr else { w = parent->left; - if (wine_rb_is_red(w)) + if (rb_is_red(w)) { - w->flags &= ~WINE_RB_FLAG_RED; - parent->flags |= WINE_RB_FLAG_RED; - wine_rb_rotate_right(tree, parent); + w->flags &= ~RB_FLAG_RED; + parent->flags |= RB_FLAG_RED; + rb_rotate_right(tree, parent); w = parent->left; } - if (wine_rb_is_red(w->left) || wine_rb_is_red(w->right)) + if (rb_is_red(w->left) || rb_is_red(w->right)) { - if (!wine_rb_is_red(w->left)) + if (!rb_is_red(w->left)) { - w->right->flags &= ~WINE_RB_FLAG_RED; - w->flags |= WINE_RB_FLAG_RED; - wine_rb_rotate_left(tree, w); + w->right->flags &= ~RB_FLAG_RED; + w->flags |= RB_FLAG_RED; + rb_rotate_left(tree, w); w = parent->left; } - w->flags = (w->flags & ~WINE_RB_FLAG_RED) | (parent->flags & WINE_RB_FLAG_RED); - parent->flags &= ~WINE_RB_FLAG_RED; + w->flags = (w->flags & ~RB_FLAG_RED) | (parent->flags & RB_FLAG_RED); + parent->flags &= ~RB_FLAG_RED; if (w->left) - w->left->flags &= ~WINE_RB_FLAG_RED; - wine_rb_rotate_right(tree, parent); + w->left->flags &= ~RB_FLAG_RED; + rb_rotate_right(tree, parent); child = NULL; break; } } - w->flags |= WINE_RB_FLAG_RED; + w->flags |= RB_FLAG_RED; child = parent; parent = child->parent; } - if (child) child->flags &= ~WINE_RB_FLAG_RED; + if (child) child->flags &= ~RB_FLAG_RED; } - if (tree->root) tree->root->flags &= ~WINE_RB_FLAG_RED; + if (tree->root) tree->root->flags &= ~RB_FLAG_RED; } -static inline void wine_rb_remove_key(struct wine_rb_tree *tree, const void *key) +static inline void rb_remove_key(struct rb_tree *tree, const void *key) { - struct wine_rb_entry *entry = wine_rb_get(tree, key); - if (entry) wine_rb_remove(tree, entry); + struct rb_entry *entry = rb_get(tree, key); + if (entry) rb_remove(tree, entry); } #endif /* __WINE_WINE_RBTREE_H */