Commit e36d1e31 authored by Ondřej Kuzník's avatar Ondřej Kuzník
Browse files

ITS#9001 manual changes

parent 51c444b0
......@@ -71,7 +71,7 @@ authzid_conn_find( Connection *c )
authzid_conn_t *ac = NULL, tmp = { 0 };
tmp.conn = c;
ac = (authzid_conn_t *)avl_find( authzid_tree, (caddr_t)&tmp, authzid_conn_cmp );
ac = (authzid_conn_t *)ldap_avl_find( authzid_tree, (caddr_t)&tmp, authzid_conn_cmp );
if ( ac == NULL || ( ac != NULL && ac->refcnt != 0 ) ) {
ac = NULL;
}
......@@ -121,7 +121,7 @@ authzid_conn_insert( Connection *c, char flag )
ac->conn = c;
ac->refcnt = 0;
ac->authzid_flag = flag;
rc = avl_insert( &authzid_tree, (caddr_t)ac,
rc = ldap_avl_insert( &authzid_tree, (caddr_t)ac,
authzid_conn_cmp, authzid_conn_dup );
ldap_pvt_thread_mutex_unlock( &authzid_mutex );
......@@ -139,7 +139,7 @@ authzid_conn_remove( Connection *c )
ldap_pvt_thread_mutex_unlock( &authzid_mutex );
return -1;
}
tmp = avl_delete( &authzid_tree, (caddr_t)ac, authzid_conn_cmp );
tmp = ldap_avl_delete( &authzid_tree, (caddr_t)ac, authzid_conn_cmp );
ldap_pvt_thread_mutex_unlock( &authzid_mutex );
assert( tmp == ac );
......
......@@ -281,7 +281,7 @@ vc_exop(
AC_MEMCPY( (char *)&tmp.conn, (const char *)cookie.bv_val, cookie.bv_len );
ldap_pvt_thread_mutex_lock( &vc_mutex );
conn = (vc_conn_t *)avl_find( vc_tree, (caddr_t)&tmp, vc_conn_cmp );
conn = (vc_conn_t *)ldap_avl_find( vc_tree, (caddr_t)&tmp, vc_conn_cmp );
if ( conn == NULL || ( conn != NULL && conn->refcnt != 0 ) ) {
conn = NULL;
ldap_pvt_thread_mutex_unlock( &vc_mutex );
......@@ -376,7 +376,7 @@ done:;
conn->conn = conn;
conn->refcnt--;
ldap_pvt_thread_mutex_lock( &vc_mutex );
rc = avl_insert( &vc_tree, (caddr_t)conn,
rc = ldap_avl_insert( &vc_tree, (caddr_t)conn,
vc_conn_cmp, vc_conn_dup );
ldap_pvt_thread_mutex_unlock( &vc_mutex );
assert( rc == 0 );
......@@ -392,7 +392,7 @@ done:;
vc_conn_t *tmp;
ldap_pvt_thread_mutex_lock( &vc_mutex );
tmp = avl_delete( &vc_tree, (caddr_t)conn, vc_conn_cmp );
tmp = ldap_avl_delete( &vc_tree, (caddr_t)conn, vc_conn_cmp );
ldap_pvt_thread_mutex_unlock( &vc_mutex );
}
SLAP_FREE( conn );
......
/* avl.h - avl tree definitions */
/* ldap_avl.h - avl tree definitions */
/* $OpenLDAP$ */
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
*
......@@ -73,15 +73,15 @@ struct tavlnode {
#define AVL_THREAD 1
/* avl routines */
#define avl_getone(x) ((x) == 0 ? 0 : (x)->avl_data)
#define avl_onenode(x) ((x) == 0 || ((x)->avl_left == 0 && (x)->avl_right == 0))
#define ldap_avl_getone(x) ((x) == 0 ? 0 : (x)->avl_data)
#define ldap_avl_onenode(x) ((x) == 0 || ((x)->avl_left == 0 && (x)->avl_right == 0))
#endif /* AVL_INTERNALS */
#define avl_child(x,dir) ((x)->avl_bits[dir]) == AVL_CHILD ? \
#define ldap_avl_child(x,dir) ((x)->avl_bits[dir]) == AVL_CHILD ? \
(x)->avl_link[dir] : NULL
#define avl_lchild(x) avl_child(x,0)
#define avl_rchild(x) avl_child(x,1)
#define ldap_avl_lchild(x) ldap_avl_child(x,0)
#define ldap_avl_rchild(x) ldap_avl_child(x,1)
typedef int (*AVL_APPLY) LDAP_P((void *, void*));
typedef int (*AVL_CMP) LDAP_P((const void*, const void*));
......@@ -89,69 +89,69 @@ typedef int (*AVL_DUP) LDAP_P((void*, void*));
typedef void (*AVL_FREE) LDAP_P((void*));
LDAP_AVL_F( int )
avl_free LDAP_P(( Avlnode *root, AVL_FREE dfree ));
ldap_avl_free LDAP_P(( Avlnode *root, AVL_FREE dfree ));
LDAP_AVL_F( int )
avl_insert LDAP_P((Avlnode **, void*, AVL_CMP, AVL_DUP));
ldap_avl_insert LDAP_P((Avlnode **, void*, AVL_CMP, AVL_DUP));
LDAP_AVL_F( void* )
avl_delete LDAP_P((Avlnode **, void*, AVL_CMP));
ldap_avl_delete LDAP_P((Avlnode **, void*, AVL_CMP));
LDAP_AVL_F( void* )
avl_find LDAP_P((Avlnode *, const void*, AVL_CMP));
ldap_avl_find LDAP_P((Avlnode *, const void*, AVL_CMP));
LDAP_AVL_F( Avlnode* )
avl_find2 LDAP_P((Avlnode *, const void*, AVL_CMP));
ldap_avl_find2 LDAP_P((Avlnode *, const void*, AVL_CMP));
LDAP_AVL_F( void* )
avl_find_lin LDAP_P((Avlnode *, const void*, AVL_CMP));
ldap_avl_find_lin LDAP_P((Avlnode *, const void*, AVL_CMP));
#ifdef AVL_NONREENTRANT
LDAP_AVL_F( void* )
avl_getfirst LDAP_P((Avlnode *));
ldap_avl_getfirst LDAP_P((Avlnode *));
LDAP_AVL_F( void* )
avl_getnext LDAP_P((void));
ldap_avl_getnext LDAP_P((void));
#endif
LDAP_AVL_F( int )
avl_dup_error LDAP_P((void*, void*));
ldap_avl_dup_error LDAP_P((void*, void*));
LDAP_AVL_F( int )
avl_dup_ok LDAP_P((void*, void*));
ldap_avl_dup_ok LDAP_P((void*, void*));
LDAP_AVL_F( int )
avl_apply LDAP_P((Avlnode *, AVL_APPLY, void*, int, int));
ldap_avl_apply LDAP_P((Avlnode *, AVL_APPLY, void*, int, int));
LDAP_AVL_F( int )
avl_prefixapply LDAP_P((Avlnode *, void*, AVL_CMP, void*, AVL_CMP, void*, int));
ldap_avl_prefixapply LDAP_P((Avlnode *, void*, AVL_CMP, void*, AVL_CMP, void*, int));
LDAP_AVL_F( int )
tavl_free LDAP_P(( TAvlnode *root, AVL_FREE dfree ));
ldap_tavl_free LDAP_P(( TAvlnode *root, AVL_FREE dfree ));
LDAP_AVL_F( int )
tavl_insert LDAP_P((TAvlnode **, void*, AVL_CMP, AVL_DUP));
ldap_tavl_insert LDAP_P((TAvlnode **, void*, AVL_CMP, AVL_DUP));
LDAP_AVL_F( void* )
tavl_delete LDAP_P((TAvlnode **, void*, AVL_CMP));
ldap_tavl_delete LDAP_P((TAvlnode **, void*, AVL_CMP));
LDAP_AVL_F( void* )
tavl_find LDAP_P((TAvlnode *, const void*, AVL_CMP));
ldap_tavl_find LDAP_P((TAvlnode *, const void*, AVL_CMP));
LDAP_AVL_F( TAvlnode* )
tavl_find2 LDAP_P((TAvlnode *, const void*, AVL_CMP));
ldap_tavl_find2 LDAP_P((TAvlnode *, const void*, AVL_CMP));
LDAP_AVL_F( TAvlnode* )
tavl_find3 LDAP_P((TAvlnode *, const void*, AVL_CMP, int *ret));
ldap_tavl_find3 LDAP_P((TAvlnode *, const void*, AVL_CMP, int *ret));
#define TAVL_DIR_LEFT 0
#define TAVL_DIR_RIGHT 1
LDAP_AVL_F( TAvlnode* )
tavl_end LDAP_P((TAvlnode *, int direction));
ldap_tavl_end LDAP_P((TAvlnode *, int direction));
LDAP_AVL_F( TAvlnode* )
tavl_next LDAP_P((TAvlnode *, int direction));
ldap_tavl_next LDAP_P((TAvlnode *, int direction));
/* apply traversal types */
#define AVL_PREORDER 1
......
......@@ -15,7 +15,7 @@
LIBRARY = libldap.la
PROGRAMS = apitest dntest ftest ltest urltest
PROGRAMS = apitest dntest ftest ltest urltest testavl
SRCS = bind.c open.c result.c error.c compare.c search.c \
controls.c messages.c references.c extended.c cyrus.c \
......@@ -31,7 +31,7 @@ SRCS = bind.c open.c result.c error.c compare.c search.c \
assertion.c deref.c ldifutil.c ldif.c fetch.c lbase64.c \
msctrl.c psearchctrl.c threads.c rdwr.c tpool.c rq.c \
thr_posix.c thr_thr.c thr_nt.c thr_pth.c thr_debug.c \
account_usability.c
account_usability.c avl.c tavl.c testavl.c
OBJS = bind.lo open.lo result.lo error.lo compare.lo search.lo \
controls.lo messages.lo references.lo extended.lo cyrus.lo \
......@@ -47,7 +47,7 @@ OBJS = bind.lo open.lo result.lo error.lo compare.lo search.lo \
assertion.lo deref.lo ldifutil.lo ldif.lo fetch.lo lbase64.lo \
msctrl.lo psearchctrl.lo threads.lo rdwr.lo tpool.lo rq.lo \
thr_posix.lo thr_thr.lo thr_nt.lo thr_pth.lo thr_debug.lo \
account_usability.lo
account_usability.lo avl.lo tavl.lo
LDAP_INCDIR= ../../include
LDAP_LIBDIR= ../../libraries
......@@ -70,9 +70,14 @@ ftest: $(XLIBS) ftest.o
$(LTLINK) -o $@ ftest.o $(LIBS)
ltest: $(XLIBS) test.o
$(LTLINK) -o $@ test.o $(LIBS)
testavl: $(XLIBS) testavl.o
$(LTLINK) -o $@ testavl.o $(LIBS)
testtavl: $(XLIBS) testtavl.o
$(LTLINK) -o $@ testtavl.o $(LIBS)
urltest: $(XLIBS) urltest.o
$(LTLINK) -o $@ urltest.o $(LIBS)
CFFILES=ldap.conf
install-local: $(CFFILES) FORCE
......
......@@ -2,7 +2,7 @@
/* $OpenLDAP$ */
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
*
* Copyright 1998-2021 The OpenLDAP Foundation.
* Copyright 1998-2020 The OpenLDAP Foundation.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
......@@ -47,7 +47,7 @@
#endif
#define AVL_INTERNAL
#include "avl.h"
#include "ldap_avl.h"
/* Maximum tree depth this host's address space could support */
#define MAX_TREE_DEPTH (sizeof(void *) * CHAR_BIT)
......@@ -55,13 +55,13 @@
static const int avl_bfs[] = {LH, RH};
/*
* avl_insert -- insert a node containing data data into the avl tree
* ldap_avl_insert -- insert a node containing data data into the avl tree
* with root root. fcmp is a function to call to compare the data portion
* of two nodes. it should take two arguments and return <, >, or == 0,
* depending on whether its first argument is <, >, or == its second
* argument (like strcmp, e.g.). fdup is a function to call when a duplicate
* node is inserted. it should return 0, or -1 and its return value
* will be the return value from avl_insert in the case of a duplicate node.
* will be the return value from ldap_avl_insert in the case of a duplicate node.
* the function will be called with the original node's data as its first
* argument and with the incoming duplicate node's data as its second
* argument. this could be used, for example, to keep a count with each
......@@ -70,7 +70,7 @@ static const int avl_bfs[] = {LH, RH};
* NOTE: this routine may malloc memory
*/
int
avl_insert( Avlnode ** root, void *data, AVL_CMP fcmp, AVL_DUP fdup )
ldap_avl_insert( Avlnode ** root, void *data, AVL_CMP fcmp, AVL_DUP fdup )
{
Avlnode *t, *p, *s, *q, *r;
int a, cmp, ncmp;
......@@ -180,7 +180,7 @@ avl_insert( Avlnode ** root, void *data, AVL_CMP fcmp, AVL_DUP fdup )
}
void*
avl_delete( Avlnode **root, void* data, AVL_CMP fcmp )
ldap_avl_delete( Avlnode **root, void* data, AVL_CMP fcmp )
{
Avlnode *p, *q, *r, *top;
int side, side_bf, shorter, nside;
......@@ -207,7 +207,7 @@ avl_delete( Avlnode **root, void* data, AVL_CMP fcmp )
if ( p == NULL )
return p;
}
data = p->avl_data;
data = p->avl_data;
/* If this node has two children, swap so we are deleting a node with
* at most one child.
......@@ -268,7 +268,7 @@ avl_delete( Avlnode **root, void* data, AVL_CMP fcmp )
top = NULL;
shorter = 1;
while ( shorter ) {
p = pptr[depth];
side = pdir[depth];
......@@ -280,7 +280,7 @@ avl_delete( Avlnode **root, void* data, AVL_CMP fcmp )
/* Tree is now heavier on opposite side */
p->avl_bf = avl_bfs[nside];
shorter = 0;
} else if ( p->avl_bf == side_bf ) {
/* case 2: taller subtree shortened, height reduced */
p->avl_bf = EH;
......@@ -358,7 +358,7 @@ avl_inapply( Avlnode *root, AVL_APPLY fn, void* arg, int stopflag )
return( AVL_NOMORE );
if ( root->avl_left != 0 )
if ( avl_inapply( root->avl_left, fn, arg, stopflag )
if ( avl_inapply( root->avl_left, fn, arg, stopflag )
== stopflag )
return( stopflag );
......@@ -378,12 +378,12 @@ avl_postapply( Avlnode *root, AVL_APPLY fn, void* arg, int stopflag )
return( AVL_NOMORE );
if ( root->avl_left != 0 )
if ( avl_postapply( root->avl_left, fn, arg, stopflag )
if ( avl_postapply( root->avl_left, fn, arg, stopflag )
== stopflag )
return( stopflag );
if ( root->avl_right != 0 )
if ( avl_postapply( root->avl_right, fn, arg, stopflag )
if ( avl_postapply( root->avl_right, fn, arg, stopflag )
== stopflag )
return( stopflag );
......@@ -400,7 +400,7 @@ avl_preapply( Avlnode *root, AVL_APPLY fn, void* arg, int stopflag )
return( stopflag );
if ( root->avl_left != 0 )
if ( avl_preapply( root->avl_left, fn, arg, stopflag )
if ( avl_preapply( root->avl_left, fn, arg, stopflag )
== stopflag )
return( stopflag );
......@@ -411,7 +411,7 @@ avl_preapply( Avlnode *root, AVL_APPLY fn, void* arg, int stopflag )
}
/*
* avl_apply -- avl tree root is traversed, function fn is called with
* ldap_avl_apply -- avl tree root is traversed, function fn is called with
* arguments arg and the data portion of each node. if fn returns stopflag,
* the traversal is cut short, otherwise it continues. Do not use -6 as
* a stopflag, as this is what is used to indicate the traversal ran out
......@@ -419,7 +419,7 @@ avl_preapply( Avlnode *root, AVL_APPLY fn, void* arg, int stopflag )
*/
int
avl_apply( Avlnode *root, AVL_APPLY fn, void* arg, int stopflag, int type )
ldap_avl_apply( Avlnode *root, AVL_APPLY fn, void* arg, int stopflag, int type )
{
switch ( type ) {
case AVL_INORDER:
......@@ -437,18 +437,18 @@ avl_apply( Avlnode *root, AVL_APPLY fn, void* arg, int stopflag, int type )
}
/*
* avl_prefixapply - traverse avl tree root, applying function fprefix
* ldap_avl_prefixapply - traverse avl tree root, applying function fprefix
* to any nodes that match. fcmp is called with data as its first arg
* and the current node's data as its second arg. it should return
* 0 if they match, < 0 if data is less, and > 0 if data is greater.
* the idea is to efficiently find all nodes that are prefixes of
* some key... Like avl_apply, this routine also takes a stopflag
* some key... Like ldap_avl_apply, this routine also takes a stopflag
* and will return prematurely if fmatch returns this value. Otherwise,
* AVL_NOMORE is returned.
*/
int
avl_prefixapply(
ldap_avl_prefixapply(
Avlnode *root,
void* data,
AVL_CMP fmatch,
......@@ -469,23 +469,23 @@ avl_prefixapply(
return( stopflag );
if ( root->avl_left != 0 )
if ( avl_prefixapply( root->avl_left, data, fmatch,
if ( ldap_avl_prefixapply( root->avl_left, data, fmatch,
marg, fcmp, carg, stopflag ) == stopflag )
return( stopflag );
if ( root->avl_right != 0 )
return( avl_prefixapply( root->avl_right, data, fmatch,
return( ldap_avl_prefixapply( root->avl_right, data, fmatch,
marg, fcmp, carg, stopflag ) );
else
return( AVL_NOMORE );
} else if ( cmp < 0 ) {
if ( root->avl_left != 0 )
return( avl_prefixapply( root->avl_left, data, fmatch,
return( ldap_avl_prefixapply( root->avl_left, data, fmatch,
marg, fcmp, carg, stopflag ) );
} else {
if ( root->avl_right != 0 )
return( avl_prefixapply( root->avl_right, data, fmatch,
return( ldap_avl_prefixapply( root->avl_right, data, fmatch,
marg, fcmp, carg, stopflag ) );
}
......@@ -493,13 +493,13 @@ avl_prefixapply(
}
/*
* avl_free -- traverse avltree root, freeing the memory it is using.
* ldap_avl_free -- traverse avltree root, freeing the memory it is using.
* the dfree() is called to free the data portion of each node. The
* number of items actually freed is returned.
*/
int
avl_free( Avlnode *root, AVL_FREE dfree )
ldap_avl_free( Avlnode *root, AVL_FREE dfree )
{
int nleft, nright;
......@@ -508,10 +508,10 @@ avl_free( Avlnode *root, AVL_FREE dfree )
nleft = nright = 0;
if ( root->avl_left != 0 )
nleft = avl_free( root->avl_left, dfree );
nleft = ldap_avl_free( root->avl_left, dfree );
if ( root->avl_right != 0 )
nright = avl_free( root->avl_right, dfree );
nright = ldap_avl_free( root->avl_right, dfree );
if ( dfree )
(*dfree)( root->avl_data );
......@@ -521,14 +521,14 @@ avl_free( Avlnode *root, AVL_FREE dfree )
}
/*
* avl_find -- search avltree root for a node with data data. the function
* cmp is used to compare things. it is called with data as its first arg
* ldap_avl_find -- search avltree root for a node with data data. the function
* cmp is used to compare things. it is called with data as its first arg
* and the current node data as its second. it should return 0 if they match,
* < 0 if arg1 is less than arg2 and > 0 if arg1 is greater than arg2.
*/
Avlnode *
avl_find2( Avlnode *root, const void *data, AVL_CMP fcmp )
ldap_avl_find2( Avlnode *root, const void *data, AVL_CMP fcmp )
{
int cmp;
......@@ -540,7 +540,7 @@ avl_find2( Avlnode *root, const void *data, AVL_CMP fcmp )
}
void*
avl_find( Avlnode *root, const void* data, AVL_CMP fcmp )
ldap_avl_find( Avlnode *root, const void* data, AVL_CMP fcmp )
{
int cmp;
......@@ -553,14 +553,14 @@ avl_find( Avlnode *root, const void* data, AVL_CMP fcmp )
}
/*
* avl_find_lin -- search avltree root linearly for a node with data data.
* ldap_avl_find_lin -- search avltree root linearly for a node with data data.
* the function cmp is used to compare things. it is called with data as its
* first arg and the current node data as its second. it should return 0 if
* they match, non-zero otherwise.
*/
void*
avl_find_lin( Avlnode *root, const void* data, AVL_CMP fcmp )
ldap_avl_find_lin( Avlnode *root, const void* data, AVL_CMP fcmp )
{
void* res;
......@@ -571,21 +571,21 @@ avl_find_lin( Avlnode *root, const void* data, AVL_CMP fcmp )
return( root->avl_data );
if ( root->avl_left != 0 )
if ( (res = avl_find_lin( root->avl_left, data, fcmp ))
if ( (res = ldap_avl_find_lin( root->avl_left, data, fcmp ))
!= NULL )
return( res );
if ( root->avl_right == 0 )
return( NULL );
else
return( avl_find_lin( root->avl_right, data, fcmp ) );
return( ldap_avl_find_lin( root->avl_right, data, fcmp ) );
}
/* NON-REENTRANT INTERFACE */
static void* *avl_list;
static int avl_maxlist;
static int avl_nextlist;
static int ldap_avl_nextlist;
#define AVL_GRABSIZE 100
......@@ -611,61 +611,61 @@ avl_buildlist( void* data, void* arg )
}
/*
* avl_getfirst() and avl_getnext() are provided as alternate tree
* ldap_avl_getfirst() and ldap_avl_getnext() are provided as alternate tree
* traversal methods, to be used when a single function cannot be
* provided to be called with every node in the tree. avl_getfirst()
* provided to be called with every node in the tree. ldap_avl_getfirst()
* traverses the tree and builds a linear list of all the nodes,
* returning the first node. avl_getnext() returns the next thing
* on the list built by avl_getfirst(). This means that avl_getfirst()
* returning the first node. ldap_avl_getnext() returns the next thing
* on the list built by ldap_avl_getfirst(). This means that ldap_avl_getfirst()
* can take a while, and that the tree should not be messed with while
* being traversed in this way, and that multiple traversals (even of
* different trees) cannot be active at once.
*/
void*
avl_getfirst( Avlnode *root )
ldap_avl_getfirst( Avlnode *root )
{
if ( avl_list ) {
ber_memfree( (char *) avl_list);
avl_list = (void* *) 0;
}
avl_maxlist = 0;
avl_nextlist = 0;
ldap_avl_nextlist = 0;
if ( root == 0 )
return( 0 );
(void) avl_apply( root, avl_buildlist, (void*) 0, -1, AVL_INORDER );
(void) ldap_avl_apply( root, avl_buildlist, (void*) 0, -1, AVL_INORDER );
return( avl_list[ avl_nextlist++ ] );
return( avl_list[ ldap_avl_nextlist++ ] );
}
void*
avl_getnext( void )
ldap_avl_getnext( void )
{
if ( avl_list == 0 )
return( 0 );
if ( avl_nextlist == avl_maxlist ) {
if ( ldap_avl_nextlist == avl_maxlist ) {
ber_memfree( (void*) avl_list);
avl_list = (void* *) 0;
return( 0 );
}
return( avl_list[ avl_nextlist++ ] );
return( avl_list[ ldap_avl_nextlist++ ] );
}
/* end non-reentrant code */
int
avl_dup_error( void* left, void* right )
ldap_avl_dup_error( void* left, void* right )
{
return( -1 );
}
int
avl_dup_ok( void* left, void* right )
ldap_avl_dup_ok( void* left, void* right )
{
return( 0 );
}
......@@ -2,7 +2,7 @@
/* $OpenLDAP$ */
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
*
* Copyright 2005-2021 The OpenLDAP Foundation.
* Copyright 2005-2020 The OpenLDAP Foundation.
* Portions Copyright (c) 2005 by Howard Chu, Symas Corp.
* All rights reserved.
*
......@@ -34,7 +34,7 @@
#endif
#define AVL_INTERNAL
#include "avl.h"
#include "ldap_avl.h"
/* Maximum tree depth this host's address space could support */
#define MAX_TREE_DEPTH (sizeof(void *) * CHAR_BIT)
......@@ -45,13 +45,13 @@ static const int avl_bfs[] = {LH, RH};
* Threaded AVL trees - for fast in-order traversal of nodes.
*/
/*
* tavl_insert -- insert a node containing data data into the avl tree
* ldap_tavl_insert -- insert a node containing data data into the avl tree
* with root root. fcmp is a function to call to compare the data portion
* of two nodes. it should take two arguments and return <, >, or == 0,
* depending on whether its first argument is <, >, or == its second
* argument (like strcmp, e.g.). fdup is a function to call when a duplicate
* node is inserted. it should return 0, or -1 and its return value
* will be the return value from avl_insert in the case of a duplicate node.
* will be the return value from ldap_avl_insert in the case of a duplicate node.
* the function will be called with the original node's data as its first
* argument and with the incoming duplicate node's data as its second
* argument. this could be used, for example, to keep a count with each
......@@ -60,7 +60,7 @@ static const int avl_bfs[] = {LH, RH};
* NOTE: this routine may malloc memory
*/
int
tavl_insert( TAvlnode ** root, void *data, AVL_CMP fcmp, AVL_DUP fdup )
ldap_tavl_insert( TAvlnode ** root, void *data, AVL_CMP fcmp, AVL_DUP fdup )
{
TAvlnode *t, *p, *s, *q, *r;
int a, cmp, ncmp;
......@@ -88,7 +88,7 @@ tavl_insert( TAvlnode ** root, void *data, AVL_CMP fcmp, AVL_DUP fdup )
return (*fdup)( p->avl_data, data );
cmp = (cmp > 0);
q = avl_child( p, cmp );
q = ldap_avl_child( p, cmp );
if (q == NULL) {
/* insert */
if (( q = (TAvlnode *) ber_memalloc( sizeof( TAvlnode ))) == NULL ) {
......@@ -187,7 +187,7 @@ tavl_insert( TAvlnode ** root, void *data, AVL_CMP fcmp, AVL_DUP fdup )
}
void*
tavl_delete( TAvlnode **root, void* data, AVL_CMP fcmp )
ldap_tavl_delete( TAvlnode **root, void* data, AVL_CMP fcmp )
{
TAvlnode *p, *q, *r, *top;
int side, side_bf, shorter, nside = -1;
......@@ -214,7 +214,7 @@ tavl_delete( TAvlnode **root, void* data, AVL_CMP fcmp )
return NULL;
p = p->avl_link[side];
}
data = p->avl_data;
data = p->avl_data;
/* If this node has two children, swap so we are deleting a node with
* at most one child.
......@@ -313,7 +313,7 @@ tavl_delete( TAvlnode **root, void* data, AVL_CMP fcmp )
top = NULL;
shorter = 1;
while ( shorter ) {