update.

[chise/xemacs-chise.git.1] / src / elhash.c

diff --git a/src/elhash.c b/src/elhash.c
index f1462fe..9055e93 100644 (file)
--- a/src/elhash.c
+++ b/src/elhash.c
@@ -336,7 +336,7 @@ print_hash_table (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
   else if (ht->test_function == lisp_object_eql_equal)
     DO_NOTHING;
   else
-    abort ();
+    ABORT ();
 
   if (ht->count || !print_readably)
     {
@@ -461,7 +461,7 @@ make_standard_lisp_hash_table (enum hash_table_test test,
       break;
 
     default:
-      abort ();
+      ABORT ();
     }
 
   return make_general_lisp_hash_table (hash_function, test_function,
@@ -730,7 +730,7 @@ hash_table_instantiate (Lisp_Object plist)
       else if (EQ (key, Qdata))                    data             = value;
       else if (EQ (key, Qtype))/*obsolete*/ weakness        = value;
       else
-       abort ();
+       ABORT ();
     }
 
   /* Create the hash table.  */
@@ -809,7 +809,7 @@ Use Common Lisp style keywords to specify hash table properties.
 Keyword :test can be `eq', `eql' (default) or `equal'.
 Comparison between keys is done using this function.
 If speed is important, consider using `eq'.
-When storing strings in the hash table, you will likely need to use `equal'.
+When hash table keys may be strings, you will likely need to use `equal'.
 
 Keyword :size specifies the number of keys likely to be inserted.
 This number of entries can be inserted without enlarging the hash table.
@@ -1201,6 +1201,19 @@ may remhash or puthash the entry currently being processed by FUNCTION.
   return Qnil;
 }
 
+/* #### If the Lisp function being called does a puthash and this
+   #### causes the hash table to be resized, the results will be quite
+   #### random and we will likely crash.  To fix this, either set a
+   #### flag in the hash table while we're mapping and signal an error
+   #### when new entries are added, or fix things to make this
+   #### operation work properly, like this: Store two hash tables in
+   #### each hash table object -- the second one is written to when
+   #### you do a puthash inside of a mapping operation, and the
+   #### various operations need to check both hash tables for entries.
+   #### As soon as the last maphash over a particular hash table
+   #### object terminates, the entries in the second table are added
+   #### to the first (using an unwind-protect). --ben */
+
 /* Map *C* function FUNCTION over the elements of a lisp hash table. */
 void
 elisp_maphash (maphash_function_t function,