blob: 121c59fa12ed1e61bd83f5f482dc9d572e7d1c7b [file] [log] [blame]
/*
* Elastic Binary Trees - macros and structures for Multi-Byte data nodes.
* Version 6.0.6
* (C) 2002-2011 - Willy Tarreau <w@1wt.eu>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation, version 2.1
* exclusively.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef _EBMBTREE_H
#define _EBMBTREE_H
#include <string.h>
#include "ebtree.h"
/* Return the structure of type <type> whose member <member> points to <ptr> */
#define ebmb_entry(ptr, type, member) container_of(ptr, type, member)
#define EBMB_ROOT EB_ROOT
#define EBMB_TREE_HEAD EB_TREE_HEAD
/* This structure carries a node, a leaf, and a key. It must start with the
* eb_node so that it can be cast into an eb_node. We could also have put some
* sort of transparent union here to reduce the indirection level, but the fact
* is, the end user is not meant to manipulate internals, so this is pointless.
* The 'node.bit' value here works differently from scalar types, as it contains
* the number of identical bits between the two branches.
*/
struct ebmb_node {
struct eb_node node; /* the tree node, must be at the beginning */
unsigned char key[0]; /* the key, its size depends on the application */
};
/*
* Exported functions and macros.
* Many of them are always inlined because they are extremely small, and
* are generally called at most once or twice in a program.
*/
/* Return leftmost node in the tree, or NULL if none */
static forceinline struct ebmb_node *ebmb_first(struct eb_root *root)
{
return ebmb_entry(eb_first(root), struct ebmb_node, node);
}
/* Return rightmost node in the tree, or NULL if none */
static forceinline struct ebmb_node *ebmb_last(struct eb_root *root)
{
return ebmb_entry(eb_last(root), struct ebmb_node, node);
}
/* Return next node in the tree, or NULL if none */
static forceinline struct ebmb_node *ebmb_next(struct ebmb_node *ebmb)
{
return ebmb_entry(eb_next(&ebmb->node), struct ebmb_node, node);
}
/* Return previous node in the tree, or NULL if none */
static forceinline struct ebmb_node *ebmb_prev(struct ebmb_node *ebmb)
{
return ebmb_entry(eb_prev(&ebmb->node), struct ebmb_node, node);
}
/* Return next node in the tree, skipping duplicates, or NULL if none */
static forceinline struct ebmb_node *ebmb_next_unique(struct ebmb_node *ebmb)
{
return ebmb_entry(eb_next_unique(&ebmb->node), struct ebmb_node, node);
}
/* Return previous node in the tree, skipping duplicates, or NULL if none */
static forceinline struct ebmb_node *ebmb_prev_unique(struct ebmb_node *ebmb)
{
return ebmb_entry(eb_prev_unique(&ebmb->node), struct ebmb_node, node);
}
/* Delete node from the tree if it was linked in. Mark the node unused. Note
* that this function relies on a non-inlined generic function: eb_delete.
*/
static forceinline void ebmb_delete(struct ebmb_node *ebmb)
{
eb_delete(&ebmb->node);
}
/* The following functions are not inlined by default. They are declared
* in ebmbtree.c, which simply relies on their inline version.
*/
REGPRM3 struct ebmb_node *ebmb_lookup(struct eb_root *root, const void *x, unsigned int len);
REGPRM3 struct ebmb_node *ebmb_insert(struct eb_root *root, struct ebmb_node *new, unsigned int len);
REGPRM2 struct ebmb_node *ebmb_lookup_longest(struct eb_root *root, const void *x);
REGPRM3 struct ebmb_node *ebmb_lookup_prefix(struct eb_root *root, const void *x, unsigned int pfx);
REGPRM3 struct ebmb_node *ebmb_insert_prefix(struct eb_root *root, struct ebmb_node *new, unsigned int len);
/* The following functions are less likely to be used directly, because their
* code is larger. The non-inlined version is preferred.
*/
/* Delete node from the tree if it was linked in. Mark the node unused. */
static forceinline void __ebmb_delete(struct ebmb_node *ebmb)
{
__eb_delete(&ebmb->node);
}
/* Find the first occurence of a key of a least <len> bytes matching <x> in the
* tree <root>. The caller is responsible for ensuring that <len> will not exceed
* the common parts between the tree's keys and <x>. In case of multiple matches,
* the leftmost node is returned. This means that this function can be used to
* lookup string keys by prefix if all keys in the tree are zero-terminated. If
* no match is found, NULL is returned. Returns first node if <len> is zero.
*/
static forceinline struct ebmb_node *__ebmb_lookup(struct eb_root *root, const void *x, unsigned int len)
{
struct ebmb_node *node;
eb_troot_t *troot;
int pos, side;
int node_bit;
troot = root->b[EB_LEFT];
if (unlikely(troot == NULL))
goto ret_null;
if (unlikely(len == 0))
goto walk_down;
pos = 0;
while (1) {
if (eb_gettag(troot) == EB_LEAF) {
node = container_of(eb_untag(troot, EB_LEAF),
struct ebmb_node, node.branches);
if (memcmp(node->key + pos, x, len) != 0)
goto ret_null;
else
goto ret_node;
}
node = container_of(eb_untag(troot, EB_NODE),
struct ebmb_node, node.branches);
node_bit = node->node.bit;
if (node_bit < 0) {
/* We have a dup tree now. Either it's for the same
* value, and we walk down left, or it's a different
* one and we don't have our key.
*/
if (memcmp(node->key + pos, x, len) != 0)
goto ret_null;
else
goto walk_left;
}
/* OK, normal data node, let's walk down. We check if all full
* bytes are equal, and we start from the last one we did not
* completely check. We stop as soon as we reach the last byte,
* because we must decide to go left/right or abort.
*/
node_bit = ~node_bit + (pos << 3) + 8; // = (pos<<3) + (7 - node_bit)
if (node_bit < 0) {
/* This surprizing construction gives better performance
* because gcc does not try to reorder the loop. Tested to
* be fine with 2.95 to 4.2.
*/
while (1) {
if (node->key[pos++] ^ *(unsigned char*)(x++))
goto ret_null; /* more than one full byte is different */
if (--len == 0)
goto walk_left; /* return first node if all bytes matched */
node_bit += 8;
if (node_bit >= 0)
break;
}
}
/* here we know that only the last byte differs, so node_bit < 8.
* We have 2 possibilities :
* - more than the last bit differs => return NULL
* - walk down on side = (x[pos] >> node_bit) & 1
*/
side = *(unsigned char *)x >> node_bit;
if (((node->key[pos] >> node_bit) ^ side) > 1)
goto ret_null;
side &= 1;
troot = node->node.branches.b[side];
}
walk_left:
troot = node->node.branches.b[EB_LEFT];
walk_down:
while (eb_gettag(troot) != EB_LEAF)
troot = (eb_untag(troot, EB_NODE))->b[EB_LEFT];
node = container_of(eb_untag(troot, EB_LEAF),
struct ebmb_node, node.branches);
ret_node:
return node;
ret_null:
return NULL;
}
/* Insert ebmb_node <new> into subtree starting at node root <root>.
* Only new->key needs be set with the key. The ebmb_node is returned.
* If root->b[EB_RGHT]==1, the tree may only contain unique keys. The
* len is specified in bytes. It is absolutely mandatory that this length
* is the same for all keys in the tree. This function cannot be used to
* insert strings.
*/
static forceinline struct ebmb_node *
__ebmb_insert(struct eb_root *root, struct ebmb_node *new, unsigned int len)
{
struct ebmb_node *old;
unsigned int side;
eb_troot_t *troot, **up_ptr;
eb_troot_t *root_right;
int diff;
int bit;
eb_troot_t *new_left, *new_rght;
eb_troot_t *new_leaf;
int old_node_bit;
side = EB_LEFT;
troot = root->b[EB_LEFT];
root_right = root->b[EB_RGHT];
if (unlikely(troot == NULL)) {
/* Tree is empty, insert the leaf part below the left branch */
root->b[EB_LEFT] = eb_dotag(&new->node.branches, EB_LEAF);
new->node.leaf_p = eb_dotag(root, EB_LEFT);
new->node.node_p = NULL; /* node part unused */
return new;
}
/* The tree descent is fairly easy :
* - first, check if we have reached a leaf node
* - second, check if we have gone too far
* - third, reiterate
* Everywhere, we use <new> for the node node we are inserting, <root>
* for the node we attach it to, and <old> for the node we are
* displacing below <new>. <troot> will always point to the future node
* (tagged with its type). <side> carries the side the node <new> is
* attached to below its parent, which is also where previous node
* was attached.
*/
bit = 0;
while (1) {
if (unlikely(eb_gettag(troot) == EB_LEAF)) {
/* insert above a leaf */
old = container_of(eb_untag(troot, EB_LEAF),
struct ebmb_node, node.branches);
new->node.node_p = old->node.leaf_p;
up_ptr = &old->node.leaf_p;
goto check_bit_and_break;
}
/* OK we're walking down this link */
old = container_of(eb_untag(troot, EB_NODE),
struct ebmb_node, node.branches);
old_node_bit = old->node.bit;
if (unlikely(old->node.bit < 0)) {
/* We're above a duplicate tree, so we must compare the whole value */
new->node.node_p = old->node.node_p;
up_ptr = &old->node.node_p;
check_bit_and_break:
bit = equal_bits(new->key, old->key, bit, len << 3);
break;
}
/* Stop going down when we don't have common bits anymore. We
* also stop in front of a duplicates tree because it means we
* have to insert above. Note: we can compare more bits than
* the current node's because as long as they are identical, we
* know we descend along the correct side.
*/
bit = equal_bits(new->key, old->key, bit, old_node_bit);
if (unlikely(bit < old_node_bit)) {
/* The tree did not contain the key, so we insert <new> before the
* node <old>, and set ->bit to designate the lowest bit position in
* <new> which applies to ->branches.b[].
*/
new->node.node_p = old->node.node_p;
up_ptr = &old->node.node_p;
break;
}
/* we don't want to skip bits for further comparisons, so we must limit <bit>.
* However, since we're going down around <old_node_bit>, we know it will be
* properly matched, so we can skip this bit.
*/
bit = old_node_bit + 1;
/* walk down */
root = &old->node.branches;
side = old_node_bit & 7;
side ^= 7;
side = (new->key[old_node_bit >> 3] >> side) & 1;
troot = root->b[side];
}
new_left = eb_dotag(&new->node.branches, EB_LEFT);
new_rght = eb_dotag(&new->node.branches, EB_RGHT);
new_leaf = eb_dotag(&new->node.branches, EB_LEAF);
/* Note: we can compare more bits than
* the current node's because as long as they are identical, we
* know we descend along the correct side.
*/
new->node.bit = bit;
diff = cmp_bits(new->key, old->key, bit);
if (diff == 0) {
new->node.bit = -1; /* mark as new dup tree, just in case */
if (likely(eb_gettag(root_right))) {
/* we refuse to duplicate this key if the tree is
* tagged as containing only unique keys.
*/
return old;
}
if (eb_gettag(troot) != EB_LEAF) {
/* there was already a dup tree below */
struct eb_node *ret;
ret = eb_insert_dup(&old->node, &new->node);
return container_of(ret, struct ebmb_node, node);
}
/* otherwise fall through */
}
if (diff >= 0) {
new->node.branches.b[EB_LEFT] = troot;
new->node.branches.b[EB_RGHT] = new_leaf;
new->node.leaf_p = new_rght;
*up_ptr = new_left;
}
else if (diff < 0) {
new->node.branches.b[EB_LEFT] = new_leaf;
new->node.branches.b[EB_RGHT] = troot;
new->node.leaf_p = new_left;
*up_ptr = new_rght;
}
/* Ok, now we are inserting <new> between <root> and <old>. <old>'s
* parent is already set to <new>, and the <root>'s branch is still in
* <side>. Update the root's leaf till we have it. Note that we can also
* find the side by checking the side of new->node.node_p.
*/
root->b[side] = eb_dotag(&new->node.branches, EB_NODE);
return new;
}
/* Find the first occurence of the longest prefix matching a key <x> in the
* tree <root>. It's the caller's responsibility to ensure that key <x> is at
* least as long as the keys in the tree. If none can be found, return NULL.
*/
static forceinline struct ebmb_node *__ebmb_lookup_longest(struct eb_root *root, const void *x)
{
struct ebmb_node *node;
eb_troot_t *troot, *cover;
int pos, side;
int node_bit;
troot = root->b[EB_LEFT];
if (unlikely(troot == NULL))
return NULL;
cover = NULL;
pos = 0;
while (1) {
if ((eb_gettag(troot) == EB_LEAF)) {
node = container_of(eb_untag(troot, EB_LEAF),
struct ebmb_node, node.branches);
if (check_bits(x - pos, node->key, pos, node->node.pfx))
goto not_found;
return node;
}
node = container_of(eb_untag(troot, EB_NODE),
struct ebmb_node, node.branches);
node_bit = node->node.bit;
if (node_bit < 0) {
/* We have a dup tree now. Either it's for the same
* value, and we walk down left, or it's a different
* one and we don't have our key.
*/
if (check_bits(x - pos, node->key, pos, node->node.pfx))
goto not_found;
troot = node->node.branches.b[EB_LEFT];
while (eb_gettag(troot) != EB_LEAF)
troot = (eb_untag(troot, EB_NODE))->b[EB_LEFT];
node = container_of(eb_untag(troot, EB_LEAF),
struct ebmb_node, node.branches);
return node;
}
node_bit >>= 1; /* strip cover bit */
node_bit = ~node_bit + (pos << 3) + 8; // = (pos<<3) + (7 - node_bit)
if (node_bit < 0) {
/* This uncommon construction gives better performance
* because gcc does not try to reorder the loop. Tested to
* be fine with 2.95 to 4.2.
*/
while (1) {
x++; pos++;
if (node->key[pos-1] ^ *(unsigned char*)(x-1))
goto not_found; /* more than one full byte is different */
node_bit += 8;
if (node_bit >= 0)
break;
}
}
/* here we know that only the last byte differs, so 0 <= node_bit <= 7.
* We have 2 possibilities :
* - more than the last bit differs => data does not match
* - walk down on side = (x[pos] >> node_bit) & 1
*/
side = *(unsigned char *)x >> node_bit;
if (((node->key[pos] >> node_bit) ^ side) > 1)
goto not_found;
if (!(node->node.bit & 1)) {
/* This is a cover node, let's keep a reference to it
* for later. The covering subtree is on the left, and
* the covered subtree is on the right, so we have to
* walk down right.
*/
cover = node->node.branches.b[EB_LEFT];
troot = node->node.branches.b[EB_RGHT];
continue;
}
side &= 1;
troot = node->node.branches.b[side];
}
not_found:
/* Walk down last cover tre if it exists. It does not matter if cover is NULL */
return ebmb_entry(eb_walk_down(cover, EB_LEFT), struct ebmb_node, node);
}
/* Find the first occurence of a prefix matching a key <x> of <pfx> BITS in the
* tree <root>. It's the caller's responsibility to ensure that key <x> is at
* least as long as the keys in the tree. If none can be found, return NULL.
*/
static forceinline struct ebmb_node *__ebmb_lookup_prefix(struct eb_root *root, const void *x, unsigned int pfx)
{
struct ebmb_node *node;
eb_troot_t *troot;
int pos, side;
int node_bit;
troot = root->b[EB_LEFT];
if (unlikely(troot == NULL))
return NULL;
pos = 0;
while (1) {
if ((eb_gettag(troot) == EB_LEAF)) {
node = container_of(eb_untag(troot, EB_LEAF),
struct ebmb_node, node.branches);
if (node->node.pfx != pfx)
return NULL;
if (check_bits(x - pos, node->key, pos, node->node.pfx))
return NULL;
return node;
}
node = container_of(eb_untag(troot, EB_NODE),
struct ebmb_node, node.branches);
node_bit = node->node.bit;
if (node_bit < 0) {
/* We have a dup tree now. Either it's for the same
* value, and we walk down left, or it's a different
* one and we don't have our key.
*/
if (node->node.pfx != pfx)
return NULL;
if (check_bits(x - pos, node->key, pos, node->node.pfx))
return NULL;
troot = node->node.branches.b[EB_LEFT];
while (eb_gettag(troot) != EB_LEAF)
troot = (eb_untag(troot, EB_NODE))->b[EB_LEFT];
node = container_of(eb_untag(troot, EB_LEAF),
struct ebmb_node, node.branches);
return node;
}
node_bit >>= 1; /* strip cover bit */
node_bit = ~node_bit + (pos << 3) + 8; // = (pos<<3) + (7 - node_bit)
if (node_bit < 0) {
/* This uncommon construction gives better performance
* because gcc does not try to reorder the loop. Tested to
* be fine with 2.95 to 4.2.
*/
while (1) {
x++; pos++;
if (node->key[pos-1] ^ *(unsigned char*)(x-1))
return NULL; /* more than one full byte is different */
node_bit += 8;
if (node_bit >= 0)
break;
}
}
/* here we know that only the last byte differs, so 0 <= node_bit <= 7.
* We have 2 possibilities :
* - more than the last bit differs => data does not match
* - walk down on side = (x[pos] >> node_bit) & 1
*/
side = *(unsigned char *)x >> node_bit;
if (((node->key[pos] >> node_bit) ^ side) > 1)
return NULL;
if (!(node->node.bit & 1)) {
/* This is a cover node, it may be the entry we're
* looking for. We already know that it matches all the
* bits, let's compare prefixes and descend the cover
* subtree if they match.
*/
if ((unsigned short)node->node.bit >> 1 == pfx)
troot = node->node.branches.b[EB_LEFT];
else
troot = node->node.branches.b[EB_RGHT];
continue;
}
side &= 1;
troot = node->node.branches.b[side];
}
}
/* Insert ebmb_node <new> into a prefix subtree starting at node root <root>.
* Only new->key and new->pfx need be set with the key and its prefix length.
* Note that bits between <pfx> and <len> are theorically ignored and should be
* zero, as it is not certain yet that they will always be ignored everywhere
* (eg in bit compare functions).
* The ebmb_node is returned.
* If root->b[EB_RGHT]==1, the tree may only contain unique keys. The
* len is specified in bytes.
*/
static forceinline struct ebmb_node *
__ebmb_insert_prefix(struct eb_root *root, struct ebmb_node *new, unsigned int len)
{
struct ebmb_node *old;
unsigned int side;
eb_troot_t *troot, **up_ptr;
eb_troot_t *root_right;
int diff;
int bit;
eb_troot_t *new_left, *new_rght;
eb_troot_t *new_leaf;
int old_node_bit;
side = EB_LEFT;
troot = root->b[EB_LEFT];
root_right = root->b[EB_RGHT];
if (unlikely(troot == NULL)) {
/* Tree is empty, insert the leaf part below the left branch */
root->b[EB_LEFT] = eb_dotag(&new->node.branches, EB_LEAF);
new->node.leaf_p = eb_dotag(root, EB_LEFT);
new->node.node_p = NULL; /* node part unused */
return new;
}
len <<= 3;
if (len > new->node.pfx)
len = new->node.pfx;
/* The tree descent is fairly easy :
* - first, check if we have reached a leaf node
* - second, check if we have gone too far
* - third, reiterate
* Everywhere, we use <new> for the node node we are inserting, <root>
* for the node we attach it to, and <old> for the node we are
* displacing below <new>. <troot> will always point to the future node
* (tagged with its type). <side> carries the side the node <new> is
* attached to below its parent, which is also where previous node
* was attached.
*/
bit = 0;
while (1) {
if (unlikely(eb_gettag(troot) == EB_LEAF)) {
/* Insert above a leaf. Note that this leaf could very
* well be part of a cover node.
*/
old = container_of(eb_untag(troot, EB_LEAF),
struct ebmb_node, node.branches);
new->node.node_p = old->node.leaf_p;
up_ptr = &old->node.leaf_p;
goto check_bit_and_break;
}
/* OK we're walking down this link */
old = container_of(eb_untag(troot, EB_NODE),
struct ebmb_node, node.branches);
old_node_bit = old->node.bit;
/* Note that old_node_bit can be :
* < 0 : dup tree
* = 2N : cover node for N bits
* = 2N+1 : normal node at N bits
*/
if (unlikely(old_node_bit < 0)) {
/* We're above a duplicate tree, so we must compare the whole value */
new->node.node_p = old->node.node_p;
up_ptr = &old->node.node_p;
check_bit_and_break:
/* No need to compare everything if the leaves are shorter than the new one. */
if (len > old->node.pfx)
len = old->node.pfx;
bit = equal_bits(new->key, old->key, bit, len);
break;
}
/* WARNING: for the two blocks below, <bit> is counted in half-bits */
bit = equal_bits(new->key, old->key, bit, old_node_bit >> 1);
bit = (bit << 1) + 1; // assume comparisons with normal nodes
/* we must always check that our prefix is larger than the nodes
* we visit, otherwise we have to stop going down. The following
* test is able to stop before both normal and cover nodes.
*/
if (bit >= (new->node.pfx << 1) && (new->node.pfx << 1) < old_node_bit) {
/* insert cover node here on the left */
new->node.node_p = old->node.node_p;
up_ptr = &old->node.node_p;
new->node.bit = new->node.pfx << 1;
diff = -1;
goto insert_above;
}
if (unlikely(bit < old_node_bit)) {
/* The tree did not contain the key, so we insert <new> before the
* node <old>, and set ->bit to designate the lowest bit position in
* <new> which applies to ->branches.b[]. We know that the bit is not
* greater than the prefix length thanks to the test above.
*/
new->node.node_p = old->node.node_p;
up_ptr = &old->node.node_p;
new->node.bit = bit;
diff = cmp_bits(new->key, old->key, bit >> 1);
goto insert_above;
}
if (!(old_node_bit & 1)) {
/* if we encounter a cover node with our exact prefix length, it's
* necessarily the same value, so we insert there as a duplicate on
* the left. For that, we go down on the left and the leaf detection
* code will finish the job.
*/
if ((new->node.pfx << 1) == old_node_bit) {
root = &old->node.branches;
side = EB_LEFT;
troot = root->b[side];
continue;
}
/* cover nodes are always walked through on the right */
side = EB_RGHT;
bit = old_node_bit >> 1; /* recheck that bit */
root = &old->node.branches;
troot = root->b[side];
continue;
}
/* we don't want to skip bits for further comparisons, so we must limit <bit>.
* However, since we're going down around <old_node_bit>, we know it will be
* properly matched, so we can skip this bit.
*/
old_node_bit >>= 1;
bit = old_node_bit + 1;
/* walk down */
root = &old->node.branches;
side = old_node_bit & 7;
side ^= 7;
side = (new->key[old_node_bit >> 3] >> side) & 1;
troot = root->b[side];
}
/* Right here, we have 4 possibilities :
* - the tree does not contain any leaf matching the
* key, and we have new->key < old->key. We insert
* new above old, on the left ;
*
* - the tree does not contain any leaf matching the
* key, and we have new->key > old->key. We insert
* new above old, on the right ;
*
* - the tree does contain the key with the same prefix
* length. We add the new key next to it as a first
* duplicate (since it was alone).
*
* The last two cases can easily be partially merged.
*
* - the tree contains a leaf matching the key, we have
* to insert above it as a cover node. The leaf with
* the shortest prefix becomes the left subtree and
* the leaf with the longest prefix becomes the right
* one. The cover node gets the min of both prefixes
* as its new bit.
*/
/* first we want to ensure that we compare the correct bit, which means
* the largest common to both nodes.
*/
if (bit > new->node.pfx)
bit = new->node.pfx;
if (bit > old->node.pfx)
bit = old->node.pfx;
new->node.bit = (bit << 1) + 1; /* assume normal node by default */
/* if one prefix is included in the second one, we don't compare bits
* because they won't necessarily match, we just proceed with a cover
* node insertion.
*/
diff = 0;
if (bit < old->node.pfx && bit < new->node.pfx)
diff = cmp_bits(new->key, old->key, bit);
if (diff == 0) {
/* Both keys match. Either it's a duplicate entry or we have to
* put the shortest prefix left and the largest one right below
* a new cover node. By default, diff==0 means we'll be inserted
* on the right.
*/
new->node.bit--; /* anticipate cover node insertion */
if (new->node.pfx == old->node.pfx) {
new->node.bit = -1; /* mark as new dup tree, just in case */
if (unlikely(eb_gettag(root_right))) {
/* we refuse to duplicate this key if the tree is
* tagged as containing only unique keys.
*/
return old;
}
if (eb_gettag(troot) != EB_LEAF) {
/* there was already a dup tree below */
struct eb_node *ret;
ret = eb_insert_dup(&old->node, &new->node);
return container_of(ret, struct ebmb_node, node);
}
/* otherwise fall through to insert first duplicate */
}
/* otherwise we just rely on the tests below to select the right side */
else if (new->node.pfx < old->node.pfx)
diff = -1; /* force insertion to left side */
}
insert_above:
new_left = eb_dotag(&new->node.branches, EB_LEFT);
new_rght = eb_dotag(&new->node.branches, EB_RGHT);
new_leaf = eb_dotag(&new->node.branches, EB_LEAF);
if (diff >= 0) {
new->node.branches.b[EB_LEFT] = troot;
new->node.branches.b[EB_RGHT] = new_leaf;
new->node.leaf_p = new_rght;
*up_ptr = new_left;
}
else {
new->node.branches.b[EB_LEFT] = new_leaf;
new->node.branches.b[EB_RGHT] = troot;
new->node.leaf_p = new_left;
*up_ptr = new_rght;
}
root->b[side] = eb_dotag(&new->node.branches, EB_NODE);
return new;
}
#endif /* _EBMBTREE_H */