wine/vkd3d
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/vkd3d.git synced 2025-09-12 18:50:22 -07:00
Code Issues Packages Projects Releases Wiki Activity

include: Drop wine prefix from red-black tree functions.

Browse Source
This commit is contained in:
Józef Kucia
2017-06-16 22:38:21 +02:00
parent 69e278e754
commit ba713c9b37
1 changed files with 104 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files

208
include/private/rbtree.h
View File

@@ -23,37 +23,37 @@
#ifndef __WINE_WINE_RBTREE_H #ifndef __WINE_WINE_RBTREE_H
#define __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))) ((type *)((char *)(element) - offsetof(type, field)))
struct wine_rb_entry struct rb_entry
{ {
struct wine_rb_entry *parent; struct rb_entry *parent;
struct wine_rb_entry *left; struct rb_entry *left;
struct wine_rb_entry *right; struct rb_entry *right;
unsigned int flags; 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; rb_compare_func_t compare;
struct wine_rb_entry *root; 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) if (!e->parent)
tree->root = right; 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; 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) if (!e->parent)
tree->root = left; 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; 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->flags ^= RB_FLAG_RED;
entry->left->flags ^= WINE_RB_FLAG_RED; entry->left->flags ^= RB_FLAG_RED;
entry->right->flags ^= WINE_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; if (!iter) return NULL;
while (iter->left) iter = iter->left; while (iter->left) iter = iter->left;
return iter; 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; while (iter->parent && iter->parent->right == iter) iter = iter->parent;
return 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; 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->parent) return NULL;
if (iter == iter->parent->right || !iter->parent->right) return iter->parent; 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 */ /* iterate through the tree */
#define WINE_RB_FOR_EACH(cursor, tree) \ #define rb_FOR_EACH(cursor, tree) \
for ((cursor) = wine_rb_head((tree)->root); (cursor); (cursor) = wine_rb_next(cursor)) for ((cursor) = rb_head((tree)->root); (cursor); (cursor) = rb_next(cursor))
/* iterate through the tree using a tree entry */ /* iterate through the tree using a tree entry */
#define WINE_RB_FOR_EACH_ENTRY(elem, tree, type, field) \ #define rb_FOR_EACH_ENTRY(elem, tree, type, field) \
for ((elem) = WINE_RB_ENTRY_VALUE(wine_rb_head((tree)->root), type, field); \ for ((elem) = rb_ENTRY_VALUE(rb_head((tree)->root), type, field); \
&(elem)->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 */ /* iterate through the tree using using postorder, making it safe to free the entry */
#define WINE_RB_FOR_EACH_DESTRUCTOR(cursor, cursor2, tree) \ #define rb_FOR_EACH_DESTRUCTOR(cursor, cursor2, tree) \
for ((cursor) = wine_rb_postorder_head((tree)->root); \ for ((cursor) = rb_postorder_head((tree)->root); \
(cursor) && (((cursor2) = wine_rb_postorder_next(cursor)) || 1); \ (cursor) && (((cursor2) = rb_postorder_next(cursor)) || 1); \
(cursor) = (cursor2)) (cursor) = (cursor2))
/* iterate through the tree using a tree entry and postorder, making it safe to free the entry */ /* 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) \ #define rb_FOR_EACH_ENTRY_DESTRUCTOR(elem, elem2, tree, type, field) \
for ((elem) = WINE_RB_ENTRY_VALUE(wine_rb_postorder_head((tree)->root), type, field); \ for ((elem) = rb_ENTRY_VALUE(rb_postorder_head((tree)->root), type, field); \
&(elem)->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)) (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; struct rb_entry *iter, *next;
WINE_RB_FOR_EACH_DESTRUCTOR(iter, next, tree) callback(iter, context); 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->compare = compare;
tree->root = NULL; 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; struct rb_entry *iter;
WINE_RB_FOR_EACH(iter, tree) callback(iter, context); 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. */ /* 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; 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) while (entry)
{ {
int c = tree->compare(key, 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; 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) 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; else iter = &parent->right;
} }
entry->flags = WINE_RB_FLAG_RED; entry->flags = RB_FLAG_RED;
entry->parent = parent; entry->parent = parent;
entry->left = NULL; entry->left = NULL;
entry->right = NULL; entry->right = NULL;
*iter = entry; *iter = entry;
while (wine_rb_is_red(entry->parent)) while (rb_is_red(entry->parent))
{ {
if (entry->parent == entry->parent->parent->left) 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; entry = entry->parent->parent;
} }
else 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) if (entry == entry->parent->right)
{ {
entry = entry->parent; entry = entry->parent;
wine_rb_rotate_left(tree, entry); rb_rotate_left(tree, entry);
} }
entry->parent->flags &= ~WINE_RB_FLAG_RED; entry->parent->flags &= ~RB_FLAG_RED;
entry->parent->parent->flags |= WINE_RB_FLAG_RED; entry->parent->parent->flags |= RB_FLAG_RED;
wine_rb_rotate_right(tree, entry->parent->parent); rb_rotate_right(tree, entry->parent->parent);
} }
} }
else 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; entry = entry->parent->parent;
} }
else 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) if (entry == entry->parent->left)
{ {
entry = entry->parent; entry = entry->parent;
wine_rb_rotate_right(tree, entry); rb_rotate_right(tree, entry);
} }
entry->parent->flags &= ~WINE_RB_FLAG_RED; entry->parent->flags &= ~RB_FLAG_RED;
entry->parent->parent->flags |= WINE_RB_FLAG_RED; entry->parent->parent->flags |= RB_FLAG_RED;
wine_rb_rotate_left(tree, entry->parent->parent); rb_rotate_left(tree, entry->parent->parent);
} }
} }
} }
tree->root->flags &= ~WINE_RB_FLAG_RED; tree->root->flags &= ~RB_FLAG_RED;
return 0; 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; int need_fixup;
if (entry->right && entry->left) 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; if (child) child->parent = iter->parent;
parent = iter->parent; parent = iter->parent;
need_fixup = !wine_rb_is_red(iter); need_fixup = !rb_is_red(iter);
if (entry != 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) if (need_fixup)
{ {
while (parent && !wine_rb_is_red(child)) while (parent && !rb_is_red(child))
{ {
if (child == parent->left) if (child == parent->left)
{ {
w = parent->right; w = parent->right;
if (wine_rb_is_red(w)) if (rb_is_red(w))
{ {
w->flags &= ~WINE_RB_FLAG_RED; w->flags &= ~RB_FLAG_RED;
parent->flags |= WINE_RB_FLAG_RED; parent->flags |= RB_FLAG_RED;
wine_rb_rotate_left(tree, parent); rb_rotate_left(tree, parent);
w = parent->right; 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->left->flags &= ~RB_FLAG_RED;
w->flags |= WINE_RB_FLAG_RED; w->flags |= RB_FLAG_RED;
wine_rb_rotate_right(tree, w); rb_rotate_right(tree, w);
w = parent->right; w = parent->right;
} }
w->flags = (w->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 &= ~WINE_RB_FLAG_RED; parent->flags &= ~RB_FLAG_RED;
if (w->right) if (w->right)
w->right->flags &= ~WINE_RB_FLAG_RED; w->right->flags &= ~RB_FLAG_RED;
wine_rb_rotate_left(tree, parent); rb_rotate_left(tree, parent);
child = NULL; child = NULL;
break; break;
} }
@@ -334,45 +334,45 @@ static inline void wine_rb_remove(struct wine_rb_tree *tree, struct wine_rb_entr
else else
{ {
w = parent->left; w = parent->left;
if (wine_rb_is_red(w)) if (rb_is_red(w))
{ {
w->flags &= ~WINE_RB_FLAG_RED; w->flags &= ~RB_FLAG_RED;
parent->flags |= WINE_RB_FLAG_RED; parent->flags |= RB_FLAG_RED;
wine_rb_rotate_right(tree, parent); rb_rotate_right(tree, parent);
w = parent->left; 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->right->flags &= ~RB_FLAG_RED;
w->flags |= WINE_RB_FLAG_RED; w->flags |= RB_FLAG_RED;
wine_rb_rotate_left(tree, w); rb_rotate_left(tree, w);
w = parent->left; w = parent->left;
} }
w->flags = (w->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 &= ~WINE_RB_FLAG_RED; parent->flags &= ~RB_FLAG_RED;
if (w->left) if (w->left)
w->left->flags &= ~WINE_RB_FLAG_RED; w->left->flags &= ~RB_FLAG_RED;
wine_rb_rotate_right(tree, parent); rb_rotate_right(tree, parent);
child = NULL; child = NULL;
break; break;
} }
} }
w->flags |= WINE_RB_FLAG_RED; w->flags |= RB_FLAG_RED;
child = parent; child = parent;
parent = 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); struct rb_entry *entry = rb_get(tree, key);
if (entry) wine_rb_remove(tree, entry); if (entry) rb_remove(tree, entry);
} }
#endif /* __WINE_WINE_RBTREE_H */ #endif /* __WINE_WINE_RBTREE_H */