Adjust remaining uses of `NILP (HASH_HASH)`.

* src/json.c (lisp_to_json_toplevel_1):
* src/pdumper.c (dump_hash_table_stable_p, hash_table_contents):
* src/print.c (print, print_vectorlike):
* src/minibuf.c (Ftry_completion, Fall_completions, Ftest_completion):
Use `EQ (HASH_KEY, Qunbound)` instead of `NILP (HASH_HASH)`.

diff --git a/src/json.c b/src/json.c
index d05f2c54e2ce44c994e1c0a64c016b334ac3e2b6..5a3d0012f0adf664bba2b3f47112e435b610a038 100644 (file)
--- a/src/json.c
+++ b/src/json.c
@@ -361,28 +361,31 @@ lisp_to_json_toplevel_1 (Lisp_Object lisp,
       count = SPECPDL_INDEX ();
       record_unwind_protect_ptr (json_release_object, json);
       for (ptrdiff_t i = 0; i < HASH_TABLE_SIZE (h); ++i)
-        if (!NILP (HASH_HASH (h, i)))
-          {
-            Lisp_Object key = json_encode (HASH_KEY (h, i));
-            /* We can't specify the length, so the string must be
+        {
+          Lisp_Object key = HASH_KEY (h, i);
+          if (!EQ (key, Qunbound))
+            {
+              Lisp_Object ekey = json_encode (key);
+              /* We can't specify the length, so the string must be
                NUL-terminated.  */
-            check_string_without_embedded_nuls (key);
-            const char *key_str = SSDATA (key);
-            /* Reject duplicate keys.  These are possible if the hash
+              check_string_without_embedded_nuls (ekey);
+              const char *key_str = SSDATA (ekey);
+              /* Reject duplicate keys.  These are possible if the hash
                table test is not `equal'.  */
-            if (json_object_get (json, key_str) != NULL)
-              wrong_type_argument (Qjson_value_p, lisp);
-            int status = json_object_set_new (json, key_str,
-                                              lisp_to_json (HASH_VALUE (h, i),
-                                                            conf));
-            if (status == -1)
-              {
-                /* A failure can be caused either by an invalid key or
+              if (json_object_get (json, key_str) != NULL)
+                wrong_type_argument (Qjson_value_p, lisp);
+              int status
+                = json_object_set_new (json, key_str,
+                                       lisp_to_json (HASH_VALUE (h, i), conf));
+              if (status == -1)
+                {
+                  /* A failure can be caused either by an invalid key or
                    by low memory.  */
-                json_check_utf8 (key);
-                json_out_of_memory ();
-              }
-          }
+                  json_check_utf8 (ekey);
+                  json_out_of_memory ();
+                }
+            }
+        }
     }
   else if (NILP (lisp))
     return json_check (json_object ());

diff --git a/src/minibuf.c b/src/minibuf.c
index 8920f37827dbb6e711f576f56b781adc53e76029..14a0dbe762cd8d26b67e28ad2753cd0b158d4cff 100644 (file)
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -1245,7 +1245,7 @@ is used to further constrain the set of candidates.  */)
       else /* if (type == hash_table) */
        {
          while (idx < HASH_TABLE_SIZE (XHASH_TABLE (collection))
-                && NILP (HASH_HASH (XHASH_TABLE (collection), idx)))
+                && EQ (HASH_KEY (XHASH_TABLE (collection), idx), Qunbound))
            idx++;
          if (idx >= HASH_TABLE_SIZE (XHASH_TABLE (collection)))
            break;
@@ -1497,7 +1497,7 @@ with a space are ignored unless STRING itself starts with a space.  */)
       else /* if (type == 3) */
        {
          while (idx < HASH_TABLE_SIZE (XHASH_TABLE (collection))
-                && NILP (HASH_HASH (XHASH_TABLE (collection), idx)))
+                && EQ (HASH_KEY (XHASH_TABLE (collection), idx), Qunbound))
            idx++;
          if (idx >= HASH_TABLE_SIZE (XHASH_TABLE (collection)))
            break;
