Switch to K&R style indentation.
This commit is contained in:
Guus Sliepen
parent
f75dcef72a
commit
9f38e39463
8 changed files with 771 additions and 787 deletions
289
lib/avl_tree.c
289
lib/avl_tree.c
|
|
@ -29,7 +29,7 @@
|
|||
library for inclusion into tinc (http://tinc.nl.linux.org/) by
|
||||
Guus Sliepen <guus@sliepen.eu.org>.
|
||||
|
||||
$Id: avl_tree.c,v 1.1.2.9 2002/06/21 10:11:11 guus Exp $
|
||||
$Id: avl_tree.c,v 1.1.2.10 2002/09/09 21:49:16 guus Exp $
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
|
|
@ -56,41 +56,46 @@
|
|||
int lg(unsigned int u)
|
||||
{
|
||||
int r = 1;
|
||||
if (!u)
|
||||
|
||||
if(!u)
|
||||
return 0;
|
||||
if (u & 0xffff0000)
|
||||
{
|
||||
|
||||
if(u & 0xffff0000) {
|
||||
u >>= 16;
|
||||
r += 16;
|
||||
}
|
||||
if (u & 0x0000ff00)
|
||||
{
|
||||
|
||||
if(u & 0x0000ff00) {
|
||||
u >>= 8;
|
||||
r += 8;
|
||||
}
|
||||
if (u & 0x000000f0)
|
||||
{
|
||||
|
||||
if(u & 0x000000f0) {
|
||||
u >>= 4;
|
||||
r += 4;
|
||||
}
|
||||
if (u & 0x0000000c)
|
||||
{
|
||||
|
||||
if(u & 0x0000000c) {
|
||||
u >>= 2;
|
||||
r += 2;
|
||||
}
|
||||
if (u & 0x00000002)
|
||||
|
||||
if(u & 0x00000002)
|
||||
r++;
|
||||
|
||||
return r;
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Internal helper functions */
|
||||
|
||||
int avl_check_balance(avl_node_t *node)
|
||||
int avl_check_balance(avl_node_t * node)
|
||||
{
|
||||
#ifdef AVL_DEPTH
|
||||
int d;
|
||||
|
||||
d = R_AVL_DEPTH(node) - L_AVL_DEPTH(node);
|
||||
|
||||
return d < -1 ? -1 : d > 1 ? 1 : 0;
|
||||
#else
|
||||
/* int d;
|
||||
|
|
@ -102,15 +107,17 @@ int avl_check_balance(avl_node_t *node)
|
|||
pl = lg(AVL_L_COUNT(node));
|
||||
r = AVL_R_COUNT(node);
|
||||
|
||||
if (r >> pl + 1)
|
||||
if(r >> pl + 1)
|
||||
return 1;
|
||||
if (pl < 2 || r >> pl - 2)
|
||||
|
||||
if(pl < 2 || r >> pl - 2)
|
||||
return 0;
|
||||
|
||||
return -1;
|
||||
#endif
|
||||
}
|
||||
|
||||
void avl_rebalance(avl_tree_t *tree, avl_node_t *node)
|
||||
void avl_rebalance(avl_tree_t * tree, avl_node_t * node)
|
||||
{
|
||||
avl_node_t *child;
|
||||
avl_node_t *gchild;
|
||||
|
|
@ -119,25 +126,25 @@ void avl_rebalance(avl_tree_t *tree, avl_node_t *node)
|
|||
|
||||
parent = node;
|
||||
|
||||
while (node)
|
||||
{
|
||||
while(node) {
|
||||
parent = node->parent;
|
||||
|
||||
superparent = parent ? node == parent->left ? &parent->left : &parent->right : &tree->root;
|
||||
superparent =
|
||||
parent ? node ==
|
||||
parent->left ? &parent->left : &parent->right : &tree->root;
|
||||
|
||||
switch (avl_check_balance(node))
|
||||
{
|
||||
switch (avl_check_balance(node)) {
|
||||
case -1:
|
||||
child = node->left;
|
||||
#ifdef AVL_DEPTH
|
||||
if(L_AVL_DEPTH(child) >= R_AVL_DEPTH(child)) {
|
||||
#else
|
||||
if (AVL_L_COUNT(child) >= AVL_R_COUNT(child))
|
||||
{
|
||||
if(AVL_L_COUNT(child) >= AVL_R_COUNT(child)) {
|
||||
#endif
|
||||
node->left = child->right;
|
||||
if (node->left)
|
||||
if(node->left)
|
||||
node->left->parent = node;
|
||||
|
||||
child->right = node;
|
||||
node->parent = child;
|
||||
*superparent = child;
|
||||
|
|
@ -150,22 +157,26 @@ void avl_rebalance(avl_tree_t *tree, avl_node_t *node)
|
|||
node->depth = AVL_CALC_DEPTH(node);
|
||||
child->depth = AVL_CALC_DEPTH(child);
|
||||
#endif
|
||||
} else
|
||||
{
|
||||
} else {
|
||||
gchild = child->right;
|
||||
node->left = gchild->right;
|
||||
if (node->left)
|
||||
|
||||
if(node->left)
|
||||
node->left->parent = node;
|
||||
child->right = gchild->left;
|
||||
if (child->right)
|
||||
|
||||
if(child->right)
|
||||
child->right->parent = child;
|
||||
gchild->right = node;
|
||||
if (gchild->right)
|
||||
|
||||
if(gchild->right)
|
||||
gchild->right->parent = gchild;
|
||||
gchild->left = child;
|
||||
if (gchild->left)
|
||||
|
||||
if(gchild->left)
|
||||
gchild->left->parent = gchild;
|
||||
*superparent = gchild;
|
||||
|
||||
gchild->parent = parent;
|
||||
#ifdef AVL_COUNT
|
||||
node->count = AVL_CALC_COUNT(node);
|
||||
|
|
@ -179,16 +190,16 @@ void avl_rebalance(avl_tree_t *tree, avl_node_t *node)
|
|||
#endif
|
||||
}
|
||||
break;
|
||||
|
||||
case 1:
|
||||
child = node->right;
|
||||
#ifdef AVL_DEPTH
|
||||
if(R_AVL_DEPTH(child) >= L_AVL_DEPTH(child)) {
|
||||
#else
|
||||
if (AVL_R_COUNT(child) >= AVL_L_COUNT(child))
|
||||
{
|
||||
if(AVL_R_COUNT(child) >= AVL_L_COUNT(child)) {
|
||||
#endif
|
||||
node->right = child->left;
|
||||
if (node->right)
|
||||
if(node->right)
|
||||
node->right->parent = node;
|
||||
child->left = node;
|
||||
node->parent = child;
|
||||
|
|
@ -202,21 +213,25 @@ void avl_rebalance(avl_tree_t *tree, avl_node_t *node)
|
|||
node->depth = AVL_CALC_DEPTH(node);
|
||||
child->depth = AVL_CALC_DEPTH(child);
|
||||
#endif
|
||||
} else
|
||||
{
|
||||
} else {
|
||||
gchild = child->left;
|
||||
node->right = gchild->left;
|
||||
if (node->right)
|
||||
|
||||
if(node->right)
|
||||
node->right->parent = node;
|
||||
child->left = gchild->right;
|
||||
if (child->left)
|
||||
|
||||
if(child->left)
|
||||
child->left->parent = child;
|
||||
gchild->left = node;
|
||||
if (gchild->left)
|
||||
|
||||
if(gchild->left)
|
||||
gchild->left->parent = gchild;
|
||||
gchild->right = child;
|
||||
if (gchild->right)
|
||||
|
||||
if(gchild->right)
|
||||
gchild->right->parent = gchild;
|
||||
|
||||
*superparent = gchild;
|
||||
gchild->parent = parent;
|
||||
#ifdef AVL_COUNT
|
||||
|
|
@ -231,6 +246,7 @@ void avl_rebalance(avl_tree_t *tree, avl_node_t *node)
|
|||
#endif
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
#ifdef AVL_COUNT
|
||||
node->count = AVL_CALC_COUNT(node);
|
||||
|
|
@ -256,117 +272,106 @@ avl_tree_t *avl_alloc_tree(avl_compare_t compare, avl_action_t delete)
|
|||
return tree;
|
||||
}
|
||||
|
||||
void avl_free_tree(avl_tree_t *tree)
|
||||
void avl_free_tree(avl_tree_t * tree)
|
||||
{
|
||||
free(tree);
|
||||
}
|
||||
|
||||
avl_node_t *avl_alloc_node(void)
|
||||
{
|
||||
avl_node_t *node;
|
||||
|
||||
node = xmalloc_and_zero(sizeof(avl_node_t));
|
||||
|
||||
return node;
|
||||
return (avl_node_t *)xmalloc_and_zero(sizeof(avl_node_t));
|
||||
}
|
||||
|
||||
void avl_free_node(avl_tree_t *tree, avl_node_t *node)
|
||||
void avl_free_node(avl_tree_t * tree, avl_node_t * node)
|
||||
{
|
||||
if(node->data && tree->delete)
|
||||
tree->delete(node->data);
|
||||
|
||||
free(node);
|
||||
}
|
||||
|
||||
/* Searching */
|
||||
|
||||
void *avl_search(const avl_tree_t *tree, const void *data)
|
||||
void *avl_search(const avl_tree_t * tree, const void *data)
|
||||
{
|
||||
avl_node_t *node;
|
||||
|
||||
node = avl_search_node(tree, data);
|
||||
|
||||
return node?node->data:NULL;
|
||||
return node ? node->data : NULL;
|
||||
}
|
||||
|
||||
void *avl_search_closest(const avl_tree_t *tree, const void *data, int *result)
|
||||
void *avl_search_closest(const avl_tree_t * tree, const void *data, int *result)
|
||||
{
|
||||
avl_node_t *node;
|
||||
|
||||
node = avl_search_closest_node(tree, data, result);
|
||||
|
||||
return node?node->data:NULL;
|
||||
return node ? node->data : NULL;
|
||||
}
|
||||
|
||||
void *avl_search_closest_smaller(const avl_tree_t *tree, const void *data)
|
||||
void *avl_search_closest_smaller(const avl_tree_t * tree, const void *data)
|
||||
{
|
||||
avl_node_t *node;
|
||||
|
||||
node = avl_search_closest_smaller_node(tree, data);
|
||||
|
||||
return node?node->data:NULL;
|
||||
return node ? node->data : NULL;
|
||||
}
|
||||
|
||||
void *avl_search_closest_greater(const avl_tree_t *tree, const void *data)
|
||||
void *avl_search_closest_greater(const avl_tree_t * tree, const void *data)
|
||||
{
|
||||
avl_node_t *node;
|
||||
|
||||
node = avl_search_closest_greater_node(tree, data);
|
||||
|
||||
return node?node->data:NULL;
|
||||
return node ? node->data : NULL;
|
||||
}
|
||||
|
||||
avl_node_t *avl_search_node(const avl_tree_t *tree, const void *data)
|
||||
avl_node_t *avl_search_node(const avl_tree_t * tree, const void *data)
|
||||
{
|
||||
avl_node_t *node;
|
||||
int result;
|
||||
|
||||
node = avl_search_closest_node(tree, data, &result);
|
||||
|
||||
return result?NULL:node;
|
||||
return result ? NULL : node;
|
||||
}
|
||||
|
||||
avl_node_t *avl_search_closest_node(const avl_tree_t *tree, const void *data, int *result)
|
||||
avl_node_t *avl_search_closest_node(const avl_tree_t * tree, const void *data,
|
||||
int *result)
|
||||
{
|
||||
avl_node_t *node;
|
||||
int c;
|
||||
|
||||
node = tree->root;
|
||||
|
||||
if (!node)
|
||||
{
|
||||
if(!node) {
|
||||
if(result)
|
||||
*result = 0;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
for (;;)
|
||||
{
|
||||
for(;;) {
|
||||
c = tree->compare(data, node->data);
|
||||
|
||||
if (c < 0)
|
||||
{
|
||||
if (node->left)
|
||||
if(c < 0) {
|
||||
if(node->left)
|
||||
node = node->left;
|
||||
else
|
||||
{
|
||||
else {
|
||||
if(result)
|
||||
*result = -1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
else if (c > 0)
|
||||
{
|
||||
if (node->right)
|
||||
} else if(c > 0) {
|
||||
if(node->right)
|
||||
node = node->right;
|
||||
else
|
||||
{
|
||||
else {
|
||||
if(result)
|
||||
*result = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
if(result)
|
||||
*result = 0;
|
||||
break;
|
||||
|
|
@ -376,7 +381,8 @@ avl_node_t *avl_search_closest_node(const avl_tree_t *tree, const void *data, in
|
|||
return node;
|
||||
}
|
||||
|
||||
avl_node_t *avl_search_closest_smaller_node(const avl_tree_t *tree, const void *data)
|
||||
avl_node_t *avl_search_closest_smaller_node(const avl_tree_t * tree,
|
||||
const void *data)
|
||||
{
|
||||
avl_node_t *node;
|
||||
int result;
|
||||
|
|
@ -389,7 +395,8 @@ avl_node_t *avl_search_closest_smaller_node(const avl_tree_t *tree, const void *
|
|||
return node;
|
||||
}
|
||||
|
||||
avl_node_t *avl_search_closest_greater_node(const avl_tree_t *tree, const void *data)
|
||||
avl_node_t *avl_search_closest_greater_node(const avl_tree_t * tree,
|
||||
const void *data)
|
||||
{
|
||||
avl_node_t *node;
|
||||
int result;
|
||||
|
|
@ -404,32 +411,31 @@ avl_node_t *avl_search_closest_greater_node(const avl_tree_t *tree, const void *
|
|||
|
||||
/* Insertion and deletion */
|
||||
|
||||
avl_node_t *avl_insert(avl_tree_t *tree, void *data)
|
||||
avl_node_t *avl_insert(avl_tree_t * tree, void *data)
|
||||
{
|
||||
avl_node_t *closest, *new;
|
||||
int result;
|
||||
|
||||
if (!tree->root)
|
||||
{
|
||||
if(!tree->root) {
|
||||
new = avl_alloc_node();
|
||||
new->data = data;
|
||||
avl_insert_top(tree, new);
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
closest = avl_search_closest_node(tree, data, &result);
|
||||
switch(result)
|
||||
{
|
||||
|
||||
switch (result) {
|
||||
case -1:
|
||||
new = avl_alloc_node();
|
||||
new->data = data;
|
||||
avl_insert_before(tree, closest, new);
|
||||
break;
|
||||
|
||||
case 1:
|
||||
new = avl_alloc_node();
|
||||
new->data = data;
|
||||
avl_insert_after(tree, closest, new);
|
||||
break;
|
||||
|
||||
default:
|
||||
return NULL;
|
||||
}
|
||||
|
|
@ -445,24 +451,25 @@ avl_node_t *avl_insert(avl_tree_t *tree, void *data)
|
|||
return new;
|
||||
}
|
||||
|
||||
avl_node_t *avl_insert_node(avl_tree_t *tree, avl_node_t *node)
|
||||
avl_node_t *avl_insert_node(avl_tree_t * tree, avl_node_t * node)
|
||||
{
|
||||
avl_node_t *closest;
|
||||
int result;
|
||||
|
||||
if (!tree->root)
|
||||
if(!tree->root)
|
||||
avl_insert_top(tree, node);
|
||||
else
|
||||
{
|
||||
else {
|
||||
closest = avl_search_closest_node(tree, node->data, &result);
|
||||
switch(result)
|
||||
{
|
||||
|
||||
switch (result) {
|
||||
case -1:
|
||||
avl_insert_before(tree, closest, node);
|
||||
break;
|
||||
|
||||
case 1:
|
||||
avl_insert_after(tree, closest, node);
|
||||
break;
|
||||
|
||||
case 0:
|
||||
return NULL;
|
||||
}
|
||||
|
|
@ -478,15 +485,16 @@ avl_node_t *avl_insert_node(avl_tree_t *tree, avl_node_t *node)
|
|||
return node;
|
||||
}
|
||||
|
||||
void avl_insert_top(avl_tree_t *tree, avl_node_t *node)
|
||||
void avl_insert_top(avl_tree_t * tree, avl_node_t * node)
|
||||
{
|
||||
node->prev = node->next = node->parent = NULL;
|
||||
tree->head = tree->tail = tree->root = node;
|
||||
}
|
||||
|
||||
void avl_insert_before(avl_tree_t *tree, avl_node_t *before, avl_node_t *node)
|
||||
void avl_insert_before(avl_tree_t * tree, avl_node_t * before,
|
||||
avl_node_t * node)
|
||||
{
|
||||
if (!before)
|
||||
if(!before)
|
||||
return tree->tail ? avl_insert_after(tree, tree->tail, node) : avl_insert_top(tree, node);
|
||||
|
||||
node->next = before;
|
||||
|
|
@ -496,7 +504,7 @@ void avl_insert_before(avl_tree_t *tree, avl_node_t *before, avl_node_t *node)
|
|||
if(before->left)
|
||||
return avl_insert_after(tree, before->prev, node);
|
||||
|
||||
if (before->prev)
|
||||
if(before->prev)
|
||||
before->prev->next = node;
|
||||
else
|
||||
tree->head = node;
|
||||
|
|
@ -507,10 +515,12 @@ void avl_insert_before(avl_tree_t *tree, avl_node_t *before, avl_node_t *node)
|
|||
avl_rebalance(tree, before->parent);
|
||||
}
|
||||
|
||||
void avl_insert_after(avl_tree_t *tree, avl_node_t *after, avl_node_t *node)
|
||||
void avl_insert_after(avl_tree_t * tree, avl_node_t * after, avl_node_t * node)
|
||||
{
|
||||
if (!after)
|
||||
return tree->head ? avl_insert_before(tree, tree->head, node) : avl_insert_top(tree, node);
|
||||
if(!after)
|
||||
return tree->head ? avl_insert_before(tree, tree->head,
|
||||
node) : avl_insert_top(tree,
|
||||
node);
|
||||
|
||||
if(after->right)
|
||||
return avl_insert_before(tree, after->next, node);
|
||||
|
|
@ -519,7 +529,7 @@ void avl_insert_after(avl_tree_t *tree, avl_node_t *after, avl_node_t *node)
|
|||
node->parent = after;
|
||||
node->next = after->next;
|
||||
|
||||
if (after->next)
|
||||
if(after->next)
|
||||
after->next->prev = node;
|
||||
else
|
||||
tree->tail = node;
|
||||
|
|
@ -530,7 +540,7 @@ void avl_insert_after(avl_tree_t *tree, avl_node_t *after, avl_node_t *node)
|
|||
avl_rebalance(tree, after->parent);
|
||||
}
|
||||
|
||||
avl_node_t *avl_unlink(avl_tree_t *tree, void *data)
|
||||
avl_node_t *avl_unlink(avl_tree_t * tree, void *data)
|
||||
{
|
||||
avl_node_t *node;
|
||||
|
||||
|
|
@ -542,54 +552,57 @@ avl_node_t *avl_unlink(avl_tree_t *tree, void *data)
|
|||
return node;
|
||||
}
|
||||
|
||||
void avl_unlink_node(avl_tree_t *tree, avl_node_t *node)
|
||||
void avl_unlink_node(avl_tree_t * tree, avl_node_t * node)
|
||||
{
|
||||
avl_node_t *parent;
|
||||
avl_node_t **superparent;
|
||||
avl_node_t *subst, *left, *right;
|
||||
avl_node_t *balnode;
|
||||
|
||||
if (node->prev)
|
||||
if(node->prev)
|
||||
node->prev->next = node->next;
|
||||
else
|
||||
tree->head = node->next;
|
||||
if (node->next)
|
||||
if(node->next)
|
||||
node->next->prev = node->prev;
|
||||
else
|
||||
tree->tail = node->prev;
|
||||
|
||||
parent = node->parent;
|
||||
|
||||
superparent = parent ? node == parent->left ? &parent->left : &parent->right : &tree->root;
|
||||
superparent =
|
||||
parent ? node ==
|
||||
parent->left ? &parent->left : &parent->right : &tree->root;
|
||||
|
||||
left = node->left;
|
||||
right = node->right;
|
||||
if (!left)
|
||||
{
|
||||
if(!left) {
|
||||
*superparent = right;
|
||||
if (right)
|
||||
|
||||
if(right)
|
||||
right->parent = parent;
|
||||
|
||||
balnode = parent;
|
||||
} else if (!right)
|
||||
{
|
||||
} else if(!right) {
|
||||
*superparent = left;
|
||||
left->parent = parent;
|
||||
balnode = parent;
|
||||
} else
|
||||
{
|
||||
} else {
|
||||
subst = node->prev;
|
||||
if (subst == left)
|
||||
{
|
||||
|
||||
if(subst == left) {
|
||||
balnode = subst;
|
||||
} else
|
||||
{
|
||||
} else {
|
||||
balnode = subst->parent;
|
||||
balnode->right = subst->left;
|
||||
if (balnode->right)
|
||||
|
||||
if(balnode->right)
|
||||
balnode->right->parent = balnode;
|
||||
|
||||
subst->left = left;
|
||||
left->parent = subst;
|
||||
}
|
||||
|
||||
subst->right = right;
|
||||
subst->parent = parent;
|
||||
right->parent = subst;
|
||||
|
|
@ -608,30 +621,29 @@ void avl_unlink_node(avl_tree_t *tree, avl_node_t *node)
|
|||
#endif
|
||||
}
|
||||
|
||||
void avl_delete_node(avl_tree_t *tree, avl_node_t *node)
|
||||
void avl_delete_node(avl_tree_t * tree, avl_node_t * node)
|
||||
{
|
||||
avl_unlink_node(tree, node);
|
||||
avl_free_node(tree, node);
|
||||
}
|
||||
|
||||
void avl_delete(avl_tree_t *tree, void *data)
|
||||
void avl_delete(avl_tree_t * tree, void *data)
|
||||
{
|
||||
avl_node_t *node;
|
||||
|
||||
node = avl_search_node(tree, data);
|
||||
|
||||
if (node)
|
||||
if(node)
|
||||
avl_delete_node(tree, node);
|
||||
}
|
||||
|
||||
/* Fast tree cleanup */
|
||||
|
||||
void avl_delete_tree(avl_tree_t *tree)
|
||||
void avl_delete_tree(avl_tree_t * tree)
|
||||
{
|
||||
avl_node_t *node, *next;
|
||||
|
||||
for(node = tree->root; node; node = next)
|
||||
{
|
||||
for(node = tree->root; node; node = next) {
|
||||
next = node->next;
|
||||
avl_free_node(tree, node);
|
||||
}
|
||||
|
|
@ -641,23 +653,21 @@ void avl_delete_tree(avl_tree_t *tree)
|
|||
|
||||
/* Tree walking */
|
||||
|
||||
void avl_foreach(avl_tree_t *tree, avl_action_t action)
|
||||
void avl_foreach(avl_tree_t * tree, avl_action_t action)
|
||||
{
|
||||
avl_node_t *node, *next;
|
||||
|
||||
for(node = tree->head; node; node = next)
|
||||
{
|
||||
for(node = tree->head; node; node = next) {
|
||||
next = node->next;
|
||||
action(node->data);
|
||||
}
|
||||
}
|
||||
|
||||
void avl_foreach_node(avl_tree_t *tree, avl_action_t action)
|
||||
void avl_foreach_node(avl_tree_t * tree, avl_action_t action)
|
||||
{
|
||||
avl_node_t *node, *next;
|
||||
|
||||
for(node = tree->head; node; node = next)
|
||||
{
|
||||
for(node = tree->head; node; node = next) {
|
||||
next = node->next;
|
||||
action(node);
|
||||
}
|
||||
|
|
@ -666,31 +676,27 @@ void avl_foreach_node(avl_tree_t *tree, avl_action_t action)
|
|||
/* Indexing */
|
||||
|
||||
#ifdef AVL_COUNT
|
||||
unsigned int avl_count(avl_tree_t *tree)
|
||||
unsigned int avl_count(avl_tree_t * tree)
|
||||
{
|
||||
return AVL_NODE_COUNT(tree->root);
|
||||
}
|
||||
|
||||
avl_node_t *avl_get_node(const avl_tree_t *tree, unsigned int index)
|
||||
avl_node_t *avl_get_node(const avl_tree_t * tree, unsigned int index)
|
||||
{
|
||||
avl_node_t *node;
|
||||
unsigned int c;
|
||||
|
||||
node = tree->root;
|
||||
|
||||
while (node)
|
||||
{
|
||||
while(node) {
|
||||
c = AVL_L_COUNT(node);
|
||||
|
||||
if (index < c)
|
||||
{
|
||||
if(index < c) {
|
||||
node = node->left;
|
||||
} else if (index > c)
|
||||
{
|
||||
} else if(index > c) {
|
||||
node = node->right;
|
||||
index -= c + 1;
|
||||
} else
|
||||
{
|
||||
} else {
|
||||
return node;
|
||||
}
|
||||
}
|
||||
|
|
@ -698,16 +704,15 @@ avl_node_t *avl_get_node(const avl_tree_t *tree, unsigned int index)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
unsigned int avl_index(const avl_node_t *node)
|
||||
unsigned int avl_index(const avl_node_t * node)
|
||||
{
|
||||
avl_node_t *next;
|
||||
unsigned int index;
|
||||
|
||||
index = AVL_L_COUNT(node);
|
||||
|
||||
while ((next = node->parent))
|
||||
{
|
||||
if (node == next->right)
|
||||
while((next = node->parent)) {
|
||||
if(node == next->right)
|
||||
index += AVL_L_COUNT(next) + 1;
|
||||
node = next;
|
||||
}
|
||||
|
|
@ -716,7 +721,7 @@ unsigned int avl_index(const avl_node_t *node)
|
|||
}
|
||||
#endif
|
||||
#ifdef AVL_DEPTH
|
||||
unsigned int avl_depth(avl_tree_t *tree)
|
||||
unsigned int avl_depth(avl_tree_t * tree)
|
||||
{
|
||||
return AVL_NODE_DEPTH(tree->root);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@
|
|||
library for inclusion into tinc (http://tinc.nl.linux.org/) by
|
||||
Guus Sliepen <guus@sliepen.eu.org>.
|
||||
|
||||
$Id: avl_tree.h,v 1.1.2.5 2002/06/21 10:11:11 guus Exp $
|
||||
$Id: avl_tree.h,v 1.1.2.6 2002/09/09 21:49:16 guus Exp $
|
||||
*/
|
||||
|
||||
|
||||
|
|
@ -37,9 +37,9 @@
|
|||
#define __AVL_TREE_H__
|
||||
|
||||
#ifndef AVL_DEPTH
|
||||
#ifndef AVL_COUNT
|
||||
#define AVL_DEPTH
|
||||
#endif
|
||||
#ifndef AVL_COUNT
|
||||
#define AVL_DEPTH
|
||||
#endif
|
||||
#endif
|
||||
|
||||
typedef struct avl_node_t {
|
||||
|
|
@ -94,7 +94,7 @@ extern avl_tree_t *avl_alloc_tree(avl_compare_t, avl_action_t);
|
|||
extern void avl_free_tree(avl_tree_t *);
|
||||
|
||||
extern avl_node_t *avl_alloc_node(void);
|
||||
extern void avl_free_node(avl_tree_t *tree, avl_node_t *);
|
||||
extern void avl_free_node(avl_tree_t * tree, avl_node_t *);
|
||||
|
||||
/* Insertion and deletion */
|
||||
|
||||
|
|
@ -106,7 +106,7 @@ extern void avl_insert_before(avl_tree_t *, avl_node_t *, avl_node_t *);
|
|||
extern void avl_insert_after(avl_tree_t *, avl_node_t *, avl_node_t *);
|
||||
|
||||
extern avl_node_t *avl_unlink(avl_tree_t *, void *);
|
||||
extern void avl_unlink_node(avl_tree_t *tree, avl_node_t *);
|
||||
extern void avl_unlink_node(avl_tree_t * tree, avl_node_t *);
|
||||
extern void avl_delete(avl_tree_t *, void *);
|
||||
extern void avl_delete_node(avl_tree_t *, avl_node_t *);
|
||||
|
||||
|
|
|
|||
39
lib/dropin.c
39
lib/dropin.c
|
|
@ -17,7 +17,7 @@
|
|||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
|
||||
$Id: dropin.c,v 1.1.2.11 2002/07/12 11:45:21 guus Exp $
|
||||
$Id: dropin.c,v 1.1.2.12 2002/09/09 21:49:16 guus Exp $
|
||||
*/
|
||||
|
||||
#include "config.h"
|
||||
|
|
@ -57,8 +57,7 @@ int daemon(int nochdir, int noclose)
|
|||
pid = fork();
|
||||
|
||||
/* Check if forking failed */
|
||||
if(pid < 0)
|
||||
{
|
||||
if(pid < 0) {
|
||||
perror("fork");
|
||||
exit(-1);
|
||||
}
|
||||
|
|
@ -68,31 +67,25 @@ int daemon(int nochdir, int noclose)
|
|||
exit(0);
|
||||
|
||||
/* Detach by becoming the new process group leader */
|
||||
if(setsid() < 0)
|
||||
{
|
||||
if(setsid() < 0) {
|
||||
perror("setsid");
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Change working directory to the root (to avoid keeping mount
|
||||
points busy) */
|
||||
if(!nochdir)
|
||||
{
|
||||
if(!nochdir) {
|
||||
chdir("/");
|
||||
}
|
||||
|
||||
/* Redirect stdin/out/err to /dev/null */
|
||||
if(!noclose)
|
||||
{
|
||||
if(!noclose) {
|
||||
fd = open("/dev/null", O_RDWR);
|
||||
|
||||
if(fd < 0)
|
||||
{
|
||||
if(fd < 0) {
|
||||
perror("opening /dev/null");
|
||||
return -1;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
dup2(fd, 0);
|
||||
dup2(fd, 1);
|
||||
dup2(fd, 2);
|
||||
|
|
@ -103,9 +96,6 @@ int daemon(int nochdir, int noclose)
|
|||
}
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
#ifndef HAVE_GET_CURRENT_DIR_NAME
|
||||
/*
|
||||
Replacement for the GNU get_current_dir_name function:
|
||||
|
|
@ -127,10 +117,10 @@ char *get_current_dir_name(void)
|
|||
|
||||
errno = 0; /* Success */
|
||||
r = getcwd(buf, size);
|
||||
|
||||
/* getcwd returns NULL and sets errno to ERANGE if the bufferspace
|
||||
is insufficient to contain the entire working directory. */
|
||||
while(r == NULL && errno == ERANGE)
|
||||
{
|
||||
while(r == NULL && errno == ERANGE) {
|
||||
free(buf);
|
||||
size <<= 1; /* double the size */
|
||||
buf = xmalloc(size);
|
||||
|
|
@ -152,18 +142,17 @@ int asprintf(char **buf, const char *fmt, ...)
|
|||
*buf = xmalloc(len);
|
||||
|
||||
va_start(ap, fmt);
|
||||
status = vsnprintf (*buf, len, fmt, ap);
|
||||
va_end (ap);
|
||||
status = vsnprintf(*buf, len, fmt, ap);
|
||||
va_end(ap);
|
||||
|
||||
if(status >= 0)
|
||||
*buf = xrealloc(*buf, status);
|
||||
|
||||
if(status > len-1)
|
||||
{
|
||||
if(status > len - 1) {
|
||||
len = status;
|
||||
va_start(ap, fmt);
|
||||
status = vsnprintf (*buf, len, fmt, ap);
|
||||
va_end (ap);
|
||||
status = vsnprintf(*buf, len, fmt, ap);
|
||||
va_end(ap);
|
||||
}
|
||||
|
||||
return status;
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@
|
|||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
|
||||
$Id: dropin.h,v 1.1.2.8 2002/06/21 10:11:11 guus Exp $
|
||||
$Id: dropin.h,v 1.1.2.9 2002/09/09 21:49:16 guus Exp $
|
||||
*/
|
||||
|
||||
#ifndef __DROPIN_H__
|
||||
|
|
@ -28,7 +28,7 @@ extern int daemon(int, int);
|
|||
#endif
|
||||
|
||||
#ifndef HAVE_GET_CURRENT_DIR_NAME
|
||||
extern char* get_current_dir_name(void);
|
||||
extern char *get_current_dir_name(void);
|
||||
#endif
|
||||
|
||||
#ifndef HAVE_ASPRINTF
|
||||
|
|
|
|||
43
lib/list.c
43
lib/list.c
|
|
@ -17,7 +17,7 @@
|
|||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
|
||||
$Id: list.c,v 1.1.2.11 2002/06/21 10:11:11 guus Exp $
|
||||
$Id: list.c,v 1.1.2.12 2002/09/09 21:49:16 guus Exp $
|
||||
*/
|
||||
|
||||
#include "config.h"
|
||||
|
|
@ -41,21 +41,17 @@ list_t *list_alloc(list_action_t delete)
|
|||
return list;
|
||||
}
|
||||
|
||||
void list_free(list_t *list)
|
||||
void list_free(list_t * list)
|
||||
{
|
||||
free(list);
|
||||
}
|
||||
|
||||
list_node_t *list_alloc_node(void)
|
||||
{
|
||||
list_node_t *node;
|
||||
|
||||
node = xmalloc_and_zero(sizeof(list_node_t));
|
||||
|
||||
return node;
|
||||
return (list_node_t *)xmalloc_and_zero(sizeof(list_node_t));
|
||||
}
|
||||
|
||||
void list_free_node(list_t *list, list_node_t *node)
|
||||
void list_free_node(list_t * list, list_node_t * node)
|
||||
{
|
||||
if(node->data && list->delete)
|
||||
list->delete(node->data);
|
||||
|
|
@ -65,7 +61,7 @@ void list_free_node(list_t *list, list_node_t *node)
|
|||
|
||||
/* Insertion and deletion */
|
||||
|
||||
list_node_t *list_insert_head(list_t *list, void *data)
|
||||
list_node_t *list_insert_head(list_t * list, void *data)
|
||||
{
|
||||
list_node_t *node;
|
||||
|
||||
|
|
@ -86,7 +82,7 @@ list_node_t *list_insert_head(list_t *list, void *data)
|
|||
return node;
|
||||
}
|
||||
|
||||
list_node_t *list_insert_tail(list_t *list, void *data)
|
||||
list_node_t *list_insert_tail(list_t * list, void *data)
|
||||
{
|
||||
list_node_t *node;
|
||||
|
||||
|
|
@ -107,7 +103,7 @@ list_node_t *list_insert_tail(list_t *list, void *data)
|
|||
return node;
|
||||
}
|
||||
|
||||
void list_unlink_node(list_t *list, list_node_t *node)
|
||||
void list_unlink_node(list_t * list, list_node_t * node)
|
||||
{
|
||||
if(node->prev)
|
||||
node->prev->next = node->next;
|
||||
|
|
@ -122,25 +118,25 @@ void list_unlink_node(list_t *list, list_node_t *node)
|
|||
list->count--;
|
||||
}
|
||||
|
||||
void list_delete_node(list_t *list, list_node_t *node)
|
||||
void list_delete_node(list_t * list, list_node_t * node)
|
||||
{
|
||||
list_unlink_node(list, node);
|
||||
list_free_node(list, node);
|
||||
}
|
||||
|
||||
void list_delete_head(list_t *list)
|
||||
void list_delete_head(list_t * list)
|
||||
{
|
||||
list_delete_node(list, list->head);
|
||||
}
|
||||
|
||||
void list_delete_tail(list_t *list)
|
||||
void list_delete_tail(list_t * list)
|
||||
{
|
||||
list_delete_node(list, list->tail);
|
||||
}
|
||||
|
||||
/* Head/tail lookup */
|
||||
|
||||
void *list_get_head(list_t *list)
|
||||
void *list_get_head(list_t * list)
|
||||
{
|
||||
if(list->head)
|
||||
return list->head->data;
|
||||
|
|
@ -148,7 +144,7 @@ void *list_get_head(list_t *list)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
void *list_get_tail(list_t *list)
|
||||
void *list_get_tail(list_t * list)
|
||||
{
|
||||
if(list->tail)
|
||||
return list->tail->data;
|
||||
|
|
@ -158,12 +154,11 @@ void *list_get_tail(list_t *list)
|
|||
|
||||
/* Fast list deletion */
|
||||
|
||||
void list_delete_list(list_t *list)
|
||||
void list_delete_list(list_t * list)
|
||||
{
|
||||
list_node_t *node, *next;
|
||||
|
||||
for(node = list->head; node; node = next)
|
||||
{
|
||||
for(node = list->head; node; node = next) {
|
||||
next = node->next;
|
||||
list_free_node(list, node);
|
||||
}
|
||||
|
|
@ -173,23 +168,21 @@ void list_delete_list(list_t *list)
|
|||
|
||||
/* Traversing */
|
||||
|
||||
void list_foreach_node(list_t *list, list_action_node_t action)
|
||||
void list_foreach_node(list_t * list, list_action_node_t action)
|
||||
{
|
||||
list_node_t *node, *next;
|
||||
|
||||
for(node = list->head; node; node = next)
|
||||
{
|
||||
for(node = list->head; node; node = next) {
|
||||
next = node->next;
|
||||
action(node);
|
||||
}
|
||||
}
|
||||
|
||||
void list_foreach(list_t *list, list_action_t action)
|
||||
void list_foreach(list_t * list, list_action_t action)
|
||||
{
|
||||
list_node_t *node, *next;
|
||||
|
||||
for(node = list->head; node; node = next)
|
||||
{
|
||||
for(node = list->head; node; node = next) {
|
||||
next = node->next;
|
||||
if(node->data)
|
||||
action(node->data);
|
||||
|
|
|
|||
|
|
@ -17,14 +17,13 @@
|
|||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
|
||||
$Id: list.h,v 1.1.2.6 2002/06/21 10:11:11 guus Exp $
|
||||
$Id: list.h,v 1.1.2.7 2002/09/09 21:49:16 guus Exp $
|
||||
*/
|
||||
|
||||
#ifndef __TINC_LIST_H__
|
||||
#define __TINC_LIST_H__
|
||||
|
||||
typedef struct list_node_t
|
||||
{
|
||||
typedef struct list_node_t {
|
||||
struct list_node_t *prev;
|
||||
struct list_node_t *next;
|
||||
|
||||
|
|
@ -36,8 +35,7 @@ typedef struct list_node_t
|
|||
typedef void (*list_action_t) (const void *);
|
||||
typedef void (*list_action_node_t) (const list_node_t *);
|
||||
|
||||
typedef struct list_t
|
||||
{
|
||||
typedef struct list_t {
|
||||
list_node_t *head;
|
||||
list_node_t *tail;
|
||||
int count;
|
||||
|
|
|
|||
41
lib/utils.c
41
lib/utils.c
|
|
@ -48,17 +48,16 @@ int charhex2bin(char c)
|
|||
void hex2bin(char *src, char *dst, int length)
|
||||
{
|
||||
int i;
|
||||
for(i=0; i<length; i++)
|
||||
dst[i] = charhex2bin(src[i*2])*16 + charhex2bin(src[i*2+1]);
|
||||
for(i = 0; i < length; i++)
|
||||
dst[i] = charhex2bin(src[i * 2]) * 16 + charhex2bin(src[i * 2 + 1]);
|
||||
}
|
||||
|
||||
void bin2hex(char *src, char *dst, int length)
|
||||
{
|
||||
int i;
|
||||
for(i=length-1; i>=0; i--)
|
||||
{
|
||||
dst[i*2+1] = hexadecimals[(unsigned char)src[i] & 15];
|
||||
dst[i*2] = hexadecimals[(unsigned char)src[i]>>4];
|
||||
for(i = length - 1; i >= 0; i--) {
|
||||
dst[i * 2 + 1] = hexadecimals[(unsigned char) src[i] & 15];
|
||||
dst[i * 2] = hexadecimals[(unsigned char) src[i] >> 4];
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -66,21 +65,21 @@ void bin2hex(char *src, char *dst, int length)
|
|||
void cp_trace()
|
||||
{
|
||||
syslog(LOG_DEBUG, "Checkpoint trace: %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d...",
|
||||
cp_file[(cp_index+15)%16], cp_line[(cp_index+15)%16],
|
||||
cp_file[(cp_index+14)%16], cp_line[(cp_index+14)%16],
|
||||
cp_file[(cp_index+13)%16], cp_line[(cp_index+13)%16],
|
||||
cp_file[(cp_index+12)%16], cp_line[(cp_index+12)%16],
|
||||
cp_file[(cp_index+11)%16], cp_line[(cp_index+11)%16],
|
||||
cp_file[(cp_index+10)%16], cp_line[(cp_index+10)%16],
|
||||
cp_file[(cp_index+9)%16], cp_line[(cp_index+9)%16],
|
||||
cp_file[(cp_index+8)%16], cp_line[(cp_index+8)%16],
|
||||
cp_file[(cp_index+7)%16], cp_line[(cp_index+7)%16],
|
||||
cp_file[(cp_index+6)%16], cp_line[(cp_index+6)%16],
|
||||
cp_file[(cp_index+5)%16], cp_line[(cp_index+5)%16],
|
||||
cp_file[(cp_index+4)%16], cp_line[(cp_index+4)%16],
|
||||
cp_file[(cp_index+3)%16], cp_line[(cp_index+3)%16],
|
||||
cp_file[(cp_index+2)%16], cp_line[(cp_index+2)%16],
|
||||
cp_file[(cp_index+1)%16], cp_line[(cp_index+1)%16],
|
||||
cp_file[(cp_index + 15) % 16], cp_line[(cp_index + 15) % 16],
|
||||
cp_file[(cp_index + 14) % 16], cp_line[(cp_index + 14) % 16],
|
||||
cp_file[(cp_index + 13) % 16], cp_line[(cp_index + 13) % 16],
|
||||
cp_file[(cp_index + 12) % 16], cp_line[(cp_index + 12) % 16],
|
||||
cp_file[(cp_index + 11) % 16], cp_line[(cp_index + 11) % 16],
|
||||
cp_file[(cp_index + 10) % 16], cp_line[(cp_index + 10) % 16],
|
||||
cp_file[(cp_index + 9) % 16], cp_line[(cp_index + 9) % 16],
|
||||
cp_file[(cp_index + 8) % 16], cp_line[(cp_index + 8) % 16],
|
||||
cp_file[(cp_index + 7) % 16], cp_line[(cp_index + 7) % 16],
|
||||
cp_file[(cp_index + 6) % 16], cp_line[(cp_index + 6) % 16],
|
||||
cp_file[(cp_index + 5) % 16], cp_line[(cp_index + 5) % 16],
|
||||
cp_file[(cp_index + 4) % 16], cp_line[(cp_index + 4) % 16],
|
||||
cp_file[(cp_index + 3) % 16], cp_line[(cp_index + 3) % 16],
|
||||
cp_file[(cp_index + 2) % 16], cp_line[(cp_index + 2) % 16],
|
||||
cp_file[(cp_index + 1) % 16], cp_line[(cp_index + 1) % 16],
|
||||
cp_file[cp_index], cp_line[cp_index]
|
||||
);
|
||||
}
|
||||
|
|
|
|||
10
lib/utils.h
10
lib/utils.h
|
|
@ -46,12 +46,12 @@ extern volatile char *cp_file[];
|
|||
extern volatile int cp_index;
|
||||
extern void cp_trace(void);
|
||||
|
||||
#define cp() { cp_line[cp_index] = __LINE__; cp_file[cp_index] = __FILE__; cp_index++; cp_index %= 16; }
|
||||
#define ecp() { fprintf(stderr, "Explicit checkpoint in %s line %d\n", __FILE__, __LINE__); }
|
||||
#define cp() { cp_line[cp_index] = __LINE__; cp_file[cp_index] = __FILE__; cp_index++; cp_index %= 16; }
|
||||
#define ecp() { fprintf(stderr, "Explicit checkpoint in %s line %d\n", __FILE__, __LINE__); }
|
||||
#else
|
||||
#define cp()
|
||||
#define ecp()
|
||||
#define cp_trace()
|
||||
#define cp()
|
||||
#define ecp()
|
||||
#define cp_trace()
|
||||
#endif
|
||||
|
||||
extern void hex2bin(char *src, char *dst, int length);
|
||||
|
|
|
|||
Loading…
Reference in a new issue