diff --git a/Headers/gnustep/base/all.h b/Headers/gnustep/base/all.h index c1e8cfaa3..4afb585fa 100644 --- a/Headers/gnustep/base/all.h +++ b/Headers/gnustep/base/all.h @@ -46,11 +46,6 @@ #include #include -#include -#include -#include -#include - /* Magnitude objects */ #include #include @@ -75,4 +70,6 @@ #include #include +#include + #endif /* __objects_h_OBJECTS_INCLUDE */ diff --git a/Headers/gnustep/base/allocs.h b/Headers/gnustep/base/allocs.h index 77e58db98..92db3ee96 100644 --- a/Headers/gnustep/base/allocs.h +++ b/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); diff --git a/Headers/gnustep/base/array.h b/Headers/gnustep/base/array.h index 35db4bc43..4577f48cd 100644 --- a/Headers/gnustep/base/array.h +++ b/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); diff --git a/Headers/gnustep/base/data.h b/Headers/gnustep/base/data.h index fbbf5c1e0..c4474f2d2 100644 --- a/Headers/gnustep/base/data.h +++ b/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; diff --git a/Headers/gnustep/base/hash.h b/Headers/gnustep/base/hash.h index 6bd302ea5..756609d4a 100644 --- a/Headers/gnustep/base/hash.h +++ b/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 **/ diff --git a/Headers/gnustep/base/list.h b/Headers/gnustep/base/list.h index 11ae2783b..47a76ce8b 100644 --- a/Headers/gnustep/base/list.h +++ b/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 **/ diff --git a/Headers/gnustep/base/map.h b/Headers/gnustep/base/map.h index 684c725ab..aff97af08 100644 --- a/Headers/gnustep/base/map.h +++ b/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 */ diff --git a/Headers/gnustep/base/o_array.h b/Headers/gnustep/base/o_array.h index 35db4bc43..4577f48cd 100644 --- a/Headers/gnustep/base/o_array.h +++ b/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); diff --git a/Headers/gnustep/base/o_cbs.h b/Headers/gnustep/base/o_cbs.h index 4af6aaec1..3494f4a86 100644 --- a/Headers/gnustep/base/o_cbs.h +++ b/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 */ diff --git a/Headers/gnustep/base/o_hash.h b/Headers/gnustep/base/o_hash.h index 6bd302ea5..756609d4a 100644 --- a/Headers/gnustep/base/o_hash.h +++ b/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 **/ diff --git a/Headers/gnustep/base/o_list.h b/Headers/gnustep/base/o_list.h index 11ae2783b..47a76ce8b 100644 --- a/Headers/gnustep/base/o_list.h +++ b/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 **/ diff --git a/Headers/gnustep/base/o_map.h b/Headers/gnustep/base/o_map.h index 684c725ab..aff97af08 100644 --- a/Headers/gnustep/base/o_map.h +++ b/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 */ diff --git a/Headers/gnustep/base/objects.h b/Headers/gnustep/base/objects.h index c1e8cfaa3..4afb585fa 100644 --- a/Headers/gnustep/base/objects.h +++ b/Headers/gnustep/base/objects.h @@ -46,11 +46,6 @@ #include #include -#include -#include -#include -#include - /* Magnitude objects */ #include #include @@ -75,4 +70,6 @@ #include #include +#include + #endif /* __objects_h_OBJECTS_INCLUDE */ diff --git a/Source/NSHashTable.m b/Source/NSHashTable.m index 52cda3b68..13935f4ed 100644 --- a/Source/NSHashTable.m +++ b/Source/NSHashTable.m @@ -3,8 +3,8 @@ * * Author: Albin L. Jones * 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 #include #include +#include #include #include @@ -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]; } - diff --git a/Source/NSMapTable.m b/Source/NSMapTable.m index 5190f89a8..693d24fa3 100644 --- a/Source/NSMapTable.m +++ b/Source/NSMapTable.m @@ -26,17 +26,19 @@ /**** Included Headers *******************************************************/ +#include #include #include #include -#include #include -#include +#include +#include +#include /**** 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); diff --git a/Source/callbacks-char_p.c b/Source/callbacks-char_p.c index 51d2145eb..158449bdb 100644 --- a/Source/callbacks-char_p.c +++ b/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; diff --git a/Source/callbacks-id.m b/Source/callbacks-id.m index 7089afd5d..4bda89f5b 100644 --- a/Source/callbacks-id.m +++ b/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 } diff --git a/Source/callbacks-int.c b/Source/callbacks-int.c index b4bb6cc99..d3ca07fd0 100644 --- a/Source/callbacks-int.c +++ b/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; diff --git a/Source/callbacks-int_p.c b/Source/callbacks-int_p.c index 205cda5a1..8a7c8ce29 100644 --- a/Source/callbacks-int_p.c +++ b/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; diff --git a/Source/callbacks-void_p.c b/Source/callbacks-void_p.c index 5f2576afc..ecd3b8074 100644 --- a/Source/callbacks-void_p.c +++ b/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; +} diff --git a/Source/callbacks.c b/Source/callbacks.c index 8612a3773..b481544d8 100644 --- a/Source/callbacks.c +++ b/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); diff --git a/Source/hash.c b/Source/hash.c index 624f6baf5..da3ebb3d6 100644 --- a/Source/hash.c +++ b/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); diff --git a/Source/list.c b/Source/list.c index 19bdb41dd..617019505 100644 --- a/Source/list.c +++ b/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); diff --git a/Source/map.c b/Source/map.c index db2288206..33975f8bd 100644 --- a/Source/map.c +++ b/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); diff --git a/Source/objects/allocs.h b/Source/objects/allocs.h index 77e58db98..92db3ee96 100644 --- a/Source/objects/allocs.h +++ b/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); diff --git a/Source/objects/array.h b/Source/objects/array.h index 35db4bc43..4577f48cd 100644 --- a/Source/objects/array.h +++ b/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); diff --git a/Source/objects/callbacks.h b/Source/objects/callbacks.h index 4af6aaec1..3494f4a86 100644 --- a/Source/objects/callbacks.h +++ b/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 */ diff --git a/Source/objects/data.h b/Source/objects/data.h index fbbf5c1e0..c4474f2d2 100644 --- a/Source/objects/data.h +++ b/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; diff --git a/Source/objects/hash.h b/Source/objects/hash.h index 6bd302ea5..756609d4a 100644 --- a/Source/objects/hash.h +++ b/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 **/ diff --git a/Source/objects/list.h b/Source/objects/list.h index 11ae2783b..47a76ce8b 100644 --- a/Source/objects/list.h +++ b/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 **/ diff --git a/Source/objects/map.h b/Source/objects/map.h index 684c725ab..aff97af08 100644 --- a/Source/objects/map.h +++ b/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 */ diff --git a/Source/objects/objects.h b/Source/objects/objects.h index c1e8cfaa3..4afb585fa 100644 --- a/Source/objects/objects.h +++ b/Source/objects/objects.h @@ -46,11 +46,6 @@ #include #include -#include -#include -#include -#include - /* Magnitude objects */ #include #include @@ -75,4 +70,6 @@ #include #include +#include + #endif /* __objects_h_OBJECTS_INCLUDE */ diff --git a/Source/x-basics.c.in b/Source/x-basics.c.in index 8cf4eb53d..c82433027 100644 --- a/Source/x-basics.c.in +++ b/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; diff --git a/Source/x-callbacks.c.in b/Source/x-callbacks.c.in index 05d814483..82679b4ce 100644 --- a/Source/x-callbacks.c.in +++ b/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;