Package: emacs;
Reported by: "Greg A. Woods" <woods <at> robohack.ca>
Date: Thu, 3 Apr 2025 03:47:02 UTC
Severity: normal
Tags: patch
Done: Paul Eggert <eggert <at> cs.ucla.edu>
Bug is archived. No further changes may be made.
Message #5 received at submit <at> debbugs.gnu.org (full text, mbox):
From: "Greg A. Woods" <woods <at> robohack.ca> To: bug-gnu-emacs <at> gnu.org Subject: [PATCH] Rename various hash functions to avoid clashing with GnuTLS. Date: Wed, 02 Apr 2025 20:46:03 -0700
[Message part 1 (text/plain, inline)]
Rename various hash functions in src/fns.c to facilitate static-linking
with GnuTLS which includes clashing hash functions from its "gl"
subdirectory.
* src/fns.c: et al (hash_string, hash_lookup, hash_lookup_get_hash,
hash_put, hash_remove_from_table): Rename with a leading "lisp_" prefix.
---
src/bytecode.c | 2 +-
src/category.c | 4 ++--
src/ccl.c | 4 ++--
src/charset.c | 4 ++--
src/charset.h | 2 +-
src/coding.h | 4 ++--
src/composite.c | 8 ++++----
src/emacs-module.c | 8 ++++----
src/fns.c | 24 ++++++++++++------------
src/image.c | 8 ++++----
src/json.c | 4 ++--
src/lisp.h | 14 +++++++-------
src/lread.c | 20 ++++++++++----------
src/minibuf.c | 2 +-
14 files changed, 54 insertions(+), 54 deletions(-)
diff --git a/src/bytecode.c b/src/bytecode.c
index ecea0c6df36..9d4f9de3eb4 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -1763,7 +1763,7 @@ #define DEFINE(name, value) [name] = &&insn_ ## name,
}
else
{
- ptrdiff_t i = hash_lookup (h, v1);
+ ptrdiff_t i = lisp_hash_lookup (h, v1);
if (i >= 0)
{
op = XFIXNUM (HASH_VALUE (h, i));
diff --git a/src/category.c b/src/category.c
index 297ba94c73d..9909ba5701c 100644
--- a/src/category.c
+++ b/src/category.c
@@ -54,10 +54,10 @@ hash_get_category_set (Lisp_Object table, Lisp_Object category_set)
make_hash_table (&hashtest_equal, DEFAULT_HASH_SIZE, Weak_None));
struct Lisp_Hash_Table *h = XHASH_TABLE (XCHAR_TABLE (table)->extras[1]);
hash_hash_t hash;
- ptrdiff_t i = hash_lookup_get_hash (h, category_set, &hash);
+ ptrdiff_t i = lisp_hash_lookup_get_hash (h, category_set, &hash);
if (i >= 0)
return HASH_KEY (h, i);
- hash_put (h, category_set, Qnil, hash);
+ lisp_hash_put (h, category_set, Qnil, hash);
return category_set;
}
diff --git a/src/ccl.c b/src/ccl.c
index a45fe0439c4..dfb50be71ac 100644
--- a/src/ccl.c
+++ b/src/ccl.c
@@ -1375,7 +1375,7 @@ #define EXCMD (field1 >> 6)
eop = (FIXNUM_OVERFLOW_P (reg[RRR])
? -1
- : hash_lookup (h, make_fixnum (reg[RRR])));
+ : lisp_hash_lookup (h, make_fixnum (reg[RRR])));
if (eop >= 0)
{
Lisp_Object opl;
@@ -1404,7 +1404,7 @@ #define EXCMD (field1 >> 6)
eop = (FIXNUM_OVERFLOW_P (i)
? -1
- : hash_lookup (h, make_fixnum (i)));
+ : lisp_hash_lookup (h, make_fixnum (i)));
if (eop >= 0)
{
Lisp_Object opl;
diff --git a/src/charset.c b/src/charset.c
index 797dfde276f..d66476a79b9 100644
--- a/src/charset.c
+++ b/src/charset.c
@@ -1112,7 +1112,7 @@ DEFUN ("define-charset-internal", Fdefine_charset_internal,
hash_hash_t hash_code;
ptrdiff_t hash_index
- = hash_lookup_get_hash (hash_table, args[charset_arg_name],
+ = lisp_hash_lookup_get_hash (hash_table, args[charset_arg_name],
&hash_code);
if (hash_index >= 0)
{
@@ -1122,7 +1122,7 @@ DEFUN ("define-charset-internal", Fdefine_charset_internal,
}
else
{
- hash_put (hash_table, args[charset_arg_name], attrs, hash_code);
+ lisp_hash_put (hash_table, args[charset_arg_name], attrs, hash_code);
if (charset_table_used == charset_table_size)
{
/* Ensure that charset IDs fit into 'int' as well as into the
diff --git a/src/charset.h b/src/charset.h
index 0217ec321ff..def4d13180d 100644
--- a/src/charset.h
+++ b/src/charset.h
@@ -285,7 +285,7 @@ #define CHARSET_SYMBOL_ID(symbol) \
/* Return an index to Vcharset_hash_table of the charset whose symbol
is SYMBOL. */
#define CHARSET_SYMBOL_HASH_INDEX(symbol) \
- hash_lookup (XHASH_TABLE (Vcharset_hash_table), symbol)
+ lisp_hash_lookup (XHASH_TABLE (Vcharset_hash_table), symbol)
/* Return the attribute vector of CHARSET. */
#define CHARSET_ATTRIBUTES(charset) (charset)->attributes
diff --git a/src/coding.h b/src/coding.h
index b72ffde3c55..73c3aa3bfc2 100644
--- a/src/coding.h
+++ b/src/coding.h
@@ -193,8 +193,8 @@ #define CODING_SYSTEM_SPEC(coding_system_symbol) \
/* Return the ID of CODING_SYSTEM_SYMBOL. */
#define CODING_SYSTEM_ID(coding_system_symbol) \
- hash_lookup (XHASH_TABLE (Vcoding_system_hash_table), \
- coding_system_symbol)
+ lisp_hash_lookup (XHASH_TABLE (Vcoding_system_hash_table), \
+ coding_system_symbol)
/* Return true if CODING_SYSTEM_SYMBOL is a coding system. */
diff --git a/src/composite.c b/src/composite.c
index 2ef72a33d2e..9f6554fa74a 100644
--- a/src/composite.c
+++ b/src/composite.c
@@ -241,7 +241,7 @@ get_composition_id (ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t nchars,
goto invalid_composition;
hash_hash_t hash_code;
- hash_index = hash_lookup_get_hash (hash_table, key, &hash_code);
+ hash_index = lisp_hash_lookup_get_hash (hash_table, key, &hash_code);
if (hash_index >= 0)
{
/* We have already registered the same composition. Change PROP
@@ -302,7 +302,7 @@ get_composition_id (ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t nchars,
XSETCDR (prop, Fcons (make_fixnum (nchars), Fcons (key, XCDR (prop))));
/* Register the composition in composition_hash_table. */
- hash_index = hash_put (hash_table, key, id, hash_code);
+ hash_index = lisp_hash_put (hash_table, key, id, hash_code);
method = (NILP (components)
? COMPOSITION_RELATIVE
@@ -664,7 +664,7 @@ composition_gstring_put_cache (Lisp_Object gstring, ptrdiff_t len)
LGSTRING_SET_HEADER (copy, Fcopy_sequence (header));
for (ptrdiff_t i = 0; i < len; i++)
LGSTRING_SET_GLYPH (copy, i, Fcopy_sequence (LGSTRING_GLYPH (gstring, i)));
- ptrdiff_t id = hash_put (h, LGSTRING_HEADER (copy), copy, hash);
+ ptrdiff_t id = lisp_hash_put (h, LGSTRING_HEADER (copy), copy, hash);
LGSTRING_SET_ID (copy, make_fixnum (id));
return copy;
}
@@ -686,7 +686,7 @@ composition_gstring_cache_clear_font (Lisp_Object font_object)
DOHASH (h, k, gstring)
if (EQ (LGSTRING_FONT (gstring), font_object))
- hash_remove_from_table (h, k);
+ lisp_hash_remove_from_table (h, k);
}
DEFUN ("clear-composition-cache", Fclear_composition_cache,
diff --git a/src/emacs-module.c b/src/emacs-module.c
index 7797b04e026..b535aff5fcd 100644
--- a/src/emacs-module.c
+++ b/src/emacs-module.c
@@ -431,7 +431,7 @@ module_make_global_ref (emacs_env *env, emacs_value value)
struct Lisp_Hash_Table *h = XHASH_TABLE (Vmodule_refs_hash);
Lisp_Object new_obj = value_to_lisp (value);
hash_hash_t hashcode;
- ptrdiff_t i = hash_lookup_get_hash (h, new_obj, &hashcode);
+ ptrdiff_t i = lisp_hash_lookup_get_hash (h, new_obj, &hashcode);
/* Note: This approach requires the garbage collector to never move
objects. */
@@ -455,7 +455,7 @@ module_make_global_ref (emacs_env *env, emacs_value value)
ref->refcount = 1;
Lisp_Object value;
XSETPSEUDOVECTOR (value, ref, PVEC_OTHER);
- hash_put (h, new_obj, value, hashcode);
+ lisp_hash_put (h, new_obj, value, hashcode);
MODULE_INTERNAL_CLEANUP ();
return &ref->value;
}
@@ -470,7 +470,7 @@ module_free_global_ref (emacs_env *env, emacs_value global_value)
MODULE_FUNCTION_BEGIN ();
struct Lisp_Hash_Table *h = XHASH_TABLE (Vmodule_refs_hash);
Lisp_Object obj = value_to_lisp (global_value);
- ptrdiff_t i = hash_lookup (h, obj);
+ ptrdiff_t i = lisp_hash_lookup (h, obj);
if (module_assertions)
{
@@ -486,7 +486,7 @@ module_free_global_ref (emacs_env *env, emacs_value global_value)
struct module_global_reference *ref = XMODULE_GLOBAL_REFERENCE (value);
eassert (0 < ref->refcount);
if (--ref->refcount == 0)
- hash_remove_from_table (h, obj);
+ lisp_hash_remove_from_table (h, obj);
}
MODULE_INTERNAL_CLEANUP ();
diff --git a/src/fns.c b/src/fns.c
index 3f109a81836..c1572d11ea9 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -2858,7 +2858,7 @@ internal_equal_1 (Lisp_Object o1, Lisp_Object o2, enum equal_kind equal_kind,
set_hash_value_slot (h, i, Fcons (o2, o2s));
}
else
- hash_put (h, o1, Fcons (o2, Qnil), hash);
+ lisp_hash_put (h, o1, Fcons (o2, Qnil), hash);
}
default: ;
}
@@ -5050,7 +5050,7 @@ hash_lookup_with_hash (struct Lisp_Hash_Table *h,
/* Look up KEY in table H. Return entry index or -1 if none. */
ptrdiff_t
-hash_lookup (struct Lisp_Hash_Table *h, Lisp_Object key)
+lisp_hash_lookup (struct Lisp_Hash_Table *h, Lisp_Object key)
{
return hash_lookup_with_hash (h, key, hash_from_key (h, key));
}
@@ -5058,8 +5058,8 @@ hash_lookup (struct Lisp_Hash_Table *h, Lisp_Object key)
/* Look up KEY in hash table H. Return its hash value in *PHASH.
Value is the index of the entry in H matching KEY, or -1 if not found. */
ptrdiff_t
-hash_lookup_get_hash (struct Lisp_Hash_Table *h, Lisp_Object key,
- hash_hash_t *phash)
+lisp_hash_lookup_get_hash (struct Lisp_Hash_Table *h, Lisp_Object key,
+ hash_hash_t *phash)
{
EMACS_UINT hash = hash_from_key (h, key);
*phash = hash;
@@ -5078,8 +5078,8 @@ check_mutable_hash_table (Lisp_Object obj, struct Lisp_Hash_Table *h)
Value is the index of the entry in H matching KEY. */
ptrdiff_t
-hash_put (struct Lisp_Hash_Table *h, Lisp_Object key, Lisp_Object value,
- hash_hash_t hash)
+lisp_hash_put (struct Lisp_Hash_Table *h, Lisp_Object key, Lisp_Object value,
+ hash_hash_t hash)
{
eassert (!hash_unused_entry_key_p (key));
/* Increment count after resizing because resizing may fail. */
@@ -5107,7 +5107,7 @@ hash_put (struct Lisp_Hash_Table *h, Lisp_Object key, Lisp_Object value,
/* Remove the entry matching KEY from hash table H, if there is one. */
void
-hash_remove_from_table (struct Lisp_Hash_Table *h, Lisp_Object key)
+lisp_hash_remove_from_table (struct Lisp_Hash_Table *h, Lisp_Object key)
{
hash_hash_t hashval = hash_from_key (h, key);
ptrdiff_t start_of_bucket = hash_index_index (h, hashval);
@@ -5288,7 +5288,7 @@ #define SXHASH_MAX_LEN 7
can be any EMACS_UINT value. */
EMACS_UINT
-hash_string (char const *ptr, ptrdiff_t len)
+lisp_hash_string (char const *ptr, ptrdiff_t len)
{
char const *p = ptr;
char const *end = ptr + len;
@@ -5461,7 +5461,7 @@ sxhash_obj (Lisp_Object obj, int depth)
return XHASH (obj);
case Lisp_String:
- return hash_string (SSDATA (obj), SBYTES (obj));
+ return lisp_hash_string (SSDATA (obj), SBYTES (obj));
case Lisp_Vectorlike:
{
@@ -5863,7 +5863,7 @@ DEFUN ("gethash", Fgethash, Sgethash, 2, 3, 0,
(Lisp_Object key, Lisp_Object table, Lisp_Object dflt)
{
struct Lisp_Hash_Table *h = check_hash_table (table);
- ptrdiff_t i = hash_lookup (h, key);
+ ptrdiff_t i = lisp_hash_lookup (h, key);
return i >= 0 ? HASH_VALUE (h, i) : dflt;
}
@@ -5882,7 +5882,7 @@ DEFUN ("puthash", Fputhash, Sputhash, 3, 3, 0,
if (i >= 0)
set_hash_value_slot (h, i, value);
else
- hash_put (h, key, value, hash);
+ lisp_hash_put (h, key, value, hash);
return value;
}
@@ -5894,7 +5894,7 @@ DEFUN ("remhash", Fremhash, Sremhash, 2, 2, 0,
{
struct Lisp_Hash_Table *h = check_hash_table (table);
check_mutable_hash_table (table, h);
- hash_remove_from_table (h, key);
+ lisp_hash_remove_from_table (h, key);
return Qnil;
}
diff --git a/src/image.c b/src/image.c
index 65d8db24adc..b6f04a275fd 100644
--- a/src/image.c
+++ b/src/image.c
@@ -5552,7 +5552,7 @@ xpm_free_color_cache (void)
static int
xpm_color_bucket (char *color_name)
{
- EMACS_UINT hash = hash_string (color_name, strlen (color_name));
+ EMACS_UINT hash = lisp_hash_string (color_name, strlen (color_name));
return hash % XPM_COLOR_CACHE_BUCKETS;
}
@@ -6238,8 +6238,8 @@ xpm_put_color_table_h (Lisp_Object color_table,
Lisp_Object chars = make_unibyte_string (chars_start, chars_len);
hash_hash_t hash_code;
- hash_lookup_get_hash (table, chars, &hash_code);
- hash_put (table, chars, color, hash_code);
+ lisp_hash_lookup_get_hash (table, chars, &hash_code);
+ lisp_hash_put (table, chars, color, hash_code);
}
static Lisp_Object
@@ -6249,7 +6249,7 @@ xpm_get_color_table_h (Lisp_Object color_table,
{
struct Lisp_Hash_Table *table = XHASH_TABLE (color_table);
ptrdiff_t i =
- hash_lookup (table, make_unibyte_string (chars_start, chars_len));
+ lisp_hash_lookup (table, make_unibyte_string (chars_start, chars_len));
return i >= 0 ? HASH_VALUE (table, i) : Qnil;
}
diff --git a/src/json.c b/src/json.c
index 5795c582ce0..f633215aca0 100644
--- a/src/json.c
+++ b/src/json.c
@@ -1571,9 +1571,9 @@ json_parse_object (struct json_parser *parser)
hash_hash_t hash;
Lisp_Object key = parser->object_workspace[i];
Lisp_Object value = parser->object_workspace[i + 1];
- ptrdiff_t i = hash_lookup_get_hash (h, key, &hash);
+ ptrdiff_t i = lisp_hash_lookup_get_hash (h, key, &hash);
if (i < 0)
- hash_put (h, key, value, hash);
+ lisp_hash_put (h, key, value, hash);
else
set_hash_value_slot (h, i, value);
}
diff --git a/src/lisp.h b/src/lisp.h
index 243e8cc7f36..6d78836db3d 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -4261,17 +4261,17 @@ #define CONS_TO_INTEGER(cons, type, var) \
extern bool sweep_weak_table (struct Lisp_Hash_Table *, bool);
extern void hexbuf_digest (char *, void const *, int);
extern char *extract_data_from_object (Lisp_Object, ptrdiff_t *, ptrdiff_t *);
-EMACS_UINT hash_string (char const *, ptrdiff_t);
+EMACS_UINT lisp_hash_string (char const *, ptrdiff_t);
EMACS_UINT sxhash (Lisp_Object);
Lisp_Object make_hash_table (const struct hash_table_test *, EMACS_INT,
hash_table_weakness_t);
Lisp_Object hash_table_weakness_symbol (hash_table_weakness_t weak);
-ptrdiff_t hash_lookup (struct Lisp_Hash_Table *, Lisp_Object);
-ptrdiff_t hash_lookup_get_hash (struct Lisp_Hash_Table *h, Lisp_Object key,
- hash_hash_t *phash);
-ptrdiff_t hash_put (struct Lisp_Hash_Table *, Lisp_Object, Lisp_Object,
- hash_hash_t);
-void hash_remove_from_table (struct Lisp_Hash_Table *, Lisp_Object);
+ptrdiff_t lisp_hash_lookup (struct Lisp_Hash_Table *, Lisp_Object);
+ptrdiff_t lisp_hash_lookup_get_hash (struct Lisp_Hash_Table *h, Lisp_Object key,
+ hash_hash_t *phash);
+ptrdiff_t lisp_hash_put (struct Lisp_Hash_Table *, Lisp_Object, Lisp_Object,
+ hash_hash_t);
+void lisp_hash_remove_from_table (struct Lisp_Hash_Table *, Lisp_Object);
extern struct hash_table_test const hashtest_eq, hashtest_eql, hashtest_equal;
extern void validate_subarray (Lisp_Object, Lisp_Object, Lisp_Object,
ptrdiff_t, ptrdiff_t *, ptrdiff_t *);
diff --git a/src/lread.c b/src/lread.c
index add8deb3954..90759c9386c 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -4258,12 +4258,12 @@ read0 (Lisp_Object readcharfun, bool locate_syms)
= XHASH_TABLE (read_objects_map);
Lisp_Object number = make_fixnum (n);
hash_hash_t hash;
- ptrdiff_t i = hash_lookup_get_hash (h, number, &hash);
+ ptrdiff_t i = lisp_hash_lookup_get_hash (h, number, &hash);
if (i >= 0)
/* Not normal, but input could be malformed. */
set_hash_value_slot (h, i, placeholder);
else
- hash_put (h, number, placeholder, hash);
+ lisp_hash_put (h, number, placeholder, hash);
read_stack_push ((struct read_stack_entry) {
.type = RE_numbered,
.u.numbered.number = number,
@@ -4276,7 +4276,7 @@ read0 (Lisp_Object readcharfun, bool locate_syms)
/* #N# -- reference to numbered object */
struct Lisp_Hash_Table *h
= XHASH_TABLE (read_objects_map);
- ptrdiff_t i = hash_lookup (h, make_fixnum (n));
+ ptrdiff_t i = lisp_hash_lookup (h, make_fixnum (n));
if (i < 0)
INVALID_SYNTAX_WITH_BUFFER ();
obj = HASH_VALUE (h, i);
@@ -4571,9 +4571,9 @@ read0 (Lisp_Object readcharfun, bool locate_syms)
struct Lisp_Hash_Table *h2
= XHASH_TABLE (read_objects_completed);
hash_hash_t hash;
- ptrdiff_t i = hash_lookup_get_hash (h2, placeholder, &hash);
+ ptrdiff_t i = lisp_hash_lookup_get_hash (h2, placeholder, &hash);
eassert (i < 0);
- hash_put (h2, placeholder, Qnil, hash);
+ lisp_hash_put (h2, placeholder, Qnil, hash);
obj = placeholder;
}
else
@@ -4586,9 +4586,9 @@ read0 (Lisp_Object readcharfun, bool locate_syms)
struct Lisp_Hash_Table *h2
= XHASH_TABLE (read_objects_completed);
hash_hash_t hash;
- ptrdiff_t i = hash_lookup_get_hash (h2, obj, &hash);
+ ptrdiff_t i = lisp_hash_lookup_get_hash (h2, obj, &hash);
eassert (i < 0);
- hash_put (h2, obj, Qnil, hash);
+ lisp_hash_put (h2, obj, Qnil, hash);
}
/* Now put it everywhere the placeholder was... */
@@ -4598,7 +4598,7 @@ read0 (Lisp_Object readcharfun, bool locate_syms)
/* ...and #n# will use the real value from now on. */
struct Lisp_Hash_Table *h = XHASH_TABLE (read_objects_map);
hash_hash_t hash;
- ptrdiff_t i = hash_lookup_get_hash (h, e->u.numbered.number,
+ ptrdiff_t i = lisp_hash_lookup_get_hash (h, e->u.numbered.number,
&hash);
eassert (i >= 0);
set_hash_value_slot (h, i, obj);
@@ -4653,7 +4653,7 @@ substitute_object_recurse (struct subst *subst, Lisp_Object subtree)
by #n=, which means that we can find it as a value in
COMPLETED. */
if (EQ (subst->completed, Qt)
- || hash_lookup (XHASH_TABLE (subst->completed), subtree) >= 0)
+ || lisp_hash_lookup (XHASH_TABLE (subst->completed), subtree) >= 0)
subst->seen = Fcons (subtree, subst->seen);
/* Recurse according to subtree's type.
@@ -5165,7 +5165,7 @@ DEFUN ("unintern", Funintern, Sunintern, 2, 2, 0,
static ptrdiff_t
obarray_index (struct Lisp_Obarray *oa, const char *str, ptrdiff_t size_byte)
{
- EMACS_UINT hash = hash_string (str, size_byte);
+ EMACS_UINT hash = lisp_hash_string (str, size_byte);
return knuth_hash (reduce_emacs_uint_to_hash_hash (hash), oa->size_bits);
}
diff --git a/src/minibuf.c b/src/minibuf.c
index b0d54bd51f0..234d730aac0 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -2103,7 +2103,7 @@ DEFUN ("test-completion", Ftest_completion, Stest_completion, 2, 3, 0,
else if (HASH_TABLE_P (collection))
{
struct Lisp_Hash_Table *h = XHASH_TABLE (collection);
- ptrdiff_t i = hash_lookup (h, string);
+ ptrdiff_t i = lisp_hash_lookup (h, string);
if (i >= 0)
{
tem = HASH_KEY (h, i);
--
2.35.1
[Message part 2 (application/pgp-signature, inline)]
GNU bug tracking system
Copyright (C) 1999 Darren O. Benham,
1997,2003 nCipher Corporation Ltd,
1994-97 Ian Jackson.