upstream/openldap
1
0
Fork 0
mirror of https://git.openldap.org/openldap/openldap.git synced 2025-12-21 07:09:34 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

ITS#8625 Separate Avlnode and TAvlnode types

Browse source 
Switch AVL_CHILD/AVL_THREAD values and set Avlnode bits to AVL_CHILD for
better compatibility between avl and tavl as suggested by Howard.
This commit is contained in:
Ondřej Kuzník 2017-03-28 15:32:27 +01:00 committed by Howard Chu
parent a0cc1d9655
commit e56a849e5d
9 changed files with 64 additions and 55 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

39
include/avl.h
View file

@ -50,9 +50,16 @@ struct avlnode {
#define avl_lbit avl_bits[0] #define avl_lbit avl_bits[0]
#define avl_rbit avl_bits[1] #define avl_rbit avl_bits[1]
#ifdef AVL_INTERNAL typedef struct tavlnode TAvlnode;
#define NULLAVL ((Avlnode *) NULL) struct tavlnode {
void* avl_data;
struct tavlnode *avl_link[2];
char avl_bits[2];
signed char avl_bf;
};
#ifdef AVL_INTERNAL
/* balance factor values */ /* balance factor values */
#define LH (-1) #define LH (-1)
@ -62,8 +69,8 @@ struct avlnode {
#define avl_bf2str(bf) ((bf) == -1 ? "LH" : (bf) == 0 ? "EH" : (bf) == 1 ? "RH" : "(unknown)" ) #define avl_bf2str(bf) ((bf) == -1 ? "LH" : (bf) == 0 ? "EH" : (bf) == 1 ? "RH" : "(unknown)" )
/* thread bits */ /* thread bits */
#define AVL_THREAD 0 #define AVL_CHILD 0
#define AVL_CHILD 1 #define AVL_THREAD 1
/* avl routines */ /* avl routines */
#define avl_getone(x) ((x) == 0 ? 0 : (x)->avl_data) #define avl_getone(x) ((x) == 0 ? 0 : (x)->avl_data)
@ -120,31 +127,31 @@ LDAP_AVL_F( int )
avl_prefixapply LDAP_P((Avlnode *, void*, AVL_CMP, void*, AVL_CMP, void*, int)); avl_prefixapply LDAP_P((Avlnode *, void*, AVL_CMP, void*, AVL_CMP, void*, int));
LDAP_AVL_F( int ) LDAP_AVL_F( int )
tavl_free LDAP_P(( Avlnode *root, AVL_FREE dfree )); tavl_free LDAP_P(( TAvlnode *root, AVL_FREE dfree ));
LDAP_AVL_F( int ) LDAP_AVL_F( int )
tavl_insert LDAP_P((Avlnode **, void*, AVL_CMP, AVL_DUP)); tavl_insert LDAP_P((TAvlnode **, void*, AVL_CMP, AVL_DUP));
LDAP_AVL_F( void* ) LDAP_AVL_F( void* )
tavl_delete LDAP_P((Avlnode **, void*, AVL_CMP)); tavl_delete LDAP_P((TAvlnode **, void*, AVL_CMP));
LDAP_AVL_F( void* ) LDAP_AVL_F( void* )
tavl_find LDAP_P((Avlnode *, const void*, AVL_CMP)); tavl_find LDAP_P((TAvlnode *, const void*, AVL_CMP));
LDAP_AVL_F( Avlnode* ) LDAP_AVL_F( TAvlnode* )
tavl_find2 LDAP_P((Avlnode *, const void*, AVL_CMP)); tavl_find2 LDAP_P((TAvlnode *, const void*, AVL_CMP));
LDAP_AVL_F( Avlnode* ) LDAP_AVL_F( TAvlnode* )
tavl_find3 LDAP_P((Avlnode *, const void*, AVL_CMP, int *ret)); tavl_find3 LDAP_P((TAvlnode *, const void*, AVL_CMP, int *ret));
#define TAVL_DIR_LEFT 0 #define TAVL_DIR_LEFT 0
#define TAVL_DIR_RIGHT 1 #define TAVL_DIR_RIGHT 1
LDAP_AVL_F( Avlnode* ) LDAP_AVL_F( TAvlnode* )
tavl_end LDAP_P((Avlnode *, int direction )); tavl_end LDAP_P((TAvlnode *, int direction));
LDAP_AVL_F( Avlnode* ) LDAP_AVL_F( TAvlnode* )
tavl_next LDAP_P((Avlnode *, int direction )); tavl_next LDAP_P((TAvlnode *, int direction));
/* apply traversal types */ /* apply traversal types */
#define AVL_PREORDER 1 #define AVL_PREORDER 1

2
libraries/liblutil/avl.c
View file

@ -81,6 +81,7 @@ avl_insert( Avlnode ** root, void *data, AVL_CMP fcmp, AVL_DUP fdup )
} }
r->avl_link[0] = r->avl_link[1] = NULL; r->avl_link[0] = r->avl_link[1] = NULL;
r->avl_data = data; r->avl_data = data;
r->avl_bits[0] = r->avl_bits[1] = AVL_CHILD;
r->avl_bf = EH; r->avl_bf = EH;
*root = r; *root = r;
@ -105,6 +106,7 @@ avl_insert( Avlnode ** root, void *data, AVL_CMP fcmp, AVL_DUP fdup )
} }
q->avl_link[0] = q->avl_link[1] = NULL; q->avl_link[0] = q->avl_link[1] = NULL;
q->avl_data = data; q->avl_data = data;
q->avl_bits[0] = q->avl_bits[1] = AVL_CHILD;
q->avl_bf = EH; q->avl_bf = EH;
p->avl_link[cmp] = q; p->avl_link[cmp] = q;

