Abstract predicate and constant for unused hash keys

Qunbound is used for many things; using a predicate and constant for
the specific purpose of unused hash entry keys allows us to locate
them and make changes much more easily.

* src/lisp.h (HASH_UNUSED_ENTRY_KEY, hash_unused_entry_key_p):
New constant and function.
* src/comp.c (compile_function, Fcomp__compile_ctxt_to_file):
* src/composite.c (composition_gstring_cache_clear_font):
* src/emacs-module.c (module_global_reference_p):
* src/fns.c (make_hash_table, maybe_resize_hash_table, hash_put)
(hash_remove_from_table, hash_clear, sweep_weak_table, Fmaphash):
* src/json.c (lisp_to_json_nonscalar_1):
* src/minibuf.c (Ftry_completion, Fall_completions, Ftest_completion):
* src/print.c (print, print_object):
Use them.

diff --git a/src/comp.c b/src/comp.c
index 347f8924793ac0cc36411742e614f04c7a2564df..2872c28a2b1fdef367a63caeb4acbe36951d70c4 100644 (file)
--- a/src/comp.c
+++ b/src/comp.c
@@ -4334,7 +4334,7 @@ compile_function (Lisp_Object func)
     {
       Lisp_Object block_name = HASH_KEY (ht, i);
       if (!EQ (block_name, Qentry)
-         && !BASE_EQ (block_name, Qunbound))
+         && !hash_unused_entry_key_p (block_name))
        declare_block (block_name);
     }
 
