rbtree.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	wine_rb_entry
struct	wine_rb_tree

Macros
#define	WINE_RB_ENTRY_VALUE(element, type, field)   ((type *)((char *)(element) - offsetof(type, field)))
#define	WINE_RB_FLAG_RED   0x1
#define	WINE_RB_FOR_EACH(cursor, tree)   for ((cursor) = wine_rb_head((tree)->root); (cursor); (cursor) = wine_rb_next(cursor))
#define	WINE_RB_FOR_EACH_ENTRY(elem, tree, type, field)
#define	WINE_RB_FOR_EACH_DESTRUCTOR(cursor, cursor2, tree)
#define	WINE_RB_FOR_EACH_ENTRY_DESTRUCTOR(elem, elem2, tree, type, field)

Typedefs
typedef int(*	wine_rb_compare_func_t) (const void *key, const struct wine_rb_entry *entry)
typedef void()	wine_rb_traverse_func_t(struct wine_rb_entry *entry, void *context)

Functions
static int	wine_rb_is_red (struct wine_rb_entry *entry)
static void	wine_rb_rotate_left (struct wine_rb_tree *tree, struct wine_rb_entry *e)
static void	wine_rb_rotate_right (struct wine_rb_tree *tree, struct wine_rb_entry *e)
static void	wine_rb_flip_color (struct wine_rb_entry *entry)
static struct wine_rb_entry *	wine_rb_head (struct wine_rb_entry *iter)
static struct wine_rb_entry *	wine_rb_tail (struct wine_rb_entry *iter)
static struct wine_rb_entry *	wine_rb_next (struct wine_rb_entry *iter)
static struct wine_rb_entry *	wine_rb_prev (struct wine_rb_entry *iter)
static struct wine_rb_entry *	wine_rb_postorder_head (struct wine_rb_entry *iter)
static struct wine_rb_entry *	wine_rb_postorder_next (struct wine_rb_entry *iter)
static void	wine_rb_postorder (struct wine_rb_tree *tree, wine_rb_traverse_func_t *callback, void *context)
static void	wine_rb_init (struct wine_rb_tree *tree, wine_rb_compare_func_t compare)
static void	wine_rb_for_each_entry (struct wine_rb_tree *tree, wine_rb_traverse_func_t *callback, void *context)
static void	wine_rb_clear (struct wine_rb_tree *tree, wine_rb_traverse_func_t *callback, void *context)
static void	wine_rb_destroy (struct wine_rb_tree *tree, wine_rb_traverse_func_t *callback, void *context)
static struct wine_rb_entry *	wine_rb_get (const struct wine_rb_tree *tree, const void *key)
static int	wine_rb_put (struct wine_rb_tree *tree, const void *key, struct wine_rb_entry *entry)
static void	wine_rb_remove (struct wine_rb_tree *tree, struct wine_rb_entry *entry)
static void	wine_rb_remove_key (struct wine_rb_tree *tree, const void *key)

Macro Definition Documentation

WINE_RB_ENTRY_VALUE

#define WINE_RB_ENTRY_VALUE	(		element,
			type,
			field
	)		((type *)((char *)(element) - offsetof(type, field)))

Definition at line 31 of file rbtree.h.

WINE_RB_FLAG_RED

#define WINE_RB_FLAG_RED   0x1

Definition at line 53 of file rbtree.h.

WINE_RB_FOR_EACH

#define WINE_RB_FOR_EACH	(		cursor,
			tree
	)		for ((cursor) = wine_rb_head((tree)->root); (cursor); (cursor) = wine_rb_next(cursor))

Definition at line 150 of file rbtree.h.

WINE_RB_FOR_EACH_DESTRUCTOR

#define WINE_RB_FOR_EACH_DESTRUCTOR	(		cursor,
			cursor2,
			tree
	)

Value:

for ((cursor) = wine_rb_postorder_head((tree)->root); \
         (cursor) && (((cursor2) = wine_rb_postorder_next(cursor)) || 1); \
         (cursor) = (cursor2))

Definition at line 160 of file rbtree.h.

WINE_RB_FOR_EACH_ENTRY

#define WINE_RB_FOR_EACH_ENTRY	(		elem,
			tree,
			type,
			field
	)

Value:

for ((elem) = WINE_RB_ENTRY_VALUE(wine_rb_head((tree)->root), type, field); \
         (elem) != WINE_RB_ENTRY_VALUE(0, type, field); \
         (elem) = WINE_RB_ENTRY_VALUE(wine_rb_next(&elem->field), type, field))

Definition at line 154 of file rbtree.h.

WINE_RB_FOR_EACH_ENTRY_DESTRUCTOR