40
libraries/liblutil/tavl.c
View file

@ -60,13 +60,13 @@ static const int avl_bfs[] = {LH, RH};
* NOTE: this routine may malloc memory * NOTE: this routine may malloc memory
*/ */
int int
tavl_insert( Avlnode ** root, void *data, AVL_CMP fcmp, AVL_DUP fdup ) tavl_insert( TAvlnode ** root, void *data, AVL_CMP fcmp, AVL_DUP fdup )
{ {
Avlnode *t, *p, *s, *q, *r; TAvlnode *t, *p, *s, *q, *r;
int a, cmp, ncmp; int a, cmp, ncmp;
if ( *root == NULL ) { if ( *root == NULL ) {
if (( r = (Avlnode *) ber_memalloc( sizeof( Avlnode ))) == NULL ) { if (( r = (TAvlnode *) ber_memalloc( sizeof( TAvlnode ))) == NULL ) {
return( -1 ); return( -1 );
} }
r->avl_link[0] = r->avl_link[1] = NULL; r->avl_link[0] = r->avl_link[1] = NULL;
@ -91,7 +91,7 @@ tavl_insert( Avlnode ** root, void *data, AVL_CMP fcmp, AVL_DUP fdup )
q = avl_child( p, cmp ); q = avl_child( p, cmp );
if (q == NULL) { if (q == NULL) {
/* insert */ /* insert */
if (( q = (Avlnode *) ber_memalloc( sizeof( Avlnode ))) == NULL ) { if (( q = (TAvlnode *) ber_memalloc( sizeof( TAvlnode ))) == NULL ) {
return( -1 ); return( -1 );
} }
q->avl_link[cmp] = p->avl_link[cmp]; q->avl_link[cmp] = p->avl_link[cmp];
@ -187,13 +187,13 @@ tavl_insert( Avlnode ** root, void *data, AVL_CMP fcmp, AVL_DUP fdup )
} }
void* void*
tavl_delete( Avlnode **root, void* data, AVL_CMP fcmp ) tavl_delete( TAvlnode **root, void* data, AVL_CMP fcmp )
{ {
Avlnode *p, *q, *r, *top; TAvlnode *p, *q, *r, *top;
int side, side_bf, shorter, nside = -1; int side, side_bf, shorter, nside = -1;
/* parent stack */ /* parent stack */
Avlnode *pptr[MAX_TREE_DEPTH]; TAvlnode *pptr[MAX_TREE_DEPTH];
unsigned char pdir[MAX_TREE_DEPTH]; unsigned char pdir[MAX_TREE_DEPTH];
int depth = 0; int depth = 0;
@ -424,7 +424,7 @@ tavl_delete( Avlnode **root, void* data, AVL_CMP fcmp )
*/ */
int int
tavl_free( Avlnode *root, AVL_FREE dfree ) tavl_free( TAvlnode *root, AVL_FREE dfree )
{ {
int nleft, nright; int nleft, nright;
@ -450,15 +450,15 @@ tavl_free( Avlnode *root, AVL_FREE dfree )
*/ */
/* /*
* tavl_find2 - returns Avlnode instead of data pointer. * tavl_find2 - returns TAvlnode instead of data pointer.
* tavl_find3 - as above, but returns Avlnode even if no match is found. * tavl_find3 - as above, but returns TAvlnode even if no match is found.
* also set *ret = last comparison result, or -1 if root == NULL. * also set *ret = last comparison result, or -1 if root == NULL.
*/ */
Avlnode * TAvlnode *
tavl_find3( Avlnode *root, const void *data, AVL_CMP fcmp, int *ret ) tavl_find3( TAvlnode *root, const void *data, AVL_CMP fcmp, int *ret )
{ {
int cmp = -1, dir; int cmp = -1, dir;
Avlnode *prev = root; TAvlnode *prev = root;
while ( root != 0 && (cmp = (*fcmp)( data, root->avl_data )) != 0 ) { while ( root != 0 && (cmp = (*fcmp)( data, root->avl_data )) != 0 ) {
prev = root; prev = root;
@ -469,8 +469,8 @@ tavl_find3( Avlnode *root, const void *data, AVL_CMP fcmp, int *ret )
return root ? root : prev; return root ? root : prev;
} }
Avlnode * TAvlnode *
tavl_find2( Avlnode *root, const void *data, AVL_CMP fcmp ) tavl_find2( TAvlnode *root, const void *data, AVL_CMP fcmp )
{ {
int cmp; int cmp;
@ -482,7 +482,7 @@ tavl_find2( Avlnode *root, const void *data, AVL_CMP fcmp )
} }
void* void*
tavl_find( Avlnode *root, const void* data, AVL_CMP fcmp ) tavl_find( TAvlnode *root, const void* data, AVL_CMP fcmp )
{ {
int cmp; int cmp;
@ -495,8 +495,8 @@ tavl_find( Avlnode *root, const void* data, AVL_CMP fcmp )
} }
/* Return the leftmost or rightmost node in the tree */ /* Return the leftmost or rightmost node in the tree */
Avlnode * TAvlnode *
tavl_end( Avlnode *root, int dir ) tavl_end( TAvlnode *root, int dir )
{ {
if ( root ) { if ( root ) {
while ( root->avl_bits[dir] == AVL_CHILD ) while ( root->avl_bits[dir] == AVL_CHILD )
@ -506,8 +506,8 @@ tavl_end( Avlnode *root, int dir )
} }
/* Return the next node in the given direction */ /* Return the next node in the given direction */
Avlnode * TAvlnode *
tavl_next( Avlnode *root, int dir ) tavl_next( TAvlnode *root, int dir )
{ {
if ( root ) { if ( root ) {
int c = root->avl_bits[dir]; int c = root->avl_bits[dir];

10
libraries/liblutil/testtavl.c
View file

@ -39,14 +39,14 @@
#define AVL_INTERNAL #define AVL_INTERNAL
#include "avl.h" #include "avl.h"
static void ravl_print LDAP_P(( Avlnode *root, int depth, int thread )); static void ravl_print LDAP_P(( TAvlnode *root, int depth, int thread ));
static void myprint LDAP_P(( Avlnode *root )); static void myprint LDAP_P(( TAvlnode *root ));
static int avl_strcmp LDAP_P(( const void *s, const void *t )); static int avl_strcmp LDAP_P(( const void *s, const void *t ));
int int
main( int argc, char **argv ) main( int argc, char **argv )
{ {
Avlnode *tree = NULL, *n; TAvlnode *tree = NULL, *n;
char command[ 10 ]; char command[ 10 ];
char name[ 80 ]; char name[ 80 ];
char *p; char *p;
@ -115,7 +115,7 @@ main( int argc, char **argv )
static const char bfc_array[] = "\\-/"; static const char bfc_array[] = "\\-/";
static const char *bfcs = bfc_array+1; static const char *bfcs = bfc_array+1;
static void ravl_print( Avlnode *root, int depth, int thread ) static void ravl_print( TAvlnode *root, int depth, int thread )
{ {
int i; int i;
@ -140,7 +140,7 @@ static void ravl_print( Avlnode *root, int depth, int thread )
ravl_print( root->avl_link[0], depth+1, root->avl_bits[0] == AVL_THREAD ); ravl_print( root->avl_link[0], depth+1, root->avl_bits[0] == AVL_THREAD );
} }
static void myprint( Avlnode *root ) static void myprint( TAvlnode *root )
{ {
printf( "********\n" ); printf( "********\n" );

2
servers/slapd/back-mdb/back-mdb.h
View file

@ -141,7 +141,7 @@ typedef struct mdb_attrinfo {
#ifdef LDAP_COMP_MATCH #ifdef LDAP_COMP_MATCH
ComponentReference* ai_cr; /*component indexing*/ ComponentReference* ai_cr; /*component indexing*/
#endif #endif
Avlnode *ai_root; /* for tools */ TAvlnode *ai_root; /* for tools */
MDB_cursor *ai_cursor; /* for tools */ MDB_cursor *ai_cursor; /* for tools */
int ai_idx; /* position in AI array */ int ai_idx; /* position in AI array */
MDB_dbi ai_dbi; MDB_dbi ai_dbi;

4
servers/slapd/back-mdb/tools.c
View file

@ -1406,7 +1406,7 @@ int mdb_tool_idl_add(
dbi = ai->ai_dbi; dbi = ai->ai_dbi;
for (i=0; keys[i].bv_val; i++) { for (i=0; keys[i].bv_val; i++) {
itmp.kstr = keys[i]; itmp.kstr = keys[i];
ic = tavl_find( (Avlnode *)ai->ai_root, &itmp, mdb_tool_idl_cmp ); ic = tavl_find( ai->ai_root, &itmp, mdb_tool_idl_cmp );
/* No entry yet, create one */ /* No entry yet, create one */
if ( !ic ) { if ( !ic ) {
@ -1428,7 +1428,7 @@ int mdb_tool_idl_add(
ic->count = 0; ic->count = 0;
ic->offset = 0; ic->offset = 0;
ic->flags = 0; ic->flags = 0;
tavl_insert( (Avlnode **)&ai->ai_root, ic, mdb_tool_idl_cmp, tavl_insert( &ai->ai_root, ic, mdb_tool_idl_cmp,
avl_dup_error ); avl_dup_error );
/* load existing key count here */ /* load existing key count here */

6
servers/slapd/overlays/pcache.c
View file

@ -65,7 +65,7 @@ typedef struct Query_s {
struct query_template_s; struct query_template_s;
typedef struct Qbase_s { typedef struct Qbase_s {
Avlnode *scopes[4]; /* threaded AVL trees of cached queries */ TAvlnode *scopes[4]; /* threaded AVL trees of cached queries */
struct berval base; struct berval base;
int queries; int queries;
} Qbase; } Qbase;
@ -1272,14 +1272,14 @@ typedef struct fstack {
} fstack; } fstack;
static CachedQuery * static CachedQuery *
find_filter( Operation *op, Avlnode *root, Filter *inputf, Filter *first ) find_filter( Operation *op, TAvlnode *root, Filter *inputf, Filter *first )
{ {
Filter* fs; Filter* fs;
Filter* fi; Filter* fi;
MatchingRule* mrule = NULL; MatchingRule* mrule = NULL;
int res=0, eqpass= 0; int res=0, eqpass= 0;
int ret, rc, dir; int ret, rc, dir;
Avlnode *ptr; TAvlnode *ptr;
CachedQuery cq, *qc; CachedQuery cq, *qc;
fstack *stack = NULL, *fsp; fstack *stack = NULL, *fsp;

12
servers/slapd/overlays/sssvlv.c
View file

@ -105,7 +105,7 @@ typedef struct sssvlv_info
typedef struct sort_op typedef struct sort_op
{ {
Avlnode *so_tree; TAvlnode *so_tree;
sort_ctrl *so_ctrl; sort_ctrl *so_ctrl;
sssvlv_info *so_info; sssvlv_info *so_info;
int so_paged; int so_paged;
@ -398,7 +398,7 @@ static void free_sort_op( Connection *conn, sort_op *so )
int sess_id; int sess_id;
if ( so->so_tree ) { if ( so->so_tree ) {
if ( so->so_paged > SLAP_CONTROL_IGNORED ) { if ( so->so_paged > SLAP_CONTROL_IGNORED ) {
Avlnode *cur_node, *next_node; TAvlnode *cur_node, *next_node;
cur_node = so->so_tree; cur_node = so->so_tree;
while ( cur_node ) { while ( cur_node ) {
next_node = tavl_next( cur_node, TAVL_DIR_RIGHT ); next_node = tavl_next( cur_node, TAVL_DIR_RIGHT );
@ -441,7 +441,7 @@ static void send_list(
SlapReply *rs, SlapReply *rs,
sort_op *so) sort_op *so)
{ {
Avlnode *cur_node, *tmp_node; TAvlnode *cur_node, *tmp_node;
vlv_ctrl *vc = op->o_controls[vlv_cid]; vlv_ctrl *vc = op->o_controls[vlv_cid];
int i, j, dir, rc; int i, j, dir, rc;
BackendDB *be; BackendDB *be;
@ -594,8 +594,8 @@ range_err:
static void send_page( Operation *op, SlapReply *rs, sort_op *so ) static void send_page( Operation *op, SlapReply *rs, sort_op *so )
{ {
Avlnode *cur_node = so->so_tree; TAvlnode *cur_node = so->so_tree;
Avlnode *next_node = NULL; TAvlnode *next_node = NULL;
BackendDB *be = op->o_bd; BackendDB *be = op->o_bd;
Entry *e; Entry *e;
int rc; int rc;
@ -659,7 +659,7 @@ static void send_entry(
send_list( op, rs, so ); send_list( op, rs, so );
} else { } else {
/* Get the first node to send */ /* Get the first node to send */
Avlnode *start_node = tavl_end(so->so_tree, TAVL_DIR_LEFT); TAvlnode *start_node = tavl_end(so->so_tree, TAVL_DIR_LEFT);
so->so_tree = start_node; so->so_tree = start_node;
if ( so->so_paged <= SLAP_CONTROL_IGNORED ) { if ( so->so_paged <= SLAP_CONTROL_IGNORED ) {

4
servers/slapd/overlays/translucent.c
View file

@ -766,7 +766,7 @@ typedef struct trans_ctx {
BackendDB *db; BackendDB *db;
slap_overinst *on; slap_overinst *on;
Filter *orig; Filter *orig;
Avlnode *list; TAvlnode *list;
int step; int step;
int slimit; int slimit;
AttributeName *attrs; AttributeName *attrs;
@ -1135,7 +1135,7 @@ static int translucent_search(Operation *op, SlapReply *rs) {
/* Send out anything remaining on the list and finish */ /* Send out anything remaining on the list and finish */
if ( tc.step & USE_LIST ) { if ( tc.step & USE_LIST ) {
if ( tc.list ) { if ( tc.list ) {
Avlnode *av; TAvlnode *av;
av = tavl_end( tc.list, TAVL_DIR_LEFT ); av = tavl_end( tc.list, TAVL_DIR_LEFT );
while ( av ) { while ( av ) {