+2011-05-31 Paul Eggert <eggert@cs.ucla.edu>
+
+ Remove arbitrary limit of 2**31 entries in hash tables.
+ * category.c (hash_get_category_set): Use 'EMACS_UINT' and 'EMACS_INT'
+ for hashes and hash indexes, instead of 'unsigned' and 'int'.
+ * ccl.c (ccl_driver): Likewise.
+ * charset.c (Fdefine_charset_internal): Likewise.
+ * charset.h (struct charset.hash_index): Likewise.
+ * composite.c (get_composition_id, gstring_lookup_cache):
+ (composition_gstring_put_cache): Likewise.
+ * composite.h (struct composition.hash_index): Likewise.
+ * dispextern.h (struct image.hash): Likewise.
+ * fns.c (next_almost_prime, larger_vector, cmpfn_eql):
+ (cmpfn_equal, cmpfn_user_defined, hashfn_eq, hashfn_eql):
+ (hashfn_equal, hashfn_user_defined, make_hash_table):
+ (maybe_resize_hash_table, hash_lookup, hash_put):
+ (hash_remove_from_table, hash_clear, sweep_weak_table, SXHASH_COMBINE):
+ (sxhash_string, sxhash_list, sxhash_vector, sxhash_bool_vector):
+ (Fsxhash, Fgethash, Fputhash, Fmaphash): Likewise.
+ * image.c (make_image, search_image_cache, lookup_image):
+ (xpm_put_color_table_h): Likewise.
+ * lisp.h (struct Lisp_Hash_Table): Likewise, for 'count', 'cmpfn',
+ and 'hashfn' members.
+ * minibuf.c (Ftry_completion, Fall_completions, Ftest_completion):
+ Likewise.
+ * print.c (print): Likewise.
+ * alloc.c (allocate_vectorlike): Check for overflow in vector size
+ calculations.
+ * ccl.c (ccl_driver): Check for overflow when converting EMACS_INT
+ to int.
+ * fns.c, image.c: Remove unnecessary static decls that would otherwise
+ need to be updated by these changes.
+ * fns.c (make_hash_table, maybe_resize_hash_table): Check for integer
+ overflow with large hash tables.
+ (make_hash_table, maybe_resize_hash_table, Fmake_hash_table):
+ Prefer the faster XFLOAT_DATA to XFLOATINT where either will do.
+ (SXHASH_REDUCE): New macro.
+ (sxhash_string, sxhash_list, sxhash_vector, sxhash_bool_vector):
+ Use it instead of discarding useful hash info with large hash values.
+ (sxhash_float): New function.
+ (sxhash): Use it. No more need for "& INTMASK" due to above changes.
+ * lisp.h (FIXNUM_BITS): New macro, useful for SXHASH_REDUCE etc.
+ (MOST_NEGATIVE_FIXNUM, MOST_POSITIVE_FIXNUM, INTMASK): Rewrite
+ to use FIXNUM_BITS, as this simplifies things.
+ (next_almost_prime, larger_vector, sxhash, hash_lookup, hash_put):
+ Adjust signatures to match updated version of code.
+ (consing_since_gc): Now EMACS_INT, since a single hash table can
+ use more than INT_MAX bytes.
+
2011-05-31 Paul Eggert <eggert@cs.ucla.edu>
Use 'inline', not 'INLINE'.
static struct Lisp_Hash_Table *check_hash_table (Lisp_Object);
static size_t get_key_arg (Lisp_Object, size_t, Lisp_Object *, char *);
static void maybe_resize_hash_table (struct Lisp_Hash_Table *);
-static int cmpfn_eql (struct Lisp_Hash_Table *, Lisp_Object, unsigned,
- Lisp_Object, unsigned);
-static int cmpfn_equal (struct Lisp_Hash_Table *, Lisp_Object, unsigned,
- Lisp_Object, unsigned);
-static int cmpfn_user_defined (struct Lisp_Hash_Table *, Lisp_Object,
- unsigned, Lisp_Object, unsigned);
-static unsigned hashfn_eq (struct Lisp_Hash_Table *, Lisp_Object);
-static unsigned hashfn_eql (struct Lisp_Hash_Table *, Lisp_Object);
-static unsigned hashfn_equal (struct Lisp_Hash_Table *, Lisp_Object);
-static unsigned hashfn_user_defined (struct Lisp_Hash_Table *,
- Lisp_Object);
-static unsigned sxhash_string (unsigned char *, int);
-static unsigned sxhash_list (Lisp_Object, int);
-static unsigned sxhash_vector (Lisp_Object, int);
-static unsigned sxhash_bool_vector (Lisp_Object);
static int sweep_weak_table (struct Lisp_Hash_Table *, int);
/* Value is the next integer I >= N, N >= 0 which is "almost" a prime
number. */
-int
-next_almost_prime (int n)
+EMACS_INT
+next_almost_prime (EMACS_INT n)
{
if (n % 2 == 0)
n += 1;
vector that are not copied from VEC are set to INIT. */
Lisp_Object
-larger_vector (Lisp_Object vec, int new_size, Lisp_Object init)
+larger_vector (Lisp_Object vec, EMACS_INT new_size, Lisp_Object init)
{
struct Lisp_Vector *v;
- int i, old_size;
+ EMACS_INT i, old_size;
xassert (VECTORP (vec));
old_size = ASIZE (vec);
KEY2 are the same. */
static int
-cmpfn_eql (struct Lisp_Hash_Table *h, Lisp_Object key1, unsigned int hash1, Lisp_Object key2, unsigned int hash2)
+cmpfn_eql (struct Lisp_Hash_Table *h,
+ Lisp_Object key1, EMACS_UINT hash1,
+ Lisp_Object key2, EMACS_UINT hash2)
{
return (FLOATP (key1)
&& FLOATP (key2)
KEY2 are the same. */
static int
-cmpfn_equal (struct Lisp_Hash_Table *h, Lisp_Object key1, unsigned int hash1, Lisp_Object key2, unsigned int hash2)
+cmpfn_equal (struct Lisp_Hash_Table *h,
+ Lisp_Object key1, EMACS_UINT hash1,
+ Lisp_Object key2, EMACS_UINT hash2)
{
return hash1 == hash2 && !NILP (Fequal (key1, key2));
}
if KEY1 and KEY2 are the same. */
static int
-cmpfn_user_defined (struct Lisp_Hash_Table *h, Lisp_Object key1, unsigned int hash1, Lisp_Object key2, unsigned int hash2)
+cmpfn_user_defined (struct Lisp_Hash_Table *h,
+ Lisp_Object key1, EMACS_UINT hash1,
+ Lisp_Object key2, EMACS_UINT hash2)
{
if (hash1 == hash2)
{
`eq' to compare keys. The hash code returned is guaranteed to fit
in a Lisp integer. */
-static unsigned
+static EMACS_UINT
hashfn_eq (struct Lisp_Hash_Table *h, Lisp_Object key)
{
- unsigned hash = XUINT (key) ^ XTYPE (key);
+ EMACS_UINT hash = XUINT (key) ^ XTYPE (key);
xassert ((hash & ~INTMASK) == 0);
return hash;
}
`eql' to compare keys. The hash code returned is guaranteed to fit
in a Lisp integer. */
-static unsigned
+static EMACS_UINT
hashfn_eql (struct Lisp_Hash_Table *h, Lisp_Object key)
{
- unsigned hash;
+ EMACS_UINT hash;
if (FLOATP (key))
hash = sxhash (key, 0);
else
`equal' to compare keys. The hash code returned is guaranteed to fit
in a Lisp integer. */
-static unsigned
+static EMACS_UINT
hashfn_equal (struct Lisp_Hash_Table *h, Lisp_Object key)
{
- unsigned hash = sxhash (key, 0);
+ EMACS_UINT hash = sxhash (key, 0);
xassert ((hash & ~INTMASK) == 0);
return hash;
}
user-defined function to compare keys. The hash code returned is
guaranteed to fit in a Lisp integer. */
-static unsigned
+static EMACS_UINT
hashfn_user_defined (struct Lisp_Hash_Table *h, Lisp_Object key)
{
Lisp_Object args[2], hash;
{
struct Lisp_Hash_Table *h;
Lisp_Object table;
- int index_size, i, sz;
+ EMACS_INT index_size, i, sz;
+ double index_float;
/* Preconditions. */
xassert (SYMBOLP (test));
xassert (INTEGERP (size) && XINT (size) >= 0);
xassert ((INTEGERP (rehash_size) && XINT (rehash_size) > 0)
- || (FLOATP (rehash_size) && XFLOATINT (rehash_size) > 1.0));
+ || (FLOATP (rehash_size) && 1 < XFLOAT_DATA (rehash_size)));
xassert (FLOATP (rehash_threshold)
- && XFLOATINT (rehash_threshold) > 0
- && XFLOATINT (rehash_threshold) <= 1.0);
+ && 0 < XFLOAT_DATA (rehash_threshold)
+ && XFLOAT_DATA (rehash_threshold) <= 1.0);
if (XFASTINT (size) == 0)
size = make_number (1);
+ sz = XFASTINT (size);
+ index_float = sz / XFLOAT_DATA (rehash_threshold);
+ index_size = (index_float < MOST_POSITIVE_FIXNUM + 1
+ ? next_almost_prime (index_float)
+ : MOST_POSITIVE_FIXNUM + 1);
+ if (MOST_POSITIVE_FIXNUM < max (index_size, 2 * sz))
+ error ("Hash table too large");
+
/* Allocate a table and initialize it. */
h = allocate_hash_table ();
/* Initialize hash table slots. */
- sz = XFASTINT (size);
-
h->test = test;
if (EQ (test, Qeql))
{
h->key_and_value = Fmake_vector (make_number (2 * sz), Qnil);
h->hash = Fmake_vector (size, Qnil);
h->next = Fmake_vector (size, Qnil);
- /* Cast to int here avoids losing with gcc 2.95 on Tru64/Alpha... */
- index_size = next_almost_prime ((int) (sz / XFLOATINT (rehash_threshold)));
h->index = Fmake_vector (make_number (index_size), Qnil);
/* Set up the free list. */
{
if (NILP (h->next_free))
{
- int old_size = HASH_TABLE_SIZE (h);
- int i, new_size, index_size;
+ EMACS_INT old_size = HASH_TABLE_SIZE (h);
+ EMACS_INT i, new_size, index_size;
EMACS_INT nsize;
+ double index_float;
if (INTEGERP (h->rehash_size))
new_size = old_size + XFASTINT (h->rehash_size);
else
- new_size = old_size * XFLOATINT (h->rehash_size);
- new_size = max (old_size + 1, new_size);
- index_size = next_almost_prime ((int)
- (new_size
- / XFLOATINT (h->rehash_threshold)));
- /* Assignment to EMACS_INT stops GCC whining about limited range
- of data type. */
+ {
+ double float_new_size = old_size * XFLOAT_DATA (h->rehash_size);
+ if (float_new_size < MOST_POSITIVE_FIXNUM + 1)
+ {
+ new_size = float_new_size;
+ if (new_size <= old_size)
+ new_size = old_size + 1;
+ }
+ else
+ new_size = MOST_POSITIVE_FIXNUM + 1;
+ }
+ index_float = new_size / XFLOAT_DATA (h->rehash_threshold);
+ index_size = (index_float < MOST_POSITIVE_FIXNUM + 1
+ ? next_almost_prime (index_float)
+ : MOST_POSITIVE_FIXNUM + 1);
nsize = max (index_size, 2 * new_size);
if (nsize > MOST_POSITIVE_FIXNUM)
error ("Hash table too large to resize");
for (i = 0; i < old_size; ++i)
if (!NILP (HASH_HASH (h, i)))
{
- unsigned hash_code = XUINT (HASH_HASH (h, i));
- int start_of_bucket = hash_code % ASIZE (h->index);
+ EMACS_UINT hash_code = XUINT (HASH_HASH (h, i));
+ EMACS_INT start_of_bucket = hash_code % ASIZE (h->index);
HASH_NEXT (h, i) = HASH_INDEX (h, start_of_bucket);
HASH_INDEX (h, start_of_bucket) = make_number (i);
}
the hash code of KEY. Value is the index of the entry in H
matching KEY, or -1 if not found. */
-int
-hash_lookup (struct Lisp_Hash_Table *h, Lisp_Object key, unsigned int *hash)
+EMACS_INT
+hash_lookup (struct Lisp_Hash_Table *h, Lisp_Object key, EMACS_UINT *hash)
{
- unsigned hash_code;
- int start_of_bucket;
+ EMACS_UINT hash_code;
+ EMACS_INT start_of_bucket;
Lisp_Object idx;
hash_code = h->hashfn (h, key);
/* We need not gcpro idx since it's either an integer or nil. */
while (!NILP (idx))
{
- int i = XFASTINT (idx);
+ EMACS_INT i = XFASTINT (idx);
if (EQ (key, HASH_KEY (h, i))
|| (h->cmpfn
&& h->cmpfn (h, key, hash_code,
HASH is a previously computed hash code of KEY.
Value is the index of the entry in H matching KEY. */
-int
-hash_put (struct Lisp_Hash_Table *h, Lisp_Object key, Lisp_Object value, unsigned int hash)
+EMACS_INT
+hash_put (struct Lisp_Hash_Table *h, Lisp_Object key, Lisp_Object value,
+ EMACS_UINT hash)
{
- int start_of_bucket, i;
+ EMACS_INT start_of_bucket, i;
xassert ((hash & ~INTMASK) == 0);
static void
hash_remove_from_table (struct Lisp_Hash_Table *h, Lisp_Object key)
{
- unsigned hash_code;
- int start_of_bucket;
+ EMACS_UINT hash_code;
+ EMACS_INT start_of_bucket;
Lisp_Object idx, prev;
hash_code = h->hashfn (h, key);
/* We need not gcpro idx, prev since they're either integers or nil. */
while (!NILP (idx))
{
- int i = XFASTINT (idx);
+ EMACS_INT i = XFASTINT (idx);
if (EQ (key, HASH_KEY (h, i))
|| (h->cmpfn
{
if (h->count > 0)
{
- int i, size = HASH_TABLE_SIZE (h);
+ EMACS_INT i, size = HASH_TABLE_SIZE (h);
for (i = 0; i < size; ++i)
{
static int
sweep_weak_table (struct Lisp_Hash_Table *h, int remove_entries_p)
{
- int bucket, n, marked;
+ EMACS_INT bucket, n;
+ int marked;
n = ASIZE (h->index) & ~ARRAY_MARK_FLAG;
marked = 0;
prev = Qnil;
for (idx = HASH_INDEX (h, bucket); !NILP (idx); idx = next)
{
- int i = XFASTINT (idx);
+ EMACS_INT i = XFASTINT (idx);
int key_known_to_survive_p = survives_gc_p (HASH_KEY (h, i));
int value_known_to_survive_p = survives_gc_p (HASH_VALUE (h, i));
int remove_p;
#define SXHASH_MAX_LEN 7
-/* Combine two integers X and Y for hashing. */
+/* Combine two integers X and Y for hashing. The result might not fit
+ into a Lisp integer. */
#define SXHASH_COMBINE(X, Y) \
- ((((unsigned)(X) << 4) + (((unsigned)(X) >> 24) & 0x0fffffff)) \
- + (unsigned)(Y))
+ ((((EMACS_UINT) (X) << 4) + ((EMACS_UINT) (X) >> (BITS_PER_EMACS_INT - 4))) \
+ + (EMACS_UINT) (Y))
+/* Hash X, returning a value that fits into a Lisp integer. */
+#define SXHASH_REDUCE(X) \
+ ((((X) ^ (X) >> (BITS_PER_EMACS_INT - FIXNUM_BITS))) & INTMASK)
/* Return a hash for string PTR which has length LEN. The hash
code returned is guaranteed to fit in a Lisp integer. */
-static unsigned
-sxhash_string (unsigned char *ptr, int len)
+static EMACS_UINT
+sxhash_string (unsigned char *ptr, EMACS_INT len)
{
unsigned char *p = ptr;
unsigned char *end = p + len;
unsigned char c;
- unsigned hash = 0;
+ EMACS_UINT hash = 0;
while (p != end)
{
c = *p++;
if (c >= 0140)
c -= 40;
- hash = ((hash << 4) + (hash >> 28) + c);
+ hash = SXHASH_COMBINE (hash, c);
}
- return hash & INTMASK;
+ return SXHASH_REDUCE (hash);
}
+/* Return a hash for the floating point value VAL. */
+
+static EMACS_INT
+sxhash_float (double val)
+{
+ EMACS_UINT hash = 0;
+ enum {
+ WORDS_PER_DOUBLE = (sizeof val / sizeof hash
+ + (sizeof val % sizeof hash != 0))
+ };
+ union {
+ double val;
+ EMACS_UINT word[WORDS_PER_DOUBLE];
+ } u;
+ int i;
+ u.val = val;
+ memset (&u.val + 1, 0, sizeof u - sizeof u.val);
+ for (i = 0; i < WORDS_PER_DOUBLE; i++)
+ hash = SXHASH_COMBINE (hash, u.word[i]);
+ return SXHASH_REDUCE (hash);
+}
/* Return a hash for list LIST. DEPTH is the current depth in the
list. We don't recurse deeper than SXHASH_MAX_DEPTH in it. */
-static unsigned
+static EMACS_UINT
sxhash_list (Lisp_Object list, int depth)
{
- unsigned hash = 0;
+ EMACS_UINT hash = 0;
int i;
if (depth < SXHASH_MAX_DEPTH)
CONSP (list) && i < SXHASH_MAX_LEN;
list = XCDR (list), ++i)
{
- unsigned hash2 = sxhash (XCAR (list), depth + 1);
+ EMACS_UINT hash2 = sxhash (XCAR (list), depth + 1);
hash = SXHASH_COMBINE (hash, hash2);
}
if (!NILP (list))
{
- unsigned hash2 = sxhash (list, depth + 1);
+ EMACS_UINT hash2 = sxhash (list, depth + 1);
hash = SXHASH_COMBINE (hash, hash2);
}
- return hash;
+ return SXHASH_REDUCE (hash);
}
/* Return a hash for vector VECTOR. DEPTH is the current depth in
the Lisp structure. */
-static unsigned
+static EMACS_UINT
sxhash_vector (Lisp_Object vec, int depth)
{
- unsigned hash = ASIZE (vec);
+ EMACS_UINT hash = ASIZE (vec);
int i, n;
n = min (SXHASH_MAX_LEN, ASIZE (vec));
for (i = 0; i < n; ++i)
{
- unsigned hash2 = sxhash (AREF (vec, i), depth + 1);
+ EMACS_UINT hash2 = sxhash (AREF (vec, i), depth + 1);
hash = SXHASH_COMBINE (hash, hash2);
}
- return hash;
+ return SXHASH_REDUCE (hash);
}
-
/* Return a hash for bool-vector VECTOR. */
-static unsigned
+static EMACS_UINT
sxhash_bool_vector (Lisp_Object vec)
{
- unsigned hash = XBOOL_VECTOR (vec)->size;
+ EMACS_UINT hash = XBOOL_VECTOR (vec)->size;
int i, n;
n = min (SXHASH_MAX_LEN, XBOOL_VECTOR (vec)->header.size);
for (i = 0; i < n; ++i)
hash = SXHASH_COMBINE (hash, XBOOL_VECTOR (vec)->data[i]);
- return hash;
+ return SXHASH_REDUCE (hash);
}
/* Return a hash code for OBJ. DEPTH is the current depth in the Lisp
structure. Value is an unsigned integer clipped to INTMASK. */
-unsigned
+EMACS_UINT
sxhash (Lisp_Object obj, int depth)
{
- unsigned hash;
+ EMACS_UINT hash;
if (depth > SXHASH_MAX_DEPTH)
return 0;
break;
case Lisp_Float:
- {
- double val = XFLOAT_DATA (obj);
- unsigned char *p = (unsigned char *) &val;
- size_t i;
- for (hash = 0, i = 0; i < sizeof val; i++)
- hash = SXHASH_COMBINE (hash, p[i]);
- break;
- }
+ hash = sxhash_float (XFLOAT_DATA (obj));
+ break;
default:
abort ();
}
- return hash & INTMASK;
+ return hash;
}
doc: /* Compute a hash code for OBJ and return it as integer. */)
(Lisp_Object obj)
{
- unsigned hash = sxhash (obj, 0);
+ EMACS_UINT hash = sxhash (obj, 0);
return make_number (hash);
}
/* Look for `:rehash-size SIZE'. */
i = get_key_arg (QCrehash_size, nargs, args, used);
rehash_size = i ? args[i] : make_float (DEFAULT_REHASH_SIZE);
- if (!NUMBERP (rehash_size)
- || (INTEGERP (rehash_size) && XINT (rehash_size) <= 0)
- || XFLOATINT (rehash_size) <= 1.0)
+ if (! ((INTEGERP (rehash_size) && 0 < XINT (rehash_size))
+ || (FLOATP (rehash_size) && 1 < XFLOAT_DATA (rehash_size))))
signal_error ("Invalid hash table rehash size", rehash_size);
/* Look for `:rehash-threshold THRESHOLD'. */
i = get_key_arg (QCrehash_threshold, nargs, args, used);
rehash_threshold = i ? args[i] : make_float (DEFAULT_REHASH_THRESHOLD);
- if (!FLOATP (rehash_threshold)
- || XFLOATINT (rehash_threshold) <= 0.0
- || XFLOATINT (rehash_threshold) > 1.0)
+ if (! (FLOATP (rehash_threshold)
+ && 0 < XFLOAT_DATA (rehash_threshold)
+ && XFLOAT_DATA (rehash_threshold) <= 1))
signal_error ("Invalid hash table rehash threshold", rehash_threshold);
/* Look for `:weakness WEAK'. */
(Lisp_Object key, Lisp_Object table, Lisp_Object dflt)
{
struct Lisp_Hash_Table *h = check_hash_table (table);
- int i = hash_lookup (h, key, NULL);
+ EMACS_INT i = hash_lookup (h, key, NULL);
return i >= 0 ? HASH_VALUE (h, i) : dflt;
}
(Lisp_Object key, Lisp_Object value, Lisp_Object table)
{
struct Lisp_Hash_Table *h = check_hash_table (table);
- int i;
- unsigned hash;
+ EMACS_INT i;
+ EMACS_UINT hash;
i = hash_lookup (h, key, &hash);
if (i >= 0)
{
struct Lisp_Hash_Table *h = check_hash_table (table);
Lisp_Object args[3];
- int i;
+ EMACS_INT i;
for (i = 0; i < HASH_TABLE_SIZE (h); ++i)
if (!NILP (HASH_HASH (h, i)))
#define EQ(x, y) (XHASH (x) == XHASH (y))
-/* Largest and smallest representable fixnum values. These are the C
- values. */
-
+/* Number of bits in a fixnum, including the sign bit. */
#ifdef USE_2_TAGS_FOR_INTS
-# define MOST_NEGATIVE_FIXNUM - ((EMACS_INT) 1 << VALBITS)
-# define MOST_POSITIVE_FIXNUM (((EMACS_INT) 1 << VALBITS) - 1)
-/* Mask indicating the significant bits of a Lisp_Int.
- I.e. (x & INTMASK) == XUINT (make_number (x)). */
-# define INTMASK ((((EMACS_INT) 1) << (VALBITS + 1)) - 1)
+# define FIXNUM_BITS (VALBITS + 1)
#else
-# define MOST_NEGATIVE_FIXNUM - ((EMACS_INT) 1 << (VALBITS - 1))
-# define MOST_POSITIVE_FIXNUM (((EMACS_INT) 1 << (VALBITS - 1)) - 1)
-/* Mask indicating the significant bits of a Lisp_Int.
- I.e. (x & INTMASK) == XUINT (make_number (x)). */
-# define INTMASK ((((EMACS_INT) 1) << VALBITS) - 1)
+# define FIXNUM_BITS VALBITS
#endif
+/* Mask indicating the significant bits of a fixnum. */
+#define INTMASK (((EMACS_INT) 1 << FIXNUM_BITS) - 1)
+
+/* Largest and smallest representable fixnum values. These are the C
+ values. */
+#define MOST_POSITIVE_FIXNUM (INTMASK / 2)
+#define MOST_NEGATIVE_FIXNUM (-1 - MOST_POSITIVE_FIXNUM)
+
/* Value is non-zero if I doesn't fit into a Lisp fixnum. It is
written this way so that it also works if I is of unsigned
type or if I is a NaN. */
a special way (e.g. because of weakness). */
/* Number of key/value entries in the table. */
- unsigned int count;
+ EMACS_INT count;
/* 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.
struct Lisp_Hash_Table *next_weak;
/* C function to compare two keys. */
- int (* cmpfn) (struct Lisp_Hash_Table *, Lisp_Object,
- unsigned, Lisp_Object, unsigned);
+ int (*cmpfn) (struct Lisp_Hash_Table *,
+ Lisp_Object, EMACS_UINT,
+ Lisp_Object, EMACS_UINT);
/* C function to compute hash code. */
- unsigned (* hashfn) (struct Lisp_Hash_Table *, Lisp_Object);
+ EMACS_UINT (*hashfn) (struct Lisp_Hash_Table *, Lisp_Object);
};
\f
/* Number of bytes of structure consed since last GC. */
-extern int consing_since_gc;
+extern EMACS_INT consing_since_gc;
extern EMACS_INT gc_relative_threshold;
/* Defined in fns.c */
extern Lisp_Object QCrehash_size, QCrehash_threshold;
-extern int next_almost_prime (int);
-extern Lisp_Object larger_vector (Lisp_Object, int, Lisp_Object);
+extern EMACS_INT next_almost_prime (EMACS_INT);
+extern Lisp_Object larger_vector (Lisp_Object, EMACS_INT, Lisp_Object);
extern void sweep_weak_hash_tables (void);
extern Lisp_Object Qcursor_in_echo_area;
extern Lisp_Object Qstring_lessp;
extern Lisp_Object QCsize, QCtest, QCweakness, Qequal, Qeq, Qeql;
-unsigned sxhash (Lisp_Object, int);
+EMACS_UINT sxhash (Lisp_Object, int);
Lisp_Object make_hash_table (Lisp_Object, Lisp_Object, Lisp_Object,
Lisp_Object, Lisp_Object, Lisp_Object,
Lisp_Object);
-int hash_lookup (struct Lisp_Hash_Table *, Lisp_Object, unsigned *);
-int hash_put (struct Lisp_Hash_Table *, Lisp_Object, Lisp_Object,
- unsigned);
+EMACS_INT hash_lookup (struct Lisp_Hash_Table *, Lisp_Object, EMACS_UINT *);
+EMACS_INT hash_put (struct Lisp_Hash_Table *, Lisp_Object, Lisp_Object,
+ EMACS_UINT);
void init_weak_hash_tables (void);
extern void init_fns (void);
EXFUN (Fmake_hash_table, MANY);
projects / emacs.git / commitdiff