#define WINE_RB_FOR_EACH_ENTRY_DESTRUCTOR	(		elem,
			elem2,
			tree,
			type,
			field
	)

Value:

for ((elem) = WINE_RB_ENTRY_VALUE(wine_rb_postorder_head((tree)->root), type, field); \
         (elem) != WINE_RB_ENTRY_VALUE(0, type, field) \
             && (((elem2) = WINE_RB_ENTRY_VALUE(wine_rb_postorder_next(&(elem)->field), type, field)) || 1); \
         (elem) = (elem2))

Definition at line 166 of file rbtree.h.

Typedef Documentation

wine_rb_compare_func_t

typedef int(* wine_rb_compare_func_t) (const void *key, const struct wine_rb_entry *entry)

Definition at line 43 of file rbtree.h.

wine_rb_traverse_func_t

typedef void() wine_rb_traverse_func_t(struct wine_rb_entry *entry, void *context)

Definition at line 51 of file rbtree.h.

Function Documentation

wine_rb_clear()

static void wine_rb_clear ( struct wine_rb_tree *  tree, wine_rb_traverse_func_t *  callback, void *  context  )

inlinestatic

Definition at line 191 of file rbtree.h.

{
    /* Note that we use postorder here because the callback will likely free the entry. */
    if (callback) wine_rb_postorder(tree, callback, context);
    tree->root = NULL;
}

Referenced by wine_rb_destroy(), wined3d_device_reset(), and wined3d_device_uninit_3d().

wine_rb_destroy()

static void wine_rb_destroy ( struct wine_rb_tree *  tree, wine_rb_traverse_func_t *  callback, void *  context  )

inlinestatic

Definition at line 198 of file rbtree.h.

{
    wine_rb_clear(tree, callback, context);
}

Referenced by add_function_decl(), arbfp_blitter_destroy(), arbfp_free(), atifs_free(), device_init(), free_function(), glsl_blitter_destroy(), glsl_fragment_pipe_free(), glsl_vertex_pipe_vp_free(), parse_hlsl(), reflection_cleanup(), shader_arb_free(), shader_glsl_free(), and wined3d_device_decref().

wine_rb_flip_color()

static void wine_rb_flip_color ( struct wine_rb_entry *  entry )

inlinestatic

Definition at line 96 of file rbtree.h.

{
    entry->flags ^= WINE_RB_FLAG_RED;
    entry->left->flags ^= WINE_RB_FLAG_RED;
    entry->right->flags ^= WINE_RB_FLAG_RED;
}

Referenced by wine_rb_put().

wine_rb_for_each_entry()

static void wine_rb_for_each_entry ( struct wine_rb_tree *  tree, wine_rb_traverse_func_t *  callback, void *  context  )

inlinestatic

Definition at line 185 of file rbtree.h.

{
    struct wine_rb_entry *iter;
    WINE_RB_FOR_EACH(iter, tree) callback(iter, context);
}

Referenced by dump_function(), parse_hlsl(), and shader_glsl_load_constants().

wine_rb_get()

static struct wine_rb_entry* wine_rb_get ( const struct wine_rb_tree *  tree, const void *  key  )

inlinestatic

Definition at line 203 of file rbtree.h.

{
    struct wine_rb_entry *entry = tree->root;
    while (entry)
    {
        int c = tree->compare(key, entry);
        if (!c) return entry;
        entry = c < 0 ? entry->left : entry->right;
    }
    return NULL;
}

Referenced by add_function_decl(), arbfp_blit_set(), CreateComponentInfo(), find_ffp_frag_shader(), find_function(), find_input_signature(), find_local(), get_glsl_program_entry(), get_overloaded_func(), get_parameter_by_name(), get_reflection_type(), get_type(), glsl_blitter_get_program(), sampler(), shader_glsl_find_ffp_vertex_shader(), source_find(), and wine_rb_remove_key().

wine_rb_head()

static struct wine_rb_entry* wine_rb_head ( struct wine_rb_entry *  iter )

inlinestatic

Definition at line 103 of file rbtree.h.

{
    if (!iter) return NULL;
    while (iter->left) iter = iter->left;
    return iter;
}

Referenced by wine_rb_next().

wine_rb_init()

static void wine_rb_init ( struct wine_rb_tree *  tree, wine_rb_compare_func_t  compare  )

inlinestatic

Definition at line 179 of file rbtree.h.

{
    tree->compare = compare;
    tree->root = NULL;
}

Referenced by add_function_decl(), arbfp_alloc(), atifs_alloc(), compile_function(), d3dcompiler_shader_reflection_init(), d3dx9_parse_effect(), device_init(), glsl_fragment_pipe_alloc(), glsl_vertex_pipe_vp_alloc(), init_functions_tree(), module_new(), push_scope(), shader_arb_alloc(), shader_glsl_alloc(), wined3d_arbfp_blitter_create(), and wined3d_glsl_blitter_create().