@@ -4347,7 +4347,7 @@ compile_function (Lisp_Object func)
   for (ptrdiff_t i = 0; i < HASH_TABLE_SIZE (ht); i++)
     {
       Lisp_Object block_name = HASH_KEY (ht, i);
-      if (!BASE_EQ (block_name, Qunbound))
+      if (!hash_unused_entry_key_p (block_name))
        {
          Lisp_Object block = HASH_VALUE (ht, i);
          Lisp_Object insns = CALL1I (comp-block-insns, block);
@@ -4966,12 +4966,12 @@ DEFUN ("comp--compile-ctxt-to-file", Fcomp__compile_ctxt_to_file,
   struct Lisp_Hash_Table *func_h =
     XHASH_TABLE (CALL1I (comp-ctxt-funcs-h, Vcomp_ctxt));
   for (ptrdiff_t i = 0; i < HASH_TABLE_SIZE (func_h); i++)
-    if (!BASE_EQ (HASH_KEY (func_h, i), Qunbound))
+    if (!hash_unused_entry_key_p (HASH_KEY (func_h, i)))
       declare_function (HASH_VALUE (func_h, i));
   /* Compile all functions. Can't be done before because the
      relocation structs has to be already defined.  */
   for (ptrdiff_t i = 0; i < HASH_TABLE_SIZE (func_h); i++)
-    if (!BASE_EQ (HASH_KEY (func_h, i), Qunbound))
+    if (!hash_unused_entry_key_p (HASH_KEY (func_h, i)))
       compile_function (HASH_VALUE (func_h, i));
 
   /* Work around bug#46495 (GCC PR99126). */

diff --git a/src/composite.c b/src/composite.c
index 7c7f47205149fa20afb5da6e97ddb2cd43d6bcd9..ed1aeb380a076decb4440a1ec4d63c0f1c040635 100644 (file)
--- a/src/composite.c
+++ b/src/composite.c
@@ -690,7 +690,7 @@ composition_gstring_cache_clear_font (Lisp_Object font_object)
     {
       Lisp_Object k = HASH_KEY (h, i);
 
-      if (!BASE_EQ (k, Qunbound))
+      if (!hash_unused_entry_key_p (k))
        {
          Lisp_Object gstring = HASH_VALUE (h, i);
 

diff --git a/src/emacs-module.c b/src/emacs-module.c
index 46bd732e8eb85b05be263a044c4682f7ee771626..283703b3651bfc6ba6bafc15cf03fe6971f53891 100644 (file)
--- a/src/emacs-module.c
+++ b/src/emacs-module.c
@@ -412,7 +412,7 @@ module_global_reference_p (emacs_value v, ptrdiff_t *n)
      reference that's identical to some global reference.  */
   for (ptrdiff_t i = 0; i < HASH_TABLE_SIZE (h); ++i)
     {
-      if (!BASE_EQ (HASH_KEY (h, i), Qunbound)
+      if (!hash_unused_entry_key_p (HASH_KEY (h, i))
           && &XMODULE_GLOBAL_REFERENCE (HASH_VALUE (h, i))->value == v)
         return true;
     }

diff --git a/src/fns.c b/src/fns.c
index 56b4e9a18c0acd774e5ed2d59102a958f3a513fc..d8da8992ce9c0057a50adbea507a0dc006f54500 100644 (file)
--- a/src/fns.c
+++ b/src/fns.c
@@ -4575,7 +4575,7 @@ make_hash_table (struct hash_table_test test, EMACS_INT size,
   h->rehash_threshold = rehash_threshold;
   h->rehash_size = rehash_size;
   h->count = 0;
-  h->key_and_value = make_vector (2 * size, Qunbound);
+  h->key_and_value = make_vector (2 * size, HASH_UNUSED_ENTRY_KEY);
   h->hash = make_nil_vector (size);
   h->next = make_vector (size, make_fixnum (-1));
   h->index = make_vector (hash_index_size (h, size), make_fixnum (-1));
@@ -4678,7 +4678,7 @@ maybe_resize_hash_table (struct Lisp_Hash_Table *h)
       Lisp_Object key_and_value
        = alloc_larger_vector (h->key_and_value, 2 * new_size);
       for (ptrdiff_t i = 2 * old_size; i < 2 * new_size; i++)
-        ASET (key_and_value, i, Qunbound);
+        ASET (key_and_value, i, HASH_UNUSED_ENTRY_KEY);
 
       Lisp_Object hash = alloc_larger_vector (h->hash, new_size);
       memclear (XVECTOR (hash)->contents + old_size,
@@ -4782,7 +4782,7 @@ hash_put (struct Lisp_Hash_Table *h, Lisp_Object key, Lisp_Object value,
   /* Store key/value in the key_and_value vector.  */
   ptrdiff_t i = h->next_free;
   eassert (NILP (HASH_HASH (h, i)));
-  eassert (BASE_EQ (Qunbound, (HASH_KEY (h, i))));
+  eassert (hash_unused_entry_key_p (HASH_KEY (h, i)));
   h->next_free = HASH_NEXT (h, i);
   set_hash_key_slot (h, i, key);
   set_hash_value_slot (h, i, value);
@@ -4824,7 +4824,7 @@ hash_remove_from_table (struct Lisp_Hash_Table *h, Lisp_Object key)
 
          /* Clear slots in key_and_value and add the slots to
             the free list.  */
-         set_hash_key_slot (h, i, Qunbound);
+         set_hash_key_slot (h, i, HASH_UNUSED_ENTRY_KEY);
          set_hash_value_slot (h, i, Qnil);
          set_hash_hash_slot (h, i, Qnil);
          set_hash_next_slot (h, i, h->next_free);
@@ -4851,7 +4851,7 @@ hash_clear (struct Lisp_Hash_Table *h)
       for (ptrdiff_t i = 0; i < size; i++)
        {
          set_hash_next_slot (h, i, i < size - 1 ? i + 1 : -1);
-         set_hash_key_slot (h, i, Qunbound);
+         set_hash_key_slot (h, i, HASH_UNUSED_ENTRY_KEY);
          set_hash_value_slot (h, i, Qnil);
        }
 
@@ -4922,7 +4922,7 @@ sweep_weak_table (struct Lisp_Hash_Table *h, bool remove_entries_p)
                  h->next_free = i;
 
                  /* Clear key, value, and hash.  */
-                 set_hash_key_slot (h, i, Qunbound);
+                 set_hash_key_slot (h, i, HASH_UNUSED_ENTRY_KEY);
                  set_hash_value_slot (h, i, Qnil);
                   if (!NILP (h->hash))
                     set_hash_hash_slot (h, i, Qnil);
@@ -5535,7 +5535,7 @@ FUNCTION is called with two arguments, KEY and VALUE.
   for (ptrdiff_t i = 0; i < HASH_TABLE_SIZE (h); ++i)
     {
       Lisp_Object k = HASH_KEY (h, i);
-      if (!BASE_EQ (k, Qunbound))
+      if (!hash_unused_entry_key_p (k))
         call2 (function, k, HASH_VALUE (h, i));
     }
 

diff --git a/src/json.c b/src/json.c
index af5f30c7275d8ff53659e93875200a0682feb51a..d98b312ecc929620b2230ceb06236616cc4b0e4f 100644 (file)
--- a/src/json.c
+++ b/src/json.c
@@ -364,7 +364,7 @@ lisp_to_json_nonscalar_1 (Lisp_Object lisp,
       for (ptrdiff_t i = 0; i < HASH_TABLE_SIZE (h); ++i)
         {
           Lisp_Object key = HASH_KEY (h, i);
-          if (!BASE_EQ (key, Qunbound))
+          if (!hash_unused_entry_key_p (key))
             {
               CHECK_STRING (key);
               Lisp_Object ekey = json_encode (key);

diff --git a/src/lisp.h b/src/lisp.h
index a34726adbcbbc781e104545604a02b1209f313ad..549b51d3f7fb7661d2cb1c5b3b781edcbaa311bb 100644 (file)
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -2462,7 +2462,7 @@ struct Lisp_Hash_Table
 
   /* Vector of keys and values.  The key of item I is found at index
      2 * I, the value is found at index 2 * I + 1.
-     If the key is equal to Qunbound, then this slot is unused.
+     If the key is HASH_UNUSED_ENTRY_KEY, then this slot is unused.
      This is gc_marked specially if the table is weak.  */
   Lisp_Object key_and_value;
 
@@ -2478,6 +2478,16 @@ struct Lisp_Hash_Table
 /* Sanity-check pseudovector layout.  */
 verify (offsetof (struct Lisp_Hash_Table, weak) == header_size);
 
+/* Key value that marks an unused hash table entry.  */
+#define HASH_UNUSED_ENTRY_KEY Qunbound
+
+/* KEY is a key of an unused hash table entry.  */
+INLINE bool
+hash_unused_entry_key_p (Lisp_Object key)
+{
+  return BASE_EQ (key, HASH_UNUSED_ENTRY_KEY);
+}
+
 INLINE bool
 HASH_TABLE_P (Lisp_Object a)
 {

diff --git a/src/minibuf.c b/src/minibuf.c
index f4f9da9c3f934274db46d77c06e5f8f5d569553b..22bb8fa1d75425132b1a00f4c2989a2e160e7e04 100644 (file)
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -1680,8 +1680,8 @@ or from one of the possible completions.  */)
       else /* if (type == hash_table) */
        {
          while (idx < HASH_TABLE_SIZE (XHASH_TABLE (collection))
-                && BASE_EQ (HASH_KEY (XHASH_TABLE (collection), idx),
-                            Qunbound))
+                && hash_unused_entry_key_p (HASH_KEY (XHASH_TABLE (collection),
+                                                      idx)))
            idx++;
          if (idx >= HASH_TABLE_SIZE (XHASH_TABLE (collection)))
            break;
@@ -1918,8 +1918,8 @@ with a space are ignored unless STRING itself starts with a space.  */)
       else /* if (type == 3) */
        {
          while (idx < HASH_TABLE_SIZE (XHASH_TABLE (collection))
-                && BASE_EQ (HASH_KEY (XHASH_TABLE (collection), idx),
-                            Qunbound))
+                && hash_unused_entry_key_p (HASH_KEY (XHASH_TABLE (collection),
+                                                      idx)))
            idx++;
          if (idx >= HASH_TABLE_SIZE (XHASH_TABLE (collection)))
            break;
@@ -2117,7 +2117,7 @@ the values STRING, PREDICATE and `lambda'.  */)
        for (i = 0; i < HASH_TABLE_SIZE (h); ++i)
           {
             tem = HASH_KEY (h, i);
-            if (BASE_EQ (tem, Qunbound)) continue;
+            if (hash_unused_entry_key_p (tem)) continue;
             Lisp_Object strkey = (SYMBOLP (tem) ? Fsymbol_name (tem) : tem);
             if (!STRINGP (strkey)) continue;
             if (BASE_EQ (Fcompare_strings (string, Qnil, Qnil,

diff --git a/src/print.c b/src/print.c
index 26ed52b46533b42918a953a6150930ac6817bfd0..e22f3b6778ceee7b974c4c8761ca779574ddc331 100644 (file)
--- a/src/print.c
+++ b/src/print.c
@@ -1290,7 +1290,7 @@ print (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
          for (i = 0; i < HASH_TABLE_SIZE (h); ++i)
             {
               Lisp_Object key =  HASH_KEY (h, i);
-             if (!BASE_EQ (key, Qunbound)
+             if (!hash_unused_entry_key_p (key)
                  && EQ (HASH_VALUE (h, i), Qt))
                Fremhash (key, Vprint_number_table);
             }
@@ -2770,7 +2770,7 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
            {
              Lisp_Object key;
              ptrdiff_t idx = e->u.hash.idx;
-             while (BASE_EQ ((key = HASH_KEY (h, idx)), Qunbound))
+             while (hash_unused_entry_key_p ((key = HASH_KEY (h, idx))))
                idx++;
              e->u.hash.idx = idx;
              obj = key;