@@ -1724,8 +1724,8 @@ the values STRING, PREDICATE and `lambda'.  */)
       else
        for (i = 0; i < HASH_TABLE_SIZE (h); ++i)
           {
-            if (NILP (HASH_HASH (h, i))) continue;
             tem = HASH_KEY (h, i);
+            if (EQ (tem, Qunbound)) continue;
             Lisp_Object strkey = (SYMBOLP (tem) ? Fsymbol_name (tem) : tem);
             if (!STRINGP (strkey)) continue;
             if (EQ (Fcompare_strings (string, Qnil, Qnil,

diff --git a/src/pdumper.c b/src/pdumper.c
index 1a5d1f32ba5f2db9ccec9dcbfd91eca01ccb9948..31f4f33adf34d05e51b2edcd89753d3cf9e86f82 100644 (file)
--- a/src/pdumper.c
+++ b/src/pdumper.c
@@ -2629,18 +2629,20 @@ dump_hash_table_stable_p (const struct Lisp_Hash_Table *hash)
   bool is_equal = hash->test.hashfn == hashfn_equal;
   ptrdiff_t size = HASH_TABLE_SIZE (hash);
   for (ptrdiff_t i = 0; i < size; ++i)
-    if (!NILP (HASH_HASH (hash, i)))
-      {
-        Lisp_Object key =  HASH_KEY (hash, i);
-       bool key_stable = (dump_builtin_symbol_p (key)
-                          || FIXNUMP (key)
-                          || (is_equal
-                              && (STRINGP (key) || BOOL_VECTOR_P (key)))
-                          || ((is_equal || is_eql)
-                              && (FLOATP (key) || BIGNUMP (key))));
-        if (!key_stable)
-          return false;
-      }
+    {
+      Lisp_Object key =  HASH_KEY (hash, i);
+      if (!EQ (key, Qunbound))
+        {
+         bool key_stable = (dump_builtin_symbol_p (key)
+                            || FIXNUMP (key)
+                            || (is_equal
+                                && (STRINGP (key) || BOOL_VECTOR_P (key)))
+                            || ((is_equal || is_eql)
+                                && (FLOATP (key) || BIGNUMP (key))));
+          if (!key_stable)
+            return false;
+        }
+    }
 
   return true;
 }
@@ -2652,8 +2654,11 @@ hash_table_contents (Lisp_Object table)
   Lisp_Object contents = Qnil;
   struct Lisp_Hash_Table *h = XHASH_TABLE (table);
   for (ptrdiff_t i = 0; i < HASH_TABLE_SIZE (h); ++i)
-    if (!NILP (HASH_HASH (h, i)))
-      dump_push (&contents, Fcons (HASH_KEY (h, i), HASH_VALUE (h, i)));
+    {
+      Lisp_Object key =  HASH_KEY (h, i);
+      if (!EQ (key, Qunbound))
+        dump_push (&contents, Fcons (key, HASH_VALUE (h, i)));
+    }
   return Fnreverse (contents);
 }
 

diff --git a/src/print.c b/src/print.c
index cb340905142a3b2a214a8e8a2d065cd1168696f1..7c3da68fc9894cb9af87c366ef351924f11f2548 100644 (file)
--- a/src/print.c
+++ b/src/print.c
@@ -1135,9 +1135,12 @@ print (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
          ptrdiff_t i;
 
          for (i = 0; i < HASH_TABLE_SIZE (h); ++i)
-           if (!NILP (HASH_HASH (h, i))
-               && EQ (HASH_VALUE (h, i), Qt))
-             Fremhash (HASH_KEY (h, i), Vprint_number_table);
+            {
+              Lisp_Object key =  HASH_KEY (h, i);
+             if (!EQ (key, Qunbound)
+                 && EQ (HASH_VALUE (h, i), Qt))
+               Fremhash (key, Vprint_number_table);
+            }
        }
     }
 
@@ -1593,13 +1596,16 @@ print_vectorlike (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag,
 
        printchar ('(', printcharfun);
        for (ptrdiff_t i = 0; i < size; i++)
-         if (!NILP (HASH_HASH (h, i)))
-           {
-             if (i) printchar (' ', printcharfun);
-             print_object (HASH_KEY (h, i), printcharfun, escapeflag);
-             printchar (' ', printcharfun);
-             print_object (HASH_VALUE (h, i), printcharfun, escapeflag);
-           }
+          {
+            Lisp_Object key = HASH_KEY (h, i);
+           if (!EQ (key, Qunbound))
+             {
+               if (i) printchar (' ', printcharfun);
+               print_object (key, printcharfun, escapeflag);
+               printchar (' ', printcharfun);
+               print_object (HASH_VALUE (h, i), printcharfun, escapeflag);
+             }
+          }
 
        if (size < real_size)
          print_c_string (" ...", printcharfun);