New version from Albin Jones, plus fixes by McCallum.

git-svn-id: svn+ssh://svn.gna.org/svn/gnustep/libs/base/trunk@948 72102866-910b-0410-8b05-ffd578937521

Headers/gnustep/base/all.h

@@ -46,11 +46,6 @@
 #include <objects/RBTreeNode.h>
 #include <objects/SplayTree.h>
 
-#include <objects/EltNodeCollector.h>
-#include <objects/LinkedListEltNode.h>
-#include <objects/BinaryTreeEltNode.h>
-#include <objects/RBTreeEltNode.h>
-
 /* Magnitude objects */
 #include <objects/Magnitude.h>
 #include <objects/Random.h>
@@ -75,4 +70,6 @@
 #include <objects/Proxy.h>
 #include <objects/ConnectedCoder.h>
 
+#include <objects/Invocation.h>
+
 #endif /* __objects_h_OBJECTS_INCLUDE */

Headers/gnustep/base/allocs.h

@@ -33,10 +33,10 @@
 
 /**** Type, Constant, and Macro Definitions **********************************/
 
-typedef void *(*objects_malloc_func_t) (size_t, void *);
-typedef void *(*objects_calloc_func_t) (size_t, size_t, void *);
-typedef void *(*objects_realloc_func_t) (void *, size_t, void *);
-typedef void (*objects_free_func_t) (void *, void *);
+typedef void *(*objects_malloc_func_t) (size_t, const void *);
+typedef void *(*objects_calloc_func_t) (size_t, size_t, const void *);
+typedef void *(*objects_realloc_func_t) (void *, size_t, const void *);
+typedef void (*objects_free_func_t) (void *, const void *);
 
 typedef struct _objects_allocs objects_allocs_t;
 
@@ -46,7 +46,7 @@ struct _objects_allocs
     objects_calloc_func_t calloc;
     objects_realloc_func_t realloc;
     objects_free_func_t free;
-    void *user_data;
+    const void *user_data;
   };
 
 /* Shorthand macros. */
@@ -71,10 +71,10 @@ void *
   objects_calloc (objects_allocs_t allocs, size_t n, size_t s);
 
 void *
-  objects_realloc (objects_allocs_t allocs, void *p, size_t s);
+  objects_realloc (objects_allocs_t allocs, const void *p, size_t s);
 
 void
-  objects_free (objects_allocs_t allocs, void *p);
+  objects_free (objects_allocs_t allocs, const void *p);
 
 size_t
 objects_next_power_of_two (size_t start);

Headers/gnustep/base/array.h

@@ -47,7 +47,7 @@ struct _objects_array_bucket
     size_t index;
 
     /* The bucket's cargo */
-    void *element;
+    const void *element;
   };
 
 struct _objects_array
@@ -55,8 +55,8 @@ struct _objects_array
     /* Identifying information. */
     int magic;
     size_t number;
-    char *name;
-    void *extra;
+    const char *name;
+    const void *extra;
     objects_callbacks_t extra_callbacks;
     objects_allocs_t allocs;
 