wine_rb_is_red()

static int wine_rb_is_red ( struct wine_rb_entry *  entry )

inlinestatic

Definition at line 55 of file rbtree.h.

{
    return entry && (entry->flags & WINE_RB_FLAG_RED);
}

Referenced by wine_rb_put(), and wine_rb_remove().

wine_rb_next()

static struct wine_rb_entry* wine_rb_next ( struct wine_rb_entry *  iter )

inlinestatic

Definition at line 117 of file rbtree.h.

{
    if (iter->right) return wine_rb_head(iter->right);
    while (iter->parent && iter->parent->right == iter) iter = iter->parent;
    return iter->parent;
}

wine_rb_postorder()

static void wine_rb_postorder ( struct wine_rb_tree *  tree, wine_rb_traverse_func_t *  callback, void *  context  )

inlinestatic

Definition at line 173 of file rbtree.h.

{
    struct wine_rb_entry *iter, *next;
    WINE_RB_FOR_EACH_DESTRUCTOR(iter, next, tree) callback(iter, context);
}

Referenced by wine_rb_clear().

wine_rb_postorder_head()

static struct wine_rb_entry* wine_rb_postorder_head ( struct wine_rb_entry *  iter )

inlinestatic

Definition at line 131 of file rbtree.h.

{
    if (!iter) return NULL;

    for (;;) {
        while (iter->left) iter = iter->left;
        if (!iter->right) return iter;
        iter = iter->right;
    }
}

Referenced by wine_rb_postorder_next().

wine_rb_postorder_next()

static struct wine_rb_entry* wine_rb_postorder_next ( struct wine_rb_entry *  iter )

inlinestatic

Definition at line 142 of file rbtree.h.

{
    if (!iter->parent) return NULL;
    if (iter == iter->parent->right || !iter->parent->right) return iter->parent;
    return wine_rb_postorder_head(iter->parent->right);
}

wine_rb_prev()

static struct wine_rb_entry* wine_rb_prev ( struct wine_rb_entry *  iter )

inlinestatic

Definition at line 124 of file rbtree.h.

{
    if (iter->left) return wine_rb_tail(iter->left);
    while (iter->parent && iter->parent->left == iter) iter = iter->parent;
    return iter->parent;
}

wine_rb_put()

static int wine_rb_put ( struct wine_rb_tree *  tree, const void *  key, struct wine_rb_entry *  entry  )

inlinestatic

Definition at line 215 of file rbtree.h.

{
    struct wine_rb_entry **iter = &tree->root, *parent = tree->root;

    while (*iter)
    {
        int c;

        parent = *iter;
        c = tree->compare(key, parent);
        if (!c) return -1;
        else if (c < 0) iter = &parent->left;
        else iter = &parent->right;
    }

    entry->flags = WINE_RB_FLAG_RED;
    entry->parent = parent;
    entry->left = NULL;
    entry->right = NULL;
    *iter = entry;

    while (wine_rb_is_red(entry->parent))
    {
        if (entry->parent == entry->parent->parent->left)
        {
            if (wine_rb_is_red(entry->parent->parent->right))
            {
                wine_rb_flip_color(entry->parent->parent);
                entry = entry->parent->parent;
            }
            else
            {
                if (entry == entry->parent->right)
                {
                    entry = entry->parent;
                    wine_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);
            }
        }
        else
        {
            if (wine_rb_is_red(entry->parent->parent->left))
            {
                wine_rb_flip_color(entry->parent->parent);
                entry = entry->parent->parent;
            }
            else
            {
                if (entry == entry->parent->left)
                {
                    entry = entry->parent;
                    wine_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);
            }
        }
    }

    tree->root->flags &= ~WINE_RB_FLAG_RED;

    return 0;
}

Referenced by add_ffp_frag_shader(), add_function_decl(), add_glsl_program_entry(), add_param_to_tree(), add_type_to_scope(), alloc_local(), arbfp_blit_set(), CreateComponentInfo(), find_input_signature(), get_reflection_type(), glsl_blitter_get_program(), sampler(), shader_glsl_find_ffp_vertex_shader(), and source_new().

wine_rb_remove()

static void wine_rb_remove ( struct wine_rb_tree *  tree, struct wine_rb_entry *  entry  )

inlinestatic

Definition at line 283 of file rbtree.h.

