+2005-03-02 David Ayers <d.ayers@inode.at>
+
+ PR libobjc/19024
+ * Makefile.in (OBJS): Add hash_compat.lo.
+ (OBJS_GC): Add hash_compat_gc.lo.
+ (hash_compat_gc.lo): New target and rule.
+ * objc/hash.h (hash_new, hash_delete, hash_add, hash_remove)
+ (hash_next, hash_value_for_key, hash_is_key_in_hash)
+ (hash_ptr, hash_string, compare_ptrs, compare_strings): Prefix
+ with objc_. Add deprecated non prefixed inlined versions.
+ (OBJC_IGNORE_DEPRECATED_API): New macro to hide deprecated
+ declarations.
+ * hash.c (hash_new, hash_delete, hash_add, hash_remove, hash_next)
+ (hash_value_for_key, hash_is_key_in_hash): Prefix with objc_ and
+ update callers.
+ * hash_compat.c: New file.
+ * archive.c: Update callers.
+ * init.c: Likewise.
+ * selector.c: Likewise.
+ * libobjc.def: Add objc_ versions of hash functions.
+
2005-02-28 Andrew Pinski <pinskia@physics.uc.edu>
PR libobjc/20252
OBJS = archive.lo class.lo encoding.lo gc.lo hash.lo init.lo linking.lo \
misc.lo nil_method.lo NXConstStr.lo Object.lo objects.lo \
Protocol.lo sarray.lo selector.lo sendmsg.lo thr.lo \
- $(OBJC_THREAD_FILE).lo exception.lo
+ $(OBJC_THREAD_FILE).lo exception.lo hash_compat.lo
OBJS_GC = archive_gc.lo class_gc.lo encoding_gc.lo gc_gc.lo hash_gc.lo \
init_gc.lo linking_gc.lo misc_gc.lo nil_method_gc.lo \
NXConstStr_gc.lo Object_gc.lo objects_gc.lo Protocol_gc.lo \
sarray_gc.lo selector_gc.lo sendmsg_gc.lo thr_gc.lo \
- $(OBJC_THREAD_FILE)_gc.lo exception_gc.lo
+ $(OBJC_THREAD_FILE)_gc.lo exception_gc.lo hash_compat_gc.lo
runtime-info.h:
echo "" > tmp-runtime.m
$(LIBTOOL_COMPILE) $(CC) -c -o $@ $(ALL_CFLAGS) $(OBJC_GCFLAGS) \
$(INCLUDES) $<
+hash_compat_gc.lo: hash_compat.c
+ $(LIBTOOL_COMPILE) $(CC) -c -o $@ $(ALL_CFLAGS) $(OBJC_GCFLAGS) \
+ $(INCLUDES) $<
+
init_gc.lo: init.c
$(LIBTOOL_COMPILE) $(CC) -c -o $@ $(ALL_CFLAGS) $(OBJC_GCFLAGS) \
$(INCLUDES) $<
unsigned char *string, unsigned int nbytes)
{
unsigned long key;
- if ((key = PTR2LONG(hash_value_for_key (stream->stream_table, string))))
+ if ((key = PTR2LONG(objc_hash_value_for_key (stream->stream_table, string))))
return objc_write_use_common (stream, key);
else
{
int length;
- hash_add (&stream->stream_table, LONG2PTR(key=PTR2LONG(string)), string);
+ objc_hash_add (&stream->stream_table,
+ LONG2PTR(key=PTR2LONG(string)), string);
if ((length = objc_write_register_common (stream, key)))
return objc_write_string (stream, string, nbytes);
return length;
objc_write_object_reference (struct objc_typed_stream *stream, id object)
{
unsigned long key;
- if ((key = PTR2LONG(hash_value_for_key (stream->object_table, object))))
+ if ((key = PTR2LONG(objc_hash_value_for_key (stream->object_table, object))))
return objc_write_use_common (stream, key);
__objc_write_extension (stream, _BX_OBJREF);
objc_write_object (struct objc_typed_stream *stream, id object)
{
unsigned long key;
- if ((key = PTR2LONG(hash_value_for_key (stream->object_table, object))))
+ if ((key = PTR2LONG(objc_hash_value_for_key (stream->object_table, object))))
return objc_write_use_common (stream, key);
else if (object == nil)
else
{
int length;
- hash_add (&stream->object_table, LONG2PTR(key=PTR2LONG(object)), object);
+ objc_hash_add (&stream->object_table,
+ LONG2PTR(key=PTR2LONG(object)), object);
if ((length = objc_write_register_common (stream, key)))
return __objc_write_object (stream, object);
return length;
struct objc_class *class)
{
unsigned long key;
- if ((key = PTR2LONG(hash_value_for_key (stream->stream_table, class))))
+ if ((key = PTR2LONG(objc_hash_value_for_key (stream->stream_table, class))))
return objc_write_use_common (stream, key);
else
{
int length;
- hash_add (&stream->stream_table, LONG2PTR(key = PTR2LONG(class)), class);
+ objc_hash_add (&stream->stream_table,
+ LONG2PTR(key = PTR2LONG(class)), class);
if ((length = objc_write_register_common (stream, key)))
return __objc_write_class (stream, class);
return length;
return __objc_write_selector (stream, selector);
sel_name = sel_get_name (selector);
- if ((key = PTR2LONG(hash_value_for_key (stream->stream_table, sel_name))))
+ if ((key = PTR2LONG(objc_hash_value_for_key (stream->stream_table,
+ sel_name))))
return objc_write_use_common (stream, key);
else
{
int length;
- hash_add (&stream->stream_table,
+ objc_hash_add (&stream->stream_table,
LONG2PTR(key = PTR2LONG(sel_name)), (char *) sel_name);
if ((length = objc_write_register_common (stream, key)))
return __objc_write_selector (stream, selector);
int length = buf[0]&_B_VALUE;
(*string) = (char*)objc_malloc (length + 1);
if (key)
- hash_add (&stream->stream_table, LONG2PTR(key), *string);
+ objc_hash_add (&stream->stream_table, LONG2PTR(key), *string);
len = (*stream->read) (stream->physical, *string, length);
(*string)[length] = '\0';
}
{
char *tmp;
len = __objc_read_nbyte_ulong (stream, (buf[0] & _B_VALUE), &key);
- tmp = hash_value_for_key (stream->stream_table, LONG2PTR (key));
+ tmp = objc_hash_value_for_key (stream->stream_table, LONG2PTR (key));
*string = objc_malloc (strlen (tmp) + 1);
strcpy (*string, tmp);
}
if (len) {
(*string) = (char*)objc_malloc (nbytes + 1);
if (key)
- hash_add (&stream->stream_table, LONG2PTR(key), *string);
+ objc_hash_add (&stream->stream_table, LONG2PTR(key), *string);
len = (*stream->read) (stream->physical, *string, nbytes);
(*string)[nbytes] = '\0';
}
/* register? */
if (key)
- hash_add (&stream->object_table, LONG2PTR(key), *object);
+ objc_hash_add (&stream->object_table, LONG2PTR(key), *object);
/* send -read: */
if (__objc_responds_to (*object, read_sel))
if (key)
objc_error (nil, OBJC_ERR_BAD_KEY, "cannot register use upcode...");
len = __objc_read_nbyte_ulong (stream, (buf[0] & _B_VALUE), &key);
- (*object) = hash_value_for_key (stream->object_table, LONG2PTR(key));
+ (*object) = objc_hash_value_for_key (stream->object_table,
+ LONG2PTR(key));
}
else if (buf[0] == (_B_EXT | _BX_OBJREF)) /* a forward reference */
{
struct objc_list *other;
len = objc_read_unsigned_long (stream, &key);
- other = (struct objc_list *) hash_value_for_key (stream->object_refs,
+ other
+ = (struct objc_list *) objc_hash_value_for_key (stream->object_refs,
LONG2PTR(key));
- hash_add (&stream->object_refs, LONG2PTR(key),
- (void *)list_cons (object, other));
+ objc_hash_add (&stream->object_refs, LONG2PTR(key),
+ (void *)list_cons (object, other));
}
else if (buf[0] == (_B_EXT | _BX_OBJROOT)) /* a root object */
/* register */
if (key)
- hash_add (&stream->stream_table, LONG2PTR(key), *class);
+ objc_hash_add (&stream->stream_table, LONG2PTR(key), *class);
objc_read_unsigned_long (stream, &version);
- hash_add (&stream->class_table, (*class)->name, (void *)version);
+ objc_hash_add (&stream->class_table,
+ (*class)->name, (void *)version);
}
else if ((buf[0]&_B_CODE) == _B_UCOMM)
if (key)
objc_error (nil, OBJC_ERR_BAD_KEY, "cannot register use upcode...");
len = __objc_read_nbyte_ulong (stream, (buf[0] & _B_VALUE), &key);
- *class = hash_value_for_key (stream->stream_table, LONG2PTR(key));
+ *class = objc_hash_value_for_key (stream->stream_table,
+ LONG2PTR(key));
if (! *class)
objc_error (nil, OBJC_ERR_BAD_CLASS,
"cannot find class for key %lu", key);
/* register */
if (key)
- hash_add (&stream->stream_table, LONG2PTR(key), (void *) *selector);
+ objc_hash_add (&stream->stream_table,
+ LONG2PTR(key), (void *) *selector);
}
else if ((buf[0]&_B_CODE) == _B_UCOMM)
if (key)
objc_error (nil, OBJC_ERR_BAD_KEY, "cannot register use upcode...");
len = __objc_read_nbyte_ulong (stream, (buf[0] & _B_VALUE), &key);
- (*selector) = hash_value_for_key (stream->stream_table,
- LONG2PTR(key));
+ (*selector) = objc_hash_value_for_key (stream->stream_table,
+ LONG2PTR(key));
}
else
static void __objc_finish_write_root_object(struct objc_typed_stream *stream)
{
- hash_delete (stream->object_table);
- stream->object_table = hash_new(64,
- (hash_func_type)hash_ptr,
- (compare_func_type)compare_ptrs);
+ objc_hash_delete (stream->object_table);
+ stream->object_table = objc_hash_new (64,
+ (hash_func_type) objc_hash_ptr,
+ (compare_func_type) objc_compare_ptrs);
}
static void __objc_finish_read_root_object(struct objc_typed_stream *stream)
{
node_ptr node;
SEL awake_sel = sel_get_any_uid ("awake");
- cache_ptr free_list = hash_new (64,
- (hash_func_type) hash_ptr,
- (compare_func_type) compare_ptrs);
+ cache_ptr free_list = objc_hash_new (64,
+ (hash_func_type) objc_hash_ptr,
+ (compare_func_type) objc_compare_ptrs);
/* resolve object forward references */
- for (node = hash_next (stream->object_refs, NULL); node;
- node = hash_next (stream->object_refs, node))
+ for (node = objc_hash_next (stream->object_refs, NULL); node;
+ node = objc_hash_next (stream->object_refs, node))
{
struct objc_list *reflist = node->value;
const void *key = node->key;
- id object = hash_value_for_key (stream->object_table, key);
+ id object = objc_hash_value_for_key (stream->object_table, key);
while (reflist)
{
*((id*) reflist->head) = object;
- if (hash_value_for_key (free_list,reflist) == NULL)
- hash_add (&free_list,reflist,reflist);
+ if (objc_hash_value_for_key (free_list,reflist) == NULL)
+ objc_hash_add (&free_list,reflist,reflist);
reflist = reflist->tail;
}
}
/* apply __objc_free to all objects stored in free_list */
- for (node = hash_next (free_list, NULL); node;
- node = hash_next (free_list, node))
+ for (node = objc_hash_next (free_list, NULL); node;
+ node = objc_hash_next (free_list, node))
objc_free ((void *) node->key);
- hash_delete (free_list);
+ objc_hash_delete (free_list);
/* empty object reference table */
- hash_delete (stream->object_refs);
- stream->object_refs = hash_new(8, (hash_func_type)hash_ptr,
- (compare_func_type)compare_ptrs);
+ objc_hash_delete (stream->object_refs);
+ stream->object_refs = objc_hash_new (8, (hash_func_type) objc_hash_ptr,
+ (compare_func_type) objc_compare_ptrs);
/* call -awake for all objects read */
if (awake_sel)
{
- for (node = hash_next (stream->object_table, NULL); node;
- node = hash_next (stream->object_table, node))
+ for (node = objc_hash_next (stream->object_table, NULL); node;
+ node = objc_hash_next (stream->object_table, node))
{
id object = node->value;
if (__objc_responds_to (object, awake_sel))
}
/* empty object table */
- hash_delete (stream->object_table);
- stream->object_table = hash_new(64,
- (hash_func_type)hash_ptr,
- (compare_func_type)compare_ptrs);
+ objc_hash_delete (stream->object_table);
+ stream->object_table = objc_hash_new(64,
+ (hash_func_type)objc_hash_ptr,
+ (compare_func_type)objc_compare_ptrs);
}
/*
s->mode = mode;
s->physical = physical;
- s->stream_table = hash_new (64,
- (hash_func_type) hash_ptr,
- (compare_func_type) compare_ptrs);
- s->object_table = hash_new (64,
- (hash_func_type) hash_ptr,
- (compare_func_type) compare_ptrs);
+ s->stream_table = objc_hash_new (64,
+ (hash_func_type) objc_hash_ptr,
+ (compare_func_type) objc_compare_ptrs);
+ s->object_table = objc_hash_new (64,
+ (hash_func_type) objc_hash_ptr,
+ (compare_func_type) objc_compare_ptrs);
s->eof = (objc_typed_eof_func) __objc_feof;
s->flush = (objc_typed_flush_func) fflush;
s->writing_root_p = 0;
if (mode == OBJC_READONLY)
{
- s->class_table = hash_new (8, (hash_func_type) hash_string,
- (compare_func_type) compare_strings);
- s->object_refs = hash_new (8, (hash_func_type) hash_ptr,
- (compare_func_type) compare_ptrs);
+ s->class_table
+ = objc_hash_new (8, (hash_func_type) objc_hash_string,
+ (compare_func_type) objc_compare_strings);
+ s->object_refs = objc_hash_new (8, (hash_func_type) objc_hash_ptr,
+ (compare_func_type) objc_compare_ptrs);
s->read = (objc_typed_read_func) __objc_fread;
s->write = (objc_typed_write_func) __objc_no_write;
__objc_read_typed_stream_signature (s);
if (stream->mode == OBJC_READONLY)
{
__objc_finish_read_root_object (stream); /* Just in case... */
- hash_delete (stream->class_table);
- hash_delete (stream->object_refs);
+ objc_hash_delete (stream->class_table);
+ objc_hash_delete (stream->object_refs);
}
- hash_delete (stream->stream_table);
- hash_delete (stream->object_table);
+ objc_hash_delete (stream->stream_table);
+ objc_hash_delete (stream->object_table);
if (stream->type == (OBJC_MANAGED_STREAM | OBJC_FILE_STREAM))
fclose ((FILE *)stream->physical);
objc_get_stream_class_version (TypedStream *stream, Class class)
{
if (stream->class_table)
- return PTR2LONG(hash_value_for_key (stream->class_table, class->name));
+ return PTR2LONG(objc_hash_value_for_key (stream->class_table,
+ class->name));
else
return class_get_version (class);
}
((cache)->size * 2)
cache_ptr
-hash_new (unsigned int size, hash_func_type hash_func,
- compare_func_type compare_func)
+objc_hash_new (unsigned int size, hash_func_type hash_func,
+ compare_func_type compare_func)
{
cache_ptr cache;
void
-hash_delete (cache_ptr cache)
+objc_hash_delete (cache_ptr cache)
{
node_ptr node;
node_ptr next_node;
/* Purge all key/value pairs from the table. */
/* Step through the nodes one by one and remove every node WITHOUT
- using hash_next. this makes hash_delete much more efficient. */
+ using objc_hash_next. this makes objc_hash_delete much more efficient. */
for (i = 0;i < cache->size;i++) {
if ((node = cache->node_table[i])) {
/* an entry in the hash table has been found, now step through the
nodes next in the list and free them. */
while ((next_node = node->next)) {
- hash_remove (cache,node->key);
+ objc_hash_remove (cache,node->key);
node = next_node;
}
- hash_remove (cache,node->key);
+ objc_hash_remove (cache,node->key);
}
}
void
-hash_add (cache_ptr *cachep, const void *key, void *value)
+objc_hash_add (cache_ptr *cachep, const void *key, void *value)
{
size_t indx = (*(*cachep)->hash_func)(*cachep, key);
node_ptr node = (node_ptr) objc_calloc (1, sizeof (struct cache_node));
primitive functions thereby increasing its
correctness. */
node_ptr node1 = NULL;
- cache_ptr new = hash_new (EXPANSION (*cachep),
- (*cachep)->hash_func,
- (*cachep)->compare_func);
+ cache_ptr new = objc_hash_new (EXPANSION (*cachep),
+ (*cachep)->hash_func,
+ (*cachep)->compare_func);
DEBUG_PRINTF ("Expanding cache %#x from %d to %d\n",
(int) *cachep, (*cachep)->size, new->size);
/* Copy the nodes from the first hash table to the new one. */
- while ((node1 = hash_next (*cachep, node1)))
- hash_add (&new, node1->key, node1->value);
+ while ((node1 = objc_hash_next (*cachep, node1)))
+ objc_hash_add (&new, node1->key, node1->value);
/* Trash the old cache. */
- hash_delete (*cachep);
+ objc_hash_delete (*cachep);
/* Return a pointer to the new hash table. */
*cachep = new;
void
-hash_remove (cache_ptr cache, const void *key)
+objc_hash_remove (cache_ptr cache, const void *key)
{
size_t indx = (*cache->hash_func)(cache, key);
node_ptr node = cache->node_table[indx];
node_ptr
-hash_next (cache_ptr cache, node_ptr node)
+objc_hash_next (cache_ptr cache, node_ptr node)
{
/* If the scan is being started then reset the last node
visitied pointer and bucket index. */
Return NULL if the KEY is not recorded. */
void *
-hash_value_for_key (cache_ptr cache, const void *key)
+objc_hash_value_for_key (cache_ptr cache, const void *key)
{
node_ptr node = cache->node_table[(*cache->hash_func)(cache, key)];
void *retval = NULL;
Return NO if it does not */
BOOL
-hash_is_key_in_hash (cache_ptr cache, const void *key)
+objc_hash_is_key_in_hash (cache_ptr cache, const void *key)
{
node_ptr node = cache->node_table[(*cache->hash_func)(cache, key)];
--- /dev/null
+/* Binary compatibility hash implementations for Objective C.
+ Copyright (C) 2005 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GCC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING. If not, write to
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
+
+/* As a special exception, if you link this library with files
+ compiled with GCC to produce an executable, this does not cause
+ the resulting executable to be covered by the GNU General Public License.
+ This exception does not however invalidate any other reasons why
+ the executable file might be covered by the GNU General Public License. */
+
+#define OBJC_IGNORE_DEPRECATED_API 1
+#include "hash.h"
+
+cache_ptr
+hash_new (unsigned int size,
+ hash_func_type hash_func,
+ compare_func_type compare_func)
+{
+ return objc_hash_new(size, hash_func, compare_func);
+}
+
+void
+hash_delete(cache_ptr cache)
+{
+ objc_hash_delete(cache);
+}
+
+void
+hash_add (cache_ptr *cachep, const void *key, void *value)
+{
+ objc_hash_add(cachep, key, value);
+}
+
+void
+hash_remove (cache_ptr cache, const void *key)
+{
+ objc_hash_remove (cache, key);
+}
+
+node_ptr
+hash_next (cache_ptr cache, node_ptr node)
+{
+ return objc_hash_next (cache, node);
+}
+
+void *
+hash_value_for_key (cache_ptr cache, const void *key)
+{
+ return objc_hash_value_for_key (cache, key);
+}
+
+BOOL
+hash_is_key_in_hash (cache_ptr cache, const void *key)
+{
+ return objc_hash_is_key_in_hash (cache, key);
+}
+
+unsigned int
+hash_ptr (cache_ptr cache, const void *key)
+{
+ return objc_hash_ptr (cache, key);
+}
+
+unsigned int
+hash_string (cache_ptr cache, const void *key)
+{
+ return objc_hash_string (cache, key);
+}
+
+int
+compare_ptrs (const void *k1, const void *k2)
+{
+ return objc_compare_ptrs (k1, k2);
+}
+
+int
+compare_strings (const void *k1, const void *k2)
+{
+ return objc_compare_strings (k1, k2);
+}
+
Method_t mth = &method_list->method_list[i];
if (mth->method_name && sel_eq (mth->method_name, op)
- && ! hash_is_key_in_hash (__objc_load_methods, mth->method_imp))
+ && ! objc_hash_is_key_in_hash (__objc_load_methods, mth->method_imp))
{
/* Add this method into the +load hash table */
- hash_add (&__objc_load_methods, mth->method_imp, mth->method_imp);
+ objc_hash_add (&__objc_load_methods,
+ mth->method_imp,
+ mth->method_imp);
DEBUG_PRINTF ("sending +load in class: %s\n", class->name);
__objc_init_class_tables ();
__objc_init_dispatch_tables ();
__objc_class_tree_list = list_cons (NULL, __objc_class_tree_list);
- __objc_load_methods
- = hash_new (128, (hash_func_type)hash_ptr, compare_ptrs);
+ __objc_load_methods = objc_hash_new (128,
+ (hash_func_type)objc_hash_ptr,
+ objc_compare_ptrs);
previous_constructors = 1;
}
EXPORTS
search_for_method_in_list
objc_get_uninstalled_dtable
+objc_hash_is_key_in_hash
hash_is_key_in_hash
objc_verror
_objc_load_callback
sarray_new
sarray_realloc
sarray_remove_garbage
+objc_hash_add
hash_add
+objc_hash_delete
hash_delete
+objc_hash_new
hash_new
+objc_hash_next
hash_next
+objc_hash_remove
hash_remove
+objc_hash_value_for_key
hash_value_for_key
*
* Unfortunately there is a mutual data structure reference problem with this
* typedef. Therefore, to remove compiler warnings the functions passed to
- * hash_new will have to be casted to this type.
+ * objc_hash_new will have to be casted to this type.
*/
typedef unsigned int (*hash_func_type) (void *, const void *);
/* Allocate and initialize a hash table. */
-cache_ptr hash_new (unsigned int size,
- hash_func_type hash_func,
- compare_func_type compare_func);
+cache_ptr objc_hash_new (unsigned int size,
+ hash_func_type hash_func,
+ compare_func_type compare_func);
/* Deallocate all of the hash nodes and the cache itself. */
-void hash_delete (cache_ptr cache);
+void objc_hash_delete (cache_ptr cache);
/* Add the key/value pair to the hash table. If the
hash table reaches a level of fullness then it will be resized.
assert if the key is already in the hash. */
-void hash_add (cache_ptr *cachep, const void *key, void *value);
+void objc_hash_add (cache_ptr *cachep, const void *key, void *value);
/* Remove the key/value pair from the hash table.
assert if the key isn't in the table. */
-void hash_remove (cache_ptr cache, const void *key);
+void objc_hash_remove (cache_ptr cache, const void *key);
/* Used to index through the hash table. Start with NULL
to get the first entry.
Cache nodes are returned such that key or value can
be extracted. */
-node_ptr hash_next (cache_ptr cache, node_ptr node);
+node_ptr objc_hash_next (cache_ptr cache, node_ptr node);
/* Used to return a value from a hash table using a given key. */
-void *hash_value_for_key (cache_ptr cache, const void *key);
+void *objc_hash_value_for_key (cache_ptr cache, const void *key);
/* Used to determine if the given key exists in the hash table */
-BOOL hash_is_key_in_hash (cache_ptr cache, const void *key);
+BOOL objc_hash_is_key_in_hash (cache_ptr cache, const void *key);
/************************************************
except for those likely to be 0 due to alignment.) */
static inline unsigned int
-hash_ptr (cache_ptr cache, const void *key)
+objc_hash_ptr (cache_ptr cache, const void *key)
{
return ((size_t)key / sizeof (void *)) & cache->mask;
}
/* Calculate a hash code by iterating over a NULL
terminate string. */
static inline unsigned int
-hash_string (cache_ptr cache, const void *key)
+objc_hash_string (cache_ptr cache, const void *key)
{
unsigned int ret = 0;
unsigned int ctr = 0;
/* Compare two pointers for equality. */
static inline int
-compare_ptrs (const void *k1, const void *k2)
+objc_compare_ptrs (const void *k1, const void *k2)
{
return (k1 == k2);
}
/* Compare two strings. */
static inline int
-compare_strings (const void *k1, const void *k2)
+objc_compare_strings (const void *k1, const void *k2)
{
if (k1 == k2)
return 1;
return ! strcmp ((const char *) k1, (const char *) k2);
}
+#ifndef OBJC_IGNORE_DEPRECATED_API
+/* Deprecated as of 4.1 */
+
+static inline cache_ptr
+hash_new (unsigned int size,
+ hash_func_type hash_func,
+ compare_func_type compare_func) __attribute__ ((deprecated));
+static inline cache_ptr
+hash_new (unsigned int size,
+ hash_func_type hash_func,
+ compare_func_type compare_func)
+{
+ return objc_hash_new(size, hash_func, compare_func);
+}
+
+static inline void
+hash_delete(cache_ptr cache) __attribute__ ((deprecated));
+static inline void
+hash_delete(cache_ptr cache)
+{
+ objc_hash_delete(cache);
+}
+
+static inline void
+hash_add (cache_ptr *cachep,
+ const void *key,
+ void *value) __attribute__ ((deprecated));
+static inline void
+hash_add (cache_ptr *cachep, const void *key, void *value)
+{
+ objc_hash_add(cachep, key, value);
+}
+
+static inline void
+hash_remove (cache_ptr cache, const void *key) __attribute__ ((deprecated));
+static inline void
+hash_remove (cache_ptr cache, const void *key)
+{
+ objc_hash_remove (cache, key);
+}
+
+static inline node_ptr
+hash_next (cache_ptr cache, node_ptr node) __attribute__ ((deprecated));
+static inline node_ptr
+hash_next (cache_ptr cache, node_ptr node)
+{
+ return objc_hash_next (cache, node);
+}
+
+static inline void *
+hash_value_for_key (cache_ptr cache,
+ const void *key) __attribute__ ((deprecated));
+static inline void *
+hash_value_for_key (cache_ptr cache, const void *key)
+{
+ return objc_hash_value_for_key (cache, key);
+}
+
+static inline BOOL
+hash_is_key_in_hash (cache_ptr cache,
+ const void *key) __attribute__ ((deprecated));
+static inline BOOL
+hash_is_key_in_hash (cache_ptr cache, const void *key)
+{
+ return objc_hash_is_key_in_hash (cache, key);
+}
+
+static inline unsigned int
+hash_ptr (cache_ptr cache, const void *key) __attribute__ ((deprecated));
+static inline unsigned int
+hash_ptr (cache_ptr cache, const void *key)
+{
+ return objc_hash_ptr (cache, key);
+}
+
+static inline unsigned int
+hash_string (cache_ptr cache, const void *key) __attribute__ ((deprecated));
+static inline unsigned int
+hash_string (cache_ptr cache, const void *key)
+{
+ return objc_hash_string (cache, key);
+}
+
+static inline int
+compare_ptrs (const void *k1, const void *k2) __attribute__ ((deprecated));
+static inline int
+compare_ptrs (const void *k1, const void *k2)
+{
+ return objc_compare_ptrs (k1, k2);
+}
+
+static inline int
+compare_strings (const void *k1, const void *k2) __attribute__ ((deprecated));
+static inline int
+compare_strings (const void *k1, const void *k2)
+{
+ return objc_compare_strings (k1, k2);
+}
+#endif /* IGNORE_DEPRECATED_API */
+
+
#ifdef __cplusplus
}
#endif /* __cplusplus */
__objc_selector_array = sarray_new (SELECTOR_HASH_SIZE, 0);
__objc_selector_names = sarray_new (SELECTOR_HASH_SIZE, 0);
__objc_selector_hash
- = hash_new (SELECTOR_HASH_SIZE,
- (hash_func_type) hash_string,
- (compare_func_type) compare_strings);
+ = objc_hash_new (SELECTOR_HASH_SIZE,
+ (hash_func_type) objc_hash_string,
+ (compare_func_type) objc_compare_strings);
}
/* This routine is given a class and records all of the methods in its class
objc_mutex_lock (__objc_runtime_mutex);
- i = (sidx) hash_value_for_key (__objc_selector_hash, name);
+ i = (sidx) objc_hash_value_for_key (__objc_selector_hash, name);
if (i == 0)
{
objc_mutex_unlock (__objc_runtime_mutex);
objc_mutex_lock (__objc_runtime_mutex);
- i = (sidx) hash_value_for_key (__objc_selector_hash, name);
+ i = (sidx) objc_hash_value_for_key (__objc_selector_hash, name);
if (i == 0)
{
objc_mutex_unlock (__objc_runtime_mutex);
objc_mutex_lock (__objc_runtime_mutex);
- i = (sidx) hash_value_for_key (__objc_selector_hash, name);
+ i = (sidx) objc_hash_value_for_key (__objc_selector_hash, name);
if (soffset_decode (i) == 0)
{
objc_mutex_unlock (__objc_runtime_mutex);
sidx i;
struct objc_list *l;
- i = (sidx) hash_value_for_key (__objc_selector_hash, name);
+ i = (sidx) objc_hash_value_for_key (__objc_selector_hash, name);
if (soffset_decode (i) != 0)
{
for (l = (struct objc_list *) sarray_get_safe (__objc_selector_array, i);
sarray_at_put_safe (__objc_selector_names, i, (void *) new_name);
sarray_at_put_safe (__objc_selector_array, i, (void *) l);
if (is_new)
- hash_add (&__objc_selector_hash, (void *) new_name, (void *) i);
+ objc_hash_add (&__objc_selector_hash, (void *) new_name, (void *) i);
}
sarray_realloc (__objc_uninstalled_dtable, __objc_selector_max_index + 1);
OSDN Git Service