@@ -135,7 +135,7 @@ int objects_array_is_equal_to_array (objects_array_t * array, objects_array_t *
 
 /** Adding **/
 
-void *objects_array_at_index_put_element (objects_array_t * array, size_t index, void *element);
+const void *objects_array_at_index_put_element (objects_array_t * array, size_t index, const void *element);
 
 /** Replacing **/
 
@@ -143,9 +143,9 @@ void *objects_array_at_index_put_element (objects_array_t * array, size_t index,
 
 void objects_array_remove_element_at_index (objects_array_t * array, size_t index);
 
-void objects_array_remove_element (objects_array_t * array, void *element);
+void objects_array_remove_element (objects_array_t * array, const void *element);
 
-void objects_array_remove_element_known_present (objects_array_t * array, void *element);
+void objects_array_remove_element_known_present (objects_array_t * array, const void *element);
 
 /** Emptying **/
 
@@ -153,19 +153,19 @@ void objects_array_empty (objects_array_t * array);
 
 /** Searching **/
 
-int objects_array_contains_element (objects_array_t * array, void *element);
+int objects_array_contains_element (objects_array_t * array, const void *element);
 
-void *objects_array_element (objects_array_t * array, void *element);
+const void *objects_array_element (objects_array_t * array, const void *element);
 
-size_t objects_array_index_of_element (objects_array_t * array, void *element);
+size_t objects_array_index_of_element (objects_array_t * array, const void *element);
 
-void *objects_array_element_at_index (objects_array_t * array, size_t index);
+const void *objects_array_element_at_index (objects_array_t * array, size_t index);
 
-void **objects_array_all_elements (objects_array_t * array);
+const void **objects_array_all_elements (objects_array_t * array);
 
-void **objects_array_all_elements_ascending (objects_array_t * array);
+const void **objects_array_all_elements_ascending (objects_array_t * array);
 
-void **objects_array_all_element_descending (objects_array_t * array);
+const void **objects_array_all_element_descending (objects_array_t * array);
 
 /** Enumerating **/
 
@@ -175,9 +175,9 @@ objects_array_enumerator_t objects_array_ascending_enumerator (objects_array_t *
 
 objects_array_enumerator_t objects_array_descending_enumerator (objects_array_t * array);
 
-int objects_array_enumerator_next_index_and_element (objects_array_enumerator_t *enumerator, size_t *index, void **element);
+int objects_array_enumerator_next_index_and_element (objects_array_enumerator_t *enumerator, size_t *index, const void **element);
 
-int objects_array_enumerator_next_element (objects_array_enumerator_t *enumerator, void **element);
+int objects_array_enumerator_next_element (objects_array_enumerator_t *enumerator, const void **element);
 
 int objects_array_enumerator_next_index (objects_array_enumerator_t *enumerator, size_t *element);
 

Headers/gnustep/base/data.h

@@ -53,8 +53,8 @@ struct _objects_data
   {
     int magic;
     size_t number;
-    char *name;
-    void *extra;
+    const char *name;
+    const void *extra;
     objects_callbacks_t extra_callbacks;
     objects_allocs_t allocs;
 

Headers/gnustep/base/hash.h

@@ -49,7 +49,7 @@ struct _objects_hash_node
     objects_hash_node_t *next_in_hash;
     objects_hash_node_t *prev_in_hash;
 
-    void *element;
+    const void *element;
   };
 
 struct _objects_hash_bucket
@@ -64,8 +64,8 @@ struct _objects_hash
   {
     int magic;
     size_t number;
-    char *name;
-    void *extra;
+    const char *name;
+    const void *extra;
     objects_callbacks_t extra_callbacks;
     objects_allocs_t allocs;
 
@@ -144,7 +144,10 @@ objects_hash_t * objects_hash_copy_with_allocs (objects_hash_t * hash, objects_a
  * to handle functions that aren't one-to-one is to create a new hash
  * and transform the elements of the first to create the elements of
  * the second. */
-objects_hash_t * objects_hash_map_elements (objects_hash_t * hash, void *(*fcn) (void *, void *), void *user_data);
+objects_hash_t * 
+objects_hash_map_elements (objects_hash_t * hash, 
+			   const void *(*fcn) (const void *, const void *), 
+			   const void *user_data);
 
 /** Destroying **/
 
@@ -160,39 +163,43 @@ int objects_hash_is_equal_to_hash (objects_hash_t * hash, objects_hash_t * other
 
 /** Adding **/
 
-void *objects_hash_add_element_known_absent (objects_hash_t * hash, void *element);
+const void *objects_hash_add_element_known_absent (objects_hash_t *hash, 
+						   const void *element);
 
-void *objects_hash_add_element (objects_hash_t * hash, void *element);
+const void *objects_hash_add_element (objects_hash_t *hash, 
+				      const void *element);
 
-void *objects_hash_add_element_if_absent (objects_hash_t * hash, void *element);
+const void *objects_hash_add_element_if_absent (objects_hash_t *hash, 
+						const void *element);
 
 /** Replacing **/
 
-void objects_hash_replace_element (objects_hash_t * hash, void *element);
+void objects_hash_replace_element (objects_hash_t *hash, const void *element);
 
 /** Removing **/
 
-void objects_hash_remove_element (objects_hash_t * hash, void *element);
+void objects_hash_remove_element (objects_hash_t *hash, const void *element);
 
 /** Emptying **/
 
-void objects_hash_empty (objects_hash_t * hash);
+void objects_hash_empty (objects_hash_t *hash);
 
 /** Searching **/
 
-void *objects_hash_any_element (objects_hash_t * hash);
+void *objects_hash_any_element (objects_hash_t *hash);
 
-int objects_hash_contains_element (objects_hash_t * hash, void *element);
+int objects_hash_contains_element (objects_hash_t *hash, const void *element);
 
-void *objects_hash_element (objects_hash_t * hash, void *element);
+const void *objects_hash_element (objects_hash_t *hash, const void *element);
 
-void **objects_hash_all_elements (objects_hash_t * hash);
+const void **objects_hash_all_elements (objects_hash_t *hash);
 
 /** Enumerating **/
 
-objects_hash_enumerator_t objects_hash_enumerator (objects_hash_t * hash);
+objects_hash_enumerator_t objects_hash_enumerator (objects_hash_t *hash);
 
-int objects_hash_enumerator_next_element (objects_hash_enumerator_t *enumerator, void **element);
+int objects_hash_enumerator_next_element (objects_hash_enumerator_t *enumeratr,
+					  const void **element);
 
 /** Statistics **/
 

Headers/gnustep/base/list.h

@@ -47,7 +47,7 @@ struct _objects_list_node
     objects_list_node_t *next_in_list;
     objects_list_node_t *prev_in_list;
 
-    void *element;
+    const void *element;
   };
 
 struct _objects_list
@@ -56,7 +56,7 @@ struct _objects_list
     int magic;
     size_t number;
     char *name;
-    void *extra;
+    const void *extra;
     objects_callbacks_t extra_callbacks;
     objects_allocs_t allocs;
 
@@ -143,9 +143,9 @@ objects_list_t * objects_list_at_index_insert_list (objects_list_t * base_list,
 
 objects_list_t * objects_list_roll_to_nth_element (objects_list_t * list, long int n);
 
-objects_list_t * objects_list_roll_to_element (objects_list_t * list, void *element);
+objects_list_t * objects_list_roll_to_element (objects_list_t * list, const void *element);
 
-objects_list_t * objects_list_roll_to_nth_occurrance_of_element (objects_list_t * list, long int n, void *element);
+objects_list_t * objects_list_roll_to_nth_occurrance_of_element (objects_list_t * list, long int n, const void *element);
 
 objects_list_t * objects_list_invert (objects_list_t * list);
 
@@ -153,39 +153,39 @@ objects_list_t * objects_list_swap_elements_at_indices (objects_list_t * list, l
 
 /** Adding **/
 
-void *objects_list_append_element (objects_list_t * list, void *element);
+const void *objects_list_append_element (objects_list_t * list, const void *element);
 
-void *objects_list_append_element_if_absent (objects_list_t * list, void *element);
+const void *objects_list_append_element_if_absent (objects_list_t * list, const void *element);
 
-void *objects_list_prepend_element (objects_list_t * list, void *element);
+const void *objects_list_prepend_element (objects_list_t * list, const void *element);
 
-void *objects_list_prepend_element_if_absent (objects_list_t * list, void *element);
+const void *objects_list_prepend_element_if_absent (objects_list_t * list, const void *element);
 
-void *objects_list_at_index_insert_element (objects_list_t * list, long int n, void *element);
+const void *objects_list_at_index_insert_element (objects_list_t * list, long int n, const void *element);
 
-void *objects_list_at_index_insert_element_if_absent (objects_list_t * list, long int n, void *element);
+const void *objects_list_at_index_insert_element_if_absent (objects_list_t * list, long int n, const void *element);
 
-void *objects_list_queue_push_element (objects_list_t * list, void *element);
+const void *objects_list_queue_push_element (objects_list_t * list, const void *element);
 
-void *objects_list_stack_push_element (objects_list_t * list, void *element);
+const void *objects_list_stack_push_element (objects_list_t * list, const void *element);
 
 /** Replacing **/
 
-void objects_list_replace_nth_occurrance_of_element (objects_list_t * list, long int n, void *old_element, void *new_element);
+void objects_list_replace_nth_occurrance_of_element (objects_list_t * list, long int n, const void *old_element, const void *new_element);
 
-void objects_list_replace_element (objects_list_t * list, void *old_element, void *new_element);
+void objects_list_replace_element (objects_list_t * list, const void *old_element, const void *new_element);
 
-void objects_list_replace_nth_element (objects_list_t * list, long int n, void *new_element);
+void objects_list_replace_nth_element (objects_list_t * list, long int n, const void *new_element);
 
-void objects_list_replace_first_element (objects_list_t * list, void *new_element);
+void objects_list_replace_first_element (objects_list_t * list, const void *new_element);
 
-void objects_list_replace_last_element (objects_list_t * list, void *new_element);
+void objects_list_replace_last_element (objects_list_t * list, const void *new_element);
 
 /** Removing **/
 
-void objects_list_remove_nth_occurrence_of_element (objects_list_t * list, long int n, void *element);
+void objects_list_remove_nth_occurrence_of_element (objects_list_t * list, long int n, const void *element);
 
-void objects_list_remove_element (objects_list_t * list, void *element);
+void objects_list_remove_element (objects_list_t * list, const void *element);
 
 void objects_list_remove_nth_element (objects_list_t * list, long int n);
 
@@ -207,17 +207,17 @@ void objects_list_empty (objects_list_t * list);
 
 /** Searching **/
 
-int objects_list_contains_element (objects_list_t * list, void *element);
+int objects_list_contains_element (objects_list_t * list, const void *element);
 
-void *objects_list_element (objects_list_t * list, void *element);
+const void *objects_list_element (objects_list_t * list, const void *element);
 
-void *objects_list_nth_element (objects_list_t * list, long int n);
+const void *objects_list_nth_element (objects_list_t * list, long int n);
 
-void *objects_list_first_element (objects_list_t * list);
+const void *objects_list_first_element (objects_list_t * list);
 
-void *objects_list_last_element (objects_list_t * list);
+const void *objects_list_last_element (objects_list_t * list);
 
-void **objects_list_all_elements (objects_list_t * list);
+const void **objects_list_all_elements (objects_list_t * list);
 
 /** Enumerating **/
 
@@ -227,13 +227,13 @@ objects_list_enumerator_t objects_list_forward_enumerator (objects_list_t * list
 
 objects_list_enumerator_t objects_list_reverse_enumerator (objects_list_t * list);
 
-int objects_list_enumerator_next_element (objects_list_enumerator_t *enumerator, void **element);
+int objects_list_enumerator_next_element (objects_list_enumerator_t *enumerator, const void **element);
 
 /** Mapping **/
 
 /* NO WARNING: The mapping function FCN need not be one-to-one on the
  * elements of LIST.  In fact, FCN may do whatever it likes. */
-objects_list_t * objects_list_map_elements (objects_list_t * list, void *(*fcn) (void *, void *), void *user_data);
+objects_list_t * objects_list_map_elements (objects_list_t * list, const void *(*fcn) (const void *, const void *), const void *user_data);
 
 /** Statistics **/
 

Headers/gnustep/base/map.h

@@ -43,56 +43,56 @@ typedef struct _objects_map_enumerator objects_map_enumerator_t;
 /* Important structures... */
 
 struct _objects_map_node
-  {
-    void *key;
-    void *value;
+{
+  const void *key;
+  const void *value;
 
-    objects_map_bucket_t *bucket;
-    objects_map_t *map;
+  objects_map_bucket_t *bucket;
+  objects_map_t *map;
 
-    objects_map_node_t *next_in_bucket;
-    objects_map_node_t *prev_in_bucket;
-    objects_map_node_t *next_in_map;
-    objects_map_node_t *prev_in_map;
-  };
+  objects_map_node_t *next_in_bucket;
+  objects_map_node_t *prev_in_bucket;
+  objects_map_node_t *next_in_map;
+  objects_map_node_t *prev_in_map;
+};
 
 struct _objects_map_bucket
-  {
-    size_t node_count;
-    size_t element_count;
+{
+  size_t node_count;
+  size_t element_count;
 
-    objects_map_node_t *first_node;
-  };
+  objects_map_node_t *first_node;
+};
 
 struct _objects_map
-  {
-    /* Container identifiers */
-    int magic;
-    size_t number;
-    char *name;
-    void *extra;
-    objects_callbacks_t extra_callbacks;
-    objects_allocs_t allocs;
-    objects_callbacks_t key_callbacks;
+{
+  /* Container identifiers */
+  int magic;
+  size_t number;
+  char *name;
+  const void *extra;
+  objects_callbacks_t extra_callbacks;
+  objects_allocs_t allocs;
+  objects_callbacks_t key_callbacks;
 
     /* Management information */
-    objects_callbacks_t value_callbacks;
+  objects_callbacks_t value_callbacks;
 
-    /* Internal counters */
-    size_t bucket_count;
-    size_t node_count;
-    size_t element_count;
+  /* Internal counters */
+  size_t bucket_count;
+  size_t node_count;
+  size_t element_count;
 
-    /* Databanks */
-    objects_map_bucket_t *buckets;
-    objects_map_node_t *first_node;
-  };
+  /* Databanks */
+  objects_map_bucket_t *buckets;
+  objects_map_node_t *first_node;
+};
 
 struct _objects_map_enumerator
-  {
-    objects_map_t *map;
-    objects_map_node_t *node;
-  };
+{
+  objects_map_t *map;
+  objects_map_node_t *node;
+};
 
 /**** Function Prototypes ****************************************************/
 
@@ -112,82 +112,82 @@ objects_map_rightsize (objects_map_t * map);
 /** Creating **/
 
 objects_map_t *
-  objects_map_alloc (void);
+objects_map_alloc (void);
 
 objects_map_t *
-  objects_map_alloc_with_allocs (objects_allocs_t allocs);
+objects_map_alloc_with_allocs (objects_allocs_t allocs);
 
 objects_map_t *
-  objects_map (void);
+objects_map (void);
 
 objects_map_t *
-  objects_map_with_allocs (objects_allocs_t allocs);
+objects_map_with_allocs (objects_allocs_t allocs);
 
 objects_map_t *
-  objects_map_with_allocs_with_callbacks (objects_allocs_t allocs,
-					  objects_callbacks_t key_callbacks,
-				       objects_callbacks_t value_callbacks);
+objects_map_with_allocs_with_callbacks (objects_allocs_t allocs,
+					objects_callbacks_t key_callbacks,
+					objects_callbacks_t value_callbacks);
 
 objects_map_t *
-  objects_map_with_callbacks (objects_callbacks_t key_callbacks,
-			      objects_callbacks_t value_callbacks);
+objects_map_with_callbacks (objects_callbacks_t key_callbacks,
+			    objects_callbacks_t value_callbacks);
 
 objects_map_t *
-  objects_map_of_int (void);
+objects_map_of_int (void);
 
 objects_map_t *
-  objects_map_of_int_to_char_p (void);
+objects_map_of_int_to_char_p (void);
 
 objects_map_t *
-  objects_map_of_int_to_void_p (void);
+objects_map_of_int_to_void_p (void);
 
 objects_map_t *
-  objects_map_of_int_to_float (void);
+objects_map_of_int_to_float (void);
 
 objects_map_t *
-  objects_map_of_char_p (void);
+objects_map_of_char_p (void);
 
 objects_map_t *
-  objects_map_of_char_p_to_int (void);
+objects_map_of_char_p_to_int (void);
 
 objects_map_t *
-  objects_map_of_char_p_to_void_p (void);
+objects_map_of_char_p_to_void_p (void);
 
 objects_map_t *
-  objects_map_of_char_p_to_float (void);
+objects_map_of_char_p_to_float (void);
 
 objects_map_t *
-  objects_map_of_void_p (void);
+objects_map_of_void_p (void);
 
 objects_map_t *
-  objects_map_of_void_p_to_int (void);
+objects_map_of_void_p_to_int (void);
 
 objects_map_t *
-  objects_map_of_void_p_to_char_p (void);
+objects_map_of_void_p_to_char_p (void);
 
 objects_map_t *
-  objects_map_of_void_p_to_float (void);
+objects_map_of_void_p_to_float (void);
 
 objects_map_t *
-  objects_map_of_float (void);
+objects_map_of_float (void);
 
 objects_map_t *
-  objects_map_of_double (void);
+objects_map_of_double (void);
 
 /** Initializing **/
 
 objects_map_t *
-  objects_map_init (objects_map_t * map);
+objects_map_init (objects_map_t * map);
 
 objects_map_t *
-  objects_map_init_with_callbacks (objects_map_t * map,
-				   objects_callbacks_t key_callbacks,
-				   objects_callbacks_t value_callbacks);
+objects_map_init_with_callbacks (objects_map_t * map,
+				 objects_callbacks_t key_callbacks,
+				 objects_callbacks_t value_callbacks);
 
 /** Destroying **/
 
 void
-  objects_map_dealloc (objects_map_t * map);
+objects_map_dealloc (objects_map_t * map);
 
 /** Gathering statistics on a mapionary **/
 
@@ -198,24 +198,24 @@ size_t
 objects_map_capacity (objects_map_t * map);
 
 int
-  objects_map_check_map (objects_map_t * map);
+objects_map_check_map (objects_map_t * map);
 
 /** Finding elements in a mapionary **/
 
 int
-  objects_map_contains_key (objects_map_t * map, void *key);
+objects_map_contains_key (objects_map_t * map, const void *key);
 
 int
-  objects_map_key_and_value (objects_map_t * map,
-			     void *key,
-			     void **old_key,
-			     void **value);
+objects_map_key_and_value (objects_map_t * map,
+			   const void *key,
+			   void **old_key,
+			   void **value);
 
-void *
-  objects_map_key (objects_map_t * map, void *key);
+const void *
+objects_map_key (objects_map_t * map, const void *key);
 
-void *
-  objects_map_value (objects_map_t * map, void *key);
+const void *
+objects_map_value_at_key (objects_map_t * map, const void *key);
 
 /** Enumerating the nodes and elements of a mapionary **/
 
@@ -223,74 +223,74 @@ objects_map_enumerator_t
 objects_map_enumerator (objects_map_t * map);
 
 int
-  objects_map_enumerator_next_key_and_value (objects_map_enumerator_t * enumerator,
-					     void **key,
-					     void **value);
+objects_map_enumerator_next_key_and_value (objects_map_enumerator_t *enumeratr,
+					   const void **key,
+					   const void **value);
 
 int
-  objects_map_enumerator_next_key (objects_map_enumerator_t * enumerator,
-				   void **key);
+objects_map_enumerator_next_key (objects_map_enumerator_t * enumerator,
+				 const void **key);
 
 int
-  objects_map_enumerator_next_value (objects_map_enumerator_t * enumerator,
-				     void **value);
+objects_map_enumerator_next_value (objects_map_enumerator_t * enumerator,
+				   const void **value);
 
 /** Obtaining an array of the elements of a mapionary **/
 
-void **
-  objects_map_all_keys_and_values (objects_map_t * map);
+const void **
+objects_map_all_keys_and_values (objects_map_t * map);
 
-void **
-  objects_map_all_keys (objects_map_t * map);
+const void **
+objects_map_all_keys (objects_map_t * map);
 
-void **
-  objects_map_all_values (objects_map_t * map);
+const void **
+objects_map_all_values (objects_map_t * map);
 
 /** Removing **/
 
 void
-  objects_map_remove_key (objects_map_t * map, void *key);
+objects_map_remove_key (objects_map_t * map, const void *key);
 
 void
-  objects_map_empty (objects_map_t * map);
+objects_map_empty (objects_map_t * map);
 
 /** Adding **/
 
-void *
-  objects_map_at_key_put_value_known_absent (objects_map_t * map,
-					     void *key,
-					     void *value);
+const void *
+objects_map_at_key_put_value_known_absent (objects_map_t * map,
+					   const void *key,
+					   const void *value);
 
-void *
-  objects_map_at_key_put_value (objects_map_t * map,
-				void *key,
-				void *value);
+const void *
+objects_map_at_key_put_value (objects_map_t * map,
+			      const void *key,
+			      const void *value);
 
-void *
-  objects_map_at_key_put_value_if_absent (objects_map_t * map,
-					  void *key,
-					  void *value);
+const void *
+objects_map_at_key_put_value_if_absent (objects_map_t * map,
+					const void *key,
+					const void *value);
 
 /** Replacing **/
 
 void
-  objects_map_replace_key (objects_map_t * map, void *key);
+objects_map_replace_key (objects_map_t * map, const void *key);
 
 /** Comparing **/
 
 int
-  objects_map_contains_map (objects_map_t * map1, objects_map_t * map2);
+objects_map_contains_map (objects_map_t * map1, objects_map_t * map2);
 
 int
-  objects_map_is_equal_to_map (objects_map_t * map1, objects_map_t * map2);
+objects_map_is_equal_to_map (objects_map_t * map1, objects_map_t * map2);
 
 /** Copying **/
 
 objects_map_t *
-  objects_map_copy_with_allocs (objects_map_t * old_map, objects_allocs_t new_allocs);
+objects_map_copy_with_allocs (objects_map_t * old_map, objects_allocs_t new_allocs);
 
 objects_map_t *
-  objects_map_copy (objects_map_t * old_map);
+objects_map_copy (objects_map_t * old_map);
 
 /** Mapping **/
 
@@ -299,32 +299,32 @@ objects_map_t *
  * possibility that KFCN maps two unequal keys of MAP to the same (or
  * equal) keys. */
 objects_map_t *
-  objects_map_map_keys (objects_map_t * map,
-			void *(*kfcn) (void *, void *),
-			void *user_data);
+objects_map_map_keys (objects_map_t * map,
+		      const void *(*kfcn) (const void *, const void *),
+		      const void *user_data);
 
 /* NO WARNING: The mapping function VFCN need not be one-to-one on
  * (the equivalence classes of) values. */
 objects_map_t *
-  objects_map_map_values (objects_map_t * map,
-			  void *(*vfcn) (void *, void *),
-			  void *user_data);
+objects_map_map_values (objects_map_t * map,
+			const void *(*vfcn) (const void *, const void *),
+			const void *user_data);
 
 /** Miscellaneous **/
 
 objects_map_t *
-  objects_map_intersect_map (objects_map_t * map, objects_map_t * other_map);
+objects_map_intersect_map (objects_map_t * map, objects_map_t * other_map);
 
 objects_map_t *
-  objects_map_minus_map (objects_map_t * map, objects_map_t * other_map);
+objects_map_minus_map (objects_map_t * map, objects_map_t * other_map);
 
 objects_map_t *
-  objects_map_union_map (objects_map_t * map, objects_map_t * other_map);
+objects_map_union_map (objects_map_t * map, objects_map_t * other_map);
 
 objects_hash_t *
-  objects_hash_init_from_map_keys (objects_hash_t * hash, objects_map_t * map);
+objects_hash_init_from_map_keys (objects_hash_t * hash, objects_map_t * map);
 
 objects_hash_t *
-  objects_hash_init_from_map_values (objects_hash_t * hash, objects_map_t * map);
+objects_hash_init_from_map_values (objects_hash_t * hash, objects_map_t * map);
 
 #endif /* __map_h_OBJECTS_INCLUDE */

Headers/gnustep/base/o_array.h

@@ -47,7 +47,7 @@ struct _objects_array_bucket
     size_t index;
 
     /* The bucket's cargo */
-    void *element;
+    const void *element;
   };
 
 struct _objects_array
@@ -55,8 +55,8 @@ struct _objects_array
     /* Identifying information. */
     int magic;
     size_t number;
-    char *name;
-    void *extra;
+    const char *name;
+    const void *extra;
     objects_callbacks_t extra_callbacks;
     objects_allocs_t allocs;
 
@@ -135,7 +135,7 @@ int objects_array_is_equal_to_array (objects_array_t * array, objects_array_t *
 
 /** Adding **/
 
-void *objects_array_at_index_put_element (objects_array_t * array, size_t index, void *element);
+const void *objects_array_at_index_put_element (objects_array_t * array, size_t index, const void *element);
 
 /** Replacing **/
 
@@ -143,9 +143,9 @@ void *objects_array_at_index_put_element (objects_array_t * array, size_t index,
 
 void objects_array_remove_element_at_index (objects_array_t * array, size_t index);
 
-void objects_array_remove_element (objects_array_t * array, void *element);
+void objects_array_remove_element (objects_array_t * array, const void *element);
 
-void objects_array_remove_element_known_present (objects_array_t * array, void *element);
+void objects_array_remove_element_known_present (objects_array_t * array, const void *element);
 
 /** Emptying **/
 
@@ -153,19 +153,19 @@ void objects_array_empty (objects_array_t * array);
 
 /** Searching **/
 
-int objects_array_contains_element (objects_array_t * array, void *element);
+int objects_array_contains_element (objects_array_t * array, const void *element);
 
-void *objects_array_element (objects_array_t * array, void *element);
+const void *objects_array_element (objects_array_t * array, const void *element);
 
-size_t objects_array_index_of_element (objects_array_t * array, void *element);
+size_t objects_array_index_of_element (objects_array_t * array, const void *element);
 
-void *objects_array_element_at_index (objects_array_t * array, size_t index);
+const void *objects_array_element_at_index (objects_array_t * array, size_t index);
 
-void **objects_array_all_elements (objects_array_t * array);
+const void **objects_array_all_elements (objects_array_t * array);
 
-void **objects_array_all_elements_ascending (objects_array_t * array);
+const void **objects_array_all_elements_ascending (objects_array_t * array);
 
-void **objects_array_all_element_descending (objects_array_t * array);
+const void **objects_array_all_element_descending (objects_array_t * array);
 
 /** Enumerating **/
 
@@ -175,9 +175,9 @@ objects_array_enumerator_t objects_array_ascending_enumerator (objects_array_t *
 
 objects_array_enumerator_t objects_array_descending_enumerator (objects_array_t * array);
 
-int objects_array_enumerator_next_index_and_element (objects_array_enumerator_t *enumerator, size_t *index, void **element);
+int objects_array_enumerator_next_index_and_element (objects_array_enumerator_t *enumerator, size_t *index, const void **element);
 
-int objects_array_enumerator_next_element (objects_array_enumerator_t *enumerator, void **element);
+int objects_array_enumerator_next_element (objects_array_enumerator_t *enumerator, const void **element);
 
 int objects_array_enumerator_next_index (objects_array_enumerator_t *enumerator, size_t *element);
 

Headers/gnustep/base/o_cbs.h

@@ -33,12 +33,14 @@
 
 /**** Type, Constant, and Macro Definitions **********************************/
 
-typedef size_t (*objects_hash_func_t) (void *, void *);
-typedef int (*objects_compare_func_t) (void *, void *, void *);
-typedef int (*objects_is_equal_func_t) (void *, void *, void *);
-typedef void *(*objects_retain_func_t) (void *, void *);
-typedef void (*objects_release_func_t) (void *, void *);
-typedef void *(*objects_describe_func_t) (void *, void *);
+typedef size_t (*objects_hash_func_t) (const void *, const void *);
+typedef int (*objects_compare_func_t) (const void *, const void *, 
+				       const void *);
+typedef int (*objects_is_equal_func_t) (const void *, const void *, 
+					const void *);
+typedef void *(*objects_retain_func_t) (const void *, const void *);
+typedef void (*objects_release_func_t) (void *, const void *);
+typedef void *(*objects_describe_func_t) (const void *, const void *);
 
 typedef struct _objects_callbacks objects_callbacks_t;
 
@@ -50,7 +52,7 @@ struct _objects_callbacks
   objects_retain_func_t retain;
   objects_release_func_t release;
   objects_describe_func_t describe;
-  void *not_an_item_marker;
+  const void *not_an_item_marker;
 };
 
 /** Callbacks for various types **/
@@ -88,85 +90,85 @@ objects_callbacks_standardize (objects_callbacks_t callbacks);
 /** Using callbacks **/
 
 size_t objects_hash (objects_callbacks_t callbacks,
-                     void *thing,
-                     void *user_data);
+                     const void *thing,
+                     const void *user_data);
 
 int objects_compare (objects_callbacks_t callbacks,
-                     void *thing1,
-                     void *thing2,
-                     void *user_data);
+                     const void *thing1,
+                     const void *thing2,
+                     const void *user_data);
 
 int objects_is_equal (objects_callbacks_t callbacks,
-                      void *thing1,
-                      void *thing2,
-                      void *user_data);
+                      const void *thing1,
+                      const void *thing2,
+                      const void *user_data);
 
 void *objects_retain (objects_callbacks_t callbacks,
-                      void *thing,
-                      void *user_data);
+                      const void *thing,
+                      const void *user_data);
 
 void objects_release (objects_callbacks_t callbacks,
                       void *thing,
-                      void *user_data);
+                      const void *user_data);
 
 /* FIXME: Decide what to do with this describe stuff.  We'd really like
  * them to return Strings?  Or would we rather they be `char *'s?
  * Or something else? */
 void *objects_describe (objects_callbacks_t callbacks,
-                        void *thing,
-                        void *user_data);
+                        const void *thing,
+                        const void *user_data);
 
-void *objects_not_an_item_marker (objects_callbacks_t);
+const void *objects_not_an_item_marker (objects_callbacks_t);
 
 /** Specific callback functions **/
 
 /* For `void *' */
-size_t objects_void_p_hash(void *ptr);
-int objects_void_p_compare(void *ptr, void *qtr);
-int objects_void_p_is_equal(void *ptr, void *qtr);
-void *objects_void_p_retain(void *ptr);
-void objects_void_p_release(void *ptr);
-void *objects_void_p_describe(void *ptr);
+size_t objects_void_p_hash(const void *ptr);
+int objects_void_p_compare(const void *ptr, const void *qtr);
+int objects_void_p_is_equal(const void *ptr, const void *qtr);
+const void *objects_void_p_retain(const void *ptr);
+void objects_void_p_release(const void *ptr);
+const void *objects_void_p_describe(const void *ptr);
 
 /* For `void *' */
-size_t objects_owned_void_p_hash(void *ptr);
-int objects_owned_void_p_compare(void *ptr, void *qtr);
-int objects_owned_void_p_is_equal(void *ptr, void *qtr);
-void *objects_owned_void_p_retain(void *ptr);
-void objects_owned_void_p_release(void *ptr);
-void *objects_owned_void_p_describe(void *ptr);
+size_t objects_owned_void_p_hash(const void *ptr);
+int objects_owned_void_p_compare(const void *ptr, const void *qtr);
+int objects_owned_void_p_is_equal(const void *ptr, const void *qtr);
+const void *objects_owned_void_p_retain(const void *ptr);
+void objects_owned_void_p_release(const void *ptr);
+const void *objects_owned_void_p_describe(const void *ptr);
 
 /* For `int' */
-size_t objects_int_hash(void *i);
-int objects_int_compare(void *i, void *j);
-int objects_int_is_equal(void *i, void *j);
-void *objects_int_retain(void *i);
-void objects_int_release(void *i);
-void *objects_int_describe(void *i);
+size_t objects_int_hash(const void *i);
+int objects_int_compare(const void *i, const void *j);
+int objects_int_is_equal(const void *i, const void *j);
+const void *objects_int_retain(const void *i);
+void objects_int_release(const void *i);
+const void *objects_int_describe(const void *i);
 
 /* For `int *' */
-size_t objects_int_p_hash(void *iptr);
-int objects_int_p_compare(void *iptr, void *jptr);
-int objects_int_p_is_equal(void *iptr, void *jptr);
-void *objects_int_p_retain(void *iptr);
-void objects_int_p_release(void *iptr);
-void *objects_int_p_describe(void *iptr);
+size_t objects_int_p_hash(const void *iptr);
+int objects_int_p_compare(const void *iptr, const void *jptr);
+int objects_int_p_is_equal(const void *iptr, const void *jptr);
+const void *objects_int_p_retain(const void *iptr);
+void objects_int_p_release(const void *iptr);
+const void *objects_int_p_describe(const void *iptr);
 
 /* For `char *' */
-size_t objects_char_p_hash(void *cptr);
-int objects_char_p_compare(void *cptr, void *dptr);
-int objects_char_p_is_equal(void *cptr, void *dptr);
-void *objects_char_p_retain(void *cptr);
-void objects_char_p_release(void *cptr);
-void *objects_char_p_describe(void *cptr);
+size_t objects_char_p_hash(const void *cptr);
+int objects_char_p_compare(const void *cptr, const void *dptr);
+int objects_char_p_is_equal(const void *cptr, const void *dptr);
+const void *objects_char_p_retain(const void *cptr);
+void objects_char_p_release(const void *cptr);
+const void *objects_char_p_describe(const void *cptr);
 
 /* For `id' */
-size_t objects_id_hash(void *obj);
-int objects_id_compare(void *obj, void *jbo);
-int objects_id_is_equal(void *obj, void *jbo);
-void *objects_id_retain(void *obj);
-void objects_id_release(void *obj);
-void *objects_id_describe(void *obj);
+size_t objects_id_hash(const void *obj);
+int objects_id_compare(const void *obj, const void *jbo);
+int objects_id_is_equal(const void *obj, const void *jbo);
+const void *objects_id_retain(const void *obj);
+void objects_id_release(const void *obj);
+const void *objects_id_describe(const void *obj);
 
 #endif /* __callbacks_h_OBJECTS_INCLUDE */
 

Headers/gnustep/base/o_hash.h

@@ -49,7 +49,7 @@ struct _objects_hash_node
     objects_hash_node_t *next_in_hash;
     objects_hash_node_t *prev_in_hash;
 
-    void *element;
+    const void *element;
   };
 
 struct _objects_hash_bucket
@@ -64,8 +64,8 @@ struct _objects_hash
   {
     int magic;
     size_t number;
-    char *name;
-    void *extra;
+    const char *name;
+    const void *extra;
     objects_callbacks_t extra_callbacks;
     objects_allocs_t allocs;
 
@@ -144,7 +144,10 @@ objects_hash_t * objects_hash_copy_with_allocs (objects_hash_t * hash, objects_a
  * to handle functions that aren't one-to-one is to create a new hash
  * and transform the elements of the first to create the elements of
  * the second. */
-objects_hash_t * objects_hash_map_elements (objects_hash_t * hash, void *(*fcn) (void *, void *), void *user_data);
+objects_hash_t * 
+objects_hash_map_elements (objects_hash_t * hash, 
+			   const void *(*fcn) (const void *, const void *), 
+			   const void *user_data);
 
 /** Destroying **/
 
@@ -160,39 +163,43 @@ int objects_hash_is_equal_to_hash (objects_hash_t * hash, objects_hash_t * other
 
 /** Adding **/
 
-void *objects_hash_add_element_known_absent (objects_hash_t * hash, void *element);
+const void *objects_hash_add_element_known_absent (objects_hash_t *hash, 
+						   const void *element);
 
-void *objects_hash_add_element (objects_hash_t * hash, void *element);
+const void *objects_hash_add_element (objects_hash_t *hash, 
+				      const void *element);
 
-void *objects_hash_add_element_if_absent (objects_hash_t * hash, void *element);
+const void *objects_hash_add_element_if_absent (objects_hash_t *hash, 
+						const void *element);
 
 /** Replacing **/
 
-void objects_hash_replace_element (objects_hash_t * hash, void *element);
+void objects_hash_replace_element (objects_hash_t *hash, const void *element);
 
 /** Removing **/
 
-void objects_hash_remove_element (objects_hash_t * hash, void *element);
+void objects_hash_remove_element (objects_hash_t *hash, const void *element);
 
 /** Emptying **/
 
-void objects_hash_empty (objects_hash_t * hash);
+void objects_hash_empty (objects_hash_t *hash);
 
 /** Searching **/
 
-void *objects_hash_any_element (objects_hash_t * hash);
+void *objects_hash_any_element (objects_hash_t *hash);
 
-int objects_hash_contains_element (objects_hash_t * hash, void *element);
+int objects_hash_contains_element (objects_hash_t *hash, const void *element);
 
-void *objects_hash_element (objects_hash_t * hash, void *element);
+const void *objects_hash_element (objects_hash_t *hash, const void *element);
 
-void **objects_hash_all_elements (objects_hash_t * hash);
+const void **objects_hash_all_elements (objects_hash_t *hash);
 
 /** Enumerating **/
 
-objects_hash_enumerator_t objects_hash_enumerator (objects_hash_t * hash);
+objects_hash_enumerator_t objects_hash_enumerator (objects_hash_t *hash);
 
-int objects_hash_enumerator_next_element (objects_hash_enumerator_t *enumerator, void **element);
+int objects_hash_enumerator_next_element (objects_hash_enumerator_t *enumeratr,
+					  const void **element);
 
 /** Statistics **/
 

Headers/gnustep/base/o_list.h

@@ -47,7 +47,7 @@ struct _objects_list_node
     objects_list_node_t *next_in_list;
     objects_list_node_t *prev_in_list;
 
-    void *element;
+    const void *element;
   };
 
 struct _objects_list
@@ -56,7 +56,7 @@ struct _objects_list
     int magic;
     size_t number;
     char *name;
-    void *extra;
+    const void *extra;
     objects_callbacks_t extra_callbacks;
     objects_allocs_t allocs;
 
@@ -143,9 +143,9 @@ objects_list_t * objects_list_at_index_insert_list (objects_list_t * base_list,
 
 objects_list_t * objects_list_roll_to_nth_element (objects_list_t * list, long int n);
 
-objects_list_t * objects_list_roll_to_element (objects_list_t * list, void *element);
+objects_list_t * objects_list_roll_to_element (objects_list_t * list, const void *element);
 
-objects_list_t * objects_list_roll_to_nth_occurrance_of_element (objects_list_t * list, long int n, void *element);
+objects_list_t * objects_list_roll_to_nth_occurrance_of_element (objects_list_t * list, long int n, const void *element);
 
 objects_list_t * objects_list_invert (objects_list_t * list);
 
@@ -153,39 +153,39 @@ objects_list_t * objects_list_swap_elements_at_indices (objects_list_t * list, l
 
 /** Adding **/
 
-void *objects_list_append_element (objects_list_t * list, void *element);
+const void *objects_list_append_element (objects_list_t * list, const void *element);
 
-void *objects_list_append_element_if_absent (objects_list_t * list, void *element);
+const void *objects_list_append_element_if_absent (objects_list_t * list, const void *element);
 
-void *objects_list_prepend_element (objects_list_t * list, void *element);
+const void *objects_list_prepend_element (objects_list_t * list, const void *element);
 
-void *objects_list_prepend_element_if_absent (objects_list_t * list, void *element);
+const void *objects_list_prepend_element_if_absent (objects_list_t * list, const void *element);
 
-void *objects_list_at_index_insert_element (objects_list_t * list, long int n, void *element);
+const void *objects_list_at_index_insert_element (objects_list_t * list, long int n, const void *element);
 
-void *objects_list_at_index_insert_element_if_absent (objects_list_t * list, long int n, void *element);
+const void *objects_list_at_index_insert_element_if_absent (objects_list_t * list, long int n, const void *element);
 
-void *objects_list_queue_push_element (objects_list_t * list, void *element);
+const void *objects_list_queue_push_element (objects_list_t * list, const void *element);
 
-void *objects_list_stack_push_element (objects_list_t * list, void *element);
+const void *objects_list_stack_push_element (objects_list_t * list, const void *element);
 
 /** Replacing **/
 
-void objects_list_replace_nth_occurrance_of_element (objects_list_t * list, long int n, void *old_element, void *new_element);
+void objects_list_replace_nth_occurrance_of_element (objects_list_t * list, long int n, const void *old_element, const void *new_element);
 
-void objects_list_replace_element (objects_list_t * list, void *old_element, void *new_element);
+void objects_list_replace_element (objects_list_t * list, const void *old_element, const void *new_element);
 
-void objects_list_replace_nth_element (objects_list_t * list, long int n, void *new_element);
+void objects_list_replace_nth_element (objects_list_t * list, long int n, const void *new_element);
 
-void objects_list_replace_first_element (objects_list_t * list, void *new_element);
+void objects_list_replace_first_element (objects_list_t * list, const void *new_element);
 
-void objects_list_replace_last_element (objects_list_t * list, void *new_element);
+void objects_list_replace_last_element (objects_list_t * list, const void *new_element);
 
 /** Removing **/
 
-void objects_list_remove_nth_occurrence_of_element (objects_list_t * list, long int n, void *element);
+void objects_list_remove_nth_occurrence_of_element (objects_list_t * list, long int n, const void *element);
 
-void objects_list_remove_element (objects_list_t * list, void *element);
+void objects_list_remove_element (objects_list_t * list, const void *element);
 
 void objects_list_remove_nth_element (objects_list_t * list, long int n);
 
@@ -207,17 +207,17 @@ void objects_list_empty (objects_list_t * list);
 
 /** Searching **/
 
-int objects_list_contains_element (objects_list_t * list, void *element);
+int objects_list_contains_element (objects_list_t * list, const void *element);
 
-void *objects_list_element (objects_list_t * list, void *element);
+const void *objects_list_element (objects_list_t * list, const void *element);
 
-void *objects_list_nth_element (objects_list_t * list, long int n);
+const void *objects_list_nth_element (objects_list_t * list, long int n);
 
-void *objects_list_first_element (objects_list_t * list);
+const void *objects_list_first_element (objects_list_t * list);
 
-void *objects_list_last_element (objects_list_t * list);
+const void *objects_list_last_element (objects_list_t * list);
 
-void **objects_list_all_elements (objects_list_t * list);
+const void **objects_list_all_elements (objects_list_t * list);
 
 /** Enumerating **/
 
@@ -227,13 +227,13 @@ objects_list_enumerator_t objects_list_forward_enumerator (objects_list_t * list
 
 objects_list_enumerator_t objects_list_reverse_enumerator (objects_list_t * list);
 
-int objects_list_enumerator_next_element (objects_list_enumerator_t *enumerator, void **element);
+int objects_list_enumerator_next_element (objects_list_enumerator_t *enumerator, const void **element);
 
 /** Mapping **/
 
 /* NO WARNING: The mapping function FCN need not be one-to-one on the
  * elements of LIST.  In fact, FCN may do whatever it likes. */
-objects_list_t * objects_list_map_elements (objects_list_t * list, void *(*fcn) (void *, void *), void *user_data);
+objects_list_t * objects_list_map_elements (objects_list_t * list, const void *(*fcn) (const void *, const void *), const void *user_data);
 
 /** Statistics **/
 

Headers/gnustep/base/o_map.h

@@ -43,56 +43,56 @@ typedef struct _objects_map_enumerator objects_map_enumerator_t;
 /* Important structures... */
 
 struct _objects_map_node
-  {
-    void *key;
-    void *value;
+{
+  const void *key;
+  const void *value;
 
-    objects_map_bucket_t *bucket;
-    objects_map_t *map;
+  objects_map_bucket_t *bucket;
+  objects_map_t *map;
 
-    objects_map_node_t *next_in_bucket;
-    objects_map_node_t *prev_in_bucket;
-    objects_map_node_t *next_in_map;
-    objects_map_node_t *prev_in_map;
-  };
+  objects_map_node_t *next_in_bucket;
+  objects_map_node_t *prev_in_bucket;
+  objects_map_node_t *next_in_map;
+  objects_map_node_t *prev_in_map;
+};
 
 struct _objects_map_bucket
-  {
-    size_t node_count;
-    size_t element_count;
+{
+  size_t node_count;
+  size_t element_count;
 
-    objects_map_node_t *first_node;
-  };
+  objects_map_node_t *first_node;
+};
 
 struct _objects_map
-  {
-    /* Container identifiers */
-    int magic;
-    size_t number;
-    char *name;
-    void *extra;
-    objects_callbacks_t extra_callbacks;
-    objects_allocs_t allocs;
-    objects_callbacks_t key_callbacks;
+{
+  /* Container identifiers */
+  int magic;
+  size_t number;
+  char *name;
+  const void *extra;
+  objects_callbacks_t extra_callbacks;
+  objects_allocs_t allocs;
+  objects_callbacks_t key_callbacks;
 
     /* Management information */
-    objects_callbacks_t value_callbacks;
+  objects_callbacks_t value_callbacks;
 
-    /* Internal counters */
-    size_t bucket_count;
-    size_t node_count;
-    size_t element_count;
+  /* Internal counters */
+  size_t bucket_count;
+  size_t node_count;
+  size_t element_count;
 
-    /* Databanks */
-    objects_map_bucket_t *buckets;
-    objects_map_node_t *first_node;
-  };
+  /* Databanks */
+  objects_map_bucket_t *buckets;
+  objects_map_node_t *first_node;
+};
 
 struct _objects_map_enumerator
-  {
-    objects_map_t *map;
-    objects_map_node_t *node;
-  };
+{
+  objects_map_t *map;
+  objects_map_node_t *node;
+};
 
 /**** Function Prototypes ****************************************************/
 
@@ -112,82 +112,82 @@ objects_map_rightsize (objects_map_t * map);
 /** Creating **/
 
 objects_map_t *
-  objects_map_alloc (void);
+objects_map_alloc (void);
 
 objects_map_t *
-  objects_map_alloc_with_allocs (objects_allocs_t allocs);
+objects_map_alloc_with_allocs (objects_allocs_t allocs);
 
 objects_map_t *
-  objects_map (void);
+objects_map (void);
 
 objects_map_t *
-  objects_map_with_allocs (objects_allocs_t allocs);
+objects_map_with_allocs (objects_allocs_t allocs);
 
 objects_map_t *
-  objects_map_with_allocs_with_callbacks (objects_allocs_t allocs,
-					  objects_callbacks_t key_callbacks,
-				       objects_callbacks_t value_callbacks);
+objects_map_with_allocs_with_callbacks (objects_allocs_t allocs,
+					objects_callbacks_t key_callbacks,
+					objects_callbacks_t value_callbacks);
 
 objects_map_t *
-  objects_map_with_callbacks (objects_callbacks_t key_callbacks,
-			      objects_callbacks_t value_callbacks);
+objects_map_with_callbacks (objects_callbacks_t key_callbacks,
+			    objects_callbacks_t value_callbacks);
 
 objects_map_t *
-  objects_map_of_int (void);
+objects_map_of_int (void);
 
 objects_map_t *
-  objects_map_of_int_to_char_p (void);
+objects_map_of_int_to_char_p (void);
 
 objects_map_t *
-  objects_map_of_int_to_void_p (void);
+objects_map_of_int_to_void_p (void);
 
 objects_map_t *
-  objects_map_of_int_to_float (void);
+objects_map_of_int_to_float (void);
 
 objects_map_t *
-  objects_map_of_char_p (void);
+objects_map_of_char_p (void);
 
 objects_map_t *
-  objects_map_of_char_p_to_int (void);
+objects_map_of_char_p_to_int (void);
 
 objects_map_t *
-  objects_map_of_char_p_to_void_p (void);
+objects_map_of_char_p_to_void_p (void);
 
 objects_map_t *
-  objects_map_of_char_p_to_float (void);
+objects_map_of_char_p_to_float (void);
 
 objects_map_t *
-  objects_map_of_void_p (void);
+objects_map_of_void_p (void);
 
 objects_map_t *
-  objects_map_of_void_p_to_int (void);
+objects_map_of_void_p_to_int (void);
 
 objects_map_t *
-  objects_map_of_void_p_to_char_p (void);
+objects_map_of_void_p_to_char_p (void);
 
 objects_map_t *
-  objects_map_of_void_p_to_float (void);
+objects_map_of_void_p_to_float (void);
 
 objects_map_t *
-  objects_map_of_float (void);
+objects_map_of_float (void);
 
 objects_map_t *
-  objects_map_of_double (void);
+objects_map_of_double (void);
 
 /** Initializing **/
 
 objects_map_t *
-  objects_map_init (objects_map_t * map);
+objects_map_init (objects_map_t * map);
 
 objects_map_t *
-  objects_map_init_with_callbacks (objects_map_t * map,
-				   objects_callbacks_t key_callbacks,
-				   objects_callbacks_t value_callbacks);
+objects_map_init_with_callbacks (objects_map_t * map,
+				 objects_callbacks_t key_callbacks,
+				 objects_callbacks_t value_callbacks);
 
 /** Destroying **/
 
 void
-  objects_map_dealloc (objects_map_t * map);
+objects_map_dealloc (objects_map_t * map);
 
 /** Gathering statistics on a mapionary **/
 
@@ -198,24 +198,24 @@ size_t
 objects_map_capacity (objects_map_t * map);
 
 int
-  objects_map_check_map (objects_map_t * map);
+objects_map_check_map (objects_map_t * map);
 
 /** Finding elements in a mapionary **/
 
 int
-  objects_map_contains_key (objects_map_t * map, void *key);
+objects_map_contains_key (objects_map_t * map, const void *key);
 
 int
-  objects_map_key_and_value (objects_map_t * map,
-			     void *key,
-			     void **old_key,
-			     void **value);
+objects_map_key_and_value (objects_map_t * map,
+			   const void *key,
+			   void **old_key,
+			   void **value);
 
-void *
-  objects_map_key (objects_map_t * map, void *key);
+const void *
+objects_map_key (objects_map_t * map, const void *key);
 
-void *
-  objects_map_value (objects_map_t * map, void *key);
+const void *
+objects_map_value_at_key (objects_map_t * map, const void *key);
 
 /** Enumerating the nodes and elements of a mapionary **/
 
@@ -223,74 +223,74 @@ objects_map_enumerator_t
 objects_map_enumerator (objects_map_t * map);
 
 int
-  objects_map_enumerator_next_key_and_value (objects_map_enumerator_t * enumerator,
-					     void **key,
-					     void **value);
+objects_map_enumerator_next_key_and_value (objects_map_enumerator_t *enumeratr,
+					   const void **key,
+					   const void **value);
 
 int
-  objects_map_enumerator_next_key (objects_map_enumerator_t * enumerator,
-				   void **key);
+objects_map_enumerator_next_key (objects_map_enumerator_t * enumerator,
+				 const void **key);
 
 int
-  objects_map_enumerator_next_value (objects_map_enumerator_t * enumerator,
-				     void **value);
+objects_map_enumerator_next_value (objects_map_enumerator_t * enumerator,
+				   const void **value);
 
 /** Obtaining an array of the elements of a mapionary **/
 
-void **
-  objects_map_all_keys_and_values (objects_map_t * map);
+const void **
+objects_map_all_keys_and_values (objects_map_t * map);
 
-void **
-  objects_map_all_keys (objects_map_t * map);
+const void **
+objects_map_all_keys (objects_map_t * map);
 
-void **
-  objects_map_all_values (objects_map_t * map);
+const void **
+objects_map_all_values (objects_map_t * map);
 
 /** Removing **/
 
 void
-  objects_map_remove_key (objects_map_t * map, void *key);
+objects_map_remove_key (objects_map_t * map, const void *key);
 
 void
-  objects_map_empty (objects_map_t * map);
+objects_map_empty (objects_map_t * map);
 
 /** Adding **/
 
-void *
-  objects_map_at_key_put_value_known_absent (objects_map_t * map,
-					     void *key,
-					     void *value);
+const void *
+objects_map_at_key_put_value_known_absent (objects_map_t * map,
+					   const void *key,
+					   const void *value);
 
-void *
-  objects_map_at_key_put_value (objects_map_t * map,
-				void *key,
-				void *value);
+const void *
+objects_map_at_key_put_value (objects_map_t * map,
+			      const void *key,
+			      const void *value);
 
-void *
-  objects_map_at_key_put_value_if_absent (objects_map_t * map,
-					  void *key,
-					  void *value);
+const void *
+objects_map_at_key_put_value_if_absent (objects_map_t * map,
+					const void *key,
+					const void *value);
 
 /** Replacing **/
 
 void
-  objects_map_replace_key (objects_map_t * map, void *key);
+objects_map_replace_key (objects_map_t * map, const void *key);
 
 /** Comparing **/
 
 int
-  objects_map_contains_map (objects_map_t * map1, objects_map_t * map2);
+objects_map_contains_map (objects_map_t * map1, objects_map_t * map2);
 
 int
-  objects_map_is_equal_to_map (objects_map_t * map1, objects_map_t * map2);
+objects_map_is_equal_to_map (objects_map_t * map1, objects_map_t * map2);
 
 /** Copying **/
 
 objects_map_t *
-  objects_map_copy_with_allocs (objects_map_t * old_map, objects_allocs_t new_allocs);
+objects_map_copy_with_allocs (objects_map_t * old_map, objects_allocs_t new_allocs);
 
 objects_map_t *
-  objects_map_copy (objects_map_t * old_map);
+objects_map_copy (objects_map_t * old_map);
 
 /** Mapping **/
 
@@ -299,32 +299,32 @@ objects_map_t *
  * possibility that KFCN maps two unequal keys of MAP to the same (or
  * equal) keys. */
 objects_map_t *
-  objects_map_map_keys (objects_map_t * map,
-			void *(*kfcn) (void *, void *),
-			void *user_data);
+objects_map_map_keys (objects_map_t * map,
+		      const void *(*kfcn) (const void *, const void *),
+		      const void *user_data);
 
 /* NO WARNING: The mapping function VFCN need not be one-to-one on
  * (the equivalence classes of) values. */
 objects_map_t *
-  objects_map_map_values (objects_map_t * map,
-			  void *(*vfcn) (void *, void *),
-			  void *user_data);
+objects_map_map_values (objects_map_t * map,
+			const void *(*vfcn) (const void *, const void *),
+			const void *user_data);
 
 /** Miscellaneous **/
 
 objects_map_t *
-  objects_map_intersect_map (objects_map_t * map, objects_map_t * other_map);
+objects_map_intersect_map (objects_map_t * map, objects_map_t * other_map);
 
 objects_map_t *
-  objects_map_minus_map (objects_map_t * map, objects_map_t * other_map);
+objects_map_minus_map (objects_map_t * map, objects_map_t * other_map);
 
 objects_map_t *
-  objects_map_union_map (objects_map_t * map, objects_map_t * other_map);
+objects_map_union_map (objects_map_t * map, objects_map_t * other_map);
 
 objects_hash_t *
-  objects_hash_init_from_map_keys (objects_hash_t * hash, objects_map_t * map);
+objects_hash_init_from_map_keys (objects_hash_t * hash, objects_map_t * map);
 
 objects_hash_t *
-  objects_hash_init_from_map_values (objects_hash_t * hash, objects_map_t * map);
+objects_hash_init_from_map_values (objects_hash_t * hash, objects_map_t * map);
 
 #endif /* __map_h_OBJECTS_INCLUDE */

Headers/gnustep/base/objects.h

@@ -46,11 +46,6 @@
 #include <objects/RBTreeNode.h>
 #include <objects/SplayTree.h>
 
-#include <objects/EltNodeCollector.h>
-#include <objects/LinkedListEltNode.h>
-#include <objects/BinaryTreeEltNode.h>
-#include <objects/RBTreeEltNode.h>
-
 /* Magnitude objects */
 #include <objects/Magnitude.h>
 #include <objects/Random.h>
@@ -75,4 +70,6 @@
 #include <objects/Proxy.h>
 #include <objects/ConnectedCoder.h>
 
+#include <objects/Invocation.h>
+
 #endif /* __objects_h_OBJECTS_INCLUDE */

Source/NSHashTable.m

@@ -3,8 +3,8 @@
  * 
  * Author: Albin L. Jones <Albin.L.Jones@Dartmouth.EDU>
  * Created: Mon Dec 12 23:54:09 EST 1994
- * Updated: Sat Feb 10 15:59:11 EST 1996
- * Serial: 96.02.10.01
+ * Updated: Mon Feb 12 22:55:15 EST 1996
+ * Serial: 96.02.12.01
  * 
  * This file is part of the GNU Objective C Class Library.
  * 
@@ -30,6 +30,7 @@
 #include <Foundation/NSArray.h>
 #include <Foundation/NSException.h>
 #include <Foundation/NSHashTable.h>
+#include <NSCallBacks.h>
 #include <Foundation/atoz.h>
 #include <objects/hash.h>
 
@@ -37,9 +38,7 @@
 
 /* These are to increase readabilty locally. */
 typedef unsigned int (*NSHT_hash_func_t)(NSHashTable *, const void *);
-typedef BOOL (*NSHT_isEqual_func_t)(NSHashTable *,
-                                    const void *,
-                                    const void *);
+typedef BOOL (*NSHT_isEqual_func_t)(NSHashTable *, const void *, const void *);
 typedef void (*NSHT_retain_func_t)(NSHashTable *, const void *);
 typedef void (*NSHT_release_func_t)(NSHashTable *, void *);
 typedef NSString *(*NSHT_describe_func_t)(NSHashTable *, const void *);
@@ -48,65 +47,65 @@ typedef NSString *(*NSHT_describe_func_t)(NSHashTable *, const void *);
      
 const NSHashTableCallBacks NSIntHashCallBacks =
 {
-  (NSHT_hash_func_t) _NSLF_int_hash,
-  (NSHT_isEqual_func_t) _NSLF_int_is_equal,
-  (NSHT_retain_func_t) fn_null_function,
-  (NSHT_release_func_t) fn_null_function,
-  (NSHT_describe_Func_t) _NSLF_int_describe
+  (NSHT_hash_func_t) _NS_int_hash,
+  (NSHT_isEqual_func_t) _NS_int_is_equal,
+  (NSHT_retain_func_t) _NS_int_retain,
+  (NSHT_release_func_t) _NS_int_release,
+  (NSHT_describe_func_t) _NS_int_describe
 };
 
 const NSHashTableCallBacks NSNonOwnedPointerHashCallBacks = 
 {
-  (NSHT_hash_func_t) _NSLF_void_p_hash,
-  (NSHT_isEqual_func_t) _NSLF_void_p_is_equal,
-  (NSHT_retain_func_t) fn_null_function,
-  (NSHT_release_func_t) fn_null_function,
-  (NSHT_describe_func_t) _NSLF_void_p_describe
+  (NSHT_hash_func_t) _NS_owned_void_p_hash,
+  (NSHT_isEqual_func_t) _NS_owned_void_p_is_equal,
+  (NSHT_retain_func_t) _NS_owned_void_p_retain,
+  (NSHT_release_func_t) _NS_owned_void_p_release,
+  (NSHT_describe_func_t) _NS_owned_void_p_describe
 };
 
 const NSHashTableCallBacks NSNonRetainedObjectsHashCallBacks = 
 {
-  (NSHT_hash_func_t) _NSLF_id_hash,
-  (NSHT_isEqual_func_t) _NSLF_id_is_equal,
-  (NSHT_retain_func_t) fn_null_function,
-  (NSHT_release_func_t) fn_null_function,
-  (NSHT_describe_func_t) _NSLF_id_describe
+  (NSHT_hash_func_t) _NS_non_retained_id_hash,
+  (NSHT_isEqual_func_t) _NS_non_retained_id_is_equal,
+  (NSHT_retain_func_t) _NS_non_retained_id_retain,
+  (NSHT_release_func_t) _NS_non_retained_id_release,
+  (NSHT_describe_func_t) _NS_non_retained_id_describe
 };
 
 const NSHashTableCallBacks NSObjectsHashCallBacks = 
 {
-  (NSHT_hash_func_t) _NSLF_id_hash,
-  (NSHT_isEqual_func_t) _NSLF_id_is_equal,
-  (NSHT_retain_func_t) _NSLF_id_retain,
-  (NSHT_release_func_t) _NSLF_id_object,
-  (NSHT_describe_func_t) _NSLF_id_describe
+  (NSHT_hash_func_t) _NS_id_hash,
+  (NSHT_isEqual_func_t) _NS_id_is_equal,
+  (NSHT_retain_func_t) _NS_id_retain,
+  (NSHT_release_func_t) _NS_id_release,
+  (NSHT_describe_func_t) _NS_id_describe
 };
 
 const NSHashTableCallBacks NSOwnedPointerHashCallBacks = 
 {
-  (NSHT_hash_func_t) _NSLF_void_p_hash,
-  (NSHT_isEqual_func_t) _NSLF_void_p_is_equal,
-  (NSHT_retain_func_t) fn_null_function,
-  (NSHT_release_func_t) _NSLF_void_p_release,
-  (NSHT_describe_func_t) _NSLF_void_p_describe
+  (NSHT_hash_func_t) _NS_owned_void_p_hash,
+  (NSHT_isEqual_func_t) _NS_owned_void_p_is_equal,
+  (NSHT_retain_func_t) _NS_owned_void_p_retain,
+  (NSHT_release_func_t) _NS_owned_void_p_release,
+  (NSHT_describe_func_t) _NS_owned_void_p_describe
 };
 
 const NSHashTableCallBacks NSPointerToStructHashCallBacks = 
 {
-  (NSHT_hash_func_t) _NSLF_int_p_hash,
-  (NSHT_isEqual_func_t) _NSLF_int_p_is_equal,
-  (NSHT_retain_func_t) fn_null_function,
-  (NSHT_release_func_t) fn_null_function,
-  (NSHT_describe_func_t) _NSLF_int_p_describe
+  (NSHT_hash_func_t) _NS_int_p_hash,
+  (NSHT_isEqual_func_t) _NS_int_p_is_equal,
+  (NSHT_retain_func_t) _NS_int_p_retain,
+  (NSHT_release_func_t) _NS_int_p_release,
+  (NSHT_describe_func_t) _NS_int_p_describe
 };
 
 /** Macros **/
 
 #define NSHT_ZONE(T) \
-  ((NSZone *)((fn_hash_allocs((fn_hash_t *)(T))).user_data))
+  ((NSZone *)((objects_hash_allocs((objects_hash_t *)(T))).user_data))
 
 #define NSHT_CALLBACKS(T) \
-  (*((NSHashTableCallBacks *)(__void_p__(fn_hash_extra((fn_hash_t *)(T))))))
+  (*((NSHashTableCallBacks *)(objects_hash_extra((objects_hash_t *)(T)))))
 
 #define NSHT_DESCRIBE(T, P) \
   NSHT_CALLBACKS((T)).describe((T), (P))
@@ -114,111 +113,102 @@ const NSHashTableCallBacks NSPointerToStructHashCallBacks =
 /** Dummy callbacks **/
 
 size_t
-_NSHT_hash(fn_generic_t element, void *table)
+_NSHT_hash (const void *element, const void *table)
 {
-  return NSHT_CALLBACKS(table).hash((NSHashTable *)table,
-                                    __void_p__(element));
+  return (NSHT_CALLBACKS(table)).hash ((NSHashTable *)table, element);
 }
 
 int
-_NSHT_compare(fn_generic_t element1,
-                 fn_generic_t element2,
-                 void *table)
+_NSHT_compare (const void *element1, const void *element2, const void *table)
 {
-  return !(NSHT_CALLBACKS(table).isEqual((NSHashTable *)table,
-                                         __void_p__(element1),
-                                         __void_p__(element2)));
+  return !((NSHT_CALLBACKS(table)).isEqual ((NSHashTable *)table,
+					    element1,
+					    element2));
 }
 
 int
-_NSHT_is_equal(fn_generic_t element1,
-                  fn_generic_t element2,
-                  void *table)
+_NSHT_is_equal (const void *element1, const void *element2, const void *table)
 {
-  return NSHT_CALLBACKS(table).isEqual((NSHashTable *) table,
-                                       __void_p__(element1),
-                                       __void_p__(element2));
+  return (NSHT_CALLBACKS(table)).isEqual ((NSHashTable *) table,
+					  element1,
+					  element2);
 }
 
-fn_generic_t
-_NSHT_retain(fn_generic_t element, void *table)
+void *
+_NSHT_retain (const void *element, const void *table)
 {
-  NSHT_CALLBACKS(table).retain((NSHashTable *)table,
-                               __void_p__(element));
-  return element;
+  (NSHT_CALLBACKS(table)).retain ((NSHashTable *)table, element);
+  return (void*) element;
 }
 
 void
-_NSHT_release(fn_generic_t element, void *table)
+_NSHT_release (void *element, const void *table)
 {
-  NSHT_CALLBACKS(table).release(table, __void_p__(element));
+  (NSHT_CALLBACKS(table)).release ((NSHashTable*)table, (void*)element);
   return;
 }
 
 /* These are wrappers for getting at the real callbacks. */
-const fn_callbacks_t _NSHT_callbacks = 
+const objects_callbacks_t _NSHT_callbacks = 
 {
   _NSHT_hash,
   _NSHT_compare,
   _NSHT_is_equal,
   _NSHT_retain,
   _NSHT_release,
-  (fn_describe_func_t)fn_null_function,
+  0,
   0 
 };
 
 /** Extra, extra **/
 
 /* Make a copy of a hash table's callbacks. */
-fn_generic_t
-_NSHT_extra_retain(fn_generic_t extra, void *table)
+void *
+_NSHT_extra_retain (const void *extra, const void *table)
 {
   /* Pick out the callbacks in EXTRA. */
-  NSHashTableCallBacks *callBacks = (NSHashTableCallBacks *)__void_p__(extra);
+  NSHashTableCallBacks *callBacks = (NSHashTableCallBacks *)(extra);
 
   /* Find our zone. */
   NSZone *zone = NSHT_ZONE(table);
 
   /* A pointer to some new callbacks. */
-  NSHashTableCallbacks *newCallBacks;
+  NSHashTableCallBacks *newCallBacks;
 
   /* Set aside space for our new callbacks in the right zone. */
-  newCallBacks = (NSHashTableCallBacks *)NSZoneMalloc(zone,
-                                                      sizeof(NSHashTableCallBacks));
+  newCallBacks = (NSHashTableCallBacks *)
+    NSZoneMalloc(zone,
+		 sizeof(NSHashTableCallBacks));
 
   /* Copy CALLBACKS into NEWCALLBACKS. */
   *newCallBacks = *callBacks;
 
-  /* Stuff NEWCALLBACKS into EXTRA. */
-  __void_p__(extra) = newCallBacks;
-
   /* Return our new EXTRA. */
-  return extra;
+  return (void*) extra;
 }
 
 void
-_NSHT_extra_release(fn_generic_t extra, void *table)
+_NSHT_extra_release (void *extra, const void *table)
 {
-  void *ptr = __void_p__(extra);
   NSZone *zone = NSHT_ZONE(table);
 
-  if (ptr != NULL)
-    NSZoneFree(zone, ptr);
+  if (extra != NULL)
+    NSZoneFree(zone, (void*)extra);
 
   return;
 }
 
 /* The idea here is that these callbacks ensure that the
  * NSHashTableCallbacks which are associated with a given NSHashTable
- * remain so throughout the life of the table and its copies. */
-fn_callbacks_t _NSHT_extra_callbacks = 
+ * remain so associated throughout the life of the table and its copies. */
+objects_callbacks_t _NSHT_extra_callbacks = 
 {
-  (fn_hash_func_t) fn_generic_hash,
-  (fn_is_equal_func_t) fn_generic_is_equal,
-  (fn_compare_func_t) fn_generic_compare,
+  (objects_hash_func_t) objects_void_p_hash,
+  (objects_compare_func_t) objects_void_p_compare,
+  (objects_is_equal_func_t) objects_void_p_is_equal,
   _NSHT_extra_retain,
   _NSHT_extra_release,
-  (fn_describe_func_t) fn_null_function,
+  0,
   0
 };
 
@@ -227,35 +217,35 @@ fn_callbacks_t _NSHT_extra_callbacks =
 /** Creating NSHashTables **/
 
 NSHashTable *
-NSCreateHashTableWithZone(NSHashTableCallBacks callBacks,
-                          unsigned int capacity,
-                          NSZone *zone)
+NSCreateHashTableWithZone (NSHashTableCallBacks callBacks,
+			   unsigned int capacity,
+			   NSZone *zone)
 {
   NSHashTable *table;
-  fn_callbacks_t callbacks;
-  fn_allocs_t allocs;
+  objects_callbacks_t callbacks;
+  objects_allocs_t allocs;
 
   /* These callbacks just look in the TABLE's extra and uses the
    * callbacks there.  See above for precise definitions. */
   callbacks = _NSHT_callbacks;
-  allocs = fn_allocs_for_zone(zone);
+  allocs = objects_allocs_for_zone(zone);
 
   /* Then we build the table. */
-  table = fn_hash_with_allocs_with_callbacks(allocs, callbacks);
+  table = objects_hash_with_allocs_with_callbacks(allocs, callbacks);
 
   if (table != NULL)
   {
-    fn_generic_t extra;
+    const void *extra;
 
     /* Resize TABLE to CAPACITY. */
-    fn_hash_resize(table, capacity);
+    objects_hash_resize(table, capacity);
 
     /* Set aside space for the NSHashTableExtra. */
-    __void_p__(extra) = &callBacks;
+    extra = &callBacks;
 
     /* Add EXTRA to TABLE.  This takes care of everything for us. */
-    fn_hash_set_extra_callbacks(table, _NSHT_extra_callbacks);
-    fn_hash_set_extra(table, extra);
+    objects_hash_set_extra_callbacks(table, _NSHT_extra_callbacks);
+    objects_hash_set_extra(table, extra);
   }
 
   /* Wah-hoo! */
@@ -263,8 +253,8 @@ NSCreateHashTableWithZone(NSHashTableCallBacks callBacks,
 }
 
 NSHashTable *
-NSCreateHashTable(NSHashTableCallBacks callBacks,
-                  unsigned int capacity)
+NSCreateHashTable (NSHashTableCallBacks callBacks,
+		   unsigned int capacity)
 {
   return NSCreateHashTableWithZone(callBacks, capacity, NULL);
 }
@@ -272,15 +262,15 @@ NSCreateHashTable(NSHashTableCallBacks callBacks,
 /** Copying **/
 
 NSHashTable *
-NSCopyHashTableWithZone(NSHashTable *table, NSZone *zone)
+NSCopyHashTableWithZone (NSHashTable *table, NSZone *zone)
 {
-  fn_allocs_t allocs;
+  objects_allocs_t allocs;
   NSHashTable *new_table;
 
   /* Due to the wonders of modern Libfn technology, everything we care
    * about is automagically transferred. */
-  allocs = fn_allocs_for_zone(zone);
-  new_table = fn_hash_copy_with_allocs(table, allocs);
+  allocs = objects_allocs_for_zone(zone);
+  new_table = objects_hash_copy_with_allocs(table, allocs);
 
   return new_table;
 }
@@ -288,95 +278,66 @@ NSCopyHashTableWithZone(NSHashTable *table, NSZone *zone)
 /** Destroying **/
 
 void
-NSFreeHashTable(NSHashTable *table)
+NSFreeHashTable (NSHashTable *table)
 {
-  /* Due to the wonders of modern Libfn technology, everything we care
-   * about is automagically and safely destroyed. */
-  fn_hash_dealloc(table);
+  /* Due to the wonders of modern Libobjects structure technology,
+   * everything we care about is automagically and safely destroyed. */
+  objects_hash_dealloc(table);
   return;
 }
 
 /** Resetting **/
 
 void
-NSResetHashTable(NSHashTable *table)
+NSResetHashTable (NSHashTable *table)
 {
-  fn_hash_empty(table);
+  objects_hash_empty(table);
   return;
 }
 
 /** Comparing **/
 
 BOOL
-NSCompareHashTables(NSHashTable *table1, NSHashTable *table2)
+NSCompareHashTables (NSHashTable *table1, NSHashTable *table2)
 {
-  return (fn_hash_is_equal_to_hash(table1, table2) ? YES : NO);
+  return (objects_hash_is_equal_to_hash(table1, table2) ? YES : NO);
 }
 
 /** Counting **/
 
 unsigned int
-NSCountHashTable(NSHashTable *table)
+NSCountHashTable (NSHashTable *table)
 {
-  return (unsigned int) fn_hash_count(table);
+  return (unsigned int) objects_hash_count(table);
 }
 
 /** Retrieving **/
 
 void *
-NSHashGet(NSHashTable *table, const void *pointer)
+NSHashGet (NSHashTable *table, const void *pointer)
 {
-  fn_generic_t element;
-  fn_generic_t member;
-
-  /* Stuff POINTER into (the `void *' facet of) ELEMENT. */
-  __void_p__(element) = pointer;
-
-  /* Look up ELEMENT in TABLE. */
-  member = fn_hash_element(table, element);
-
-  /* Return the `void *' facet of MEMBER. */
-  return __void_p__(member);
+  /* Just make the call.  You know the number. */
+  return (void*) objects_hash_element (table, pointer);
 }
 
 NSArray *
-NSAllHashTableObjects(NSHashTable *table)
+NSAllHashTableObjects (NSHashTable *table)
 {
-  NSArray *array;
-  fn_generic_t *elements;
-  id *objects;
-  unsigned int count;
+  NSMutableArray *array;
+  NSHashEnumerator enumerator;
+  id element;
 
   /* FIXME: We should really be locking TABLE somehow, to insure
    * the thread-safeness of this method. */
 
-  /* Get an array of the (generically-typed) elements of TABLE. */
-  elements = fn_hash_all_elements(table);
+  /* Get us a mutable array with plenty of space. */
+  array = [NSMutableArray arrayWithCapacity:NSCountHashTable(table)];
 
-  /* How many thing are in TABLE? */
-  count = NSCountHashTable(table);
+  /* Get an enumerator for TABLE. */
+  enumerator = NSEnumerateHashTable(table);
 
-  /* Make enough room for our array of `id's together with a
-   * terminating `nil' that we add below. */
-  objects = fn_calloc(fn_hash_allocs(table), count + 1, sizeof(id));
-
-  /* Step through the generic array and copy the `id' facet of each
-   * into the corresponding member of the objects array.  Remember
-   * that this function is only suppossed to be called when TABLE
-   * contains objects.  Otherwise, everything goes to hell remarkably
-   * quickly. */
-  for (i = 0; i < count; ++i)
-    objects[i] = __id__(elements[i]);
-
-  /* `nil' terminate OBJECTS. */
-  objects[i] = nil;
-
-  /* Build the NSArray to return. */
-  array = [[NSArray alloc] initWithObjects:objects count:count];
-
-  /* Free up all the space we allocated here. */
-  fn_free(fn_hash_allocs(table), elements);
-  fn_free(fn_hash_allocs(table), objects);
+  while ((element = NSNextHashEnumeratorItem(&enumerator)) != 0)
+    [array addObject:element];
 
   /* FIXME: Should ARRAY returned be `autorelease'd? */
   return [array autorelease];
@@ -385,91 +346,76 @@ NSAllHashTableObjects(NSHashTable *table)
 /** Enumerating **/
 
 NSHashEnumerator
-NSEnumerateHashTable(NSHashTable *table)
+NSEnumerateHashTable (NSHashTable *table)
 {
-  return fn_hash_enumerator(table);
+  return objects_hash_enumerator (table);
 }
 
 void *
-NSNextHashEnumeratorItem(NSHashEnumerator *enumerator)
+NSNextHashEnumeratorItem (NSHashEnumerator *enumerator)
 {
-  fn_generic_t element;
+  const void *element;
 
   /* Grab the next element. */
-  fn_hash_enumerator_next_element(enumerator, &element);
+  objects_hash_enumerator_next_element (enumerator, &element);
 
-  /* Return ELEMENT's `void *' facet. */
-  return __void_p__(element);
+  /* Return ELEMENT. */
+  return (void*) element;
 }
 
 /** Adding **/
 
 void
-NSHashInsert(NSHashTable *table, const void *pointer)
+NSHashInsert (NSHashTable *table, const void *pointer)
 {
-  fn_generic_t element;
-
-  /* Stuff POINTER into ELEMENT. */
-  __void_p__(element) = (void *)pointer;
-
-  /* Place ELEMENT in TABLE. */
-  fn_hash_add_element(table, element);
+  /* Place POINTER in TABLE. */
+  objects_hash_add_element (table, pointer);
 
+  /* OpenStep doesn't care for any return value, so... */
   return;
 }
 
 void
-NSHashInsertKnownAbsent(NSHashTable *table, const void *pointer)
+NSHashInsertKnownAbsent (NSHashTable *table, const void *element)
 {
-  fn_generic_t element;
-
-  __void_p__(element) = pointer;
-
-  if (fn_hash_contains_element(table, element))
+  if (objects_hash_contains_element(table, element))
   {
     /* FIXME: I should make this give the user/programmer more
      * information.  Not difficult to do, just something for a later
      * date. */
     [NSException raise:NSInvalidArgumentException
                  format:@"Attempted reinsertion of \"%@\" into a hash table.",
-                 NSHT_DESCRIBE(table, pointer)];
+                 NSHT_DESCRIBE(table, element)];
   }
   else
   {
-    fn_hash_add_element_known_absent(table, element);
+    objects_hash_add_element_known_absent(table, element);
   }
 
   return;
 }
 
 void *
-NSHashInsertIfAbsent(NSHashTable *table, const void *pointer)
+NSHashInsertIfAbsent (NSHashTable *table, const void *element)
 {
-  fn_generic_t element;
-
-  /* Stuff POINTER into ELEMENT. */
-  __void_p__(element) = (void *)pointer;
+  const void *old_element;
 
   /* Place ELEMENT in TABLE. */
-  element = fn_hash_add_element_if_absent(table, element);
+  old_element = objects_hash_add_element_if_absent(table, element);
 
-  /* Return the `void *' facet of ELEMENT. */
-  return __void_p__(element);
+  /* Return the version of ELEMENT in TABLE now. */
+  return (void*) old_element;
 }
 
 /** Removing **/
 
 void
-NSHashRemove(NSHashTable *table, const void *pointer)
+NSHashRemove (NSHashTable *table, const void *element)
 {
-  fn_generic_t element;
-
-  /* Stuff POINTER into ELEMENT. */
-  __void_p__(element) = pointer;
-
   /* Remove ELEMENT from TABLE. */
-  fn_hash_remove_element(table, element);
+  objects_hash_remove_element(table, element);
 
+  /* OpenStep doesn't care about return values here, so... */
   return;
 }
 
@@ -479,25 +425,24 @@ NSHashRemove(NSHashTable *table, const void *pointer)
  * If somebody has a clear idea of what this string should look like,
  * please tell me, and I'll make it happen. */
 NSString *
-NSStringFromHashTable(NSHashTable *table)
+NSStringFromHashTable (NSHashTable *table)
 {
-  NSString *string;
+  NSMutableString *string;
   NSHashEnumerator enumerator;
-  void *pointer;
+  const void *pointer;
 
   /* This will be our string. */
-  string = [NSMutableString string];
+  string = [NSMutableString stringWithCapacity:0];
 
   /* Get an enumerator for TABLE. */
   enumerator = NSEnumerateHashTable(table);
 
   /* Iterate over the elements of TABLE, appending the description of
    * each to the mutable string STRING. */
-  while ((pointer = NSNextHashEnumeratorItem(&enumerator)) != NULL)
+  while ((pointer = NSNextHashEnumeratorItem(&enumerator)) != 0)
     [string appendFormat:@"%@;", NSHT_DESCRIBE(table, pointer)];
 
   /* Note that this string'll need to be `retain'ed. */
   /* FIXME: Should I `autorelease' STRING?  I think so. */
-  return [string autorelease];
+  return (NSString *)[string autorelease];
 }
-

Source/NSMapTable.m

@@ -26,17 +26,19 @@
 
 /**** Included Headers *******************************************************/
 
+#include <Foundation/NSObject.h>
 #include <Foundation/NSString.h>
 #include <Foundation/NSArray.h>
 #include <Foundation/NSException.h>
-#include <Foundation/_NSLibfn.h>
 #include <Foundation/NSMapTable.h>
-#include <fn/map.h>
+#include <NSCallBacks.h>
+#include <Foundation/atoz.h>
+#include <objects/map.h>
 
 /**** Type, Constant, and Macro Definitions **********************************/
 
 /* This is for keeping track of information... */     
-typedef struct _NSMT_extra NSMT_extra_t;
+typedef struct _NSMT_extra _NSMT_extra_t;
 
 struct _NSMT_extra
 {
@@ -56,43 +58,43 @@ const NSMapTableKeyCallBacks NSIntMapKeyCallBacks =
 {
   (NSMT_hash_func_t) _NS_int_hash,
   (NSMT_is_equal_func_t) _NS_int_is_equal,
-  (NSMT_retain_func_t) fn_null_function,
-  (NSMT_release_func_t) fn_null_function,
+  (NSMT_retain_func_t) _NS_int_retain,
+  (NSMT_release_func_t) _NS_int_release,
   (NSMT_describe_func_t) _NS_int_describe,
-  (const void *) 0
+  0
 };
 
 const NSMapTableKeyCallBacks NSNonOwnedPointerMapKeyCallBacks = 
 {
-  (NSMT_hash_func_t) _NS_void_p_hash,
-  (NSMT_is_equal_func_t) _NS_void_p_is_equal,
-  (NSMT_retain_func_t) fn_null_function,
-  (NSMT_release_func_t) fn_null_function,
-  (NSMT_describe_func_t) _NS_void_p_describe,
-  (const void *) NULL
+  (NSMT_hash_func_t) _NS_non_owned_void_p_hash,
+  (NSMT_is_equal_func_t) _NS_non_owned_void_p_is_equal,
+  (NSMT_retain_func_t) _NS_non_owned_void_p_retain,
+  (NSMT_release_func_t) _NS_non_owned_void_p_release,
+  (NSMT_describe_func_t) _NS_non_owned_void_p_describe,
+  0
 };
 
 const NSMapTableKeyCallBacks NSNonOwnedPointerOrNullMapKeyCallBacks = 
 {
-  (NSMT_hash_func_t) _NS_void_p_hash,
-  (NSMT_is_equal_func_t) _NS_void_p_is_equal,
-  (NSMT_retain_func_t) fn_null_function,
-  (NSMT_release_func_t) fn_null_function,
-  (NSMT_describe_func_t) _NS_void_p_describe,
+  (NSMT_hash_func_t) _NS_non_owned_void_p_hash,
+  (NSMT_is_equal_func_t) _NS_non_owned_void_p_is_equal,
+  (NSMT_retain_func_t) _NS_non_owned_void_p_retain,
+  (NSMT_release_func_t) _NS_non_owned_void_p_release,
+  (NSMT_describe_func_t) _NS_non_owned_void_p_describe,
   /* FIXME: Oh my.  Is this really ok?  I did it in a moment of
    * weakness.  A fit of madness, I say!  And if this is wrong, what
    * *should* it be?!? */
-  (const void *) -1
+  (const void *)-1
 };
 
 const NSMapTableKeyCallBacks NSNonRetainedObjectMapKeyCallBacks = 
 {
-  (NSMT_hash_func_t) _NS_id_hash,
-  (NSMT_is_equal_func_t) _NS_id_is_equal,
-  (NSMT_retain_func_t) fn_null_function,
-  (NSMT_release_func_t) fn_null_function,
-  (NSMT_describe_func_t) _NS_id_describe,
-  (const void *) NULL
+  (NSMT_hash_func_t) _NS_non_retained_id_hash,
+  (NSMT_is_equal_func_t) _NS_non_retained_id_is_equal,
+  (NSMT_retain_func_t) _NS_non_retained_id_retain,
+  (NSMT_release_func_t) _NS_non_retained_id_release,
+  (NSMT_describe_func_t) _NS_non_retained_id_describe,
+  0
 };
 
 const NSMapTableKeyCallBacks NSObjectMapKeyCallBacks = 
@@ -102,31 +104,31 @@ const NSMapTableKeyCallBacks NSObjectMapKeyCallBacks =
   (NSMT_retain_func_t) _NS_id_retain,
   (NSMT_release_func_t) _NS_id_release,
   (NSMT_describe_func_t) _NS_id_describe,
-  (const void *) NULL
+  0
 };
 
 const NSMapTableKeyCallBacks NSOwnedPointerMapKeyCallBacks = 
 {
-  (NSMT_hash_func_t) _NS_void_p_hash,
-  (NSMT_is_equal_func_t) _NS_void_p_is_equal,
-  (NSMT_retain_func_t) fn_null_function,
-  (NSMT_release_func_t) _NS_void_p_release,
-  (NSMT_describe_func_t) _NS_void_p_describe,
-  (const void *) NULL
+  (NSMT_hash_func_t) _NS_owned_void_p_hash,
+  (NSMT_is_equal_func_t) _NS_owned_void_p_is_equal,
+  (NSMT_retain_func_t) _NS_owned_void_p_retain,
+  (NSMT_release_func_t) _NS_owned_void_p_release,
+  (NSMT_describe_func_t) _NS_owned_void_p_describe,
+  0
 };
 
 const NSMapTableValueCallBacks NSIntMapValueCallBacks = 
 {
-  (NSMT_retain_func_t) fn_null_function,
-  (NSMT_release_func_t) fn_null_function,
+  (NSMT_retain_func_t) _NS_int_retain,
+  (NSMT_release_func_t) _NS_int_release,
   (NSMT_describe_func_t) _NS_int_describe
 };
 
 const NSMapTableValueCallBacks NSNonOwnedPointerMapValueCallBacks = 
 {
-  (NSMT_retain_func_t) fn_null_function,
-  (NSMT_release_func_t) fn_null_function,
-  (NSMT_describe_func_t) _NS_void_p_describe
+  (NSMT_retain_func_t) _NS_non_owned_void_p_retain,
+  (NSMT_release_func_t) _NS_non_owned_void_p_release,
+  (NSMT_describe_func_t) _NS_non_owned_void_p_describe
 };
 
 const NSMapTableValueCallBacks NSObjectMapValueCallBacks = 
@@ -138,18 +140,18 @@ const NSMapTableValueCallBacks NSObjectMapValueCallBacks =
 
 const NSMapTableValueCallBacks NSOwnedPointerMapValueCallBacks = 
 {
-  (NSMT_retain_func_t) fn_null_function,
-  (NSMT_release_func_t) _NS_void_p_release,
-  (NSMT_describe_func_t) _NS_void_p_describe
+  (NSMT_retain_func_t) _NS_owned_void_p_retain,
+  (NSMT_release_func_t) _NS_owned_void_p_release,
+  (NSMT_describe_func_t) _NS_owned_void_p_describe
 };
 
 /** Macros **/
 
 #define NSMT_ZONE(T) \
-  ((NSZone *)((fn_map_allocs((fn_map_t *)(T))).user_data))
+  ((NSZone *)((objects_map_allocs((objects_map_t *)(T))).user_data))
 
 #define NSMT_EXTRA(T) \
-  ((NSMT_extra_t *)(__void_p__(fn_map_extra((fn_map_t *)(T)))))
+  ((_NSMT_extra_t *)(objects_map_extra((objects_map_t *)(T))))
 
 #define NSMT_KEY_CALLBACKS(T) \
   ((NSMT_EXTRA((T)))->keyCallBacks)
@@ -166,126 +168,118 @@ const NSMapTableValueCallBacks NSOwnedPointerMapValueCallBacks =
 /** Dummy callbacks **/
 
 size_t
-_NSMT_key_hash(fn_generic_t element, void *table)
+_NSMT_key_hash (const void *element, const void *table)
 {
   return NSMT_KEY_CALLBACKS(table).hash((NSMapTable *)table,
-                                        __void_p__(element));
+                                        element);
 }
 
 int
-_NSMT_key_compare(fn_generic_t element1,
-                  fn_generic_t element2,
-                  void *table)
+_NSMT_key_compare (const void *element1, const void *element2, 
+		   const void *table)
 {
   return !(NSMT_KEY_CALLBACKS(table).isEqual((NSMapTable *)table,
-                                             __void_p__(element1),
-                                             __void_p__(element2)));
+                                             element1,
+                                             element2));
 }
 
 int
-_NSMT_key_is_equal(fn_generic_t element1,
-                   fn_generic_t element2,
-                   void *table)
+_NSMT_key_is_equal (const void *element1, const void *element2, 
+		    const void *table)
 {
   return NSMT_KEY_CALLBACKS(table).isEqual((NSMapTable *) table,
-                                           __void_p__(element1),
-                                           __void_p__(element2));
+                                           element1,
+                                           element2);
 }
 
-fn_generic_t
-_NSMT_key_retain(fn_generic_t element, void *table)
+void *
+_NSMT_key_retain (const void *element, const void *table)
 {
-  NSMT_KEY_CALLBACKS(table).retain((NSMapTable *)table,
-                                   __void_p__(element));
-  return element;
+  NSMT_KEY_CALLBACKS(table).retain((NSMapTable *)table, element);
+  return (void*) element;
 }
 
 void
-_NSMT_key_release(fn_generic_t element, void *table)
+_NSMT_key_release (void *element, const void *table)
 {
-  NSMT_KEY_CALLBACKS(table).release(table, __void_p__(element));
+  NSMT_KEY_CALLBACKS(table).release ((NSMapTable*)table, element);
   return;
 }
 
-fn_generic_t
-_NSMT_value_retain(fn_generic_t element, void *table)
+void *
+_NSMT_value_retain (const void *element, const void *table)
 {
-  NSMT_VALUE_CALLBACKS(table).retain((NSMapTable *)table,
-                                     __void_p__(element));
-  return element;
+  NSMT_VALUE_CALLBACKS(table).retain ((NSMapTable *)table, element);
+  return (void*) element;
 }
 
 void
-_NSMT_value_release(fn_generic_t element, void *table)
+_NSMT_value_release (void *element, const void *table)
 {
-  NSMT_VALUE_CALLBACKS(table).release(table, __void_p__(element));
+  NSMT_VALUE_CALLBACKS(table).release ((NSMapTable*)table, element);
   return;
 }
 
 /* These are wrappers for getting at the real callbacks. */
-fn_callbacks_t _NSMT_key_callbacks = 
+objects_callbacks_t _NSMT_key_callbacks = 
 {
   _NSMT_key_hash,
   _NSMT_key_compare,
   _NSMT_key_is_equal,
   _NSMT_key_retain,
   _NSMT_key_release,
-  (fn_describe_func_t)fn_null_function,
+  0,
   0 
 };
 
-fn_callbacks_t
-_NSMT_callbacks_for_key_callbacks(NSMapTableKeyCallBacks keyCallBacks)
+objects_callbacks_t
+_NSMT_callbacks_for_key_callbacks (NSMapTableKeyCallBacks keyCallBacks)
 {
-  fn_callbacks_t cb = _NSMT_key_callbacks;
+  objects_callbacks_t cb = _NSMT_key_callbacks;
 
-  __void_p__(cb.not_an_item_marker) = (void *)(keyCallBacks.notAKeyMarker);
+  cb.not_an_item_marker = keyCallBacks.notAKeyMarker;
 
-  return callbacks;
+  return cb;
 }
 
-fn_callbacks_t _NSMT_value_callbacks = 
+objects_callbacks_t _NSMT_value_callbacks = 
 {
-  (fn_hash_func_t) fn_generic_hash,
-  (fn_compare_func_t) fn_generic_compare,
-  (fn_is_equal_func_t) fn_generic_is_equal,
+  (objects_hash_func_t) objects_void_p_hash,
+  (objects_compare_func_t) objects_void_p_compare,
+  (objects_is_equal_func_t) objects_void_p_is_equal,
   _NSMT_value_retain,
   _NSMT_value_release,
-  (fn_describe_func_t)fn_null_function,
+  0,
   0
 };
 
 /** Extra, extra **/
 
 /* Make a copy of a hash table's callbacks. */
-fn_generic_t
-_NSMT_extra_retain(fn_generic_t g, void *table)
+void *
+_NSMT_extra_retain(const void *extra, const void *table)
 {
   /* A pointer to some space for new callbacks. */
-  NSMT_extra_t *new_extra;
+  _NSMT_extra_t *new_extra;
 
   /* Set aside space for our new callbacks in the right zone. */
-  new_extra = (NSMT_extra_t *)NSZoneMalloc(NSMT_ZONE(table),
-                                           sizeof(NSMT_extra_t));
+  new_extra = (_NSMT_extra_t *)NSZoneMalloc(NSMT_ZONE(table),
+                                           sizeof(_NSMT_extra_t));
 
   /* Copy the old callbacks into NEW_EXTRA. */
-  *new_extra = *((NSMT_extra_t *)(__void_p__(g)))
-
-  /* Stuff NEW_EXTRA into G. */
-  __void_p__(g) = new_extra;
+  *new_extra = *((_NSMT_extra_t *)(extra));
 
   /* Return our new EXTRA. */
-  return g;
+  return new_extra;
 }
 
 void
-_NSMT_extra_release(fn_generic_t extra, void *table)
+_NSMT_extra_release(void *extra, const void *table)
 {
-  void *ptr = __void_p__(extra);
   NSZone *zone = NSMT_ZONE(table);
 
-  if (ptr != NULL)
-    NSZoneFree(zone, ptr);
+  if (extra != 0)
+    NSZoneFree(zone, extra);
 
   return;
 }
@@ -293,14 +287,14 @@ _NSMT_extra_release(fn_generic_t extra, void *table)
 /* The idea here is that these callbacks ensure that the
  * NSMapTableCallbacks which are associated with a given NSMapTable
  * remain so throughout the life of the table and its copies. */
-fn_callbacks_t _NSMT_extra_callbacks = 
+objects_callbacks_t _NSMT_extra_callbacks = 
 {
-  (fn_hash_func_t) fn_generic_hash,
-  (fn_is_equal_func_t) fn_generic_is_equal,
-  (fn_compare_func_t) fn_generic_compare,
+  (objects_hash_func_t) objects_void_p_hash,
+  (objects_compare_func_t) objects_void_p_compare,
+  (objects_is_equal_func_t) objects_void_p_is_equal,
   _NSMT_extra_retain,
   _NSMT_extra_release,
-  (fn_describe_func_t) fn_null_function,
+  0,
   0
 };
 
@@ -315,33 +309,38 @@ NSCreateMapTableWithZone(NSMapTableKeyCallBacks keyCallBacks,
                          NSZone *zone)
 {
   NSMapTable *table;
-  fn_callbacks_t key_callbacks, value_callbacks;
-  fn_allocs_t alloc;
+  objects_callbacks_t key_callbacks, value_callbacks;
+  objects_allocs_t allocs;
 
   /* Transform the callbacks we were given. */
   key_callbacks = _NSMT_callbacks_for_key_callbacks(keyCallBacks);
   value_callbacks = _NSMT_value_callbacks;
   
   /* Get some useful allocs. */
-  alloc = fn_allocs_for_zone(zone);
+  allocs = objects_allocs_for_zone(zone);
 
   /* Create a map table. */
-  table = fn_map_with_allocs_with_callbacks(allocs, key_callbacks,
-                                            value_callbacks);
+  table = objects_map_with_allocs_with_callbacks(allocs, key_callbacks,
+                                                 value_callbacks);
 
   /* Adjust the capacity of TABLE. */
-  fn_map_resize(table, capacity);
+  objects_map_resize(table, capacity);
 
-  if (table != NULL)
+  if (table != 0)
   {
-    NSMapTableExtras *extras;
+    _NSMT_extra_t extra;
 
-    /* Set aside space for the NSMapTableExtras. */
-    extras = _NSNewMapTableExtrasWithZone(zone);
-    extras->keyCallBacks = keyCallBacks;
-    extras->valueCallBacks = valueCallBacks;
+    /* Set aside space for TABLE's extra. */
+    extra.keyCallBacks = keyCallBacks;
+    extra.valueCallBacks = valueCallBacks;
 
-    table->extras = extras;
+    /* These callbacks are defined above. */
+    objects_map_set_extra_callbacks(table, _NSMT_extra_callbacks);
+
+    /* We send a pointer because that's all the room we have.  
+     * The callbacks make a copy of these extras, so we needn't
+     * worry about the way they disappear real soon now. */
+    objects_map_set_extra(table, &extra);
   }
 
   return table;
@@ -352,21 +351,18 @@ NSCreateMapTable(NSMapTableKeyCallBacks keyCallBacks,
 		 NSMapTableValueCallBacks valueCallBacks,
 		 unsigned int capacity)
 {
-  return NSCreateMapTableWithZone(keyCallBacks,
-                                  valueCallBacks,
-				  capacity,
-                                  NULL);
+  return NSCreateMapTableWithZone(keyCallBacks, valueCallBacks,
+				  capacity, 0);
 }
 
-/* FIXME: CODE THIS! */
 NSMapTable *
 NSCopyMapTableWithZone(NSMapTable *table, NSZone *zone)
 {
-  fn_allocs_t allocs;
+  objects_allocs_t allocs;
   NSMapTable *new_table;
 
-  allocs = fn_allocs_for_zone(zone);
-  new_table = fn_map_copy_with_allocs(table, alloc);
+  allocs = objects_allocs_for_zone(zone);
+  new_table = objects_map_copy_with_allocs(table, allocs);
 
   return new_table;
 }
@@ -376,14 +372,14 @@ NSCopyMapTableWithZone(NSMapTable *table, NSZone *zone)
 void
 NSFreeMapTable(NSMapTable *table)
 {
-  fn_map_dealloc(table);
+  objects_map_dealloc(table);
   return;
 }
 
 void
 NSResetMapTable(NSMapTable *table)
 {
-  fn_map_empty(table);
+  objects_map_empty(table);
   return;
 }
 
@@ -392,7 +388,7 @@ NSResetMapTable(NSMapTable *table)
 BOOL
 NSCompareMapTables(NSMapTable *table1, NSMapTable *table2)
 {
-  return fn_map_is_equal_map(table1, table2) ? YES : NO;
+  return objects_map_is_equal_to_map(table1, table2) ? YES : NO;
 }
 
 /** Getting the number of items in an NSMapTable **/
@@ -400,7 +396,7 @@ NSCompareMapTables(NSMapTable *table1, NSMapTable *table2)
 unsigned int
 NSCountMapTable(NSMapTable *table)
 {
-  return (unsigned int) fn_map_count(table);
+  return (unsigned int) objects_map_count(table);
 }
 
 /** Retrieving items from an NSMapTable **/
@@ -409,20 +405,10 @@ BOOL
 NSMapMember(NSMapTable *table, const void *key,
 	    void **originalKey, void **value)
 {
-  fn_generic_t k, ok, v;
   int i;
 
-  /* Stuff KEY into K. */
-  __void_p__(k) = key;
-
   /* Check for K in TABLE. */
-  i = fn_map_key_and_value(table, k, &ok, &v);
-
-  /* Put the `void *' facet of OK and V into ORIGINALKEY and VALUE. */
-  if (originalKey != NULL)
-    *originalKey = __void_p__(ok);
-  if (value != NULL)
-    *value = __void_p__(v);
+  i = objects_map_key_and_value_at_key (table, key, originalKey, value);
 
   /* Indicate our state of success. */
   return i ? YES : NO;
@@ -431,28 +417,25 @@ NSMapMember(NSMapTable *table, const void *key,
 void *
 NSMapGet(NSMapTable *table, const void *key)
 {
-  return fn_map_value(table, key);
+  return (void*) objects_map_value_at_key (table, key);
 }
 
 NSMapEnumerator
 NSEnumerateMapTable(NSMapTable *table)
 {
-  return fn_map_enumerator(table);
+  return objects_map_enumerator(table);
 }
 
 BOOL
 NSNextMapEnumeratorPair(NSMapEnumerator *enumerator,
 			void **key, void **value)
 {
-  fn_generic_t k, v;
   int i;
 
   /* Get the next pair. */
-  i = fn_map_enumerator_next_key_and_value(enumerator, &k, &v);
-
-  /* Put the `void *' facet of K and V into KEY and VALUE. */
-  *key = __void_p__(k);
-  *value = __void_p__(v);
+  i = objects_map_enumerator_next_key_and_value (enumerator, 
+						 (const void**)key, 
+						 (const void**)value);
 
   /* Indicate our success or failure. */
   return i ? YES : NO;
@@ -461,50 +444,41 @@ NSNextMapEnumeratorPair(NSMapEnumerator *enumerator,
 NSArray *
 NSAllMapTableKeys(NSMapTable *table)
 {
-  NSArray *array;
-  fn_generic_t *keys;
-  id *objects;
-  unsigned int count;
+  NSMutableArray *keyArray;
+  NSMapEnumerator enumerator;
+  id key;
 
-  count = fn_map_count(table);
-  keys = fn_map_all_keys(table);
-  objects = fn_calloc(fn_set_allocs(table), count + 1, sizeof(id));
+  /* Create our mutable key array. */
+  keyArray = [NSMutableArray arrayWithCapacity: NSCountMapTable (table)];
 
-  for (i = 0; i < count; ++i)
-    objects[i] = __id__(keys[i]);
+  /* Get an enumerator for TABLE. */
+  enumerator = NSEnumerateMapTable (table);
 
-  objects[i] = nil;
-
-  array = [[NSArray alloc] initWithObjects:objects count:count];
-  
-  fn_free(fn_map_allocs(table), keys);
-  fn_free(fn_map_allocs(table), objects);
+  /* Step through TABLE... */
+  while (NSNextMapEnumeratorPair (&enumerator, (void**)&key, 0))
+    [keyArray addObject: key];
 
   /* FIXME: Should ARRAY returned be `autorelease'd? */
-  return [array autorelease];
+  return [keyArray autorelease];
 }
 
 NSArray *
 NSAllMapTableValues(NSMapTable *table)
 {
-  NSArray *array;
-  fn_generic_t *values;
-  id *objects;
-  unsigned int count;
+  NSMutableArray *array;
+  NSMapEnumerator enumerator;
+  id valueArray;
+  id value;
 
-  count = fn_map_count(table);
-  values = fn_map_all_values(table);
-  objects = fn_calloc(fn_set_allocs(table), count + 1, sizeof(id));
+  /* Create our mutable value array. */
+  valueArray = [NSMutableArray arrayWithCapacity:NSCountMapTable(table)];
 
-  for (i = 0; i < count; ++i)
-    objects[i] = __id__(values[i]);
+  /* Get an enumerator for TABLE. */
+  enumerator = NSEnumerateMapTable(table);
 
-  objects[i] = nil;
-
-  array = [[NSArray alloc] initWithObjects:objects count:count];
-  
-  fn_free(fn_map_allocs(table), keys);
-  fn_free(fn_map_allocs(table), objects);
+  /* Step through TABLE... */
+  while (NSNextMapEnumeratorPair (&enumerator, 0, (void**)&value))
+    [valueArray addObject:value];
 
   /* FIXME: Should ARRAY returned be `autorelease'd? */
   return [array autorelease];
@@ -515,14 +489,8 @@ NSAllMapTableValues(NSMapTable *table)
 void
 NSMapInsert(NSMapTable *table, const void *key, const void *value)
 {
-  fn_generic_t k, v;
-
-  /* Stuff KEY and VALUE into K and V. */
-  __void_p__(k) = key;
-  __void_p__(v) = value;
-
-  /* Put K -> V into TABLE. */
-  fn_map_at_key_put_value(table, k, v);
+  /* Put KEY -> VALUE into TABLE. */
+  objects_map_at_key_put_value (table, key, value);
 
   return;
 }
@@ -530,30 +498,23 @@ NSMapInsert(NSMapTable *table, const void *key, const void *value)
 void *
 NSMapInsertIfAbsent(NSMapTable *table, const void *key, const void *value)
 {
-  fn_generic_t k, v, m;
+  void *old_key;
 
-  /* Stuff KEY and VALUE into K and V. */
-  __void_p__(k) = key;
-  __void_p__(v) = value;
-
-  /* Put K -> V into TABLE. */
-  m = fn_map_at_key_put_value_if_absent(table, k, v);
-
-  /* Return the `void *' facet of M. */
-  return __void_p__(m);
+  if (objects_map_contains_key (table, key))
+    return (void*) objects_map_key (table, key);
+  else
+  {
+    /* Put KEY -> VALUE into TABLE. */
+    objects_map_at_key_put_value_known_absent (table, key, value);
+    return NULL;
+  }
 }
 
 void
 NSMapInsertKnownAbsent(NSMapTable *table, const void *key, const void *value)
 {
-  fn_generic_t k, v;
-
-  /* Stuff KEY and VALUE into K and V. */
-  __void_p__(k) = key;
-  __void_p__(v) = value;
-
   /* Is the key already in the table? */
-  if (fn_map_contains_key(table, k))
+  if (objects_map_contains_key(table, key))
   {
     /* Ooh.  Bad.  The docs say to raise an exception! */
     /* FIXME: I should make this much more informative.  */
@@ -563,7 +524,7 @@ NSMapInsertKnownAbsent(NSMapTable *table, const void *key, const void *value)
   else
   {
     /* Well, we know it's not there, so... */
-    fn_map_at_key_put_value_known_absent(table, k, v);
+    objects_map_at_key_put_value_known_absent (table, key, value);
   }
 
   /* Yah-hoo! */
@@ -575,7 +536,7 @@ NSMapInsertKnownAbsent(NSMapTable *table, const void *key, const void *value)
 void
 NSMapRemove(NSMapTable *table, const void *key)
 {
-  fn_map_remove_key(table, key);
+  objects_map_remove_key (table, key);
   return;
 }
 
@@ -584,14 +545,14 @@ NSMapRemove(NSMapTable *table, const void *key)
 NSString *
 NSStringFromMapTable(NSMapTable *table)
 {
-  NSString *string;
+  NSMutableString *string;
   NSMapEnumerator enumerator;
   NSMapTableKeyCallBacks keyCallBacks;
   NSMapTableValueCallBacks valueCallBacks;
   void *key, *value;
 
   /* Get an empty mutable string. */
-  string = [NSMutableString string];
+  string = [NSMutableString stringWithCapacity:0];
 
   /* Pull the NSMapTable...CallBacks out of the mess. */
   keyCallBacks = NSMT_KEY_CALLBACKS(table);

Source/callbacks-char_p.c

@@ -45,7 +45,7 @@ objects_callbacks_t objects_callbacks_for_char_p =
 /**** Function Implementations ***********************************************/
 
 size_t
-objects_char_p_hash(void *cptr)
+objects_char_p_hash (const void *cptr)
 {
   register char *s = (char *) cptr;
   register size_t h = 0;
@@ -58,7 +58,7 @@ objects_char_p_hash(void *cptr)
 }
 
 int
-objects_char_p_compare(void *cptr, void *dptr)
+objects_char_p_compare (const void *cptr, const void *dptr)
 {
   register char *s = (char *) cptr;
   register char *t = (char *) dptr;
@@ -86,7 +86,7 @@ objects_char_p_compare(void *cptr, void *dptr)
  * internationalization here.  CPTR and DPTR are taken to be C strings
  * in the default (seven or) eight bit character encoding. */
 int
-objects_char_p_is_equal(register void *cptr, register void *dptr)
+objects_char_p_is_equal (register const void *cptr, register const void *dptr)
 {
   register char *s = (char *) cptr;
   register char *t = (char *) dptr;
@@ -108,20 +108,20 @@ objects_char_p_is_equal(register void *cptr, register void *dptr)
   }
 }
 
-void *
-objects_char_p_retain(void *cptr)
+const void *
+objects_char_p_retain (const void *cptr)
 {
   return cptr;
 }
 
 void
-objects_char_p_release(void *cptr)
+objects_char_p_release (const void *cptr)
 {
   return;
 }
 
-void *
-objects_char_p_describe(void *cptr)
+const void *
+objects_char_p_describe (const void *cptr)
 {
   /* FIXME: Code this.  But first, figure out what it should do, OK? */
   return 0;

Source/callbacks-id.m

@@ -53,41 +53,45 @@ objects_callbacks_t objects_callbacks_for_id =
  * that there was already a built-in call to do this sort of thing. */
 
 size_t
-objects_id_hash(void *obj)
+objects_id_hash(const void *obj)
 {
   return (size_t)[(id)obj hash];
 }
 
 int
-objects_id_compare(void *obj, void *jbo)
+objects_id_compare(const void *obj, const void *jbo)
 {
   return (int)[(id)obj compare:(id)jbo];
 }
 
 int
-objects_id_is_equal(void *obj, void *jbo)
+objects_id_is_equal(const void *obj, const void *jbo)
 {
   return (int)[(id)obj isEqual:(id)jbo];
 }
 
-void *
-objects_id_retain(void *obj)
+const void *
+objects_id_retain(const void *obj)
 {
   return [(id)obj retain];
 }
 
 void
-objects_id_release(void *obj)
+objects_id_release(const void *obj)
 {
   [(id)obj release];
   return;
 }
 
-void *
-objects_id_describe(void *obj)
+const void *
+objects_id_describe (const void *obj)
 {
   /* FIXME: Harrumph.  Make all of these describe functions live
    * in harmony.  Please. */
+#if 0
   return [(id)obj describe];
+#else
+  return 0;
+#endif
 }
 

Source/callbacks-int.c

@@ -45,37 +45,37 @@ objects_callbacks_t objects_callbacks_for_int =
 /**** Function Implementations ***********************************************/
 
 size_t
-objects_int_hash(void *i)
+objects_int_hash (const void *i)
 {
   return (size_t)((int)i);
 }
 
 int
-objects_int_compare(void *i, void *j)
+objects_int_compare (const void *i, const void *j)
 {
   return ((int)i) - ((int)j);
 }
 
 int
-objects_int_is_equal(void *i, void *j)
+objects_int_is_equal (const void *i, const void *j)
 {
   return ((int)i) == ((int)j);
 }
 
-void *
-objects_int_retain(void *i)
+const void *
+objects_int_retain (const void *i)
 {
   return i;
 }
 
 void
-object_int_release(void *i)
+objects_int_release (const void *i)
 {
   return;
 }
 
-void *
-objects_int_describe(void *i)
+const void *
+objects_int_describe (const void *i)
 {
   /* FIXME: Code this. */
   return 0;

Source/callbacks-int_p.c

@@ -46,7 +46,7 @@ objects_callbacks_t objects_callbacks_for_int_p =
 /**** Function Implementations ***********************************************/
 
 size_t
-objects_int_p_hash(void *iptr)
+objects_int_p_hash (const void *iptr)
 {
   return (size_t)(*((int *)iptr));
 }
@@ -54,31 +54,31 @@ objects_int_p_hash(void *iptr)
 /* FIXME: Are these next two correct?  These seem rather useless to me. */
 
 int
-objects_int_p_compare(void *iptr, void *jptr)
+objects_int_p_compare (const void *iptr, const void *jptr)
 {
   return *((int *)iptr) - *((int *)jptr);
 }
 
 int
-objects_int_p_is_equal(void *iptr, void *jptr)
+objects_int_p_is_equal (const void *iptr, const void *jptr)
 {
   return *((int *)iptr) == *((int *)jptr);
 }
 
-void *
-objects_int_p_retain(void *iptr)
+const void *
+objects_int_p_retain (const void *iptr)
 {
   return iptr;
 }
 
 void
-objects_int_p_release(void *iptr)
+objects_int_p_release (const void *iptr)
 {
   return;
 }
 
-void *
-objects_int_p_describe(void *iptr)
+const void *
+objects_int_p_describe (const void *iptr)
 {
   /* FIXME: Code this. */
   return 0;

Source/callbacks-void_p.c

@@ -54,13 +54,13 @@ objects_callbacks_t objects_callbacks_for_owned_void_p =
 /**** Function Implementations ***********************************************/
 
 size_t
-objects_void_p_hash(void *cptr)
+objects_void_p_hash (const void *cptr)
 {
   return ((size_t) cptr)/4;
 }
 
 int
-objects_void_p_compare(void *cptr, void *dptr)
+objects_void_p_compare (const void *cptr, const void *dptr)
 {
   if (cptr == dptr)
     return 0;
@@ -71,25 +71,25 @@ objects_void_p_compare(void *cptr, void *dptr)
 }
 
 int
-objects_void_p_is_equal(register void *cptr, register void *dptr)
+objects_void_p_is_equal (register const void *cptr, register const void *dptr)
 {
   return (cptr == dptr);
 }
 
-void *
-objects_void_p_retain(void *cptr)
+const void *
+objects_void_p_retain (const void *cptr)
 {
   return cptr;
 }
 
 void
-objects_void_p_release(void *cptr)
+objects_void_p_release (const void *cptr)
 {
   return;
 }
 
 size_t
-objects_owned_void_p_hash(void *cptr)
+objects_owned_void_p_hash (const void *cptr)
 {
   /* We divide by 4 because many machines align
    * memory on word boundaries. */
@@ -97,7 +97,7 @@ objects_owned_void_p_hash(void *cptr)
 }
 
 int
-objects_owned_void_p_compare(void *cptr, void *dptr)
+objects_owned_void_p_compare (const void *cptr, const void *dptr)
 {
   if (cptr == dptr)
     return 0;
@@ -108,22 +108,30 @@ objects_owned_void_p_compare(void *cptr, void *dptr)
 }
 
 int
-objects_owned_void_p_is_equal(register void *cptr, register void *dptr)
+objects_owned_void_p_is_equal(register const void *cptr, 
+			      register const void *dptr)
 {
   return (cptr == dptr);
 }
 
-void *
-objects_owned_void_p_retain(void *cptr)
+const void *
+objects_owned_void_p_retain(const void *cptr)
 {
   return cptr;
 }
 
 void
-objects_owned_void_p_release(void *cptr)
+objects_owned_void_p_release (const void *cptr)
 {
-  free(cptr);
+  free ((void*)cptr);
   return;
 }
 
+const void *
+objects_void_p_describe (const void *obj)
+{
+  /* FIXME: Harrumph.  Make all of these describe functions live
+   * in harmony.  Please. */
+  return 0;
+}
 

Source/callbacks.c

@@ -75,7 +75,8 @@ objects_callbacks_standardize(objects_callbacks_t callbacks)
 /** Using callbacks **/
 
 size_t
-objects_hash (objects_callbacks_t callbacks, void *thing, void *user_data)
+objects_hash (objects_callbacks_t callbacks, 
+	      const void *thing, const void *user_data)
 {
   if (callbacks.hash != 0)
     return callbacks.hash(thing, user_data);
@@ -85,9 +86,9 @@ objects_hash (objects_callbacks_t callbacks, void *thing, void *user_data)
 
 int
 objects_compare (objects_callbacks_t callbacks,
-		 void *thing1,
-		 void *thing2,
-		 void *user_data)
+		 const void *thing1,
+		 const void *thing2,
+		 const void *user_data)
 {
   if (callbacks.compare != 0)
     return callbacks.compare(thing1, thing2, user_data);
@@ -99,9 +100,9 @@ objects_compare (objects_callbacks_t callbacks,
 
 int
 objects_is_equal (objects_callbacks_t callbacks,
-		  void *thing1,
-		  void *thing2,
-		  void *user_data)
+		  const void *thing1,
+		  const void *thing2,
+		  const void *user_data)
 {
   if (callbacks.is_equal != 0)
     return callbacks.is_equal(thing1, thing2, user_data);
@@ -112,7 +113,8 @@ objects_is_equal (objects_callbacks_t callbacks,
 }
 
 void *
-objects_retain (objects_callbacks_t callbacks, void *thing, void *user_data)
+objects_retain (objects_callbacks_t callbacks, 
+		const void *thing, const void *user_data)
 {
   if (callbacks.retain != 0)
     return callbacks.retain(thing, user_data);
@@ -121,17 +123,19 @@ objects_retain (objects_callbacks_t callbacks, void *thing, void *user_data)
 }
 
 void
-objects_release (objects_callbacks_t callbacks, void *thing, void *user_data)
+objects_release (objects_callbacks_t callbacks, 
+		 void *thing, const void *user_data)
 {
   if (callbacks.release != 0)
-    callbacks.release(thing, user_data);
+    callbacks.release (thing, user_data);
   else
-    objects_callbacks_standard().release(thing, user_data);
+    objects_callbacks_standard().release (thing, user_data);
   return;
 }
 
 void *
-objects_describe(objects_callbacks_t callbacks, void *thing, void *user_data)
+objects_describe(objects_callbacks_t callbacks, 
+		 const void *thing, const void *user_data)
 {
   if (callbacks.release != 0)
     return callbacks.describe(thing, user_data);

Source/hash.c

@@ -38,10 +38,11 @@ objects_hash_bucket_t *
 _objects_hash_pick_bucket_for_element (objects_hash_t *hash,
 				       objects_hash_bucket_t *buckets,
 				       size_t bucket_count,
-				       void *element)
+				       const void *element)
 {
   return buckets + (objects_hash (objects_hash_element_callbacks (hash),
-				  element, hash) % bucket_count);
+				  element, hash)
+		    % bucket_count);
 }
 
 objects_hash_bucket_t *
@@ -51,11 +52,12 @@ _objects_hash_pick_bucket_for_node (objects_hash_t * hash,
 				    objects_hash_node_t * node)
 {
   return buckets + (objects_hash (objects_hash_element_callbacks (hash),
-				  node->element, hash) % bucket_count);
+				  node->element, hash) 
+		    % bucket_count);
 }
 
 objects_hash_bucket_t *
-_objects_hash_bucket_for_element (objects_hash_t * hash, void *element)
+_objects_hash_bucket_for_element (objects_hash_t * hash, const void *element)
 {
   return _objects_hash_pick_bucket_for_element (hash, hash->buckets,
 						hash->bucket_count, element);
@@ -242,7 +244,7 @@ _objects_hash_remangle_buckets (objects_hash_t * hash,
 }
 
 objects_hash_node_t *
-_objects_hash_new_node (objects_hash_t * hash, void *element)
+_objects_hash_new_node (objects_hash_t * hash, const void *element)
 {
   objects_hash_node_t *node;
 
@@ -281,7 +283,9 @@ _objects_hash_free_node (objects_hash_node_t * node)
       hash = node->hash;
 
       /* Release ELEMENT.  (It's retained in `_objects_hash_new_node()'.) */
-      objects_release (objects_hash_element_callbacks (hash), node->element, hash);
+      objects_release (objects_hash_element_callbacks (hash), 
+		       (void*)node->element, 
+		       hash);
 
       /* Actually free the space hash aside for NODE. */
       objects_free (objects_hash_allocs (hash), node);
@@ -292,7 +296,7 @@ _objects_hash_free_node (objects_hash_node_t * node)
 }
 
 objects_hash_node_t *
-_objects_hash_node_for_element (objects_hash_t * hash, void *element)
+_objects_hash_node_for_element (objects_hash_t * hash, const void *element)
 {
   objects_hash_bucket_t *bucket;
   objects_hash_node_t *node;
@@ -405,7 +409,7 @@ objects_hash_capacity (objects_hash_t * hash)
 }
 
 int
-objects_hash_check (objects_hash_t * hash)
+objects_hash_check (objects_hash_t *hash)
 {
   /* FIXME: Code this. */
   return 0;
@@ -414,7 +418,7 @@ objects_hash_check (objects_hash_t * hash)
 /** Searching **/
 
 int
-objects_hash_contains_element (objects_hash_t * hash, void *element)
+objects_hash_contains_element (objects_hash_t *hash, const void *element)
 {
   objects_hash_node_t *node;
 
@@ -423,8 +427,8 @@ objects_hash_contains_element (objects_hash_t * hash, void *element)
   return node != NULL;
 }
 
-void *
-objects_hash_element (objects_hash_t * hash, void *element)
+const void *
+objects_hash_element (objects_hash_t *hash, const void *element)
 {
   objects_hash_node_t *node;
 
@@ -437,17 +441,17 @@ objects_hash_element (objects_hash_t * hash, void *element)
     return objects_hash_not_an_element_marker (hash);
 }
 
-void **
-objects_hash_all_elements (objects_hash_t * hash)
+const void **
+objects_hash_all_elements (objects_hash_t *hash)
 {
   size_t j;
-  void **array;
+  const void **array;
   objects_hash_enumerator_t enumerator;
 
   /* Allocate space for ARRAY.  Remember that it is the programmer's
    * responsibility to free this by calling
    * `objects_free(objects_hash_allocs(HASH), ARRAY)' */
-  array = (void **) objects_calloc (objects_hash_allocs (hash),
+  array = (const void **) objects_calloc (objects_hash_allocs (hash),
 				    hash->node_count + 1,
 				    sizeof (void *));
 
@@ -538,7 +542,7 @@ objects_hash_enumerator (objects_hash_t * hash)
 
 int
 objects_hash_enumerator_next_element (objects_hash_enumerator_t * enumerator,
-				      void **element)
+				      const void **element)
 {
   objects_hash_node_t *node;
 
@@ -573,8 +577,9 @@ objects_hash_enumerator_next_element (objects_hash_enumerator_t * enumerator,
 
 /** Adding **/
 
-void *
-objects_hash_add_element_known_absent (objects_hash_t * hash, void *element)
+const void *
+objects_hash_add_element_known_absent (objects_hash_t *hash, 
+				       const void *element)
 {
   objects_hash_node_t *node;
 
@@ -593,8 +598,8 @@ objects_hash_add_element_known_absent (objects_hash_t * hash, void *element)
     }
 }
 
-void *
-objects_hash_add_element (objects_hash_t * hash, void *element)
+const void *
+objects_hash_add_element (objects_hash_t * hash, const void *element)
 {
   objects_hash_node_t *node;
 
@@ -609,13 +614,15 @@ objects_hash_add_element (objects_hash_t * hash, void *element)
   else
     {
       objects_retain (objects_hash_element_callbacks (hash), element, hash);
-      objects_release (objects_hash_element_callbacks (hash), node->element, hash);
+      objects_release (objects_hash_element_callbacks (hash), 
+		       (void*)node->element, 
+		       hash);
       return node->element = element;
     }
 }
 
-void *
-objects_hash_add_element_if_absent (objects_hash_t * hash, void *element)
+const void *
+objects_hash_add_element_if_absent (objects_hash_t* hash, const void *element)
 {
   objects_hash_node_t *node;
 
@@ -634,7 +641,7 @@ objects_hash_add_element_if_absent (objects_hash_t * hash, void *element)
 /** Removing **/
 
 void
-objects_hash_remove_element (objects_hash_t * hash, void *element)
+objects_hash_remove_element (objects_hash_t *hash, const void *element)
 {
   objects_hash_node_t *node;
 
@@ -789,7 +796,7 @@ objects_hash_init_from_hash (objects_hash_t * hash, objects_hash_t * old_hash)
   if (hash != NULL)
     {
       objects_hash_enumerator_t enumerator;
-      void *element;
+      const void *element;
 
       /* Make a note of the callbacks for HASH. */
       hash->callbacks = objects_hash_element_callbacks (hash);
@@ -838,7 +845,7 @@ objects_hash_dealloc (objects_hash_t * hash)
 /** Replacing **/
 
 void
-objects_hash_replace_element (objects_hash_t * hash, void *element)
+objects_hash_replace_element (objects_hash_t *hash, const void *element)
 {
   objects_hash_node_t *node;
 
@@ -850,7 +857,9 @@ objects_hash_replace_element (objects_hash_t * hash, void *element)
       /* Remember: First retain the new element, then release the old
        * element, just in case they're the same. */
       objects_retain (objects_hash_element_callbacks (hash), element, hash);
-      objects_release (objects_hash_element_callbacks (hash), node->element, hash);
+      objects_release (objects_hash_element_callbacks (hash), 
+		       (void*)node->element, 
+		       hash);
       node->element = element;
     }
 
@@ -864,7 +873,7 @@ int
 objects_hash_contains_hash (objects_hash_t * hash1, objects_hash_t * hash2)
 {
   objects_hash_enumerator_t enumerator;
-  void *element;
+  const void *element;
 
   enumerator = objects_hash_enumerator (hash2);
 
@@ -906,7 +915,7 @@ int
 objects_hash_intersects_hash (objects_hash_t * hash, objects_hash_t * other_hash)
 {
   objects_hash_enumerator_t enumerator;
-  void *element;
+  const void *element;
 
   /* Get an element enumerator for OTHER_HASH. */
   enumerator = objects_hash_enumerator (other_hash);
@@ -956,8 +965,8 @@ objects_hash_copy (objects_hash_t * old_hash)
  * the second. */
 objects_hash_t *
 objects_hash_map_elements (objects_hash_t * hash,
-			   void *(*fcn) (void *, void *),
-			   void *user_data)
+			   const void *(*fcn) (const void *, const void *),
+			   const void *user_data)
 {
   objects_hash_enumerator_t enumerator;
   objects_hash_node_t *node;
@@ -966,14 +975,16 @@ objects_hash_map_elements (objects_hash_t * hash,
 
   while ((node = _objects_hash_enumerator_next_node (&enumerator)) != NULL)
     {
-      void *element;
+      const void *element;
 
       element = (*fcn) (node->element, user_data);
 
       /* Remember: First retain the new element, then release the old
        * element. */
       objects_retain (objects_hash_element_callbacks (hash), element, hash);
-      objects_release (objects_hash_element_callbacks (hash), node->element, hash);
+      objects_release (objects_hash_element_callbacks (hash), 
+		       (void*)node->element, 
+		       hash);
       node->element = element;
     }
 
@@ -1025,7 +1036,7 @@ objects_hash_t *
 objects_hash_union_hash (objects_hash_t * hash, objects_hash_t * other_hash)
 {
   objects_hash_enumerator_t enumerator;
-  void *element;
+  const void *element;
 
   enumerator = objects_hash_enumerator (other_hash);
 

Source/list.c

@@ -54,7 +54,7 @@ _objects_list_remove_node_from_its_list (objects_list_node_t * node)
 }
 
 objects_list_node_t *
-_objects_list_new_node (objects_list_t * list, void *element)
+_objects_list_new_node (objects_list_t * list, const void *element)
 {
   objects_list_node_t *node;
 
@@ -75,7 +75,9 @@ _objects_list_new_node (objects_list_t * list, void *element)
 void
 _objects_list_free_node (objects_list_t * list, objects_list_node_t * node)
 {
-  objects_release (objects_list_element_callbacks (node->list), node->element, node->list);
+  objects_release (objects_list_element_callbacks (node->list), 
+		   (void*)node->element, 
+		   node->list);
   objects_free (objects_list_allocs (list), node);
   return;
 }
@@ -114,7 +116,7 @@ _objects_list_nth_node (objects_list_t * list, long int n)
 inline objects_list_node_t *
 _objects_list_nth_node_for_element (objects_list_t * list,
 				    long int n,
-				    void *element)
+				    const void *element)
 {
   objects_list_node_t *node;
 
@@ -191,10 +193,10 @@ objects_list_check (objects_list_t * list)
 }
 
 int
-objects_list_contains_element (objects_list_t * list, void *element)
+objects_list_contains_element (objects_list_t * list, const void *element)
 {
   objects_list_enumerator_t enumerator;
-  void *member;
+  const void *member;
 
   objects_list_enumerator (list);
 
@@ -258,7 +260,7 @@ objects_list_reverse_enumerator (objects_list_t * list)
 
 int
 objects_list_enumerator_next_element (objects_list_enumerator_t * enumerator,
-				      void **element)
+				      const void **element)
 {
   objects_list_node_t *node;
 
@@ -288,8 +290,8 @@ objects_list_enumerator_next_element (objects_list_enumerator_t * enumerator,
 
 /** Searching **/
 
-void *
-objects_list_element (objects_list_t * list, void *element)
+const void *
+objects_list_element (objects_list_t * list, const void *element)
 {
   objects_list_node_t *node;
 
@@ -301,7 +303,7 @@ objects_list_element (objects_list_t * list, void *element)
     return objects_list_not_an_element_marker (list);
 }
 
-void *
+const void *
 objects_list_nth_element (objects_list_t * list, long int n)
 {
   objects_list_node_t *node;
@@ -314,7 +316,7 @@ objects_list_nth_element (objects_list_t * list, long int n)
     return objects_list_not_an_element_marker (list);
 }
 
-void *
+const void *
 objects_list_first_element (objects_list_t * list)
 {
   if (list->first_node != NULL)
@@ -323,7 +325,7 @@ objects_list_first_element (objects_list_t * list)
     return objects_list_not_an_element_marker (list);
 }
 
-void *
+const void *
 objects_list_last_element (objects_list_t * list)
 {
   if (list->last_node != NULL)
@@ -334,16 +336,16 @@ objects_list_last_element (objects_list_t * list)
 
 /** Obtaining elements **/
 
-void **
+const void **
 objects_list_all_elements (objects_list_t * list)
 {
   objects_list_enumerator_t enumerator;
-  void **array;
+  const void **array;
   size_t i;
 
   array = objects_calloc (objects_list_allocs (list),
 			  objects_list_count (list) + 1,
-			  sizeof (void *));
+			  sizeof (const void *));
 
   for (i = 0; objects_list_enumerator_next_element (&enumerator, array + i); ++i);
 
@@ -352,34 +354,34 @@ objects_list_all_elements (objects_list_t * list)
 
 /** Adding elements **/
 
-void *
-objects_list_append_element (objects_list_t * list, void *element)
+const void *
+objects_list_append_element (objects_list_t * list, const void *element)
 {
   return objects_list_at_index_insert_element (list, -1, element);
 }
 
-void *
-objects_list_append_element_if_absent (objects_list_t * list, void *element)
+const void *
+objects_list_append_element_if_absent (objects_list_t * list, const void *element)
 {
   return objects_list_at_index_insert_element_if_absent (list, -1, element);
 }
 
-void *
-objects_list_prepend_element (objects_list_t * list, void *element)
+const void *
+objects_list_prepend_element (objects_list_t * list, const void *element)
 {
   return objects_list_at_index_insert_element (list, 0, element);
 }
 
-void *
-objects_list_prepend_element_if_absent (objects_list_t * list, void *element)
+const void *
+objects_list_prepend_element_if_absent (objects_list_t * list, const void *element)
 {
   return objects_list_at_index_insert_element_if_absent (list, 0, element);
 }
 
-void *
+const void *
 objects_list_at_index_insert_element (objects_list_t * list,
 				      long int n,
-				      void *element)
+				      const void *element)
 {
   objects_list_node_t *anode, *bnode, *new_node, *node;
 
@@ -438,10 +440,10 @@ objects_list_at_index_insert_element (objects_list_t * list,
   return new_node->element;
 }
 
-void *
+const void *
 objects_list_at_index_insert_element_if_absent (objects_list_t * list,
 						long int n,
-						void *element)
+						const void *element)
 {
   if (!objects_list_contains_element (list, element))
     return objects_list_at_index_insert_element (list, n, element);
@@ -454,7 +456,7 @@ objects_list_at_index_insert_element_if_absent (objects_list_t * list,
 void
 objects_list_remove_nth_occurrance_of_element (objects_list_t * list,
 					       long int n,
-					       void *element)
+					       const void *element)
 {
   objects_list_node_t *node;
 
@@ -470,7 +472,7 @@ objects_list_remove_nth_occurrance_of_element (objects_list_t * list,
 }
 
 void
-objects_list_remove_element (objects_list_t * list, void *element)
+objects_list_remove_element (objects_list_t * list, const void *element)
 {
   objects_list_remove_nth_occurrance_of_element (list, 0, element);
   return;
@@ -530,8 +532,8 @@ objects_list_empty (objects_list_t * list)
 void
 objects_list_replace_nth_occurrance_of_element (objects_list_t * list,
 						long int n,
-						void *old_element,
-						void *new_element)
+						const void *old_element,
+						const void *new_element)
 {
   objects_list_node_t *node;
 
@@ -540,7 +542,9 @@ objects_list_replace_nth_occurrance_of_element (objects_list_t * list,
   if (node != NULL)
     {
       objects_retain (objects_list_element_callbacks (list), new_element, list);
-      objects_release (objects_list_element_callbacks (list), node->element, list);
+      objects_release (objects_list_element_callbacks (list), 
+		       (void*)node->element, 
+		       list);
       node->element = new_element;
     }
 
@@ -549,8 +553,8 @@ objects_list_replace_nth_occurrance_of_element (objects_list_t * list,
 
 void
 objects_list_replace_element (objects_list_t * list,
-			      void *old_element,
-			      void *new_element)
+			      const void *old_element,
+			      const void *new_element)
 {
   objects_list_replace_nth_occurrance_of_element (list, 0, old_element, new_element);
   return;
@@ -559,7 +563,7 @@ objects_list_replace_element (objects_list_t * list,
 void
 objects_list_replace_nth_element (objects_list_t * list,
 				  long int n,
-				  void *new_element)
+				  const void *new_element)
 {
   objects_list_node_t *node;
 
@@ -568,7 +572,9 @@ objects_list_replace_nth_element (objects_list_t * list,
   if (node != NULL)
     {
       objects_retain (objects_list_element_callbacks (list), new_element, list);
-      objects_release (objects_list_element_callbacks (list), node->element, list);
+      objects_release (objects_list_element_callbacks (list), 
+		       (void*)node->element, 
+		       list);
       node->element = new_element;
     }
 
@@ -577,7 +583,7 @@ objects_list_replace_nth_element (objects_list_t * list,
 
 void
 objects_list_replace_first_element (objects_list_t * list,
-				    void *new_element)
+				    const void *new_element)
 {
   objects_list_replace_nth_element (list, 0, new_element);
   return;
@@ -585,7 +591,7 @@ objects_list_replace_first_element (objects_list_t * list,
 
 void
 objects_list_replace_last_element (objects_list_t * list,
-				   void *new_element)
+				   const void *new_element)
 {
   objects_list_replace_nth_element (list, -1, new_element);
   return;
@@ -692,7 +698,7 @@ objects_list_t *
 objects_list_init_from_list (objects_list_t * list, objects_list_t * old_list)
 {
   objects_list_enumerator_t enumerator;
-  void *element;
+  const void *element;
 
   if (list != NULL)
     {
@@ -762,7 +768,7 @@ objects_list_at_index_insert_list (objects_list_t * base_list,
 				   objects_list_t * infix_list)
 {
   objects_list_enumerator_t enumerator;
-  void *element;
+  const void *element;
 
   if (n < 0)
     enumerator = objects_list_forward_enumerator (infix_list);
@@ -801,8 +807,8 @@ objects_list_copy_with_allocs (objects_list_t * old_list, objects_allocs_t alloc
 
 objects_list_t *
 objects_list_map_elements (objects_list_t * list,
-			   void *(*fcn) (void *, void *),
-			   void *user_data)
+			   const void *(*fcn) (const void *, const void *),
+			   const void *user_data)
 {
   objects_list_enumerator_t enumerator;
   objects_list_node_t *node;
@@ -811,14 +817,14 @@ objects_list_map_elements (objects_list_t * list,
 
   while ((node = _objects_list_enumerator_next_node (&enumerator)) != NULL)
     {
-      void *element;
+      const void *element;
 
       element = (*fcn) (node->element, user_data);
 
       /* NOTE: I'm accessing the callbacks directly for a little
        * efficiency. */
       objects_retain (list->callbacks, element, list);
-      objects_release (list->callbacks, node->element, list);
+      objects_release (list->callbacks, (void*)node->element, list);
 
       node->element = element;
     }
@@ -834,7 +840,7 @@ objects_hash_init_from_list (objects_hash_t * hash, objects_list_t * list)
   if (hash != NULL)
     {
       objects_list_enumerator_t enumerator;
-      void *element;
+      const void *element;
 
       /* Make a note of the callbacks for HASH. */
       hash->callbacks = objects_list_element_callbacks (list);
@@ -872,7 +878,7 @@ objects_hash_init_from_list (objects_hash_t * hash, objects_list_t * list)
 //   if (chash != NULL)
 //     {
 //       objects_list_enumerator_t enumerator;
-//       void *element;
+//       const void *element;
 // 
 //       /* Make a note of the callbacks for CHASH. */
 //       chash->callbacks = objects_list_element_callbacks (list);

Source/map.c

@@ -39,10 +39,11 @@ objects_map_bucket_t *
 _objects_map_pick_bucket_for_key (objects_map_t *map,
                                   objects_map_bucket_t *buckets,
 				  size_t bucket_count,
-                                  void *key)
+                                  const void *key)
 {
   return buckets + (objects_hash (objects_map_key_callbacks (map),
-				  key, map) % bucket_count);
+				  key, map) 
+		    % bucket_count);
 }
 
 objects_map_bucket_t *
@@ -52,11 +53,12 @@ _objects_map_pick_bucket_for_node (objects_map_t * map,
 				   objects_map_node_t * node)
 {
   return buckets + (objects_hash (objects_map_key_callbacks (map),
-				  node->key, map) % bucket_count);
+				  node->key, map)
+		    % bucket_count);
 }
 
 objects_map_bucket_t *
-_objects_map_bucket_for_key (objects_map_t * map, void *key)
+_objects_map_bucket_for_key (objects_map_t * map, const void *key)
 {
   return _objects_map_pick_bucket_for_key (map, map->buckets,
 					   map->bucket_count, key);
@@ -100,7 +102,8 @@ _objects_map_unlink_node_from_its_bucket (objects_map_node_t * node)
 }
 
 void
-_objects_map_link_node_into_map (objects_map_t * map, objects_map_node_t * node)
+_objects_map_link_node_into_map (objects_map_t * map, 
+				 objects_map_node_t * node)
 {
   if (map->first_node != NULL)
     map->first_node->prev_in_map = node;
@@ -129,7 +132,8 @@ _objects_map_unlink_node_from_its_map (objects_map_node_t * node)
 }
 
 void
-_objects_map_add_node_to_bucket (objects_map_bucket_t * bucket, objects_map_node_t * node)
+_objects_map_add_node_to_bucket (objects_map_bucket_t * bucket, 
+				 objects_map_node_t * node)
 {
   if (bucket != NULL)
     {
@@ -145,9 +149,11 @@ _objects_map_add_node_to_bucket (objects_map_bucket_t * bucket, objects_map_node
 }
 
 void
-_objects_map_add_node_to_its_bucket (objects_map_t * map, objects_map_node_t * node)
+_objects_map_add_node_to_its_bucket (objects_map_t * map, 
+				     objects_map_node_t * node)
 {
-  _objects_map_add_node_to_bucket (_objects_map_bucket_for_node (map, node), node);
+  _objects_map_add_node_to_bucket (_objects_map_bucket_for_node (map, node), 
+				   node);
   return;
 }
 
@@ -243,7 +249,7 @@ _objects_map_remangle_buckets (objects_map_t * map,
 }
 
 objects_map_node_t *
-_objects_map_new_node (objects_map_t * map, void *key, void *value)
+_objects_map_new_node (objects_map_t * map, const void *key, const void *value)
 {
   objects_map_node_t *node;
 
@@ -286,8 +292,10 @@ _objects_map_free_node (objects_map_node_t * node)
 
       /* Release KEY and VALUE.  (They're retained above in
        * `_objects_map_new_node()'.) */
-      objects_release (objects_map_key_callbacks (map), node->key, map);
-      objects_release (objects_map_value_callbacks (map), node->value, map);
+      objects_release (objects_map_key_callbacks (map), 
+		       (void*)node->key, map);
+      objects_release (objects_map_value_callbacks (map), 
+		       (void*)node->value, map);
 
       /* Actually free the space map aside for NODE. */
       objects_free (objects_map_allocs (map), node);
@@ -298,7 +306,7 @@ _objects_map_free_node (objects_map_node_t * node)
 }
 
 objects_map_node_t *
-_objects_map_node_for_key (objects_map_t * map, void *key)
+_objects_map_node_for_key (objects_map_t * map, const void *key)
 {
   objects_map_bucket_t *bucket;
   objects_map_node_t *node;
@@ -413,7 +421,7 @@ objects_map_is_empty (objects_map_t * map)
  * in DICT. */
 
 int
-objects_map_contains_key (objects_map_t * map, void *key)
+objects_map_contains_key (objects_map_t * map, const void *key)
 {
   objects_map_node_t *node;
 
@@ -426,16 +434,16 @@ objects_map_contains_key (objects_map_t * map, void *key)
 }
 
 int
-objects_map_contains_value (objects_map_t * map, void *value)
+objects_map_contains_value (objects_map_t * map, const void *value)
 {
   return 0;
 }
 
 int
 objects_map_key_and_value_at_key (objects_map_t * map,
-				  void **old_key,
-				  void **value,
-				  void *key)
+				  const void **old_key,
+				  const void **value,
+				  const void *key)
 {
   objects_map_node_t *node;
 
@@ -460,39 +468,39 @@ objects_map_key_and_value_at_key (objects_map_t * map,
     }
 }
 
-void *
-objects_map_key (objects_map_t * map, void *key)
+const void *
+objects_map_key (objects_map_t * map, const void *key)
 {
-  void *old_key;
+  const void *old_key;
 
   objects_map_key_and_value_at_key (map, &old_key, NULL, key);
 
   return old_key;
 }
 
-void *
-objects_map_value_at_key (objects_map_t * map, void *key)
+const void *
+objects_map_value_at_key (objects_map_t * map, const void *key)
 {
-  void *value;
+  const void *value;
 
   objects_map_key_and_value_at_key (map, NULL, &value, key);
 
   return value;
 }
 
-void **
+const void **
 objects_map_all_keys_and_values (objects_map_t * map)
 {
   size_t j;
-  void **array;
+  const void **array;
   objects_map_enumerator_t enumerator;
 
   /* Allocate space for ARRAY.  Remember that it is the programmer's
    * responsibility to free this by calling
    * `objects_free(objects_map_allocs(DICT), ARRAY)' */
-  array = (void **) objects_calloc (objects_map_allocs (map),
-				    2 * (map->node_count + 1),
-				    sizeof (void *));
+  array = (const void **) objects_calloc (objects_map_allocs (map),
+					  2 * (map->node_count + 1),
+					  sizeof (void *));
 
   /* ENUMERATOR is an enumerator for DICT. */
   enumerator = objects_map_enumerator (map);
@@ -510,19 +518,19 @@ objects_map_all_keys_and_values (objects_map_t * map)
   return array;
 }
 
-void **
+const void **
 objects_map_all_keys (objects_map_t * map)
 {
   size_t j;
-  void **array;
+  const void **array;
   objects_map_enumerator_t enumerator;
 
   /* Allocate space for ARRAY.  Remember that it is the programmer's
    * responsibility to free this by calling
    * `objects_free(objects_map_allocs(DICT), ARRAY)' */
-  array = (void **) objects_calloc (objects_map_allocs (map),
-				    map->node_count + 1,
-				    sizeof (void *));
+  array = (const void **) objects_calloc (objects_map_allocs (map),
+					  map->node_count + 1,
+					  sizeof (void *));
 
   /* ENUMERATOR is an enumerator for DICT. */
   enumerator = objects_map_enumerator (map);
@@ -536,19 +544,19 @@ objects_map_all_keys (objects_map_t * map)
   return array;
 }
 
-void **
+const void **
 objects_map_all_values (objects_map_t * map)
 {
   size_t j;
-  void **array;
+  const void **array;
   objects_map_enumerator_t enumerator;
 
   /* Allocate space for ARRAY.  Remember that it is the programmer's
    * responsibility to free this by calling
    * `objects_free(objects_map_allocs(DICT), ARRAY)' */
-  array = (void **) objects_calloc (objects_map_allocs (map),
-				    map->node_count + 1,
-				    sizeof (void *));
+  array = (const void **) objects_calloc (objects_map_allocs (map),
+					  map->node_count + 1,
+					  sizeof (void *));
 
   /* ENUMERATOR is an enumerator for DICT. */
   enumerator = objects_map_enumerator (map);
@@ -644,8 +652,8 @@ _objects_map_enumerator_next_node (objects_map_enumerator_t * enumerator)
 
 int
 objects_map_enumerator_next_key_and_value (objects_map_enumerator_t * enumerator,
-					   void **key,
-					   void **value)
+					   const void **key,
+					   const void **value)
 {
   objects_map_node_t *node;
 
@@ -679,24 +687,24 @@ objects_map_enumerator_next_key_and_value (objects_map_enumerator_t * enumerator
 
 int
 objects_map_enumerator_next_key (objects_map_enumerator_t * enumerator,
-				 void **key)
+				 const void **key)
 {
   return objects_map_enumerator_next_key_and_value (enumerator, key, NULL);
 }
 
 int
 objects_map_enumerator_next_value (objects_map_enumerator_t * enumerator,
-				   void **value)
+				   const void **value)
 {
   return objects_map_enumerator_next_key_and_value (enumerator, NULL, value);
 }
 
 /** Adding **/
 
-void *
+const void *
 objects_map_at_key_put_value_known_absent (objects_map_t * map,
-					   void *key,
-					   void *value)
+					   const void *key,
+					   const void *value)
 {
   objects_map_node_t *node;
 
@@ -723,10 +731,10 @@ objects_map_at_key_put_value_known_absent (objects_map_t * map,
     }
 }
 
-void *
+const void *
 objects_map_at_key_put_value (objects_map_t * map,
-			      void *key,
-			      void *value)
+			      const void *key,
+			      const void *value)
 {
   objects_map_node_t *node;
 
@@ -736,7 +744,8 @@ objects_map_at_key_put_value (objects_map_t * map,
   if (node != NULL)
     {
       objects_retain (objects_map_value_callbacks (map), value, map);
-      objects_release (objects_map_value_callbacks (map), node->value, map);
+      objects_release (objects_map_value_callbacks (map), 
+		       (void*)node->value, map);
       node->value = value;
       return node->key;
     }
@@ -747,10 +756,10 @@ objects_map_at_key_put_value (objects_map_t * map,
     }
 }
 
-void *
+const void *
 objects_map_at_key_put_value_if_absent (objects_map_t * map,
-					void *key,
-					void *value)
+					const void *key,
+					const void *value)
 {
   objects_map_node_t *node;
 
@@ -774,7 +783,7 @@ objects_map_at_key_put_value_if_absent (objects_map_t * map,
 /** Removing **/
 
 void
-objects_map_remove_key (objects_map_t * map, void *key)
+objects_map_remove_key (objects_map_t * map, const void *key)
 {
   objects_map_node_t *node;
 
@@ -992,8 +1001,8 @@ objects_map_t *
 objects_map_init_from_map (objects_map_t * map, objects_map_t * old_map)
 {
   objects_map_enumerator_t enumerator;
-  void *key;
-  void *value;
+  const void *key;
+  const void *value;
 
   /* Initialize MAP. */
   objects_map_init_with_callbacks (map,
@@ -1038,7 +1047,7 @@ objects_map_dealloc (objects_map_t * map)
 
 void
 objects_map_replace_key (objects_map_t * map,
-			 void *key)
+			 const void *key)
 {
   objects_map_node_t *node;
 
@@ -1047,7 +1056,8 @@ objects_map_replace_key (objects_map_t * map,
   if (node != NULL)
     {
       objects_retain (objects_map_key_callbacks (map), key, map);
-      objects_release (objects_map_key_callbacks (map), node->key, map);
+      objects_release (objects_map_key_callbacks (map), 
+		       (void*)node->key, map);
       node->key = key;
     }
 
@@ -1060,7 +1070,7 @@ int
 objects_map_contains_map (objects_map_t * map1, objects_map_t * map2)
 {
   objects_map_enumerator_t enumerator;
-  void *key;
+  const void *key;
 
   enumerator = objects_map_enumerator (map2);
 
@@ -1075,7 +1085,7 @@ int
 objects_map_intersects_map (objects_map_t * map1, objects_map_t * map2)
 {
   objects_map_enumerator_t enumerator;
-  void *key;
+  const void *key;
 
   enumerator = objects_map_enumerator (map1);
 
@@ -1137,8 +1147,8 @@ objects_map_copy (objects_map_t * old_map)
 
 objects_map_t *
 objects_map_map_keys (objects_map_t * map,
-		      void *(*fcn) (void *, void *),
-		      void *user_data)
+		      const void *(*fcn) (const void *, const void *),
+		      const void *user_data)
 {
   objects_map_enumerator_t enumerator;
   objects_map_node_t *node;
@@ -1147,12 +1157,13 @@ objects_map_map_keys (objects_map_t * map,
 
   while ((node = _objects_map_enumerator_next_node (&enumerator)) != NULL)
     {
-      void *key;
-
+      const void *key;
+      
       key = (*fcn) (node->key, user_data);
 
       objects_retain (objects_map_key_callbacks (map), key, map);
-      objects_release (objects_map_key_callbacks (map), node->key, map);
+      objects_release (objects_map_key_callbacks (map), 
+		       (void*)node->key, map);
       node->key = key;
     }
 
@@ -1161,8 +1172,8 @@ objects_map_map_keys (objects_map_t * map,
 
 objects_map_t *
 objects_map_map_values (objects_map_t * map,
-			void *(*fcn) (void *, void *),
-			void *user_data)
+			const void *(*fcn) (const void *, const void *),
+			const void *user_data)
 {
   objects_map_enumerator_t enumerator;
   objects_map_node_t *node;
@@ -1171,12 +1182,13 @@ objects_map_map_values (objects_map_t * map,
 
   while ((node = _objects_map_enumerator_next_node (&enumerator)) != NULL)
     {
-      void *value;
+      const void *value;
 
       value = (fcn) (node->value, user_data);
 
       objects_retain (objects_map_value_callbacks (map), value, map);
-      objects_release (objects_map_value_callbacks (map), node->value, map);
+      objects_release (objects_map_value_callbacks (map), 
+		       (void*)node->value, map);
       node->value = value;
     }
 
@@ -1189,7 +1201,7 @@ objects_map_t *
 objects_map_intersect_map (objects_map_t * map, objects_map_t * other_map)
 {
   objects_map_enumerator_t enumerator;
-  void *key;
+  const void *key;
 
   enumerator = objects_map_enumerator (map);
 
@@ -1204,7 +1216,7 @@ objects_map_t *
 objects_map_minus_map (objects_map_t * map, objects_map_t * other_map)
 {
   objects_map_enumerator_t enumerator;
-  void *key;
+  const void *key;
 
   enumerator = objects_map_enumerator (other_map);
 
@@ -1220,8 +1232,8 @@ objects_map_t *
 objects_map_union_map (objects_map_t * map, objects_map_t * other_map)
 {
   objects_map_enumerator_t enumerator;
-  void *key;
-  void *value;
+  const void *key;
+  const void *value;
 
   enumerator = objects_map_enumerator (other_map);
 

Source/objects/allocs.h

@@ -33,10 +33,10 @@
 
 /**** Type, Constant, and Macro Definitions **********************************/
 
-typedef void *(*objects_malloc_func_t) (size_t, void *);
-typedef void *(*objects_calloc_func_t) (size_t, size_t, void *);
-typedef void *(*objects_realloc_func_t) (void *, size_t, void *);
-typedef void (*objects_free_func_t) (void *, void *);
+typedef void *(*objects_malloc_func_t) (size_t, const void *);
+typedef void *(*objects_calloc_func_t) (size_t, size_t, const void *);
+typedef void *(*objects_realloc_func_t) (void *, size_t, const void *);
+typedef void (*objects_free_func_t) (void *, const void *);
 
 typedef struct _objects_allocs objects_allocs_t;
 
@@ -46,7 +46,7 @@ struct _objects_allocs
     objects_calloc_func_t calloc;
     objects_realloc_func_t realloc;
     objects_free_func_t free;
-    void *user_data;
+    const void *user_data;
   };
 
 /* Shorthand macros. */
@@ -71,10 +71,10 @@ void *
   objects_calloc (objects_allocs_t allocs, size_t n, size_t s);
 
 void *
-  objects_realloc (objects_allocs_t allocs, void *p, size_t s);
+  objects_realloc (objects_allocs_t allocs, const void *p, size_t s);
 
 void
-  objects_free (objects_allocs_t allocs, void *p);
+  objects_free (objects_allocs_t allocs, const void *p);
 
 size_t
 objects_next_power_of_two (size_t start);

Source/objects/array.h

@@ -47,7 +47,7 @@ struct _objects_array_bucket
     size_t index;
 
     /* The bucket's cargo */
-    void *element;
+    const void *element;
   };
 
 struct _objects_array
@@ -55,8 +55,8 @@ struct _objects_array
     /* Identifying information. */
     int magic;
     size_t number;
-    char *name;
-    void *extra;
+    const char *name;
+    const void *extra;
     objects_callbacks_t extra_callbacks;
     objects_allocs_t allocs;
 
@@ -135,7 +135,7 @@ int objects_array_is_equal_to_array (objects_array_t * array, objects_array_t *
 
 /** Adding **/
 
-void *objects_array_at_index_put_element (objects_array_t * array, size_t index, void *element);
+const void *objects_array_at_index_put_element (objects_array_t * array, size_t index, const void *element);
 
 /** Replacing **/
 
@@ -143,9 +143,9 @@ void *objects_array_at_index_put_element (objects_array_t * array, size_t index,
 
 void objects_array_remove_element_at_index (objects_array_t * array, size_t index);
 
-void objects_array_remove_element (objects_array_t * array, void *element);
+void objects_array_remove_element (objects_array_t * array, const void *element);
 
-void objects_array_remove_element_known_present (objects_array_t * array, void *element);
+void objects_array_remove_element_known_present (objects_array_t * array, const void *element);
 
 /** Emptying **/
 
@@ -153,19 +153,19 @@ void objects_array_empty (objects_array_t * array);
 
 /** Searching **/
 
-int objects_array_contains_element (objects_array_t * array, void *element);
+int objects_array_contains_element (objects_array_t * array, const void *element);
 
-void *objects_array_element (objects_array_t * array, void *element);
+const void *objects_array_element (objects_array_t * array, const void *element);
 
-size_t objects_array_index_of_element (objects_array_t * array, void *element);
+size_t objects_array_index_of_element (objects_array_t * array, const void *element);
 
-void *objects_array_element_at_index (objects_array_t * array, size_t index);
+const void *objects_array_element_at_index (objects_array_t * array, size_t index);
 
-void **objects_array_all_elements (objects_array_t * array);
+const void **objects_array_all_elements (objects_array_t * array);
 
-void **objects_array_all_elements_ascending (objects_array_t * array);
+const void **objects_array_all_elements_ascending (objects_array_t * array);
 
-void **objects_array_all_element_descending (objects_array_t * array);
+const void **objects_array_all_element_descending (objects_array_t * array);
 
 /** Enumerating **/
 
@@ -175,9 +175,9 @@ objects_array_enumerator_t objects_array_ascending_enumerator (objects_array_t *
 
 objects_array_enumerator_t objects_array_descending_enumerator (objects_array_t * array);
 
-int objects_array_enumerator_next_index_and_element (objects_array_enumerator_t *enumerator, size_t *index, void **element);
+int objects_array_enumerator_next_index_and_element (objects_array_enumerator_t *enumerator, size_t *index, const void **element);
 
-int objects_array_enumerator_next_element (objects_array_enumerator_t *enumerator, void **element);
+int objects_array_enumerator_next_element (objects_array_enumerator_t *enumerator, const void **element);
 
 int objects_array_enumerator_next_index (objects_array_enumerator_t *enumerator, size_t *element);
 

Source/objects/callbacks.h

@@ -33,12 +33,14 @@
 
 /**** Type, Constant, and Macro Definitions **********************************/
 
-typedef size_t (*objects_hash_func_t) (void *, void *);
-typedef int (*objects_compare_func_t) (void *, void *, void *);
-typedef int (*objects_is_equal_func_t) (void *, void *, void *);
-typedef void *(*objects_retain_func_t) (void *, void *);
-typedef void (*objects_release_func_t) (void *, void *);
-typedef void *(*objects_describe_func_t) (void *, void *);
+typedef size_t (*objects_hash_func_t) (const void *, const void *);
+typedef int (*objects_compare_func_t) (const void *, const void *, 
+				       const void *);
+typedef int (*objects_is_equal_func_t) (const void *, const void *, 
+					const void *);
+typedef void *(*objects_retain_func_t) (const void *, const void *);
+typedef void (*objects_release_func_t) (void *, const void *);
+typedef void *(*objects_describe_func_t) (const void *, const void *);
 
 typedef struct _objects_callbacks objects_callbacks_t;
 
@@ -50,7 +52,7 @@ struct _objects_callbacks
   objects_retain_func_t retain;
   objects_release_func_t release;
   objects_describe_func_t describe;
-  void *not_an_item_marker;
+  const void *not_an_item_marker;
 };
 
 /** Callbacks for various types **/
@@ -88,85 +90,85 @@ objects_callbacks_standardize (objects_callbacks_t callbacks);
 /** Using callbacks **/
 
 size_t objects_hash (objects_callbacks_t callbacks,
-                     void *thing,
-                     void *user_data);
+                     const void *thing,
+                     const void *user_data);
 
 int objects_compare (objects_callbacks_t callbacks,
-                     void *thing1,
-                     void *thing2,
-                     void *user_data);
+                     const void *thing1,
+                     const void *thing2,
+                     const void *user_data);
 
 int objects_is_equal (objects_callbacks_t callbacks,
-                      void *thing1,
-                      void *thing2,
-                      void *user_data);
+                      const void *thing1,
+                      const void *thing2,
+                      const void *user_data);
 
 void *objects_retain (objects_callbacks_t callbacks,
-                      void *thing,
-                      void *user_data);
+                      const void *thing,
+                      const void *user_data);
 
 void objects_release (objects_callbacks_t callbacks,
                       void *thing,
-                      void *user_data);
+                      const void *user_data);
 
 /* FIXME: Decide what to do with this describe stuff.  We'd really like
  * them to return Strings?  Or would we rather they be `char *'s?
  * Or something else? */
 void *objects_describe (objects_callbacks_t callbacks,
-                        void *thing,
-                        void *user_data);
+                        const void *thing,
+                        const void *user_data);
 
-void *objects_not_an_item_marker (objects_callbacks_t);
+const void *objects_not_an_item_marker (objects_callbacks_t);
 
 /** Specific callback functions **/
 
 /* For `void *' */
-size_t objects_void_p_hash(void *ptr);
-int objects_void_p_compare(void *ptr, void *qtr);
-int objects_void_p_is_equal(void *ptr, void *qtr);
-void *objects_void_p_retain(void *ptr);
-void objects_void_p_release(void *ptr);
-void *objects_void_p_describe(void *ptr);
+size_t objects_void_p_hash(const void *ptr);
+int objects_void_p_compare(const void *ptr, const void *qtr);
+int objects_void_p_is_equal(const void *ptr, const void *qtr);
+const void *objects_void_p_retain(const void *ptr);
+void objects_void_p_release(const void *ptr);
+const void *objects_void_p_describe(const void *ptr);
 
 /* For `void *' */
-size_t objects_owned_void_p_hash(void *ptr);
-int objects_owned_void_p_compare(void *ptr, void *qtr);
-int objects_owned_void_p_is_equal(void *ptr, void *qtr);
-void *objects_owned_void_p_retain(void *ptr);
-void objects_owned_void_p_release(void *ptr);
-void *objects_owned_void_p_describe(void *ptr);
+size_t objects_owned_void_p_hash(const void *ptr);
+int objects_owned_void_p_compare(const void *ptr, const void *qtr);
+int objects_owned_void_p_is_equal(const void *ptr, const void *qtr);
+const void *objects_owned_void_p_retain(const void *ptr);
+void objects_owned_void_p_release(const void *ptr);
+const void *objects_owned_void_p_describe(const void *ptr);
 
 /* For `int' */
-size_t objects_int_hash(void *i);
-int objects_int_compare(void *i, void *j);
-int objects_int_is_equal(void *i, void *j);
-void *objects_int_retain(void *i);
-void objects_int_release(void *i);
-void *objects_int_describe(void *i);
+size_t objects_int_hash(const void *i);
+int objects_int_compare(const void *i, const void *j);
+int objects_int_is_equal(const void *i, const void *j);
+const void *objects_int_retain(const void *i);
+void objects_int_release(const void *i);
+const void *objects_int_describe(const void *i);
 
 /* For `int *' */
-size_t objects_int_p_hash(void *iptr);
-int objects_int_p_compare(void *iptr, void *jptr);
-int objects_int_p_is_equal(void *iptr, void *jptr);
-void *objects_int_p_retain(void *iptr);
-void objects_int_p_release(void *iptr);
-void *objects_int_p_describe(void *iptr);
+size_t objects_int_p_hash(const void *iptr);
+int objects_int_p_compare(const void *iptr, const void *jptr);
+int objects_int_p_is_equal(const void *iptr, const void *jptr);
+const void *objects_int_p_retain(const void *iptr);
+void objects_int_p_release(const void *iptr);
+const void *objects_int_p_describe(const void *iptr);
 
 /* For `char *' */
-size_t objects_char_p_hash(void *cptr);
-int objects_char_p_compare(void *cptr, void *dptr);
-int objects_char_p_is_equal(void *cptr, void *dptr);
-void *objects_char_p_retain(void *cptr);
-void objects_char_p_release(void *cptr);
-void *objects_char_p_describe(void *cptr);
+size_t objects_char_p_hash(const void *cptr);
+int objects_char_p_compare(const void *cptr, const void *dptr);
+int objects_char_p_is_equal(const void *cptr, const void *dptr);
+const void *objects_char_p_retain(const void *cptr);
+void objects_char_p_release(const void *cptr);
+const void *objects_char_p_describe(const void *cptr);
 
 /* For `id' */
-size_t objects_id_hash(void *obj);
-int objects_id_compare(void *obj, void *jbo);
-int objects_id_is_equal(void *obj, void *jbo);
-void *objects_id_retain(void *obj);
-void objects_id_release(void *obj);
-void *objects_id_describe(void *obj);
+size_t objects_id_hash(const void *obj);
+int objects_id_compare(const void *obj, const void *jbo);
+int objects_id_is_equal(const void *obj, const void *jbo);
+const void *objects_id_retain(const void *obj);
+void objects_id_release(const void *obj);
+const void *objects_id_describe(const void *obj);
 
 #endif /* __callbacks_h_OBJECTS_INCLUDE */
 

Source/objects/data.h

@@ -53,8 +53,8 @@ struct _objects_data
   {
     int magic;
     size_t number;
-    char *name;
-    void *extra;
+    const char *name;
+    const void *extra;
     objects_callbacks_t extra_callbacks;
     objects_allocs_t allocs;
 

Source/objects/hash.h

@@ -49,7 +49,7 @@ struct _objects_hash_node
     objects_hash_node_t *next_in_hash;
     objects_hash_node_t *prev_in_hash;
 
-    void *element;
+    const void *element;
   };
 
 struct _objects_hash_bucket
@@ -64,8 +64,8 @@ struct _objects_hash
   {
     int magic;
     size_t number;
-    char *name;
-    void *extra;
+    const char *name;
+    const void *extra;
     objects_callbacks_t extra_callbacks;
     objects_allocs_t allocs;
 
@@ -144,7 +144,10 @@ objects_hash_t * objects_hash_copy_with_allocs (objects_hash_t * hash, objects_a
  * to handle functions that aren't one-to-one is to create a new hash
  * and transform the elements of the first to create the elements of
  * the second. */
-objects_hash_t * objects_hash_map_elements (objects_hash_t * hash, void *(*fcn) (void *, void *), void *user_data);
+objects_hash_t * 
+objects_hash_map_elements (objects_hash_t * hash, 
+			   const void *(*fcn) (const void *, const void *), 
+			   const void *user_data);
 
 /** Destroying **/
 
@@ -160,39 +163,43 @@ int objects_hash_is_equal_to_hash (objects_hash_t * hash, objects_hash_t * other
 
 /** Adding **/
 
-void *objects_hash_add_element_known_absent (objects_hash_t * hash, void *element);
+const void *objects_hash_add_element_known_absent (objects_hash_t *hash, 
+						   const void *element);
 
-void *objects_hash_add_element (objects_hash_t * hash, void *element);
+const void *objects_hash_add_element (objects_hash_t *hash, 
+				      const void *element);
 
-void *objects_hash_add_element_if_absent (objects_hash_t * hash, void *element);
+const void *objects_hash_add_element_if_absent (objects_hash_t *hash, 
+						const void *element);
 
 /** Replacing **/
 
-void objects_hash_replace_element (objects_hash_t * hash, void *element);
+void objects_hash_replace_element (objects_hash_t *hash, const void *element);
 
 /** Removing **/
 
-void objects_hash_remove_element (objects_hash_t * hash, void *element);
+void objects_hash_remove_element (objects_hash_t *hash, const void *element);
 
 /** Emptying **/
 
-void objects_hash_empty (objects_hash_t * hash);
+void objects_hash_empty (objects_hash_t *hash);
 
 /** Searching **/
 
-void *objects_hash_any_element (objects_hash_t * hash);
+void *objects_hash_any_element (objects_hash_t *hash);
 
-int objects_hash_contains_element (objects_hash_t * hash, void *element);
+int objects_hash_contains_element (objects_hash_t *hash, const void *element);
 
-void *objects_hash_element (objects_hash_t * hash, void *element);
+const void *objects_hash_element (objects_hash_t *hash, const void *element);
 
-void **objects_hash_all_elements (objects_hash_t * hash);
+const void **objects_hash_all_elements (objects_hash_t *hash);
 
 /** Enumerating **/
 
-objects_hash_enumerator_t objects_hash_enumerator (objects_hash_t * hash);
+objects_hash_enumerator_t objects_hash_enumerator (objects_hash_t *hash);
 
-int objects_hash_enumerator_next_element (objects_hash_enumerator_t *enumerator, void **element);
+int objects_hash_enumerator_next_element (objects_hash_enumerator_t *enumeratr,
+					  const void **element);
 
 /** Statistics **/
 

Source/objects/list.h

@@ -47,7 +47,7 @@ struct _objects_list_node
     objects_list_node_t *next_in_list;
     objects_list_node_t *prev_in_list;
 
-    void *element;
+    const void *element;
   };
 
 struct _objects_list
@@ -56,7 +56,7 @@ struct _objects_list
     int magic;
     size_t number;
     char *name;
-    void *extra;
+    const void *extra;
     objects_callbacks_t extra_callbacks;
     objects_allocs_t allocs;
 
@@ -143,9 +143,9 @@ objects_list_t * objects_list_at_index_insert_list (objects_list_t * base_list,
 
 objects_list_t * objects_list_roll_to_nth_element (objects_list_t * list, long int n);
 
-objects_list_t * objects_list_roll_to_element (objects_list_t * list, void *element);
+objects_list_t * objects_list_roll_to_element (objects_list_t * list, const void *element);
 
-objects_list_t * objects_list_roll_to_nth_occurrance_of_element (objects_list_t * list, long int n, void *element);
+objects_list_t * objects_list_roll_to_nth_occurrance_of_element (objects_list_t * list, long int n, const void *element);
 
 objects_list_t * objects_list_invert (objects_list_t * list);
 
@@ -153,39 +153,39 @@ objects_list_t * objects_list_swap_elements_at_indices (objects_list_t * list, l
 
 /** Adding **/
 
-void *objects_list_append_element (objects_list_t * list, void *element);
+const void *objects_list_append_element (objects_list_t * list, const void *element);
 
-void *objects_list_append_element_if_absent (objects_list_t * list, void *element);
+const void *objects_list_append_element_if_absent (objects_list_t * list, const void *element);
 
-void *objects_list_prepend_element (objects_list_t * list, void *element);
+const void *objects_list_prepend_element (objects_list_t * list, const void *element);
 
-void *objects_list_prepend_element_if_absent (objects_list_t * list, void *element);
+const void *objects_list_prepend_element_if_absent (objects_list_t * list, const void *element);
 
-void *objects_list_at_index_insert_element (objects_list_t * list, long int n, void *element);
+const void *objects_list_at_index_insert_element (objects_list_t * list, long int n, const void *element);
 
-void *objects_list_at_index_insert_element_if_absent (objects_list_t * list, long int n, void *element);
+const void *objects_list_at_index_insert_element_if_absent (objects_list_t * list, long int n, const void *element);
 
-void *objects_list_queue_push_element (objects_list_t * list, void *element);
+const void *objects_list_queue_push_element (objects_list_t * list, const void *element);
 
-void *objects_list_stack_push_element (objects_list_t * list, void *element);
+const void *objects_list_stack_push_element (objects_list_t * list, const void *element);
 
 /** Replacing **/
 
-void objects_list_replace_nth_occurrance_of_element (objects_list_t * list, long int n, void *old_element, void *new_element);
+void objects_list_replace_nth_occurrance_of_element (objects_list_t * list, long int n, const void *old_element, const void *new_element);
 
-void objects_list_replace_element (objects_list_t * list, void *old_element, void *new_element);
+void objects_list_replace_element (objects_list_t * list, const void *old_element, const void *new_element);
 
-void objects_list_replace_nth_element (objects_list_t * list, long int n, void *new_element);
+void objects_list_replace_nth_element (objects_list_t * list, long int n, const void *new_element);
 
-void objects_list_replace_first_element (objects_list_t * list, void *new_element);
+void objects_list_replace_first_element (objects_list_t * list, const void *new_element);
 
-void objects_list_replace_last_element (objects_list_t * list, void *new_element);
+void objects_list_replace_last_element (objects_list_t * list, const void *new_element);
 
 /** Removing **/
 
-void objects_list_remove_nth_occurrence_of_element (objects_list_t * list, long int n, void *element);
+void objects_list_remove_nth_occurrence_of_element (objects_list_t * list, long int n, const void *element);
 
-void objects_list_remove_element (objects_list_t * list, void *element);
+void objects_list_remove_element (objects_list_t * list, const void *element);
 
 void objects_list_remove_nth_element (objects_list_t * list, long int n);
 
@@ -207,17 +207,17 @@ void objects_list_empty (objects_list_t * list);
 
 /** Searching **/
 
-int objects_list_contains_element (objects_list_t * list, void *element);
+int objects_list_contains_element (objects_list_t * list, const void *element);
 
-void *objects_list_element (objects_list_t * list, void *element);
+const void *objects_list_element (objects_list_t * list, const void *element);
 
-void *objects_list_nth_element (objects_list_t * list, long int n);
+const void *objects_list_nth_element (objects_list_t * list, long int n);
 
-void *objects_list_first_element (objects_list_t * list);
+const void *objects_list_first_element (objects_list_t * list);
 
-void *objects_list_last_element (objects_list_t * list);
+const void *objects_list_last_element (objects_list_t * list);
 
-void **objects_list_all_elements (objects_list_t * list);
+const void **objects_list_all_elements (objects_list_t * list);
 
 /** Enumerating **/
 
@@ -227,13 +227,13 @@ objects_list_enumerator_t objects_list_forward_enumerator (objects_list_t * list
 
 objects_list_enumerator_t objects_list_reverse_enumerator (objects_list_t * list);
 
-int objects_list_enumerator_next_element (objects_list_enumerator_t *enumerator, void **element);
+int objects_list_enumerator_next_element (objects_list_enumerator_t *enumerator, const void **element);
 
 /** Mapping **/
 
 /* NO WARNING: The mapping function FCN need not be one-to-one on the
  * elements of LIST.  In fact, FCN may do whatever it likes. */
-objects_list_t * objects_list_map_elements (objects_list_t * list, void *(*fcn) (void *, void *), void *user_data);
+objects_list_t * objects_list_map_elements (objects_list_t * list, const void *(*fcn) (const void *, const void *), const void *user_data);
 
 /** Statistics **/
 

Source/objects/map.h

@@ -43,56 +43,56 @@ typedef struct _objects_map_enumerator objects_map_enumerator_t;
 /* Important structures... */
 
 struct _objects_map_node
-  {
-    void *key;
-    void *value;
+{
+  const void *key;
+  const void *value;
 
-    objects_map_bucket_t *bucket;
-    objects_map_t *map;
+  objects_map_bucket_t *bucket;
+  objects_map_t *map;
 
-    objects_map_node_t *next_in_bucket;
-    objects_map_node_t *prev_in_bucket;
-    objects_map_node_t *next_in_map;
-    objects_map_node_t *prev_in_map;
-  };
+  objects_map_node_t *next_in_bucket;
+  objects_map_node_t *prev_in_bucket;
+  objects_map_node_t *next_in_map;
+  objects_map_node_t *prev_in_map;
+};
 
 struct _objects_map_bucket
-  {
-    size_t node_count;
-    size_t element_count;
+{
+  size_t node_count;
+  size_t element_count;
 
-    objects_map_node_t *first_node;
-  };
+  objects_map_node_t *first_node;
+};
 
 struct _objects_map
-  {
-    /* Container identifiers */
-    int magic;
-    size_t number;
-    char *name;
-    void *extra;
-    objects_callbacks_t extra_callbacks;
-    objects_allocs_t allocs;
-    objects_callbacks_t key_callbacks;
+{
+  /* Container identifiers */
+  int magic;
+  size_t number;
+  char *name;
+  const void *extra;
+  objects_callbacks_t extra_callbacks;
+  objects_allocs_t allocs;
+  objects_callbacks_t key_callbacks;
 
     /* Management information */
-    objects_callbacks_t value_callbacks;
+  objects_callbacks_t value_callbacks;
 
-    /* Internal counters */
-    size_t bucket_count;
-    size_t node_count;
-    size_t element_count;
+  /* Internal counters */
+  size_t bucket_count;
+  size_t node_count;
+  size_t element_count;
 
-    /* Databanks */
-    objects_map_bucket_t *buckets;
-    objects_map_node_t *first_node;
-  };
+  /* Databanks */
+  objects_map_bucket_t *buckets;
+  objects_map_node_t *first_node;
+};
 
 struct _objects_map_enumerator
-  {
-    objects_map_t *map;
-    objects_map_node_t *node;
-  };
+{
+  objects_map_t *map;
+  objects_map_node_t *node;
+};
 
 /**** Function Prototypes ****************************************************/
 
@@ -112,82 +112,82 @@ objects_map_rightsize (objects_map_t * map);
 /** Creating **/
 
 objects_map_t *
-  objects_map_alloc (void);
+objects_map_alloc (void);
 
 objects_map_t *
-  objects_map_alloc_with_allocs (objects_allocs_t allocs);
+objects_map_alloc_with_allocs (objects_allocs_t allocs);
 
 objects_map_t *
-  objects_map (void);
+objects_map (void);
 
 objects_map_t *
-  objects_map_with_allocs (objects_allocs_t allocs);
+objects_map_with_allocs (objects_allocs_t allocs);
 
 objects_map_t *
-  objects_map_with_allocs_with_callbacks (objects_allocs_t allocs,
-					  objects_callbacks_t key_callbacks,
-				       objects_callbacks_t value_callbacks);
+objects_map_with_allocs_with_callbacks (objects_allocs_t allocs,
+					objects_callbacks_t key_callbacks,
+					objects_callbacks_t value_callbacks);
 
 objects_map_t *
-  objects_map_with_callbacks (objects_callbacks_t key_callbacks,
-			      objects_callbacks_t value_callbacks);
+objects_map_with_callbacks (objects_callbacks_t key_callbacks,
+			    objects_callbacks_t value_callbacks);
 
 objects_map_t *
-  objects_map_of_int (void);
+objects_map_of_int (void);
 
 objects_map_t *
-  objects_map_of_int_to_char_p (void);
+objects_map_of_int_to_char_p (void);
 
 objects_map_t *
-  objects_map_of_int_to_void_p (void);
+objects_map_of_int_to_void_p (void);
 
 objects_map_t *
-  objects_map_of_int_to_float (void);
+objects_map_of_int_to_float (void);
 
 objects_map_t *
-  objects_map_of_char_p (void);
+objects_map_of_char_p (void);
 
 objects_map_t *
-  objects_map_of_char_p_to_int (void);
+objects_map_of_char_p_to_int (void);
 
 objects_map_t *
-  objects_map_of_char_p_to_void_p (void);
+objects_map_of_char_p_to_void_p (void);
 
 objects_map_t *
-  objects_map_of_char_p_to_float (void);
+objects_map_of_char_p_to_float (void);
 
 objects_map_t *
-  objects_map_of_void_p (void);
+objects_map_of_void_p (void);
 
 objects_map_t *
-  objects_map_of_void_p_to_int (void);
+objects_map_of_void_p_to_int (void);
 
 objects_map_t *
-  objects_map_of_void_p_to_char_p (void);
+objects_map_of_void_p_to_char_p (void);
 
 objects_map_t *
-  objects_map_of_void_p_to_float (void);
+objects_map_of_void_p_to_float (void);
 
 objects_map_t *
-  objects_map_of_float (void);
+objects_map_of_float (void);
 
 objects_map_t *
-  objects_map_of_double (void);
+objects_map_of_double (void);
 
 /** Initializing **/
 
 objects_map_t *
-  objects_map_init (objects_map_t * map);
+objects_map_init (objects_map_t * map);
 
 objects_map_t *
-  objects_map_init_with_callbacks (objects_map_t * map,
-				   objects_callbacks_t key_callbacks,
-				   objects_callbacks_t value_callbacks);
+objects_map_init_with_callbacks (objects_map_t * map,
+				 objects_callbacks_t key_callbacks,
+				 objects_callbacks_t value_callbacks);
 
 /** Destroying **/
 
 void
-  objects_map_dealloc (objects_map_t * map);
+objects_map_dealloc (objects_map_t * map);
 
 /** Gathering statistics on a mapionary **/
 
@@ -198,24 +198,24 @@ size_t
 objects_map_capacity (objects_map_t * map);
 
 int
-  objects_map_check_map (objects_map_t * map);
+objects_map_check_map (objects_map_t * map);
 
 /** Finding elements in a mapionary **/
 
 int
-  objects_map_contains_key (objects_map_t * map, void *key);
+objects_map_contains_key (objects_map_t * map, const void *key);
 
 int
-  objects_map_key_and_value (objects_map_t * map,
-			     void *key,
-			     void **old_key,
-			     void **value);
+objects_map_key_and_value (objects_map_t * map,
+			   const void *key,
+			   void **old_key,
+			   void **value);
 
-void *
-  objects_map_key (objects_map_t * map, void *key);
+const void *
+objects_map_key (objects_map_t * map, const void *key);
 
-void *
-  objects_map_value (objects_map_t * map, void *key);
+const void *
+objects_map_value_at_key (objects_map_t * map, const void *key);
 
 /** Enumerating the nodes and elements of a mapionary **/
 
@@ -223,74 +223,74 @@ objects_map_enumerator_t
 objects_map_enumerator (objects_map_t * map);
 
 int
-  objects_map_enumerator_next_key_and_value (objects_map_enumerator_t * enumerator,
-					     void **key,
-					     void **value);
+objects_map_enumerator_next_key_and_value (objects_map_enumerator_t *enumeratr,
+					   const void **key,
+					   const void **value);
 
 int
-  objects_map_enumerator_next_key (objects_map_enumerator_t * enumerator,
-				   void **key);
+objects_map_enumerator_next_key (objects_map_enumerator_t * enumerator,
+				 const void **key);
 
 int
-  objects_map_enumerator_next_value (objects_map_enumerator_t * enumerator,
-				     void **value);
+objects_map_enumerator_next_value (objects_map_enumerator_t * enumerator,
+				   const void **value);
 
 /** Obtaining an array of the elements of a mapionary **/
 
-void **
-  objects_map_all_keys_and_values (objects_map_t * map);
+const void **
+objects_map_all_keys_and_values (objects_map_t * map);
 
-void **
-  objects_map_all_keys (objects_map_t * map);
+const void **
+objects_map_all_keys (objects_map_t * map);
 
-void **
-  objects_map_all_values (objects_map_t * map);
+const void **
+objects_map_all_values (objects_map_t * map);
 
 /** Removing **/
 
 void
-  objects_map_remove_key (objects_map_t * map, void *key);
+objects_map_remove_key (objects_map_t * map, const void *key);
 
 void
-  objects_map_empty (objects_map_t * map);
+objects_map_empty (objects_map_t * map);
 
 /** Adding **/
 
-void *
-  objects_map_at_key_put_value_known_absent (objects_map_t * map,
-					     void *key,
-					     void *value);
+const void *
+objects_map_at_key_put_value_known_absent (objects_map_t * map,
+					   const void *key,
+					   const void *value);
 
-void *
-  objects_map_at_key_put_value (objects_map_t * map,
-				void *key,
-				void *value);
+const void *
+objects_map_at_key_put_value (objects_map_t * map,
+			      const void *key,
+			      const void *value);
 
-void *
-  objects_map_at_key_put_value_if_absent (objects_map_t * map,
-					  void *key,
-					  void *value);
+const void *
+objects_map_at_key_put_value_if_absent (objects_map_t * map,
+					const void *key,
+					const void *value);
 
 /** Replacing **/
 
 void
-  objects_map_replace_key (objects_map_t * map, void *key);
+objects_map_replace_key (objects_map_t * map, const void *key);
 
 /** Comparing **/
 
 int
-  objects_map_contains_map (objects_map_t * map1, objects_map_t * map2);
+objects_map_contains_map (objects_map_t * map1, objects_map_t * map2);
 
 int
-  objects_map_is_equal_to_map (objects_map_t * map1, objects_map_t * map2);
+objects_map_is_equal_to_map (objects_map_t * map1, objects_map_t * map2);
 
 /** Copying **/
 
 objects_map_t *
-  objects_map_copy_with_allocs (objects_map_t * old_map, objects_allocs_t new_allocs);
+objects_map_copy_with_allocs (objects_map_t * old_map, objects_allocs_t new_allocs);
 
 objects_map_t *
-  objects_map_copy (objects_map_t * old_map);
+objects_map_copy (objects_map_t * old_map);
 
 /** Mapping **/
 
@@ -299,32 +299,32 @@ objects_map_t *
  * possibility that KFCN maps two unequal keys of MAP to the same (or
  * equal) keys. */
 objects_map_t *
-  objects_map_map_keys (objects_map_t * map,
-			void *(*kfcn) (void *, void *),
-			void *user_data);
+objects_map_map_keys (objects_map_t * map,
+		      const void *(*kfcn) (const void *, const void *),
+		      const void *user_data);
 
 /* NO WARNING: The mapping function VFCN need not be one-to-one on
  * (the equivalence classes of) values. */
 objects_map_t *
-  objects_map_map_values (objects_map_t * map,
-			  void *(*vfcn) (void *, void *),
-			  void *user_data);
+objects_map_map_values (objects_map_t * map,
+			const void *(*vfcn) (const void *, const void *),
+			const void *user_data);
 
 /** Miscellaneous **/
 
 objects_map_t *
-  objects_map_intersect_map (objects_map_t * map, objects_map_t * other_map);
+objects_map_intersect_map (objects_map_t * map, objects_map_t * other_map);
 
 objects_map_t *
-  objects_map_minus_map (objects_map_t * map, objects_map_t * other_map);
+objects_map_minus_map (objects_map_t * map, objects_map_t * other_map);
 
 objects_map_t *
-  objects_map_union_map (objects_map_t * map, objects_map_t * other_map);
+objects_map_union_map (objects_map_t * map, objects_map_t * other_map);
 
 objects_hash_t *
-  objects_hash_init_from_map_keys (objects_hash_t * hash, objects_map_t * map);
+objects_hash_init_from_map_keys (objects_hash_t * hash, objects_map_t * map);
 
 objects_hash_t *
-  objects_hash_init_from_map_values (objects_hash_t * hash, objects_map_t * map);
+objects_hash_init_from_map_values (objects_hash_t * hash, objects_map_t * map);
 
 #endif /* __map_h_OBJECTS_INCLUDE */

Source/objects/objects.h

@@ -46,11 +46,6 @@
 #include <objects/RBTreeNode.h>
 #include <objects/SplayTree.h>
 
-#include <objects/EltNodeCollector.h>
-#include <objects/LinkedListEltNode.h>
-#include <objects/BinaryTreeEltNode.h>
-#include <objects/RBTreeEltNode.h>
-
 /* Magnitude objects */
 #include <objects/Magnitude.h>
 #include <objects/Random.h>
@@ -75,4 +70,6 @@
 #include <objects/Proxy.h>
 #include <objects/ConnectedCoder.h>
 
+#include <objects/Invocation.h>
+
 #endif /* __objects_h_OBJECTS_INCLUDE */

Source/x-basics.c.in

@@ -73,7 +73,7 @@ objects_@XX@_set_name (objects_@XX@_t *xx, const char *name)
 {
   /* Figure out how much space we need. */
   size_t len = strlen (name);
-  char *old_name = xx->name;
+  const char *old_name = xx->name;
 
   /* Allocate space for the new name.  (Don't forget the extra space
    * for the terminating `NUL'. */
@@ -148,7 +148,7 @@ objects_@XX@_set_extra_callbacks (objects_@XX@_t *xx, objects_callbacks_t callba
   xx->extra_callbacks = callbacks;
 
   /* Release the old contents. */
-  objects_release (old_callbacks, xx->extra, xx);
+  objects_release (old_callbacks, (void*)xx->extra, xx);
 
   /* Set the contents to something noticible. */
   xx->extra = (xx->extra_callbacks).not_an_item_marker;
@@ -166,7 +166,7 @@ objects_@XX@_extra_callbacks (objects_@XX@_t *xx, objects_callbacks_t callbacks)
 /* Returns XX's ``extra'', a little extra space that each Libobjects
  * structure carries around with it.  Its use is
  * implementation-dependent. */
-void *
+const void *
 objects_@XX@_extra (objects_@XX@_t *xx)
 {
   return xx->extra;
@@ -174,15 +174,15 @@ objects_@XX@_extra (objects_@XX@_t *xx)
 
 /* Sets XX's ``extra'', a little extra space that each Libobjects structure
  * carries around with it.  Its use is implementation-dependent. */
-void *
-objects_@XX@_set_extra (objects_@XX@_t *xx, void *extra)
+const void *
+objects_@XX@_set_extra (objects_@XX@_t *xx, const void *extra)
 {
-  void *old_extra;
+  const void *old_extra;
 
   /* Out with the old, and in with the new. */
   old_extra = xx->extra;
   xx->extra = objects_retain (xx->extra_callbacks, extra, xx);
-  objects_release (xx->extra_callbacks, old_extra, xx);
+  objects_release (xx->extra_callbacks, (void*)old_extra, xx);
 
   return old_extra;
 }
@@ -192,7 +192,7 @@ void
 objects_@XX@_unset_extra (objects_@XX@_t *xx)
 {
   /* Release XX's extra. */
-  objects_release (xx->extra_callbacks, xx->extra, xx);
+  objects_release (xx->extra_callbacks, (void*)xx->extra, xx);
 
   /* Reset XX's extra. */
   xx->extra = (xx->extra_callbacks).not_an_item_marker;

Source/x-callbacks.c.in

@@ -47,7 +47,7 @@ objects_@YY@_key_callbacks (objects_@YY@_t * yy)
 }
 
 /* Returns the ``bogus'' marker associated with YY's keys. */
-void *
+const void *
 objects_@YY@_not_a_key_marker (objects_@YY@_t *yy)
 {
   return (yy->key_callbacks).not_an_item_marker;
@@ -61,7 +61,7 @@ objects_@YY@_value_callbacks (objects_@YY@_t *yy)
 }
 
 /* Returns the ``bogus'' marker associated with YY's values. */
-void *
+const void *
 objects_@YY@_not_a_value_marker (objects_@YY@_t *yy)
 {
   return (yy->value_callbacks).not_an_item_marker;
@@ -79,7 +79,7 @@ objects_@YY@_element_callbacks (objects_@YY@_t *yy)
 }
 
 /* Returns the ``bogus'' marker associated with YY's elements. */
-void *
+const void *
 objects_@YY@_not_an_element_marker (objects_@YY@_t *yy)
 {
   return (yy->callbacks).not_an_item_marker;