#include "bytecode.h"
#include "elhash.h"
-Lisp_Object Qhash_tablep, Qhashtable, Qhash_table;
-Lisp_Object Qweak, Qkey_weak, Qvalue_weak, Qnon_weak;
+Lisp_Object Qhash_tablep;
+static Lisp_Object Qhashtable, Qhash_table;
+static Lisp_Object Qweakness, Qvalue;
static Lisp_Object Vall_weak_hash_tables;
static Lisp_Object Qrehash_size, Qrehash_threshold;
-static Lisp_Object Q_size, Q_test, Q_type, Q_rehash_size, Q_rehash_threshold;
+static Lisp_Object Q_size, Q_test, Q_weakness, Q_rehash_size, Q_rehash_threshold;
+
+/* obsolete as of 19990901 in xemacs-21.2 */
+static Lisp_Object Qweak, Qkey_weak, Qvalue_weak, Qnon_weak, Q_type;
typedef struct hentry
{
hash_table_hash_function_t hash_function;
hash_table_test_function_t test_function;
hentry *hentries;
- enum hash_table_type type; /* whether and how this hash table is weak */
+ enum hash_table_weakness weakness;
Lisp_Object next_weak; /* Used to chain together all of the weak
hash tables. Don't mark through this. */
};
typedef struct Lisp_Hash_Table Lisp_Hash_Table;
#define HENTRY_CLEAR_P(hentry) ((*(EMACS_UINT*)(&((hentry)->key))) == 0)
-#define CLEAR_HENTRY(hentry) ((*(EMACS_UINT*)(&((hentry)->key))) = 0)
+#define CLEAR_HENTRY(hentry) \
+ ((*(EMACS_UINT*)(&((hentry)->key))) = 0, \
+ (*(EMACS_UINT*)(&((hentry)->value))) = 0)
#define HASH_TABLE_DEFAULT_SIZE 16
#define HASH_TABLE_DEFAULT_REHASH_SIZE 1.3
\f
static Lisp_Object
-mark_hash_table (Lisp_Object obj, void (*markobj) (Lisp_Object))
+mark_hash_table (Lisp_Object obj)
{
Lisp_Hash_Table *ht = XHASH_TABLE (obj);
/* If the hash table is weak, we don't want to mark the keys and
values (we scan over them after everything else has been marked,
and mark or remove them as necessary). */
- if (ht->type == HASH_TABLE_NON_WEAK)
+ if (ht->weakness == HASH_TABLE_NON_WEAK)
{
hentry *e, *sentinel;
for (e = ht->hentries, sentinel = e + ht->size; e < sentinel; e++)
if (!HENTRY_CLEAR_P (e))
{
- markobj (e->key);
- markobj (e->value);
+ mark_object (e->key);
+ mark_object (e->value);
}
}
return Qnil;
}
\f
/* Equality of hash tables. Two hash tables are equal when they are of
- the same type and test function, they have the same number of
+ the same weakness and test function, they have the same number of
elements, and for each key in the hash table, the values are `equal'.
This is similar to Common Lisp `equalp' of hash tables, with the
hentry *e, *sentinel;
if ((ht1->test_function != ht2->test_function) ||
- (ht1->type != ht2->type) ||
+ (ht1->weakness != ht2->weakness) ||
(ht1->count != ht2->count))
return 0;
#s(hash-table size 2 data (key1 value1 key2 value2))
- The supported keywords are `type' (non-weak (or nil), weak,
- key-weak and value-weak), `test' (eql (or nil), eq or equal),
- `size' (a natnum or nil) and `data' (a list).
+ The supported hash table structure keywords and their values are:
+ `test' (eql (or nil), eq or equal)
+ `size' (a natnum or nil)
+ `rehash-size' (a float)
+ `rehash-threshold' (a float)
+ `weakness' (nil, t, key or value)
+ `data' (a list)
If `print-readably' is non-nil, then a simpler syntax is used; for
instance:
write_c_string (print_readably ? "#s(hash-table" : "#<hash-table",
printcharfun);
- if (ht->type != HASH_TABLE_NON_WEAK)
- {
- sprintf (buf, " type %s",
- (ht->type == HASH_TABLE_WEAK ? "weak" :
- ht->type == HASH_TABLE_KEY_WEAK ? "key-weak" :
- ht->type == HASH_TABLE_VALUE_WEAK ? "value-weak" :
- "you-d-better-not-see-this"));
- write_c_string (buf, printcharfun);
- }
-
/* These checks have a kludgy look to them, but they are safe.
Due to nature of hashing, you cannot use arbitrary
test functions anyway. */
write_c_string (buf, printcharfun);
}
+ if (ht->weakness != HASH_TABLE_NON_WEAK)
+ {
+ sprintf (buf, " weakness %s",
+ (ht->weakness == HASH_TABLE_WEAK ? "t" :
+ ht->weakness == HASH_TABLE_KEY_WEAK ? "key" :
+ ht->weakness == HASH_TABLE_VALUE_WEAK ? "value" :
+ "you-d-better-not-see-this"));
+ write_c_string (buf, printcharfun);
+ }
+
if (ht->count)
print_hash_table_data (ht, printcharfun);
hentry_description_1
};
-static const struct lrecord_description hash_table_description[] = {
+const struct lrecord_description hash_table_description[] = {
{ XD_SIZE_T, offsetof(Lisp_Hash_Table, size) },
- { XD_STRUCT_PTR, offsetof(Lisp_Hash_Table, hentries), XD_INDIRECT(0), &hentry_description },
+ { XD_STRUCT_PTR, offsetof(Lisp_Hash_Table, hentries), XD_INDIRECT(0, 1), &hentry_description },
+ { XD_LO_LINK, offsetof(Lisp_Hash_Table, next_weak) },
{ XD_END }
};
}
Lisp_Object
-make_general_lisp_hash_table (size_t size,
- enum hash_table_type type,
- enum hash_table_test test,
- double rehash_size,
- double rehash_threshold)
+make_general_lisp_hash_table (enum hash_table_test test,
+ size_t size,
+ double rehash_size,
+ double rehash_threshold,
+ enum hash_table_weakness weakness)
{
Lisp_Object hash_table;
Lisp_Hash_Table *ht = alloc_lcrecord_type (Lisp_Hash_Table, &lrecord_hash_table);
- ht->type = type;
ht->rehash_size = rehash_size;
ht->rehash_threshold = rehash_threshold;
+ ht->weakness = weakness;
switch (test)
{
XSETHASH_TABLE (hash_table, ht);
- if (type == HASH_TABLE_NON_WEAK)
+ if (weakness == HASH_TABLE_NON_WEAK)
ht->next_weak = Qunbound;
else
ht->next_weak = Vall_weak_hash_tables, Vall_weak_hash_tables = hash_table;
Lisp_Object
make_lisp_hash_table (size_t size,
- enum hash_table_type type,
+ enum hash_table_weakness weakness,
enum hash_table_test test)
{
- return make_general_lisp_hash_table (size, type, test,
- HASH_TABLE_DEFAULT_REHASH_SIZE, -1.0);
+ return make_general_lisp_hash_table
+ (test, size, HASH_TABLE_DEFAULT_REHASH_SIZE, -1.0, weakness);
}
/* Pretty reading of hash tables.
}
static int
-hash_table_type_validate (Lisp_Object keyword, Lisp_Object value,
- Error_behavior errb)
+hash_table_weakness_validate (Lisp_Object keyword, Lisp_Object value,
+ Error_behavior errb)
{
if (EQ (value, Qnil)) return 1;
+ if (EQ (value, Qt)) return 1;
+ if (EQ (value, Qkey)) return 1;
+ if (EQ (value, Qvalue)) return 1;
+
+ /* Following values are obsolete as of 19990901 in xemacs-21.2 */
if (EQ (value, Qnon_weak)) return 1;
if (EQ (value, Qweak)) return 1;
if (EQ (value, Qkey_weak)) return 1;
if (EQ (value, Qvalue_weak)) return 1;
- maybe_signal_simple_error ("Invalid hash table type",
+ maybe_signal_simple_error ("Invalid hash table weakness",
value, Qhash_table, errb);
return 0;
}
-static enum hash_table_type
-decode_hash_table_type (Lisp_Object obj)
+static enum hash_table_weakness
+decode_hash_table_weakness (Lisp_Object obj)
{
if (EQ (obj, Qnil)) return HASH_TABLE_NON_WEAK;
+ if (EQ (obj, Qt)) return HASH_TABLE_WEAK;
+ if (EQ (obj, Qkey)) return HASH_TABLE_KEY_WEAK;
+ if (EQ (obj, Qvalue)) return HASH_TABLE_VALUE_WEAK;
+
+ /* Following values are obsolete as of 19990901 in xemacs-21.2 */
if (EQ (obj, Qnon_weak)) return HASH_TABLE_NON_WEAK;
if (EQ (obj, Qweak)) return HASH_TABLE_WEAK;
if (EQ (obj, Qkey_weak)) return HASH_TABLE_KEY_WEAK;
if (EQ (obj, Qvalue_weak)) return HASH_TABLE_VALUE_WEAK;
- signal_simple_error ("Invalid hash table type", obj);
+ signal_simple_error ("Invalid hash table weakness", obj);
return HASH_TABLE_NON_WEAK; /* not reached */
}
static int
hash_table_rehash_size_validate (Lisp_Object keyword, Lisp_Object value,
- Error_behavior errb)
+ Error_behavior errb)
{
if (!FLOATP (value))
{
{
Lisp_Object hash_table;
Lisp_Object test = Qnil;
- Lisp_Object type = Qnil;
Lisp_Object size = Qnil;
- Lisp_Object data = Qnil;
Lisp_Object rehash_size = Qnil;
Lisp_Object rehash_threshold = Qnil;
+ Lisp_Object weakness = Qnil;
+ Lisp_Object data = Qnil;
while (!NILP (plist))
{
value = XCAR (plist); plist = XCDR (plist);
if (EQ (key, Qtest)) test = value;
- else if (EQ (key, Qtype)) type = value;
else if (EQ (key, Qsize)) size = value;
- else if (EQ (key, Qdata)) data = value;
else if (EQ (key, Qrehash_size)) rehash_size = value;
else if (EQ (key, Qrehash_threshold)) rehash_threshold = value;
+ else if (EQ (key, Qweakness)) weakness = value;
+ else if (EQ (key, Qdata)) data = value;
+ else if (EQ (key, Qtype))/*obsolete*/ weakness = value;
else
abort ();
}
/* Create the hash table. */
hash_table = make_general_lisp_hash_table
- (decode_hash_table_size (size),
- decode_hash_table_type (type),
- decode_hash_table_test (test),
+ (decode_hash_table_test (test),
+ decode_hash_table_size (size),
decode_hash_table_rehash_size (rehash_size),
- decode_hash_table_rehash_threshold (rehash_threshold));
+ decode_hash_table_rehash_threshold (rehash_threshold),
+ decode_hash_table_weakness (weakness));
/* I'm not sure whether this can GC, but better safe than sorry. */
{
struct structure_type *st;
st = define_structure_type (structure_name, 0, hash_table_instantiate);
- define_structure_type_keyword (st, Qsize, hash_table_size_validate);
define_structure_type_keyword (st, Qtest, hash_table_test_validate);
- define_structure_type_keyword (st, Qtype, hash_table_type_validate);
- define_structure_type_keyword (st, Qdata, hash_table_data_validate);
+ define_structure_type_keyword (st, Qsize, hash_table_size_validate);
define_structure_type_keyword (st, Qrehash_size, hash_table_rehash_size_validate);
define_structure_type_keyword (st, Qrehash_threshold, hash_table_rehash_threshold_validate);
+ define_structure_type_keyword (st, Qweakness, hash_table_weakness_validate);
+ define_structure_type_keyword (st, Qdata, hash_table_data_validate);
+
+ /* obsolete as of 19990901 in xemacs-21.2 */
+ define_structure_type_keyword (st, Qtype, hash_table_weakness_validate);
}
/* Create a built-in Lisp structure type named `hash-table'.
We make #s(hashtable ...) equivalent to #s(hash-table ...),
- for backward comptabibility.
+ for backward compatibility.
This is called from emacs.c. */
void
structure_type_create_hash_table (void)
DEFUN ("make-hash-table", Fmake_hash_table, 0, MANY, 0, /*
Return a new empty hash table object.
Use Common Lisp style keywords to specify hash table properties.
- (make-hash-table &key :size :test :type :rehash-size :rehash-threshold)
-
-Keyword :size specifies the number of keys likely to be inserted.
-This number of entries can be inserted without enlarging the hash table.
+ (make-hash-table &key test size rehash-size rehash-threshold weakness)
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'.
-Keyword :type can be `non-weak' (default), `weak', `key-weak' or `value-weak'.
+Keyword :size specifies the number of keys likely to be inserted.
+This number of entries can be inserted without enlarging the hash table.
+
+Keyword :rehash-size must be a float greater than 1.0, and specifies
+the factor by which to increase the size of the hash table when enlarging.
+
+Keyword :rehash-threshold must be a float between 0.0 and 1.0,
+and specifies the load factor of the hash table which triggers enlarging.
+
+Non-standard keyword :weakness can be `nil' (default), `t', `key' or `value'.
A weak hash table is one whose pointers do not count as GC referents:
for any key-value pair in the hash table, if the only remaining pointer
unmarked outside of weak hash tables. The pair will remain in the
hash table if the value is pointed to by something other than a weak
hash table, even if the key is not.
-
-Keyword :rehash-size must be a float greater than 1.0, and specifies
-the factor by which to increase the size of the hash table when enlarging.
-
-Keyword :rehash-threshold must be a float between 0.0 and 1.0,
-and specifies the load factor of the hash table which triggers enlarging.
-
*/
(int nargs, Lisp_Object *args))
{
- int j = 0;
- Lisp_Object size = Qnil;
- Lisp_Object type = Qnil;
+ int i = 0;
Lisp_Object test = Qnil;
+ Lisp_Object size = Qnil;
Lisp_Object rehash_size = Qnil;
Lisp_Object rehash_threshold = Qnil;
+ Lisp_Object weakness = Qnil;
- while (j < nargs)
+ while (i + 1 < nargs)
{
- Lisp_Object keyword, value;
-
- keyword = args[j++];
- if (!KEYWORDP (keyword))
- signal_simple_error ("Invalid hash table property keyword", keyword);
- if (j == nargs)
- signal_simple_error ("Hash table property requires a value", keyword);
-
- value = args[j++];
+ Lisp_Object keyword = args[i++];
+ Lisp_Object value = args[i++];
- if (EQ (keyword, Q_size)) size = value;
- else if (EQ (keyword, Q_type)) type = value;
- else if (EQ (keyword, Q_test)) test = value;
+ if (EQ (keyword, Q_test)) test = value;
+ else if (EQ (keyword, Q_size)) size = value;
else if (EQ (keyword, Q_rehash_size)) rehash_size = value;
else if (EQ (keyword, Q_rehash_threshold)) rehash_threshold = value;
+ else if (EQ (keyword, Q_weakness)) weakness = value;
+ else if (EQ (keyword, Q_type))/*obsolete*/ weakness = value;
else signal_simple_error ("Invalid hash table property keyword", keyword);
}
+ if (i < nargs)
+ signal_simple_error ("Hash table property requires a value", args[i]);
+
#define VALIDATE_VAR(var) \
if (!NILP (var)) hash_table_##var##_validate (Q##var, var, ERROR_ME);
- VALIDATE_VAR (size);
- VALIDATE_VAR (type);
VALIDATE_VAR (test);
+ VALIDATE_VAR (size);
VALIDATE_VAR (rehash_size);
VALIDATE_VAR (rehash_threshold);
+ VALIDATE_VAR (weakness);
return make_general_lisp_hash_table
- (decode_hash_table_size (size),
- decode_hash_table_type (type),
- decode_hash_table_test (test),
+ (decode_hash_table_test (test),
+ decode_hash_table_size (size),
decode_hash_table_rehash_size (rehash_size),
- decode_hash_table_rehash_threshold (rehash_threshold));
+ decode_hash_table_rehash_threshold (rehash_threshold),
+ decode_hash_table_weakness (weakness));
}
DEFUN ("copy-hash-table", Fcopy_hash_table, 1, 1, 0, /*
}
static void
-enlarge_hash_table (Lisp_Hash_Table *ht)
+resize_hash_table (Lisp_Hash_Table *ht, size_t new_size)
{
hentry *old_entries, *new_entries, *old_sentinel, *new_sentinel, *e;
- size_t old_size, new_size;
+ size_t old_size;
old_size = ht->size;
- new_size = ht->size =
- hash_table_size ((size_t) ((double) old_size * ht->rehash_size));
+ ht->size = new_size;
old_entries = ht->hentries;
*probe = *e;
}
- xfree (old_entries);
+ if (!DUMPEDP (old_entries))
+ xfree (old_entries);
+}
+
+void
+reorganize_hash_table (Lisp_Hash_Table *ht)
+{
+ resize_hash_table (ht, ht->size);
+}
+
+static void
+enlarge_hash_table (Lisp_Hash_Table *ht)
+{
+ size_t new_size =
+ hash_table_size ((size_t) ((double) ht->size * ht->rehash_size));
+ resize_hash_table (ht, new_size);
}
static hentry *
remhash_1 (Lisp_Hash_Table *ht, hentry *entries, hentry *probe)
{
size_t size = ht->size;
- CLEAR_HENTRY (probe++);
+ CLEAR_HENTRY (probe);
+ probe++;
ht->count--;
LINEAR_PROBING_LOOP (probe, entries, size)
return make_int (xhash_table (hash_table)->count);
}
-DEFUN ("hash-table-size", Fhash_table_size, 1, 1, 0, /*
-Return the size of HASH-TABLE.
-This is the current number of slots in HASH-TABLE, whether occupied or not.
-*/
- (hash_table))
-{
- return make_int (xhash_table (hash_table)->size);
-}
-
-DEFUN ("hash-table-type", Fhash_table_type, 1, 1, 0, /*
-Return the type of HASH-TABLE.
-This can be one of `non-weak', `weak', `key-weak' or `value-weak'.
-*/
- (hash_table))
-{
- switch (xhash_table (hash_table)->type)
- {
- case HASH_TABLE_WEAK: return Qweak;
- case HASH_TABLE_KEY_WEAK: return Qkey_weak;
- case HASH_TABLE_VALUE_WEAK: return Qvalue_weak;
- default: return Qnon_weak;
- }
-}
-
DEFUN ("hash-table-test", Fhash_table_test, 1, 1, 0, /*
Return the test function of HASH-TABLE.
This can be one of `eq', `eql' or `equal'.
Qeq);
}
+DEFUN ("hash-table-size", Fhash_table_size, 1, 1, 0, /*
+Return the size of HASH-TABLE.
+This is the current number of slots in HASH-TABLE, whether occupied or not.
+*/
+ (hash_table))
+{
+ return make_int (xhash_table (hash_table)->size);
+}
+
DEFUN ("hash-table-rehash-size", Fhash_table_rehash_size, 1, 1, 0, /*
Return the current rehash size of HASH-TABLE.
This is a float greater than 1.0; the factor by which HASH-TABLE
return make_float (hash_table_rehash_threshold (xhash_table (hash_table)));
}
+DEFUN ("hash-table-weakness", Fhash_table_weakness, 1, 1, 0, /*
+Return the weakness of HASH-TABLE.
+This can be one of `nil', `t', `key' or `value'.
+*/
+ (hash_table))
+{
+ switch (xhash_table (hash_table)->weakness)
+ {
+ case HASH_TABLE_WEAK: return Qt;
+ case HASH_TABLE_KEY_WEAK: return Qkey;
+ case HASH_TABLE_VALUE_WEAK: return Qvalue;
+ default: return Qnil;
+ }
+}
+
+/* obsolete as of 19990901 in xemacs-21.2 */
+DEFUN ("hash-table-type", Fhash_table_type, 1, 1, 0, /*
+Return the type of HASH-TABLE.
+This can be one of `non-weak', `weak', `key-weak' or `value-weak'.
+*/
+ (hash_table))
+{
+ switch (xhash_table (hash_table)->weakness)
+ {
+ case HASH_TABLE_WEAK: return Qweak;
+ case HASH_TABLE_KEY_WEAK: return Qkey_weak;
+ case HASH_TABLE_VALUE_WEAK: return Qvalue_weak;
+ default: return Qnon_weak;
+ }
+}
+
/************************************************************************/
/* Mapping Functions */
/************************************************************************/
/* Complete the marking for semi-weak hash tables. */
int
-finish_marking_weak_hash_tables (int (*obj_marked_p) (Lisp_Object),
- void (*markobj) (Lisp_Object))
+finish_marking_weak_hash_tables (void)
{
Lisp_Object hash_table;
int did_mark = 0;
for (hash_table = Vall_weak_hash_tables;
- !GC_NILP (hash_table);
+ !NILP (hash_table);
hash_table = XHASH_TABLE (hash_table)->next_weak)
{
CONST Lisp_Hash_Table *ht = XHASH_TABLE (hash_table);
CONST hentry *e = ht->hentries;
CONST hentry *sentinel = e + ht->size;
- if (! obj_marked_p (hash_table))
+ if (! marked_p (hash_table))
/* The hash table is probably garbage. Ignore it. */
continue;
half-marked, we may need to mark the other half if we're
keeping this pair. */
#define MARK_OBJ(obj) \
-do { if (!obj_marked_p (obj)) markobj (obj), did_mark = 1; } while (0)
+do { if (!marked_p (obj)) mark_object (obj), did_mark = 1; } while (0)
- switch (ht->type)
+ switch (ht->weakness)
{
case HASH_TABLE_KEY_WEAK:
for (; e < sentinel; e++)
if (!HENTRY_CLEAR_P (e))
- if (obj_marked_p (e->key))
+ if (marked_p (e->key))
MARK_OBJ (e->value);
break;
case HASH_TABLE_VALUE_WEAK:
for (; e < sentinel; e++)
if (!HENTRY_CLEAR_P (e))
- if (obj_marked_p (e->value))
+ if (marked_p (e->value))
MARK_OBJ (e->key);
break;
case HASH_TABLE_KEY_CAR_WEAK:
for (; e < sentinel; e++)
if (!HENTRY_CLEAR_P (e))
- if (!CONSP (e->key) || obj_marked_p (XCAR (e->key)))
+ if (!CONSP (e->key) || marked_p (XCAR (e->key)))
{
MARK_OBJ (e->key);
MARK_OBJ (e->value);
case HASH_TABLE_VALUE_CAR_WEAK:
for (; e < sentinel; e++)
if (!HENTRY_CLEAR_P (e))
- if (!CONSP (e->value) || obj_marked_p (XCAR (e->value)))
+ if (!CONSP (e->value) || marked_p (XCAR (e->value)))
{
MARK_OBJ (e->key);
MARK_OBJ (e->value);
}
void
-prune_weak_hash_tables (int (*obj_marked_p) (Lisp_Object))
+prune_weak_hash_tables (void)
{
Lisp_Object hash_table, prev = Qnil;
for (hash_table = Vall_weak_hash_tables;
- !GC_NILP (hash_table);
+ !NILP (hash_table);
hash_table = XHASH_TABLE (hash_table)->next_weak)
{
- if (! obj_marked_p (hash_table))
+ if (! marked_p (hash_table))
{
/* This hash table itself is garbage. Remove it from the list. */
- if (GC_NILP (prev))
+ if (NILP (prev))
Vall_weak_hash_tables = XHASH_TABLE (hash_table)->next_weak;
else
XHASH_TABLE (prev)->next_weak = XHASH_TABLE (hash_table)->next_weak;
{
/* Now, scan over all the pairs. Remove all of the pairs
in which the key or value, or both, is unmarked
- (depending on the type of weak hash table). */
+ (depending on the weakness of the hash table). */
Lisp_Hash_Table *ht = XHASH_TABLE (hash_table);
hentry *entries = ht->hentries;
hentry *sentinel = entries + ht->size;
if (!HENTRY_CLEAR_P (e))
{
again:
- if (!obj_marked_p (e->key) || !obj_marked_p (e->value))
+ if (!marked_p (e->key) || !marked_p (e->value))
{
remhash_1 (ht, entries, e);
if (!HENTRY_CLEAR_P (e))
return LISP_HASH (obj);
}
+DEFUN ("sxhash", Fsxhash, 1, 1, 0, /*
+Return a hash value for OBJECT.
+(equal obj1 obj2) implies (= (sxhash obj1) (sxhash obj2)).
+*/
+ (object))
+{
+ return make_int (internal_hash (object, 0));
+}
+
#if 0
xxDEFUN ("internal-hash-value", Finternal_hash_value, 1, 1, 0, /*
Hash value of OBJECT. For debugging.
DEFSUBR (Fclrhash);
DEFSUBR (Fmaphash);
DEFSUBR (Fhash_table_count);
+ DEFSUBR (Fhash_table_test);
DEFSUBR (Fhash_table_size);
DEFSUBR (Fhash_table_rehash_size);
DEFSUBR (Fhash_table_rehash_threshold);
- DEFSUBR (Fhash_table_type);
- DEFSUBR (Fhash_table_test);
+ DEFSUBR (Fhash_table_weakness);
+ DEFSUBR (Fhash_table_type); /* obsolete */
+ DEFSUBR (Fsxhash);
#if 0
DEFSUBR (Finternal_hash_value);
#endif
defsymbol (&Qhash_tablep, "hash-table-p");
defsymbol (&Qhash_table, "hash-table");
defsymbol (&Qhashtable, "hashtable");
- defsymbol (&Qweak, "weak");
- defsymbol (&Qkey_weak, "key-weak");
- defsymbol (&Qvalue_weak, "value-weak");
- defsymbol (&Qnon_weak, "non-weak");
+ defsymbol (&Qweakness, "weakness");
+ defsymbol (&Qvalue, "value");
defsymbol (&Qrehash_size, "rehash-size");
defsymbol (&Qrehash_threshold, "rehash-threshold");
- defkeyword (&Q_size, ":size");
+ defsymbol (&Qweak, "weak"); /* obsolete */
+ defsymbol (&Qkey_weak, "key-weak"); /* obsolete */
+ defsymbol (&Qvalue_weak, "value-weak"); /* obsolete */
+ defsymbol (&Qnon_weak, "non-weak"); /* obsolete */
+
defkeyword (&Q_test, ":test");
- defkeyword (&Q_type, ":type");
+ defkeyword (&Q_size, ":size");
defkeyword (&Q_rehash_size, ":rehash-size");
defkeyword (&Q_rehash_threshold, ":rehash-threshold");
+ defkeyword (&Q_weakness, ":weakness");
+ defkeyword (&Q_type, ":type"); /* obsolete */
}
void
{
/* This must NOT be staticpro'd */
Vall_weak_hash_tables = Qnil;
+ pdump_wire_list (&Vall_weak_hash_tables);
}
projects / chise / xemacs-chise.git.1 / blobdiff