From 2bbcdae974b82d33df527a696aafd9bad5b99732 Mon Sep 17 00:00:00 2001 From: Jim Blandy Date: Thu, 21 Feb 2002 22:19:14 +0000 Subject: [PATCH] include: Allow the user to specify functions for allocating memory for splay tree roots and nodes. * splay-tree.h (splay_tree_allocate_fn, splay_tree_deallocate_fn): New types. (splay_tree): New fields: `allocate', `deallocate', and `allocate_data'. (splay_tree_new_with_allocator): New function declaration. libiberty: * splay-tree.c (splay_tree_xmalloc_allocate, splay_tree_xmalloc_deallocate): New functions. (splay_tree_new): Call splay_tree_new_with_allocator, passing the above functions and a dummy data pointer. (splay_tree_new_with_allocator): New function. (splay_tree_delete_helper, splay_tree_delete, splay_tree_insert, splay_tree_remove): Use the splay tree's allocation and deallocation functions. --- include/ChangeLog | 10 ++++++++ include/splay-tree.h | 25 +++++++++++++++++++ libiberty/ChangeLog | 11 +++++++++ libiberty/splay-tree.c | 54 +++++++++++++++++++++++++++++++++++++----- 4 files changed, 94 insertions(+), 6 deletions(-) diff --git a/include/ChangeLog b/include/ChangeLog index ad8cedd29bb..8ccea0591cd 100644 --- a/include/ChangeLog +++ b/include/ChangeLog @@ -1,3 +1,13 @@ +2002-02-21 Jim Blandy + + Allow the user to specify functions for allocating memory for + splay tree roots and nodes. + * splay-tree.h (splay_tree_allocate_fn, splay_tree_deallocate_fn): + New types. + (splay_tree): New fields: `allocate', `deallocate', and + `allocate_data'. + (splay_tree_new_with_allocator): New function declaration. + 2002-02-15 Alan Modra Support arbitrary length fill patterns. diff --git a/include/splay-tree.h b/include/splay-tree.h index 6903969402e..4b7a7bf8c2c 100644 --- a/include/splay-tree.h +++ b/include/splay-tree.h @@ -61,6 +61,18 @@ typedef void (*splay_tree_delete_value_fn) PARAMS((splay_tree_value)); /* The type of a function used to iterate over the tree. */ typedef int (*splay_tree_foreach_fn) PARAMS((splay_tree_node, void*)); +/* The type of a function used to allocate memory for tree root and + node structures. The first argument is the number of bytes needed; + the second is a data pointer the splay tree functions pass through + to the allocator. This function must never return zero. */ +typedef void *(*splay_tree_allocate_fn) PARAMS((int, void *)); + +/* The type of a function used to free memory allocated using the + corresponding splay_tree_allocate_fn. The first argument is the + memory to be freed; the latter is a data pointer the splay tree + functions pass through to the freer. */ +typedef void (*splay_tree_deallocate_fn) PARAMS((void *, void *)); + /* The nodes in the splay tree. */ struct splay_tree_node_s { @@ -89,11 +101,24 @@ typedef struct splay_tree_s /* The deallocate-value function. NULL if no cleanup is necessary. */ splay_tree_delete_value_fn delete_value; + + /* Allocate/free functions, and a data pointer to pass to them. */ + splay_tree_allocate_fn allocate; + splay_tree_deallocate_fn deallocate; + void *allocate_data; + } *splay_tree; extern splay_tree splay_tree_new PARAMS((splay_tree_compare_fn, splay_tree_delete_key_fn, splay_tree_delete_value_fn)); +extern splay_tree splay_tree_new_with_allocator + PARAMS((splay_tree_compare_fn, + splay_tree_delete_key_fn, + splay_tree_delete_value_fn, + splay_tree_allocate_fn, + splay_tree_deallocate_fn, + void *)); extern void splay_tree_delete PARAMS((splay_tree)); extern splay_tree_node splay_tree_insert PARAMS((splay_tree, diff --git a/libiberty/ChangeLog b/libiberty/ChangeLog index 9c0fe09dcac..e46c71128e8 100644 --- a/libiberty/ChangeLog +++ b/libiberty/ChangeLog @@ -1,3 +1,14 @@ +2002-02-21 Jim Blandy + + * splay-tree.c (splay_tree_xmalloc_allocate, + splay_tree_xmalloc_deallocate): New functions. + (splay_tree_new): Call splay_tree_new_with_allocator, passing the + above functions and a dummy data pointer. + (splay_tree_new_with_allocator): New function. + (splay_tree_delete_helper, splay_tree_delete, splay_tree_insert, + splay_tree_remove): Use the splay tree's allocation and + deallocation functions. + 2002-02-19 Scott Snyder * testsuite/demangle-expected: Add test case for infinite loop in diff --git a/libiberty/splay-tree.c b/libiberty/splay-tree.c index a7123952671..f12b4cc5007 100644 --- a/libiberty/splay-tree.c +++ b/libiberty/splay-tree.c @@ -70,7 +70,7 @@ splay_tree_delete_helper (sp, node) if (sp->delete_value) (*sp->delete_value)(node->value); - free ((char*) node); + (*sp->deallocate) ((char*) node, sp->allocate_data); } /* Help splay SP around KEY. PARENT and GRANDPARENT are the parent @@ -227,9 +227,25 @@ splay_tree_foreach_helper (sp, node, fn, data) return splay_tree_foreach_helper (sp, node->right, fn, data); } + +/* An allocator and deallocator based on xmalloc. */ +static void * +splay_tree_xmalloc_allocate (int size, void *data) +{ + return xmalloc (size); +} + +static void +splay_tree_xmalloc_deallocate (void *object, void *data) +{ + free (object); +} + + /* Allocate a new splay tree, using COMPARE_FN to compare nodes, DELETE_KEY_FN to deallocate keys, and DELETE_VALUE_FN to deallocate - values. */ + values. Use xmalloc to allocate the splay tree structure, and any + nodes added. */ splay_tree splay_tree_new (compare_fn, delete_key_fn, delete_value_fn) @@ -237,11 +253,35 @@ splay_tree_new (compare_fn, delete_key_fn, delete_value_fn) splay_tree_delete_key_fn delete_key_fn; splay_tree_delete_value_fn delete_value_fn; { - splay_tree sp = (splay_tree) xmalloc (sizeof (struct splay_tree_s)); + return (splay_tree_new_with_allocator + (compare_fn, delete_key_fn, delete_value_fn, + splay_tree_xmalloc_allocate, splay_tree_xmalloc_deallocate, 0)); +} + + +/* Allocate a new splay tree, using COMPARE_FN to compare nodes, + DELETE_KEY_FN to deallocate keys, and DELETE_VALUE_FN to deallocate + values. */ + +splay_tree +splay_tree_new_with_allocator (compare_fn, delete_key_fn, delete_value_fn, + allocate_fn, deallocate_fn, allocate_data) + splay_tree_compare_fn compare_fn; + splay_tree_delete_key_fn delete_key_fn; + splay_tree_delete_value_fn delete_value_fn; + splay_tree_allocate_fn allocate_fn; + splay_tree_deallocate_fn deallocate_fn; + void *allocate_data; +{ + splay_tree sp = (splay_tree) (*allocate_fn) (sizeof (struct splay_tree_s), + allocate_data); sp->root = 0; sp->comp = compare_fn; sp->delete_key = delete_key_fn; sp->delete_value = delete_value_fn; + sp->allocate = allocate_fn; + sp->deallocate = deallocate_fn; + sp->allocate_data = allocate_data; return sp; } @@ -253,7 +293,7 @@ splay_tree_delete (sp) splay_tree sp; { splay_tree_delete_helper (sp, sp->root); - free ((char*) sp); + (*sp->deallocate) ((char*) sp, sp->allocate_data); } /* Insert a new node (associating KEY with DATA) into SP. If a @@ -286,7 +326,9 @@ splay_tree_insert (sp, key, value) /* Create a new node, and insert it at the root. */ splay_tree_node node; - node = (splay_tree_node) xmalloc (sizeof (struct splay_tree_node_s)); + node = ((splay_tree_node) + (*sp->allocate) (sizeof (struct splay_tree_node_s), + sp->allocate_data)); node->key = key; node->value = value; @@ -330,7 +372,7 @@ splay_tree_remove (sp, key) /* Delete the root node itself. */ if (sp->delete_value) (*sp->delete_value) (sp->root->value); - free (sp->root); + (*sp->deallocate) (sp->root, sp->allocate_data); /* One of the children is now the root. Doesn't matter much which, so long as we preserve the properties of the tree. */ -- 2.30.2