diff --git a/libs/libks/src/include/mpool.h b/libs/libks/src/include/mpool.h index 23ac93fb91..16ccb3c1b9 100644 --- a/libs/libks/src/include/mpool.h +++ b/libs/libks/src/include/mpool.h @@ -134,11 +134,11 @@ * mpool_resize only. */ typedef void (*mpool_log_func_t)(const void *mp_p, - const int func_id, - const unsigned long byte_size, - const unsigned long ele_n, - const void *old_addr, const void *new_addr, - const unsigned long old_byte_size); + const int func_id, + const unsigned long byte_size, + const unsigned long ele_n, + const void *old_addr, const void *new_addr, + const unsigned long old_byte_size); #ifdef MPOOL_MAIN @@ -183,7 +183,7 @@ typedef void mpool_t; */ extern mpool_t *mpool_open(const unsigned int flags, const unsigned int page_size, - void *start_addr, int *error_p); + void *start_addr, int *error_p); /* * int mpool_close @@ -251,7 +251,7 @@ int mpool_clear(mpool_t *mp_p); */ extern void *mpool_alloc(mpool_t *mp_p, const unsigned long byte_size, - int *error_p); + int *error_p); /* * void *mpool_calloc @@ -281,7 +281,7 @@ void *mpool_alloc(mpool_t *mp_p, const unsigned long byte_size, */ extern void *mpool_calloc(mpool_t *mp_p, const unsigned long ele_n, - const unsigned long ele_size, int *error_p); + const unsigned long ele_size, int *error_p); /* * int mpool_free @@ -341,9 +341,9 @@ int mpool_free(mpool_t *mp_p, void *addr, const unsigned long size); */ extern void *mpool_resize(mpool_t *mp_p, void *old_addr, - const unsigned long old_byte_size, - const unsigned long new_byte_size, - int *error_p); + const unsigned long old_byte_size, + const unsigned long new_byte_size, + int *error_p); /* * int mpool_stats @@ -381,10 +381,10 @@ void *mpool_resize(mpool_t *mp_p, void *old_addr, */ extern int mpool_stats(const mpool_t *mp_p, unsigned int *page_size_p, - unsigned long *num_alloced_p, - unsigned long *user_alloced_p, - unsigned long *max_alloced_p, - unsigned long *tot_alloced_p); + unsigned long *num_alloced_p, + unsigned long *user_alloced_p, + unsigned long *max_alloced_p, + unsigned long *tot_alloced_p); /* * int mpool_set_log_func @@ -461,3 +461,14 @@ const char *mpool_strerror(const int error); /*<<<<<<<<<< This is end of the auto-generated output from fillproto. */ #endif /* ! __MPOOL_H__ */ + +/* For Emacs: + * Local Variables: + * mode:c + * indent-tabs-mode:t + * tab-width:4 + * c-basic-offset:4 + * End: + * For VIM: + * vim:set softtabstop=4 shiftwidth=4 tabstop=4 noet: + */ diff --git a/libs/libks/src/include/simclist.h b/libs/libks/src/include/simclist.h index 2ce9d491ad..1b99ad9c43 100755 --- a/libs/libks/src/include/simclist.h +++ b/libs/libks/src/include/simclist.h @@ -40,7 +40,7 @@ extern "C" { #endif -/* Be friend of both C90 and C99 compilers */ + /* Be friend of both C90 and C99 compilers */ #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* "inline" and "restrict" are keywords */ #else @@ -49,928 +49,928 @@ extern "C" { #endif -/** - * Type representing list hashes. - * - * This is a signed integer value. - */ -typedef int32_t list_hash_t; + /** + * Type representing list hashes. + * + * This is a signed integer value. + */ + typedef int32_t list_hash_t; #ifndef SIMCLIST_NO_DUMPRESTORE -typedef struct { - uint16_t version; /* dump version */ - struct timeval timestamp; /* when the list has been dumped, seconds since UNIX epoch */ - uint32_t list_size; - uint32_t list_numels; - list_hash_t list_hash; /* hash of the list when dumped, or 0 if invalid */ - uint32_t dumpsize; - int consistent; /* 1 if the dump is verified complete/consistent; 0 otherwise */ -} list_dump_info_t; + typedef struct { + uint16_t version; /* dump version */ + struct timeval timestamp; /* when the list has been dumped, seconds since UNIX epoch */ + uint32_t list_size; + uint32_t list_numels; + list_hash_t list_hash; /* hash of the list when dumped, or 0 if invalid */ + uint32_t dumpsize; + int consistent; /* 1 if the dump is verified complete/consistent; 0 otherwise */ + } list_dump_info_t; #endif -/** - * a comparator of elements. - * - * A comparator of elements is a function that: - * -# receives two references to elements a and b - * -# returns {<0, 0, >0} if (a > b), (a == b), (a < b) respectively - * - * It is responsability of the function to handle possible NULL values. - */ -typedef int (*element_comparator)(const void *a, const void *b); + /** + * a comparator of elements. + * + * A comparator of elements is a function that: + * -# receives two references to elements a and b + * -# returns {<0, 0, >0} if (a > b), (a == b), (a < b) respectively + * + * It is responsability of the function to handle possible NULL values. + */ + typedef int (*element_comparator)(const void *a, const void *b); -/** - * a seeker of elements. - * - * An element seeker is a function that: - * -# receives a reference to an element el - * -# receives a reference to some indicator data - * -# returns non-0 if the element matches the indicator, 0 otherwise - * - * It is responsability of the function to handle possible NULL values in any - * argument. - */ -typedef int (*element_seeker)(const void *el, const void *indicator); + /** + * a seeker of elements. + * + * An element seeker is a function that: + * -# receives a reference to an element el + * -# receives a reference to some indicator data + * -# returns non-0 if the element matches the indicator, 0 otherwise + * + * It is responsability of the function to handle possible NULL values in any + * argument. + */ + typedef int (*element_seeker)(const void *el, const void *indicator); -/** - * an element lenght meter. - * - * An element meter is a function that: - * -# receives the reference to an element el - * -# returns its size in bytes - * - * It is responsability of the function to handle possible NULL values. - */ -typedef size_t (*element_meter)(const void *el); + /** + * an element lenght meter. + * + * An element meter is a function that: + * -# receives the reference to an element el + * -# returns its size in bytes + * + * It is responsability of the function to handle possible NULL values. + */ + typedef size_t (*element_meter)(const void *el); -/** - * a function computing the hash of elements. - * - * An hash computing function is a function that: - * -# receives the reference to an element el - * -# returns a hash value for el - * - * It is responsability of the function to handle possible NULL values. - */ -typedef list_hash_t (*element_hash_computer)(const void *el); + /** + * a function computing the hash of elements. + * + * An hash computing function is a function that: + * -# receives the reference to an element el + * -# returns a hash value for el + * + * It is responsability of the function to handle possible NULL values. + */ + typedef list_hash_t (*element_hash_computer)(const void *el); -/** - * a function for serializing an element. - * - * A serializer function is one that gets a reference to an element, - * and returns a reference to a buffer that contains its serialization - * along with the length of this buffer. - * It is responsability of the function to handle possible NULL values, - * returning a NULL buffer and a 0 buffer length. - * - * These functions have 3 goals: - * -# "freeze" and "flatten" the memory representation of the element - * -# provide a portable (wrt byte order, or type size) representation of the element, if the dump can be used on different sw/hw combinations - * -# possibly extract a compressed representation of the element - * - * @param el reference to the element data - * @param serialize_buffer reference to fill with the length of the buffer - * @return reference to the buffer with the serialized data - */ -typedef void *(*element_serializer)(const void *restrict el, uint32_t *restrict serializ_len); + /** + * a function for serializing an element. + * + * A serializer function is one that gets a reference to an element, + * and returns a reference to a buffer that contains its serialization + * along with the length of this buffer. + * It is responsability of the function to handle possible NULL values, + * returning a NULL buffer and a 0 buffer length. + * + * These functions have 3 goals: + * -# "freeze" and "flatten" the memory representation of the element + * -# provide a portable (wrt byte order, or type size) representation of the element, if the dump can be used on different sw/hw combinations + * -# possibly extract a compressed representation of the element + * + * @param el reference to the element data + * @param serialize_buffer reference to fill with the length of the buffer + * @return reference to the buffer with the serialized data + */ + typedef void *(*element_serializer)(const void *restrict el, uint32_t *restrict serializ_len); -/** - * a function for un-serializing an element. - * - * An unserializer function accomplishes the inverse operation of the - * serializer function. An unserializer function is one that gets a - * serialized representation of an element and turns it backe to the original - * element. The serialized representation is passed as a reference to a buffer - * with its data, and the function allocates and returns the buffer containing - * the original element, and it sets the length of this buffer into the - * integer passed by reference. - * - * @param data reference to the buffer with the serialized representation of the element - * @param data_len reference to the location where to store the length of the data in the buffer returned - * @return reference to a buffer with the original, unserialized representation of the element - */ -typedef void *(*element_unserializer)(const void *restrict data, uint32_t *restrict data_len); + /** + * a function for un-serializing an element. + * + * An unserializer function accomplishes the inverse operation of the + * serializer function. An unserializer function is one that gets a + * serialized representation of an element and turns it backe to the original + * element. The serialized representation is passed as a reference to a buffer + * with its data, and the function allocates and returns the buffer containing + * the original element, and it sets the length of this buffer into the + * integer passed by reference. + * + * @param data reference to the buffer with the serialized representation of the element + * @param data_len reference to the location where to store the length of the data in the buffer returned + * @return reference to a buffer with the original, unserialized representation of the element + */ + typedef void *(*element_unserializer)(const void *restrict data, uint32_t *restrict data_len); -/* [private-use] list entry -- olds actual user datum */ -struct list_entry_s { - void *data; + /* [private-use] list entry -- olds actual user datum */ + struct list_entry_s { + void *data; - /* doubly-linked list service references */ - struct list_entry_s *next; - struct list_entry_s *prev; -}; + /* doubly-linked list service references */ + struct list_entry_s *next; + struct list_entry_s *prev; + }; -/* [private-use] list attributes */ -struct list_attributes_s { - /* user-set routine for comparing list elements */ - element_comparator comparator; - /* user-set routing for seeking elements */ - element_seeker seeker; - /* user-set routine for determining the length of an element */ - element_meter meter; - int copy_data; - /* user-set routine for computing the hash of an element */ - element_hash_computer hasher; - /* user-set routine for serializing an element */ - element_serializer serializer; - /* user-set routine for unserializing an element */ - element_unserializer unserializer; -}; + /* [private-use] list attributes */ + struct list_attributes_s { + /* user-set routine for comparing list elements */ + element_comparator comparator; + /* user-set routing for seeking elements */ + element_seeker seeker; + /* user-set routine for determining the length of an element */ + element_meter meter; + int copy_data; + /* user-set routine for computing the hash of an element */ + element_hash_computer hasher; + /* user-set routine for serializing an element */ + element_serializer serializer; + /* user-set routine for unserializing an element */ + element_unserializer unserializer; + }; -/** list object */ -typedef struct { - struct list_entry_s *head_sentinel; - struct list_entry_s *tail_sentinel; - struct list_entry_s *mid; + /** list object */ + typedef struct { + struct list_entry_s *head_sentinel; + struct list_entry_s *tail_sentinel; + struct list_entry_s *mid; - unsigned int numels; + unsigned int numels; - /* array of spare elements */ - struct list_entry_s **spareels; - unsigned int spareelsnum; + /* array of spare elements */ + struct list_entry_s **spareels; + unsigned int spareelsnum; #ifdef SIMCLIST_WITH_THREADS - /* how many threads are currently running */ - unsigned int threadcount; + /* how many threads are currently running */ + unsigned int threadcount; #endif - /* service variables for list iteration */ - int iter_active; - unsigned int iter_pos; - struct list_entry_s *iter_curentry; + /* service variables for list iteration */ + int iter_active; + unsigned int iter_pos; + struct list_entry_s *iter_curentry; - /* list attributes */ - struct list_attributes_s attrs; -} list_t; + /* list attributes */ + struct list_attributes_s attrs; + } list_t; -/** - * initialize a list object for use. - * - * @param l must point to a user-provided memory location - * @return 0 for success. -1 for failure - */ -int list_init(list_t *restrict l); + /** + * initialize a list object for use. + * + * @param l must point to a user-provided memory location + * @return 0 for success. -1 for failure + */ + int list_init(list_t *restrict l); -/** - * completely remove the list from memory. - * - * This function is the inverse of list_init(). It is meant to be called when - * the list is no longer going to be used. Elements and possible memory taken - * for internal use are freed. - * - * @param l list to destroy - */ -void list_destroy(list_t *restrict l); + /** + * completely remove the list from memory. + * + * This function is the inverse of list_init(). It is meant to be called when + * the list is no longer going to be used. Elements and possible memory taken + * for internal use are freed. + * + * @param l list to destroy + */ + void list_destroy(list_t *restrict l); -/** - * set the comparator function for list elements. - * - * Comparator functions are used for searching and sorting. If NULL is passed - * as reference to the function, the comparator is disabled. - * - * @param l list to operate - * @param comparator_fun pointer to the actual comparator function - * @return 0 if the attribute was successfully set; -1 otherwise - * - * @see element_comparator() - */ -int list_attributes_comparator(list_t *restrict l, element_comparator comparator_fun); + /** + * set the comparator function for list elements. + * + * Comparator functions are used for searching and sorting. If NULL is passed + * as reference to the function, the comparator is disabled. + * + * @param l list to operate + * @param comparator_fun pointer to the actual comparator function + * @return 0 if the attribute was successfully set; -1 otherwise + * + * @see element_comparator() + */ + int list_attributes_comparator(list_t *restrict l, element_comparator comparator_fun); -/** - * set a seeker function for list elements. - * - * Seeker functions are used for finding elements. If NULL is passed as reference - * to the function, the seeker is disabled. - * - * @param l list to operate - * @param seeker_fun pointer to the actual seeker function - * @return 0 if the attribute was successfully set; -1 otherwise - * - * @see element_seeker() - */ -int list_attributes_seeker(list_t *restrict l, element_seeker seeker_fun); + /** + * set a seeker function for list elements. + * + * Seeker functions are used for finding elements. If NULL is passed as reference + * to the function, the seeker is disabled. + * + * @param l list to operate + * @param seeker_fun pointer to the actual seeker function + * @return 0 if the attribute was successfully set; -1 otherwise + * + * @see element_seeker() + */ + int list_attributes_seeker(list_t *restrict l, element_seeker seeker_fun); -/** - * require to free element data when list entry is removed (default: don't free). - * - * [ advanced preference ] - * - * By default, when an element is removed from the list, it disappears from - * the list by its actual data is not free()d. With this option, every - * deletion causes element data to be freed. - * - * It is responsability of this function to correctly handle NULL values, if - * NULL elements are inserted into the list. - * - * @param l list to operate - * @param metric_fun pointer to the actual metric function - * @param copy_data 0: do not free element data (default); non-0: do free - * @return 0 if the attribute was successfully set; -1 otherwise - * - * @see element_meter() - * @see list_meter_int8_t() - * @see list_meter_int16_t() - * @see list_meter_int32_t() - * @see list_meter_int64_t() - * @see list_meter_uint8_t() - * @see list_meter_uint16_t() - * @see list_meter_uint32_t() - * @see list_meter_uint64_t() - * @see list_meter_float() - * @see list_meter_double() - * @see list_meter_string() - */ -int list_attributes_copy(list_t *restrict l, element_meter metric_fun, int copy_data); + /** + * require to free element data when list entry is removed (default: don't free). + * + * [ advanced preference ] + * + * By default, when an element is removed from the list, it disappears from + * the list by its actual data is not free()d. With this option, every + * deletion causes element data to be freed. + * + * It is responsability of this function to correctly handle NULL values, if + * NULL elements are inserted into the list. + * + * @param l list to operate + * @param metric_fun pointer to the actual metric function + * @param copy_data 0: do not free element data (default); non-0: do free + * @return 0 if the attribute was successfully set; -1 otherwise + * + * @see element_meter() + * @see list_meter_int8_t() + * @see list_meter_int16_t() + * @see list_meter_int32_t() + * @see list_meter_int64_t() + * @see list_meter_uint8_t() + * @see list_meter_uint16_t() + * @see list_meter_uint32_t() + * @see list_meter_uint64_t() + * @see list_meter_float() + * @see list_meter_double() + * @see list_meter_string() + */ + int list_attributes_copy(list_t *restrict l, element_meter metric_fun, int copy_data); -/** - * set the element hash computing function for the list elements. - * - * [ advanced preference ] - * - * An hash can be requested depicting the list status at a given time. An hash - * only depends on the elements and their order. By default, the hash of an - * element is only computed on its reference. With this function, the user can - * set a custom function computing the hash of an element. If such function is - * provided, the list_hash() function automatically computes the list hash using - * the custom function instead of simply referring to element references. - * - * @param l list to operate - * @param hash_computer_fun pointer to the actual hash computing function - * @return 0 if the attribute was successfully set; -1 otherwise - * - * @see element_hash_computer() - */ -int list_attributes_hash_computer(list_t *restrict l, element_hash_computer hash_computer_fun); + /** + * set the element hash computing function for the list elements. + * + * [ advanced preference ] + * + * An hash can be requested depicting the list status at a given time. An hash + * only depends on the elements and their order. By default, the hash of an + * element is only computed on its reference. With this function, the user can + * set a custom function computing the hash of an element. If such function is + * provided, the list_hash() function automatically computes the list hash using + * the custom function instead of simply referring to element references. + * + * @param l list to operate + * @param hash_computer_fun pointer to the actual hash computing function + * @return 0 if the attribute was successfully set; -1 otherwise + * + * @see element_hash_computer() + */ + int list_attributes_hash_computer(list_t *restrict l, element_hash_computer hash_computer_fun); -/** - * set the element serializer function for the list elements. - * - * [ advanced preference ] - * - * Serialize functions are used for dumping the list to some persistent - * storage. The serializer function is called for each element; it is passed - * a reference to the element and a reference to a size_t object. It will - * provide (and return) the buffer with the serialization of the element and - * fill the size_t object with the length of this serialization data. - * - * @param l list to operate - * @param serializer_fun pointer to the actual serializer function - * @return 0 if the attribute was successfully set; -1 otherwise - * - * @see element_serializer() - * @see list_dump_filedescriptor() - * @see list_restore_filedescriptor() - */ -int list_attributes_serializer(list_t *restrict l, element_serializer serializer_fun); + /** + * set the element serializer function for the list elements. + * + * [ advanced preference ] + * + * Serialize functions are used for dumping the list to some persistent + * storage. The serializer function is called for each element; it is passed + * a reference to the element and a reference to a size_t object. It will + * provide (and return) the buffer with the serialization of the element and + * fill the size_t object with the length of this serialization data. + * + * @param l list to operate + * @param serializer_fun pointer to the actual serializer function + * @return 0 if the attribute was successfully set; -1 otherwise + * + * @see element_serializer() + * @see list_dump_filedescriptor() + * @see list_restore_filedescriptor() + */ + int list_attributes_serializer(list_t *restrict l, element_serializer serializer_fun); -/** - * set the element unserializer function for the list elements. - * - * [ advanced preference ] - * - * Unserialize functions are used for restoring the list from some persistent - * storage. The unserializer function is called for each element segment read - * from the storage; it is passed the segment and a reference to an integer. - * It shall allocate and return a buffer compiled with the resumed memory - * representation of the element, and set the integer value to the length of - * this buffer. - * - * @param l list to operate - * @param unserializer_fun pointer to the actual unserializer function - * @return 0 if the attribute was successfully set; -1 otherwise - * - * @see element_unserializer() - * @see list_dump_filedescriptor() - * @see list_restore_filedescriptor() - */ -int list_attributes_unserializer(list_t *restrict l, element_unserializer unserializer_fun); + /** + * set the element unserializer function for the list elements. + * + * [ advanced preference ] + * + * Unserialize functions are used for restoring the list from some persistent + * storage. The unserializer function is called for each element segment read + * from the storage; it is passed the segment and a reference to an integer. + * It shall allocate and return a buffer compiled with the resumed memory + * representation of the element, and set the integer value to the length of + * this buffer. + * + * @param l list to operate + * @param unserializer_fun pointer to the actual unserializer function + * @return 0 if the attribute was successfully set; -1 otherwise + * + * @see element_unserializer() + * @see list_dump_filedescriptor() + * @see list_restore_filedescriptor() + */ + int list_attributes_unserializer(list_t *restrict l, element_unserializer unserializer_fun); -/** - * append data at the end of the list. - * - * This function is useful for adding elements with a FIFO/queue policy. - * - * @param l list to operate - * @param data pointer to user data to append - * - * @return 1 for success. < 0 for failure - */ -int list_append(list_t *restrict l, const void *data); + /** + * append data at the end of the list. + * + * This function is useful for adding elements with a FIFO/queue policy. + * + * @param l list to operate + * @param data pointer to user data to append + * + * @return 1 for success. < 0 for failure + */ + int list_append(list_t *restrict l, const void *data); -/** - * insert data in the head of the list. - * - * This function is useful for adding elements with a LIFO/Stack policy. - * - * @param l list to operate - * @param data pointer to user data to append - * - * @return 1 for success. < 0 for failure - */ -int list_prepend(list_t *restrict l, const void *restrict data); + /** + * insert data in the head of the list. + * + * This function is useful for adding elements with a LIFO/Stack policy. + * + * @param l list to operate + * @param data pointer to user data to append + * + * @return 1 for success. < 0 for failure + */ + int list_prepend(list_t *restrict l, const void *restrict data); -/** - * extract the element in the top of the list. - * - * This function is for using a list with a FIFO/queue policy. - * - * @param l list to operate - * @return reference to user datum, or NULL on errors - */ -void *list_fetch(list_t *restrict l); + /** + * extract the element in the top of the list. + * + * This function is for using a list with a FIFO/queue policy. + * + * @param l list to operate + * @return reference to user datum, or NULL on errors + */ + void *list_fetch(list_t *restrict l); -/** - * retrieve an element at a given position. - * - * @param l list to operate - * @param pos [0,size-1] position index of the element wanted - * @return reference to user datum, or NULL on errors - */ -void *list_get_at(const list_t *restrict l, unsigned int pos); + /** + * retrieve an element at a given position. + * + * @param l list to operate + * @param pos [0,size-1] position index of the element wanted + * @return reference to user datum, or NULL on errors + */ + void *list_get_at(const list_t *restrict l, unsigned int pos); -/** - * return the maximum element of the list. - * - * @warning Requires a comparator function to be set for the list. - * - * Returns the maximum element with respect to the comparator function output. - * - * @see list_attributes_comparator() - * - * @param l list to operate - * @return the reference to the element, or NULL - */ -void *list_get_max(const list_t *restrict l); + /** + * return the maximum element of the list. + * + * @warning Requires a comparator function to be set for the list. + * + * Returns the maximum element with respect to the comparator function output. + * + * @see list_attributes_comparator() + * + * @param l list to operate + * @return the reference to the element, or NULL + */ + void *list_get_max(const list_t *restrict l); -/** - * return the minimum element of the list. - * - * @warning Requires a comparator function to be set for the list. - * - * Returns the minimum element with respect to the comparator function output. - * - * @see list_attributes_comparator() - * - * @param l list to operate - * @return the reference to the element, or NULL - */ -void *list_get_min(const list_t *restrict l); + /** + * return the minimum element of the list. + * + * @warning Requires a comparator function to be set for the list. + * + * Returns the minimum element with respect to the comparator function output. + * + * @see list_attributes_comparator() + * + * @param l list to operate + * @return the reference to the element, or NULL + */ + void *list_get_min(const list_t *restrict l); -/** - * retrieve and remove from list an element at a given position. - * - * @param l list to operate - * @param pos [0,size-1] position index of the element wanted - * @return reference to user datum, or NULL on errors - */ -void *list_extract_at(list_t *restrict l, unsigned int pos); + /** + * retrieve and remove from list an element at a given position. + * + * @param l list to operate + * @param pos [0,size-1] position index of the element wanted + * @return reference to user datum, or NULL on errors + */ + void *list_extract_at(list_t *restrict l, unsigned int pos); -/** - * insert an element at a given position. - * - * @param l list to operate - * @param data reference to data to be inserted - * @param pos [0,size-1] position index to insert the element at - * @return positive value on success. Negative on failure - */ -int list_insert_at(list_t *restrict l, const void *data, unsigned int pos); + /** + * insert an element at a given position. + * + * @param l list to operate + * @param data reference to data to be inserted + * @param pos [0,size-1] position index to insert the element at + * @return positive value on success. Negative on failure + */ + int list_insert_at(list_t *restrict l, const void *data, unsigned int pos); -/** - * expunge the first found given element from the list. - * - * Inspects the given list looking for the given element; if the element - * is found, it is removed. Only the first occurence is removed. - * If a comparator function was not set, elements are compared by reference. - * Otherwise, the comparator is used to match the element. - * - * @param l list to operate - * @param data reference of the element to search for - * @return 0 on success. Negative value on failure - * - * @see list_attributes_comparator() - * @see list_delete_at() - */ -int list_delete(list_t *restrict l, const void *data); + /** + * expunge the first found given element from the list. + * + * Inspects the given list looking for the given element; if the element + * is found, it is removed. Only the first occurence is removed. + * If a comparator function was not set, elements are compared by reference. + * Otherwise, the comparator is used to match the element. + * + * @param l list to operate + * @param data reference of the element to search for + * @return 0 on success. Negative value on failure + * + * @see list_attributes_comparator() + * @see list_delete_at() + */ + int list_delete(list_t *restrict l, const void *data); -/** - * expunge an element at a given position from the list. - * - * @param l list to operate - * @param pos [0,size-1] position index of the element to be deleted - * @return 0 on success. Negative value on failure - */ -int list_delete_at(list_t *restrict l, unsigned int pos); + /** + * expunge an element at a given position from the list. + * + * @param l list to operate + * @param pos [0,size-1] position index of the element to be deleted + * @return 0 on success. Negative value on failure + */ + int list_delete_at(list_t *restrict l, unsigned int pos); -/** - * expunge an array of elements from the list, given their position range. - * - * @param l list to operate - * @param posstart [0,size-1] position index of the first element to be deleted - * @param posend [posstart,size-1] position of the last element to be deleted - * @return the number of elements successfully removed on success, <0 on error - */ -int list_delete_range(list_t *restrict l, unsigned int posstart, unsigned int posend); + /** + * expunge an array of elements from the list, given their position range. + * + * @param l list to operate + * @param posstart [0,size-1] position index of the first element to be deleted + * @param posend [posstart,size-1] position of the last element to be deleted + * @return the number of elements successfully removed on success, <0 on error + */ + int list_delete_range(list_t *restrict l, unsigned int posstart, unsigned int posend); -/** - * clear all the elements off of the list. - * - * The element datums will not be freed. - * - * @see list_delete_range() - * @see list_size() - * - * @param l list to operate - * @return the number of elements removed on success, <0 on error - */ -int list_clear(list_t *restrict l); + /** + * clear all the elements off of the list. + * + * The element datums will not be freed. + * + * @see list_delete_range() + * @see list_size() + * + * @param l list to operate + * @return the number of elements removed on success, <0 on error + */ + int list_clear(list_t *restrict l); -/** - * inspect the number of elements in the list. - * - * @param l list to operate - * @return number of elements currently held by the list - */ -unsigned int list_size(const list_t *restrict l); + /** + * inspect the number of elements in the list. + * + * @param l list to operate + * @return number of elements currently held by the list + */ + unsigned int list_size(const list_t *restrict l); -/** - * inspect whether the list is empty. - * - * @param l list to operate - * @return 0 iff the list is not empty - * - * @see list_size() - */ -int list_empty(const list_t *restrict l); + /** + * inspect whether the list is empty. + * + * @param l list to operate + * @return 0 iff the list is not empty + * + * @see list_size() + */ + int list_empty(const list_t *restrict l); -/** - * find the position of an element in a list. - * - * @warning Requires a comparator function to be set for the list. - * - * Inspects the given list looking for the given element; if the element - * is found, its position into the list is returned. - * Elements are inspected comparing references if a comparator has not been - * set. Otherwise, the comparator is used to find the element. - * - * @param l list to operate - * @param data reference of the element to search for - * @return position of element in the list, or <0 if not found - * - * @see list_attributes_comparator() - * @see list_get_at() - */ -int list_locate(const list_t *restrict l, const void *data); + /** + * find the position of an element in a list. + * + * @warning Requires a comparator function to be set for the list. + * + * Inspects the given list looking for the given element; if the element + * is found, its position into the list is returned. + * Elements are inspected comparing references if a comparator has not been + * set. Otherwise, the comparator is used to find the element. + * + * @param l list to operate + * @param data reference of the element to search for + * @return position of element in the list, or <0 if not found + * + * @see list_attributes_comparator() + * @see list_get_at() + */ + int list_locate(const list_t *restrict l, const void *data); -/** - * returns an element given an indicator. - * - * @warning Requires a seeker function to be set for the list. - * - * Inspect the given list looking with the seeker if an element matches - * an indicator. If such element is found, the reference to the element - * is returned. - * - * @param l list to operate - * @param indicator indicator data to pass to the seeker along with elements - * @return reference to the element accepted by the seeker, or NULL if none found - */ -void *list_seek(list_t *restrict l, const void *indicator); + /** + * returns an element given an indicator. + * + * @warning Requires a seeker function to be set for the list. + * + * Inspect the given list looking with the seeker if an element matches + * an indicator. If such element is found, the reference to the element + * is returned. + * + * @param l list to operate + * @param indicator indicator data to pass to the seeker along with elements + * @return reference to the element accepted by the seeker, or NULL if none found + */ + void *list_seek(list_t *restrict l, const void *indicator); -/** - * inspect whether some data is member of the list. - * - * @warning Requires a comparator function to be set for the list. - * - * By default, a per-reference comparison is accomplished. That is, - * the data is in list if any element of the list points to the same - * location of data. - * A "semantic" comparison is accomplished, otherwise, if a comparator - * function has been set previously, with list_attributes_comparator(); - * in which case, the given data reference is believed to be in list iff - * comparator_fun(elementdata, userdata) == 0 for any element in the list. - * - * @param l list to operate - * @param data reference to the data to search - * @return 0 iff the list does not contain data as an element - * - * @see list_attributes_comparator() - */ -int list_contains(const list_t *restrict l, const void *data); + /** + * inspect whether some data is member of the list. + * + * @warning Requires a comparator function to be set for the list. + * + * By default, a per-reference comparison is accomplished. That is, + * the data is in list if any element of the list points to the same + * location of data. + * A "semantic" comparison is accomplished, otherwise, if a comparator + * function has been set previously, with list_attributes_comparator(); + * in which case, the given data reference is believed to be in list iff + * comparator_fun(elementdata, userdata) == 0 for any element in the list. + * + * @param l list to operate + * @param data reference to the data to search + * @return 0 iff the list does not contain data as an element + * + * @see list_attributes_comparator() + */ + int list_contains(const list_t *restrict l, const void *data); -/** - * concatenate two lists - * - * Concatenates one list with another, and stores the result into a - * user-provided list object, which must be different from both the - * lists to concatenate. Attributes from the original lists are not - * cloned. - * The destination list referred is threated as virgin room: if it - * is an existing list containing elements, memory leaks will happen. - * It is OK to specify the same list twice as source, for "doubling" - * it in the destination. - * - * @param l1 base list - * @param l2 list to append to the base - * @param dest reference to the destination list - * @return 0 for success, -1 for errors - */ -int list_concat(const list_t *l1, const list_t *l2, list_t *restrict dest); + /** + * concatenate two lists + * + * Concatenates one list with another, and stores the result into a + * user-provided list object, which must be different from both the + * lists to concatenate. Attributes from the original lists are not + * cloned. + * The destination list referred is threated as virgin room: if it + * is an existing list containing elements, memory leaks will happen. + * It is OK to specify the same list twice as source, for "doubling" + * it in the destination. + * + * @param l1 base list + * @param l2 list to append to the base + * @param dest reference to the destination list + * @return 0 for success, -1 for errors + */ + int list_concat(const list_t *l1, const list_t *l2, list_t *restrict dest); -/** - * sort list elements. - * - * @warning Requires a comparator function to be set for the list. - * - * Sorts the list in ascending or descending order as specified by the versus - * flag. The algorithm chooses autonomously what algorithm is best suited for - * sorting the list wrt its current status. - * - * @param l list to operate - * @param versus positive: order small to big; negative: order big to small - * @return 0 iff sorting was successful - * - * @see list_attributes_comparator() - */ -int list_sort(list_t *restrict l, int versus); + /** + * sort list elements. + * + * @warning Requires a comparator function to be set for the list. + * + * Sorts the list in ascending or descending order as specified by the versus + * flag. The algorithm chooses autonomously what algorithm is best suited for + * sorting the list wrt its current status. + * + * @param l list to operate + * @param versus positive: order small to big; negative: order big to small + * @return 0 iff sorting was successful + * + * @see list_attributes_comparator() + */ + int list_sort(list_t *restrict l, int versus); -/** - * start an iteration session. - * - * This function prepares the list to be iterated. - * - * @param l list to operate - * @return 0 if the list cannot be currently iterated. >0 otherwise - * - * @see list_iterator_stop() - */ -int list_iterator_start(list_t *restrict l); + /** + * start an iteration session. + * + * This function prepares the list to be iterated. + * + * @param l list to operate + * @return 0 if the list cannot be currently iterated. >0 otherwise + * + * @see list_iterator_stop() + */ + int list_iterator_start(list_t *restrict l); -/** - * return the next element in the iteration session. - * - * @param l list to operate - * @return element datum, or NULL on errors - */ -void *list_iterator_next(list_t *restrict l); + /** + * return the next element in the iteration session. + * + * @param l list to operate + * @return element datum, or NULL on errors + */ + void *list_iterator_next(list_t *restrict l); -/** - * inspect whether more elements are available in the iteration session. - * - * @param l list to operate - * @return 0 iff no more elements are available. - */ -int list_iterator_hasnext(const list_t *restrict l); + /** + * inspect whether more elements are available in the iteration session. + * + * @param l list to operate + * @return 0 iff no more elements are available. + */ + int list_iterator_hasnext(const list_t *restrict l); -/** - * end an iteration session. - * - * @param l list to operate - * @return 0 iff the iteration session cannot be stopped - */ -int list_iterator_stop(list_t *restrict l); + /** + * end an iteration session. + * + * @param l list to operate + * @return 0 iff the iteration session cannot be stopped + */ + int list_iterator_stop(list_t *restrict l); -/** - * return the hash of the current status of the list. - * - * @param l list to operate - * @param hash where the resulting hash is put - * - * @return 0 for success; <0 for failure - */ -int list_hash(const list_t *restrict l, list_hash_t *restrict hash); + /** + * return the hash of the current status of the list. + * + * @param l list to operate + * @param hash where the resulting hash is put + * + * @return 0 for success; <0 for failure + */ + int list_hash(const list_t *restrict l, list_hash_t *restrict hash); #ifndef SIMCLIST_NO_DUMPRESTORE -/** - * get meta informations on a list dump on filedescriptor. - * - * [ advanced function ] - * - * Extracts the meta information from a SimCList dump located in a file - * descriptor. The file descriptor must be open and positioned at the - * beginning of the SimCList dump block. - * - * @param fd file descriptor to get metadata from - * @param info reference to a dump metainformation structure to fill - * @return 0 for success; <0 for failure - * - * @see list_dump_filedescriptor() - */ -int list_dump_getinfo_filedescriptor(int fd, list_dump_info_t *restrict info); + /** + * get meta informations on a list dump on filedescriptor. + * + * [ advanced function ] + * + * Extracts the meta information from a SimCList dump located in a file + * descriptor. The file descriptor must be open and positioned at the + * beginning of the SimCList dump block. + * + * @param fd file descriptor to get metadata from + * @param info reference to a dump metainformation structure to fill + * @return 0 for success; <0 for failure + * + * @see list_dump_filedescriptor() + */ + int list_dump_getinfo_filedescriptor(int fd, list_dump_info_t *restrict info); -/** - * get meta informations on a list dump on file. - * - * [ advanced function ] - * - * Extracts the meta information from a SimCList dump located in a file. - * - * @param filename filename of the file to fetch from - * @param info reference to a dump metainformation structure to fill - * @return 0 for success; <0 for failure - * - * @see list_dump_filedescriptor() - */ -int list_dump_getinfo_file(const char *restrict filename, list_dump_info_t *restrict info); + /** + * get meta informations on a list dump on file. + * + * [ advanced function ] + * + * Extracts the meta information from a SimCList dump located in a file. + * + * @param filename filename of the file to fetch from + * @param info reference to a dump metainformation structure to fill + * @return 0 for success; <0 for failure + * + * @see list_dump_filedescriptor() + */ + int list_dump_getinfo_file(const char *restrict filename, list_dump_info_t *restrict info); -/** - * dump the list into an open, writable file descriptor. - * - * This function "dumps" the list to a persistent storage so it can be - * preserved across process terminations. - * When called, the file descriptor must be open for writing and positioned - * where the serialized data must begin. It writes its serialization of the - * list in a form which is portable across different architectures. Dump can - * be safely performed on stream-only (non seekable) descriptors. The file - * descriptor is not closed at the end of the operations. - * - * To use dump functions, either of these conditions must be satisfied: - * -# a metric function has been specified with list_attributes_copy() - * -# a serializer function has been specified with list_attributes_serializer() - * - * If a metric function has been specified, each element of the list is dumped - * as-is from memory, copying it from its pointer for its length down to the - * file descriptor. This might have impacts on portability of the dump to - * different architectures. - * - * If a serializer function has been specified, its result for each element is - * dumped to the file descriptor. - * - * - * @param l list to operate - * @param fd file descriptor to write to - * @param len location to store the resulting length of the dump (bytes), or NULL - * - * @return 0 if successful; -1 otherwise - * - * @see element_serializer() - * @see list_attributes_copy() - * @see list_attributes_serializer() - */ -int list_dump_filedescriptor(const list_t *restrict l, int fd, size_t *restrict len); + /** + * dump the list into an open, writable file descriptor. + * + * This function "dumps" the list to a persistent storage so it can be + * preserved across process terminations. + * When called, the file descriptor must be open for writing and positioned + * where the serialized data must begin. It writes its serialization of the + * list in a form which is portable across different architectures. Dump can + * be safely performed on stream-only (non seekable) descriptors. The file + * descriptor is not closed at the end of the operations. + * + * To use dump functions, either of these conditions must be satisfied: + * -# a metric function has been specified with list_attributes_copy() + * -# a serializer function has been specified with list_attributes_serializer() + * + * If a metric function has been specified, each element of the list is dumped + * as-is from memory, copying it from its pointer for its length down to the + * file descriptor. This might have impacts on portability of the dump to + * different architectures. + * + * If a serializer function has been specified, its result for each element is + * dumped to the file descriptor. + * + * + * @param l list to operate + * @param fd file descriptor to write to + * @param len location to store the resulting length of the dump (bytes), or NULL + * + * @return 0 if successful; -1 otherwise + * + * @see element_serializer() + * @see list_attributes_copy() + * @see list_attributes_serializer() + */ + int list_dump_filedescriptor(const list_t *restrict l, int fd, size_t *restrict len); -/** - * dump the list to a file name. - * - * This function creates a filename and dumps the current content of the list - * to it. If the file exists it is overwritten. The number of bytes written to - * the file can be returned in a specified argument. - * - * @param l list to operate - * @param filename filename to write to - * @param len location to store the resulting length of the dump (bytes), or NULL - * - * @return 0 if successful; -1 otherwise - * - * @see list_attributes_copy() - * @see element_serializer() - * @see list_attributes_serializer() - * @see list_dump_filedescriptor() - * @see list_restore_file() - * - * This function stores a representation of the list - */ -int list_dump_file(const list_t *restrict l, const char *restrict filename, size_t *restrict len); + /** + * dump the list to a file name. + * + * This function creates a filename and dumps the current content of the list + * to it. If the file exists it is overwritten. The number of bytes written to + * the file can be returned in a specified argument. + * + * @param l list to operate + * @param filename filename to write to + * @param len location to store the resulting length of the dump (bytes), or NULL + * + * @return 0 if successful; -1 otherwise + * + * @see list_attributes_copy() + * @see element_serializer() + * @see list_attributes_serializer() + * @see list_dump_filedescriptor() + * @see list_restore_file() + * + * This function stores a representation of the list + */ + int list_dump_file(const list_t *restrict l, const char *restrict filename, size_t *restrict len); -/** - * restore the list from an open, readable file descriptor to memory. - * - * This function is the "inverse" of list_dump_filedescriptor(). It restores - * the list content from a (open, read-ready) file descriptor to memory. An - * unserializer might be needed to restore elements from the persistent - * representation back into memory-consistent format. List attributes can not - * be restored and must be set manually. - * - * @see list_dump_filedescriptor() - * @see list_attributes_serializer() - * @see list_attributes_unserializer() - * - * @param l list to restore to - * @param fd file descriptor to read from. - * @param len location to store the length of the dump read (bytes), or NULL - * @return 0 if successful; -1 otherwise - */ -int list_restore_filedescriptor(list_t *restrict l, int fd, size_t *restrict len); + /** + * restore the list from an open, readable file descriptor to memory. + * + * This function is the "inverse" of list_dump_filedescriptor(). It restores + * the list content from a (open, read-ready) file descriptor to memory. An + * unserializer might be needed to restore elements from the persistent + * representation back into memory-consistent format. List attributes can not + * be restored and must be set manually. + * + * @see list_dump_filedescriptor() + * @see list_attributes_serializer() + * @see list_attributes_unserializer() + * + * @param l list to restore to + * @param fd file descriptor to read from. + * @param len location to store the length of the dump read (bytes), or NULL + * @return 0 if successful; -1 otherwise + */ + int list_restore_filedescriptor(list_t *restrict l, int fd, size_t *restrict len); -/** - * restore the list from a file name. - * - * This function restores the content of a list from a file into memory. It is - * the inverse of list_dump_file(). - * - * @see element_unserializer() - * @see list_attributes_unserializer() - * @see list_dump_file() - * @see list_restore_filedescriptor() - * - * @param l list to restore to - * @param filename filename to read data from - * @param len location to store the length of the dump read (bytes), or NULL - * @return 0 if successful; -1 otherwise - */ -int list_restore_file(list_t *restrict l, const char *restrict filename, size_t *len); + /** + * restore the list from a file name. + * + * This function restores the content of a list from a file into memory. It is + * the inverse of list_dump_file(). + * + * @see element_unserializer() + * @see list_attributes_unserializer() + * @see list_dump_file() + * @see list_restore_filedescriptor() + * + * @param l list to restore to + * @param filename filename to read data from + * @param len location to store the length of the dump read (bytes), or NULL + * @return 0 if successful; -1 otherwise + */ + int list_restore_file(list_t *restrict l, const char *restrict filename, size_t *len); #endif -/* ready-made comparators, meters and hash computers */ - /* comparator functions */ -/** - * ready-made comparator for int8_t elements. - * @see list_attributes_comparator() - */ -int list_comparator_int8_t(const void *a, const void *b); + /* ready-made comparators, meters and hash computers */ + /* comparator functions */ + /** + * ready-made comparator for int8_t elements. + * @see list_attributes_comparator() + */ + int list_comparator_int8_t(const void *a, const void *b); -/** - * ready-made comparator for int16_t elements. - * @see list_attributes_comparator() - */ -int list_comparator_int16_t(const void *a, const void *b); + /** + * ready-made comparator for int16_t elements. + * @see list_attributes_comparator() + */ + int list_comparator_int16_t(const void *a, const void *b); -/** - * ready-made comparator for int32_t elements. - * @see list_attributes_comparator() - */ -int list_comparator_int32_t(const void *a, const void *b); + /** + * ready-made comparator for int32_t elements. + * @see list_attributes_comparator() + */ + int list_comparator_int32_t(const void *a, const void *b); -/** - * ready-made comparator for int64_t elements. - * @see list_attributes_comparator() - */ -int list_comparator_int64_t(const void *a, const void *b); + /** + * ready-made comparator for int64_t elements. + * @see list_attributes_comparator() + */ + int list_comparator_int64_t(const void *a, const void *b); -/** - * ready-made comparator for uint8_t elements. - * @see list_attributes_comparator() - */ -int list_comparator_uint8_t(const void *a, const void *b); + /** + * ready-made comparator for uint8_t elements. + * @see list_attributes_comparator() + */ + int list_comparator_uint8_t(const void *a, const void *b); -/** - * ready-made comparator for uint16_t elements. - * @see list_attributes_comparator() - */ -int list_comparator_uint16_t(const void *a, const void *b); + /** + * ready-made comparator for uint16_t elements. + * @see list_attributes_comparator() + */ + int list_comparator_uint16_t(const void *a, const void *b); -/** - * ready-made comparator for uint32_t elements. - * @see list_attributes_comparator() - */ -int list_comparator_uint32_t(const void *a, const void *b); + /** + * ready-made comparator for uint32_t elements. + * @see list_attributes_comparator() + */ + int list_comparator_uint32_t(const void *a, const void *b); -/** - * ready-made comparator for uint64_t elements. - * @see list_attributes_comparator() - */ -int list_comparator_uint64_t(const void *a, const void *b); + /** + * ready-made comparator for uint64_t elements. + * @see list_attributes_comparator() + */ + int list_comparator_uint64_t(const void *a, const void *b); -/** - * ready-made comparator for float elements. - * @see list_attributes_comparator() - */ -int list_comparator_float(const void *a, const void *b); + /** + * ready-made comparator for float elements. + * @see list_attributes_comparator() + */ + int list_comparator_float(const void *a, const void *b); -/** - * ready-made comparator for double elements. - * @see list_attributes_comparator() - */ -int list_comparator_double(const void *a, const void *b); + /** + * ready-made comparator for double elements. + * @see list_attributes_comparator() + */ + int list_comparator_double(const void *a, const void *b); -/** - * ready-made comparator for string elements. - * @see list_attributes_comparator() - */ -int list_comparator_string(const void *a, const void *b); + /** + * ready-made comparator for string elements. + * @see list_attributes_comparator() + */ + int list_comparator_string(const void *a, const void *b); - /* metric functions */ -/** - * ready-made metric function for int8_t elements. - * @see list_attributes_copy() - */ -size_t list_meter_int8_t(const void *el); + /* metric functions */ + /** + * ready-made metric function for int8_t elements. + * @see list_attributes_copy() + */ + size_t list_meter_int8_t(const void *el); -/** - * ready-made metric function for int16_t elements. - * @see list_attributes_copy() - */ -size_t list_meter_int16_t(const void *el); + /** + * ready-made metric function for int16_t elements. + * @see list_attributes_copy() + */ + size_t list_meter_int16_t(const void *el); -/** - * ready-made metric function for int32_t elements. - * @see list_attributes_copy() - */ -size_t list_meter_int32_t(const void *el); + /** + * ready-made metric function for int32_t elements. + * @see list_attributes_copy() + */ + size_t list_meter_int32_t(const void *el); -/** - * ready-made metric function for int64_t elements. - * @see list_attributes_copy() - */ -size_t list_meter_int64_t(const void *el); + /** + * ready-made metric function for int64_t elements. + * @see list_attributes_copy() + */ + size_t list_meter_int64_t(const void *el); -/** - * ready-made metric function for uint8_t elements. - * @see list_attributes_copy() - */ -size_t list_meter_uint8_t(const void *el); + /** + * ready-made metric function for uint8_t elements. + * @see list_attributes_copy() + */ + size_t list_meter_uint8_t(const void *el); -/** - * ready-made metric function for uint16_t elements. - * @see list_attributes_copy() - */ -size_t list_meter_uint16_t(const void *el); + /** + * ready-made metric function for uint16_t elements. + * @see list_attributes_copy() + */ + size_t list_meter_uint16_t(const void *el); -/** - * ready-made metric function for uint32_t elements. - * @see list_attributes_copy() - */ -size_t list_meter_uint32_t(const void *el); + /** + * ready-made metric function for uint32_t elements. + * @see list_attributes_copy() + */ + size_t list_meter_uint32_t(const void *el); -/** - * ready-made metric function for uint64_t elements. - * @see list_attributes_copy() - */ -size_t list_meter_uint64_t(const void *el); + /** + * ready-made metric function for uint64_t elements. + * @see list_attributes_copy() + */ + size_t list_meter_uint64_t(const void *el); -/** - * ready-made metric function for float elements. - * @see list_attributes_copy() - */ -size_t list_meter_float(const void *el); + /** + * ready-made metric function for float elements. + * @see list_attributes_copy() + */ + size_t list_meter_float(const void *el); -/** - * ready-made metric function for double elements. - * @see list_attributes_copy() - */ -size_t list_meter_double(const void *el); + /** + * ready-made metric function for double elements. + * @see list_attributes_copy() + */ + size_t list_meter_double(const void *el); -/** - * ready-made metric function for string elements. - * @see list_attributes_copy() - */ -size_t list_meter_string(const void *el); + /** + * ready-made metric function for string elements. + * @see list_attributes_copy() + */ + size_t list_meter_string(const void *el); - /* hash functions */ -/** - * ready-made hash function for int8_t elements. - * @see list_attributes_hash_computer() - */ -list_hash_t list_hashcomputer_int8_t(const void *el); + /* hash functions */ + /** + * ready-made hash function for int8_t elements. + * @see list_attributes_hash_computer() + */ + list_hash_t list_hashcomputer_int8_t(const void *el); -/** - * ready-made hash function for int16_t elements. - * @see list_attributes_hash_computer() - */ -list_hash_t list_hashcomputer_int16_t(const void *el); + /** + * ready-made hash function for int16_t elements. + * @see list_attributes_hash_computer() + */ + list_hash_t list_hashcomputer_int16_t(const void *el); -/** - * ready-made hash function for int32_t elements. - * @see list_attributes_hash_computer() - */ -list_hash_t list_hashcomputer_int32_t(const void *el); + /** + * ready-made hash function for int32_t elements. + * @see list_attributes_hash_computer() + */ + list_hash_t list_hashcomputer_int32_t(const void *el); -/** - * ready-made hash function for int64_t elements. - * @see list_attributes_hash_computer() - */ -list_hash_t list_hashcomputer_int64_t(const void *el); + /** + * ready-made hash function for int64_t elements. + * @see list_attributes_hash_computer() + */ + list_hash_t list_hashcomputer_int64_t(const void *el); -/** - * ready-made hash function for uint8_t elements. - * @see list_attributes_hash_computer() - */ -list_hash_t list_hashcomputer_uint8_t(const void *el); + /** + * ready-made hash function for uint8_t elements. + * @see list_attributes_hash_computer() + */ + list_hash_t list_hashcomputer_uint8_t(const void *el); -/** - * ready-made hash function for uint16_t elements. - * @see list_attributes_hash_computer() - */ -list_hash_t list_hashcomputer_uint16_t(const void *el); + /** + * ready-made hash function for uint16_t elements. + * @see list_attributes_hash_computer() + */ + list_hash_t list_hashcomputer_uint16_t(const void *el); -/** - * ready-made hash function for uint32_t elements. - * @see list_attributes_hash_computer() - */ -list_hash_t list_hashcomputer_uint32_t(const void *el); + /** + * ready-made hash function for uint32_t elements. + * @see list_attributes_hash_computer() + */ + list_hash_t list_hashcomputer_uint32_t(const void *el); -/** - * ready-made hash function for uint64_t elements. - * @see list_attributes_hash_computer() - */ -list_hash_t list_hashcomputer_uint64_t(const void *el); + /** + * ready-made hash function for uint64_t elements. + * @see list_attributes_hash_computer() + */ + list_hash_t list_hashcomputer_uint64_t(const void *el); -/** - * ready-made hash function for float elements. - * @see list_attributes_hash_computer() - */ -list_hash_t list_hashcomputer_float(const void *el); + /** + * ready-made hash function for float elements. + * @see list_attributes_hash_computer() + */ + list_hash_t list_hashcomputer_float(const void *el); -/** - * ready-made hash function for double elements. - * @see list_attributes_hash_computer() - */ -list_hash_t list_hashcomputer_double(const void *el); + /** + * ready-made hash function for double elements. + * @see list_attributes_hash_computer() + */ + list_hash_t list_hashcomputer_double(const void *el); -/** - * ready-made hash function for string elements. - * @see list_attributes_hash_computer() - */ -list_hash_t list_hashcomputer_string(const void *el); + /** + * ready-made hash function for string elements. + * @see list_attributes_hash_computer() + */ + list_hash_t list_hashcomputer_string(const void *el); #ifdef __cplusplus } @@ -978,3 +978,13 @@ list_hash_t list_hashcomputer_string(const void *el); #endif +/* For Emacs: + * Local Variables: + * mode:c + * indent-tabs-mode:t + * tab-width:4 + * c-basic-offset:4 + * End: + * For VIM: + * vim:set softtabstop=4 shiftwidth=4 tabstop=4 noet: + */ diff --git a/libs/libks/src/include/table.h b/libs/libks/src/include/table.h index 687358683d..181cacb906 100644 --- a/libs/libks/src/include/table.h +++ b/libs/libks/src/include/table.h @@ -28,19 +28,19 @@ extern "C" { #endif /* __cplusplus */ -/* - * To build a "key" in any of the below routines, pass in a pointer to - * the key and its size [i.e. sizeof(int), etc]. With any of the - * "key" or "data" arguments, if their size is < 0, it will do an - * internal strlen of the item and add 1 for the \0. - * - * If you are using firstkey() and nextkey() functions, be careful if, - * after starting your firstkey loop, you use delete or insert, it - * will not crash but may produce interesting results. If you are - * deleting from firstkey to NULL it will work fine. - */ + /* + * To build a "key" in any of the below routines, pass in a pointer to + * the key and its size [i.e. sizeof(int), etc]. With any of the + * "key" or "data" arguments, if their size is < 0, it will do an + * internal strlen of the item and add 1 for the \0. + * + * If you are using firstkey() and nextkey() functions, be careful if, + * after starting your firstkey loop, you use delete or insert, it + * will not crash but may produce interesting results. If you are + * deleting from firstkey to NULL it will work fine. + */ -/* return types for table functions */ + /* return types for table functions */ #define TABLE_ERROR_NONE 1 /* no error from function */ #define TABLE_ERROR_PNT 2 /* bad table pointer */ #define TABLE_ERROR_ARG_NULL 3 /* buffer args were null */ @@ -62,146 +62,146 @@ extern "C" { #define TABLE_ERROR_COMPARE 19 /* problems with internal comparison */ #define TABLE_ERROR_FREE 20 /* memory free error */ -/* - * Table flags set with table_attr. - */ + /* + * Table flags set with table_attr. + */ -/* - * Automatically adjust the number of table buckets on the fly. - * Whenever the number of entries gets above some threshold, the - * number of buckets is realloced to a new size and each entry is - * re-hashed. Although this may take some time when it re-hashes, the - * table will perform better over time. - */ + /* + * Automatically adjust the number of table buckets on the fly. + * Whenever the number of entries gets above some threshold, the + * number of buckets is realloced to a new size and each entry is + * re-hashed. Although this may take some time when it re-hashes, the + * table will perform better over time. + */ #define TABLE_FLAG_AUTO_ADJUST (1<<0) -/* - * If the above auto-adjust flag is set, also adjust the number of - * table buckets down as we delete entries. - */ + /* + * If the above auto-adjust flag is set, also adjust the number of + * table buckets down as we delete entries. + */ #define TABLE_FLAG_ADJUST_DOWN (1<<1) -/* structure to walk through the fields in a linear order */ -typedef struct { - unsigned int tl_magic; /* magic structure to ensure correct init */ - unsigned int tl_bucket_c; /* where in the table buck array we are */ - unsigned int tl_entry_c; /* in the bucket, which entry we are on */ -} table_linear_t; + /* structure to walk through the fields in a linear order */ + typedef struct { + unsigned int tl_magic; /* magic structure to ensure correct init */ + unsigned int tl_bucket_c; /* where in the table buck array we are */ + unsigned int tl_entry_c; /* in the bucket, which entry we are on */ + } table_linear_t; -/* - * int (*table_compare_t) - * - * DESCRIPTION - * - * Comparison function which compares two key/data pairs for table - * order. - * - * RETURNS: - * - * -1, 0, or 1 if key1 is <, ==, or > than key2. - * - * ARGUMENTS: - * - * key1 - Pointer to the first key entry. - * - * key1_size - Pointer to the size of the first key entry. - * - * data1 - Pointer to the first data entry. - * - * data1_size - Pointer to the size of the first data entry. - * - * key2 - Pointer to the second key entry. - * - * key2_size - Pointer to the size of the second key entry. - * - * data2 - Pointer to the second data entry. - * - * data2_size - Pointer to the size of the second data entry. - */ -typedef int (*table_compare_t)(const void *key1, const int key1_size, - const void *data1, const int data1_size, - const void *key2, const int key2_size, - const void *data2, const int data2_size); + /* + * int (*table_compare_t) + * + * DESCRIPTION + * + * Comparison function which compares two key/data pairs for table + * order. + * + * RETURNS: + * + * -1, 0, or 1 if key1 is <, ==, or > than key2. + * + * ARGUMENTS: + * + * key1 - Pointer to the first key entry. + * + * key1_size - Pointer to the size of the first key entry. + * + * data1 - Pointer to the first data entry. + * + * data1_size - Pointer to the size of the first data entry. + * + * key2 - Pointer to the second key entry. + * + * key2_size - Pointer to the size of the second key entry. + * + * data2 - Pointer to the second data entry. + * + * data2_size - Pointer to the size of the second data entry. + */ + typedef int (*table_compare_t)(const void *key1, const int key1_size, + const void *data1, const int data1_size, + const void *key2, const int key2_size, + const void *data2, const int data2_size); -/* - * int (*table_mem_alloc_t) - * - * DESCRIPTION - * - * Function to override the table's allocation function. - * - * RETURNS: - * - * Success - Newly allocated pointer. - * - * Failure - NULL - * - * ARGUMENTS: - * - * pool_p <-> Pointer to our memory pool. If no pool is set then this - * will be NULL. - * - * size -> Number of bytes that needs to be allocated. - */ -typedef void *(*table_mem_alloc_t)(void *pool_p, const unsigned long size); + /* + * int (*table_mem_alloc_t) + * + * DESCRIPTION + * + * Function to override the table's allocation function. + * + * RETURNS: + * + * Success - Newly allocated pointer. + * + * Failure - NULL + * + * ARGUMENTS: + * + * pool_p <-> Pointer to our memory pool. If no pool is set then this + * will be NULL. + * + * size -> Number of bytes that needs to be allocated. + */ + typedef void *(*table_mem_alloc_t)(void *pool_p, const unsigned long size); -/* - * int (*table_mem_resize_t) - * - * DESCRIPTION - * - * Function to override the table's memory resize function. The - * difference between this and realloc is that this provides the - * previous allocation size. You can specify NULL for this function - * in which cause the library will allocate, copy, and free itself. - * - * RETURNS: - * - * Success - Newly allocated pointer. - * - * Failure - NULL - * - * ARGUMENTS: - * - * pool_p <-> Pointer to our memory pool. If no pool is set then this - * will be NULL. - * - * old_addr -> Previously allocated address. - * - * old_size -> Size of the old address. Since the system is - * lightweight, it does not store size information on the pointer. - * - * new_size -> New size of the allocation. - */ -typedef void *(*table_mem_resize_t)(void *pool_p, void *old_addr, - const unsigned long old_size, - const unsigned long new_size); + /* + * int (*table_mem_resize_t) + * + * DESCRIPTION + * + * Function to override the table's memory resize function. The + * difference between this and realloc is that this provides the + * previous allocation size. You can specify NULL for this function + * in which cause the library will allocate, copy, and free itself. + * + * RETURNS: + * + * Success - Newly allocated pointer. + * + * Failure - NULL + * + * ARGUMENTS: + * + * pool_p <-> Pointer to our memory pool. If no pool is set then this + * will be NULL. + * + * old_addr -> Previously allocated address. + * + * old_size -> Size of the old address. Since the system is + * lightweight, it does not store size information on the pointer. + * + * new_size -> New size of the allocation. + */ + typedef void *(*table_mem_resize_t)(void *pool_p, void *old_addr, + const unsigned long old_size, + const unsigned long new_size); -/* - * int (*table_mem_free_t) - * - * DESCRIPTION - * - * Function to override the table's free function. - * - * RETURNS: - * - * Success - 1 - * - * Failure - 0 - * - * ARGUMENTS: - * - * pool_p <-> Pointer to our memory pool. If no pool is set then this - * will be NULL. - * - * addr -> Address that we are freeing. - * - * min_size -> Minimum size of the address being freed or 0 if not - * known. This can also be the exact size if known. - */ -typedef int (*table_mem_free_t)(void *pool_p, void *addr, - const unsigned long min_size); + /* + * int (*table_mem_free_t) + * + * DESCRIPTION + * + * Function to override the table's free function. + * + * RETURNS: + * + * Success - 1 + * + * Failure - 0 + * + * ARGUMENTS: + * + * pool_p <-> Pointer to our memory pool. If no pool is set then this + * will be NULL. + * + * addr -> Address that we are freeing. + * + * min_size -> Minimum size of the address being freed or 0 if not + * known. This can also be the exact size if known. + */ + typedef int (*table_mem_free_t)(void *pool_p, void *addr, + const unsigned long min_size); #ifdef TABLE_MAIN @@ -209,1164 +209,1175 @@ typedef int (*table_mem_free_t)(void *pool_p, void *addr, #else -/* generic table type */ -typedef void table_t; + /* generic table type */ + typedef void table_t; -/* generic table entry type */ -typedef void table_entry_t; + /* generic table entry type */ + typedef void table_entry_t; #endif -/*<<<<<<<<<< The below prototypes are auto-generated by fillproto */ + /*<<<<<<<<<< The below prototypes are auto-generated by fillproto */ -/* - * table_t *table_alloc - * - * DESCRIPTION: - * - * Allocate a new table structure. - * - * RETURNS: - * - * A pointer to the new table structure which must be passed to - * table_free to be deallocated. On error a NULL is returned. - * - * ARGUMENTS: - * - * bucket_n - Number of buckets for the hash table. Our current hash - * value works best with base two numbers. Set to 0 to take the - * library default of 1024. - * - * error_p - Pointer to an integer which, if not NULL, will contain a - * table error code. - */ -extern -table_t *table_alloc(const unsigned int bucket_n, int *error_p); + /* + * table_t *table_alloc + * + * DESCRIPTION: + * + * Allocate a new table structure. + * + * RETURNS: + * + * A pointer to the new table structure which must be passed to + * table_free to be deallocated. On error a NULL is returned. + * + * ARGUMENTS: + * + * bucket_n - Number of buckets for the hash table. Our current hash + * value works best with base two numbers. Set to 0 to take the + * library default of 1024. + * + * error_p - Pointer to an integer which, if not NULL, will contain a + * table error code. + */ + extern + table_t *table_alloc(const unsigned int bucket_n, int *error_p); -/* - * table_t *table_alloc_in_pool - * - * DESCRIPTION: - * - * Allocate a new table structure in a memory pool or using - * alternative allocation and free functions. - * - * RETURNS: - * - * A pointer to the new table structure which must be passed to - * table_free to be deallocated. On error a NULL is returned. - * - * ARGUMENTS: - * - * bucket_n - Number of buckets for the hash table. Our current hash - * value works best with base two numbers. Set to 0 to take the - * library default of 1024. - * - * mem_pool <-> Memory pool to associate with the table. Can be NULL. - * - * alloc_func -> Allocate function we are overriding malloc() with. - * - * resize_func -> Resize function we are overriding the standard - * memory resize/realloc with. This can be NULL in which cause the - * library will allocate, copy, and free itself. - * - * free_func -> Free function we are overriding free() with. - * - * error_p - Pointer to an integer which, if not NULL, will contain a - * table error code. - */ -extern -table_t *table_alloc_in_pool(const unsigned int bucket_n, - void *mem_pool, - table_mem_alloc_t alloc_func, - table_mem_resize_t resize_func, - table_mem_free_t free_func, int *error_p); + /* + * table_t *table_alloc_in_pool + * + * DESCRIPTION: + * + * Allocate a new table structure in a memory pool or using + * alternative allocation and free functions. + * + * RETURNS: + * + * A pointer to the new table structure which must be passed to + * table_free to be deallocated. On error a NULL is returned. + * + * ARGUMENTS: + * + * bucket_n - Number of buckets for the hash table. Our current hash + * value works best with base two numbers. Set to 0 to take the + * library default of 1024. + * + * mem_pool <-> Memory pool to associate with the table. Can be NULL. + * + * alloc_func -> Allocate function we are overriding malloc() with. + * + * resize_func -> Resize function we are overriding the standard + * memory resize/realloc with. This can be NULL in which cause the + * library will allocate, copy, and free itself. + * + * free_func -> Free function we are overriding free() with. + * + * error_p - Pointer to an integer which, if not NULL, will contain a + * table error code. + */ + extern + table_t *table_alloc_in_pool(const unsigned int bucket_n, + void *mem_pool, + table_mem_alloc_t alloc_func, + table_mem_resize_t resize_func, + table_mem_free_t free_func, int *error_p); -/* - * int table_attr - * - * DESCRIPTION: - * - * Set the attributes for the table. The available attributes are - * specified at the top of table.h. - * - * RETURNS: - * - * Success - TABLE_ERROR_NONE - * - * Failure - Table error code. - * - * ARGUMENTS: - * - * table_p - Pointer to a table structure which we will be altering. - * - * attr - Attribute(s) that we will be applying to the table. - */ -extern -int table_attr(table_t *table_p, const int attr); + /* + * int table_attr + * + * DESCRIPTION: + * + * Set the attributes for the table. The available attributes are + * specified at the top of table.h. + * + * RETURNS: + * + * Success - TABLE_ERROR_NONE + * + * Failure - Table error code. + * + * ARGUMENTS: + * + * table_p - Pointer to a table structure which we will be altering. + * + * attr - Attribute(s) that we will be applying to the table. + */ + extern + int table_attr(table_t *table_p, const int attr); -/* - * int table_set_data_alignment - * - * DESCRIPTION: - * - * Set the alignment for the data in the table. This is used when you - * want to store binary data types and refer to them directly out of - * the table storage. For instance if you are storing integers as - * data in the table and want to be able to retrieve the location of - * the interger and then increment it as (*loc_p)++. Otherwise you - * would have to memcpy it out to an integer, increment it, and memcpy - * it back. If you are storing character data, no alignment is - * necessary. - * - * For most data elements, sizeof(long) is recommended unless you use - * smaller data types exclusively. - * - * WARNING: If necessary, you must set the data alignment before any - * data gets put into the table. Otherwise a TABLE_ERROR_NOT_EMPTY - * error will be returned. - * - * NOTE: there is no way to set the key data alignment although it - * should automatically be long aligned. - * - * RETURNS: - * - * Success - TABLE_ERROR_NONE - * - * Failure - Table error code. - * - * ARGUMENTS: - * - * table_p - Pointer to a table structure which we will be altering. - * - * alignment - Alignment requested for the data. Must be a power of - * 2. Set to 0 for none. - */ -extern -int table_set_data_alignment(table_t *table_p, const int alignment); + /* + * int table_set_data_alignment + * + * DESCRIPTION: + * + * Set the alignment for the data in the table. This is used when you + * want to store binary data types and refer to them directly out of + * the table storage. For instance if you are storing integers as + * data in the table and want to be able to retrieve the location of + * the interger and then increment it as (*loc_p)++. Otherwise you + * would have to memcpy it out to an integer, increment it, and memcpy + * it back. If you are storing character data, no alignment is + * necessary. + * + * For most data elements, sizeof(long) is recommended unless you use + * smaller data types exclusively. + * + * WARNING: If necessary, you must set the data alignment before any + * data gets put into the table. Otherwise a TABLE_ERROR_NOT_EMPTY + * error will be returned. + * + * NOTE: there is no way to set the key data alignment although it + * should automatically be long aligned. + * + * RETURNS: + * + * Success - TABLE_ERROR_NONE + * + * Failure - Table error code. + * + * ARGUMENTS: + * + * table_p - Pointer to a table structure which we will be altering. + * + * alignment - Alignment requested for the data. Must be a power of + * 2. Set to 0 for none. + */ + extern + int table_set_data_alignment(table_t *table_p, const int alignment); -/* - * int table_clear - * - * DESCRIPTION: - * - * Clear out and free all elements in a table structure. - * - * RETURNS: - * - * Success - TABLE_ERROR_NONE - * - * Failure - Table error code. - * - * ARGUMENTS: - * - * table_p - Table structure pointer that we will be clearing. - */ -extern -int table_clear(table_t *table_p); + /* + * int table_clear + * + * DESCRIPTION: + * + * Clear out and free all elements in a table structure. + * + * RETURNS: + * + * Success - TABLE_ERROR_NONE + * + * Failure - Table error code. + * + * ARGUMENTS: + * + * table_p - Table structure pointer that we will be clearing. + */ + extern + int table_clear(table_t *table_p); -/* - * int table_free - * - * DESCRIPTION: - * - * Deallocates a table structure. - * - * RETURNS: - * - * Success - TABLE_ERROR_NONE - * - * Failure - Table error code. - * - * ARGUMENTS: - * - * table_p - Table structure pointer that we will be freeing. - */ -extern -int table_free(table_t *table_p); + /* + * int table_free + * + * DESCRIPTION: + * + * Deallocates a table structure. + * + * RETURNS: + * + * Success - TABLE_ERROR_NONE + * + * Failure - Table error code. + * + * ARGUMENTS: + * + * table_p - Table structure pointer that we will be freeing. + */ + extern + int table_free(table_t *table_p); -/* - * int table_insert_kd - * - * DESCRIPTION: - * - * Like table_insert except it passes back a pointer to the key and - * the data buffers after they have been inserted into the table - * structure. - * - * This routine adds a key/data pair both of which are made up of a - * buffer of bytes and an associated size. Both the key and the data - * will be copied into buffers allocated inside the table. If the key - * exists already, the associated data will be replaced if the - * overwrite flag is set, otherwise an error is returned. - * - * NOTE: be very careful changing the values since the table library - * provides the pointers to its memory. The key can _never_ be - * changed otherwise you will not find it again. The data can be - * changed but its length can never be altered unless you delete and - * re-insert it into the table. - * - * WARNING: The pointers to the key and data are not in any specific - * alignment. Accessing the key and/or data as an short, integer, or - * long pointer directly can cause problems. - * - * WARNING: Replacing a data cell (not inserting) will cause the table - * linked list to be temporarily invalid. Care must be taken with - * multiple threaded programs which are relying on the first/next - * linked list to be always valid. - * - * RETURNS: - * - * Success - TABLE_ERROR_NONE - * - * Failure - Table error code. - * - * ARGUMENTS: - * - * table_p - Table structure pointer into which we will be inserting a - * new key/data pair. - * - * key_buf - Buffer of bytes of the key that we are inserting. If you - * are storing an (int) as the key (for example) then key_buf should - * be a (int *). - * - * key_size - Size of the key_buf buffer. If set to < 0 then the - * library will do a strlen of key_buf and add 1 for the '\0'. If you - * are storing an (int) as the key (for example) then key_size should - * be sizeof(int). - * - * data_buf - Buffer of bytes of the data that we are inserting. If - * it is NULL then the library will allocate space for the data in the - * table without copying in any information. If data_buf is NULL and - * data_size is 0 then the library will associate a NULL data pointer - * with the key. If you are storing a (long) as the data (for - * example) then data_buf should be a (long *). - * - * data_size - Size of the data_buf buffer. If set to < 0 then the - * library will do a strlen of data_buf and add 1 for the '\0'. If - * you are storing an (long) as the key (for example) then key_size - * should be sizeof(long). - * - * key_buf_p - Pointer which, if not NULL, will be set to the address - * of the key storage that was allocated in the table. If you are - * storing an (int) as the key (for example) then key_buf_p should be - * (int **) i.e. the address of a (int *). - * - * data_buf_p - Pointer which, if not NULL, will be set to the address - * of the data storage that was allocated in the table. If you are - * storing an (long) as the data (for example) then data_buf_p should - * be (long **) i.e. the address of a (long *). - * - * overwrite - Flag which, if set to 1, will allow the overwriting of - * the data in the table with the new data if the key already exists - * in the table. - */ -extern -int table_insert_kd(table_t *table_p, - const void *key_buf, const int key_size, - const void *data_buf, const int data_size, - void **key_buf_p, void **data_buf_p, - const char overwrite_b); + /* + * int table_insert_kd + * + * DESCRIPTION: + * + * Like table_insert except it passes back a pointer to the key and + * the data buffers after they have been inserted into the table + * structure. + * + * This routine adds a key/data pair both of which are made up of a + * buffer of bytes and an associated size. Both the key and the data + * will be copied into buffers allocated inside the table. If the key + * exists already, the associated data will be replaced if the + * overwrite flag is set, otherwise an error is returned. + * + * NOTE: be very careful changing the values since the table library + * provides the pointers to its memory. The key can _never_ be + * changed otherwise you will not find it again. The data can be + * changed but its length can never be altered unless you delete and + * re-insert it into the table. + * + * WARNING: The pointers to the key and data are not in any specific + * alignment. Accessing the key and/or data as an short, integer, or + * long pointer directly can cause problems. + * + * WARNING: Replacing a data cell (not inserting) will cause the table + * linked list to be temporarily invalid. Care must be taken with + * multiple threaded programs which are relying on the first/next + * linked list to be always valid. + * + * RETURNS: + * + * Success - TABLE_ERROR_NONE + * + * Failure - Table error code. + * + * ARGUMENTS: + * + * table_p - Table structure pointer into which we will be inserting a + * new key/data pair. + * + * key_buf - Buffer of bytes of the key that we are inserting. If you + * are storing an (int) as the key (for example) then key_buf should + * be a (int *). + * + * key_size - Size of the key_buf buffer. If set to < 0 then the + * library will do a strlen of key_buf and add 1 for the '\0'. If you + * are storing an (int) as the key (for example) then key_size should + * be sizeof(int). + * + * data_buf - Buffer of bytes of the data that we are inserting. If + * it is NULL then the library will allocate space for the data in the + * table without copying in any information. If data_buf is NULL and + * data_size is 0 then the library will associate a NULL data pointer + * with the key. If you are storing a (long) as the data (for + * example) then data_buf should be a (long *). + * + * data_size - Size of the data_buf buffer. If set to < 0 then the + * library will do a strlen of data_buf and add 1 for the '\0'. If + * you are storing an (long) as the key (for example) then key_size + * should be sizeof(long). + * + * key_buf_p - Pointer which, if not NULL, will be set to the address + * of the key storage that was allocated in the table. If you are + * storing an (int) as the key (for example) then key_buf_p should be + * (int **) i.e. the address of a (int *). + * + * data_buf_p - Pointer which, if not NULL, will be set to the address + * of the data storage that was allocated in the table. If you are + * storing an (long) as the data (for example) then data_buf_p should + * be (long **) i.e. the address of a (long *). + * + * overwrite - Flag which, if set to 1, will allow the overwriting of + * the data in the table with the new data if the key already exists + * in the table. + */ + extern + int table_insert_kd(table_t *table_p, + const void *key_buf, const int key_size, + const void *data_buf, const int data_size, + void **key_buf_p, void **data_buf_p, + const char overwrite_b); -/* - * int table_insert - * - * DESCRIPTION: - * - * Exactly the same as table_insert_kd except it does not pass back a - * pointer to the key after they have been inserted into the table - * structure. This is still here for backwards compatibility. - * - * See table_insert_kd for more information. - * - * RETURNS: - * - * Success - TABLE_ERROR_NONE - * - * Failure - Table error code. - * - * ARGUMENTS: - * - * table_p - Table structure pointer into which we will be inserting a - * new key/data pair. - * - * key_buf - Buffer of bytes of the key that we are inserting. If you - * are storing an (int) as the key (for example) then key_buf should - * be a (int *). - * - * key_size - Size of the key_buf buffer. If set to < 0 then the - * library will do a strlen of key_buf and add 1 for the '\0'. If you - * are storing an (int) as the key (for example) then key_size should - * be sizeof(int). - * - * data_buf - Buffer of bytes of the data that we are inserting. If - * it is NULL then the library will allocate space for the data in the - * table without copying in any information. If data_buf is NULL and - * data_size is 0 then the library will associate a NULL data pointer - * with the key. If you are storing a (long) as the data (for - * example) then data_buf should be a (long *). - * - * data_size - Size of the data_buf buffer. If set to < 0 then the - * library will do a strlen of data_buf and add 1 for the '\0'. If - * you are storing an (long) as the key (for example) then key_size - * should be sizeof(long). - * - * data_buf_p - Pointer which, if not NULL, will be set to the address - * of the data storage that was allocated in the table. If you are - * storing an (long) as the data (for example) then data_buf_p should - * be (long **) i.e. the address of a (long *). - * - * overwrite - Flag which, if set to 1, will allow the overwriting of - * the data in the table with the new data if the key already exists - * in the table. - */ -extern -int table_insert(table_t *table_p, - const void *key_buf, const int key_size, - const void *data_buf, const int data_size, - void **data_buf_p, const char overwrite_b); + /* + * int table_insert + * + * DESCRIPTION: + * + * Exactly the same as table_insert_kd except it does not pass back a + * pointer to the key after they have been inserted into the table + * structure. This is still here for backwards compatibility. + * + * See table_insert_kd for more information. + * + * RETURNS: + * + * Success - TABLE_ERROR_NONE + * + * Failure - Table error code. + * + * ARGUMENTS: + * + * table_p - Table structure pointer into which we will be inserting a + * new key/data pair. + * + * key_buf - Buffer of bytes of the key that we are inserting. If you + * are storing an (int) as the key (for example) then key_buf should + * be a (int *). + * + * key_size - Size of the key_buf buffer. If set to < 0 then the + * library will do a strlen of key_buf and add 1 for the '\0'. If you + * are storing an (int) as the key (for example) then key_size should + * be sizeof(int). + * + * data_buf - Buffer of bytes of the data that we are inserting. If + * it is NULL then the library will allocate space for the data in the + * table without copying in any information. If data_buf is NULL and + * data_size is 0 then the library will associate a NULL data pointer + * with the key. If you are storing a (long) as the data (for + * example) then data_buf should be a (long *). + * + * data_size - Size of the data_buf buffer. If set to < 0 then the + * library will do a strlen of data_buf and add 1 for the '\0'. If + * you are storing an (long) as the key (for example) then key_size + * should be sizeof(long). + * + * data_buf_p - Pointer which, if not NULL, will be set to the address + * of the data storage that was allocated in the table. If you are + * storing an (long) as the data (for example) then data_buf_p should + * be (long **) i.e. the address of a (long *). + * + * overwrite - Flag which, if set to 1, will allow the overwriting of + * the data in the table with the new data if the key already exists + * in the table. + */ + extern + int table_insert(table_t *table_p, + const void *key_buf, const int key_size, + const void *data_buf, const int data_size, + void **data_buf_p, const char overwrite_b); -/* - * int table_retrieve - * - * DESCRIPTION: - * - * This routine looks up a key made up of a buffer of bytes and an - * associated size in the table. If found then it returns the - * associated data information. - * - * RETURNS: - * - * Success - TABLE_ERROR_NONE - * - * Failure - Table error code. - * - * ARGUMENTS: - * - * table_p - Table structure pointer into which we will be searching - * for the key. - * - * key_buf - Buffer of bytes of the key that we are searching for. If - * you are looking for an (int) as the key (for example) then key_buf - * should be a (int *). - * - * key_size - Size of the key_buf buffer. If set to < 0 then the - * library will do a strlen of key_buf and add 1 for the '\0'. If you - * are looking for an (int) as the key (for example) then key_size - * should be sizeof(int). - * - * data_buf_p - Pointer which, if not NULL, will be set to the address - * of the data storage that was allocated in the table and that is - * associated with the key. If a (long) was stored as the data (for - * example) then data_buf_p should be (long **) i.e. the address of a - * (long *). - * - * data_size_p - Pointer to an integer which, if not NULL, will be set - * to the size of the data stored in the table that is associated with - * the key. - */ -extern -int table_retrieve(table_t *table_p, - const void *key_buf, const int key_size, - void **data_buf_p, int *data_size_p); + /* + * int table_retrieve + * + * DESCRIPTION: + * + * This routine looks up a key made up of a buffer of bytes and an + * associated size in the table. If found then it returns the + * associated data information. + * + * RETURNS: + * + * Success - TABLE_ERROR_NONE + * + * Failure - Table error code. + * + * ARGUMENTS: + * + * table_p - Table structure pointer into which we will be searching + * for the key. + * + * key_buf - Buffer of bytes of the key that we are searching for. If + * you are looking for an (int) as the key (for example) then key_buf + * should be a (int *). + * + * key_size - Size of the key_buf buffer. If set to < 0 then the + * library will do a strlen of key_buf and add 1 for the '\0'. If you + * are looking for an (int) as the key (for example) then key_size + * should be sizeof(int). + * + * data_buf_p - Pointer which, if not NULL, will be set to the address + * of the data storage that was allocated in the table and that is + * associated with the key. If a (long) was stored as the data (for + * example) then data_buf_p should be (long **) i.e. the address of a + * (long *). + * + * data_size_p - Pointer to an integer which, if not NULL, will be set + * to the size of the data stored in the table that is associated with + * the key. + */ + extern + int table_retrieve(table_t *table_p, + const void *key_buf, const int key_size, + void **data_buf_p, int *data_size_p); -/* - * int table_delete - * - * DESCRIPTION: - * - * This routine looks up a key made up of a buffer of bytes and an - * associated size in the table. If found then it will be removed - * from the table. The associated data can be passed back to the user - * if requested. - * - * RETURNS: - * - * Success - TABLE_ERROR_NONE - * - * Failure - Table error code. - * - * NOTE: this could be an allocation error if the library is to return - * the data to the user. - * - * ARGUMENTS: - * - * table_p - Table structure pointer from which we will be deleteing - * the key. - * - * key_buf - Buffer of bytes of the key that we are searching for to - * delete. If you are deleting an (int) key (for example) then - * key_buf should be a (int *). - * - * key_size - Size of the key_buf buffer. If set to < 0 then the - * library will do a strlen of key_buf and add 1 for the '\0'. If you - * are deleting an (int) key (for example) then key_size should be - * sizeof(int). - * - * data_buf_p - Pointer which, if not NULL, will be set to the address - * of the data storage that was allocated in the table and that was - * associated with the key. If a (long) was stored as the data (for - * example) then data_buf_p should be (long **) i.e. the address of a - * (long *). If a pointer is passed in, the caller is responsible for - * freeing it after use. If data_buf_p is NULL then the library will - * free up the data allocation itself. - * - * data_size_p - Pointer to an integer which, if not NULL, will be set - * to the size of the data that was stored in the table and that was - * associated with the key. - */ -extern -int table_delete(table_t *table_p, - const void *key_buf, const int key_size, - void **data_buf_p, int *data_size_p); + /* + * int table_delete + * + * DESCRIPTION: + * + * This routine looks up a key made up of a buffer of bytes and an + * associated size in the table. If found then it will be removed + * from the table. The associated data can be passed back to the user + * if requested. + * + * RETURNS: + * + * Success - TABLE_ERROR_NONE + * + * Failure - Table error code. + * + * NOTE: this could be an allocation error if the library is to return + * the data to the user. + * + * ARGUMENTS: + * + * table_p - Table structure pointer from which we will be deleteing + * the key. + * + * key_buf - Buffer of bytes of the key that we are searching for to + * delete. If you are deleting an (int) key (for example) then + * key_buf should be a (int *). + * + * key_size - Size of the key_buf buffer. If set to < 0 then the + * library will do a strlen of key_buf and add 1 for the '\0'. If you + * are deleting an (int) key (for example) then key_size should be + * sizeof(int). + * + * data_buf_p - Pointer which, if not NULL, will be set to the address + * of the data storage that was allocated in the table and that was + * associated with the key. If a (long) was stored as the data (for + * example) then data_buf_p should be (long **) i.e. the address of a + * (long *). If a pointer is passed in, the caller is responsible for + * freeing it after use. If data_buf_p is NULL then the library will + * free up the data allocation itself. + * + * data_size_p - Pointer to an integer which, if not NULL, will be set + * to the size of the data that was stored in the table and that was + * associated with the key. + */ + extern + int table_delete(table_t *table_p, + const void *key_buf, const int key_size, + void **data_buf_p, int *data_size_p); -/* - * int table_delete_first - * - * DESCRIPTION: - * - * This is like the table_delete routines except it deletes the first - * key/data pair in the table instead of an entry corresponding to a - * particular key. The associated key and data information can be - * passed back to the user if requested. This routines is handy to - * clear out a table. - * - * RETURNS: - * - * Success - TABLE_ERROR_NONE - * - * Failure - Table error code. - * - * NOTE: this could be an allocation error if the library is to return - * the data to the user. - * - * ARGUMENTS: - * - * table_p - Table structure pointer from which we will be deleteing - * the first key. - * - * key_buf_p - Pointer which, if not NULL, will be set to the address - * of the storage of the first key that was allocated in the table. - * If an (int) was stored as the first key (for example) then - * key_buf_p should be (int **) i.e. the address of a (int *). If a - * pointer is passed in, the caller is responsible for freeing it - * after use. If key_buf_p is NULL then the library will free up the - * key allocation itself. - * - * key_size_p - Pointer to an integer which, if not NULL, will be set - * to the size of the key that was stored in the table and that was - * associated with the key. - * - * data_buf_p - Pointer which, if not NULL, will be set to the address - * of the data storage that was allocated in the table and that was - * associated with the key. If a (long) was stored as the data (for - * example) then data_buf_p should be (long **) i.e. the address of a - * (long *). If a pointer is passed in, the caller is responsible for - * freeing it after use. If data_buf_p is NULL then the library will - * free up the data allocation itself. - * - * data_size_p - Pointer to an integer which, if not NULL, will be set - * to the size of the data that was stored in the table and that was - * associated with the key. - */ -extern -int table_delete_first(table_t *table_p, - void **key_buf_p, int *key_size_p, - void **data_buf_p, int *data_size_p); + /* + * int table_delete_first + * + * DESCRIPTION: + * + * This is like the table_delete routines except it deletes the first + * key/data pair in the table instead of an entry corresponding to a + * particular key. The associated key and data information can be + * passed back to the user if requested. This routines is handy to + * clear out a table. + * + * RETURNS: + * + * Success - TABLE_ERROR_NONE + * + * Failure - Table error code. + * + * NOTE: this could be an allocation error if the library is to return + * the data to the user. + * + * ARGUMENTS: + * + * table_p - Table structure pointer from which we will be deleteing + * the first key. + * + * key_buf_p - Pointer which, if not NULL, will be set to the address + * of the storage of the first key that was allocated in the table. + * If an (int) was stored as the first key (for example) then + * key_buf_p should be (int **) i.e. the address of a (int *). If a + * pointer is passed in, the caller is responsible for freeing it + * after use. If key_buf_p is NULL then the library will free up the + * key allocation itself. + * + * key_size_p - Pointer to an integer which, if not NULL, will be set + * to the size of the key that was stored in the table and that was + * associated with the key. + * + * data_buf_p - Pointer which, if not NULL, will be set to the address + * of the data storage that was allocated in the table and that was + * associated with the key. If a (long) was stored as the data (for + * example) then data_buf_p should be (long **) i.e. the address of a + * (long *). If a pointer is passed in, the caller is responsible for + * freeing it after use. If data_buf_p is NULL then the library will + * free up the data allocation itself. + * + * data_size_p - Pointer to an integer which, if not NULL, will be set + * to the size of the data that was stored in the table and that was + * associated with the key. + */ + extern + int table_delete_first(table_t *table_p, + void **key_buf_p, int *key_size_p, + void **data_buf_p, int *data_size_p); -/* - * int table_info - * - * DESCRIPTION: - * - * Get some information about a table_p structure. - * - * RETURNS: - * - * Success - TABLE_ERROR_NONE - * - * Failure - Table error code. - * - * ARGUMENTS: - * - * table_p - Table structure pointer from which we are getting - * information. - * - * num_buckets_p - Pointer to an integer which, if not NULL, will - * contain the number of buckets in the table. - * - * num_entries_p - Pointer to an integer which, if not NULL, will - * contain the number of entries stored in the table. - */ -extern -int table_info(table_t *table_p, int *num_buckets_p, int *num_entries_p); + /* + * int table_info + * + * DESCRIPTION: + * + * Get some information about a table_p structure. + * + * RETURNS: + * + * Success - TABLE_ERROR_NONE + * + * Failure - Table error code. + * + * ARGUMENTS: + * + * table_p - Table structure pointer from which we are getting + * information. + * + * num_buckets_p - Pointer to an integer which, if not NULL, will + * contain the number of buckets in the table. + * + * num_entries_p - Pointer to an integer which, if not NULL, will + * contain the number of entries stored in the table. + */ + extern + int table_info(table_t *table_p, int *num_buckets_p, int *num_entries_p); -/* - * int table_adjust - * - * DESCRIPTION: - * - * Set the number of buckets in a table to a certain value. - * - * RETURNS: - * - * Success - TABLE_ERROR_NONE - * - * Failure - Table error code. - * - * ARGUMENTS: - * - * table_p - Table structure pointer of which we are adjusting. - * - * bucket_n - Number buckets to adjust the table to. Set to 0 to - * adjust the table to its number of entries. - */ -extern -int table_adjust(table_t *table_p, const int bucket_n); + /* + * int table_adjust + * + * DESCRIPTION: + * + * Set the number of buckets in a table to a certain value. + * + * RETURNS: + * + * Success - TABLE_ERROR_NONE + * + * Failure - Table error code. + * + * ARGUMENTS: + * + * table_p - Table structure pointer of which we are adjusting. + * + * bucket_n - Number buckets to adjust the table to. Set to 0 to + * adjust the table to its number of entries. + */ + extern + int table_adjust(table_t *table_p, const int bucket_n); -/* - * int table_type_size - * - * DESCRIPTION: - * - * Return the size of the internal table type. - * - * RETURNS: - * - * The size of the table_t type. - * - * ARGUMENTS: - * - * None. - */ -extern -int table_type_size(void); + /* + * int table_type_size + * + * DESCRIPTION: + * + * Return the size of the internal table type. + * + * RETURNS: + * + * The size of the table_t type. + * + * ARGUMENTS: + * + * None. + */ + extern + int table_type_size(void); -/* - * int table_first - * - * DESCRIPTION: - * - * Find first element in a table and pass back information about the - * key/data pair. If any of the key/data pointers are NULL then they - * are ignored. - * - * NOTE: This function is not reentrant. More than one thread cannot - * be doing a first and next on the same table at the same time. Use - * the table_first_r version below for this. - * - * RETURNS: - * - * Success - TABLE_ERROR_NONE - * - * Failure - Table error code. - * - * ARGUMENTS: - * - * table_p - Table structure pointer from which we are getting the - * first element. - * - * key_buf_p - Pointer which, if not NULL, will be set to the address - * of the storage of the first key that is allocated in the table. If - * an (int) is stored as the first key (for example) then key_buf_p - * should be (int **) i.e. the address of a (int *). - * - * key_size_p - Pointer to an integer which, if not NULL, will be set - * to the size of the key that is stored in the table and that is - * associated with the first key. - * - * data_buf_p - Pointer which, if not NULL, will be set to the address - * of the data storage that is allocated in the table and that is - * associated with the first key. If a (long) is stored as the data - * (for example) then data_buf_p should be (long **) i.e. the address - * of a (long *). - * - * data_size_p - Pointer to an integer which, if not NULL, will be set - * to the size of the data that is stored in the table and that is - * associated with the first key. - */ -extern -int table_first(table_t *table_p, - void **key_buf_p, int *key_size_p, - void **data_buf_p, int *data_size_p); + /* + * int table_first + * + * DESCRIPTION: + * + * Find first element in a table and pass back information about the + * key/data pair. If any of the key/data pointers are NULL then they + * are ignored. + * + * NOTE: This function is not reentrant. More than one thread cannot + * be doing a first and next on the same table at the same time. Use + * the table_first_r version below for this. + * + * RETURNS: + * + * Success - TABLE_ERROR_NONE + * + * Failure - Table error code. + * + * ARGUMENTS: + * + * table_p - Table structure pointer from which we are getting the + * first element. + * + * key_buf_p - Pointer which, if not NULL, will be set to the address + * of the storage of the first key that is allocated in the table. If + * an (int) is stored as the first key (for example) then key_buf_p + * should be (int **) i.e. the address of a (int *). + * + * key_size_p - Pointer to an integer which, if not NULL, will be set + * to the size of the key that is stored in the table and that is + * associated with the first key. + * + * data_buf_p - Pointer which, if not NULL, will be set to the address + * of the data storage that is allocated in the table and that is + * associated with the first key. If a (long) is stored as the data + * (for example) then data_buf_p should be (long **) i.e. the address + * of a (long *). + * + * data_size_p - Pointer to an integer which, if not NULL, will be set + * to the size of the data that is stored in the table and that is + * associated with the first key. + */ + extern + int table_first(table_t *table_p, + void **key_buf_p, int *key_size_p, + void **data_buf_p, int *data_size_p); -/* - * int table_next - * - * DESCRIPTION: - * - * Find the next element in a table and pass back information about - * the key/data pair. If any of the key/data pointers are NULL then - * they are ignored. - * - * NOTE: This function is not reentrant. More than one thread cannot - * be doing a first and next on the same table at the same time. Use - * the table_next_r version below for this. - * - * RETURNS: - * - * Success - TABLE_ERROR_NONE - * - * Failure - Table error code. - * - * ARGUMENTS: - * - * table_p - Table structure pointer from which we are getting the - * next element. - * - * key_buf_p - Pointer which, if not NULL, will be set to the address - * of the storage of the next key that is allocated in the table. If - * an (int) is stored as the next key (for example) then key_buf_p - * should be (int **) i.e. the address of a (int *). - * - * key_size_p - Pointer to an integer which, if not NULL, will be set - * to the size of the key that is stored in the table and that is - * associated with the next key. - * - * data_buf_p - Pointer which, if not NULL, will be set to the address - * of the data storage that is allocated in the table and that is - * associated with the next key. If a (long) is stored as the data - * (for example) then data_buf_p should be (long **) i.e. the address - * of a (long *). - * - * data_size_p - Pointer to an integer which, if not NULL, will be set - * to the size of the data that is stored in the table and that is - * associated with the next key. - */ -extern -int table_next(table_t *table_p, - void **key_buf_p, int *key_size_p, - void **data_buf_p, int *data_size_p); + /* + * int table_next + * + * DESCRIPTION: + * + * Find the next element in a table and pass back information about + * the key/data pair. If any of the key/data pointers are NULL then + * they are ignored. + * + * NOTE: This function is not reentrant. More than one thread cannot + * be doing a first and next on the same table at the same time. Use + * the table_next_r version below for this. + * + * RETURNS: + * + * Success - TABLE_ERROR_NONE + * + * Failure - Table error code. + * + * ARGUMENTS: + * + * table_p - Table structure pointer from which we are getting the + * next element. + * + * key_buf_p - Pointer which, if not NULL, will be set to the address + * of the storage of the next key that is allocated in the table. If + * an (int) is stored as the next key (for example) then key_buf_p + * should be (int **) i.e. the address of a (int *). + * + * key_size_p - Pointer to an integer which, if not NULL, will be set + * to the size of the key that is stored in the table and that is + * associated with the next key. + * + * data_buf_p - Pointer which, if not NULL, will be set to the address + * of the data storage that is allocated in the table and that is + * associated with the next key. If a (long) is stored as the data + * (for example) then data_buf_p should be (long **) i.e. the address + * of a (long *). + * + * data_size_p - Pointer to an integer which, if not NULL, will be set + * to the size of the data that is stored in the table and that is + * associated with the next key. + */ + extern + int table_next(table_t *table_p, + void **key_buf_p, int *key_size_p, + void **data_buf_p, int *data_size_p); -/* - * int table_this - * - * DESCRIPTION: - * - * Find the current element in a table and pass back information about - * the key/data pair. If any of the key/data pointers are NULL then - * they are ignored. - * - * NOTE: This function is not reentrant. Use the table_current_r - * version below. - * - * RETURNS: - * - * Success - TABLE_ERROR_NONE - * - * Failure - Table error code. - * - * ARGUMENTS: - * - * table_p - Table structure pointer from which we are getting the - * current element. - * - * key_buf_p - Pointer which, if not NULL, will be set to the address - * of the storage of the current key that is allocated in the table. - * If an (int) is stored as the current key (for example) then - * key_buf_p should be (int **) i.e. the address of a (int *). - * - * key_size_p - Pointer to an integer which, if not NULL, will be set - * to the size of the key that is stored in the table and that is - * associated with the current key. - * - * data_buf_p - Pointer which, if not NULL, will be set to the address - * of the data storage that is allocated in the table and that is - * associated with the current key. If a (long) is stored as the data - * (for example) then data_buf_p should be (long **) i.e. the address - * of a (long *). - * - * data_size_p - Pointer to an integer which, if not NULL, will be set - * to the size of the data that is stored in the table and that is - * associated with the current key. - */ -extern -int table_this(table_t *table_p, - void **key_buf_p, int *key_size_p, - void **data_buf_p, int *data_size_p); + /* + * int table_this + * + * DESCRIPTION: + * + * Find the current element in a table and pass back information about + * the key/data pair. If any of the key/data pointers are NULL then + * they are ignored. + * + * NOTE: This function is not reentrant. Use the table_current_r + * version below. + * + * RETURNS: + * + * Success - TABLE_ERROR_NONE + * + * Failure - Table error code. + * + * ARGUMENTS: + * + * table_p - Table structure pointer from which we are getting the + * current element. + * + * key_buf_p - Pointer which, if not NULL, will be set to the address + * of the storage of the current key that is allocated in the table. + * If an (int) is stored as the current key (for example) then + * key_buf_p should be (int **) i.e. the address of a (int *). + * + * key_size_p - Pointer to an integer which, if not NULL, will be set + * to the size of the key that is stored in the table and that is + * associated with the current key. + * + * data_buf_p - Pointer which, if not NULL, will be set to the address + * of the data storage that is allocated in the table and that is + * associated with the current key. If a (long) is stored as the data + * (for example) then data_buf_p should be (long **) i.e. the address + * of a (long *). + * + * data_size_p - Pointer to an integer which, if not NULL, will be set + * to the size of the data that is stored in the table and that is + * associated with the current key. + */ + extern + int table_this(table_t *table_p, + void **key_buf_p, int *key_size_p, + void **data_buf_p, int *data_size_p); -/* - * int table_first_r - * - * DESCRIPTION: - * - * Reetrant version of the table_first routine above. Find first - * element in a table and pass back information about the key/data - * pair. If any of the key/data pointers are NULL then they are - * ignored. - * - * RETURNS: - * - * Success - TABLE_ERROR_NONE - * - * Failure - Table error code. - * - * ARGUMENTS: - * - * table_p - Table structure pointer from which we are getting the - * first element. - * - * linear_p - Pointer to a table linear structure which is initialized - * here. The same pointer should then be passed to table_next_r - * below. - * - * key_buf_p - Pointer which, if not NULL, will be set to the address - * of the storage of the first key that is allocated in the table. If - * an (int) is stored as the first key (for example) then key_buf_p - * should be (int **) i.e. the address of a (int *). - * - * key_size_p - Pointer to an integer which, if not NULL, will be set - * to the size of the key that is stored in the table and that is - * associated with the first key. - * - * data_buf_p - Pointer which, if not NULL, will be set to the address - * of the data storage that is allocated in the table and that is - * associated with the first key. If a (long) is stored as the data - * (for example) then data_buf_p should be (long **) i.e. the address - * of a (long *). - * - * data_size_p - Pointer to an integer which, if not NULL, will be set - * to the size of the data that is stored in the table and that is - * associated with the first key. - */ -extern -int table_first_r(table_t *table_p, table_linear_t *linear_p, - void **key_buf_p, int *key_size_p, - void **data_buf_p, int *data_size_p); + /* + * int table_first_r + * + * DESCRIPTION: + * + * Reetrant version of the table_first routine above. Find first + * element in a table and pass back information about the key/data + * pair. If any of the key/data pointers are NULL then they are + * ignored. + * + * RETURNS: + * + * Success - TABLE_ERROR_NONE + * + * Failure - Table error code. + * + * ARGUMENTS: + * + * table_p - Table structure pointer from which we are getting the + * first element. + * + * linear_p - Pointer to a table linear structure which is initialized + * here. The same pointer should then be passed to table_next_r + * below. + * + * key_buf_p - Pointer which, if not NULL, will be set to the address + * of the storage of the first key that is allocated in the table. If + * an (int) is stored as the first key (for example) then key_buf_p + * should be (int **) i.e. the address of a (int *). + * + * key_size_p - Pointer to an integer which, if not NULL, will be set + * to the size of the key that is stored in the table and that is + * associated with the first key. + * + * data_buf_p - Pointer which, if not NULL, will be set to the address + * of the data storage that is allocated in the table and that is + * associated with the first key. If a (long) is stored as the data + * (for example) then data_buf_p should be (long **) i.e. the address + * of a (long *). + * + * data_size_p - Pointer to an integer which, if not NULL, will be set + * to the size of the data that is stored in the table and that is + * associated with the first key. + */ + extern + int table_first_r(table_t *table_p, table_linear_t *linear_p, + void **key_buf_p, int *key_size_p, + void **data_buf_p, int *data_size_p); -/* - * int table_next_r - * - * DESCRIPTION: - * - * Reetrant version of the table_next routine above. Find next - * element in a table and pass back information about the key/data - * pair. If any of the key/data pointers are NULL then they are - * ignored. - * - * RETURNS: - * - * Success - TABLE_ERROR_NONE - * - * Failure - Table error code. - * - * ARGUMENTS: - * - * table_p - Table structure pointer from which we are getting the - * next element. - * - * linear_p - Pointer to a table linear structure which is incremented - * here. The same pointer must have been passed to table_first_r - * first so that it can be initialized. - * - * key_buf_p - Pointer which, if not NULL, will be set to the address - * of the storage of the next key that is allocated in the table. If - * an (int) is stored as the next key (for example) then key_buf_p - * should be (int **) i.e. the address of a (int *). - * - * key_size_p - Pointer to an integer which, if not NULL will be set - * to the size of the key that is stored in the table and that is - * associated with the next key. - * - * data_buf_p - Pointer which, if not NULL, will be set to the address - * of the data storage that is allocated in the table and that is - * associated with the next key. If a (long) is stored as the data - * (for example) then data_buf_p should be (long **) i.e. the address - * of a (long *). - * - * data_size_p - Pointer to an integer which, if not NULL, will be set - * to the size of the data that is stored in the table and that is - * associated with the next key. - */ -extern -int table_next_r(table_t *table_p, table_linear_t *linear_p, - void **key_buf_p, int *key_size_p, - void **data_buf_p, int *data_size_p); + /* + * int table_next_r + * + * DESCRIPTION: + * + * Reetrant version of the table_next routine above. Find next + * element in a table and pass back information about the key/data + * pair. If any of the key/data pointers are NULL then they are + * ignored. + * + * RETURNS: + * + * Success - TABLE_ERROR_NONE + * + * Failure - Table error code. + * + * ARGUMENTS: + * + * table_p - Table structure pointer from which we are getting the + * next element. + * + * linear_p - Pointer to a table linear structure which is incremented + * here. The same pointer must have been passed to table_first_r + * first so that it can be initialized. + * + * key_buf_p - Pointer which, if not NULL, will be set to the address + * of the storage of the next key that is allocated in the table. If + * an (int) is stored as the next key (for example) then key_buf_p + * should be (int **) i.e. the address of a (int *). + * + * key_size_p - Pointer to an integer which, if not NULL will be set + * to the size of the key that is stored in the table and that is + * associated with the next key. + * + * data_buf_p - Pointer which, if not NULL, will be set to the address + * of the data storage that is allocated in the table and that is + * associated with the next key. If a (long) is stored as the data + * (for example) then data_buf_p should be (long **) i.e. the address + * of a (long *). + * + * data_size_p - Pointer to an integer which, if not NULL, will be set + * to the size of the data that is stored in the table and that is + * associated with the next key. + */ + extern + int table_next_r(table_t *table_p, table_linear_t *linear_p, + void **key_buf_p, int *key_size_p, + void **data_buf_p, int *data_size_p); -/* - * int table_this_r - * - * DESCRIPTION: - * - * Reetrant version of the table_this routine above. Find current - * element in a table and pass back information about the key/data - * pair. If any of the key/data pointers are NULL then they are - * ignored. - * - * RETURNS: - * - * Success - TABLE_ERROR_NONE - * - * Failure - Table error code. - * - * ARGUMENTS: - * - * table_p - Table structure pointer from which we are getting the - * current element. - * - * linear_p - Pointer to a table linear structure which is accessed - * here. The same pointer must have been passed to table_first_r - * first so that it can be initialized. - * - * key_buf_p - Pointer which, if not NULL, will be set to the address - * of the storage of the current key that is allocated in the table. - * If an (int) is stored as the current key (for example) then - * key_buf_p should be (int **) i.e. the address of a (int *). - * - * key_size_p - Pointer to an integer which, if not NULL, will be set - * to the size of the key that is stored in the table and that is - * associated with the current key. - * - * data_buf_p - Pointer which, if not NULL, will be set to the address - * of the data storage that is allocated in the table and that is - * associated with the current key. If a (long) is stored as the data - * (for example) then data_buf_p should be (long **) i.e. the address - * of a (long *). - * - * data_size_p - Pointer to an integer which, if not NULL, will be set - * to the size of the data that is stored in the table and that is - * associated with the current key. - */ -extern -int table_this_r(table_t *table_p, table_linear_t *linear_p, - void **key_buf_p, int *key_size_p, - void **data_buf_p, int *data_size_p); + /* + * int table_this_r + * + * DESCRIPTION: + * + * Reetrant version of the table_this routine above. Find current + * element in a table and pass back information about the key/data + * pair. If any of the key/data pointers are NULL then they are + * ignored. + * + * RETURNS: + * + * Success - TABLE_ERROR_NONE + * + * Failure - Table error code. + * + * ARGUMENTS: + * + * table_p - Table structure pointer from which we are getting the + * current element. + * + * linear_p - Pointer to a table linear structure which is accessed + * here. The same pointer must have been passed to table_first_r + * first so that it can be initialized. + * + * key_buf_p - Pointer which, if not NULL, will be set to the address + * of the storage of the current key that is allocated in the table. + * If an (int) is stored as the current key (for example) then + * key_buf_p should be (int **) i.e. the address of a (int *). + * + * key_size_p - Pointer to an integer which, if not NULL, will be set + * to the size of the key that is stored in the table and that is + * associated with the current key. + * + * data_buf_p - Pointer which, if not NULL, will be set to the address + * of the data storage that is allocated in the table and that is + * associated with the current key. If a (long) is stored as the data + * (for example) then data_buf_p should be (long **) i.e. the address + * of a (long *). + * + * data_size_p - Pointer to an integer which, if not NULL, will be set + * to the size of the data that is stored in the table and that is + * associated with the current key. + */ + extern + int table_this_r(table_t *table_p, table_linear_t *linear_p, + void **key_buf_p, int *key_size_p, + void **data_buf_p, int *data_size_p); -/* - * table_t *table_mmap - * - * DESCRIPTION: - * - * Mmap a table from a file that had been written to disk earlier via - * table_write. - * - * RETURNS: - * - * A pointer to the new table structure which must be passed to - * table_munmap to be deallocated. On error a NULL is returned. - * - * ARGUMENTS: - * - * path - Table file to mmap in. - * - * error_p - Pointer to an integer which, if not NULL, will contain a - * table error code. - */ -extern -table_t *table_mmap(const char *path, int *error_p); + /* + * table_t *table_mmap + * + * DESCRIPTION: + * + * Mmap a table from a file that had been written to disk earlier via + * table_write. + * + * RETURNS: + * + * A pointer to the new table structure which must be passed to + * table_munmap to be deallocated. On error a NULL is returned. + * + * ARGUMENTS: + * + * path - Table file to mmap in. + * + * error_p - Pointer to an integer which, if not NULL, will contain a + * table error code. + */ + extern + table_t *table_mmap(const char *path, int *error_p); -/* - * int table_munmap - * - * DESCRIPTION: - * - * Unmmap a table that was previously mmapped using table_mmap. - * - * RETURNS: - * - * Returns table error codes. - * - * ARGUMENTS: - * - * table_p - Mmaped table pointer to unmap. - */ -extern -int table_munmap(table_t *table_p); + /* + * int table_munmap + * + * DESCRIPTION: + * + * Unmmap a table that was previously mmapped using table_mmap. + * + * RETURNS: + * + * Returns table error codes. + * + * ARGUMENTS: + * + * table_p - Mmaped table pointer to unmap. + */ + extern + int table_munmap(table_t *table_p); -/* - * int table_read - * - * DESCRIPTION: - * - * Read in a table from a file that had been written to disk earlier - * via table_write. - * - * RETURNS: - * - * Success - Pointer to the new table structure which must be passed - * to table_free to be deallocated. - * - * Failure - NULL - * - * ARGUMENTS: - * - * path - Table file to read in. - * - * error_p - Pointer to an integer which, if not NULL, will contain a - * table error code. - */ -extern -table_t *table_read(const char *path, int *error_p); + /* + * int table_read + * + * DESCRIPTION: + * + * Read in a table from a file that had been written to disk earlier + * via table_write. + * + * RETURNS: + * + * Success - Pointer to the new table structure which must be passed + * to table_free to be deallocated. + * + * Failure - NULL + * + * ARGUMENTS: + * + * path - Table file to read in. + * + * error_p - Pointer to an integer which, if not NULL, will contain a + * table error code. + */ + extern + table_t *table_read(const char *path, int *error_p); -/* - * int table_write - * - * DESCRIPTION: - * - * Write a table from memory to file. - * - * RETURNS: - * - * Success - TABLE_ERROR_NONE - * - * Failure - Table error code. - * - * ARGUMENTS: - * - * table_p - Pointer to the table that we are writing to the file. - * - * path - Table file to write out to. - * - * mode - Mode of the file. This argument is passed on to open when - * the file is created. - */ -extern -int table_write(const table_t *table_p, const char *path, const int mode); + /* + * int table_write + * + * DESCRIPTION: + * + * Write a table from memory to file. + * + * RETURNS: + * + * Success - TABLE_ERROR_NONE + * + * Failure - Table error code. + * + * ARGUMENTS: + * + * table_p - Pointer to the table that we are writing to the file. + * + * path - Table file to write out to. + * + * mode - Mode of the file. This argument is passed on to open when + * the file is created. + */ + extern + int table_write(const table_t *table_p, const char *path, const int mode); -/* - * table_entry_t *table_order - * - * DESCRIPTION: - * - * Order a table by building an array of table entry pointers and then - * sorting this array using the qsort function. To retrieve the - * sorted entries, you can then use the table_entry routine to access - * each entry in order. - * - * NOTE: This routine is thread safe and makes use of an internal - * status qsort function. - * - * RETURNS: - * - * Success - An allocated list of table-linear structures which must - * be freed by table_order_free later. - * - * Failure - NULL - * - * ARGUMENTS: - * - * table_p - Pointer to the table that we are ordering. - * - * compare - Comparison function defined by the user. Its definition - * is at the top of the table.h file. If this is NULL then it will - * order the table my memcmp-ing the keys. - * - * num_entries_p - Pointer to an integer which, if not NULL, will - * contain the number of entries in the returned entry pointer array. - * - * error_p - Pointer to an integer which, if not NULL, will contain a - * table error code. - */ -extern -table_entry_t **table_order(table_t *table_p, table_compare_t compare, - int *num_entries_p, int *error_p); + /* + * table_entry_t *table_order + * + * DESCRIPTION: + * + * Order a table by building an array of table entry pointers and then + * sorting this array using the qsort function. To retrieve the + * sorted entries, you can then use the table_entry routine to access + * each entry in order. + * + * NOTE: This routine is thread safe and makes use of an internal + * status qsort function. + * + * RETURNS: + * + * Success - An allocated list of table-linear structures which must + * be freed by table_order_free later. + * + * Failure - NULL + * + * ARGUMENTS: + * + * table_p - Pointer to the table that we are ordering. + * + * compare - Comparison function defined by the user. Its definition + * is at the top of the table.h file. If this is NULL then it will + * order the table my memcmp-ing the keys. + * + * num_entries_p - Pointer to an integer which, if not NULL, will + * contain the number of entries in the returned entry pointer array. + * + * error_p - Pointer to an integer which, if not NULL, will contain a + * table error code. + */ + extern + table_entry_t **table_order(table_t *table_p, table_compare_t compare, + int *num_entries_p, int *error_p); -/* - * int table_order_free - * - * DESCRIPTION: - * - * Free the pointer returned by the table_order or table_order_pos - * routines. - * - * RETURNS: - * - * Success - TABLE_ERROR_NONE - * - * Failure - Table error code. - * - * ARGUMENTS: - * - * table_p - Pointer to the table. - * - * table_entries - Allocated list of entry pointers returned by - * table_order. - * - * entry_n - Number of entries in the array as passed back by - * table_order or table_order_pos in num_entries_p. - */ -extern -int table_order_free(table_t *table_p, table_entry_t **table_entries, - const int entry_n); + /* + * int table_order_free + * + * DESCRIPTION: + * + * Free the pointer returned by the table_order or table_order_pos + * routines. + * + * RETURNS: + * + * Success - TABLE_ERROR_NONE + * + * Failure - Table error code. + * + * ARGUMENTS: + * + * table_p - Pointer to the table. + * + * table_entries - Allocated list of entry pointers returned by + * table_order. + * + * entry_n - Number of entries in the array as passed back by + * table_order or table_order_pos in num_entries_p. + */ + extern + int table_order_free(table_t *table_p, table_entry_t **table_entries, + const int entry_n); -/* - * int table_entry - * - * DESCRIPTION: - * - * Get information about an element. The element is one from the - * array returned by the table_order function. If any of the key/data - * pointers are NULL then they are ignored. - * - * RETURNS: - * - * Success - TABLE_ERROR_NONE - * - * Failure - Table error code. - * - * ARGUMENTS: - * - * table_p - Table structure pointer from which we are getting the - * element. - * - * entry_p - Pointer to a table entry from the array returned by the - * table_order function. - * - * key_buf_p - Pointer which, if not NULL, will be set to the address - * of the storage of this entry that is allocated in the table. If an - * (int) is stored as this entry (for example) then key_buf_p should - * be (int **) i.e. the address of a (int *). - * - * key_size_p - Pointer to an integer which, if not NULL, will be set - * to the size of the key that is stored in the table. - * - * data_buf_p - Pointer which, if not NULL, will be set to the address - * of the data storage of this entry that is allocated in the table. - * If a (long) is stored as this entry data (for example) then - * data_buf_p should be (long **) i.e. the address of a (long *). - * - * data_size_p - Pointer to an integer which, if not NULL, will be set - * to the size of the data that is stored in the table. - */ -extern -int table_entry(table_t *table_p, table_entry_t *entry_p, - void **key_buf_p, int *key_size_p, - void **data_buf_p, int *data_size_p); + /* + * int table_entry + * + * DESCRIPTION: + * + * Get information about an element. The element is one from the + * array returned by the table_order function. If any of the key/data + * pointers are NULL then they are ignored. + * + * RETURNS: + * + * Success - TABLE_ERROR_NONE + * + * Failure - Table error code. + * + * ARGUMENTS: + * + * table_p - Table structure pointer from which we are getting the + * element. + * + * entry_p - Pointer to a table entry from the array returned by the + * table_order function. + * + * key_buf_p - Pointer which, if not NULL, will be set to the address + * of the storage of this entry that is allocated in the table. If an + * (int) is stored as this entry (for example) then key_buf_p should + * be (int **) i.e. the address of a (int *). + * + * key_size_p - Pointer to an integer which, if not NULL, will be set + * to the size of the key that is stored in the table. + * + * data_buf_p - Pointer which, if not NULL, will be set to the address + * of the data storage of this entry that is allocated in the table. + * If a (long) is stored as this entry data (for example) then + * data_buf_p should be (long **) i.e. the address of a (long *). + * + * data_size_p - Pointer to an integer which, if not NULL, will be set + * to the size of the data that is stored in the table. + */ + extern + int table_entry(table_t *table_p, table_entry_t *entry_p, + void **key_buf_p, int *key_size_p, + void **data_buf_p, int *data_size_p); -/* - * table_linear_t *table_order_pos - * - * DESCRIPTION: - * - * Order a table by building an array of table linear structures and - * then sorting this array using the qsort function. To retrieve the - * sorted entries, you can then use the table_entry_pos routine to - * access each entry in order. - * - * NOTE: This routine is thread safe and makes use of an internal - * status qsort function. - * - * RETURNS: - * - * Success - An allocated list of table-linear structures which must - * be freed by table_order_pos_free later. - * - * Failure - NULL - * - * ARGUMENTS: - * - * table_p - Pointer to the table that we are ordering. - * - * compare - Comparison function defined by the user. Its definition - * is at the top of the table.h file. If this is NULL then it will - * order the table my memcmp-ing the keys. - * - * num_entries_p - Pointer to an integer which, if not NULL, will - * contain the number of entries in the returned entry pointer array. - * - * error_p - Pointer to an integer which, if not NULL, will contain a - * table error code. - */ -extern -table_linear_t *table_order_pos(table_t *table_p, table_compare_t compare, - int *num_entries_p, int *error_p); + /* + * table_linear_t *table_order_pos + * + * DESCRIPTION: + * + * Order a table by building an array of table linear structures and + * then sorting this array using the qsort function. To retrieve the + * sorted entries, you can then use the table_entry_pos routine to + * access each entry in order. + * + * NOTE: This routine is thread safe and makes use of an internal + * status qsort function. + * + * RETURNS: + * + * Success - An allocated list of table-linear structures which must + * be freed by table_order_pos_free later. + * + * Failure - NULL + * + * ARGUMENTS: + * + * table_p - Pointer to the table that we are ordering. + * + * compare - Comparison function defined by the user. Its definition + * is at the top of the table.h file. If this is NULL then it will + * order the table my memcmp-ing the keys. + * + * num_entries_p - Pointer to an integer which, if not NULL, will + * contain the number of entries in the returned entry pointer array. + * + * error_p - Pointer to an integer which, if not NULL, will contain a + * table error code. + */ + extern + table_linear_t *table_order_pos(table_t *table_p, table_compare_t compare, + int *num_entries_p, int *error_p); -/* - * int table_order_pos_free - * - * DESCRIPTION: - * - * Free the pointer returned by the table_order or table_order_pos - * routines. - * - * RETURNS: - * - * Success - TABLE_ERROR_NONE - * - * Failure - Table error code. - * - * ARGUMENTS: - * - * table_p - Pointer to the table. - * - * table_entries - Allocated list of entry pointers returned by - * table_order_pos. - * - * entry_n - Number of entries in the array as passed back by - * table_order or table_order_pos in num_entries_p. - */ -extern -int table_order_pos_free(table_t *table_p, table_linear_t *table_entries, - const int entry_n); + /* + * int table_order_pos_free + * + * DESCRIPTION: + * + * Free the pointer returned by the table_order or table_order_pos + * routines. + * + * RETURNS: + * + * Success - TABLE_ERROR_NONE + * + * Failure - Table error code. + * + * ARGUMENTS: + * + * table_p - Pointer to the table. + * + * table_entries - Allocated list of entry pointers returned by + * table_order_pos. + * + * entry_n - Number of entries in the array as passed back by + * table_order or table_order_pos in num_entries_p. + */ + extern + int table_order_pos_free(table_t *table_p, table_linear_t *table_entries, + const int entry_n); -/* - * int table_entry_pos - * - * DESCRIPTION: - * - * Get information about an element. The element is one from the - * array returned by the table_order function. If any of the key/data - * pointers are NULL then they are ignored. - * - * RETURNS: - * - * Success - TABLE_ERROR_NONE - * - * Failure - Table error code. - * - * ARGUMENTS: - * - * table_p - Table structure pointer from which we are getting the - * element. - * - * linear_p - Pointer to a table linear structure from the array - * returned by the table_order function. - * - * key_buf_p - Pointer which, if not NULL, will be set to the address - * of the storage of this entry that is allocated in the table. If an - * (int) is stored as this entry (for example) then key_buf_p should - * be (int **) i.e. the address of a (int *). - * - * key_size_p - Pointer to an integer which, if not NULL, will be set - * to the size of the key that is stored in the table. - * - * data_buf_p - Pointer which, if not NULL, will be set to the address - * of the data storage of this entry that is allocated in the table. - * If a (long) is stored as this entry data (for example) then - * data_buf_p should be (long **) i.e. the address of a (long *). - * - * data_size_p - Pointer to an integer which, if not NULL, will be set - * to the size of the data that is stored in the table. - */ -extern -int table_entry_pos(table_t *table_p, table_linear_t *linear_p, - void **key_buf_p, int *key_size_p, - void **data_buf_p, int *data_size_p); + /* + * int table_entry_pos + * + * DESCRIPTION: + * + * Get information about an element. The element is one from the + * array returned by the table_order function. If any of the key/data + * pointers are NULL then they are ignored. + * + * RETURNS: + * + * Success - TABLE_ERROR_NONE + * + * Failure - Table error code. + * + * ARGUMENTS: + * + * table_p - Table structure pointer from which we are getting the + * element. + * + * linear_p - Pointer to a table linear structure from the array + * returned by the table_order function. + * + * key_buf_p - Pointer which, if not NULL, will be set to the address + * of the storage of this entry that is allocated in the table. If an + * (int) is stored as this entry (for example) then key_buf_p should + * be (int **) i.e. the address of a (int *). + * + * key_size_p - Pointer to an integer which, if not NULL, will be set + * to the size of the key that is stored in the table. + * + * data_buf_p - Pointer which, if not NULL, will be set to the address + * of the data storage of this entry that is allocated in the table. + * If a (long) is stored as this entry data (for example) then + * data_buf_p should be (long **) i.e. the address of a (long *). + * + * data_size_p - Pointer to an integer which, if not NULL, will be set + * to the size of the data that is stored in the table. + */ + extern + int table_entry_pos(table_t *table_p, table_linear_t *linear_p, + void **key_buf_p, int *key_size_p, + void **data_buf_p, int *data_size_p); -/* - * const char *table_strerror - * - * DESCRIPTION: - * - * Return the corresponding string for the error number. - * - * RETURNS: - * - * Success - String equivalient of the error. - * - * Failure - String "invalid error code" - * - * ARGUMENTS: - * - * error - Error number that we are converting. - */ -extern -const char *table_strerror(const int error); + /* + * const char *table_strerror + * + * DESCRIPTION: + * + * Return the corresponding string for the error number. + * + * RETURNS: + * + * Success - String equivalient of the error. + * + * Failure - String "invalid error code" + * + * ARGUMENTS: + * + * error - Error number that we are converting. + */ + extern + const char *table_strerror(const int error); -/*<<<<<<<<<< This is end of the auto-generated output from fillproto. */ + /*<<<<<<<<<< This is end of the auto-generated output from fillproto. */ #ifdef __cplusplus } #endif /* __cplusplus */ #endif /* ! __TABLE_H__ */ + +/* For Emacs: + * Local Variables: + * mode:c + * indent-tabs-mode:t + * tab-width:4 + * c-basic-offset:4 + * End: + * For VIM: + * vim:set softtabstop=4 shiftwidth=4 tabstop=4 noet: + */ diff --git a/libs/libks/src/include/table_loc.h b/libs/libks/src/include/table_loc.h index 02514c8211..95149db971 100644 --- a/libs/libks/src/include/table_loc.h +++ b/libs/libks/src/include/table_loc.h @@ -83,25 +83,25 @@ * were about 2^68 hashes to choose from. I only tested about a * billion of those. */ -#define HASH_MIX(a, b, c) \ - do { \ - a -= b; a -= c; a ^= (c >> 13); \ - b -= c; b -= a; b ^= (a << 8); \ - c -= a; c -= b; c ^= (b >> 13); \ - a -= b; a -= c; a ^= (c >> 12); \ - b -= c; b -= a; b ^= (a << 16); \ - c -= a; c -= b; c ^= (b >> 5); \ - a -= b; a -= c; a ^= (c >> 3); \ - b -= c; b -= a; b ^= (a << 10); \ - c -= a; c -= b; c ^= (b >> 15); \ - } while(0) +#define HASH_MIX(a, b, c) \ + do { \ + a -= b; a -= c; a ^= (c >> 13); \ + b -= c; b -= a; b ^= (a << 8); \ + c -= a; c -= b; c ^= (b >> 13); \ + a -= b; a -= c; a ^= (c >> 12); \ + b -= c; b -= a; b ^= (a << 16); \ + c -= a; c -= b; c ^= (b >> 5); \ + a -= b; a -= c; a ^= (c >> 3); \ + b -= c; b -= a; b ^= (a << 10); \ + c -= a; c -= b; c ^= (b >> 15); \ + } while(0) -#define SET_POINTER(pnt, val) \ - do { \ - if ((pnt) != NULL) { \ - (*(pnt)) = (val); \ - } \ - } while(0) +#define SET_POINTER(pnt, val) \ + do { \ + if ((pnt) != NULL) { \ + (*(pnt)) = (val); \ + } \ + } while(0) /* * The following macros take care of the mmap case. When we are @@ -117,9 +117,9 @@ #else -#define TABLE_POINTER(tab_p, type, pnt) \ - ((tab_p)->ta_mmap == NULL || (pnt) == NULL ? (pnt) : \ - (type)((char *)((tab_p)->ta_mmap) + (long)(pnt))) +#define TABLE_POINTER(tab_p, type, pnt) \ + ((tab_p)->ta_mmap == NULL || (pnt) == NULL ? (pnt) : \ + (type)((char *)((tab_p)->ta_mmap) + (long)(pnt))) #endif @@ -127,8 +127,8 @@ * Macros to get at the key and the data pointers */ #define ENTRY_KEY_BUF(entry_p) ((entry_p)->te_key_buf) -#define ENTRY_DATA_BUF(tab_p, entry_p) \ - (ENTRY_KEY_BUF(entry_p) + (entry_p)->te_key_size) +#define ENTRY_DATA_BUF(tab_p, entry_p) \ + (ENTRY_KEY_BUF(entry_p) + (entry_p)->te_key_size) /* * Table structures... @@ -142,10 +142,10 @@ * faster. */ typedef struct table_shell_st { - unsigned int te_key_size; /* size of data */ - unsigned int te_data_size; /* size of data */ - struct table_shell_st *te_next_p; /* pointer to next in the list */ - /* NOTE: this does not have the te_key_buf field here */ + unsigned int te_key_size; /* size of data */ + unsigned int te_data_size; /* size of data */ + struct table_shell_st *te_next_p; /* pointer to next in the list */ + /* NOTE: this does not have the te_key_buf field here */ } table_shell_t; /* @@ -157,10 +157,10 @@ typedef struct table_shell_st { * changed to match. */ typedef struct table_entry_st { - unsigned int te_key_size; /* size of data */ - unsigned int te_data_size; /* size of data */ - struct table_entry_st *te_next_p; /* pointer to next in the list */ - unsigned char te_key_buf[1]; /* 1st byte of key buf */ + unsigned int te_key_size; /* size of data */ + unsigned int te_data_size; /* size of data */ + struct table_entry_st *te_next_p; /* pointer to next in the list */ + unsigned char te_key_buf[1]; /* 1st byte of key buf */ } table_entry_t; /* external structure for debuggers be able to see void */ @@ -168,20 +168,20 @@ typedef table_entry_t table_entry_ext_t; /* main table structure */ typedef struct table_st { - unsigned int ta_magic; /* magic number */ - unsigned int ta_flags; /* table's flags defined in table.h */ - unsigned int ta_bucket_n; /* num of buckets, should be 2^X */ - unsigned int ta_entry_n; /* num of entries in all buckets */ - unsigned int ta_data_align; /* data alignment value */ - table_entry_t **ta_buckets; /* array of linked lists */ - table_linear_t ta_linear; /* linear tracking */ - struct table_st *ta_mmap; /* mmaped table */ - unsigned long ta_file_size; /* size of on-disk space */ + unsigned int ta_magic; /* magic number */ + unsigned int ta_flags; /* table's flags defined in table.h */ + unsigned int ta_bucket_n; /* num of buckets, should be 2^X */ + unsigned int ta_entry_n; /* num of entries in all buckets */ + unsigned int ta_data_align; /* data alignment value */ + table_entry_t **ta_buckets; /* array of linked lists */ + table_linear_t ta_linear; /* linear tracking */ + struct table_st *ta_mmap; /* mmaped table */ + unsigned long ta_file_size; /* size of on-disk space */ - void *ta_mem_pool; /* pointer to some memory pool */ - table_mem_alloc_t ta_alloc_func; /* memory allocation function */ - table_mem_resize_t ta_resize_func; /* memory resize function */ - table_mem_free_t ta_free_func; /* memory free function */ + void *ta_mem_pool; /* pointer to some memory pool */ + table_mem_alloc_t ta_alloc_func; /* memory allocation function */ + table_mem_resize_t ta_resize_func; /* memory resize function */ + table_mem_free_t ta_free_func; /* memory free function */ } table_t; /* external table structure for debuggers */ @@ -189,41 +189,53 @@ typedef table_t table_ext_t; /* local comparison functions */ typedef int (*compare_t)(const void *element1_p, const void *element2_p, - table_compare_t user_compare, - const table_t *table_p, int *err_bp); + table_compare_t user_compare, + const table_t *table_p, int *err_bp); /* * to map error to string */ typedef struct { - int es_error; /* error number */ - char *es_string; /* assocaited string */ + int es_error; /* error number */ + char *es_string; /* assocaited string */ } error_str_t; static error_str_t errors[] = { - { TABLE_ERROR_NONE, "no error" }, - { TABLE_ERROR_PNT, "invalid table pointer" }, - { TABLE_ERROR_ARG_NULL, "buffer argument is null" }, - { TABLE_ERROR_SIZE, "incorrect size argument" }, - { TABLE_ERROR_OVERWRITE, "key exists and no overwrite" }, - { TABLE_ERROR_NOT_FOUND, "key does not exist" }, - { TABLE_ERROR_ALLOC, "error allocating memory" }, - { TABLE_ERROR_LINEAR, "linear access not in progress" }, - { TABLE_ERROR_OPEN, "could not open file" }, - { TABLE_ERROR_SEEK, "could not seek to position in file" }, - { TABLE_ERROR_READ, "could not read from file" }, - { TABLE_ERROR_WRITE, "could not write to file" }, - { TABLE_ERROR_MMAP_NONE, "no mmap support compiled in library" }, - { TABLE_ERROR_MMAP, "could not mmap the file" }, - { TABLE_ERROR_MMAP_OP, "operation not valid on mmap files" }, - { TABLE_ERROR_EMPTY, "table is empty" }, - { TABLE_ERROR_NOT_EMPTY, "table contains data" }, - { TABLE_ERROR_ALIGNMENT, "invalid alignment value" }, - { TABLE_ERROR_COMPARE, "problems with internal comparison" }, - { TABLE_ERROR_FREE, "memory free error" }, - { 0 } + { TABLE_ERROR_NONE, "no error" }, + { TABLE_ERROR_PNT, "invalid table pointer" }, + { TABLE_ERROR_ARG_NULL, "buffer argument is null" }, + { TABLE_ERROR_SIZE, "incorrect size argument" }, + { TABLE_ERROR_OVERWRITE, "key exists and no overwrite" }, + { TABLE_ERROR_NOT_FOUND, "key does not exist" }, + { TABLE_ERROR_ALLOC, "error allocating memory" }, + { TABLE_ERROR_LINEAR, "linear access not in progress" }, + { TABLE_ERROR_OPEN, "could not open file" }, + { TABLE_ERROR_SEEK, "could not seek to position in file" }, + { TABLE_ERROR_READ, "could not read from file" }, + { TABLE_ERROR_WRITE, "could not write to file" }, + { TABLE_ERROR_MMAP_NONE, "no mmap support compiled in library" }, + { TABLE_ERROR_MMAP, "could not mmap the file" }, + { TABLE_ERROR_MMAP_OP, "operation not valid on mmap files" }, + { TABLE_ERROR_EMPTY, "table is empty" }, + { TABLE_ERROR_NOT_EMPTY, "table contains data" }, + { TABLE_ERROR_ALIGNMENT, "invalid alignment value" }, + { TABLE_ERROR_COMPARE, "problems with internal comparison" }, + { TABLE_ERROR_FREE, "memory free error" }, + { 0 } }; #define INVALID_ERROR "invalid error code" #endif /* ! __TABLE_LOC_H__ */ + +/* For Emacs: + * Local Variables: + * mode:c + * indent-tabs-mode:t + * tab-width:4 + * c-basic-offset:4 + * End: + * For VIM: + * vim:set softtabstop=4 shiftwidth=4 tabstop=4 noet: + */ + diff --git a/libs/libks/src/mpool.c b/libs/libks/src/mpool.c index 72c5b6b108..c285621a82 100644 --- a/libs/libks/src/mpool.c +++ b/libs/libks/src/mpool.c @@ -83,36 +83,36 @@ static unsigned long bit_array[MAX_BITS + 1]; /* size -> bit */ */ static void startup(void) { - int bit_c; - unsigned long size = 1; + int bit_c; + unsigned long size = 1; - if (enabled_b) { - return; - } + if (enabled_b) { + return; + } - /* allocate our free bit array list */ - for (bit_c = 0; bit_c <= MAX_BITS; bit_c++) { - bit_array[bit_c] = size; + /* allocate our free bit array list */ + for (bit_c = 0; bit_c <= MAX_BITS; bit_c++) { + bit_array[bit_c] = size; - /* - * Note our minimum number of bits that can store a pointer. This - * is smallest address that we can have a linked list for. - */ - if (min_bit_free_next == 0 && size >= sizeof(void *)) { - min_bit_free_next = bit_c; - } - /* - * Note our minimum number of bits that can store a pointer and - * the size of the block. - */ - if (min_bit_free_size == 0 && size >= sizeof(mpool_free_t)) { - min_bit_free_size = bit_c; - } + /* + * Note our minimum number of bits that can store a pointer. This + * is smallest address that we can have a linked list for. + */ + if (min_bit_free_next == 0 && size >= sizeof(void *)) { + min_bit_free_next = bit_c; + } + /* + * Note our minimum number of bits that can store a pointer and + * the size of the block. + */ + if (min_bit_free_size == 0 && size >= sizeof(mpool_free_t)) { + min_bit_free_size = bit_c; + } - size *= 2; - } + size *= 2; + } - enabled_b = 1; + enabled_b = 1; } /* @@ -132,15 +132,15 @@ static void startup(void) */ static int size_to_bits(const unsigned long size) { - int bit_c = 0; + int bit_c = 0; - for (bit_c = 0; bit_c <= MAX_BITS; bit_c++) { - if (size <= bit_array[bit_c]) { - break; - } - } + for (bit_c = 0; bit_c <= MAX_BITS; bit_c++) { + if (size <= bit_array[bit_c]) { + break; + } + } - return bit_c; + return bit_c; } /* @@ -160,19 +160,19 @@ static int size_to_bits(const unsigned long size) */ static int size_to_free_bits(const unsigned long size) { - int bit_c = 0; + int bit_c = 0; - if (size == 0) { - return 0; - } + if (size == 0) { + return 0; + } - for (bit_c = 0; bit_c <= MAX_BITS; bit_c++) { - if (size < bit_array[bit_c]) { - break; - } - } + for (bit_c = 0; bit_c <= MAX_BITS; bit_c++) { + if (size < bit_array[bit_c]) { + break; + } + } - return bit_c - 1; + return bit_c - 1; } /* @@ -192,12 +192,12 @@ static int size_to_free_bits(const unsigned long size) */ static unsigned long bits_to_size(const int bit_n) { - if (bit_n > MAX_BITS) { - return bit_array[MAX_BITS]; - } - else { - return bit_array[bit_n]; - } + if (bit_n > MAX_BITS) { + return bit_array[MAX_BITS]; + } + else { + return bit_array[bit_n]; + } } /* @@ -223,77 +223,77 @@ static unsigned long bits_to_size(const int bit_n) * a mpool error code. */ static void *alloc_pages(mpool_t *mp_p, const unsigned int page_n, - int *error_p) + int *error_p) { - void *mem, *fill_mem; - unsigned long size, fill; - int state; + void *mem, *fill_mem; + unsigned long size, fill; + int state; - /* are we over our max-pages? */ - if (mp_p->mp_max_pages > 0 && mp_p->mp_page_c >= mp_p->mp_max_pages) { - SET_POINTER(error_p, MPOOL_ERROR_NO_PAGES); - return NULL; - } + /* are we over our max-pages? */ + if (mp_p->mp_max_pages > 0 && mp_p->mp_page_c >= mp_p->mp_max_pages) { + SET_POINTER(error_p, MPOOL_ERROR_NO_PAGES); + return NULL; + } - size = SIZE_OF_PAGES(mp_p, page_n); + size = SIZE_OF_PAGES(mp_p, page_n); #ifdef DEBUG - (void)printf("allocating %u pages or %lu bytes\n", page_n, size); + (void)printf("allocating %u pages or %lu bytes\n", page_n, size); #endif - if (BIT_IS_SET(mp_p->mp_flags, MPOOL_FLAG_USE_SBRK)) { - mem = sbrk(size); - if (mem == (void *)-1) { - SET_POINTER(error_p, MPOOL_ERROR_NO_MEM); - return NULL; - } - fill = (unsigned long)mem % mp_p->mp_page_size; + if (BIT_IS_SET(mp_p->mp_flags, MPOOL_FLAG_USE_SBRK)) { + mem = sbrk(size); + if (mem == (void *)-1) { + SET_POINTER(error_p, MPOOL_ERROR_NO_MEM); + return NULL; + } + fill = (unsigned long)mem % mp_p->mp_page_size; - if (fill > 0) { - fill = mp_p->mp_page_size - fill; - fill_mem = sbrk(fill); - if (fill_mem == (void *)-1) { - SET_POINTER(error_p, MPOOL_ERROR_NO_MEM); - return NULL; - } - if ((char *)fill_mem != (char *)mem + size) { - SET_POINTER(error_p, MPOOL_ERROR_SBRK_CONTIG); - return NULL; - } - mem = (char *)mem + fill; - } - } - else { - state = MAP_PRIVATE; + if (fill > 0) { + fill = mp_p->mp_page_size - fill; + fill_mem = sbrk(fill); + if (fill_mem == (void *)-1) { + SET_POINTER(error_p, MPOOL_ERROR_NO_MEM); + return NULL; + } + if ((char *)fill_mem != (char *)mem + size) { + SET_POINTER(error_p, MPOOL_ERROR_SBRK_CONTIG); + return NULL; + } + mem = (char *)mem + fill; + } + } + else { + state = MAP_PRIVATE; #ifdef MAP_FILE - state |= MAP_FILE; + state |= MAP_FILE; #endif #ifdef MAP_VARIABLE - state |= MAP_VARIABLE; + state |= MAP_VARIABLE; #endif - /* mmap from /dev/zero */ - mem = mmap((caddr_t)mp_p->mp_addr, size, PROT_READ | PROT_WRITE, state, - mp_p->mp_fd, mp_p->mp_top); - if (mem == (void *)MAP_FAILED) { - if (errno == ENOMEM) { - SET_POINTER(error_p, MPOOL_ERROR_NO_MEM); - } - else { - SET_POINTER(error_p, MPOOL_ERROR_MMAP); - } - return NULL; - } - mp_p->mp_top += size; - if (mp_p->mp_addr != NULL) { - mp_p->mp_addr = (char *)mp_p->mp_addr + size; - } - } + /* mmap from /dev/zero */ + mem = mmap((caddr_t)mp_p->mp_addr, size, PROT_READ | PROT_WRITE, state, + mp_p->mp_fd, mp_p->mp_top); + if (mem == (void *)MAP_FAILED) { + if (errno == ENOMEM) { + SET_POINTER(error_p, MPOOL_ERROR_NO_MEM); + } + else { + SET_POINTER(error_p, MPOOL_ERROR_MMAP); + } + return NULL; + } + mp_p->mp_top += size; + if (mp_p->mp_addr != NULL) { + mp_p->mp_addr = (char *)mp_p->mp_addr + size; + } + } - mp_p->mp_page_c += page_n; + mp_p->mp_page_c += page_n; - SET_POINTER(error_p, MPOOL_ERROR_NONE); - return mem; + SET_POINTER(error_p, MPOOL_ERROR_NONE); + return mem; } /* @@ -318,13 +318,13 @@ static void *alloc_pages(mpool_t *mp_p, const unsigned int page_n, * sbrk_b -> Set to one if the pages were allocated with sbrk else mmap. */ static int free_pages(void *pages, const unsigned long size, - const int sbrk_b) + const int sbrk_b) { - if (! sbrk_b) { - (void)munmap((caddr_t)pages, size); - } + if (! sbrk_b) { + (void)munmap((caddr_t)pages, size); + } - return MPOOL_ERROR_NONE; + return MPOOL_ERROR_NONE; } /* @@ -348,17 +348,17 @@ static int free_pages(void *pages, const unsigned long size, */ static int check_magic(const void *addr, const unsigned long size) { - const unsigned char *mem_p; + const unsigned char *mem_p; - /* set our starting point */ - mem_p = (unsigned char *)addr + size; + /* set our starting point */ + mem_p = (unsigned char *)addr + size; - if (*mem_p == FENCE_MAGIC0 && *(mem_p + 1) == FENCE_MAGIC1) { - return MPOOL_ERROR_NONE; - } - else { - return MPOOL_ERROR_PNT_OVER; - } + if (*mem_p == FENCE_MAGIC0 && *(mem_p + 1) == FENCE_MAGIC1) { + return MPOOL_ERROR_NONE; + } + else { + return MPOOL_ERROR_PNT_OVER; + } } /* @@ -378,8 +378,8 @@ static int check_magic(const void *addr, const unsigned long size) */ static void write_magic(const void *addr) { - *(unsigned char *)addr = FENCE_MAGIC0; - *((unsigned char *)addr + 1) = FENCE_MAGIC1; + *(unsigned char *)addr = FENCE_MAGIC0; + *((unsigned char *)addr + 1) = FENCE_MAGIC1; } /* @@ -405,75 +405,75 @@ static void write_magic(const void *addr) * size -> Size of the address space. */ static int free_pointer(mpool_t *mp_p, void *addr, - const unsigned long size) + const unsigned long size) { - unsigned int bit_n; - unsigned long real_size; - mpool_free_t free_pnt; + unsigned int bit_n; + unsigned long real_size; + mpool_free_t free_pnt; #ifdef DEBUG - (void)printf("freeing a block at %lx of %lu bytes\n", (long)addr, size); + (void)printf("freeing a block at %lx of %lu bytes\n", (long)addr, size); #endif - if (size == 0) { - return MPOOL_ERROR_NONE; - } + if (size == 0) { + return MPOOL_ERROR_NONE; + } - /* - * if the user size is larger then can fit in an entire block then - * we change the size - */ - if (size > MAX_BLOCK_USER_MEMORY(mp_p)) { - real_size = SIZE_OF_PAGES(mp_p, PAGES_IN_SIZE(mp_p, size)) - - sizeof(mpool_block_t); - } - else { - real_size = size; - } + /* + * if the user size is larger then can fit in an entire block then + * we change the size + */ + if (size > MAX_BLOCK_USER_MEMORY(mp_p)) { + real_size = SIZE_OF_PAGES(mp_p, PAGES_IN_SIZE(mp_p, size)) - + sizeof(mpool_block_t); + } + else { + real_size = size; + } - /* - * We use a specific free bits calculation here because if we are - * freeing 10 bytes then we will be putting it into the 8-byte free - * list and not the 16 byte list. size_to_bits(10) will return 4 - * instead of 3. - */ - bit_n = size_to_free_bits(real_size); + /* + * We use a specific free bits calculation here because if we are + * freeing 10 bytes then we will be putting it into the 8-byte free + * list and not the 16 byte list. size_to_bits(10) will return 4 + * instead of 3. + */ + bit_n = size_to_free_bits(real_size); - /* - * Minimal error checking. We could go all the way through the - * list however this might be prohibitive. - */ - if (mp_p->mp_free[bit_n] == addr) { - return MPOOL_ERROR_IS_FREE; - } + /* + * Minimal error checking. We could go all the way through the + * list however this might be prohibitive. + */ + if (mp_p->mp_free[bit_n] == addr) { + return MPOOL_ERROR_IS_FREE; + } - /* add the freed pointer to the free list */ - if (bit_n < min_bit_free_next) { - /* - * Yes we know this will lose 99% of the allocations but what else - * can we do? No space for a next pointer. - */ - if (mp_p->mp_free[bit_n] == NULL) { - mp_p->mp_free[bit_n] = addr; - } - } - else if (bit_n < min_bit_free_size) { - /* we copy, not assign, to maintain the free list */ - memcpy(addr, mp_p->mp_free + bit_n, sizeof(void *)); - mp_p->mp_free[bit_n] = addr; - } - else { + /* add the freed pointer to the free list */ + if (bit_n < min_bit_free_next) { + /* + * Yes we know this will lose 99% of the allocations but what else + * can we do? No space for a next pointer. + */ + if (mp_p->mp_free[bit_n] == NULL) { + mp_p->mp_free[bit_n] = addr; + } + } + else if (bit_n < min_bit_free_size) { + /* we copy, not assign, to maintain the free list */ + memcpy(addr, mp_p->mp_free + bit_n, sizeof(void *)); + mp_p->mp_free[bit_n] = addr; + } + else { - /* setup our free list structure */ - free_pnt.mf_next_p = mp_p->mp_free[bit_n]; - free_pnt.mf_size = real_size; + /* setup our free list structure */ + free_pnt.mf_next_p = mp_p->mp_free[bit_n]; + free_pnt.mf_size = real_size; - /* we copy the structure in since we don't know about alignment */ - memcpy(addr, &free_pnt, sizeof(free_pnt)); - mp_p->mp_free[bit_n] = addr; - } + /* we copy the structure in since we don't know about alignment */ + memcpy(addr, &free_pnt, sizeof(free_pnt)); + mp_p->mp_free[bit_n] = addr; + } - return MPOOL_ERROR_NONE; + return MPOOL_ERROR_NONE; } /* @@ -499,59 +499,59 @@ static int free_pointer(mpool_t *mp_p, void *addr, * size -> Size of the space that we are taking from address. */ static int split_block(mpool_t *mp_p, void *free_addr, - const unsigned long size) + const unsigned long size) { - mpool_block_t *block_p, *new_block_p; - int ret, page_n; - void *end_p; + mpool_block_t *block_p, *new_block_p; + int ret, page_n; + void *end_p; - /* - * 1st we find the block pointer from our free addr. At this point - * the pointer must be the 1st one in the block if it is spans - * multiple blocks. - */ - block_p = (mpool_block_t *)((char *)free_addr - sizeof(mpool_block_t)); - if (block_p->mb_magic != BLOCK_MAGIC - || block_p->mb_magic2 != BLOCK_MAGIC) { - return MPOOL_ERROR_POOL_OVER; - } + /* + * 1st we find the block pointer from our free addr. At this point + * the pointer must be the 1st one in the block if it is spans + * multiple blocks. + */ + block_p = (mpool_block_t *)((char *)free_addr - sizeof(mpool_block_t)); + if (block_p->mb_magic != BLOCK_MAGIC + || block_p->mb_magic2 != BLOCK_MAGIC) { + return MPOOL_ERROR_POOL_OVER; + } - page_n = PAGES_IN_SIZE(mp_p, size); + page_n = PAGES_IN_SIZE(mp_p, size); - /* we are creating a new block structure for the 2nd ... */ - new_block_p = (mpool_block_t *)((char *)block_p + - SIZE_OF_PAGES(mp_p, page_n)); - new_block_p->mb_magic = BLOCK_MAGIC; - /* New bounds is 1st block bounds. The 1st block's is reset below. */ - new_block_p->mb_bounds_p = block_p->mb_bounds_p; - /* Continue the linked list. The 1st block will point to us below. */ - new_block_p->mb_next_p = block_p->mb_next_p; - new_block_p->mb_magic2 = BLOCK_MAGIC; + /* we are creating a new block structure for the 2nd ... */ + new_block_p = (mpool_block_t *)((char *)block_p + + SIZE_OF_PAGES(mp_p, page_n)); + new_block_p->mb_magic = BLOCK_MAGIC; + /* New bounds is 1st block bounds. The 1st block's is reset below. */ + new_block_p->mb_bounds_p = block_p->mb_bounds_p; + /* Continue the linked list. The 1st block will point to us below. */ + new_block_p->mb_next_p = block_p->mb_next_p; + new_block_p->mb_magic2 = BLOCK_MAGIC; - /* bounds for the 1st block are reset to the 1st page only */ - block_p->mb_bounds_p = (char *)new_block_p; - /* the next block pointer for the 1st block is now the new one */ - block_p->mb_next_p = new_block_p; + /* bounds for the 1st block are reset to the 1st page only */ + block_p->mb_bounds_p = (char *)new_block_p; + /* the next block pointer for the 1st block is now the new one */ + block_p->mb_next_p = new_block_p; - /* only free the space in the 1st block if it is only 1 block in size */ - if (page_n == 1) { - /* now free the rest of the 1st block block */ - end_p = (char *)free_addr + size; - ret = free_pointer(mp_p, end_p, - (char *)block_p->mb_bounds_p - (char *)end_p); - if (ret != MPOOL_ERROR_NONE) { - return ret; - } - } + /* only free the space in the 1st block if it is only 1 block in size */ + if (page_n == 1) { + /* now free the rest of the 1st block block */ + end_p = (char *)free_addr + size; + ret = free_pointer(mp_p, end_p, + (char *)block_p->mb_bounds_p - (char *)end_p); + if (ret != MPOOL_ERROR_NONE) { + return ret; + } + } - /* now free the rest of the block */ - ret = free_pointer(mp_p, FIRST_ADDR_IN_BLOCK(new_block_p), - MEMORY_IN_BLOCK(new_block_p)); - if (ret != MPOOL_ERROR_NONE) { - return ret; - } + /* now free the rest of the block */ + ret = free_pointer(mp_p, FIRST_ADDR_IN_BLOCK(new_block_p), + MEMORY_IN_BLOCK(new_block_p)); + if (ret != MPOOL_ERROR_NONE) { + return ret; + } - return MPOOL_ERROR_NONE; + return MPOOL_ERROR_NONE; } /* @@ -577,145 +577,145 @@ static int split_block(mpool_t *mp_p, void *free_addr, * a mpool error code. */ static void *get_space(mpool_t *mp_p, const unsigned long byte_size, - int *error_p) + int *error_p) { - mpool_block_t *block_p; - mpool_free_t free_pnt; - int ret; - unsigned long size; - unsigned int bit_c, page_n, left; - void *free_addr = NULL, *free_end; + mpool_block_t *block_p; + mpool_free_t free_pnt; + int ret; + unsigned long size; + unsigned int bit_c, page_n, left; + void *free_addr = NULL, *free_end; - size = byte_size; - while ((size & (sizeof(void *) - 1)) > 0) { - size++; - } + size = byte_size; + while ((size & (sizeof(void *) - 1)) > 0) { + size++; + } - /* - * First we check the free lists looking for something with enough - * pages. Maybe we should only look X bits higher in the list. - * - * XXX: this is where we'd do the best fit. We'd look for the - * closest match. We then could put the rest of the allocation that - * we did not use in a lower free list. Have a define which states - * how deep in the free list to go to find the closest match. - */ - for (bit_c = size_to_bits(size); bit_c <= MAX_BITS; bit_c++) { - if (mp_p->mp_free[bit_c] != NULL) { - free_addr = mp_p->mp_free[bit_c]; - break; - } - } + /* + * First we check the free lists looking for something with enough + * pages. Maybe we should only look X bits higher in the list. + * + * XXX: this is where we'd do the best fit. We'd look for the + * closest match. We then could put the rest of the allocation that + * we did not use in a lower free list. Have a define which states + * how deep in the free list to go to find the closest match. + */ + for (bit_c = size_to_bits(size); bit_c <= MAX_BITS; bit_c++) { + if (mp_p->mp_free[bit_c] != NULL) { + free_addr = mp_p->mp_free[bit_c]; + break; + } + } - /* - * If we haven't allocated any blocks or if the last block doesn't - * have enough memory then we need a new block. - */ - if (bit_c > MAX_BITS) { + /* + * If we haven't allocated any blocks or if the last block doesn't + * have enough memory then we need a new block. + */ + if (bit_c > MAX_BITS) { - /* we need to allocate more space */ + /* we need to allocate more space */ - page_n = PAGES_IN_SIZE(mp_p, size); + page_n = PAGES_IN_SIZE(mp_p, size); - /* now we try and get the pages we need/want */ - block_p = alloc_pages(mp_p, page_n, error_p); - if (block_p == NULL) { - /* error_p set in alloc_pages */ - return NULL; - } + /* now we try and get the pages we need/want */ + block_p = alloc_pages(mp_p, page_n, error_p); + if (block_p == NULL) { + /* error_p set in alloc_pages */ + return NULL; + } - /* init the block header */ - block_p->mb_magic = BLOCK_MAGIC; - block_p->mb_bounds_p = (char *)block_p + SIZE_OF_PAGES(mp_p, page_n); - block_p->mb_next_p = mp_p->mp_first_p; - block_p->mb_magic2 = BLOCK_MAGIC; + /* init the block header */ + block_p->mb_magic = BLOCK_MAGIC; + block_p->mb_bounds_p = (char *)block_p + SIZE_OF_PAGES(mp_p, page_n); + block_p->mb_next_p = mp_p->mp_first_p; + block_p->mb_magic2 = BLOCK_MAGIC; - /* - * We insert it into the front of the queue. We could add it to - * the end but there is not much use. - */ - mp_p->mp_first_p = block_p; - if (mp_p->mp_last_p == NULL) { - mp_p->mp_last_p = block_p; - } + /* + * We insert it into the front of the queue. We could add it to + * the end but there is not much use. + */ + mp_p->mp_first_p = block_p; + if (mp_p->mp_last_p == NULL) { + mp_p->mp_last_p = block_p; + } - free_addr = FIRST_ADDR_IN_BLOCK(block_p); + free_addr = FIRST_ADDR_IN_BLOCK(block_p); #ifdef DEBUG - (void)printf("had to allocate space for %lx of %lu bytes\n", - (long)free_addr, size); + (void)printf("had to allocate space for %lx of %lu bytes\n", + (long)free_addr, size); #endif - free_end = (char *)free_addr + size; - left = (char *)block_p->mb_bounds_p - (char *)free_end; - } - else { - - if (bit_c < min_bit_free_next) { - mp_p->mp_free[bit_c] = NULL; - /* calculate the number of left over bytes */ - left = bits_to_size(bit_c) - size; - } - else if (bit_c < min_bit_free_next) { - /* grab the next pointer from the freed address into our list */ - memcpy(mp_p->mp_free + bit_c, free_addr, sizeof(void *)); - /* calculate the number of left over bytes */ - left = bits_to_size(bit_c) - size; - } - else { - /* grab the free structure from the address */ - memcpy(&free_pnt, free_addr, sizeof(free_pnt)); - mp_p->mp_free[bit_c] = free_pnt.mf_next_p; - - /* are we are splitting up a multiblock chunk into fewer blocks? */ - if (PAGES_IN_SIZE(mp_p, free_pnt.mf_size) > PAGES_IN_SIZE(mp_p, size)) { - ret = split_block(mp_p, free_addr, size); - if (ret != MPOOL_ERROR_NONE) { - SET_POINTER(error_p, ret); - return NULL; + free_end = (char *)free_addr + size; + left = (char *)block_p->mb_bounds_p - (char *)free_end; } - /* left over memory was taken care of in split_block */ - left = 0; - } - else { - /* calculate the number of left over bytes */ - left = free_pnt.mf_size - size; - } - } + else { + + if (bit_c < min_bit_free_next) { + mp_p->mp_free[bit_c] = NULL; + /* calculate the number of left over bytes */ + left = bits_to_size(bit_c) - size; + } + else if (bit_c < min_bit_free_next) { + /* grab the next pointer from the freed address into our list */ + memcpy(mp_p->mp_free + bit_c, free_addr, sizeof(void *)); + /* calculate the number of left over bytes */ + left = bits_to_size(bit_c) - size; + } + else { + /* grab the free structure from the address */ + memcpy(&free_pnt, free_addr, sizeof(free_pnt)); + mp_p->mp_free[bit_c] = free_pnt.mf_next_p; + + /* are we are splitting up a multiblock chunk into fewer blocks? */ + if (PAGES_IN_SIZE(mp_p, free_pnt.mf_size) > PAGES_IN_SIZE(mp_p, size)) { + ret = split_block(mp_p, free_addr, size); + if (ret != MPOOL_ERROR_NONE) { + SET_POINTER(error_p, ret); + return NULL; + } + /* left over memory was taken care of in split_block */ + left = 0; + } + else { + /* calculate the number of left over bytes */ + left = free_pnt.mf_size - size; + } + } #ifdef DEBUG - (void)printf("found a free block at %lx of %lu bytes\n", - (long)free_addr, left + size); + (void)printf("found a free block at %lx of %lu bytes\n", + (long)free_addr, left + size); #endif - free_end = (char *)free_addr + size; - } + free_end = (char *)free_addr + size; + } - /* - * If we have memory left over then we free it so someone else can - * use it. We do not free the space if we just allocated a - * multi-block chunk because we need to have every allocation easily - * find the start of the block. Every user address % page-size - * should take us to the start of the block. - */ - if (left > 0 && size <= MAX_BLOCK_USER_MEMORY(mp_p)) { - /* free the rest of the block */ - ret = free_pointer(mp_p, free_end, left); - if (ret != MPOOL_ERROR_NONE) { - SET_POINTER(error_p, ret); - return NULL; - } - } + /* + * If we have memory left over then we free it so someone else can + * use it. We do not free the space if we just allocated a + * multi-block chunk because we need to have every allocation easily + * find the start of the block. Every user address % page-size + * should take us to the start of the block. + */ + if (left > 0 && size <= MAX_BLOCK_USER_MEMORY(mp_p)) { + /* free the rest of the block */ + ret = free_pointer(mp_p, free_end, left); + if (ret != MPOOL_ERROR_NONE) { + SET_POINTER(error_p, ret); + return NULL; + } + } - /* update our bounds */ - if (free_addr > mp_p->mp_bounds_p) { - mp_p->mp_bounds_p = free_addr; - } - else if (free_addr < mp_p->mp_min_p) { - mp_p->mp_min_p = free_addr; - } + /* update our bounds */ + if (free_addr > mp_p->mp_bounds_p) { + mp_p->mp_bounds_p = free_addr; + } + else if (free_addr < mp_p->mp_min_p) { + mp_p->mp_min_p = free_addr; + } - return free_addr; + return free_addr; } /* @@ -742,46 +742,46 @@ static void *get_space(mpool_t *mp_p, const unsigned long byte_size, * a mpool error code. */ static void *alloc_mem(mpool_t *mp_p, const unsigned long byte_size, - int *error_p) + int *error_p) { - unsigned long size, fence; - void *addr; + unsigned long size, fence; + void *addr; - /* make sure we have enough bytes */ - if (byte_size < MIN_ALLOCATION) { - size = MIN_ALLOCATION; - } - else { - size = byte_size; - } + /* make sure we have enough bytes */ + if (byte_size < MIN_ALLOCATION) { + size = MIN_ALLOCATION; + } + else { + size = byte_size; + } - if (BIT_IS_SET(mp_p->mp_flags, MPOOL_FLAG_NO_FREE)) { - fence = 0; - } - else { - fence = FENCE_SIZE; - } + if (BIT_IS_SET(mp_p->mp_flags, MPOOL_FLAG_NO_FREE)) { + fence = 0; + } + else { + fence = FENCE_SIZE; + } - /* get our free space + the space for the fence post */ - addr = get_space(mp_p, size + fence, error_p); - if (addr == NULL) { - /* error_p set in get_space */ - return NULL; - } + /* get our free space + the space for the fence post */ + addr = get_space(mp_p, size + fence, error_p); + if (addr == NULL) { + /* error_p set in get_space */ + return NULL; + } - if (! BIT_IS_SET(mp_p->mp_flags, MPOOL_FLAG_NO_FREE)) { - write_magic((char *)addr + size); - } + if (! BIT_IS_SET(mp_p->mp_flags, MPOOL_FLAG_NO_FREE)) { + write_magic((char *)addr + size); + } - /* maintain our stats */ - mp_p->mp_alloc_c++; - mp_p->mp_user_alloc += size; - if (mp_p->mp_user_alloc > mp_p->mp_max_alloc) { - mp_p->mp_max_alloc = mp_p->mp_user_alloc; - } + /* maintain our stats */ + mp_p->mp_alloc_c++; + mp_p->mp_user_alloc += size; + if (mp_p->mp_user_alloc > mp_p->mp_max_alloc) { + mp_p->mp_max_alloc = mp_p->mp_user_alloc; + } - SET_POINTER(error_p, MPOOL_ERROR_NONE); - return addr; + SET_POINTER(error_p, MPOOL_ERROR_NONE); + return addr; } /* @@ -808,54 +808,54 @@ static void *alloc_mem(mpool_t *mp_p, const unsigned long byte_size, */ static int free_mem(mpool_t *mp_p, void *addr, const unsigned long size) { - unsigned long old_size, fence; - int ret; - mpool_block_t *block_p; + unsigned long old_size, fence; + int ret; + mpool_block_t *block_p; - /* - * If the size is larger than a block then the allocation must be at - * the front of the block. - */ - if (size > MAX_BLOCK_USER_MEMORY(mp_p)) { - block_p = (mpool_block_t *)((char *)addr - sizeof(mpool_block_t)); - if (block_p->mb_magic != BLOCK_MAGIC - || block_p->mb_magic2 != BLOCK_MAGIC) { - return MPOOL_ERROR_POOL_OVER; - } - } + /* + * If the size is larger than a block then the allocation must be at + * the front of the block. + */ + if (size > MAX_BLOCK_USER_MEMORY(mp_p)) { + block_p = (mpool_block_t *)((char *)addr - sizeof(mpool_block_t)); + if (block_p->mb_magic != BLOCK_MAGIC + || block_p->mb_magic2 != BLOCK_MAGIC) { + return MPOOL_ERROR_POOL_OVER; + } + } - /* make sure we have enough bytes */ - if (size < MIN_ALLOCATION) { - old_size = MIN_ALLOCATION; - } - else { - old_size = size; - } + /* make sure we have enough bytes */ + if (size < MIN_ALLOCATION) { + old_size = MIN_ALLOCATION; + } + else { + old_size = size; + } - /* if we are packing the pool smaller */ - if (BIT_IS_SET(mp_p->mp_flags, MPOOL_FLAG_NO_FREE)) { - fence = 0; - } - else { - /* find the user's magic numbers if they were written */ - ret = check_magic(addr, old_size); - if (ret != MPOOL_ERROR_NONE) { - return ret; - } - fence = FENCE_SIZE; - } + /* if we are packing the pool smaller */ + if (BIT_IS_SET(mp_p->mp_flags, MPOOL_FLAG_NO_FREE)) { + fence = 0; + } + else { + /* find the user's magic numbers if they were written */ + ret = check_magic(addr, old_size); + if (ret != MPOOL_ERROR_NONE) { + return ret; + } + fence = FENCE_SIZE; + } - /* now we free the pointer */ - ret = free_pointer(mp_p, addr, old_size + fence); - if (ret != MPOOL_ERROR_NONE) { - return ret; - } - mp_p->mp_user_alloc -= old_size; + /* now we free the pointer */ + ret = free_pointer(mp_p, addr, old_size + fence); + if (ret != MPOOL_ERROR_NONE) { + return ret; + } + mp_p->mp_user_alloc -= old_size; - /* adjust our stats */ - mp_p->mp_alloc_c--; + /* adjust our stats */ + mp_p->mp_alloc_c--; - return MPOOL_ERROR_NONE; + return MPOOL_ERROR_NONE; } /***************************** exported routines *****************************/ @@ -889,147 +889,147 @@ static int free_mem(mpool_t *mp_p, void *addr, const unsigned long size) * a mpool error code. */ mpool_t *mpool_open(const unsigned int flags, const unsigned int page_size, - void *start_addr, int *error_p) + void *start_addr, int *error_p) { - mpool_block_t *block_p; - int page_n, ret; - mpool_t mp, *mp_p; - void *free_addr; + mpool_block_t *block_p; + int page_n, ret; + mpool_t mp, *mp_p; + void *free_addr; - if (! enabled_b) { - startup(); - } + if (! enabled_b) { + startup(); + } - /* zero our temp struct */ - memset(&mp, 0, sizeof(mp)); + /* zero our temp struct */ + memset(&mp, 0, sizeof(mp)); - mp.mp_magic = MPOOL_MAGIC; - mp.mp_flags = flags; - mp.mp_alloc_c = 0; - mp.mp_user_alloc = 0; - mp.mp_max_alloc = 0; - mp.mp_page_c = 0; - /* mp.mp_page_size set below */ - /* mp.mp_blocks_bit_n set below */ - /* mp.mp_fd set below */ - /* mp.mp_top set below */ - /* mp.mp_addr set below */ - mp.mp_log_func = NULL; - mp.mp_min_p = NULL; - mp.mp_bounds_p = NULL; - mp.mp_first_p = NULL; - mp.mp_last_p = NULL; - mp.mp_magic2 = MPOOL_MAGIC; + mp.mp_magic = MPOOL_MAGIC; + mp.mp_flags = flags; + mp.mp_alloc_c = 0; + mp.mp_user_alloc = 0; + mp.mp_max_alloc = 0; + mp.mp_page_c = 0; + /* mp.mp_page_size set below */ + /* mp.mp_blocks_bit_n set below */ + /* mp.mp_fd set below */ + /* mp.mp_top set below */ + /* mp.mp_addr set below */ + mp.mp_log_func = NULL; + mp.mp_min_p = NULL; + mp.mp_bounds_p = NULL; + mp.mp_first_p = NULL; + mp.mp_last_p = NULL; + mp.mp_magic2 = MPOOL_MAGIC; - /* get and sanity check our page size */ - if (page_size > 0) { - mp.mp_page_size = page_size; - if (mp.mp_page_size % getpagesize() != 0) { - SET_POINTER(error_p, MPOOL_ERROR_ARG_INVALID); - return NULL; - } - } - else { - mp.mp_page_size = getpagesize() * DEFAULT_PAGE_MULT; - if (mp.mp_page_size % 1024 != 0) { - SET_POINTER(error_p, MPOOL_ERROR_PAGE_SIZE); - return NULL; - } - } + /* get and sanity check our page size */ + if (page_size > 0) { + mp.mp_page_size = page_size; + if (mp.mp_page_size % getpagesize() != 0) { + SET_POINTER(error_p, MPOOL_ERROR_ARG_INVALID); + return NULL; + } + } + else { + mp.mp_page_size = getpagesize() * DEFAULT_PAGE_MULT; + if (mp.mp_page_size % 1024 != 0) { + SET_POINTER(error_p, MPOOL_ERROR_PAGE_SIZE); + return NULL; + } + } - if (BIT_IS_SET(flags, MPOOL_FLAG_USE_SBRK)) { - mp.mp_fd = -1; - mp.mp_addr = NULL; - mp.mp_top = 0; - } - else { - /* open dev-zero for our mmaping */ - mp.mp_fd = open("/dev/zero", O_RDWR, 0); - if (mp.mp_fd < 0) { - SET_POINTER(error_p, MPOOL_ERROR_OPEN_ZERO); - return NULL; - } - mp.mp_addr = start_addr; - /* we start at the front of the file */ - mp.mp_top = 0; - } + if (BIT_IS_SET(flags, MPOOL_FLAG_USE_SBRK)) { + mp.mp_fd = -1; + mp.mp_addr = NULL; + mp.mp_top = 0; + } + else { + /* open dev-zero for our mmaping */ + mp.mp_fd = open("/dev/zero", O_RDWR, 0); + if (mp.mp_fd < 0) { + SET_POINTER(error_p, MPOOL_ERROR_OPEN_ZERO); + return NULL; + } + mp.mp_addr = start_addr; + /* we start at the front of the file */ + mp.mp_top = 0; + } - /* - * Find out how many pages we need for our mpool structure. - * - * NOTE: this adds possibly unneeded space for mpool_block_t which - * may not be in this block. - */ - page_n = PAGES_IN_SIZE(&mp, sizeof(mpool_t)); + /* + * Find out how many pages we need for our mpool structure. + * + * NOTE: this adds possibly unneeded space for mpool_block_t which + * may not be in this block. + */ + page_n = PAGES_IN_SIZE(&mp, sizeof(mpool_t)); - /* now allocate us space for the actual struct */ - mp_p = alloc_pages(&mp, page_n, error_p); - if (mp_p == NULL) { - if (mp.mp_fd >= 0) { - (void)close(mp.mp_fd); - mp.mp_fd = -1; - } - return NULL; - } + /* now allocate us space for the actual struct */ + mp_p = alloc_pages(&mp, page_n, error_p); + if (mp_p == NULL) { + if (mp.mp_fd >= 0) { + (void)close(mp.mp_fd); + mp.mp_fd = -1; + } + return NULL; + } - /* - * NOTE: we do not normally free the rest of the block here because - * we want to lesson the chance of an allocation overwriting the - * main structure. - */ - if (BIT_IS_SET(flags, MPOOL_FLAG_HEAVY_PACKING)) { + /* + * NOTE: we do not normally free the rest of the block here because + * we want to lesson the chance of an allocation overwriting the + * main structure. + */ + if (BIT_IS_SET(flags, MPOOL_FLAG_HEAVY_PACKING)) { - /* we add a block header to the front of the block */ - block_p = (mpool_block_t *)mp_p; + /* we add a block header to the front of the block */ + block_p = (mpool_block_t *)mp_p; - /* init the block header */ - block_p->mb_magic = BLOCK_MAGIC; - block_p->mb_bounds_p = (char *)block_p + SIZE_OF_PAGES(&mp, page_n); - block_p->mb_next_p = NULL; - block_p->mb_magic2 = BLOCK_MAGIC; + /* init the block header */ + block_p->mb_magic = BLOCK_MAGIC; + block_p->mb_bounds_p = (char *)block_p + SIZE_OF_PAGES(&mp, page_n); + block_p->mb_next_p = NULL; + block_p->mb_magic2 = BLOCK_MAGIC; - /* the mpool pointer is then the 2nd thing in the block */ - mp_p = FIRST_ADDR_IN_BLOCK(block_p); - free_addr = (char *)mp_p + sizeof(mpool_t); + /* the mpool pointer is then the 2nd thing in the block */ + mp_p = FIRST_ADDR_IN_BLOCK(block_p); + free_addr = (char *)mp_p + sizeof(mpool_t); - /* free the rest of the block */ - ret = free_pointer(&mp, free_addr, - (char *)block_p->mb_bounds_p - (char *)free_addr); - if (ret != MPOOL_ERROR_NONE) { - if (mp.mp_fd >= 0) { - (void)close(mp.mp_fd); - mp.mp_fd = -1; - } - /* NOTE: after this line mp_p will be invalid */ - (void)free_pages(block_p, SIZE_OF_PAGES(&mp, page_n), - BIT_IS_SET(flags, MPOOL_FLAG_USE_SBRK)); - SET_POINTER(error_p, ret); - return NULL; - } + /* free the rest of the block */ + ret = free_pointer(&mp, free_addr, + (char *)block_p->mb_bounds_p - (char *)free_addr); + if (ret != MPOOL_ERROR_NONE) { + if (mp.mp_fd >= 0) { + (void)close(mp.mp_fd); + mp.mp_fd = -1; + } + /* NOTE: after this line mp_p will be invalid */ + (void)free_pages(block_p, SIZE_OF_PAGES(&mp, page_n), + BIT_IS_SET(flags, MPOOL_FLAG_USE_SBRK)); + SET_POINTER(error_p, ret); + return NULL; + } - /* - * NOTE: if we are HEAVY_PACKING then the 1st block with the mpool - * header is not on the block linked list. - */ + /* + * NOTE: if we are HEAVY_PACKING then the 1st block with the mpool + * header is not on the block linked list. + */ - /* now copy our tmp structure into our new memory area */ - memcpy(mp_p, &mp, sizeof(mpool_t)); + /* now copy our tmp structure into our new memory area */ + memcpy(mp_p, &mp, sizeof(mpool_t)); - /* we setup min/max to our current address which is as good as any */ - mp_p->mp_min_p = block_p; - mp_p->mp_bounds_p = block_p->mb_bounds_p; - } - else { - /* now copy our tmp structure into our new memory area */ - memcpy(mp_p, &mp, sizeof(mpool_t)); + /* we setup min/max to our current address which is as good as any */ + mp_p->mp_min_p = block_p; + mp_p->mp_bounds_p = block_p->mb_bounds_p; + } + else { + /* now copy our tmp structure into our new memory area */ + memcpy(mp_p, &mp, sizeof(mpool_t)); - /* we setup min/max to our current address which is as good as any */ - mp_p->mp_min_p = mp_p; - mp_p->mp_bounds_p = (char *)mp_p + SIZE_OF_PAGES(mp_p, page_n); - } + /* we setup min/max to our current address which is as good as any */ + mp_p->mp_min_p = mp_p; + mp_p->mp_bounds_p = (char *)mp_p + SIZE_OF_PAGES(mp_p, page_n); + } - SET_POINTER(error_p, MPOOL_ERROR_NONE); - return mp_p; + SET_POINTER(error_p, MPOOL_ERROR_NONE); + return mp_p; } /* @@ -1052,75 +1052,75 @@ mpool_t *mpool_open(const unsigned int flags, const unsigned int page_size, */ int mpool_close(mpool_t *mp_p) { - mpool_block_t *block_p, *next_p; - void *addr; - unsigned long size; - int ret, final = MPOOL_ERROR_NONE; + mpool_block_t *block_p, *next_p; + void *addr; + unsigned long size; + int ret, final = MPOOL_ERROR_NONE; - /* special case, just return no-error */ - if (mp_p == NULL) { - return MPOOL_ERROR_ARG_NULL; - } - if (mp_p->mp_magic != MPOOL_MAGIC) { - return MPOOL_ERROR_PNT; - } - if (mp_p->mp_magic2 != MPOOL_MAGIC) { - return MPOOL_ERROR_POOL_OVER; - } + /* special case, just return no-error */ + if (mp_p == NULL) { + return MPOOL_ERROR_ARG_NULL; + } + if (mp_p->mp_magic != MPOOL_MAGIC) { + return MPOOL_ERROR_PNT; + } + if (mp_p->mp_magic2 != MPOOL_MAGIC) { + return MPOOL_ERROR_POOL_OVER; + } - if (mp_p->mp_log_func != NULL) { - mp_p->mp_log_func(mp_p, MPOOL_FUNC_CLOSE, 0, 0, NULL, NULL, 0); - } + if (mp_p->mp_log_func != NULL) { + mp_p->mp_log_func(mp_p, MPOOL_FUNC_CLOSE, 0, 0, NULL, NULL, 0); + } - /* - * NOTE: if we are HEAVY_PACKING then the 1st block with the mpool - * header is not on the linked list. - */ + /* + * NOTE: if we are HEAVY_PACKING then the 1st block with the mpool + * header is not on the linked list. + */ - /* free/invalidate the blocks */ - for (block_p = mp_p->mp_first_p; block_p != NULL; block_p = next_p) { - if (block_p->mb_magic != BLOCK_MAGIC - || block_p->mb_magic2 != BLOCK_MAGIC) { - final = MPOOL_ERROR_POOL_OVER; - break; - } - block_p->mb_magic = 0; - block_p->mb_magic2 = 0; - /* record the next pointer because it might be invalidated below */ - next_p = block_p->mb_next_p; - ret = free_pages(block_p, (char *)block_p->mb_bounds_p - (char *)block_p, - BIT_IS_SET(mp_p->mp_flags, MPOOL_FLAG_USE_SBRK)); - if (ret != MPOOL_ERROR_NONE) { - final = ret; - } - } + /* free/invalidate the blocks */ + for (block_p = mp_p->mp_first_p; block_p != NULL; block_p = next_p) { + if (block_p->mb_magic != BLOCK_MAGIC + || block_p->mb_magic2 != BLOCK_MAGIC) { + final = MPOOL_ERROR_POOL_OVER; + break; + } + block_p->mb_magic = 0; + block_p->mb_magic2 = 0; + /* record the next pointer because it might be invalidated below */ + next_p = block_p->mb_next_p; + ret = free_pages(block_p, (char *)block_p->mb_bounds_p - (char *)block_p, + BIT_IS_SET(mp_p->mp_flags, MPOOL_FLAG_USE_SBRK)); + if (ret != MPOOL_ERROR_NONE) { + final = ret; + } + } - /* close /dev/zero if necessary */ - if (mp_p->mp_fd >= 0) { - (void)close(mp_p->mp_fd); - mp_p->mp_fd = -1; - } + /* close /dev/zero if necessary */ + if (mp_p->mp_fd >= 0) { + (void)close(mp_p->mp_fd); + mp_p->mp_fd = -1; + } - /* invalidate the mpool before we ditch it */ - mp_p->mp_magic = 0; - mp_p->mp_magic2 = 0; + /* invalidate the mpool before we ditch it */ + mp_p->mp_magic = 0; + mp_p->mp_magic2 = 0; - /* last we munmap the mpool pointer itself */ - if (! BIT_IS_SET(mp_p->mp_flags, MPOOL_FLAG_USE_SBRK)) { + /* last we munmap the mpool pointer itself */ + if (! BIT_IS_SET(mp_p->mp_flags, MPOOL_FLAG_USE_SBRK)) { - /* if we are heavy packing then we need to free the 1st block later */ - if (BIT_IS_SET(mp_p->mp_flags, MPOOL_FLAG_HEAVY_PACKING)) { - addr = (char *)mp_p - sizeof(mpool_block_t); - } - else { - addr = mp_p; - } - size = SIZE_OF_PAGES(mp_p, PAGES_IN_SIZE(mp_p, sizeof(mpool_t))); + /* if we are heavy packing then we need to free the 1st block later */ + if (BIT_IS_SET(mp_p->mp_flags, MPOOL_FLAG_HEAVY_PACKING)) { + addr = (char *)mp_p - sizeof(mpool_block_t); + } + else { + addr = mp_p; + } + size = SIZE_OF_PAGES(mp_p, PAGES_IN_SIZE(mp_p, sizeof(mpool_t))); - (void)munmap((caddr_t)addr, size); - } + (void)munmap((caddr_t)addr, size); + } - return final; + return final; } /* @@ -1142,50 +1142,50 @@ int mpool_close(mpool_t *mp_p) */ int mpool_clear(mpool_t *mp_p) { - mpool_block_t *block_p; - int final = MPOOL_ERROR_NONE, bit_n, ret; - void *first_p; + mpool_block_t *block_p; + int final = MPOOL_ERROR_NONE, bit_n, ret; + void *first_p; - /* special case, just return no-error */ - if (mp_p == NULL) { - return MPOOL_ERROR_ARG_NULL; - } - if (mp_p->mp_magic != MPOOL_MAGIC) { - return MPOOL_ERROR_PNT; - } - if (mp_p->mp_magic2 != MPOOL_MAGIC) { - return MPOOL_ERROR_POOL_OVER; - } + /* special case, just return no-error */ + if (mp_p == NULL) { + return MPOOL_ERROR_ARG_NULL; + } + if (mp_p->mp_magic != MPOOL_MAGIC) { + return MPOOL_ERROR_PNT; + } + if (mp_p->mp_magic2 != MPOOL_MAGIC) { + return MPOOL_ERROR_POOL_OVER; + } - if (mp_p->mp_log_func != NULL) { - mp_p->mp_log_func(mp_p, MPOOL_FUNC_CLEAR, 0, 0, NULL, NULL, 0); - } + if (mp_p->mp_log_func != NULL) { + mp_p->mp_log_func(mp_p, MPOOL_FUNC_CLEAR, 0, 0, NULL, NULL, 0); + } - /* reset all of our free lists */ - for (bit_n = 0; bit_n <= MAX_BITS; bit_n++) { - mp_p->mp_free[bit_n] = NULL; - } + /* reset all of our free lists */ + for (bit_n = 0; bit_n <= MAX_BITS; bit_n++) { + mp_p->mp_free[bit_n] = NULL; + } - /* free the blocks */ - for (block_p = mp_p->mp_first_p; - block_p != NULL; - block_p = block_p->mb_next_p) { - if (block_p->mb_magic != BLOCK_MAGIC - || block_p->mb_magic2 != BLOCK_MAGIC) { - final = MPOOL_ERROR_POOL_OVER; - break; - } + /* free the blocks */ + for (block_p = mp_p->mp_first_p; + block_p != NULL; + block_p = block_p->mb_next_p) { + if (block_p->mb_magic != BLOCK_MAGIC + || block_p->mb_magic2 != BLOCK_MAGIC) { + final = MPOOL_ERROR_POOL_OVER; + break; + } - first_p = FIRST_ADDR_IN_BLOCK(block_p); + first_p = FIRST_ADDR_IN_BLOCK(block_p); - /* free the memory */ - ret = free_pointer(mp_p, first_p, MEMORY_IN_BLOCK(block_p)); - if (ret != MPOOL_ERROR_NONE) { - final = ret; - } - } + /* free the memory */ + ret = free_pointer(mp_p, first_p, MEMORY_IN_BLOCK(block_p)); + if (ret != MPOOL_ERROR_NONE) { + final = ret; + } + } - return final; + return final; } /* @@ -1212,44 +1212,44 @@ int mpool_clear(mpool_t *mp_p) * a mpool error code. */ void *mpool_alloc(mpool_t *mp_p, const unsigned long byte_size, - int *error_p) + int *error_p) { - void *addr; + void *addr; - if (mp_p == NULL) { - /* special case -- do a normal malloc */ - addr = (void *)malloc(byte_size); - if (addr == NULL) { - SET_POINTER(error_p, MPOOL_ERROR_ALLOC); - return NULL; - } - else { - SET_POINTER(error_p, MPOOL_ERROR_NONE); - return addr; - } - } + if (mp_p == NULL) { + /* special case -- do a normal malloc */ + addr = (void *)malloc(byte_size); + if (addr == NULL) { + SET_POINTER(error_p, MPOOL_ERROR_ALLOC); + return NULL; + } + else { + SET_POINTER(error_p, MPOOL_ERROR_NONE); + return addr; + } + } - if (mp_p->mp_magic != MPOOL_MAGIC) { - SET_POINTER(error_p, MPOOL_ERROR_PNT); - return NULL; - } - if (mp_p->mp_magic2 != MPOOL_MAGIC) { - SET_POINTER(error_p, MPOOL_ERROR_POOL_OVER); - return NULL; - } + if (mp_p->mp_magic != MPOOL_MAGIC) { + SET_POINTER(error_p, MPOOL_ERROR_PNT); + return NULL; + } + if (mp_p->mp_magic2 != MPOOL_MAGIC) { + SET_POINTER(error_p, MPOOL_ERROR_POOL_OVER); + return NULL; + } - if (byte_size == 0) { - SET_POINTER(error_p, MPOOL_ERROR_ARG_INVALID); - return NULL; - } + if (byte_size == 0) { + SET_POINTER(error_p, MPOOL_ERROR_ARG_INVALID); + return NULL; + } - addr = alloc_mem(mp_p, byte_size, error_p); + addr = alloc_mem(mp_p, byte_size, error_p); - if (mp_p->mp_log_func != NULL) { - mp_p->mp_log_func(mp_p, MPOOL_FUNC_ALLOC, byte_size, 0, addr, NULL, 0); - } + if (mp_p->mp_log_func != NULL) { + mp_p->mp_log_func(mp_p, MPOOL_FUNC_ALLOC, byte_size, 0, addr, NULL, 0); + } - return addr; + return addr; } /* @@ -1279,50 +1279,50 @@ void *mpool_alloc(mpool_t *mp_p, const unsigned long byte_size, * a mpool error code. */ void *mpool_calloc(mpool_t *mp_p, const unsigned long ele_n, - const unsigned long ele_size, int *error_p) + const unsigned long ele_size, int *error_p) { - void *addr; - unsigned long byte_size; + void *addr; + unsigned long byte_size; - if (mp_p == NULL) { - /* special case -- do a normal calloc */ - addr = (void *)calloc(ele_n, ele_size); - if (addr == NULL) { - SET_POINTER(error_p, MPOOL_ERROR_ALLOC); - return NULL; - } - else { - SET_POINTER(error_p, MPOOL_ERROR_NONE); - return addr; - } + if (mp_p == NULL) { + /* special case -- do a normal calloc */ + addr = (void *)calloc(ele_n, ele_size); + if (addr == NULL) { + SET_POINTER(error_p, MPOOL_ERROR_ALLOC); + return NULL; + } + else { + SET_POINTER(error_p, MPOOL_ERROR_NONE); + return addr; + } - } - if (mp_p->mp_magic != MPOOL_MAGIC) { - SET_POINTER(error_p, MPOOL_ERROR_PNT); - return NULL; - } - if (mp_p->mp_magic2 != MPOOL_MAGIC) { - SET_POINTER(error_p, MPOOL_ERROR_POOL_OVER); - return NULL; - } + } + if (mp_p->mp_magic != MPOOL_MAGIC) { + SET_POINTER(error_p, MPOOL_ERROR_PNT); + return NULL; + } + if (mp_p->mp_magic2 != MPOOL_MAGIC) { + SET_POINTER(error_p, MPOOL_ERROR_POOL_OVER); + return NULL; + } - if (ele_n == 0 || ele_size == 0) { - SET_POINTER(error_p, MPOOL_ERROR_ARG_INVALID); - return NULL; - } + if (ele_n == 0 || ele_size == 0) { + SET_POINTER(error_p, MPOOL_ERROR_ARG_INVALID); + return NULL; + } - byte_size = ele_n * ele_size; - addr = alloc_mem(mp_p, byte_size, error_p); - if (addr != NULL) { - memset(addr, 0, byte_size); - } + byte_size = ele_n * ele_size; + addr = alloc_mem(mp_p, byte_size, error_p); + if (addr != NULL) { + memset(addr, 0, byte_size); + } - if (mp_p->mp_log_func != NULL) { - mp_p->mp_log_func(mp_p, MPOOL_FUNC_CALLOC, ele_size, ele_n, addr, NULL, 0); - } + if (mp_p->mp_log_func != NULL) { + mp_p->mp_log_func(mp_p, MPOOL_FUNC_CALLOC, ele_size, ele_n, addr, NULL, 0); + } - /* NOTE: error_p set above */ - return addr; + /* NOTE: error_p set above */ + return addr; } /* @@ -1349,30 +1349,30 @@ void *mpool_calloc(mpool_t *mp_p, const unsigned long ele_n, */ int mpool_free(mpool_t *mp_p, void *addr, const unsigned long size) { - if (mp_p == NULL) { - /* special case -- do a normal free */ - free(addr); - return MPOOL_ERROR_NONE; - } - if (mp_p->mp_magic != MPOOL_MAGIC) { - return MPOOL_ERROR_PNT; - } - if (mp_p->mp_magic2 != MPOOL_MAGIC) { - return MPOOL_ERROR_POOL_OVER; - } + if (mp_p == NULL) { + /* special case -- do a normal free */ + free(addr); + return MPOOL_ERROR_NONE; + } + if (mp_p->mp_magic != MPOOL_MAGIC) { + return MPOOL_ERROR_PNT; + } + if (mp_p->mp_magic2 != MPOOL_MAGIC) { + return MPOOL_ERROR_POOL_OVER; + } - if (mp_p->mp_log_func != NULL) { - mp_p->mp_log_func(mp_p, MPOOL_FUNC_FREE, size, 0, NULL, addr, 0); - } + if (mp_p->mp_log_func != NULL) { + mp_p->mp_log_func(mp_p, MPOOL_FUNC_FREE, size, 0, NULL, addr, 0); + } - if (addr == NULL) { - return MPOOL_ERROR_ARG_NULL; - } - if (size == 0) { - return MPOOL_ERROR_ARG_INVALID; - } + if (addr == NULL) { + return MPOOL_ERROR_ARG_NULL; + } + if (size == 0) { + return MPOOL_ERROR_ARG_INVALID; + } - return free_mem(mp_p, addr, size); + return free_mem(mp_p, addr, size); } /* @@ -1407,126 +1407,126 @@ int mpool_free(mpool_t *mp_p, void *addr, const unsigned long size) * a mpool error code. */ void *mpool_resize(mpool_t *mp_p, void *old_addr, - const unsigned long old_byte_size, - const unsigned long new_byte_size, - int *error_p) + const unsigned long old_byte_size, + const unsigned long new_byte_size, + int *error_p) { - unsigned long copy_size, new_size, old_size, fence; - void *new_addr; - mpool_block_t *block_p; - int ret; + unsigned long copy_size, new_size, old_size, fence; + void *new_addr; + mpool_block_t *block_p; + int ret; - if (mp_p == NULL) { - /* special case -- do a normal realloc */ - new_addr = (void *)realloc(old_addr, new_byte_size); - if (new_addr == NULL) { - SET_POINTER(error_p, MPOOL_ERROR_ALLOC); - return NULL; - } - else { - SET_POINTER(error_p, MPOOL_ERROR_NONE); - return new_addr; - } - } + if (mp_p == NULL) { + /* special case -- do a normal realloc */ + new_addr = (void *)realloc(old_addr, new_byte_size); + if (new_addr == NULL) { + SET_POINTER(error_p, MPOOL_ERROR_ALLOC); + return NULL; + } + else { + SET_POINTER(error_p, MPOOL_ERROR_NONE); + return new_addr; + } + } - if (mp_p->mp_magic != MPOOL_MAGIC) { - SET_POINTER(error_p, MPOOL_ERROR_PNT); - return NULL; - } - if (mp_p->mp_magic2 != MPOOL_MAGIC) { - SET_POINTER(error_p, MPOOL_ERROR_POOL_OVER); - return NULL; - } + if (mp_p->mp_magic != MPOOL_MAGIC) { + SET_POINTER(error_p, MPOOL_ERROR_PNT); + return NULL; + } + if (mp_p->mp_magic2 != MPOOL_MAGIC) { + SET_POINTER(error_p, MPOOL_ERROR_POOL_OVER); + return NULL; + } - if (old_addr == NULL) { - SET_POINTER(error_p, MPOOL_ERROR_ARG_NULL); - return NULL; - } - if (old_byte_size == 0) { - SET_POINTER(error_p, MPOOL_ERROR_ARG_INVALID); - return NULL; - } + if (old_addr == NULL) { + SET_POINTER(error_p, MPOOL_ERROR_ARG_NULL); + return NULL; + } + if (old_byte_size == 0) { + SET_POINTER(error_p, MPOOL_ERROR_ARG_INVALID); + return NULL; + } - /* - * If the size is larger than a block then the allocation must be at - * the front of the block. - */ - if (old_byte_size > MAX_BLOCK_USER_MEMORY(mp_p)) { - block_p = (mpool_block_t *)((char *)old_addr - sizeof(mpool_block_t)); - if (block_p->mb_magic != BLOCK_MAGIC - || block_p->mb_magic2 != BLOCK_MAGIC) { - SET_POINTER(error_p, MPOOL_ERROR_POOL_OVER); - return NULL; - } - } + /* + * If the size is larger than a block then the allocation must be at + * the front of the block. + */ + if (old_byte_size > MAX_BLOCK_USER_MEMORY(mp_p)) { + block_p = (mpool_block_t *)((char *)old_addr - sizeof(mpool_block_t)); + if (block_p->mb_magic != BLOCK_MAGIC + || block_p->mb_magic2 != BLOCK_MAGIC) { + SET_POINTER(error_p, MPOOL_ERROR_POOL_OVER); + return NULL; + } + } - /* make sure we have enough bytes */ - if (old_byte_size < MIN_ALLOCATION) { - old_size = MIN_ALLOCATION; - } - else { - old_size = old_byte_size; - } + /* make sure we have enough bytes */ + if (old_byte_size < MIN_ALLOCATION) { + old_size = MIN_ALLOCATION; + } + else { + old_size = old_byte_size; + } - /* verify that the size matches exactly if we can */ - if (BIT_IS_SET(mp_p->mp_flags, MPOOL_FLAG_NO_FREE)) { - fence = 0; - } - else if (old_size > 0) { - ret = check_magic(old_addr, old_size); - if (ret != MPOOL_ERROR_NONE) { - SET_POINTER(error_p, ret); - return NULL; - } - fence = FENCE_SIZE; - } + /* verify that the size matches exactly if we can */ + if (BIT_IS_SET(mp_p->mp_flags, MPOOL_FLAG_NO_FREE)) { + fence = 0; + } + else if (old_size > 0) { + ret = check_magic(old_addr, old_size); + if (ret != MPOOL_ERROR_NONE) { + SET_POINTER(error_p, ret); + return NULL; + } + fence = FENCE_SIZE; + } - /* make sure we have enough bytes */ - if (new_byte_size < MIN_ALLOCATION) { - new_size = MIN_ALLOCATION; - } - else { - new_size = new_byte_size; - } + /* make sure we have enough bytes */ + if (new_byte_size < MIN_ALLOCATION) { + new_size = MIN_ALLOCATION; + } + else { + new_size = new_byte_size; + } - /* - * NOTE: we could here see if the size is the same or less and then - * use the current memory and free the space above. This is harder - * than it sounds if we are changing the block size of the - * allocation. - */ + /* + * NOTE: we could here see if the size is the same or less and then + * use the current memory and free the space above. This is harder + * than it sounds if we are changing the block size of the + * allocation. + */ - /* we need to get another address */ - new_addr = alloc_mem(mp_p, new_byte_size, error_p); - if (new_addr == NULL) { - /* error_p set in mpool_alloc */ - return NULL; - } + /* we need to get another address */ + new_addr = alloc_mem(mp_p, new_byte_size, error_p); + if (new_addr == NULL) { + /* error_p set in mpool_alloc */ + return NULL; + } - if (new_byte_size > old_byte_size) { - copy_size = old_byte_size; - } - else { - copy_size = new_byte_size; - } - memcpy(new_addr, old_addr, copy_size); + if (new_byte_size > old_byte_size) { + copy_size = old_byte_size; + } + else { + copy_size = new_byte_size; + } + memcpy(new_addr, old_addr, copy_size); - /* free the old address */ - ret = free_mem(mp_p, old_addr, old_byte_size); - if (ret != MPOOL_ERROR_NONE) { - /* if the old free failed, try and free the new address */ - (void)free_mem(mp_p, new_addr, new_byte_size); - SET_POINTER(error_p, ret); - return NULL; - } + /* free the old address */ + ret = free_mem(mp_p, old_addr, old_byte_size); + if (ret != MPOOL_ERROR_NONE) { + /* if the old free failed, try and free the new address */ + (void)free_mem(mp_p, new_addr, new_byte_size); + SET_POINTER(error_p, ret); + return NULL; + } - if (mp_p->mp_log_func != NULL) { - mp_p->mp_log_func(mp_p, MPOOL_FUNC_RESIZE, new_byte_size, - 0, new_addr, old_addr, old_byte_size); - } + if (mp_p->mp_log_func != NULL) { + mp_p->mp_log_func(mp_p, MPOOL_FUNC_RESIZE, new_byte_size, + 0, new_addr, old_addr, old_byte_size); + } - SET_POINTER(error_p, MPOOL_ERROR_NONE); - return new_addr; + SET_POINTER(error_p, MPOOL_ERROR_NONE); + return new_addr; } /* @@ -1564,28 +1564,28 @@ void *mpool_resize(mpool_t *mp_p, void *old_addr, * overhead) used by the pool. */ int mpool_stats(const mpool_t *mp_p, unsigned int *page_size_p, - unsigned long *num_alloced_p, - unsigned long *user_alloced_p, - unsigned long *max_alloced_p, - unsigned long *tot_alloced_p) + unsigned long *num_alloced_p, + unsigned long *user_alloced_p, + unsigned long *max_alloced_p, + unsigned long *tot_alloced_p) { - if (mp_p == NULL) { - return MPOOL_ERROR_ARG_NULL; - } - if (mp_p->mp_magic != MPOOL_MAGIC) { - return MPOOL_ERROR_PNT; - } - if (mp_p->mp_magic2 != MPOOL_MAGIC) { - return MPOOL_ERROR_POOL_OVER; - } + if (mp_p == NULL) { + return MPOOL_ERROR_ARG_NULL; + } + if (mp_p->mp_magic != MPOOL_MAGIC) { + return MPOOL_ERROR_PNT; + } + if (mp_p->mp_magic2 != MPOOL_MAGIC) { + return MPOOL_ERROR_POOL_OVER; + } - SET_POINTER(page_size_p, mp_p->mp_page_size); - SET_POINTER(num_alloced_p, mp_p->mp_alloc_c); - SET_POINTER(user_alloced_p, mp_p->mp_user_alloc); - SET_POINTER(max_alloced_p, mp_p->mp_max_alloc); - SET_POINTER(tot_alloced_p, SIZE_OF_PAGES(mp_p, mp_p->mp_page_c)); + SET_POINTER(page_size_p, mp_p->mp_page_size); + SET_POINTER(num_alloced_p, mp_p->mp_alloc_c); + SET_POINTER(user_alloced_p, mp_p->mp_user_alloc); + SET_POINTER(max_alloced_p, mp_p->mp_max_alloc); + SET_POINTER(tot_alloced_p, SIZE_OF_PAGES(mp_p, mp_p->mp_page_c)); - return MPOOL_ERROR_NONE; + return MPOOL_ERROR_NONE; } /* @@ -1611,19 +1611,19 @@ int mpool_stats(const mpool_t *mp_p, unsigned int *page_size_p, */ int mpool_set_log_func(mpool_t *mp_p, mpool_log_func_t log_func) { - if (mp_p == NULL) { - return MPOOL_ERROR_ARG_NULL; - } - if (mp_p->mp_magic != MPOOL_MAGIC) { - return MPOOL_ERROR_PNT; - } - if (mp_p->mp_magic2 != MPOOL_MAGIC) { - return MPOOL_ERROR_POOL_OVER; - } + if (mp_p == NULL) { + return MPOOL_ERROR_ARG_NULL; + } + if (mp_p->mp_magic != MPOOL_MAGIC) { + return MPOOL_ERROR_PNT; + } + if (mp_p->mp_magic2 != MPOOL_MAGIC) { + return MPOOL_ERROR_POOL_OVER; + } - mp_p->mp_log_func = log_func; + mp_p->mp_log_func = log_func; - return MPOOL_ERROR_NONE; + return MPOOL_ERROR_NONE; } /* @@ -1653,28 +1653,28 @@ int mpool_set_log_func(mpool_t *mp_p, mpool_log_func_t log_func) */ int mpool_set_max_pages(mpool_t *mp_p, const unsigned int max_pages) { - if (mp_p == NULL) { - return MPOOL_ERROR_ARG_NULL; - } - if (mp_p->mp_magic != MPOOL_MAGIC) { - return MPOOL_ERROR_PNT; - } - if (mp_p->mp_magic2 != MPOOL_MAGIC) { - return MPOOL_ERROR_POOL_OVER; - } + if (mp_p == NULL) { + return MPOOL_ERROR_ARG_NULL; + } + if (mp_p->mp_magic != MPOOL_MAGIC) { + return MPOOL_ERROR_PNT; + } + if (mp_p->mp_magic2 != MPOOL_MAGIC) { + return MPOOL_ERROR_POOL_OVER; + } - if (BIT_IS_SET(mp_p->mp_flags, MPOOL_FLAG_HEAVY_PACKING)) { - mp_p->mp_max_pages = max_pages; - } - else { - /* - * If we are not heavy-packing the pool then we don't count the - * 1st page allocated which holds the mpool header structure. - */ - mp_p->mp_max_pages = max_pages + 1; - } + if (BIT_IS_SET(mp_p->mp_flags, MPOOL_FLAG_HEAVY_PACKING)) { + mp_p->mp_max_pages = max_pages; + } + else { + /* + * If we are not heavy-packing the pool then we don't count the + * 1st page allocated which holds the mpool header structure. + */ + mp_p->mp_max_pages = max_pages + 1; + } - return MPOOL_ERROR_NONE; + return MPOOL_ERROR_NONE; } /* @@ -1696,73 +1696,85 @@ int mpool_set_max_pages(mpool_t *mp_p, const unsigned int max_pages) */ const char *mpool_strerror(const int error) { - switch (error) { - case MPOOL_ERROR_NONE: - return "no error"; - break; - case MPOOL_ERROR_ARG_NULL: - return "function argument is null"; - break; - case MPOOL_ERROR_ARG_INVALID: - return "function argument is invalid"; - break; - case MPOOL_ERROR_PNT: - return "invalid mpool pointer"; - break; - case MPOOL_ERROR_POOL_OVER: - return "mpool structure was overwritten"; - break; - case MPOOL_ERROR_PAGE_SIZE: - return "could not get system page-size"; - break; - case MPOOL_ERROR_OPEN_ZERO: - return "could not open /dev/zero"; - break; - case MPOOL_ERROR_NO_MEM: - return "no memory available"; - break; - case MPOOL_ERROR_MMAP: - return "problems with mmap"; - break; - case MPOOL_ERROR_SIZE: - return "error processing requested size"; - break; - case MPOOL_ERROR_TOO_BIG: - return "allocation exceeds pool max size"; - break; - case MPOOL_ERROR_MEM: - return "invalid memory address"; - break; - case MPOOL_ERROR_MEM_OVER: - return "memory lower bounds overwritten"; - break; - case MPOOL_ERROR_NOT_FOUND: - return "memory block not found in pool"; - break; - case MPOOL_ERROR_IS_FREE: - return "memory address has already been freed"; - break; - case MPOOL_ERROR_BLOCK_STAT: - return "invalid internal block status"; - break; - case MPOOL_ERROR_FREE_ADDR: - return "invalid internal free address"; - break; - case MPOOL_ERROR_SBRK_CONTIG: - return "sbrk did not return contiguous memory"; - break; - case MPOOL_ERROR_NO_PAGES: - return "no available pages left in pool"; - break; - case MPOOL_ERROR_ALLOC: - return "system alloc function failed"; - break; - case MPOOL_ERROR_PNT_OVER: - return "user pointer admin space overwritten"; - break; - default: - break; - } + switch (error) { + case MPOOL_ERROR_NONE: + return "no error"; + break; + case MPOOL_ERROR_ARG_NULL: + return "function argument is null"; + break; + case MPOOL_ERROR_ARG_INVALID: + return "function argument is invalid"; + break; + case MPOOL_ERROR_PNT: + return "invalid mpool pointer"; + break; + case MPOOL_ERROR_POOL_OVER: + return "mpool structure was overwritten"; + break; + case MPOOL_ERROR_PAGE_SIZE: + return "could not get system page-size"; + break; + case MPOOL_ERROR_OPEN_ZERO: + return "could not open /dev/zero"; + break; + case MPOOL_ERROR_NO_MEM: + return "no memory available"; + break; + case MPOOL_ERROR_MMAP: + return "problems with mmap"; + break; + case MPOOL_ERROR_SIZE: + return "error processing requested size"; + break; + case MPOOL_ERROR_TOO_BIG: + return "allocation exceeds pool max size"; + break; + case MPOOL_ERROR_MEM: + return "invalid memory address"; + break; + case MPOOL_ERROR_MEM_OVER: + return "memory lower bounds overwritten"; + break; + case MPOOL_ERROR_NOT_FOUND: + return "memory block not found in pool"; + break; + case MPOOL_ERROR_IS_FREE: + return "memory address has already been freed"; + break; + case MPOOL_ERROR_BLOCK_STAT: + return "invalid internal block status"; + break; + case MPOOL_ERROR_FREE_ADDR: + return "invalid internal free address"; + break; + case MPOOL_ERROR_SBRK_CONTIG: + return "sbrk did not return contiguous memory"; + break; + case MPOOL_ERROR_NO_PAGES: + return "no available pages left in pool"; + break; + case MPOOL_ERROR_ALLOC: + return "system alloc function failed"; + break; + case MPOOL_ERROR_PNT_OVER: + return "user pointer admin space overwritten"; + break; + default: + break; + } - return "invalid error code"; + return "invalid error code"; } + + +/* For Emacs: + * Local Variables: + * mode:c + * indent-tabs-mode:t + * tab-width:4 + * c-basic-offset:4 + * End: + * For VIM: + * vim:set softtabstop=4 shiftwidth=4 tabstop=4 noet: + */ diff --git a/libs/libks/src/simclist.c b/libs/libks/src/simclist.c index c8d36f5ff4..6796a8cd48 100755 --- a/libs/libks/src/simclist.c +++ b/libs/libks/src/simclist.c @@ -26,12 +26,12 @@ #include /* for setting errno */ #include #ifndef _WIN32 - /* not in Windows! */ +/* not in Windows! */ # include # include #endif #ifndef SIMCLIST_NO_DUMPRESTORE - /* includes for dump/restore */ +/* includes for dump/restore */ # include # include /* for READ_ERRCHECK() and write() */ # include /* for open() etc */ @@ -88,31 +88,31 @@ typedef INT64 int64_t; /* define some commodity macros for Dump/Restore functionality */ #ifndef SIMCLIST_NO_DUMPRESTORE /* write() decorated with error checking logic */ -#define WRITE_ERRCHECK(fd, msgbuf, msglen) do { \ - if (write(fd, msgbuf, msglen) < 0) return -1; \ - } while (0); +#define WRITE_ERRCHECK(fd, msgbuf, msglen) do { \ + if (write(fd, msgbuf, msglen) < 0) return -1; \ + } while (0); /* READ_ERRCHECK() decorated with error checking logic */ -#define READ_ERRCHECK(fd, msgbuf, msglen) do { \ - if (read(fd, msgbuf, msglen) != msglen) { \ - /*errno = EPROTO;*/ \ - return -1; \ - } \ - } while (0); +#define READ_ERRCHECK(fd, msgbuf, msglen) do { \ + if (read(fd, msgbuf, msglen) != msglen) { \ + /*errno = EPROTO;*/ \ + return -1; \ + } \ + } while (0); /* convert 64bit integers from host to network format */ -#define hton64(x) (\ - htons(1) == 1 ? \ - (uint64_t)x /* big endian */ \ - : /* little endian */ \ - ((uint64_t)((((uint64_t)(x) & 0xff00000000000000ULL) >> 56) | \ - (((uint64_t)(x) & 0x00ff000000000000ULL) >> 40) | \ - (((uint64_t)(x) & 0x0000ff0000000000ULL) >> 24) | \ - (((uint64_t)(x) & 0x000000ff00000000ULL) >> 8) | \ - (((uint64_t)(x) & 0x00000000ff000000ULL) << 8) | \ - (((uint64_t)(x) & 0x0000000000ff0000ULL) << 24) | \ - (((uint64_t)(x) & 0x000000000000ff00ULL) << 40) | \ - (((uint64_t)(x) & 0x00000000000000ffULL) << 56))) \ - ) +#define hton64(x) ( \ + htons(1) == 1 ? \ + (uint64_t)x /* big endian */ \ + : /* little endian */ \ + ((uint64_t)((((uint64_t)(x) & 0xff00000000000000ULL) >> 56) | \ + (((uint64_t)(x) & 0x00ff000000000000ULL) >> 40) | \ + (((uint64_t)(x) & 0x0000ff0000000000ULL) >> 24) | \ + (((uint64_t)(x) & 0x000000ff00000000ULL) >> 8) | \ + (((uint64_t)(x) & 0x00000000ff000000ULL) << 8) | \ + (((uint64_t)(x) & 0x0000000000ff0000ULL) << 24) | \ + (((uint64_t)(x) & 0x000000000000ff00ULL) << 40) | \ + (((uint64_t)(x) & 0x00000000000000ffULL) << 56))) \ + ) /* convert 64bit integers from network to host format */ #define ntoh64(x) (hton64(x)) @@ -206,12 +206,12 @@ static int list_attrOk(const list_t *restrict l); /* do not inline, this is recursive */ static void list_sort_quicksort(list_t *restrict l, int versus, - unsigned int first, struct list_entry_s *fel, - unsigned int last, struct list_entry_s *lel); + unsigned int first, struct list_entry_s *fel, + unsigned int last, struct list_entry_s *lel); static inline void list_sort_selectionsort(list_t *restrict l, int versus, - unsigned int first, struct list_entry_s *fel, - unsigned int last, struct list_entry_s *lel); + unsigned int first, struct list_entry_s *fel, + unsigned int last, struct list_entry_s *lel); static void *list_get_minmax(const list_t *restrict l, int versus); @@ -792,8 +792,8 @@ static void *list_sort_quicksort_threadwrapper(void *wrapped_params) { #endif static inline void list_sort_selectionsort(list_t *restrict l, int versus, - unsigned int first, struct list_entry_s *fel, - unsigned int last, struct list_entry_s *lel) { + unsigned int first, struct list_entry_s *fel, + unsigned int last, struct list_entry_s *lel) { struct list_entry_s *cursor, *toswap, *firstunsorted; void *tmpdata; @@ -813,8 +813,8 @@ static inline void list_sort_selectionsort(list_t *restrict l, int versus, } static void list_sort_quicksort(list_t *restrict l, int versus, - unsigned int first, struct list_entry_s *fel, - unsigned int last, struct list_entry_s *lel) { + unsigned int first, struct list_entry_s *fel, + unsigned int last, struct list_entry_s *lel) { unsigned int pivotid; unsigned int i; register struct list_entry_s *pivot; @@ -1094,15 +1094,15 @@ int list_dump_filedescriptor(const list_t *restrict l, int fd, size_t *restrict /**** DUMP FORMAT **** - [ ver timestamp | totlen numels elemlen hash | DATA ] + [ ver timestamp | totlen numels elemlen hash | DATA ] - where DATA can be: - @ for constant-size list (element size is constant; elemlen > 0) - [ elem elem ... elem ] - @ for other lists (element size dictated by element_meter each time; elemlen <= 0) - [ size elem size elem ... size elem ] + where DATA can be: + @ for constant-size list (element size is constant; elemlen > 0) + [ elem elem ... elem ] + @ for other lists (element size dictated by element_meter each time; elemlen <= 0) + [ size elem size elem ... size elem ] - all integers are encoded in NETWORK BYTE FORMAT + all integers are encoded in NETWORK BYTE FORMAT *****/ @@ -1327,10 +1327,10 @@ int list_restore_filedescriptor(list_t *restrict l, int fd, size_t *restrict len /* possibly verify the list consistency */ /* wrt hash */ /* don't do that - if (header.listhash != 0 && header.listhash != list_hash(l)) { - errno = ECANCELED; - return -1; - } + if (header.listhash != 0 && header.listhash != list_hash(l)) { + errno = ECANCELED; + return -1; + } */ /* wrt header */ @@ -1487,14 +1487,14 @@ static int list_repOk(const list_t *restrict l) { struct list_entry_s *s; ok = (l != NULL) && ( - /* head/tail checks */ - (l->head_sentinel != NULL && l->tail_sentinel != NULL) && - (l->head_sentinel != l->tail_sentinel) && (l->head_sentinel->prev == NULL && l->tail_sentinel->next == NULL) && - /* empty list */ - (l->numels > 0 || (l->mid == NULL && l->head_sentinel->next == l->tail_sentinel && l->tail_sentinel->prev == l->head_sentinel)) && - /* spare elements checks */ - l->spareelsnum <= SIMCLIST_MAX_SPARE_ELEMS - ); + /* head/tail checks */ + (l->head_sentinel != NULL && l->tail_sentinel != NULL) && + (l->head_sentinel != l->tail_sentinel) && (l->head_sentinel->prev == NULL && l->tail_sentinel->next == NULL) && + /* empty list */ + (l->numels > 0 || (l->mid == NULL && l->head_sentinel->next == l->tail_sentinel && l->tail_sentinel->prev == l->head_sentinel)) && + /* spare elements checks */ + l->spareelsnum <= SIMCLIST_MAX_SPARE_ELEMS + ); if (!ok) return 0; @@ -1523,3 +1523,13 @@ static int list_attrOk(const list_t *restrict l) { #endif +/* For Emacs: + * Local Variables: + * mode:c + * indent-tabs-mode:t + * tab-width:4 + * c-basic-offset:4 + * End: + * For VIM: + * vim:set softtabstop=4 shiftwidth=4 tabstop=4 noet: + */ diff --git a/libs/libks/src/table.c b/libs/libks/src/table.c index 4e28556eb9..e586a8aaad 100644 --- a/libs/libks/src/table.c +++ b/libs/libks/src/table.c @@ -68,7 +68,7 @@ #endif static char *rcs_id = - "$Id: table.c,v 1.19 2000/03/09 03:30:41 gray Exp $"; + "$Id: table.c,v 1.19 2000/03/09 03:30:41 gray Exp $"; /* * Version id for the library. You also need to add an entry to the @@ -100,24 +100,24 @@ static char *version_id = "$TableVersion: 4.3.0 March 8, 2000 $"; * and then find the corresponding entry. */ static table_entry_t *first_entry(const table_t *table_p, - table_linear_t *linear_p) + table_linear_t *linear_p) { - table_entry_t *entry_p; - unsigned int bucket_c = 0; + table_entry_t *entry_p; + unsigned int bucket_c = 0; - /* look for the first non-empty bucket */ - for (bucket_c = 0; bucket_c < table_p->ta_bucket_n; bucket_c++) { - entry_p = table_p->ta_buckets[bucket_c]; - if (entry_p != NULL) { - if (linear_p != NULL) { - linear_p->tl_bucket_c = bucket_c; - linear_p->tl_entry_c = 0; - } - return TABLE_POINTER(table_p, table_entry_t *, entry_p); - } - } + /* look for the first non-empty bucket */ + for (bucket_c = 0; bucket_c < table_p->ta_bucket_n; bucket_c++) { + entry_p = table_p->ta_buckets[bucket_c]; + if (entry_p != NULL) { + if (linear_p != NULL) { + linear_p->tl_bucket_c = bucket_c; + linear_p->tl_entry_c = 0; + } + return TABLE_POINTER(table_p, table_entry_t *, entry_p); + } + } - return NULL; + return NULL; } /* @@ -145,59 +145,59 @@ static table_entry_t *first_entry(const table_t *table_p, * will contain a table error code. */ static table_entry_t *next_entry(const table_t *table_p, - table_linear_t *linear_p, int *error_p) + table_linear_t *linear_p, int *error_p) { - table_entry_t *entry_p; - int entry_c; + table_entry_t *entry_p; + int entry_c; - /* can't next if we haven't first-ed */ - if (linear_p == NULL) { - SET_POINTER(error_p, TABLE_ERROR_LINEAR); - return NULL; - } + /* can't next if we haven't first-ed */ + if (linear_p == NULL) { + SET_POINTER(error_p, TABLE_ERROR_LINEAR); + return NULL; + } - if (linear_p->tl_bucket_c >= table_p->ta_bucket_n) { - /* - * NOTE: this might happen if we delete an item which shortens the - * table bucket numbers. - */ - SET_POINTER(error_p, TABLE_ERROR_NOT_FOUND); - return NULL; - } + if (linear_p->tl_bucket_c >= table_p->ta_bucket_n) { + /* + * NOTE: this might happen if we delete an item which shortens the + * table bucket numbers. + */ + SET_POINTER(error_p, TABLE_ERROR_NOT_FOUND); + return NULL; + } - linear_p->tl_entry_c++; + linear_p->tl_entry_c++; - /* find the entry which is the nth in the list */ - entry_p = table_p->ta_buckets[linear_p->tl_bucket_c]; - /* NOTE: we swap the order here to be more efficient */ - for (entry_c = linear_p->tl_entry_c; entry_c > 0; entry_c--) { - /* did we reach the end of the list? */ - if (entry_p == NULL) { - break; - } - entry_p = TABLE_POINTER(table_p, table_entry_t *, entry_p)->te_next_p; - } + /* find the entry which is the nth in the list */ + entry_p = table_p->ta_buckets[linear_p->tl_bucket_c]; + /* NOTE: we swap the order here to be more efficient */ + for (entry_c = linear_p->tl_entry_c; entry_c > 0; entry_c--) { + /* did we reach the end of the list? */ + if (entry_p == NULL) { + break; + } + entry_p = TABLE_POINTER(table_p, table_entry_t *, entry_p)->te_next_p; + } - /* did we find an entry in the current bucket? */ - if (entry_p != NULL) { - SET_POINTER(error_p, TABLE_ERROR_NONE); - return TABLE_POINTER(table_p, table_entry_t *, entry_p); - } + /* did we find an entry in the current bucket? */ + if (entry_p != NULL) { + SET_POINTER(error_p, TABLE_ERROR_NONE); + return TABLE_POINTER(table_p, table_entry_t *, entry_p); + } - /* find the first entry in the next non-empty bucket */ + /* find the first entry in the next non-empty bucket */ - linear_p->tl_entry_c = 0; - for (linear_p->tl_bucket_c++; linear_p->tl_bucket_c < table_p->ta_bucket_n; - linear_p->tl_bucket_c++) { - entry_p = table_p->ta_buckets[linear_p->tl_bucket_c]; - if (entry_p != NULL) { - SET_POINTER(error_p, TABLE_ERROR_NONE); - return TABLE_POINTER(table_p, table_entry_t *, entry_p); - } - } + linear_p->tl_entry_c = 0; + for (linear_p->tl_bucket_c++; linear_p->tl_bucket_c < table_p->ta_bucket_n; + linear_p->tl_bucket_c++) { + entry_p = table_p->ta_buckets[linear_p->tl_bucket_c]; + if (entry_p != NULL) { + SET_POINTER(error_p, TABLE_ERROR_NONE); + return TABLE_POINTER(table_p, table_entry_t *, entry_p); + } + } - SET_POINTER(error_p, TABLE_ERROR_NOT_FOUND); - return NULL; + SET_POINTER(error_p, TABLE_ERROR_NOT_FOUND); + return NULL; } /* @@ -225,48 +225,48 @@ static table_entry_t *next_entry(const table_t *table_p, * will contain a table error code. */ static table_entry_t *this_entry(const table_t *table_p, - const table_linear_t *linear_p, - int *error_p) + const table_linear_t *linear_p, + int *error_p) { - table_entry_t *entry_p; - int entry_c; + table_entry_t *entry_p; + int entry_c; - /* can't next if we haven't first-ed */ - if (linear_p == NULL) { - SET_POINTER(error_p, TABLE_ERROR_LINEAR); - return NULL; - } + /* can't next if we haven't first-ed */ + if (linear_p == NULL) { + SET_POINTER(error_p, TABLE_ERROR_LINEAR); + return NULL; + } - if (linear_p->tl_bucket_c >= table_p->ta_bucket_n) { - /* - * NOTE: this might happen if we delete an item which shortens the - * table bucket numbers. - */ - SET_POINTER(error_p, TABLE_ERROR_NOT_FOUND); - return NULL; - } + if (linear_p->tl_bucket_c >= table_p->ta_bucket_n) { + /* + * NOTE: this might happen if we delete an item which shortens the + * table bucket numbers. + */ + SET_POINTER(error_p, TABLE_ERROR_NOT_FOUND); + return NULL; + } - /* find the entry which is the nth in the list */ - entry_p = table_p->ta_buckets[linear_p->tl_bucket_c]; + /* find the entry which is the nth in the list */ + entry_p = table_p->ta_buckets[linear_p->tl_bucket_c]; - /* NOTE: we swap the order here to be more efficient */ - for (entry_c = linear_p->tl_entry_c; entry_c > 0; entry_c--) { - /* did we reach the end of the list? */ - if (entry_p == NULL) { - break; - } - entry_p = TABLE_POINTER(table_p, table_entry_t *, entry_p)->te_next_p; - } + /* NOTE: we swap the order here to be more efficient */ + for (entry_c = linear_p->tl_entry_c; entry_c > 0; entry_c--) { + /* did we reach the end of the list? */ + if (entry_p == NULL) { + break; + } + entry_p = TABLE_POINTER(table_p, table_entry_t *, entry_p)->te_next_p; + } - /* did we find an entry in the current bucket? */ - if (entry_p == NULL) { - SET_POINTER(error_p, TABLE_ERROR_NOT_FOUND); - return NULL; - } - else { - SET_POINTER(error_p, TABLE_ERROR_NONE); - return TABLE_POINTER(table_p, table_entry_t *, entry_p); - } + /* did we find an entry in the current bucket? */ + if (entry_p == NULL) { + SET_POINTER(error_p, TABLE_ERROR_NOT_FOUND); + return NULL; + } + else { + SET_POINTER(error_p, TABLE_ERROR_NONE); + return TABLE_POINTER(table_p, table_entry_t *, entry_p); + } } /* @@ -307,67 +307,67 @@ static table_entry_t *this_entry(const table_t *table_p, * for (i=0, h=0; i= 12; len -= 12) { - a += (key_p[0] - + ((unsigned int)key_p[1] << 8) - + ((unsigned int)key_p[2] << 16) - + ((unsigned int)key_p[3] << 24)); - b += (key_p[4] - + ((unsigned int)key_p[5] << 8) - + ((unsigned int)key_p[6] << 16) - + ((unsigned int)key_p[7] << 24)); - c += (key_p[8] - + ((unsigned int)key_p[9] << 8) - + ((unsigned int)key_p[10] << 16) - + ((unsigned int)key_p[11] << 24)); - HASH_MIX(a,b,c); - key_p += 12; - } + /* handle most of the key */ + for (len = length; len >= 12; len -= 12) { + a += (key_p[0] + + ((unsigned int)key_p[1] << 8) + + ((unsigned int)key_p[2] << 16) + + ((unsigned int)key_p[3] << 24)); + b += (key_p[4] + + ((unsigned int)key_p[5] << 8) + + ((unsigned int)key_p[6] << 16) + + ((unsigned int)key_p[7] << 24)); + c += (key_p[8] + + ((unsigned int)key_p[9] << 8) + + ((unsigned int)key_p[10] << 16) + + ((unsigned int)key_p[11] << 24)); + HASH_MIX(a,b,c); + key_p += 12; + } - c += length; + c += length; - /* all the case statements fall through to the next */ - switch(len) { - case 11: - c += ((unsigned int)key_p[10] << 24); - case 10: - c += ((unsigned int)key_p[9] << 16); - case 9: - c += ((unsigned int)key_p[8] << 8); - /* the first byte of c is reserved for the length */ - case 8: - b += ((unsigned int)key_p[7] << 24); - case 7: - b += ((unsigned int)key_p[6] << 16); - case 6: - b += ((unsigned int)key_p[5] << 8); - case 5: - b += key_p[4]; - case 4: - a += ((unsigned int)key_p[3] << 24); - case 3: - a += ((unsigned int)key_p[2] << 16); - case 2: - a += ((unsigned int)key_p[1] << 8); - case 1: - a += key_p[0]; - /* case 0: nothing left to add */ - } - HASH_MIX(a, b, c); + /* all the case statements fall through to the next */ + switch(len) { + case 11: + c += ((unsigned int)key_p[10] << 24); + case 10: + c += ((unsigned int)key_p[9] << 16); + case 9: + c += ((unsigned int)key_p[8] << 8); + /* the first byte of c is reserved for the length */ + case 8: + b += ((unsigned int)key_p[7] << 24); + case 7: + b += ((unsigned int)key_p[6] << 16); + case 6: + b += ((unsigned int)key_p[5] << 8); + case 5: + b += key_p[4]; + case 4: + a += ((unsigned int)key_p[3] << 24); + case 3: + a += ((unsigned int)key_p[2] << 16); + case 2: + a += ((unsigned int)key_p[1] << 8); + case 1: + a += key_p[0]; + /* case 0: nothing left to add */ + } + HASH_MIX(a, b, c); - return c; + return c; } /* @@ -392,28 +392,28 @@ static unsigned int hash(const unsigned char *key, * data - Size of the entry data. */ static int entry_size(const table_t *table_p, const unsigned int key_size, - const unsigned int data_size) + const unsigned int data_size) { - int size, left; + int size, left; - /* initial size -- key is already aligned if right after struct */ - size = sizeof(struct table_shell_st) + key_size; + /* initial size -- key is already aligned if right after struct */ + size = sizeof(struct table_shell_st) + key_size; - /* if there is no alignment then it is easy */ - if (table_p->ta_data_align == 0) { - return size + data_size; - } + /* if there is no alignment then it is easy */ + if (table_p->ta_data_align == 0) { + return size + data_size; + } - /* add in our alignement */ - left = size & (table_p->ta_data_align - 1); - if (left > 0) { - size += table_p->ta_data_align - left; - } + /* add in our alignement */ + left = size & (table_p->ta_data_align - 1); + if (left > 0) { + size += table_p->ta_data_align - left; + } - /* we add the data size here after the alignment */ - size += data_size; + /* we add the data size here after the alignment */ + size += data_size; - return size; + return size; } /* @@ -437,23 +437,23 @@ static int entry_size(const table_t *table_p, const unsigned int key_size, * entry_p - Entry whose data pointer we are determining. */ static unsigned char *entry_data_buf(const table_t *table_p, - const table_entry_t *entry_p) + const table_entry_t *entry_p) { - const unsigned char *buf_p; - unsigned int size, pad; + const unsigned char *buf_p; + unsigned int size, pad; - buf_p = entry_p->te_key_buf + entry_p->te_key_size; + buf_p = entry_p->te_key_buf + entry_p->te_key_size; - /* we need the size of the space before the data */ - size = sizeof(struct table_shell_st) + entry_p->te_key_size; + /* we need the size of the space before the data */ + size = sizeof(struct table_shell_st) + entry_p->te_key_size; - /* add in our alignment */ - pad = size & (table_p->ta_data_align - 1); - if (pad > 0) { - pad = table_p->ta_data_align - pad; - } + /* add in our alignment */ + pad = size & (table_p->ta_data_align - 1); + if (pad > 0) { + pad = table_p->ta_data_align - pad; + } - return (unsigned char *)buf_p + pad; + return (unsigned char *)buf_p + pad; } /******************************* sort routines *******************************/ @@ -484,26 +484,26 @@ static unsigned char *entry_data_buf(const table_t *table_p, * has occurred. It cannot be NULL. */ static int local_compare(const void *p1, const void *p2, - table_compare_t compare, const table_t *table_p, - int *err_bp) + table_compare_t compare, const table_t *table_p, + int *err_bp) { - const table_entry_t * const *ent1_p = p1, * const *ent2_p = p2; - int cmp; - unsigned int size; + const table_entry_t * const *ent1_p = p1, * const *ent2_p = p2; + int cmp; + unsigned int size; - /* compare as many bytes as we can */ - size = (*ent1_p)->te_key_size; - if ((*ent2_p)->te_key_size < size) { - size = (*ent2_p)->te_key_size; - } - cmp = memcmp(ENTRY_KEY_BUF(*ent1_p), ENTRY_KEY_BUF(*ent2_p), size); - /* if common-size equal, then if next more bytes, it is larger */ - if (cmp == 0) { - cmp = (*ent1_p)->te_key_size - (*ent2_p)->te_key_size; - } + /* compare as many bytes as we can */ + size = (*ent1_p)->te_key_size; + if ((*ent2_p)->te_key_size < size) { + size = (*ent2_p)->te_key_size; + } + cmp = memcmp(ENTRY_KEY_BUF(*ent1_p), ENTRY_KEY_BUF(*ent2_p), size); + /* if common-size equal, then if next more bytes, it is larger */ + if (cmp == 0) { + cmp = (*ent1_p)->te_key_size - (*ent2_p)->te_key_size; + } - *err_bp = 0; - return cmp; + *err_bp = 0; + return cmp; } /* @@ -532,35 +532,35 @@ static int local_compare(const void *p1, const void *p2, * has occurred. It cannot be NULL. */ static int local_compare_pos(const void *p1, const void *p2, - table_compare_t compare, - const table_t *table_p, int *err_bp) + table_compare_t compare, + const table_t *table_p, int *err_bp) { - const table_linear_t *lin1_p = p1, *lin2_p = p2; - const table_entry_t *ent1_p, *ent2_p; - int cmp, ret; - unsigned int size; + const table_linear_t *lin1_p = p1, *lin2_p = p2; + const table_entry_t *ent1_p, *ent2_p; + int cmp, ret; + unsigned int size; - /* get entry pointers */ - ent1_p = this_entry(table_p, lin1_p, &ret); - ent2_p = this_entry(table_p, lin2_p, &ret); - if (ent1_p == NULL || ent2_p == NULL) { - *err_bp = 1; - return 0; - } + /* get entry pointers */ + ent1_p = this_entry(table_p, lin1_p, &ret); + ent2_p = this_entry(table_p, lin2_p, &ret); + if (ent1_p == NULL || ent2_p == NULL) { + *err_bp = 1; + return 0; + } - /* compare as many bytes as we can */ - size = ent1_p->te_key_size; - if (ent2_p->te_key_size < size) { - size = ent2_p->te_key_size; - } - cmp = memcmp(ENTRY_KEY_BUF(ent1_p), ENTRY_KEY_BUF(ent2_p), size); - /* if common-size equal, then if next more bytes, it is larger */ - if (cmp == 0) { - cmp = ent1_p->te_key_size - ent2_p->te_key_size; - } + /* compare as many bytes as we can */ + size = ent1_p->te_key_size; + if (ent2_p->te_key_size < size) { + size = ent2_p->te_key_size; + } + cmp = memcmp(ENTRY_KEY_BUF(ent1_p), ENTRY_KEY_BUF(ent2_p), size); + /* if common-size equal, then if next more bytes, it is larger */ + if (cmp == 0) { + cmp = ent1_p->te_key_size - ent2_p->te_key_size; + } - *err_bp = 0; - return cmp; + *err_bp = 0; + return cmp; } /* @@ -589,18 +589,18 @@ static int local_compare_pos(const void *p1, const void *p2, * has occurred. It cannot be NULL. */ static int external_compare(const void *p1, const void *p2, - table_compare_t user_compare, - const table_t *table_p, int *err_bp) + table_compare_t user_compare, + const table_t *table_p, int *err_bp) { - const table_entry_t * const *ent1_p = p1, * const *ent2_p = p2; - /* since we know we are not aligned we can use the EXTRY_DATA_BUF macro */ - *err_bp = 0; - return user_compare(ENTRY_KEY_BUF(*ent1_p), (*ent1_p)->te_key_size, - ENTRY_DATA_BUF(table_p, *ent1_p), - (*ent1_p)->te_data_size, - ENTRY_KEY_BUF(*ent2_p), (*ent2_p)->te_key_size, - ENTRY_DATA_BUF(table_p, *ent2_p), - (*ent2_p)->te_data_size); + const table_entry_t * const *ent1_p = p1, * const *ent2_p = p2; + /* since we know we are not aligned we can use the EXTRY_DATA_BUF macro */ + *err_bp = 0; + return user_compare(ENTRY_KEY_BUF(*ent1_p), (*ent1_p)->te_key_size, + ENTRY_DATA_BUF(table_p, *ent1_p), + (*ent1_p)->te_data_size, + ENTRY_KEY_BUF(*ent2_p), (*ent2_p)->te_key_size, + ENTRY_DATA_BUF(table_p, *ent2_p), + (*ent2_p)->te_data_size); } /* @@ -627,29 +627,29 @@ static int external_compare(const void *p1, const void *p2, * * err_bp - Pointer to an integer which will be set with 1 if an error * has occurred. It cannot be NULL. -*/ + */ static int external_compare_pos(const void *p1, const void *p2, - table_compare_t user_compare, - const table_t *table_p, int *err_bp) + table_compare_t user_compare, + const table_t *table_p, int *err_bp) { - const table_linear_t *lin1_p = p1, *lin2_p = p2; - const table_entry_t *ent1_p, *ent2_p; - int ret; + const table_linear_t *lin1_p = p1, *lin2_p = p2; + const table_entry_t *ent1_p, *ent2_p; + int ret; - /* get entry pointers */ - ent1_p = this_entry(table_p, lin1_p, &ret); - ent2_p = this_entry(table_p, lin2_p, &ret); - if (ent1_p == NULL || ent2_p == NULL) { - *err_bp = 1; - return 0; - } + /* get entry pointers */ + ent1_p = this_entry(table_p, lin1_p, &ret); + ent2_p = this_entry(table_p, lin2_p, &ret); + if (ent1_p == NULL || ent2_p == NULL) { + *err_bp = 1; + return 0; + } - /* since we know we are not aligned we can use the EXTRY_DATA_BUF macro */ - *err_bp = 0; - return user_compare(ENTRY_KEY_BUF(ent1_p), (ent1_p)->te_key_size, - ENTRY_DATA_BUF(table_p, ent1_p), ent1_p->te_data_size, - ENTRY_KEY_BUF(ent2_p), ent2_p->te_key_size, - ENTRY_DATA_BUF(table_p, ent2_p), ent2_p->te_data_size); + /* since we know we are not aligned we can use the EXTRY_DATA_BUF macro */ + *err_bp = 0; + return user_compare(ENTRY_KEY_BUF(ent1_p), (ent1_p)->te_key_size, + ENTRY_DATA_BUF(table_p, ent1_p), ent1_p->te_data_size, + ENTRY_KEY_BUF(ent2_p), ent2_p->te_key_size, + ENTRY_DATA_BUF(table_p, ent2_p), ent2_p->te_data_size); } /* @@ -678,18 +678,18 @@ static int external_compare_pos(const void *p1, const void *p2, * has occurred. It cannot be NULL. */ static int external_compare_align(const void *p1, const void *p2, - table_compare_t user_compare, - const table_t *table_p, int *err_bp) + table_compare_t user_compare, + const table_t *table_p, int *err_bp) { - const table_entry_t * const *ent1_p = p1, * const *ent2_p = p2; - /* since we are aligned we have to use the entry_data_buf function */ - *err_bp = 0; - return user_compare(ENTRY_KEY_BUF(*ent1_p), (*ent1_p)->te_key_size, - entry_data_buf(table_p, *ent1_p), - (*ent1_p)->te_data_size, - ENTRY_KEY_BUF(*ent2_p), (*ent2_p)->te_key_size, - entry_data_buf(table_p, *ent2_p), - (*ent2_p)->te_data_size); + const table_entry_t * const *ent1_p = p1, * const *ent2_p = p2; + /* since we are aligned we have to use the entry_data_buf function */ + *err_bp = 0; + return user_compare(ENTRY_KEY_BUF(*ent1_p), (*ent1_p)->te_key_size, + entry_data_buf(table_p, *ent1_p), + (*ent1_p)->te_data_size, + ENTRY_KEY_BUF(*ent2_p), (*ent2_p)->te_key_size, + entry_data_buf(table_p, *ent2_p), + (*ent2_p)->te_data_size); } /* @@ -718,27 +718,27 @@ static int external_compare_align(const void *p1, const void *p2, * has occurred. It cannot be NULL. */ static int external_compare_align_pos(const void *p1, const void *p2, - table_compare_t user_compare, - const table_t *table_p, int *err_bp) + table_compare_t user_compare, + const table_t *table_p, int *err_bp) { - const table_linear_t *lin1_p = p1, *lin2_p = p2; - const table_entry_t *ent1_p, *ent2_p; - int ret; + const table_linear_t *lin1_p = p1, *lin2_p = p2; + const table_entry_t *ent1_p, *ent2_p; + int ret; - /* get entry pointers */ - ent1_p = this_entry(table_p, lin1_p, &ret); - ent2_p = this_entry(table_p, lin2_p, &ret); - if (ent1_p == NULL || ent2_p == NULL) { - *err_bp = 1; - return 0; - } + /* get entry pointers */ + ent1_p = this_entry(table_p, lin1_p, &ret); + ent2_p = this_entry(table_p, lin2_p, &ret); + if (ent1_p == NULL || ent2_p == NULL) { + *err_bp = 1; + return 0; + } - /* since we are aligned we have to use the entry_data_buf function */ - *err_bp = 0; - return user_compare(ENTRY_KEY_BUF(ent1_p), ent1_p->te_key_size, - entry_data_buf(table_p, ent1_p), ent1_p->te_data_size, - ENTRY_KEY_BUF(ent2_p), ent2_p->te_key_size, - entry_data_buf(table_p, ent2_p), ent2_p->te_data_size); + /* since we are aligned we have to use the entry_data_buf function */ + *err_bp = 0; + return user_compare(ENTRY_KEY_BUF(ent1_p), ent1_p->te_key_size, + entry_data_buf(table_p, ent1_p), ent1_p->te_data_size, + ENTRY_KEY_BUF(ent2_p), ent2_p->te_key_size, + entry_data_buf(table_p, ent2_p), ent2_p->te_data_size); } /* @@ -761,17 +761,17 @@ static int external_compare_align_pos(const void *p1, const void *p2, * ele_size -> Size of the two items. */ static void swap_bytes(unsigned char *item1_p, unsigned char *item2_p, - int ele_size) + int ele_size) { - unsigned char char_temp; + unsigned char char_temp; - for (; ele_size > 0; ele_size--) { - char_temp = *item1_p; - *item1_p = *item2_p; - *item2_p = char_temp; - item1_p++; - item2_p++; - } + for (; ele_size > 0; ele_size--) { + char_temp = *item1_p; + *item1_p = *item2_p; + *item2_p = char_temp; + item1_p++; + item2_p++; + } } /* @@ -806,44 +806,44 @@ static void swap_bytes(unsigned char *item1_p, unsigned char *item2_p, * table_p -> Associated table being sorted. */ static int insert_sort(unsigned char *first_p, unsigned char *last_p, - unsigned char *holder_p, - const unsigned int ele_size, compare_t compare, - table_compare_t user_compare, table_t *table_p) + unsigned char *holder_p, + const unsigned int ele_size, compare_t compare, + table_compare_t user_compare, table_t *table_p) { - unsigned char *inner_p, *outer_p; - int ret, err_b; + unsigned char *inner_p, *outer_p; + int ret, err_b; - for (outer_p = first_p + ele_size; outer_p <= last_p; ) { + for (outer_p = first_p + ele_size; outer_p <= last_p; ) { - /* look for the place to insert the entry */ - for (inner_p = outer_p - ele_size; - inner_p >= first_p; - inner_p -= ele_size) { - ret = compare(outer_p, inner_p, user_compare, table_p, &err_b); - if (err_b) { - return TABLE_ERROR_COMPARE; - } - if (ret >= 0) { - break; - } - } - inner_p += ele_size; + /* look for the place to insert the entry */ + for (inner_p = outer_p - ele_size; + inner_p >= first_p; + inner_p -= ele_size) { + ret = compare(outer_p, inner_p, user_compare, table_p, &err_b); + if (err_b) { + return TABLE_ERROR_COMPARE; + } + if (ret >= 0) { + break; + } + } + inner_p += ele_size; - /* do we need to insert the entry in? */ - if (outer_p != inner_p) { - /* - * Now we shift the entry down into its place in the already - * sorted list. - */ - memcpy(holder_p, outer_p, ele_size); - memmove(inner_p + ele_size, inner_p, outer_p - inner_p); - memcpy(inner_p, holder_p, ele_size); - } + /* do we need to insert the entry in? */ + if (outer_p != inner_p) { + /* + * Now we shift the entry down into its place in the already + * sorted list. + */ + memcpy(holder_p, outer_p, ele_size); + memmove(inner_p + ele_size, inner_p, outer_p - inner_p); + memcpy(inner_p, holder_p, ele_size); + } - outer_p += ele_size; - } + outer_p += ele_size; + } - return TABLE_ERROR_NONE; + return TABLE_ERROR_NONE; } /* @@ -874,197 +874,197 @@ static int insert_sort(unsigned char *first_p, unsigned char *last_p, * table_p -> Associated table being sorted. */ static int split(unsigned char *first_p, unsigned char *last_p, - const unsigned int ele_size, compare_t compare, - table_compare_t user_compare, table_t *table_p) + const unsigned int ele_size, compare_t compare, + table_compare_t user_compare, table_t *table_p) { - unsigned char *left_p, *right_p, *pivot_p, *left_last_p, *right_first_p; - unsigned char *firsts[MAX_QSORT_SPLITS], *lasts[MAX_QSORT_SPLITS], *pivot; - unsigned int width, split_c = 0; - int size1, size2, min_qsort_size; - int ret, err_b; + unsigned char *left_p, *right_p, *pivot_p, *left_last_p, *right_first_p; + unsigned char *firsts[MAX_QSORT_SPLITS], *lasts[MAX_QSORT_SPLITS], *pivot; + unsigned int width, split_c = 0; + int size1, size2, min_qsort_size; + int ret, err_b; - /* - * Allocate some space for our pivot value. We also use this as - * holder space for our insert sort. - */ - pivot = alloca(ele_size); - if (pivot == NULL) { - /* what else can we do? */ - abort(); - } - - min_qsort_size = MAX_QSORT_MANY * ele_size; - - while (1) { - - /* find the left, right, and mid point */ - left_p = first_p; - right_p = last_p; - /* is there a faster way to find this? */ - width = (last_p - first_p) / ele_size; - pivot_p = first_p + ele_size * (width >> 1); - - /* - * Find which of the left, middle, and right elements is the - * median (Knuth vol3 p123). - */ - ret = compare(first_p, pivot_p, user_compare, table_p, &err_b); - if (err_b) { - return TABLE_ERROR_COMPARE; - } - if (ret > 0) { - swap_bytes(first_p, pivot_p, ele_size); - } - ret = compare(pivot_p, last_p, user_compare, table_p, &err_b); - if (err_b) { - return TABLE_ERROR_COMPARE; - } - if (ret > 0) { - swap_bytes(pivot_p, last_p, ele_size); - ret = compare(first_p, pivot_p, user_compare, table_p, &err_b); - if (err_b) { - return TABLE_ERROR_COMPARE; - } - if (ret > 0) { - swap_bytes(first_p, pivot_p, ele_size); - } - } - - /* - * save our pivot so we don't have to worry about hitting and - * swapping it elsewhere while we iterate across the list below. - */ - memcpy(pivot, pivot_p, ele_size); - - do { - - /* shift the left side up until we reach the pivot value */ - while (1) { - ret = compare(left_p, pivot, user_compare, table_p, &err_b); - if (err_b) { - return TABLE_ERROR_COMPARE; - } - if (ret >= 0) { - break; - } - left_p += ele_size; - } - /* shift the right side down until we reach the pivot value */ - while (1) { - ret = compare(pivot, right_p, user_compare, table_p, &err_b); - if (err_b) { - return TABLE_ERROR_COMPARE; - } - if (ret >= 0) { - break; - } - right_p -= ele_size; - } - - /* if we met in the middle then we are done */ - if (left_p == right_p) { - left_p += ele_size; - right_p -= ele_size; - break; - } - else if (left_p < right_p) { /* - * swap the left and right since they both were on the wrong - * size of the pivot and continue + * Allocate some space for our pivot value. We also use this as + * holder space for our insert sort. */ - swap_bytes(left_p, right_p, ele_size); - left_p += ele_size; - right_p -= ele_size; - } - } while (left_p <= right_p); - - /* Rename variables to make more sense. This will get optimized out. */ - right_first_p = left_p; - left_last_p = right_p; - - /* determine the size of the left and right hand parts */ - size1 = left_last_p - first_p; - size2 = last_p - right_first_p; - - /* is the 1st half small enough to just insert-sort? */ - if (size1 < min_qsort_size) { - - /* use the pivot as our temporary space */ - ret = insert_sort(first_p, left_last_p, pivot, ele_size, compare, - user_compare, table_p); - if (ret != TABLE_ERROR_NONE) { - return ret; - } - - /* is the 2nd part small as well? */ - if (size2 < min_qsort_size) { - - /* use the pivot as our temporary space */ - ret = insert_sort(right_first_p, last_p, pivot, ele_size, compare, - user_compare, table_p); - if (ret != TABLE_ERROR_NONE) { - return ret; + pivot = alloca(ele_size); + if (pivot == NULL) { + /* what else can we do? */ + abort(); } - - /* pop a partition off our stack */ - if (split_c == 0) { - /* we are done */ - return TABLE_ERROR_NONE; - } - split_c--; - first_p = firsts[split_c]; - last_p = lasts[split_c]; - } - else { - /* we can just handle the right side immediately */ - first_p = right_first_p; - /* last_p = last_p */ - } - } - else if (size2 < min_qsort_size) { - - /* use the pivot as our temporary space */ - ret = insert_sort(right_first_p, last_p, pivot, ele_size, compare, - user_compare, table_p); - if (ret != TABLE_ERROR_NONE) { - return ret; - } - - /* we can just handle the left side immediately */ - /* first_p = first_p */ - last_p = left_last_p; - } - else { - /* - * neither partition is small, we'll have to push the larger one - * of them on the stack - */ - if (split_c >= MAX_QSORT_SPLITS) { - /* sanity check here -- we should never get here */ - abort(); - } - if (size1 > size2) { - /* push the left partition on the stack */ - firsts[split_c] = first_p; - lasts[split_c] = left_last_p; - split_c++; - /* continue handling the right side */ - first_p = right_first_p; - /* last_p = last_p */ - } - else { - /* push the right partition on the stack */ - firsts[split_c] = right_first_p; - lasts[split_c] = last_p; - split_c++; - /* continue handling the left side */ - /* first_p = first_p */ - last_p = left_last_p; - } - } - } - return TABLE_ERROR_NONE; + min_qsort_size = MAX_QSORT_MANY * ele_size; + + while (1) { + + /* find the left, right, and mid point */ + left_p = first_p; + right_p = last_p; + /* is there a faster way to find this? */ + width = (last_p - first_p) / ele_size; + pivot_p = first_p + ele_size * (width >> 1); + + /* + * Find which of the left, middle, and right elements is the + * median (Knuth vol3 p123). + */ + ret = compare(first_p, pivot_p, user_compare, table_p, &err_b); + if (err_b) { + return TABLE_ERROR_COMPARE; + } + if (ret > 0) { + swap_bytes(first_p, pivot_p, ele_size); + } + ret = compare(pivot_p, last_p, user_compare, table_p, &err_b); + if (err_b) { + return TABLE_ERROR_COMPARE; + } + if (ret > 0) { + swap_bytes(pivot_p, last_p, ele_size); + ret = compare(first_p, pivot_p, user_compare, table_p, &err_b); + if (err_b) { + return TABLE_ERROR_COMPARE; + } + if (ret > 0) { + swap_bytes(first_p, pivot_p, ele_size); + } + } + + /* + * save our pivot so we don't have to worry about hitting and + * swapping it elsewhere while we iterate across the list below. + */ + memcpy(pivot, pivot_p, ele_size); + + do { + + /* shift the left side up until we reach the pivot value */ + while (1) { + ret = compare(left_p, pivot, user_compare, table_p, &err_b); + if (err_b) { + return TABLE_ERROR_COMPARE; + } + if (ret >= 0) { + break; + } + left_p += ele_size; + } + /* shift the right side down until we reach the pivot value */ + while (1) { + ret = compare(pivot, right_p, user_compare, table_p, &err_b); + if (err_b) { + return TABLE_ERROR_COMPARE; + } + if (ret >= 0) { + break; + } + right_p -= ele_size; + } + + /* if we met in the middle then we are done */ + if (left_p == right_p) { + left_p += ele_size; + right_p -= ele_size; + break; + } + else if (left_p < right_p) { + /* + * swap the left and right since they both were on the wrong + * size of the pivot and continue + */ + swap_bytes(left_p, right_p, ele_size); + left_p += ele_size; + right_p -= ele_size; + } + } while (left_p <= right_p); + + /* Rename variables to make more sense. This will get optimized out. */ + right_first_p = left_p; + left_last_p = right_p; + + /* determine the size of the left and right hand parts */ + size1 = left_last_p - first_p; + size2 = last_p - right_first_p; + + /* is the 1st half small enough to just insert-sort? */ + if (size1 < min_qsort_size) { + + /* use the pivot as our temporary space */ + ret = insert_sort(first_p, left_last_p, pivot, ele_size, compare, + user_compare, table_p); + if (ret != TABLE_ERROR_NONE) { + return ret; + } + + /* is the 2nd part small as well? */ + if (size2 < min_qsort_size) { + + /* use the pivot as our temporary space */ + ret = insert_sort(right_first_p, last_p, pivot, ele_size, compare, + user_compare, table_p); + if (ret != TABLE_ERROR_NONE) { + return ret; + } + + /* pop a partition off our stack */ + if (split_c == 0) { + /* we are done */ + return TABLE_ERROR_NONE; + } + split_c--; + first_p = firsts[split_c]; + last_p = lasts[split_c]; + } + else { + /* we can just handle the right side immediately */ + first_p = right_first_p; + /* last_p = last_p */ + } + } + else if (size2 < min_qsort_size) { + + /* use the pivot as our temporary space */ + ret = insert_sort(right_first_p, last_p, pivot, ele_size, compare, + user_compare, table_p); + if (ret != TABLE_ERROR_NONE) { + return ret; + } + + /* we can just handle the left side immediately */ + /* first_p = first_p */ + last_p = left_last_p; + } + else { + /* + * neither partition is small, we'll have to push the larger one + * of them on the stack + */ + if (split_c >= MAX_QSORT_SPLITS) { + /* sanity check here -- we should never get here */ + abort(); + } + if (size1 > size2) { + /* push the left partition on the stack */ + firsts[split_c] = first_p; + lasts[split_c] = left_last_p; + split_c++; + /* continue handling the right side */ + first_p = right_first_p; + /* last_p = last_p */ + } + else { + /* push the right partition on the stack */ + firsts[split_c] = right_first_p; + lasts[split_c] = last_p; + split_c++; + /* continue handling the left side */ + /* first_p = first_p */ + last_p = left_last_p; + } + } + } + + return TABLE_ERROR_NONE; } /*************************** exported routines *******************************/ @@ -1092,50 +1092,50 @@ static int split(unsigned char *first_p, unsigned char *last_p, */ table_t *table_alloc(const unsigned int bucket_n, int *error_p) { - table_t *table_p = NULL; - unsigned int buck_n; + table_t *table_p = NULL; + unsigned int buck_n; - /* allocate a table structure */ - table_p = malloc(sizeof(table_t)); - if (table_p == NULL) { - SET_POINTER(error_p, TABLE_ERROR_ALLOC); - return NULL; - } + /* allocate a table structure */ + table_p = malloc(sizeof(table_t)); + if (table_p == NULL) { + SET_POINTER(error_p, TABLE_ERROR_ALLOC); + return NULL; + } - if (bucket_n > 0) { - buck_n = bucket_n; - } - else { - buck_n = DEFAULT_SIZE; - } + if (bucket_n > 0) { + buck_n = bucket_n; + } + else { + buck_n = DEFAULT_SIZE; + } - /* allocate the buckets which are NULLed */ - table_p->ta_buckets = (table_entry_t **)calloc(buck_n, - sizeof(table_entry_t *)); - if (table_p->ta_buckets == NULL) { - SET_POINTER(error_p, TABLE_ERROR_ALLOC); - free(table_p); - return NULL; - } + /* allocate the buckets which are NULLed */ + table_p->ta_buckets = (table_entry_t **)calloc(buck_n, + sizeof(table_entry_t *)); + if (table_p->ta_buckets == NULL) { + SET_POINTER(error_p, TABLE_ERROR_ALLOC); + free(table_p); + return NULL; + } - /* initialize structure */ - table_p->ta_magic = TABLE_MAGIC; - table_p->ta_flags = 0; - table_p->ta_bucket_n = buck_n; - table_p->ta_entry_n = 0; - table_p->ta_data_align = 0; - table_p->ta_linear.tl_magic = 0; - table_p->ta_linear.tl_bucket_c = 0; - table_p->ta_linear.tl_entry_c = 0; - table_p->ta_mmap = NULL; - table_p->ta_file_size = 0; - table_p->ta_mem_pool = NULL; - table_p->ta_alloc_func = NULL; - table_p->ta_resize_func = NULL; - table_p->ta_free_func = NULL; + /* initialize structure */ + table_p->ta_magic = TABLE_MAGIC; + table_p->ta_flags = 0; + table_p->ta_bucket_n = buck_n; + table_p->ta_entry_n = 0; + table_p->ta_data_align = 0; + table_p->ta_linear.tl_magic = 0; + table_p->ta_linear.tl_bucket_c = 0; + table_p->ta_linear.tl_entry_c = 0; + table_p->ta_mmap = NULL; + table_p->ta_file_size = 0; + table_p->ta_mem_pool = NULL; + table_p->ta_alloc_func = NULL; + table_p->ta_resize_func = NULL; + table_p->ta_free_func = NULL; - SET_POINTER(error_p, TABLE_ERROR_NONE); - return table_p; + SET_POINTER(error_p, TABLE_ERROR_NONE); + return table_p; } /* @@ -1171,66 +1171,66 @@ table_t *table_alloc(const unsigned int bucket_n, int *error_p) * table error code. */ table_t *table_alloc_in_pool(const unsigned int bucket_n, - void *mem_pool, - table_mem_alloc_t alloc_func, - table_mem_resize_t resize_func, - table_mem_free_t free_func, int *error_p) + void *mem_pool, + table_mem_alloc_t alloc_func, + table_mem_resize_t resize_func, + table_mem_free_t free_func, int *error_p) { - table_t *table_p = NULL; - unsigned int buck_n, size; + table_t *table_p = NULL; + unsigned int buck_n, size; - /* make sure we have real functions, mem_pool and resize_func can be NULL */ - if (alloc_func == NULL || free_func == NULL) { - SET_POINTER(error_p, TABLE_ERROR_ARG_NULL); - return NULL; - } + /* make sure we have real functions, mem_pool and resize_func can be NULL */ + if (alloc_func == NULL || free_func == NULL) { + SET_POINTER(error_p, TABLE_ERROR_ARG_NULL); + return NULL; + } - /* allocate a table structure */ - table_p = alloc_func(mem_pool, sizeof(table_t)); - if (table_p == NULL) { - SET_POINTER(error_p, TABLE_ERROR_ALLOC); - return NULL; - } + /* allocate a table structure */ + table_p = alloc_func(mem_pool, sizeof(table_t)); + if (table_p == NULL) { + SET_POINTER(error_p, TABLE_ERROR_ALLOC); + return NULL; + } - if (bucket_n > 0) { - buck_n = bucket_n; - } - else { - buck_n = DEFAULT_SIZE; - } + if (bucket_n > 0) { + buck_n = bucket_n; + } + else { + buck_n = DEFAULT_SIZE; + } - /* allocate the buckets which are NULLed */ - size = buck_n * sizeof(table_entry_t *); - table_p->ta_buckets = (table_entry_t **)alloc_func(mem_pool, size); - if (table_p->ta_buckets == NULL) { - SET_POINTER(error_p, TABLE_ERROR_ALLOC); - (void)free_func(mem_pool, table_p, sizeof(table_t)); - return NULL; - } - /* - * We zero it ourselves to save the necessity of having a - * table_mem_calloc_t memory override function. - */ - memset(table_p->ta_buckets, 0, size); + /* allocate the buckets which are NULLed */ + size = buck_n * sizeof(table_entry_t *); + table_p->ta_buckets = (table_entry_t **)alloc_func(mem_pool, size); + if (table_p->ta_buckets == NULL) { + SET_POINTER(error_p, TABLE_ERROR_ALLOC); + (void)free_func(mem_pool, table_p, sizeof(table_t)); + return NULL; + } + /* + * We zero it ourselves to save the necessity of having a + * table_mem_calloc_t memory override function. + */ + memset(table_p->ta_buckets, 0, size); - /* initialize structure */ - table_p->ta_magic = TABLE_MAGIC; - table_p->ta_flags = 0; - table_p->ta_bucket_n = buck_n; - table_p->ta_entry_n = 0; - table_p->ta_data_align = 0; - table_p->ta_linear.tl_magic = 0; - table_p->ta_linear.tl_bucket_c = 0; - table_p->ta_linear.tl_entry_c = 0; - table_p->ta_mmap = NULL; - table_p->ta_file_size = 0; - table_p->ta_mem_pool = mem_pool; - table_p->ta_alloc_func = alloc_func; - table_p->ta_resize_func = resize_func; - table_p->ta_free_func = free_func; + /* initialize structure */ + table_p->ta_magic = TABLE_MAGIC; + table_p->ta_flags = 0; + table_p->ta_bucket_n = buck_n; + table_p->ta_entry_n = 0; + table_p->ta_data_align = 0; + table_p->ta_linear.tl_magic = 0; + table_p->ta_linear.tl_bucket_c = 0; + table_p->ta_linear.tl_entry_c = 0; + table_p->ta_mmap = NULL; + table_p->ta_file_size = 0; + table_p->ta_mem_pool = mem_pool; + table_p->ta_alloc_func = alloc_func; + table_p->ta_resize_func = resize_func; + table_p->ta_free_func = free_func; - SET_POINTER(error_p, TABLE_ERROR_NONE); - return table_p; + SET_POINTER(error_p, TABLE_ERROR_NONE); + return table_p; } /* @@ -1255,16 +1255,16 @@ table_t *table_alloc_in_pool(const unsigned int bucket_n, */ int table_attr(table_t *table_p, const int attr) { - if (table_p == NULL) { - return TABLE_ERROR_ARG_NULL; - } - if (table_p->ta_magic != TABLE_MAGIC) { - return TABLE_ERROR_PNT; - } + if (table_p == NULL) { + return TABLE_ERROR_ARG_NULL; + } + if (table_p->ta_magic != TABLE_MAGIC) { + return TABLE_ERROR_PNT; + } - table_p->ta_flags = attr; + table_p->ta_flags = attr; - return TABLE_ERROR_NONE; + return TABLE_ERROR_NONE; } /* @@ -1306,36 +1306,36 @@ int table_attr(table_t *table_p, const int attr) */ int table_set_data_alignment(table_t *table_p, const int alignment) { - int val; + int val; - if (table_p == NULL) { - return TABLE_ERROR_ARG_NULL; - } - if (table_p->ta_magic != TABLE_MAGIC) { - return TABLE_ERROR_PNT; - } - if (table_p->ta_entry_n > 0) { - return TABLE_ERROR_NOT_EMPTY; - } + if (table_p == NULL) { + return TABLE_ERROR_ARG_NULL; + } + if (table_p->ta_magic != TABLE_MAGIC) { + return TABLE_ERROR_PNT; + } + if (table_p->ta_entry_n > 0) { + return TABLE_ERROR_NOT_EMPTY; + } - /* defaults */ - if (alignment < 2) { - table_p->ta_data_align = 0; - } - else { - /* verify we have a base 2 number */ - for (val = 2; val < MAX_ALIGNMENT; val *= 2) { - if (val == alignment) { - break; - } - } - if (val >= MAX_ALIGNMENT) { - return TABLE_ERROR_ALIGNMENT; - } - table_p->ta_data_align = alignment; - } + /* defaults */ + if (alignment < 2) { + table_p->ta_data_align = 0; + } + else { + /* verify we have a base 2 number */ + for (val = 2; val < MAX_ALIGNMENT; val *= 2) { + if (val == alignment) { + break; + } + } + if (val >= MAX_ALIGNMENT) { + return TABLE_ERROR_ALIGNMENT; + } + table_p->ta_data_align = alignment; + } - return TABLE_ERROR_NONE; + return TABLE_ERROR_NONE; } /* @@ -1357,52 +1357,52 @@ int table_set_data_alignment(table_t *table_p, const int alignment) */ int table_clear(table_t *table_p) { - int final = TABLE_ERROR_NONE; - table_entry_t *entry_p, *next_p; - table_entry_t **bucket_p, **bounds_p; + int final = TABLE_ERROR_NONE; + table_entry_t *entry_p, *next_p; + table_entry_t **bucket_p, **bounds_p; - if (table_p == NULL) { - return TABLE_ERROR_ARG_NULL; - } - if (table_p->ta_magic != TABLE_MAGIC) { - return TABLE_ERROR_PNT; - } + if (table_p == NULL) { + return TABLE_ERROR_ARG_NULL; + } + if (table_p->ta_magic != TABLE_MAGIC) { + return TABLE_ERROR_PNT; + } #ifndef NO_MMAP - /* no mmap support so immediate error */ - if (table_p->ta_mmap != NULL) { - return TABLE_ERROR_MMAP_OP; - } + /* no mmap support so immediate error */ + if (table_p->ta_mmap != NULL) { + return TABLE_ERROR_MMAP_OP; + } #endif - /* free the table allocation and table structure */ - bounds_p = table_p->ta_buckets + table_p->ta_bucket_n; - for (bucket_p = table_p->ta_buckets; bucket_p < bounds_p; bucket_p++) { - for (entry_p = *bucket_p; entry_p != NULL; entry_p = next_p) { - /* record the next pointer before we free */ - next_p = entry_p->te_next_p; - if (table_p->ta_free_func == NULL) { - free(entry_p); - } - else if (! table_p->ta_free_func(table_p->ta_mem_pool, entry_p, - entry_size(table_p, - entry_p->te_key_size, - entry_p->te_data_size))) { - final = TABLE_ERROR_FREE; - } - } + /* free the table allocation and table structure */ + bounds_p = table_p->ta_buckets + table_p->ta_bucket_n; + for (bucket_p = table_p->ta_buckets; bucket_p < bounds_p; bucket_p++) { + for (entry_p = *bucket_p; entry_p != NULL; entry_p = next_p) { + /* record the next pointer before we free */ + next_p = entry_p->te_next_p; + if (table_p->ta_free_func == NULL) { + free(entry_p); + } + else if (! table_p->ta_free_func(table_p->ta_mem_pool, entry_p, + entry_size(table_p, + entry_p->te_key_size, + entry_p->te_data_size))) { + final = TABLE_ERROR_FREE; + } + } - /* clear the bucket entry after we free its entries */ - *bucket_p = NULL; - } + /* clear the bucket entry after we free its entries */ + *bucket_p = NULL; + } - /* reset table state info */ - table_p->ta_entry_n = 0; - table_p->ta_linear.tl_magic = 0; - table_p->ta_linear.tl_bucket_c = 0; - table_p->ta_linear.tl_entry_c = 0; + /* reset table state info */ + table_p->ta_entry_n = 0; + table_p->ta_linear.tl_magic = 0; + table_p->ta_linear.tl_bucket_c = 0; + table_p->ta_linear.tl_entry_c = 0; - return final; + return final; } /* @@ -1424,47 +1424,47 @@ int table_clear(table_t *table_p) */ int table_free(table_t *table_p) { - int ret; + int ret; - if (table_p == NULL) { - return TABLE_ERROR_ARG_NULL; - } - if (table_p->ta_magic != TABLE_MAGIC) { - return TABLE_ERROR_PNT; - } + if (table_p == NULL) { + return TABLE_ERROR_ARG_NULL; + } + if (table_p->ta_magic != TABLE_MAGIC) { + return TABLE_ERROR_PNT; + } #ifndef NO_MMAP - /* no mmap support so immediate error */ - if (table_p->ta_mmap != NULL) { - return TABLE_ERROR_MMAP_OP; - } + /* no mmap support so immediate error */ + if (table_p->ta_mmap != NULL) { + return TABLE_ERROR_MMAP_OP; + } #endif - ret = table_clear(table_p); + ret = table_clear(table_p); - if (table_p->ta_buckets != NULL) { - if (table_p->ta_free_func == NULL) { - free(table_p->ta_buckets); - } - else if (! table_p->ta_free_func(table_p->ta_mem_pool, - table_p->ta_buckets, - table_p->ta_bucket_n * - sizeof(table_entry_t *))) { - return TABLE_ERROR_FREE; - } - } - table_p->ta_magic = 0; - if (table_p->ta_free_func == NULL) { - free(table_p); - } - else if (! table_p->ta_free_func(table_p->ta_mem_pool, table_p, - sizeof(table_t))) { - if (ret == TABLE_ERROR_NONE) { - ret = TABLE_ERROR_FREE; - } - } + if (table_p->ta_buckets != NULL) { + if (table_p->ta_free_func == NULL) { + free(table_p->ta_buckets); + } + else if (! table_p->ta_free_func(table_p->ta_mem_pool, + table_p->ta_buckets, + table_p->ta_bucket_n * + sizeof(table_entry_t *))) { + return TABLE_ERROR_FREE; + } + } + table_p->ta_magic = 0; + if (table_p->ta_free_func == NULL) { + free(table_p); + } + else if (! table_p->ta_free_func(table_p->ta_mem_pool, table_p, + sizeof(table_t))) { + if (ret == TABLE_ERROR_NONE) { + ret = TABLE_ERROR_FREE; + } + } - return ret; + return ret; } /* @@ -1544,241 +1544,241 @@ int table_free(table_t *table_p) * in the table. */ int table_insert_kd(table_t *table_p, - const void *key_buf, const int key_size, - const void *data_buf, const int data_size, - void **key_buf_p, void **data_buf_p, - const char overwrite_b) + const void *key_buf, const int key_size, + const void *data_buf, const int data_size, + void **key_buf_p, void **data_buf_p, + const char overwrite_b) { - int bucket; - unsigned int ksize, dsize, new_size, old_size, copy_size; - table_entry_t *entry_p, *last_p, *new_entry_p; - void *key_copy_p, *data_copy_p; + int bucket; + unsigned int ksize, dsize, new_size, old_size, copy_size; + table_entry_t *entry_p, *last_p, *new_entry_p; + void *key_copy_p, *data_copy_p; - /* check the arguments */ - if (table_p == NULL) { - return TABLE_ERROR_ARG_NULL; - } - if (table_p->ta_magic != TABLE_MAGIC) { - return TABLE_ERROR_PNT; - } - if (key_buf == NULL) { - return TABLE_ERROR_ARG_NULL; - } - /* data_buf can be null but size must be >= 0, if it isn't null size != 0 */ - if ((data_buf == NULL && data_size < 0) - || (data_buf != NULL && data_size == 0)) { - return TABLE_ERROR_SIZE; - } + /* check the arguments */ + if (table_p == NULL) { + return TABLE_ERROR_ARG_NULL; + } + if (table_p->ta_magic != TABLE_MAGIC) { + return TABLE_ERROR_PNT; + } + if (key_buf == NULL) { + return TABLE_ERROR_ARG_NULL; + } + /* data_buf can be null but size must be >= 0, if it isn't null size != 0 */ + if ((data_buf == NULL && data_size < 0) + || (data_buf != NULL && data_size == 0)) { + return TABLE_ERROR_SIZE; + } #ifndef NO_MMAP - /* no mmap support so immediate error */ - if (table_p->ta_mmap != NULL) { - return TABLE_ERROR_MMAP_OP; - } + /* no mmap support so immediate error */ + if (table_p->ta_mmap != NULL) { + return TABLE_ERROR_MMAP_OP; + } #endif - /* determine sizes of key and data */ - if (key_size < 0) { - ksize = strlen((char *)key_buf) + sizeof(char); - } - else { - ksize = key_size; - } - if (data_size < 0) { - dsize = strlen((char *)data_buf) + sizeof(char); - } - else { - dsize = data_size; - } - - /* get the bucket number via a hash function */ - bucket = hash(key_buf, ksize, 0) % table_p->ta_bucket_n; - - /* look for the entry in this bucket, only check keys of the same size */ - last_p = NULL; - for (entry_p = table_p->ta_buckets[bucket]; - entry_p != NULL; - last_p = entry_p, entry_p = entry_p->te_next_p) { - if (entry_p->te_key_size == ksize - && memcmp(ENTRY_KEY_BUF(entry_p), key_buf, ksize) == 0) { - break; - } - } - - /* did we find it? then we are in replace mode. */ - if (entry_p != NULL) { - - /* can we not overwrite existing data? */ - if (! overwrite_b) { - SET_POINTER(key_buf_p, ENTRY_KEY_BUF(entry_p)); - if (data_buf_p != NULL) { - if (entry_p->te_data_size == 0) { - *data_buf_p = NULL; + /* determine sizes of key and data */ + if (key_size < 0) { + ksize = strlen((char *)key_buf) + sizeof(char); } else { - if (table_p->ta_data_align == 0) { - *data_buf_p = ENTRY_DATA_BUF(table_p, entry_p); - } - else { - *data_buf_p = entry_data_buf(table_p, entry_p); - } + ksize = key_size; } - } - return TABLE_ERROR_OVERWRITE; - } + if (data_size < 0) { + dsize = strlen((char *)data_buf) + sizeof(char); + } + else { + dsize = data_size; + } + + /* get the bucket number via a hash function */ + bucket = hash(key_buf, ksize, 0) % table_p->ta_bucket_n; + + /* look for the entry in this bucket, only check keys of the same size */ + last_p = NULL; + for (entry_p = table_p->ta_buckets[bucket]; + entry_p != NULL; + last_p = entry_p, entry_p = entry_p->te_next_p) { + if (entry_p->te_key_size == ksize + && memcmp(ENTRY_KEY_BUF(entry_p), key_buf, ksize) == 0) { + break; + } + } + + /* did we find it? then we are in replace mode. */ + if (entry_p != NULL) { - /* re-alloc entry's data if the new size != the old */ - if (dsize != entry_p->te_data_size) { + /* can we not overwrite existing data? */ + if (! overwrite_b) { + SET_POINTER(key_buf_p, ENTRY_KEY_BUF(entry_p)); + if (data_buf_p != NULL) { + if (entry_p->te_data_size == 0) { + *data_buf_p = NULL; + } + else { + if (table_p->ta_data_align == 0) { + *data_buf_p = ENTRY_DATA_BUF(table_p, entry_p); + } + else { + *data_buf_p = entry_data_buf(table_p, entry_p); + } + } + } + return TABLE_ERROR_OVERWRITE; + } + + /* re-alloc entry's data if the new size != the old */ + if (dsize != entry_p->te_data_size) { - /* - * First we delete it from the list to keep the list whole. - * This properly preserves the linked list in case we have a - * thread marching through the linked list while we are - * inserting. Maybe this is an unnecessary protection but it - * should not harm that much. - */ - if (last_p == NULL) { - table_p->ta_buckets[bucket] = entry_p->te_next_p; - } - else { - last_p->te_next_p = entry_p->te_next_p; - } + /* + * First we delete it from the list to keep the list whole. + * This properly preserves the linked list in case we have a + * thread marching through the linked list while we are + * inserting. Maybe this is an unnecessary protection but it + * should not harm that much. + */ + if (last_p == NULL) { + table_p->ta_buckets[bucket] = entry_p->te_next_p; + } + else { + last_p->te_next_p = entry_p->te_next_p; + } - /* - * Realloc the structure which may change its pointer. NOTE: - * this may change any previous data_key_p and data_copy_p - * pointers. - */ - new_size = entry_size(table_p, entry_p->te_key_size, dsize); - if (table_p->ta_resize_func == NULL) { - /* if the alloc function has not been overriden do realloc */ + /* + * Realloc the structure which may change its pointer. NOTE: + * this may change any previous data_key_p and data_copy_p + * pointers. + */ + new_size = entry_size(table_p, entry_p->te_key_size, dsize); + if (table_p->ta_resize_func == NULL) { + /* if the alloc function has not been overriden do realloc */ + if (table_p->ta_alloc_func == NULL) { + entry_p = (table_entry_t *)realloc(entry_p, new_size); + if (entry_p == NULL) { + return TABLE_ERROR_ALLOC; + } + } + else { + old_size = new_size - dsize + entry_p->te_data_size; + /* + * if the user did override alloc but not resize, assume + * that the user's allocation functions can't grok realloc + * and do it ourselves the hard way. + */ + new_entry_p = + (table_entry_t *)table_p->ta_alloc_func(table_p->ta_mem_pool, + new_size); + if (new_entry_p == NULL) { + return TABLE_ERROR_ALLOC; + } + if (new_size > old_size) { + copy_size = old_size; + } + else { + copy_size = new_size; + } + memcpy(new_entry_p, entry_p, copy_size); + if (! table_p->ta_free_func(table_p->ta_mem_pool, entry_p, + old_size)) { + return TABLE_ERROR_FREE; + } + entry_p = new_entry_p; + } + } + else { + old_size = new_size - dsize + entry_p->te_data_size; + entry_p = (table_entry_t *) + table_p->ta_resize_func(table_p->ta_mem_pool, entry_p, + old_size, new_size); + if (entry_p == NULL) { + return TABLE_ERROR_ALLOC; + } + } + + /* add it back to the front of the list */ + entry_p->te_data_size = dsize; + entry_p->te_next_p = table_p->ta_buckets[bucket]; + table_p->ta_buckets[bucket] = entry_p; + } + + /* copy or replace data in storage */ + if (dsize > 0) { + if (table_p->ta_data_align == 0) { + data_copy_p = ENTRY_DATA_BUF(table_p, entry_p); + } + else { + data_copy_p = entry_data_buf(table_p, entry_p); + } + if (data_buf != NULL) { + memcpy(data_copy_p, data_buf, dsize); + } + } + else { + data_copy_p = NULL; + } + + SET_POINTER(key_buf_p, ENTRY_KEY_BUF(entry_p)); + SET_POINTER(data_buf_p, data_copy_p); + + /* returning from the section where we were overwriting table data */ + return TABLE_ERROR_NONE; + } + + /* + * It is a new entry. + */ + + /* allocate a new entry */ + new_size = entry_size(table_p, ksize, dsize); if (table_p->ta_alloc_func == NULL) { - entry_p = (table_entry_t *)realloc(entry_p, new_size); - if (entry_p == NULL) { - return TABLE_ERROR_ALLOC; - } + entry_p = (table_entry_t *)malloc(new_size); } else { - old_size = new_size - dsize + entry_p->te_data_size; - /* - * if the user did override alloc but not resize, assume - * that the user's allocation functions can't grok realloc - * and do it ourselves the hard way. - */ - new_entry_p = - (table_entry_t *)table_p->ta_alloc_func(table_p->ta_mem_pool, - new_size); - if (new_entry_p == NULL) { - return TABLE_ERROR_ALLOC; - } - if (new_size > old_size) { - copy_size = old_size; - } - else { - copy_size = new_size; - } - memcpy(new_entry_p, entry_p, copy_size); - if (! table_p->ta_free_func(table_p->ta_mem_pool, entry_p, - old_size)) { - return TABLE_ERROR_FREE; - } - entry_p = new_entry_p; + entry_p = + (table_entry_t *)table_p->ta_alloc_func(table_p->ta_mem_pool, new_size); } - } - else { - old_size = new_size - dsize + entry_p->te_data_size; - entry_p = (table_entry_t *) - table_p->ta_resize_func(table_p->ta_mem_pool, entry_p, - old_size, new_size); if (entry_p == NULL) { - return TABLE_ERROR_ALLOC; + return TABLE_ERROR_ALLOC; } - } - - /* add it back to the front of the list */ - entry_p->te_data_size = dsize; - entry_p->te_next_p = table_p->ta_buckets[bucket]; - table_p->ta_buckets[bucket] = entry_p; - } - - /* copy or replace data in storage */ - if (dsize > 0) { - if (table_p->ta_data_align == 0) { - data_copy_p = ENTRY_DATA_BUF(table_p, entry_p); - } - else { - data_copy_p = entry_data_buf(table_p, entry_p); - } - if (data_buf != NULL) { - memcpy(data_copy_p, data_buf, dsize); - } - } - else { - data_copy_p = NULL; - } - - SET_POINTER(key_buf_p, ENTRY_KEY_BUF(entry_p)); - SET_POINTER(data_buf_p, data_copy_p); - - /* returning from the section where we were overwriting table data */ - return TABLE_ERROR_NONE; - } - /* - * It is a new entry. - */ + /* copy key into storage */ + entry_p->te_key_size = ksize; + key_copy_p = ENTRY_KEY_BUF(entry_p); + memcpy(key_copy_p, key_buf, ksize); - /* allocate a new entry */ - new_size = entry_size(table_p, ksize, dsize); - if (table_p->ta_alloc_func == NULL) { - entry_p = (table_entry_t *)malloc(new_size); - } - else { - entry_p = - (table_entry_t *)table_p->ta_alloc_func(table_p->ta_mem_pool, new_size); - } - if (entry_p == NULL) { - return TABLE_ERROR_ALLOC; - } + /* copy data in */ + entry_p->te_data_size = dsize; + if (dsize > 0) { + if (table_p->ta_data_align == 0) { + data_copy_p = ENTRY_DATA_BUF(table_p, entry_p); + } + else { + data_copy_p = entry_data_buf(table_p, entry_p); + } + if (data_buf != NULL) { + memcpy(data_copy_p, data_buf, dsize); + } + } + else { + data_copy_p = NULL; + } - /* copy key into storage */ - entry_p->te_key_size = ksize; - key_copy_p = ENTRY_KEY_BUF(entry_p); - memcpy(key_copy_p, key_buf, ksize); + SET_POINTER(key_buf_p, key_copy_p); + SET_POINTER(data_buf_p, data_copy_p); - /* copy data in */ - entry_p->te_data_size = dsize; - if (dsize > 0) { - if (table_p->ta_data_align == 0) { - data_copy_p = ENTRY_DATA_BUF(table_p, entry_p); - } - else { - data_copy_p = entry_data_buf(table_p, entry_p); - } - if (data_buf != NULL) { - memcpy(data_copy_p, data_buf, dsize); - } - } - else { - data_copy_p = NULL; - } + /* insert into list, no need to append */ + entry_p->te_next_p = table_p->ta_buckets[bucket]; + table_p->ta_buckets[bucket] = entry_p; - SET_POINTER(key_buf_p, key_copy_p); - SET_POINTER(data_buf_p, data_copy_p); + table_p->ta_entry_n++; - /* insert into list, no need to append */ - entry_p->te_next_p = table_p->ta_buckets[bucket]; - table_p->ta_buckets[bucket] = entry_p; + /* do we need auto-adjust? */ + if ((table_p->ta_flags & TABLE_FLAG_AUTO_ADJUST) + && SHOULD_TABLE_GROW(table_p)) { + return table_adjust(table_p, table_p->ta_entry_n); + } - table_p->ta_entry_n++; - - /* do we need auto-adjust? */ - if ((table_p->ta_flags & TABLE_FLAG_AUTO_ADJUST) - && SHOULD_TABLE_GROW(table_p)) { - return table_adjust(table_p, table_p->ta_entry_n); - } - - return TABLE_ERROR_NONE; + return TABLE_ERROR_NONE; } /* @@ -1834,12 +1834,12 @@ int table_insert_kd(table_t *table_p, * in the table. */ int table_insert(table_t *table_p, - const void *key_buf, const int key_size, - const void *data_buf, const int data_size, - void **data_buf_p, const char overwrite_b) + const void *key_buf, const int key_size, + const void *data_buf, const int data_size, + void **data_buf_p, const char overwrite_b) { - return table_insert_kd(table_p, key_buf, key_size, data_buf, data_size, - NULL, data_buf_p, overwrite_b); + return table_insert_kd(table_p, key_buf, key_size, data_buf, data_size, + NULL, data_buf_p, overwrite_b); } /* @@ -1882,67 +1882,67 @@ int table_insert(table_t *table_p, * the key. */ int table_retrieve(table_t *table_p, - const void *key_buf, const int key_size, - void **data_buf_p, int *data_size_p) + const void *key_buf, const int key_size, + void **data_buf_p, int *data_size_p) { - int bucket; - unsigned int ksize; - table_entry_t *entry_p, **buckets; + int bucket; + unsigned int ksize; + table_entry_t *entry_p, **buckets; - if (table_p == NULL) { - return TABLE_ERROR_ARG_NULL; - } - if (table_p->ta_magic != TABLE_MAGIC) { - return TABLE_ERROR_PNT; - } - if (key_buf == NULL) { - return TABLE_ERROR_ARG_NULL; - } + if (table_p == NULL) { + return TABLE_ERROR_ARG_NULL; + } + if (table_p->ta_magic != TABLE_MAGIC) { + return TABLE_ERROR_PNT; + } + if (key_buf == NULL) { + return TABLE_ERROR_ARG_NULL; + } - /* find key size */ - if (key_size < 0) { - ksize = strlen((char *)key_buf) + sizeof(char); - } - else { - ksize = key_size; - } + /* find key size */ + if (key_size < 0) { + ksize = strlen((char *)key_buf) + sizeof(char); + } + else { + ksize = key_size; + } - /* get the bucket number via a has function */ - bucket = hash(key_buf, ksize, 0) % table_p->ta_bucket_n; + /* get the bucket number via a has function */ + bucket = hash(key_buf, ksize, 0) % table_p->ta_bucket_n; - /* look for the entry in this bucket, only check keys of the same size */ - buckets = table_p->ta_buckets; - for (entry_p = buckets[bucket]; - entry_p != NULL; - entry_p = entry_p->te_next_p) { - entry_p = TABLE_POINTER(table_p, table_entry_t *, entry_p); - if (entry_p->te_key_size == ksize - && memcmp(ENTRY_KEY_BUF(entry_p), key_buf, ksize) == 0) { - break; - } - } + /* look for the entry in this bucket, only check keys of the same size */ + buckets = table_p->ta_buckets; + for (entry_p = buckets[bucket]; + entry_p != NULL; + entry_p = entry_p->te_next_p) { + entry_p = TABLE_POINTER(table_p, table_entry_t *, entry_p); + if (entry_p->te_key_size == ksize + && memcmp(ENTRY_KEY_BUF(entry_p), key_buf, ksize) == 0) { + break; + } + } - /* not found? */ - if (entry_p == NULL) { - return TABLE_ERROR_NOT_FOUND; - } + /* not found? */ + if (entry_p == NULL) { + return TABLE_ERROR_NOT_FOUND; + } - if (data_buf_p != NULL) { - if (entry_p->te_data_size == 0) { - *data_buf_p = NULL; - } - else { - if (table_p->ta_data_align == 0) { - *data_buf_p = ENTRY_DATA_BUF(table_p, entry_p); - } - else { - *data_buf_p = entry_data_buf(table_p, entry_p); - } - } - } - SET_POINTER(data_size_p, entry_p->te_data_size); + if (data_buf_p != NULL) { + if (entry_p->te_data_size == 0) { + *data_buf_p = NULL; + } + else { + if (table_p->ta_data_align == 0) { + *data_buf_p = ENTRY_DATA_BUF(table_p, entry_p); + } + else { + *data_buf_p = entry_data_buf(table_p, entry_p); + } + } + } + SET_POINTER(data_size_p, entry_p->te_data_size); - return TABLE_ERROR_NONE; + return TABLE_ERROR_NONE; } /* @@ -1991,121 +1991,121 @@ int table_retrieve(table_t *table_p, * associated with the key. */ int table_delete(table_t *table_p, - const void *key_buf, const int key_size, - void **data_buf_p, int *data_size_p) + const void *key_buf, const int key_size, + void **data_buf_p, int *data_size_p) { - int bucket; - unsigned int ksize; - unsigned char *data_copy_p; - table_entry_t *entry_p, *last_p; + int bucket; + unsigned int ksize; + unsigned char *data_copy_p; + table_entry_t *entry_p, *last_p; - if (table_p == NULL) { - return TABLE_ERROR_ARG_NULL; - } - if (table_p->ta_magic != TABLE_MAGIC) { - return TABLE_ERROR_PNT; - } - if (key_buf == NULL) { - return TABLE_ERROR_ARG_NULL; - } + if (table_p == NULL) { + return TABLE_ERROR_ARG_NULL; + } + if (table_p->ta_magic != TABLE_MAGIC) { + return TABLE_ERROR_PNT; + } + if (key_buf == NULL) { + return TABLE_ERROR_ARG_NULL; + } #ifndef NO_MMAP - /* no mmap support so immediate error */ - if (table_p->ta_mmap != NULL) { - return TABLE_ERROR_MMAP_OP; - } + /* no mmap support so immediate error */ + if (table_p->ta_mmap != NULL) { + return TABLE_ERROR_MMAP_OP; + } #endif - /* get the key size */ - if (key_size < 0) { - ksize = strlen((char *)key_buf) + sizeof(char); - } - else { - ksize = key_size; - } + /* get the key size */ + if (key_size < 0) { + ksize = strlen((char *)key_buf) + sizeof(char); + } + else { + ksize = key_size; + } - /* find our bucket */ - bucket = hash(key_buf, ksize, 0) % table_p->ta_bucket_n; + /* find our bucket */ + bucket = hash(key_buf, ksize, 0) % table_p->ta_bucket_n; - /* look for the entry in this bucket, only check keys of the same size */ - for (last_p = NULL, entry_p = table_p->ta_buckets[bucket]; - entry_p != NULL; - last_p = entry_p, entry_p = entry_p->te_next_p) { - if (entry_p->te_key_size == ksize - && memcmp(ENTRY_KEY_BUF(entry_p), key_buf, ksize) == 0) { - break; - } - } + /* look for the entry in this bucket, only check keys of the same size */ + for (last_p = NULL, entry_p = table_p->ta_buckets[bucket]; + entry_p != NULL; + last_p = entry_p, entry_p = entry_p->te_next_p) { + if (entry_p->te_key_size == ksize + && memcmp(ENTRY_KEY_BUF(entry_p), key_buf, ksize) == 0) { + break; + } + } - /* did we find it? */ - if (entry_p == NULL) { - return TABLE_ERROR_NOT_FOUND; - } + /* did we find it? */ + if (entry_p == NULL) { + return TABLE_ERROR_NOT_FOUND; + } - /* - * NOTE: we may want to adjust the linear counters here if the entry - * we are deleting is the one we are pointing on or is ahead of the - * one in the bucket list - */ + /* + * NOTE: we may want to adjust the linear counters here if the entry + * we are deleting is the one we are pointing on or is ahead of the + * one in the bucket list + */ - /* remove entry from the linked list */ - if (last_p == NULL) { - table_p->ta_buckets[bucket] = entry_p->te_next_p; - } - else { - last_p->te_next_p = entry_p->te_next_p; - } + /* remove entry from the linked list */ + if (last_p == NULL) { + table_p->ta_buckets[bucket] = entry_p->te_next_p; + } + else { + last_p->te_next_p = entry_p->te_next_p; + } - /* free entry */ - if (data_buf_p != NULL) { - if (entry_p->te_data_size == 0) { - *data_buf_p = NULL; - } - else { - /* - * if we were storing it compacted, we now need to malloc some - * space if the user wants the value after the delete. - */ - if (table_p->ta_alloc_func == NULL) { - *data_buf_p = malloc(entry_p->te_data_size); - } - else { - *data_buf_p = table_p->ta_alloc_func(table_p->ta_mem_pool, - entry_p->te_data_size); - } - if (*data_buf_p == NULL) { - return TABLE_ERROR_ALLOC; - } - if (table_p->ta_data_align == 0) { - data_copy_p = ENTRY_DATA_BUF(table_p, entry_p); - } - else { - data_copy_p = entry_data_buf(table_p, entry_p); - } - memcpy(*data_buf_p, data_copy_p, entry_p->te_data_size); - } - } - SET_POINTER(data_size_p, entry_p->te_data_size); - if (table_p->ta_free_func == NULL) { - free(entry_p); - } - else if (! table_p->ta_free_func(table_p->ta_mem_pool, entry_p, - entry_size(table_p, - entry_p->te_key_size, - entry_p->te_data_size))) { - return TABLE_ERROR_FREE; - } + /* free entry */ + if (data_buf_p != NULL) { + if (entry_p->te_data_size == 0) { + *data_buf_p = NULL; + } + else { + /* + * if we were storing it compacted, we now need to malloc some + * space if the user wants the value after the delete. + */ + if (table_p->ta_alloc_func == NULL) { + *data_buf_p = malloc(entry_p->te_data_size); + } + else { + *data_buf_p = table_p->ta_alloc_func(table_p->ta_mem_pool, + entry_p->te_data_size); + } + if (*data_buf_p == NULL) { + return TABLE_ERROR_ALLOC; + } + if (table_p->ta_data_align == 0) { + data_copy_p = ENTRY_DATA_BUF(table_p, entry_p); + } + else { + data_copy_p = entry_data_buf(table_p, entry_p); + } + memcpy(*data_buf_p, data_copy_p, entry_p->te_data_size); + } + } + SET_POINTER(data_size_p, entry_p->te_data_size); + if (table_p->ta_free_func == NULL) { + free(entry_p); + } + else if (! table_p->ta_free_func(table_p->ta_mem_pool, entry_p, + entry_size(table_p, + entry_p->te_key_size, + entry_p->te_data_size))) { + return TABLE_ERROR_FREE; + } - table_p->ta_entry_n--; + table_p->ta_entry_n--; - /* do we need auto-adjust down? */ - if ((table_p->ta_flags & TABLE_FLAG_AUTO_ADJUST) - && (table_p->ta_flags & TABLE_FLAG_ADJUST_DOWN) - && SHOULD_TABLE_SHRINK(table_p)) { - return table_adjust(table_p, table_p->ta_entry_n); - } + /* do we need auto-adjust down? */ + if ((table_p->ta_flags & TABLE_FLAG_AUTO_ADJUST) + && (table_p->ta_flags & TABLE_FLAG_ADJUST_DOWN) + && SHOULD_TABLE_SHRINK(table_p)) { + return table_adjust(table_p, table_p->ta_entry_n); + } - return TABLE_ERROR_NONE; + return TABLE_ERROR_NONE; } /* @@ -2158,116 +2158,116 @@ int table_delete(table_t *table_p, * associated with the key. */ int table_delete_first(table_t *table_p, - void **key_buf_p, int *key_size_p, - void **data_buf_p, int *data_size_p) + void **key_buf_p, int *key_size_p, + void **data_buf_p, int *data_size_p) { - unsigned char *data_copy_p; - table_entry_t *entry_p; - table_linear_t linear; + unsigned char *data_copy_p; + table_entry_t *entry_p; + table_linear_t linear; - if (table_p == NULL) { - return TABLE_ERROR_ARG_NULL; - } - if (table_p->ta_magic != TABLE_MAGIC) { - return TABLE_ERROR_PNT; - } + if (table_p == NULL) { + return TABLE_ERROR_ARG_NULL; + } + if (table_p->ta_magic != TABLE_MAGIC) { + return TABLE_ERROR_PNT; + } #ifndef NO_MMAP - /* no mmap support so immediate error */ - if (table_p->ta_mmap != NULL) { - return TABLE_ERROR_MMAP_OP; - } + /* no mmap support so immediate error */ + if (table_p->ta_mmap != NULL) { + return TABLE_ERROR_MMAP_OP; + } #endif - /* take the first entry */ - entry_p = first_entry(table_p, &linear); - if (entry_p == NULL) { - return TABLE_ERROR_NOT_FOUND; - } + /* take the first entry */ + entry_p = first_entry(table_p, &linear); + if (entry_p == NULL) { + return TABLE_ERROR_NOT_FOUND; + } - /* - * NOTE: we may want to adjust the linear counters here if the entry - * we are deleting is the one we are pointing on or is ahead of the - * one in the bucket list - */ + /* + * NOTE: we may want to adjust the linear counters here if the entry + * we are deleting is the one we are pointing on or is ahead of the + * one in the bucket list + */ - /* remove entry from the linked list */ - table_p->ta_buckets[linear.tl_bucket_c] = entry_p->te_next_p; + /* remove entry from the linked list */ + table_p->ta_buckets[linear.tl_bucket_c] = entry_p->te_next_p; - /* free entry */ - if (key_buf_p != NULL) { - if (entry_p->te_key_size == 0) { - *key_buf_p = NULL; - } - else { - /* - * if we were storing it compacted, we now need to malloc some - * space if the user wants the value after the delete. - */ - if (table_p->ta_alloc_func == NULL) { - *key_buf_p = malloc(entry_p->te_key_size); - } - else { - *key_buf_p = table_p->ta_alloc_func(table_p->ta_mem_pool, - entry_p->te_key_size); - } - if (*key_buf_p == NULL) { - return TABLE_ERROR_ALLOC; - } - memcpy(*key_buf_p, ENTRY_KEY_BUF(entry_p), entry_p->te_key_size); - } - } - SET_POINTER(key_size_p, entry_p->te_key_size); + /* free entry */ + if (key_buf_p != NULL) { + if (entry_p->te_key_size == 0) { + *key_buf_p = NULL; + } + else { + /* + * if we were storing it compacted, we now need to malloc some + * space if the user wants the value after the delete. + */ + if (table_p->ta_alloc_func == NULL) { + *key_buf_p = malloc(entry_p->te_key_size); + } + else { + *key_buf_p = table_p->ta_alloc_func(table_p->ta_mem_pool, + entry_p->te_key_size); + } + if (*key_buf_p == NULL) { + return TABLE_ERROR_ALLOC; + } + memcpy(*key_buf_p, ENTRY_KEY_BUF(entry_p), entry_p->te_key_size); + } + } + SET_POINTER(key_size_p, entry_p->te_key_size); - if (data_buf_p != NULL) { - if (entry_p->te_data_size == 0) { - *data_buf_p = NULL; - } - else { - /* - * if we were storing it compacted, we now need to malloc some - * space if the user wants the value after the delete. - */ - if (table_p->ta_alloc_func == NULL) { - *data_buf_p = malloc(entry_p->te_data_size); - } - else { - *data_buf_p = table_p->ta_alloc_func(table_p->ta_mem_pool, - entry_p->te_data_size); - } - if (*data_buf_p == NULL) { - return TABLE_ERROR_ALLOC; - } - if (table_p->ta_data_align == 0) { - data_copy_p = ENTRY_DATA_BUF(table_p, entry_p); - } - else { - data_copy_p = entry_data_buf(table_p, entry_p); - } - memcpy(*data_buf_p, data_copy_p, entry_p->te_data_size); - } - } - SET_POINTER(data_size_p, entry_p->te_data_size); - if (table_p->ta_free_func == NULL) { - free(entry_p); - } - else if (! table_p->ta_free_func(table_p->ta_mem_pool, entry_p, - entry_size(table_p, - entry_p->te_key_size, - entry_p->te_data_size))) { - return TABLE_ERROR_FREE; - } + if (data_buf_p != NULL) { + if (entry_p->te_data_size == 0) { + *data_buf_p = NULL; + } + else { + /* + * if we were storing it compacted, we now need to malloc some + * space if the user wants the value after the delete. + */ + if (table_p->ta_alloc_func == NULL) { + *data_buf_p = malloc(entry_p->te_data_size); + } + else { + *data_buf_p = table_p->ta_alloc_func(table_p->ta_mem_pool, + entry_p->te_data_size); + } + if (*data_buf_p == NULL) { + return TABLE_ERROR_ALLOC; + } + if (table_p->ta_data_align == 0) { + data_copy_p = ENTRY_DATA_BUF(table_p, entry_p); + } + else { + data_copy_p = entry_data_buf(table_p, entry_p); + } + memcpy(*data_buf_p, data_copy_p, entry_p->te_data_size); + } + } + SET_POINTER(data_size_p, entry_p->te_data_size); + if (table_p->ta_free_func == NULL) { + free(entry_p); + } + else if (! table_p->ta_free_func(table_p->ta_mem_pool, entry_p, + entry_size(table_p, + entry_p->te_key_size, + entry_p->te_data_size))) { + return TABLE_ERROR_FREE; + } - table_p->ta_entry_n--; + table_p->ta_entry_n--; - /* do we need auto-adjust down? */ - if ((table_p->ta_flags & TABLE_FLAG_AUTO_ADJUST) - && (table_p->ta_flags & TABLE_FLAG_ADJUST_DOWN) - && SHOULD_TABLE_SHRINK(table_p)) { - return table_adjust(table_p, table_p->ta_entry_n); - } + /* do we need auto-adjust down? */ + if ((table_p->ta_flags & TABLE_FLAG_AUTO_ADJUST) + && (table_p->ta_flags & TABLE_FLAG_ADJUST_DOWN) + && SHOULD_TABLE_SHRINK(table_p)) { + return table_adjust(table_p, table_p->ta_entry_n); + } - return TABLE_ERROR_NONE; + return TABLE_ERROR_NONE; } /* @@ -2296,17 +2296,17 @@ int table_delete_first(table_t *table_p, */ int table_info(table_t *table_p, int *num_buckets_p, int *num_entries_p) { - if (table_p == NULL) { - return TABLE_ERROR_ARG_NULL; - } - if (table_p->ta_magic != TABLE_MAGIC) { - return TABLE_ERROR_PNT; - } + if (table_p == NULL) { + return TABLE_ERROR_ARG_NULL; + } + if (table_p->ta_magic != TABLE_MAGIC) { + return TABLE_ERROR_PNT; + } - SET_POINTER(num_buckets_p, table_p->ta_bucket_n); - SET_POINTER(num_entries_p, table_p->ta_entry_n); + SET_POINTER(num_buckets_p, table_p->ta_bucket_n); + SET_POINTER(num_entries_p, table_p->ta_entry_n); - return TABLE_ERROR_NONE; + return TABLE_ERROR_NONE; } /* @@ -2331,111 +2331,111 @@ int table_info(table_t *table_p, int *num_buckets_p, int *num_entries_p) */ int table_adjust(table_t *table_p, const int bucket_n) { - table_entry_t *entry_p, *next_p; - table_entry_t **buckets, **bucket_p, **bounds_p; - int bucket; - unsigned int buck_n, bucket_size; + table_entry_t *entry_p, *next_p; + table_entry_t **buckets, **bucket_p, **bounds_p; + int bucket; + unsigned int buck_n, bucket_size; - if (table_p == NULL) { - return TABLE_ERROR_ARG_NULL; - } - if (table_p->ta_magic != TABLE_MAGIC) { - return TABLE_ERROR_PNT; - } + if (table_p == NULL) { + return TABLE_ERROR_ARG_NULL; + } + if (table_p->ta_magic != TABLE_MAGIC) { + return TABLE_ERROR_PNT; + } #ifndef NO_MMAP - /* no mmap support so immediate error */ - if (table_p->ta_mmap != NULL) { - return TABLE_ERROR_MMAP_OP; - } + /* no mmap support so immediate error */ + if (table_p->ta_mmap != NULL) { + return TABLE_ERROR_MMAP_OP; + } #endif - /* - * NOTE: we walk through the entries and rehash them. If we stored - * the hash value as a full int in the table-entry, all we would - * have to do is remod it. - */ + /* + * NOTE: we walk through the entries and rehash them. If we stored + * the hash value as a full int in the table-entry, all we would + * have to do is remod it. + */ - /* normalize to the number of entries */ - if (bucket_n == 0) { - buck_n = table_p->ta_entry_n; - } - else { - buck_n = bucket_n; - } + /* normalize to the number of entries */ + if (bucket_n == 0) { + buck_n = table_p->ta_entry_n; + } + else { + buck_n = bucket_n; + } - /* we must have at least 1 bucket */ - if (buck_n == 0) { - buck_n = 1; - } + /* we must have at least 1 bucket */ + if (buck_n == 0) { + buck_n = 1; + } - (void)printf("growing table to %d\n", buck_n); + (void)printf("growing table to %d\n", buck_n); - /* make sure we have something to do */ - if (buck_n == table_p->ta_bucket_n) { - return TABLE_ERROR_NONE; - } + /* make sure we have something to do */ + if (buck_n == table_p->ta_bucket_n) { + return TABLE_ERROR_NONE; + } - /* allocate a new bucket list */ - bucket_size = buck_n * sizeof(table_entry_t *); - if (table_p->ta_alloc_func == NULL) { - buckets = (table_entry_t **)malloc(bucket_size); - } - else { - buckets = - (table_entry_t **)table_p->ta_alloc_func(table_p->ta_mem_pool, - bucket_size); - } - if (buckets == NULL) { - return TABLE_ERROR_ALLOC; - } - /* - * We zero it ourselves to save the necessity of having a - * table_mem_calloc_t memory override function. - */ - memset(buckets, 0, bucket_size); + /* allocate a new bucket list */ + bucket_size = buck_n * sizeof(table_entry_t *); + if (table_p->ta_alloc_func == NULL) { + buckets = (table_entry_t **)malloc(bucket_size); + } + else { + buckets = + (table_entry_t **)table_p->ta_alloc_func(table_p->ta_mem_pool, + bucket_size); + } + if (buckets == NULL) { + return TABLE_ERROR_ALLOC; + } + /* + * We zero it ourselves to save the necessity of having a + * table_mem_calloc_t memory override function. + */ + memset(buckets, 0, bucket_size); - /* - * run through each of the items in the current table and rehash - * them into the newest bucket sizes - */ - bounds_p = table_p->ta_buckets + table_p->ta_bucket_n; - for (bucket_p = table_p->ta_buckets; bucket_p < bounds_p; bucket_p++) { - for (entry_p = *bucket_p; entry_p != NULL; entry_p = next_p) { + /* + * run through each of the items in the current table and rehash + * them into the newest bucket sizes + */ + bounds_p = table_p->ta_buckets + table_p->ta_bucket_n; + for (bucket_p = table_p->ta_buckets; bucket_p < bounds_p; bucket_p++) { + for (entry_p = *bucket_p; entry_p != NULL; entry_p = next_p) { - /* hash the old data into the new table size */ - bucket = hash(ENTRY_KEY_BUF(entry_p), entry_p->te_key_size, 0) % buck_n; + /* hash the old data into the new table size */ + bucket = hash(ENTRY_KEY_BUF(entry_p), entry_p->te_key_size, 0) % buck_n; - /* record the next one now since we overwrite next below */ - next_p = entry_p->te_next_p; + /* record the next one now since we overwrite next below */ + next_p = entry_p->te_next_p; - /* insert into new list, no need to append */ - entry_p->te_next_p = buckets[bucket]; - buckets[bucket] = entry_p; + /* insert into new list, no need to append */ + entry_p->te_next_p = buckets[bucket]; + buckets[bucket] = entry_p; - /* - * NOTE: we may want to adjust the bucket_c linear entry here to - * keep it current - */ - } - /* remove the old table pointers as we go by */ - *bucket_p = NULL; - } + /* + * NOTE: we may want to adjust the bucket_c linear entry here to + * keep it current + */ + } + /* remove the old table pointers as we go by */ + *bucket_p = NULL; + } - /* replace the table buckets with the new ones */ - if (table_p->ta_free_func == NULL) { - free(table_p->ta_buckets); - } - else if (! table_p->ta_free_func(table_p->ta_mem_pool, - table_p->ta_buckets, - table_p->ta_bucket_n * - sizeof(table_entry_t *))) { - return TABLE_ERROR_FREE; - } - table_p->ta_buckets = buckets; - table_p->ta_bucket_n = buck_n; + /* replace the table buckets with the new ones */ + if (table_p->ta_free_func == NULL) { + free(table_p->ta_buckets); + } + else if (! table_p->ta_free_func(table_p->ta_mem_pool, + table_p->ta_buckets, + table_p->ta_bucket_n * + sizeof(table_entry_t *))) { + return TABLE_ERROR_FREE; + } + table_p->ta_buckets = buckets; + table_p->ta_bucket_n = buck_n; - return TABLE_ERROR_NONE; + return TABLE_ERROR_NONE; } /* @@ -2455,7 +2455,7 @@ int table_adjust(table_t *table_p, const int bucket_n) */ int table_type_size(void) { - return sizeof(table_t); + return sizeof(table_t); } /************************* linear access routines ****************************/ @@ -2504,44 +2504,44 @@ int table_type_size(void) * associated with the first key. */ int table_first(table_t *table_p, - void **key_buf_p, int *key_size_p, - void **data_buf_p, int *data_size_p) + void **key_buf_p, int *key_size_p, + void **data_buf_p, int *data_size_p) { - table_entry_t *entry_p; + table_entry_t *entry_p; - if (table_p == NULL) { - return TABLE_ERROR_ARG_NULL; - } - if (table_p->ta_magic != TABLE_MAGIC) { - return TABLE_ERROR_PNT; - } + if (table_p == NULL) { + return TABLE_ERROR_ARG_NULL; + } + if (table_p->ta_magic != TABLE_MAGIC) { + return TABLE_ERROR_PNT; + } - /* initialize our linear magic number */ - table_p->ta_linear.tl_magic = LINEAR_MAGIC; + /* initialize our linear magic number */ + table_p->ta_linear.tl_magic = LINEAR_MAGIC; - entry_p = first_entry(table_p, &table_p->ta_linear); - if (entry_p == NULL) { - return TABLE_ERROR_NOT_FOUND; - } + entry_p = first_entry(table_p, &table_p->ta_linear); + if (entry_p == NULL) { + return TABLE_ERROR_NOT_FOUND; + } - SET_POINTER(key_buf_p, ENTRY_KEY_BUF(entry_p)); - SET_POINTER(key_size_p, entry_p->te_key_size); - if (data_buf_p != NULL) { - if (entry_p->te_data_size == 0) { - *data_buf_p = NULL; - } - else { - if (table_p->ta_data_align == 0) { - *data_buf_p = ENTRY_DATA_BUF(table_p, entry_p); - } - else { - *data_buf_p = entry_data_buf(table_p, entry_p); - } - } - } - SET_POINTER(data_size_p, entry_p->te_data_size); + SET_POINTER(key_buf_p, ENTRY_KEY_BUF(entry_p)); + SET_POINTER(key_size_p, entry_p->te_key_size); + if (data_buf_p != NULL) { + if (entry_p->te_data_size == 0) { + *data_buf_p = NULL; + } + else { + if (table_p->ta_data_align == 0) { + *data_buf_p = ENTRY_DATA_BUF(table_p, entry_p); + } + else { + *data_buf_p = entry_data_buf(table_p, entry_p); + } + } + } + SET_POINTER(data_size_p, entry_p->te_data_size); - return TABLE_ERROR_NONE; + return TABLE_ERROR_NONE; } /* @@ -2588,46 +2588,46 @@ int table_first(table_t *table_p, * associated with the next key. */ int table_next(table_t *table_p, - void **key_buf_p, int *key_size_p, - void **data_buf_p, int *data_size_p) + void **key_buf_p, int *key_size_p, + void **data_buf_p, int *data_size_p) { - table_entry_t *entry_p; - int error; + table_entry_t *entry_p; + int error; - if (table_p == NULL) { - return TABLE_ERROR_ARG_NULL; - } - if (table_p->ta_magic != TABLE_MAGIC) { - return TABLE_ERROR_PNT; - } - if (table_p->ta_linear.tl_magic != LINEAR_MAGIC) { - return TABLE_ERROR_LINEAR; - } + if (table_p == NULL) { + return TABLE_ERROR_ARG_NULL; + } + if (table_p->ta_magic != TABLE_MAGIC) { + return TABLE_ERROR_PNT; + } + if (table_p->ta_linear.tl_magic != LINEAR_MAGIC) { + return TABLE_ERROR_LINEAR; + } - /* move to the next entry */ - entry_p = next_entry(table_p, &table_p->ta_linear, &error); - if (entry_p == NULL) { - return error; - } + /* move to the next entry */ + entry_p = next_entry(table_p, &table_p->ta_linear, &error); + if (entry_p == NULL) { + return error; + } - SET_POINTER(key_buf_p, ENTRY_KEY_BUF(entry_p)); - SET_POINTER(key_size_p, entry_p->te_key_size); - if (data_buf_p != NULL) { - if (entry_p->te_data_size == 0) { - *data_buf_p = NULL; - } - else { - if (table_p->ta_data_align == 0) { - *data_buf_p = ENTRY_DATA_BUF(table_p, entry_p); - } - else { - *data_buf_p = entry_data_buf(table_p, entry_p); - } - } - } - SET_POINTER(data_size_p, entry_p->te_data_size); + SET_POINTER(key_buf_p, ENTRY_KEY_BUF(entry_p)); + SET_POINTER(key_size_p, entry_p->te_key_size); + if (data_buf_p != NULL) { + if (entry_p->te_data_size == 0) { + *data_buf_p = NULL; + } + else { + if (table_p->ta_data_align == 0) { + *data_buf_p = ENTRY_DATA_BUF(table_p, entry_p); + } + else { + *data_buf_p = entry_data_buf(table_p, entry_p); + } + } + } + SET_POINTER(data_size_p, entry_p->te_data_size); - return TABLE_ERROR_NONE; + return TABLE_ERROR_NONE; } /* @@ -2673,65 +2673,65 @@ int table_next(table_t *table_p, * associated with the current key. */ int table_this(table_t *table_p, - void **key_buf_p, int *key_size_p, - void **data_buf_p, int *data_size_p) + void **key_buf_p, int *key_size_p, + void **data_buf_p, int *data_size_p) { - table_entry_t *entry_p = NULL; - int entry_c; + table_entry_t *entry_p = NULL; + int entry_c; - if (table_p == NULL) { - return TABLE_ERROR_ARG_NULL; - } - if (table_p->ta_magic != TABLE_MAGIC) { - return TABLE_ERROR_PNT; - } - if (table_p->ta_linear.tl_magic != LINEAR_MAGIC) { - return TABLE_ERROR_LINEAR; - } + if (table_p == NULL) { + return TABLE_ERROR_ARG_NULL; + } + if (table_p->ta_magic != TABLE_MAGIC) { + return TABLE_ERROR_PNT; + } + if (table_p->ta_linear.tl_magic != LINEAR_MAGIC) { + return TABLE_ERROR_LINEAR; + } - /* if we removed an item that shorted the bucket list, we may get this */ - if (table_p->ta_linear.tl_bucket_c >= table_p->ta_bucket_n) { - /* - * NOTE: this might happen if we delete an item which shortens the - * table bucket numbers. - */ - return TABLE_ERROR_NOT_FOUND; - } + /* if we removed an item that shorted the bucket list, we may get this */ + if (table_p->ta_linear.tl_bucket_c >= table_p->ta_bucket_n) { + /* + * NOTE: this might happen if we delete an item which shortens the + * table bucket numbers. + */ + return TABLE_ERROR_NOT_FOUND; + } - /* find the entry which is the nth in the list */ - entry_p = table_p->ta_buckets[table_p->ta_linear.tl_bucket_c]; - /* NOTE: we swap the order here to be more efficient */ - for (entry_c = table_p->ta_linear.tl_entry_c; entry_c > 0; entry_c--) { - /* did we reach the end of the list? */ - if (entry_p == NULL) { - break; - } - entry_p = TABLE_POINTER(table_p, table_entry_t *, entry_p)->te_next_p; - } + /* find the entry which is the nth in the list */ + entry_p = table_p->ta_buckets[table_p->ta_linear.tl_bucket_c]; + /* NOTE: we swap the order here to be more efficient */ + for (entry_c = table_p->ta_linear.tl_entry_c; entry_c > 0; entry_c--) { + /* did we reach the end of the list? */ + if (entry_p == NULL) { + break; + } + entry_p = TABLE_POINTER(table_p, table_entry_t *, entry_p)->te_next_p; + } - /* is this a NOT_FOUND or a LINEAR error */ - if (entry_p == NULL) { - return TABLE_ERROR_NOT_FOUND; - } + /* is this a NOT_FOUND or a LINEAR error */ + if (entry_p == NULL) { + return TABLE_ERROR_NOT_FOUND; + } - SET_POINTER(key_buf_p, ENTRY_KEY_BUF(entry_p)); - SET_POINTER(key_size_p, entry_p->te_key_size); - if (data_buf_p != NULL) { - if (entry_p->te_data_size == 0) { - *data_buf_p = NULL; - } - else { - if (table_p->ta_data_align == 0) { - *data_buf_p = ENTRY_DATA_BUF(table_p, entry_p); - } - else { - *data_buf_p = entry_data_buf(table_p, entry_p); - } - } - } - SET_POINTER(data_size_p, entry_p->te_data_size); + SET_POINTER(key_buf_p, ENTRY_KEY_BUF(entry_p)); + SET_POINTER(key_size_p, entry_p->te_key_size); + if (data_buf_p != NULL) { + if (entry_p->te_data_size == 0) { + *data_buf_p = NULL; + } + else { + if (table_p->ta_data_align == 0) { + *data_buf_p = ENTRY_DATA_BUF(table_p, entry_p); + } + else { + *data_buf_p = entry_data_buf(table_p, entry_p); + } + } + } + SET_POINTER(data_size_p, entry_p->te_data_size); - return TABLE_ERROR_NONE; + return TABLE_ERROR_NONE; } /* @@ -2779,47 +2779,47 @@ int table_this(table_t *table_p, * associated with the first key. */ int table_first_r(table_t *table_p, table_linear_t *linear_p, - void **key_buf_p, int *key_size_p, - void **data_buf_p, int *data_size_p) + void **key_buf_p, int *key_size_p, + void **data_buf_p, int *data_size_p) { - table_entry_t *entry_p; + table_entry_t *entry_p; - if (table_p == NULL) { - return TABLE_ERROR_ARG_NULL; - } - if (table_p->ta_magic != TABLE_MAGIC) { - return TABLE_ERROR_PNT; - } - if (linear_p == NULL) { - return TABLE_ERROR_ARG_NULL; - } + if (table_p == NULL) { + return TABLE_ERROR_ARG_NULL; + } + if (table_p->ta_magic != TABLE_MAGIC) { + return TABLE_ERROR_PNT; + } + if (linear_p == NULL) { + return TABLE_ERROR_ARG_NULL; + } - /* initialize our linear magic number */ - linear_p->tl_magic = LINEAR_MAGIC; + /* initialize our linear magic number */ + linear_p->tl_magic = LINEAR_MAGIC; - entry_p = first_entry(table_p, linear_p); - if (entry_p == NULL) { - return TABLE_ERROR_NOT_FOUND; - } + entry_p = first_entry(table_p, linear_p); + if (entry_p == NULL) { + return TABLE_ERROR_NOT_FOUND; + } - SET_POINTER(key_buf_p, ENTRY_KEY_BUF(entry_p)); - SET_POINTER(key_size_p, entry_p->te_key_size); - if (data_buf_p != NULL) { - if (entry_p->te_data_size == 0) { - *data_buf_p = NULL; - } - else { - if (table_p->ta_data_align == 0) { - *data_buf_p = ENTRY_DATA_BUF(table_p, entry_p); - } - else { - *data_buf_p = entry_data_buf(table_p, entry_p); - } - } - } - SET_POINTER(data_size_p, entry_p->te_data_size); + SET_POINTER(key_buf_p, ENTRY_KEY_BUF(entry_p)); + SET_POINTER(key_size_p, entry_p->te_key_size); + if (data_buf_p != NULL) { + if (entry_p->te_data_size == 0) { + *data_buf_p = NULL; + } + else { + if (table_p->ta_data_align == 0) { + *data_buf_p = ENTRY_DATA_BUF(table_p, entry_p); + } + else { + *data_buf_p = entry_data_buf(table_p, entry_p); + } + } + } + SET_POINTER(data_size_p, entry_p->te_data_size); - return TABLE_ERROR_NONE; + return TABLE_ERROR_NONE; } /* @@ -2867,49 +2867,49 @@ int table_first_r(table_t *table_p, table_linear_t *linear_p, * associated with the next key. */ int table_next_r(table_t *table_p, table_linear_t *linear_p, - void **key_buf_p, int *key_size_p, - void **data_buf_p, int *data_size_p) + void **key_buf_p, int *key_size_p, + void **data_buf_p, int *data_size_p) { - table_entry_t *entry_p; - int error; + table_entry_t *entry_p; + int error; - if (table_p == NULL) { - return TABLE_ERROR_ARG_NULL; - } - if (table_p->ta_magic != TABLE_MAGIC) { - return TABLE_ERROR_PNT; - } - if (linear_p == NULL) { - return TABLE_ERROR_ARG_NULL; - } - if (linear_p->tl_magic != LINEAR_MAGIC) { - return TABLE_ERROR_LINEAR; - } + if (table_p == NULL) { + return TABLE_ERROR_ARG_NULL; + } + if (table_p->ta_magic != TABLE_MAGIC) { + return TABLE_ERROR_PNT; + } + if (linear_p == NULL) { + return TABLE_ERROR_ARG_NULL; + } + if (linear_p->tl_magic != LINEAR_MAGIC) { + return TABLE_ERROR_LINEAR; + } - /* move to the next entry */ - entry_p = next_entry(table_p, linear_p, &error); - if (entry_p == NULL) { - return error; - } + /* move to the next entry */ + entry_p = next_entry(table_p, linear_p, &error); + if (entry_p == NULL) { + return error; + } - SET_POINTER(key_buf_p, ENTRY_KEY_BUF(entry_p)); - SET_POINTER(key_size_p, entry_p->te_key_size); - if (data_buf_p != NULL) { - if (entry_p->te_data_size == 0) { - *data_buf_p = NULL; - } - else { - if (table_p->ta_data_align == 0) { - *data_buf_p = ENTRY_DATA_BUF(table_p, entry_p); - } - else { - *data_buf_p = entry_data_buf(table_p, entry_p); - } - } - } - SET_POINTER(data_size_p, entry_p->te_data_size); + SET_POINTER(key_buf_p, ENTRY_KEY_BUF(entry_p)); + SET_POINTER(key_size_p, entry_p->te_key_size); + if (data_buf_p != NULL) { + if (entry_p->te_data_size == 0) { + *data_buf_p = NULL; + } + else { + if (table_p->ta_data_align == 0) { + *data_buf_p = ENTRY_DATA_BUF(table_p, entry_p); + } + else { + *data_buf_p = entry_data_buf(table_p, entry_p); + } + } + } + SET_POINTER(data_size_p, entry_p->te_data_size); - return TABLE_ERROR_NONE; + return TABLE_ERROR_NONE; } /* @@ -2957,61 +2957,61 @@ int table_next_r(table_t *table_p, table_linear_t *linear_p, * associated with the current key. */ int table_this_r(table_t *table_p, table_linear_t *linear_p, - void **key_buf_p, int *key_size_p, - void **data_buf_p, int *data_size_p) + void **key_buf_p, int *key_size_p, + void **data_buf_p, int *data_size_p) { - table_entry_t *entry_p; - int entry_c; + table_entry_t *entry_p; + int entry_c; - if (table_p == NULL) { - return TABLE_ERROR_ARG_NULL; - } - if (table_p->ta_magic != TABLE_MAGIC) { - return TABLE_ERROR_PNT; - } - if (linear_p->tl_magic != LINEAR_MAGIC) { - return TABLE_ERROR_LINEAR; - } + if (table_p == NULL) { + return TABLE_ERROR_ARG_NULL; + } + if (table_p->ta_magic != TABLE_MAGIC) { + return TABLE_ERROR_PNT; + } + if (linear_p->tl_magic != LINEAR_MAGIC) { + return TABLE_ERROR_LINEAR; + } - /* if we removed an item that shorted the bucket list, we may get this */ - if (linear_p->tl_bucket_c >= table_p->ta_bucket_n) { - /* - * NOTE: this might happen if we delete an item which shortens the - * table bucket numbers. - */ - return TABLE_ERROR_NOT_FOUND; - } + /* if we removed an item that shorted the bucket list, we may get this */ + if (linear_p->tl_bucket_c >= table_p->ta_bucket_n) { + /* + * NOTE: this might happen if we delete an item which shortens the + * table bucket numbers. + */ + return TABLE_ERROR_NOT_FOUND; + } - /* find the entry which is the nth in the list */ - for (entry_c = linear_p->tl_entry_c, - entry_p = table_p->ta_buckets[linear_p->tl_bucket_c]; - entry_p != NULL && entry_c > 0; - entry_c--, entry_p = TABLE_POINTER(table_p, table_entry_t *, - entry_p)->te_next_p) { - } + /* find the entry which is the nth in the list */ + for (entry_c = linear_p->tl_entry_c, + entry_p = table_p->ta_buckets[linear_p->tl_bucket_c]; + entry_p != NULL && entry_c > 0; + entry_c--, entry_p = TABLE_POINTER(table_p, table_entry_t *, + entry_p)->te_next_p) { + } - if (entry_p == NULL) { - return TABLE_ERROR_NOT_FOUND; - } + if (entry_p == NULL) { + return TABLE_ERROR_NOT_FOUND; + } - SET_POINTER(key_buf_p, ENTRY_KEY_BUF(entry_p)); - SET_POINTER(key_size_p, entry_p->te_key_size); - if (data_buf_p != NULL) { - if (entry_p->te_data_size == 0) { - *data_buf_p = NULL; - } - else { - if (table_p->ta_data_align == 0) { - *data_buf_p = ENTRY_DATA_BUF(table_p, entry_p); - } - else { - *data_buf_p = entry_data_buf(table_p, entry_p); - } - } - } - SET_POINTER(data_size_p, entry_p->te_data_size); + SET_POINTER(key_buf_p, ENTRY_KEY_BUF(entry_p)); + SET_POINTER(key_size_p, entry_p->te_key_size); + if (data_buf_p != NULL) { + if (entry_p->te_data_size == 0) { + *data_buf_p = NULL; + } + else { + if (table_p->ta_data_align == 0) { + *data_buf_p = ENTRY_DATA_BUF(table_p, entry_p); + } + else { + *data_buf_p = entry_data_buf(table_p, entry_p); + } + } + } + SET_POINTER(data_size_p, entry_p->te_data_size); - return TABLE_ERROR_NONE; + return TABLE_ERROR_NONE; } /******************************* mmap routines *******************************/ @@ -3040,81 +3040,81 @@ table_t *table_mmap(const char *path, int *error_p) { #ifdef NO_MMAP - /* no mmap support so immediate error */ - SET_POINTER(error_p, TABLE_ERROR_MMAP_NONE); - return NULL; + /* no mmap support so immediate error */ + SET_POINTER(error_p, TABLE_ERROR_MMAP_NONE); + return NULL; #else - table_t *table_p; - struct stat sbuf; - int fd, state; + table_t *table_p; + struct stat sbuf; + int fd, state; - table_p = (table_t *)malloc(sizeof(table_t)); - if (table_p == NULL) { - SET_POINTER(error_p, TABLE_ERROR_ALLOC); - return NULL; - } + table_p = (table_t *)malloc(sizeof(table_t)); + if (table_p == NULL) { + SET_POINTER(error_p, TABLE_ERROR_ALLOC); + return NULL; + } - /* open the mmap file */ - fd = open(path, O_RDONLY, 0); - if (fd < 0) { - free(table_p); - SET_POINTER(error_p, TABLE_ERROR_OPEN); - return NULL; - } + /* open the mmap file */ + fd = open(path, O_RDONLY, 0); + if (fd < 0) { + free(table_p); + SET_POINTER(error_p, TABLE_ERROR_OPEN); + return NULL; + } - /* get the file size */ - if (fstat(fd, &sbuf) != 0) { - free(table_p); - SET_POINTER(error_p, TABLE_ERROR_OPEN); - return NULL; - } + /* get the file size */ + if (fstat(fd, &sbuf) != 0) { + free(table_p); + SET_POINTER(error_p, TABLE_ERROR_OPEN); + return NULL; + } - /* mmap the space and close the file */ + /* mmap the space and close the file */ #ifdef __alpha - state = (MAP_SHARED | MAP_FILE | MAP_VARIABLE); + state = (MAP_SHARED | MAP_FILE | MAP_VARIABLE); #else - state = MAP_SHARED; + state = MAP_SHARED; #endif - table_p->ta_mmap = (table_t *)mmap((caddr_t)0, sbuf.st_size, PROT_READ, - state, fd, 0); - (void)close(fd); + table_p->ta_mmap = (table_t *)mmap((caddr_t)0, sbuf.st_size, PROT_READ, + state, fd, 0); + (void)close(fd); - if (table_p->ta_mmap == (table_t *)MAP_FAILED) { - SET_POINTER(error_p, TABLE_ERROR_MMAP); - return NULL; - } + if (table_p->ta_mmap == (table_t *)MAP_FAILED) { + SET_POINTER(error_p, TABLE_ERROR_MMAP); + return NULL; + } - /* is the mmap file contain bad info or maybe another system type? */ - if (table_p->ta_mmap->ta_magic != TABLE_MAGIC) { - SET_POINTER(error_p, TABLE_ERROR_PNT); - return NULL; - } + /* is the mmap file contain bad info or maybe another system type? */ + if (table_p->ta_mmap->ta_magic != TABLE_MAGIC) { + SET_POINTER(error_p, TABLE_ERROR_PNT); + return NULL; + } - /* sanity check on the file size */ - if (table_p->ta_mmap->ta_file_size != sbuf.st_size) { - SET_POINTER(error_p, TABLE_ERROR_SIZE); - return NULL; - } + /* sanity check on the file size */ + if (table_p->ta_mmap->ta_file_size != sbuf.st_size) { + SET_POINTER(error_p, TABLE_ERROR_SIZE); + return NULL; + } - /* copy the fields out of the mmap file into our memory version */ - table_p->ta_magic = TABLE_MAGIC; - table_p->ta_flags = table_p->ta_mmap->ta_flags; - table_p->ta_bucket_n = table_p->ta_mmap->ta_bucket_n; - table_p->ta_entry_n = table_p->ta_mmap->ta_entry_n; - table_p->ta_data_align = table_p->ta_mmap->ta_data_align; - table_p->ta_buckets = TABLE_POINTER(table_p, table_entry_t **, - table_p->ta_mmap->ta_buckets); - table_p->ta_linear.tl_magic = 0; - table_p->ta_linear.tl_bucket_c = 0; - table_p->ta_linear.tl_entry_c = 0; - /* mmap is already set */ - table_p->ta_file_size = table_p->ta_mmap->ta_file_size; + /* copy the fields out of the mmap file into our memory version */ + table_p->ta_magic = TABLE_MAGIC; + table_p->ta_flags = table_p->ta_mmap->ta_flags; + table_p->ta_bucket_n = table_p->ta_mmap->ta_bucket_n; + table_p->ta_entry_n = table_p->ta_mmap->ta_entry_n; + table_p->ta_data_align = table_p->ta_mmap->ta_data_align; + table_p->ta_buckets = TABLE_POINTER(table_p, table_entry_t **, + table_p->ta_mmap->ta_buckets); + table_p->ta_linear.tl_magic = 0; + table_p->ta_linear.tl_bucket_c = 0; + table_p->ta_linear.tl_entry_c = 0; + /* mmap is already set */ + table_p->ta_file_size = table_p->ta_mmap->ta_file_size; - SET_POINTER(error_p, TABLE_ERROR_NONE); - return table_p; + SET_POINTER(error_p, TABLE_ERROR_NONE); + return table_p; #endif } @@ -3138,25 +3138,25 @@ int table_munmap(table_t *table_p) { #ifdef NO_MMAP - /* no mmap support so immediate error */ - return TABLE_ERROR_MMAP_NONE; + /* no mmap support so immediate error */ + return TABLE_ERROR_MMAP_NONE; #else - if (table_p == NULL) { - return TABLE_ERROR_ARG_NULL; - } - if (table_p->ta_magic != TABLE_MAGIC) { - return TABLE_ERROR_PNT; - } - if (table_p->ta_mmap == NULL) { - return TABLE_ERROR_PNT; - } + if (table_p == NULL) { + return TABLE_ERROR_ARG_NULL; + } + if (table_p->ta_magic != TABLE_MAGIC) { + return TABLE_ERROR_PNT; + } + if (table_p->ta_mmap == NULL) { + return TABLE_ERROR_PNT; + } - (void)munmap((caddr_t)table_p->ta_mmap, table_p->ta_file_size); - table_p->ta_magic = 0; - free(table_p); - return TABLE_ERROR_NONE; + (void)munmap((caddr_t)table_p->ta_mmap, table_p->ta_file_size); + table_p->ta_magic = 0; + free(table_p); + return TABLE_ERROR_NONE; #endif } @@ -3187,146 +3187,146 @@ int table_munmap(table_t *table_p) */ table_t *table_read(const char *path, int *error_p) { - unsigned int size; - int fd, ent_size; - FILE *infile; - table_entry_t entry, **bucket_p, *entry_p = NULL, *last_p; - unsigned long pos; - table_t *table_p; + unsigned int size; + int fd, ent_size; + FILE *infile; + table_entry_t entry, **bucket_p, *entry_p = NULL, *last_p; + unsigned long pos; + table_t *table_p; - /* open the file */ - fd = open(path, O_RDONLY, 0); - if (fd < 0) { - SET_POINTER(error_p, TABLE_ERROR_OPEN); - return NULL; - } - - /* allocate a table structure */ - table_p = malloc(sizeof(table_t)); - if (table_p == NULL) { - SET_POINTER(error_p, TABLE_ERROR_ALLOC); - return NULL; - } - - /* now open the fd to get buffered i/o */ - infile = fdopen(fd, "r"); - if (infile == NULL) { - SET_POINTER(error_p, TABLE_ERROR_OPEN); - return NULL; - } - - /* read the main table struct */ - if (fread(table_p, sizeof(table_t), 1, infile) != 1) { - SET_POINTER(error_p, TABLE_ERROR_READ); - free(table_p); - return NULL; - } - table_p->ta_file_size = 0; - - /* is the mmap file contain bad info or maybe another system type? */ - if (table_p->ta_magic != TABLE_MAGIC) { - SET_POINTER(error_p, TABLE_ERROR_PNT); - return NULL; - } - - /* allocate the buckets */ - table_p->ta_buckets = (table_entry_t **)calloc(table_p->ta_bucket_n, - sizeof(table_entry_t *)); - if (table_p->ta_buckets == NULL) { - SET_POINTER(error_p, TABLE_ERROR_ALLOC); - free(table_p); - return NULL; - } - - if (fread(table_p->ta_buckets, sizeof(table_entry_t *), table_p->ta_bucket_n, - infile) != (size_t)table_p->ta_bucket_n) { - SET_POINTER(error_p, TABLE_ERROR_READ); - free(table_p->ta_buckets); - free(table_p); - return NULL; - } - - /* read in the entries */ - for (bucket_p = table_p->ta_buckets; - bucket_p < table_p->ta_buckets + table_p->ta_bucket_n; - bucket_p++) { - - /* skip null buckets */ - if (*bucket_p == NULL) { - continue; - } - - /* run through the entry list */ - last_p = NULL; - for (pos = *(unsigned long *)bucket_p;; - pos = (unsigned long)entry_p->te_next_p) { - - /* read in the entry */ - if (fseek(infile, pos, SEEK_SET) != 0) { - SET_POINTER(error_p, TABLE_ERROR_SEEK); - free(table_p->ta_buckets); - free(table_p); - if (entry_p != NULL) { - free(entry_p); + /* open the file */ + fd = open(path, O_RDONLY, 0); + if (fd < 0) { + SET_POINTER(error_p, TABLE_ERROR_OPEN); + return NULL; } - /* the other table elements will not be freed */ - return NULL; - } - if (fread(&entry, sizeof(struct table_shell_st), 1, infile) != 1) { - SET_POINTER(error_p, TABLE_ERROR_READ); - free(table_p->ta_buckets); - free(table_p); - if (entry_p != NULL) { - free(entry_p); + + /* allocate a table structure */ + table_p = malloc(sizeof(table_t)); + if (table_p == NULL) { + SET_POINTER(error_p, TABLE_ERROR_ALLOC); + return NULL; } - /* the other table elements will not be freed */ - return NULL; - } - - /* make a new entry */ - ent_size = entry_size(table_p, entry.te_key_size, entry.te_data_size); - entry_p = (table_entry_t *)malloc(ent_size); - if (entry_p == NULL) { - SET_POINTER(error_p, TABLE_ERROR_ALLOC); - free(table_p->ta_buckets); - free(table_p); - /* the other table elements will not be freed */ - return NULL; - } - entry_p->te_key_size = entry.te_key_size; - entry_p->te_data_size = entry.te_data_size; - entry_p->te_next_p = entry.te_next_p; - - if (last_p == NULL) { - *bucket_p = entry_p; - } - else { - last_p->te_next_p = entry_p; - } - - /* determine how much more we have to read */ - size = ent_size - sizeof(struct table_shell_st); - if (fread(ENTRY_KEY_BUF(entry_p), sizeof(char), size, infile) != size) { - SET_POINTER(error_p, TABLE_ERROR_READ); - free(table_p->ta_buckets); - free(table_p); - free(entry_p); - /* the other table elements will not be freed */ - return NULL; - } - - /* we are done if the next pointer is null */ - if (entry_p->te_next_p == (unsigned long)0) { - break; - } - last_p = entry_p; - } - } - (void)fclose(infile); + /* now open the fd to get buffered i/o */ + infile = fdopen(fd, "r"); + if (infile == NULL) { + SET_POINTER(error_p, TABLE_ERROR_OPEN); + return NULL; + } - SET_POINTER(error_p, TABLE_ERROR_NONE); - return table_p; + /* read the main table struct */ + if (fread(table_p, sizeof(table_t), 1, infile) != 1) { + SET_POINTER(error_p, TABLE_ERROR_READ); + free(table_p); + return NULL; + } + table_p->ta_file_size = 0; + + /* is the mmap file contain bad info or maybe another system type? */ + if (table_p->ta_magic != TABLE_MAGIC) { + SET_POINTER(error_p, TABLE_ERROR_PNT); + return NULL; + } + + /* allocate the buckets */ + table_p->ta_buckets = (table_entry_t **)calloc(table_p->ta_bucket_n, + sizeof(table_entry_t *)); + if (table_p->ta_buckets == NULL) { + SET_POINTER(error_p, TABLE_ERROR_ALLOC); + free(table_p); + return NULL; + } + + if (fread(table_p->ta_buckets, sizeof(table_entry_t *), table_p->ta_bucket_n, + infile) != (size_t)table_p->ta_bucket_n) { + SET_POINTER(error_p, TABLE_ERROR_READ); + free(table_p->ta_buckets); + free(table_p); + return NULL; + } + + /* read in the entries */ + for (bucket_p = table_p->ta_buckets; + bucket_p < table_p->ta_buckets + table_p->ta_bucket_n; + bucket_p++) { + + /* skip null buckets */ + if (*bucket_p == NULL) { + continue; + } + + /* run through the entry list */ + last_p = NULL; + for (pos = *(unsigned long *)bucket_p;; + pos = (unsigned long)entry_p->te_next_p) { + + /* read in the entry */ + if (fseek(infile, pos, SEEK_SET) != 0) { + SET_POINTER(error_p, TABLE_ERROR_SEEK); + free(table_p->ta_buckets); + free(table_p); + if (entry_p != NULL) { + free(entry_p); + } + /* the other table elements will not be freed */ + return NULL; + } + if (fread(&entry, sizeof(struct table_shell_st), 1, infile) != 1) { + SET_POINTER(error_p, TABLE_ERROR_READ); + free(table_p->ta_buckets); + free(table_p); + if (entry_p != NULL) { + free(entry_p); + } + /* the other table elements will not be freed */ + return NULL; + } + + /* make a new entry */ + ent_size = entry_size(table_p, entry.te_key_size, entry.te_data_size); + entry_p = (table_entry_t *)malloc(ent_size); + if (entry_p == NULL) { + SET_POINTER(error_p, TABLE_ERROR_ALLOC); + free(table_p->ta_buckets); + free(table_p); + /* the other table elements will not be freed */ + return NULL; + } + entry_p->te_key_size = entry.te_key_size; + entry_p->te_data_size = entry.te_data_size; + entry_p->te_next_p = entry.te_next_p; + + if (last_p == NULL) { + *bucket_p = entry_p; + } + else { + last_p->te_next_p = entry_p; + } + + /* determine how much more we have to read */ + size = ent_size - sizeof(struct table_shell_st); + if (fread(ENTRY_KEY_BUF(entry_p), sizeof(char), size, infile) != size) { + SET_POINTER(error_p, TABLE_ERROR_READ); + free(table_p->ta_buckets); + free(table_p); + free(entry_p); + /* the other table elements will not be freed */ + return NULL; + } + + /* we are done if the next pointer is null */ + if (entry_p->te_next_p == (unsigned long)0) { + break; + } + last_p = entry_p; + } + } + + (void)fclose(infile); + + SET_POINTER(error_p, TABLE_ERROR_NONE); + return table_p; } /* @@ -3353,186 +3353,186 @@ table_t *table_read(const char *path, int *error_p) */ int table_write(const table_t *table_p, const char *path, const int mode) { - int fd, rem, ent_size; - unsigned int bucket_c, bucket_size; - unsigned long size; - table_entry_t *entry_p, **buckets, **bucket_p, *next_p; - table_t main_tab; - FILE *outfile; + int fd, rem, ent_size; + unsigned int bucket_c, bucket_size; + unsigned long size; + table_entry_t *entry_p, **buckets, **bucket_p, *next_p; + table_t main_tab; + FILE *outfile; - if (table_p == NULL) { - return TABLE_ERROR_ARG_NULL; - } - if (table_p->ta_magic != TABLE_MAGIC) { - return TABLE_ERROR_PNT; - } + if (table_p == NULL) { + return TABLE_ERROR_ARG_NULL; + } + if (table_p->ta_magic != TABLE_MAGIC) { + return TABLE_ERROR_PNT; + } - fd = open(path, O_WRONLY | O_CREAT, mode); - if (fd < 0) { - return TABLE_ERROR_OPEN; - } + fd = open(path, O_WRONLY | O_CREAT, mode); + if (fd < 0) { + return TABLE_ERROR_OPEN; + } - outfile = fdopen(fd, "w"); - if (outfile == NULL) { - return TABLE_ERROR_OPEN; - } + outfile = fdopen(fd, "w"); + if (outfile == NULL) { + return TABLE_ERROR_OPEN; + } - /* allocate a block of sizes for each bucket */ - bucket_size = sizeof(table_entry_t *) * table_p->ta_bucket_n; - if (table_p->ta_alloc_func == NULL) { - buckets = (table_entry_t **)malloc(bucket_size); - } - else { - buckets = - (table_entry_t **)table_p->ta_alloc_func(table_p->ta_mem_pool, - bucket_size); - } - if (buckets == NULL) { - return TABLE_ERROR_ALLOC; - } - - /* make a copy of the main struct */ - main_tab = *table_p; - - /* start counting the bytes */ - size = 0; - size += sizeof(table_t); - - /* buckets go right after main struct */ - main_tab.ta_buckets = (table_entry_t **)size; - size += sizeof(table_entry_t *) * table_p->ta_bucket_n; - - /* run through and count the buckets */ - for (bucket_c = 0; bucket_c < table_p->ta_bucket_n; bucket_c++) { - bucket_p = table_p->ta_buckets + bucket_c; - if (*bucket_p == NULL) { - buckets[bucket_c] = NULL; - continue; - } - buckets[bucket_c] = (table_entry_t *)size; - for (entry_p = *bucket_p; entry_p != NULL; entry_p = entry_p->te_next_p) { - size += entry_size(table_p, entry_p->te_key_size, entry_p->te_data_size); - /* - * We now have to round the file to the nearest long so the - * mmaping of the longs in the entry structs will work. - */ - rem = size & (sizeof(long) - 1); - if (rem > 0) { - size += sizeof(long) - rem; - } - } - } - /* add a \0 at the end to fill the last section */ - size++; - - /* set the main fields */ - main_tab.ta_linear.tl_magic = 0; - main_tab.ta_linear.tl_bucket_c = 0; - main_tab.ta_linear.tl_entry_c = 0; - main_tab.ta_mmap = NULL; - main_tab.ta_file_size = size; - - /* - * Now we can start the writing because we got the bucket offsets. - */ - - /* write the main table struct */ - size = 0; - if (fwrite(&main_tab, sizeof(table_t), 1, outfile) != 1) { - if (table_p->ta_free_func == NULL) { - free(buckets); - } - else { - (void)table_p->ta_free_func(table_p->ta_mem_pool, buckets, bucket_size); - } - return TABLE_ERROR_WRITE; - } - size += sizeof(table_t); - if (fwrite(buckets, sizeof(table_entry_t *), table_p->ta_bucket_n, - outfile) != (size_t)table_p->ta_bucket_n) { - if (table_p->ta_free_func == NULL) { - free(buckets); - } - else { - (void)table_p->ta_free_func(table_p->ta_mem_pool, buckets, bucket_size); - } - return TABLE_ERROR_WRITE; - } - size += sizeof(table_entry_t *) * table_p->ta_bucket_n; - - /* write out the entries */ - for (bucket_p = table_p->ta_buckets; - bucket_p < table_p->ta_buckets + table_p->ta_bucket_n; - bucket_p++) { - for (entry_p = *bucket_p; entry_p != NULL; entry_p = entry_p->te_next_p) { - - ent_size = entry_size(table_p, entry_p->te_key_size, - entry_p->te_data_size); - size += ent_size; - /* round to nearest long here so we can write copy */ - rem = size & (sizeof(long) - 1); - if (rem > 0) { - size += sizeof(long) - rem; - } - next_p = entry_p->te_next_p; - if (next_p != NULL) { - entry_p->te_next_p = (table_entry_t *)size; - } - - /* now write to disk */ - if (fwrite(entry_p, ent_size, 1, outfile) != 1) { - if (table_p->ta_free_func == NULL) { - free(buckets); + /* allocate a block of sizes for each bucket */ + bucket_size = sizeof(table_entry_t *) * table_p->ta_bucket_n; + if (table_p->ta_alloc_func == NULL) { + buckets = (table_entry_t **)malloc(bucket_size); } else { - (void)table_p->ta_free_func(table_p->ta_mem_pool, buckets, - bucket_size); + buckets = + (table_entry_t **)table_p->ta_alloc_func(table_p->ta_mem_pool, + bucket_size); } - return TABLE_ERROR_WRITE; - } - - /* restore the next pointer */ - if (next_p != NULL) { - entry_p->te_next_p = next_p; - } - - /* now write the padding information */ - if (rem > 0) { - rem = sizeof(long) - rem; + if (buckets == NULL) { + return TABLE_ERROR_ALLOC; + } + + /* make a copy of the main struct */ + main_tab = *table_p; + + /* start counting the bytes */ + size = 0; + size += sizeof(table_t); + + /* buckets go right after main struct */ + main_tab.ta_buckets = (table_entry_t **)size; + size += sizeof(table_entry_t *) * table_p->ta_bucket_n; + + /* run through and count the buckets */ + for (bucket_c = 0; bucket_c < table_p->ta_bucket_n; bucket_c++) { + bucket_p = table_p->ta_buckets + bucket_c; + if (*bucket_p == NULL) { + buckets[bucket_c] = NULL; + continue; + } + buckets[bucket_c] = (table_entry_t *)size; + for (entry_p = *bucket_p; entry_p != NULL; entry_p = entry_p->te_next_p) { + size += entry_size(table_p, entry_p->te_key_size, entry_p->te_data_size); + /* + * We now have to round the file to the nearest long so the + * mmaping of the longs in the entry structs will work. + */ + rem = size & (sizeof(long) - 1); + if (rem > 0) { + size += sizeof(long) - rem; + } + } + } + /* add a \0 at the end to fill the last section */ + size++; + + /* set the main fields */ + main_tab.ta_linear.tl_magic = 0; + main_tab.ta_linear.tl_bucket_c = 0; + main_tab.ta_linear.tl_entry_c = 0; + main_tab.ta_mmap = NULL; + main_tab.ta_file_size = size; + /* - * NOTE: this won't leave fseek'd space at the end but we - * don't care there because there is no accessed memory - * afterwards. We write 1 \0 at the end to make sure. + * Now we can start the writing because we got the bucket offsets. */ - if (fseek(outfile, rem, SEEK_CUR) != 0) { - if (table_p->ta_free_func == NULL) { - free(buckets); - } - else { - (void)table_p->ta_free_func(table_p->ta_mem_pool, buckets, - bucket_size); - } - return TABLE_ERROR_SEEK; + + /* write the main table struct */ + size = 0; + if (fwrite(&main_tab, sizeof(table_t), 1, outfile) != 1) { + if (table_p->ta_free_func == NULL) { + free(buckets); + } + else { + (void)table_p->ta_free_func(table_p->ta_mem_pool, buckets, bucket_size); + } + return TABLE_ERROR_WRITE; } - } - } - } - /* - * Write a \0 at the end of the file to make sure that the last - * fseek filled with nulls. - */ - (void)fputc('\0', outfile); + size += sizeof(table_t); + if (fwrite(buckets, sizeof(table_entry_t *), table_p->ta_bucket_n, + outfile) != (size_t)table_p->ta_bucket_n) { + if (table_p->ta_free_func == NULL) { + free(buckets); + } + else { + (void)table_p->ta_free_func(table_p->ta_mem_pool, buckets, bucket_size); + } + return TABLE_ERROR_WRITE; + } + size += sizeof(table_entry_t *) * table_p->ta_bucket_n; - (void)fclose(outfile); - if (table_p->ta_free_func == NULL) { - free(buckets); - } - else if (! table_p->ta_free_func(table_p->ta_mem_pool, buckets, - bucket_size)) { - return TABLE_ERROR_FREE; - } + /* write out the entries */ + for (bucket_p = table_p->ta_buckets; + bucket_p < table_p->ta_buckets + table_p->ta_bucket_n; + bucket_p++) { + for (entry_p = *bucket_p; entry_p != NULL; entry_p = entry_p->te_next_p) { + + ent_size = entry_size(table_p, entry_p->te_key_size, + entry_p->te_data_size); + size += ent_size; + /* round to nearest long here so we can write copy */ + rem = size & (sizeof(long) - 1); + if (rem > 0) { + size += sizeof(long) - rem; + } + next_p = entry_p->te_next_p; + if (next_p != NULL) { + entry_p->te_next_p = (table_entry_t *)size; + } + + /* now write to disk */ + if (fwrite(entry_p, ent_size, 1, outfile) != 1) { + if (table_p->ta_free_func == NULL) { + free(buckets); + } + else { + (void)table_p->ta_free_func(table_p->ta_mem_pool, buckets, + bucket_size); + } + return TABLE_ERROR_WRITE; + } + + /* restore the next pointer */ + if (next_p != NULL) { + entry_p->te_next_p = next_p; + } + + /* now write the padding information */ + if (rem > 0) { + rem = sizeof(long) - rem; + /* + * NOTE: this won't leave fseek'd space at the end but we + * don't care there because there is no accessed memory + * afterwards. We write 1 \0 at the end to make sure. + */ + if (fseek(outfile, rem, SEEK_CUR) != 0) { + if (table_p->ta_free_func == NULL) { + free(buckets); + } + else { + (void)table_p->ta_free_func(table_p->ta_mem_pool, buckets, + bucket_size); + } + return TABLE_ERROR_SEEK; + } + } + } + } + /* + * Write a \0 at the end of the file to make sure that the last + * fseek filled with nulls. + */ + (void)fputc('\0', outfile); - return TABLE_ERROR_NONE; + (void)fclose(outfile); + if (table_p->ta_free_func == NULL) { + free(buckets); + } + else if (! table_p->ta_free_func(table_p->ta_mem_pool, buckets, + bucket_size)) { + return TABLE_ERROR_FREE; + } + + return TABLE_ERROR_NONE; } /******************************** table order ********************************/ @@ -3572,104 +3572,104 @@ int table_write(const table_t *table_p, const char *path, const int mode) * table error code. */ table_entry_t **table_order(table_t *table_p, table_compare_t compare, - int *num_entries_p, int *error_p) + int *num_entries_p, int *error_p) { - table_entry_t *entry_p, **entries, **entries_p; - table_linear_t linear; - compare_t comp_func; - unsigned int entries_size; - int ret; + table_entry_t *entry_p, **entries, **entries_p; + table_linear_t linear; + compare_t comp_func; + unsigned int entries_size; + int ret; - if (table_p == NULL) { - SET_POINTER(error_p, TABLE_ERROR_ARG_NULL); - return NULL; - } - if (table_p->ta_magic != TABLE_MAGIC) { - SET_POINTER(error_p, TABLE_ERROR_PNT); - return NULL; - } + if (table_p == NULL) { + SET_POINTER(error_p, TABLE_ERROR_ARG_NULL); + return NULL; + } + if (table_p->ta_magic != TABLE_MAGIC) { + SET_POINTER(error_p, TABLE_ERROR_PNT); + return NULL; + } - /* there must be at least 1 element in the table for this to work */ - if (table_p->ta_entry_n == 0) { - SET_POINTER(error_p, TABLE_ERROR_EMPTY); - return NULL; - } + /* there must be at least 1 element in the table for this to work */ + if (table_p->ta_entry_n == 0) { + SET_POINTER(error_p, TABLE_ERROR_EMPTY); + return NULL; + } - entries_size = table_p->ta_entry_n * sizeof(table_entry_t *); - if (table_p->ta_alloc_func == NULL) { - entries = (table_entry_t **)malloc(entries_size); - } - else { - entries = - (table_entry_t **)table_p->ta_alloc_func(table_p->ta_mem_pool, - entries_size); - } - if (entries == NULL) { - SET_POINTER(error_p, TABLE_ERROR_ALLOC); - return NULL; - } + entries_size = table_p->ta_entry_n * sizeof(table_entry_t *); + if (table_p->ta_alloc_func == NULL) { + entries = (table_entry_t **)malloc(entries_size); + } + else { + entries = + (table_entry_t **)table_p->ta_alloc_func(table_p->ta_mem_pool, + entries_size); + } + if (entries == NULL) { + SET_POINTER(error_p, TABLE_ERROR_ALLOC); + return NULL; + } - /* get a pointer to all entries */ - entry_p = first_entry(table_p, &linear); - if (entry_p == NULL) { - if (table_p->ta_free_func == NULL) { - free(entries); - } - else { - (void)table_p->ta_free_func(table_p->ta_mem_pool, entries, entries_size); - } - SET_POINTER(error_p, TABLE_ERROR_NOT_FOUND); - return NULL; - } + /* get a pointer to all entries */ + entry_p = first_entry(table_p, &linear); + if (entry_p == NULL) { + if (table_p->ta_free_func == NULL) { + free(entries); + } + else { + (void)table_p->ta_free_func(table_p->ta_mem_pool, entries, entries_size); + } + SET_POINTER(error_p, TABLE_ERROR_NOT_FOUND); + return NULL; + } - /* add all of the entries to the array */ - for (entries_p = entries; - entry_p != NULL; - entry_p = next_entry(table_p, &linear, &ret)) { - *entries_p++ = entry_p; - } + /* add all of the entries to the array */ + for (entries_p = entries; + entry_p != NULL; + entry_p = next_entry(table_p, &linear, &ret)) { + *entries_p++ = entry_p; + } - if (ret != TABLE_ERROR_NOT_FOUND) { - if (table_p->ta_free_func == NULL) { - free(entries); - } - else { - (void)table_p->ta_free_func(table_p->ta_mem_pool, entries, entries_size); - } - SET_POINTER(error_p, ret); - return NULL; - } + if (ret != TABLE_ERROR_NOT_FOUND) { + if (table_p->ta_free_func == NULL) { + free(entries); + } + else { + (void)table_p->ta_free_func(table_p->ta_mem_pool, entries, entries_size); + } + SET_POINTER(error_p, ret); + return NULL; + } - if (compare == NULL) { - /* this is regardless of the alignment */ - comp_func = local_compare; - } - else if (table_p->ta_data_align == 0) { - comp_func = external_compare; - } - else { - comp_func = external_compare_align; - } + if (compare == NULL) { + /* this is regardless of the alignment */ + comp_func = local_compare; + } + else if (table_p->ta_data_align == 0) { + comp_func = external_compare; + } + else { + comp_func = external_compare_align; + } - /* now qsort the entire entries array from first to last element */ - ret = split((unsigned char *)entries, - (unsigned char *)(entries + table_p->ta_entry_n - 1), - sizeof(table_entry_t *), comp_func, compare, table_p); - if (ret != TABLE_ERROR_NONE) { - if (table_p->ta_free_func == NULL) { - free(entries); - } - else { - (void)table_p->ta_free_func(table_p->ta_mem_pool, entries, entries_size); - } - SET_POINTER(error_p, ret); - return NULL; - } + /* now qsort the entire entries array from first to last element */ + ret = split((unsigned char *)entries, + (unsigned char *)(entries + table_p->ta_entry_n - 1), + sizeof(table_entry_t *), comp_func, compare, table_p); + if (ret != TABLE_ERROR_NONE) { + if (table_p->ta_free_func == NULL) { + free(entries); + } + else { + (void)table_p->ta_free_func(table_p->ta_mem_pool, entries, entries_size); + } + SET_POINTER(error_p, ret); + return NULL; + } - SET_POINTER(num_entries_p, table_p->ta_entry_n); + SET_POINTER(num_entries_p, table_p->ta_entry_n); - SET_POINTER(error_p, TABLE_ERROR_NONE); - return entries; + SET_POINTER(error_p, TABLE_ERROR_NONE); + return entries; } /* @@ -3697,29 +3697,29 @@ table_entry_t **table_order(table_t *table_p, table_compare_t compare, * table_order or table_order_pos in num_entries_p. */ int table_order_free(table_t *table_p, table_entry_t **table_entries, - const int entry_n) + const int entry_n) { - int ret, final = TABLE_ERROR_NONE; + int ret, final = TABLE_ERROR_NONE; - if (table_p == NULL) { - return TABLE_ERROR_ARG_NULL; - } - if (table_p->ta_magic != TABLE_MAGIC) { - return TABLE_ERROR_PNT; - } + if (table_p == NULL) { + return TABLE_ERROR_ARG_NULL; + } + if (table_p->ta_magic != TABLE_MAGIC) { + return TABLE_ERROR_PNT; + } - if (table_p->ta_free_func == NULL) { - free(table_entries); - } - else { - ret = table_p->ta_free_func(table_p->ta_mem_pool, table_entries, - sizeof(table_entry_t *) * entry_n); - if (ret != 1) { - final = TABLE_ERROR_FREE; - } - } + if (table_p->ta_free_func == NULL) { + free(table_entries); + } + else { + ret = table_p->ta_free_func(table_p->ta_mem_pool, table_entries, + sizeof(table_entry_t *) * entry_n); + if (ret != 1) { + final = TABLE_ERROR_FREE; + } + } - return final; + return final; } /* @@ -3762,37 +3762,37 @@ int table_order_free(table_t *table_p, table_entry_t **table_entries, * to the size of the data that is stored in the table. */ int table_entry(table_t *table_p, table_entry_t *entry_p, - void **key_buf_p, int *key_size_p, - void **data_buf_p, int *data_size_p) + void **key_buf_p, int *key_size_p, + void **data_buf_p, int *data_size_p) { - if (table_p == NULL) { - return TABLE_ERROR_ARG_NULL; - } - if (table_p->ta_magic != TABLE_MAGIC) { - return TABLE_ERROR_PNT; - } - if (entry_p == NULL) { - return TABLE_ERROR_ARG_NULL; - } + if (table_p == NULL) { + return TABLE_ERROR_ARG_NULL; + } + if (table_p->ta_magic != TABLE_MAGIC) { + return TABLE_ERROR_PNT; + } + if (entry_p == NULL) { + return TABLE_ERROR_ARG_NULL; + } - SET_POINTER(key_buf_p, ENTRY_KEY_BUF(entry_p)); - SET_POINTER(key_size_p, entry_p->te_key_size); - if (data_buf_p != NULL) { - if (entry_p->te_data_size == 0) { - *data_buf_p = NULL; - } - else { - if (table_p->ta_data_align == 0) { - *data_buf_p = ENTRY_DATA_BUF(table_p, entry_p); - } - else { - *data_buf_p = entry_data_buf(table_p, entry_p); - } - } - } - SET_POINTER(data_size_p, entry_p->te_data_size); + SET_POINTER(key_buf_p, ENTRY_KEY_BUF(entry_p)); + SET_POINTER(key_size_p, entry_p->te_key_size); + if (data_buf_p != NULL) { + if (entry_p->te_data_size == 0) { + *data_buf_p = NULL; + } + else { + if (table_p->ta_data_align == 0) { + *data_buf_p = ENTRY_DATA_BUF(table_p, entry_p); + } + else { + *data_buf_p = entry_data_buf(table_p, entry_p); + } + } + } + SET_POINTER(data_size_p, entry_p->te_data_size); - return TABLE_ERROR_NONE; + return TABLE_ERROR_NONE; } /* @@ -3830,84 +3830,84 @@ int table_entry(table_t *table_p, table_entry_t *entry_p, * table error code. */ table_linear_t *table_order_pos(table_t *table_p, table_compare_t compare, - int *num_entries_p, int *error_p) + int *num_entries_p, int *error_p) { - table_entry_t *entry_p; - table_linear_t linear, *linears, *linears_p; - compare_t comp_func; - int ret; + table_entry_t *entry_p; + table_linear_t linear, *linears, *linears_p; + compare_t comp_func; + int ret; - if (table_p == NULL) { - SET_POINTER(error_p, TABLE_ERROR_ARG_NULL); - return NULL; - } - if (table_p->ta_magic != TABLE_MAGIC) { - SET_POINTER(error_p, TABLE_ERROR_PNT); - return NULL; - } + if (table_p == NULL) { + SET_POINTER(error_p, TABLE_ERROR_ARG_NULL); + return NULL; + } + if (table_p->ta_magic != TABLE_MAGIC) { + SET_POINTER(error_p, TABLE_ERROR_PNT); + return NULL; + } - /* there must be at least 1 element in the table for this to work */ - if (table_p->ta_entry_n == 0) { - SET_POINTER(error_p, TABLE_ERROR_EMPTY); - return NULL; - } + /* there must be at least 1 element in the table for this to work */ + if (table_p->ta_entry_n == 0) { + SET_POINTER(error_p, TABLE_ERROR_EMPTY); + return NULL; + } - if (table_p->ta_alloc_func == NULL) { - linears = (table_linear_t *)malloc(table_p->ta_entry_n * - sizeof(table_linear_t)); - } - else { - linears = - (table_linear_t *)table_p->ta_alloc_func(table_p->ta_mem_pool, - table_p->ta_entry_n * - sizeof(table_linear_t)); - } - if (linears == NULL) { - SET_POINTER(error_p, TABLE_ERROR_ALLOC); - return NULL; - } + if (table_p->ta_alloc_func == NULL) { + linears = (table_linear_t *)malloc(table_p->ta_entry_n * + sizeof(table_linear_t)); + } + else { + linears = + (table_linear_t *)table_p->ta_alloc_func(table_p->ta_mem_pool, + table_p->ta_entry_n * + sizeof(table_linear_t)); + } + if (linears == NULL) { + SET_POINTER(error_p, TABLE_ERROR_ALLOC); + return NULL; + } - /* get a pointer to all entries */ - entry_p = first_entry(table_p, &linear); - if (entry_p == NULL) { - SET_POINTER(error_p, TABLE_ERROR_NOT_FOUND); - return NULL; - } + /* get a pointer to all entries */ + entry_p = first_entry(table_p, &linear); + if (entry_p == NULL) { + SET_POINTER(error_p, TABLE_ERROR_NOT_FOUND); + return NULL; + } - /* add all of the entries to the array */ - for (linears_p = linears; - entry_p != NULL; - entry_p = next_entry(table_p, &linear, &ret)) { - *linears_p++ = linear; - } + /* add all of the entries to the array */ + for (linears_p = linears; + entry_p != NULL; + entry_p = next_entry(table_p, &linear, &ret)) { + *linears_p++ = linear; + } - if (ret != TABLE_ERROR_NOT_FOUND) { - SET_POINTER(error_p, ret); - return NULL; - } + if (ret != TABLE_ERROR_NOT_FOUND) { + SET_POINTER(error_p, ret); + return NULL; + } - if (compare == NULL) { - /* this is regardless of the alignment */ - comp_func = local_compare_pos; - } - else if (table_p->ta_data_align == 0) { - comp_func = external_compare_pos; - } - else { - comp_func = external_compare_align_pos; - } + if (compare == NULL) { + /* this is regardless of the alignment */ + comp_func = local_compare_pos; + } + else if (table_p->ta_data_align == 0) { + comp_func = external_compare_pos; + } + else { + comp_func = external_compare_align_pos; + } - /* now qsort the entire entries array from first to last element */ - split((unsigned char *)linears, - (unsigned char *)(linears + table_p->ta_entry_n - 1), - sizeof(table_linear_t), comp_func, compare, table_p); + /* now qsort the entire entries array from first to last element */ + split((unsigned char *)linears, + (unsigned char *)(linears + table_p->ta_entry_n - 1), + sizeof(table_linear_t), comp_func, compare, table_p); - if (num_entries_p != NULL) { - *num_entries_p = table_p->ta_entry_n; - } + if (num_entries_p != NULL) { + *num_entries_p = table_p->ta_entry_n; + } - SET_POINTER(error_p, TABLE_ERROR_NONE); - return linears; + SET_POINTER(error_p, TABLE_ERROR_NONE); + return linears; } /* @@ -3935,29 +3935,29 @@ table_linear_t *table_order_pos(table_t *table_p, table_compare_t compare, * table_order or table_order_pos in num_entries_p. */ int table_order_pos_free(table_t *table_p, table_linear_t *table_entries, - const int entry_n) + const int entry_n) { - int ret, final = TABLE_ERROR_NONE; + int ret, final = TABLE_ERROR_NONE; - if (table_p == NULL) { - return TABLE_ERROR_ARG_NULL; - } - if (table_p->ta_magic != TABLE_MAGIC) { - return TABLE_ERROR_PNT; - } + if (table_p == NULL) { + return TABLE_ERROR_ARG_NULL; + } + if (table_p->ta_magic != TABLE_MAGIC) { + return TABLE_ERROR_PNT; + } - if (table_p->ta_free_func == NULL) { - free(table_entries); - } - else { - ret = table_p->ta_free_func(table_p->ta_mem_pool, table_entries, - sizeof(table_linear_t) * entry_n); - if (ret != 1) { - final = TABLE_ERROR_FREE; - } - } + if (table_p->ta_free_func == NULL) { + free(table_entries); + } + else { + ret = table_p->ta_free_func(table_p->ta_mem_pool, table_entries, + sizeof(table_linear_t) * entry_n); + if (ret != 1) { + final = TABLE_ERROR_FREE; + } + } - return final; + return final; } /* @@ -4000,52 +4000,52 @@ int table_order_pos_free(table_t *table_p, table_linear_t *table_entries, * to the size of the data that is stored in the table. */ int table_entry_pos(table_t *table_p, table_linear_t *linear_p, - void **key_buf_p, int *key_size_p, - void **data_buf_p, int *data_size_p) + void **key_buf_p, int *key_size_p, + void **data_buf_p, int *data_size_p) { - table_entry_t *entry_p; - int ret; + table_entry_t *entry_p; + int ret; - if (table_p == NULL) { - return TABLE_ERROR_ARG_NULL; - } - if (table_p->ta_magic != TABLE_MAGIC) { - return TABLE_ERROR_PNT; - } - if (linear_p == NULL) { - return TABLE_ERROR_ARG_NULL; - } + if (table_p == NULL) { + return TABLE_ERROR_ARG_NULL; + } + if (table_p->ta_magic != TABLE_MAGIC) { + return TABLE_ERROR_PNT; + } + if (linear_p == NULL) { + return TABLE_ERROR_ARG_NULL; + } - /* find the associated entry */ - entry_p = this_entry(table_p, linear_p, &ret); - if (entry_p == NULL) { - return ret; - } + /* find the associated entry */ + entry_p = this_entry(table_p, linear_p, &ret); + if (entry_p == NULL) { + return ret; + } - if (key_buf_p != NULL) { - *key_buf_p = ENTRY_KEY_BUF(entry_p); - } - if (key_size_p != NULL) { - *key_size_p = entry_p->te_key_size; - } - if (data_buf_p != NULL) { - if (entry_p->te_data_size == 0) { - *data_buf_p = NULL; - } - else { - if (table_p->ta_data_align == 0) { - *data_buf_p = ENTRY_DATA_BUF(table_p, entry_p); - } - else { - *data_buf_p = entry_data_buf(table_p, entry_p); - } - } - } - if (data_size_p != NULL) { - *data_size_p = entry_p->te_data_size; - } + if (key_buf_p != NULL) { + *key_buf_p = ENTRY_KEY_BUF(entry_p); + } + if (key_size_p != NULL) { + *key_size_p = entry_p->te_key_size; + } + if (data_buf_p != NULL) { + if (entry_p->te_data_size == 0) { + *data_buf_p = NULL; + } + else { + if (table_p->ta_data_align == 0) { + *data_buf_p = ENTRY_DATA_BUF(table_p, entry_p); + } + else { + *data_buf_p = entry_data_buf(table_p, entry_p); + } + } + } + if (data_size_p != NULL) { + *data_size_p = entry_p->te_data_size; + } - return TABLE_ERROR_NONE; + return TABLE_ERROR_NONE; } /* @@ -4067,13 +4067,24 @@ int table_entry_pos(table_t *table_p, table_linear_t *linear_p, */ const char *table_strerror(const int error) { - error_str_t *err_p; + error_str_t *err_p; - for (err_p = errors; err_p->es_error != 0; err_p++) { - if (err_p->es_error == error) { - return err_p->es_string; - } - } + for (err_p = errors; err_p->es_error != 0; err_p++) { + if (err_p->es_error == error) { + return err_p->es_string; + } + } - return INVALID_ERROR; + return INVALID_ERROR; } + +/* For Emacs: + * Local Variables: + * mode:c + * indent-tabs-mode:t + * tab-width:4 + * c-basic-offset:4 + * End: + * For VIM: + * vim:set softtabstop=4 shiftwidth=4 tabstop=4 noet: + */ diff --git a/libs/libks/src/table_util.c b/libs/libks/src/table_util.c index 2fcfda3778..8b8c20f0b7 100644 --- a/libs/libks/src/table_util.c +++ b/libs/libks/src/table_util.c @@ -28,7 +28,7 @@ #include "table.h" static char *rcs_id = - "$Id: table_util.c,v 1.5 2000/03/09 03:30:42 gray Exp $"; + "$Id: table_util.c,v 1.5 2000/03/09 03:30:42 gray Exp $"; #define WRITE_MODE 0640 /* mode to write out table */ #define SPECIAL_CHARS "e\033^^\"\"''\\\\n\nr\rt\tb\bf\fa\007" @@ -61,67 +61,67 @@ static char *rcs_id = * out_size - size of the output buffer. */ int expand_chars(const void *buf, const int buf_size, - char *out, const int out_size) + char *out, const int out_size) { - int buf_c; - const unsigned char *buf_p, *spec_p; - char *max_p, *out_p = out; + int buf_c; + const unsigned char *buf_p, *spec_p; + char *max_p, *out_p = out; - /* setup our max pointer */ - max_p = out + out_size; + /* setup our max pointer */ + max_p = out + out_size; - /* run through the input buffer, counting the characters as we go */ - for (buf_c = 0, buf_p = (const unsigned char *)buf;; buf_c++, buf_p++) { + /* run through the input buffer, counting the characters as we go */ + for (buf_c = 0, buf_p = (const unsigned char *)buf;; buf_c++, buf_p++) { - /* did we reach the end of the buffer? */ - if (buf_size < 0) { - if (*buf_p == '\0') { - break; - } - } - else { - if (buf_c >= buf_size) { - break; - } - } + /* did we reach the end of the buffer? */ + if (buf_size < 0) { + if (*buf_p == '\0') { + break; + } + } + else { + if (buf_c >= buf_size) { + break; + } + } - /* search for special characters */ - for (spec_p = (unsigned char *)SPECIAL_CHARS + 1; - *(spec_p - 1) != '\0'; - spec_p += 2) { - if (*spec_p == *buf_p) { - break; - } - } + /* search for special characters */ + for (spec_p = (unsigned char *)SPECIAL_CHARS + 1; + *(spec_p - 1) != '\0'; + spec_p += 2) { + if (*spec_p == *buf_p) { + break; + } + } - /* did we find one? */ - if (*(spec_p - 1) != '\0') { - if (out_p + 2 >= max_p) { - break; - } - (void)sprintf(out_p, "\\%c", *(spec_p - 1)); - out_p += 2; - continue; - } + /* did we find one? */ + if (*(spec_p - 1) != '\0') { + if (out_p + 2 >= max_p) { + break; + } + (void)sprintf(out_p, "\\%c", *(spec_p - 1)); + out_p += 2; + continue; + } - /* print out any 7-bit printable characters */ - if (*buf_p < 128 && isprint(*buf_p)) { - if (out_p + 1 >= max_p) { - break; - } - *out_p = *(char *)buf_p; - out_p += 1; - } - else { - if (out_p + 4 >= max_p) { - break; - } - (void)sprintf(out_p, "\\%03o", *buf_p); - out_p += 4; - } - } + /* print out any 7-bit printable characters */ + if (*buf_p < 128 && isprint(*buf_p)) { + if (out_p + 1 >= max_p) { + break; + } + *out_p = *(char *)buf_p; + out_p += 1; + } + else { + if (out_p + 4 >= max_p) { + break; + } + (void)sprintf(out_p, "\\%03o", *buf_p); + out_p += 4; + } + } - return out_p - out; + return out_p - out; } /* @@ -141,22 +141,22 @@ int expand_chars(const void *buf, const int buf_size, */ static void dump_table(table_t *tab_p) { - char buf[10240]; - void *key_p, *data_p; - int ret, key_size, data_size, len, entry_c; + char buf[10240]; + void *key_p, *data_p; + int ret, key_size, data_size, len, entry_c; - for (ret = table_first(tab_p, (void **)&key_p, &key_size, - (void **)&data_p, &data_size), entry_c = 0; - ret == TABLE_ERROR_NONE; - ret = table_next(tab_p, (void **)&key_p, &key_size, - (void **)&data_p, &data_size), entry_c++) { - /* expand the key */ - len = expand_chars(key_p, key_size, buf, sizeof(buf)); - (void)printf("%d: key '%.*s' (%d), ", entry_c, len, buf, len); - /* now dump the data */ - len = expand_chars(data_p, data_size, buf, sizeof(buf)); - (void)printf("data '%.*s' (%d)\n", len, buf, len); - } + for (ret = table_first(tab_p, (void **)&key_p, &key_size, + (void **)&data_p, &data_size), entry_c = 0; + ret == TABLE_ERROR_NONE; + ret = table_next(tab_p, (void **)&key_p, &key_size, + (void **)&data_p, &data_size), entry_c++) { + /* expand the key */ + len = expand_chars(key_p, key_size, buf, sizeof(buf)); + (void)printf("%d: key '%.*s' (%d), ", entry_c, len, buf, len); + /* now dump the data */ + len = expand_chars(data_p, data_size, buf, sizeof(buf)); + (void)printf("data '%.*s' (%d)\n", len, buf, len); + } } /* @@ -176,120 +176,131 @@ static void dump_table(table_t *tab_p) */ static void usage(void) { - (void)fprintf(stderr, - "Usage: table_util\n" - " [-b number] or --buckets num buckets to adjust table\n" - " [-o file] or --out-file output filename\n" - " [-v] or --verbose verbose messages\n" - " file input table filename\n"); - exit(1); + (void)fprintf(stderr, + "Usage: table_util\n" + " [-b number] or --buckets num buckets to adjust table\n" + " [-o file] or --out-file output filename\n" + " [-v] or --verbose verbose messages\n" + " file input table filename\n"); + exit(1); } int main(int argc, char **argv) { - table_t *tab_p; - char do_write = 0, verbose = 0; - char *out_file = NULL, *in_file; - int ret, entry_n, bucket_n, num_buckets = 0; + table_t *tab_p; + char do_write = 0, verbose = 0; + char *out_file = NULL, *in_file; + int ret, entry_n, bucket_n, num_buckets = 0; - /* process the args */ - for (argc--, argv++; argc > 0 && **argv == '-'; argc--, argv++) { + /* process the args */ + for (argc--, argv++; argc > 0 && **argv == '-'; argc--, argv++) { - switch (*(*argv + 1)) { + switch (*(*argv + 1)) { - case 'b': - argc--, argv++; - if (argc == 0) { - usage(); - } - num_buckets = atoi(*argv); - break; + case 'b': + argc--, argv++; + if (argc == 0) { + usage(); + } + num_buckets = atoi(*argv); + break; - case 'o': - argc--, argv++; - if (argc == 0) { - usage(); - } - out_file = *argv; - break; + case 'o': + argc--, argv++; + if (argc == 0) { + usage(); + } + out_file = *argv; + break; - case 'v': - verbose = 1; - break; + case 'v': + verbose = 1; + break; - default: - usage(); - break; - } - } + default: + usage(); + break; + } + } - if (argc != 1) { - usage(); - } + if (argc != 1) { + usage(); + } - /* take the last argument as the input file */ - in_file = *argv; + /* take the last argument as the input file */ + in_file = *argv; - /* read in the table from disk */ - tab_p = table_read(in_file, &ret); - if (tab_p == NULL) { - (void)fprintf(stderr, "table_util: unable to table_read from '%s': %s\n", - in_file, table_strerror(ret)); - exit(1); - } + /* read in the table from disk */ + tab_p = table_read(in_file, &ret); + if (tab_p == NULL) { + (void)fprintf(stderr, "table_util: unable to table_read from '%s': %s\n", + in_file, table_strerror(ret)); + exit(1); + } - /* get info about the table */ - ret = table_info(tab_p, &bucket_n, &entry_n); - if (ret != TABLE_ERROR_NONE) { - (void)fprintf(stderr, - "table_util: unable to get info on table in '%s': %s\n", - in_file, table_strerror(ret)); - exit(1); - } + /* get info about the table */ + ret = table_info(tab_p, &bucket_n, &entry_n); + if (ret != TABLE_ERROR_NONE) { + (void)fprintf(stderr, + "table_util: unable to get info on table in '%s': %s\n", + in_file, table_strerror(ret)); + exit(1); + } - (void)printf("Read table of %d buckets and %d entries from '%s'\n", - bucket_n, entry_n, in_file); + (void)printf("Read table of %d buckets and %d entries from '%s'\n", + bucket_n, entry_n, in_file); - if (verbose) { - dump_table(tab_p); - } + if (verbose) { + dump_table(tab_p); + } - if (num_buckets > 0) { - /* adjust the table's buckets */ - ret = table_adjust(tab_p, num_buckets); - if (ret != TABLE_ERROR_NONE) { - (void)fprintf(stderr, - "table_util: unable to adjust table to %d buckets: %s\n", - num_buckets, table_strerror(ret)); - exit(1); - } - do_write = 1; - } + if (num_buckets > 0) { + /* adjust the table's buckets */ + ret = table_adjust(tab_p, num_buckets); + if (ret != TABLE_ERROR_NONE) { + (void)fprintf(stderr, + "table_util: unable to adjust table to %d buckets: %s\n", + num_buckets, table_strerror(ret)); + exit(1); + } + do_write = 1; + } - /* did we modify the table at all */ - if (do_write) { - if (out_file == NULL) { - out_file = in_file; - } + /* did we modify the table at all */ + if (do_write) { + if (out_file == NULL) { + out_file = in_file; + } - /* write out our table */ - ret = table_write(tab_p, out_file, WRITE_MODE); - if (ret != TABLE_ERROR_NONE) { - (void)fprintf(stderr, "table_util: unable to write table to '%s': %s\n", - out_file, table_strerror(ret)); - exit(1); - } + /* write out our table */ + ret = table_write(tab_p, out_file, WRITE_MODE); + if (ret != TABLE_ERROR_NONE) { + (void)fprintf(stderr, "table_util: unable to write table to '%s': %s\n", + out_file, table_strerror(ret)); + exit(1); + } - (void)printf("Wrote table to '%s'\n", out_file); - } + (void)printf("Wrote table to '%s'\n", out_file); + } - /* free the table */ - ret = table_free(tab_p); - if (ret != TABLE_ERROR_NONE) { - (void)fprintf(stderr, "table_util: unable to free table: %s\n", - table_strerror(ret)); - /* NOTE: not a critical error */ - } + /* free the table */ + ret = table_free(tab_p); + if (ret != TABLE_ERROR_NONE) { + (void)fprintf(stderr, "table_util: unable to free table: %s\n", + table_strerror(ret)); + /* NOTE: not a critical error */ + } - exit(0); + exit(0); } + +/* For Emacs: + * Local Variables: + * mode:c + * indent-tabs-mode:t + * tab-width:4 + * c-basic-offset:4 + * End: + * For VIM: + * vim:set softtabstop=4 shiftwidth=4 tabstop=4 noet: + */