{
    struct wine_rb_entry *iter, *child, *parent, *w;
    int need_fixup;

    if (entry->right && entry->left)
        for(iter = entry->right; iter->left; iter = iter->left);
    else
        iter = entry;

    child = iter->left ? iter->left : iter->right;

    if (!iter->parent)
        tree->root = child;
    else if (iter == iter->parent->left)
        iter->parent->left = child;
    else
        iter->parent->right = child;

    if (child) child->parent = iter->parent;
    parent = iter->parent;

    need_fixup = !wine_rb_is_red(iter);

    if (entry != iter)
    {
        *iter = *entry;
        if (!iter->parent)
            tree->root = iter;
        else if (entry == iter->parent->left)
            iter->parent->left = iter;
        else
            iter->parent->right = iter;

        if (iter->right) iter->right->parent = iter;
        if (iter->left)  iter->left->parent = iter;
        if (parent == entry) parent = iter;
    }

    if (need_fixup)
    {
        while (parent && !wine_rb_is_red(child))
        {
            if (child == parent->left)
            {
                w = parent->right;
                if (wine_rb_is_red(w))
                {
                    w->flags &= ~WINE_RB_FLAG_RED;
                    parent->flags |= WINE_RB_FLAG_RED;
                    wine_rb_rotate_left(tree, parent);
                    w = parent->right;
                }
                if (wine_rb_is_red(w->left) || wine_rb_is_red(w->right))
                {
                    if (!wine_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 = parent->right;
                    }
                    w->flags = (w->flags & ~WINE_RB_FLAG_RED) | (parent->flags & WINE_RB_FLAG_RED);
                    parent->flags &= ~WINE_RB_FLAG_RED;
                    if (w->right)
                        w->right->flags &= ~WINE_RB_FLAG_RED;
                    wine_rb_rotate_left(tree, parent);
                    child = NULL;
                    break;
                }
            }
            else
            {
                w = parent->left;
                if (wine_rb_is_red(w))
                {
                    w->flags &= ~WINE_RB_FLAG_RED;
                    parent->flags |= WINE_RB_FLAG_RED;
                    wine_rb_rotate_right(tree, parent);
                    w = parent->left;
                }
                if (wine_rb_is_red(w->left) || wine_rb_is_red(w->right))
                {
                    if (!wine_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 = parent->left;
                    }
                    w->flags = (w->flags & ~WINE_RB_FLAG_RED) | (parent->flags & WINE_RB_FLAG_RED);
                    parent->flags &= ~WINE_RB_FLAG_RED;
                    if (w->left)
                        w->left->flags &= ~WINE_RB_FLAG_RED;
                    wine_rb_rotate_right(tree, parent);
                    child = NULL;
                    break;
                }
            }
            w->flags |= WINE_RB_FLAG_RED;
            child = parent;
            parent = child->parent;
        }
        if (child) child->flags &= ~WINE_RB_FLAG_RED;
    }

    if (tree->root) tree->root->flags &= ~WINE_RB_FLAG_RED;
}

Referenced by add_function_decl(), delete_glsl_program_entry(), and wine_rb_remove_key().

wine_rb_remove_key()

static void wine_rb_remove_key ( struct wine_rb_tree *  tree, const void *  key  )

inlinestatic

Definition at line 392 of file rbtree.h.

{
    struct wine_rb_entry *entry = wine_rb_get(tree, key);
    if (entry) wine_rb_remove(tree, entry);
}

wine_rb_rotate_left()

static void wine_rb_rotate_left ( struct wine_rb_tree *  tree, struct wine_rb_entry *  e  )

inlinestatic

Definition at line 60 of file rbtree.h.

{
    struct wine_rb_entry *right = e->right;

    if (!e->parent)
        tree->root = right;
    else if (e->parent->left == e)
        e->parent->left = right;
    else
        e->parent->right = right;

    e->right = right->left;
    if (e->right) e->right->parent = e;
    right->left = e;
    right->parent = e->parent;
    e->parent = right;
}

Referenced by wine_rb_put(), and wine_rb_remove().

wine_rb_rotate_right()

static void wine_rb_rotate_right ( struct wine_rb_tree *  tree, struct wine_rb_entry *  e  )

inlinestatic

Definition at line 78 of file rbtree.h.

{
    struct wine_rb_entry *left = e->left;

    if (!e->parent)
        tree->root = left;
    else if (e->parent->left == e)
        e->parent->left = left;
    else
        e->parent->right = left;

    e->left = left->right;
    if (e->left) e->left->parent = e;
    left->right = e;
    left->parent = e->parent;
    e->parent = left;
}

Referenced by wine_rb_put(), and wine_rb_remove().

wine_rb_tail()

static struct wine_rb_entry* wine_rb_tail ( struct wine_rb_entry *  iter )

inlinestatic

Definition at line 110 of file rbtree.h.

{
    if (!iter) return NULL;
    while (iter->right) iter = iter->right;
    return iter;
}

Referenced by wine_rb_prev().