*NULL* on failure.
-.. c:function:: long PyObject_Hash(PyObject *o)
+.. c:function:: Py_hash_t PyObject_Hash(PyObject *o)
.. index:: builtin: hash
Compute and return the hash value of an object *o*. On failure, return ``-1``.
This is the equivalent of the Python expression ``hash(o)``.
+ .. versionchanged:: 3.2
-.. c:function:: long PyObject_HashNotImplemented(PyObject *o)
+ The return type is now Py_hash_t. This is a signed integer the same size
+ as Py_ssize_t.
+
+
+.. c:function:: Py_hash_t PyObject_HashNotImplemented(PyObject *o)
Set a :exc:`TypeError` indicating that ``type(o)`` is not hashable and return ``-1``.
This function receives special treatment when stored in a ``tp_hash`` slot,
An optional pointer to a function that implements the built-in function
:func:`hash`.
- The signature is the same as for :c:func:`PyObject_Hash`; it must return a C
- long. The value ``-1`` should not be returned as a normal return value; when an
- error occurs during the computation of the hash value, the function should set
- an exception and return ``-1``.
+ The signature is the same as for :c:func:`PyObject_Hash`; it must return a
+ value of the type Py_hash_t. The value ``-1`` should not be returned as a
+ normal return value; when an error occurs during the computation of the hash
+ value, the function should set an exception and return ``-1``.
This field can be set explicitly to :c:func:`PyObject_HashNotImplemented` to
block inheritance of the hash method from a parent type. This is interpreted
typedef struct {
PyObject_VAR_HEAD
- long ob_shash;
+ Py_hash_t ob_shash;
char ob_sval[1];
/* Invariants:
typedef struct
{
PyObject_HEAD
- long hashcode; /* -1 when unknown */
+ Py_hash_t hashcode; /* -1 when unknown */
int days; /* -MAX_DELTA_DAYS <= days <= MAX_DELTA_DAYS */
int seconds; /* 0 <= seconds < 24*3600 is invariant */
int microseconds; /* 0 <= microseconds < 1000000 is invariant */
*/
#define _PyTZINFO_HEAD \
PyObject_HEAD \
- long hashcode; \
+ Py_hash_t hashcode; \
char hastzinfo; /* boolean flag */
/* No _PyDateTime_BaseTZInfo is allocated; it's just to have something
#define PyDict_MINSIZE 8
typedef struct {
- /* Cached hash code of me_key. Note that hash codes are C longs.
- * We have to use Py_ssize_t instead because dict_popitem() abuses
- * me_hash to hold a search finger.
- */
- Py_ssize_t me_hash;
+ /* Cached hash code of me_key. */
+ Py_hash_t me_hash;
PyObject *me_key;
PyObject *me_value;
} PyDictEntry;
* setitem calls.
*/
PyDictEntry *ma_table;
- PyDictEntry *(*ma_lookup)(PyDictObject *mp, PyObject *key, long hash);
+ PyDictEntry *(*ma_lookup)(PyDictObject *mp, PyObject *key, Py_hash_t hash);
PyDictEntry ma_smalltable[PyDict_MINSIZE];
};
PyAPI_FUNC(int) PyDict_Next(
PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value);
PyAPI_FUNC(int) _PyDict_Next(
- PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value, long *hash);
+ PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value, Py_hash_t *hash);
PyAPI_FUNC(PyObject *) PyDict_Keys(PyObject *mp);
PyAPI_FUNC(PyObject *) PyDict_Values(PyObject *mp);
PyAPI_FUNC(PyObject *) PyDict_Items(PyObject *mp);
PyAPI_FUNC(Py_ssize_t) PyDict_Size(PyObject *mp);
PyAPI_FUNC(PyObject *) PyDict_Copy(PyObject *mp);
PyAPI_FUNC(int) PyDict_Contains(PyObject *mp, PyObject *key);
-PyAPI_FUNC(int) _PyDict_Contains(PyObject *mp, PyObject *key, long hash);
+PyAPI_FUNC(int) _PyDict_Contains(PyObject *mp, PyObject *key, Py_hash_t hash);
PyAPI_FUNC(PyObject *) _PyDict_NewPresized(Py_ssize_t minused);
PyAPI_FUNC(void) _PyDict_MaybeUntrack(PyObject *mp);
PyAPI_FUNC(int) _PyDict_HasOnlyStringKeys(PyObject *mp);
typedef int (*setattrfunc)(PyObject *, char *, PyObject *);
typedef int (*setattrofunc)(PyObject *, PyObject *, PyObject *);
typedef PyObject *(*reprfunc)(PyObject *);
-typedef long (*hashfunc)(PyObject *);
+typedef Py_hash_t (*hashfunc)(PyObject *);
typedef PyObject *(*richcmpfunc) (PyObject *, PyObject *, int);
typedef PyObject *(*getiterfunc) (PyObject *);
typedef PyObject *(*iternextfunc) (PyObject *);
PyAPI_FUNC(PyObject *) PyObject_GenericGetAttr(PyObject *, PyObject *);
PyAPI_FUNC(int) PyObject_GenericSetAttr(PyObject *,
PyObject *, PyObject *);
-PyAPI_FUNC(long) PyObject_Hash(PyObject *);
-PyAPI_FUNC(long) PyObject_HashNotImplemented(PyObject *);
+PyAPI_FUNC(Py_hash_t) PyObject_Hash(PyObject *);
+PyAPI_FUNC(Py_hash_t) PyObject_HashNotImplemented(PyObject *);
PyAPI_FUNC(int) PyObject_IsTrue(PyObject *);
PyAPI_FUNC(int) PyObject_Not(PyObject *);
PyAPI_FUNC(int) PyCallable_Check(PyObject *);
PyAPI_FUNC(void) Py_ReprLeave(PyObject *);
/* Helpers for hash functions */
-PyAPI_FUNC(long) _Py_HashDouble(double);
-PyAPI_FUNC(long) _Py_HashPointer(void*);
+PyAPI_FUNC(Py_hash_t) _Py_HashDouble(double);
+PyAPI_FUNC(Py_hash_t) _Py_HashPointer(void*);
/* Helper for passing objects to printf and the like */
#define PyObject_REPR(obj) _PyUnicode_AsString(PyObject_Repr(obj))
_PyHash_Double in Objects/object.c. Numeric hashes are based on
reduction modulo the prime 2**_PyHASH_BITS - 1. */
-#if SIZEOF_LONG >= 8
+#if SIZEOF_VOID_P >= 8
#define _PyHASH_BITS 61
#else
#define _PyHASH_BITS 31
# error "Python needs a typedef for Py_ssize_t in pyport.h."
#endif
+/* Py_hash_t is the same size as a pointer. */
+typedef Py_ssize_t Py_hash_t;
+
/* Largest possible value of size_t.
SIZE_MAX is part of C99, so it might be defined on some
platforms. If it is not defined, (size_t)-1 is a portable
#define PySet_MINSIZE 8
typedef struct {
- /* Cached hash code of the key. Note that hash codes are C longs.
- * We have to use Py_ssize_t instead because set_pop() abuses
- * the hash field to hold a search finger.
- */
- Py_ssize_t hash;
+ /* Cached hash code of the key. */
+ Py_hash_t hash;
PyObject *key;
} setentry;
* saves repeated runtime null-tests.
*/
setentry *table;
- setentry *(*lookup)(PySetObject *so, PyObject *key, long hash);
+ setentry *(*lookup)(PySetObject *so, PyObject *key, Py_hash_t hash);
setentry smalltable[PySet_MINSIZE];
- long hash; /* only used by frozenset objects */
+ Py_hash_t hash; /* only used by frozenset objects */
PyObject *weakreflist; /* List of weak references */
};
PyAPI_FUNC(int) PySet_Contains(PyObject *anyset, PyObject *key);
PyAPI_FUNC(int) PySet_Discard(PyObject *set, PyObject *key);
PyAPI_FUNC(int) PySet_Add(PyObject *set, PyObject *key);
-PyAPI_FUNC(int) _PySet_NextEntry(PyObject *set, Py_ssize_t *pos, PyObject **key, long *hash);
+PyAPI_FUNC(int) _PySet_NextEntry(PyObject *set, Py_ssize_t *pos, PyObject **key, Py_hash_t *hash);
PyAPI_FUNC(PyObject *) PySet_Pop(PyObject *set);
PyAPI_FUNC(int) _PySet_Update(PyObject *set, PyObject *iterable);
PyObject_HEAD
Py_ssize_t length; /* Length of raw Unicode data in buffer */
Py_UNICODE *str; /* Raw Unicode buffer */
- long hash; /* Hash value; -1 if not set */
+ Py_hash_t hash; /* Hash value; -1 if not set */
int state; /* != 0 if interned. In this case the two
* references from the dictionary to this object
* are *not* counted in ob_refcnt. */
/* A cache for wr_object's hash code. As usual for hashes, this is -1
* if the hash code isn't known yet.
*/
- long hash;
+ Py_hash_t hash;
/* If wr_object is weakly referenced, wr_object has a doubly-linked NULL-
* terminated list of weak references to it. These are the list pointers.
- The Unicode database was updated to 6.0.0.
+C-API
+-----
+
+- Issue #9778: Hash values are now always the size of pointers. A new Py_hash_t
+ type has been introduced.
+
Tools/Demos
-----------
static PyObject *delta_getstate(PyDateTime_Delta *self);
-static long
+static Py_hash_t
delta_hash(PyDateTime_Delta *self)
{
if (self->hashcode == -1) {
/*
Borrowed from stringobject.c, originally it was string_hash()
*/
-static long
+static Py_hash_t
generic_hash(unsigned char *data, int len)
{
register unsigned char *p;
- register long x;
+ register Py_hash_t x;
p = (unsigned char *) data;
x = *p << 7;
static PyObject *date_getstate(PyDateTime_Date *self);
-static long
+static Py_hash_t
date_hash(PyDateTime_Date *self)
{
if (self->hashcode == -1)
return delta_richcompare(self->offset, other->offset, op);
}
-static long
+static Py_hash_t
timezone_hash(PyDateTime_TimeZone *self)
{
return delta_hash((PyDateTime_Delta *)self->offset);
return result;
}
-static long
+static Py_hash_t
time_hash(PyDateTime_Time *self)
{
if (self->hashcode == -1) {
return result;
}
-static long
+static Py_hash_t
datetime_hash(PyDateTime_DateTime *self)
{
if (self->hashcode == -1) {
size_t mask = (size_t)self->mt_mask;
PyMemoEntry *table = self->mt_table;
PyMemoEntry *entry;
- long hash = (long)key >> 3;
+ Py_hash_t hash = (Py_hash_t)key >> 3;
i = hash & mask;
entry = &table[i];
return result;
}
-static long
+static Py_hash_t
bytes_hash(PyBytesObject *a)
{
register Py_ssize_t len;
register unsigned char *p;
- register long x;
+ register Py_hash_t x;
if (a->ob_shash != -1)
return a->ob_shash;
return result;
}
-static long
+static Py_hash_t
method_hash(PyMethodObject *a)
{
- long x, y;
+ Py_hash_t x, y;
if (a->im_self == NULL)
x = PyObject_Hash(Py_None);
else
return res;
}
-static long
+static Py_hash_t
code_hash(PyCodeObject *co)
{
- long h, h0, h1, h2, h3, h4, h5, h6;
+ Py_hash_t h, h0, h1, h2, h3, h4, h5, h6;
h0 = PyObject_Hash(co->co_name);
if (h0 == -1) return -1;
h1 = PyObject_Hash(co->co_code);
return complex_format(v, 0, 'r');
}
-static long
+static Py_hash_t
complex_hash(PyComplexObject *v)
{
unsigned long hashreal, hashimag, combined;
combined = hashreal + _PyHASH_IMAG * hashimag;
if (combined == (unsigned long)-1)
combined = (unsigned long)-2;
- return (long)combined;
+ return (Py_hash_t)combined;
}
/* This macro may return! */
return v;
}
-static long
+static Py_hash_t
wrapper_hash(wrapperobject *wp)
{
- int x, y;
+ Py_hash_t x, y;
x = _Py_HashPointer(wp->descr);
if (x == -1)
return -1;
PyDictEntry*.
*/
static PyDictEntry *
-lookdict(PyDictObject *mp, PyObject *key, register long hash)
+lookdict(PyDictObject *mp, PyObject *key, register Py_hash_t hash)
{
register size_t i;
register size_t perturb;
* This is valuable because dicts with only unicode keys are very common.
*/
static PyDictEntry *
-lookdict_unicode(PyDictObject *mp, PyObject *key, register long hash)
+lookdict_unicode(PyDictObject *mp, PyObject *key, register Py_hash_t hash)
{
register size_t i;
register size_t perturb;
Returns -1 if an error occurred, or 0 on success.
*/
static int
-insertdict(register PyDictObject *mp, PyObject *key, long hash, PyObject *value)
+insertdict(register PyDictObject *mp, PyObject *key, Py_hash_t hash, PyObject *value)
{
PyObject *old_value;
register PyDictEntry *ep;
Py_DECREF(dummy);
}
ep->me_key = key;
- ep->me_hash = (Py_ssize_t)hash;
+ ep->me_hash = hash;
ep->me_value = value;
mp->ma_used++;
}
is responsible for incref'ing `key` and `value`.
*/
static void
-insertdict_clean(register PyDictObject *mp, PyObject *key, long hash,
+insertdict_clean(register PyDictObject *mp, PyObject *key, Py_hash_t hash,
PyObject *value)
{
register size_t i;
assert(ep->me_value == NULL);
mp->ma_fill++;
ep->me_key = key;
- ep->me_hash = (Py_ssize_t)hash;
+ ep->me_hash = hash;
ep->me_value = value;
mp->ma_used++;
}
for (ep = oldtable; i > 0; ep++) {
if (ep->me_value != NULL) { /* active entry */
--i;
- insertdict_clean(mp, ep->me_key, (long)ep->me_hash,
- ep->me_value);
+ insertdict_clean(mp, ep->me_key, ep->me_hash, ep->me_value);
}
else if (ep->me_key != NULL) { /* dummy entry */
--i;
PyObject *
PyDict_GetItem(PyObject *op, PyObject *key)
{
- long hash;
+ Py_hash_t hash;
PyDictObject *mp = (PyDictObject *)op;
PyDictEntry *ep;
PyThreadState *tstate;
PyObject *
PyDict_GetItemWithError(PyObject *op, PyObject *key)
{
- long hash;
+ Py_hash_t hash;
PyDictObject*mp = (PyDictObject *)op;
PyDictEntry *ep;
PyDict_SetItem(register PyObject *op, PyObject *key, PyObject *value)
{
register PyDictObject *mp;
- register long hash;
+ register Py_hash_t hash;
register Py_ssize_t n_used;
if (!PyDict_Check(op)) {
PyDict_DelItem(PyObject *op, PyObject *key)
{
register PyDictObject *mp;
- register long hash;
+ register Py_hash_t hash;
register PyDictEntry *ep;
PyObject *old_value, *old_key;
/* Internal version of PyDict_Next that returns a hash value in addition to the key and value.*/
int
-_PyDict_Next(PyObject *op, Py_ssize_t *ppos, PyObject **pkey, PyObject **pvalue, long *phash)
+_PyDict_Next(PyObject *op, Py_ssize_t *ppos, PyObject **pkey, PyObject **pvalue, Py_hash_t *phash)
{
register Py_ssize_t i;
register Py_ssize_t mask;
*ppos = i+1;
if (i > mask)
return 0;
- *phash = (long)(ep[i].me_hash);
+ *phash = ep[i].me_hash;
if (pkey)
*pkey = ep[i].me_key;
if (pvalue)
dict_subscript(PyDictObject *mp, register PyObject *key)
{
PyObject *v;
- long hash;
+ Py_hash_t hash;
PyDictEntry *ep;
assert(mp->ma_table != NULL);
if (!PyUnicode_CheckExact(key) ||
PyObject *oldvalue;
Py_ssize_t pos = 0;
PyObject *key;
- long hash;
+ Py_hash_t hash;
if (dictresize(mp, Py_SIZE(seq)))
return NULL;
PyDictObject *mp = (PyDictObject *)d;
Py_ssize_t pos = 0;
PyObject *key;
- long hash;
+ Py_hash_t hash;
if (dictresize(mp, PySet_GET_SIZE(seq)))
return NULL;
Py_INCREF(entry->me_key);
Py_INCREF(entry->me_value);
if (insertdict(mp, entry->me_key,
- (long)entry->me_hash,
+ entry->me_hash,
entry->me_value) != 0)
return -1;
}
static PyObject *
dict_contains(register PyDictObject *mp, PyObject *key)
{
- long hash;
+ Py_hash_t hash;
PyDictEntry *ep;
if (!PyUnicode_CheckExact(key) ||
PyObject *key;
PyObject *failobj = Py_None;
PyObject *val = NULL;
- long hash;
+ Py_hash_t hash;
PyDictEntry *ep;
if (!PyArg_UnpackTuple(args, "get", 1, 2, &key, &failobj))
PyObject *key;
PyObject *failobj = Py_None;
PyObject *val = NULL;
- long hash;
+ Py_hash_t hash;
PyDictEntry *ep;
if (!PyArg_UnpackTuple(args, "setdefault", 1, 2, &key, &failobj))
static PyObject *
dict_pop(PyDictObject *mp, PyObject *args)
{
- long hash;
+ Py_hash_t hash;
PyDictEntry *ep;
PyObject *old_value, *old_key;
PyObject *key, *deflt = NULL;
static PyObject *
dict_popitem(PyDictObject *mp)
{
- Py_ssize_t i = 0;
+ Py_hash_t i = 0;
PyDictEntry *ep;
PyObject *res;
int
PyDict_Contains(PyObject *op, PyObject *key)
{
- long hash;
+ Py_hash_t hash;
PyDictObject *mp = (PyDictObject *)op;
PyDictEntry *ep;
/* Internal version of PyDict_Contains used when the hash value is already known */
int
-_PyDict_Contains(PyObject *op, PyObject *key, long hash)
+_PyDict_Contains(PyObject *op, PyObject *key, Py_hash_t hash)
{
PyDictObject *mp = (PyDictObject *)op;
PyDictEntry *ep;
return Py_NotImplemented;
}
-static long
+static Py_hash_t
float_hash(PyFloatObject *v)
{
return _Py_HashDouble(v->ob_fval);
return v;
}
-static long
+static Py_hash_t
long_hash(PyLongObject *v)
{
unsigned long x;
x = x * sign;
if (x == (unsigned long)-1)
x = (unsigned long)-2;
- return (long)x;
+ return (Py_hash_t)x;
}
return res;
}
-static long
+static Py_hash_t
meth_hash(PyCFunctionObject *a)
{
- long x,y;
+ Py_hash_t x, y;
if (a->m_self == NULL)
x = 0;
else {
*/
-long
+Py_hash_t
_Py_HashDouble(double v)
{
int e, sign;
x = x * sign;
if (x == (unsigned long)-1)
x = (unsigned long)-2;
- return (long)x;
+ return (Py_hash_t)x;
}
-long
+Py_hash_t
_Py_HashPointer(void *p)
{
- long x;
+ Py_hash_t x;
size_t y = (size_t)p;
/* bottom 3 or 4 bits are likely to be 0; rotate y by 4 to avoid
excessive hash collisions for dicts and sets */
y = (y >> 4) | (y << (8 * SIZEOF_VOID_P - 4));
- x = (long)y;
+ x = (Py_hash_t)y;
if (x == -1)
x = -2;
return x;
}
-long
+Py_hash_t
PyObject_HashNotImplemented(PyObject *v)
{
PyErr_Format(PyExc_TypeError, "unhashable type: '%.200s'",
return -1;
}
-long
+Py_hash_t
PyObject_Hash(PyObject *v)
{
PyTypeObject *tp = Py_TYPE(v);
*/
static setentry *
-set_lookkey(PySetObject *so, PyObject *key, register long hash)
+set_lookkey(PySetObject *so, PyObject *key, register Py_hash_t hash)
{
register Py_ssize_t i;
register size_t perturb;
* see if the comparison altered the table.
*/
static setentry *
-set_lookkey_unicode(PySetObject *so, PyObject *key, register long hash)
+set_lookkey_unicode(PySetObject *so, PyObject *key, register Py_hash_t hash)
{
register Py_ssize_t i;
register size_t perturb;
Eats a reference to key.
*/
static int
-set_insert_key(register PySetObject *so, PyObject *key, long hash)
+set_insert_key(register PySetObject *so, PyObject *key, Py_hash_t hash)
{
register setentry *entry;
typedef setentry *(*lookupfunc)(PySetObject *, PyObject *, long);
is responsible for incref'ing `key`.
*/
static void
-set_insert_clean(register PySetObject *so, PyObject *key, long hash)
+set_insert_clean(register PySetObject *so, PyObject *key, Py_hash_t hash)
{
register size_t i;
register size_t perturb;
} else {
/* ACTIVE */
--i;
- set_insert_clean(so, entry->key, (long) entry->hash);
+ set_insert_clean(so, entry->key, entry->hash);
}
}
assert(so->fill <= so->mask); /* at least one empty slot */
n_used = so->used;
Py_INCREF(key);
- if (set_insert_key(so, key, (long) entry->hash) == -1) {
+ if (set_insert_key(so, key, entry->hash) == -1) {
Py_DECREF(key);
return -1;
}
static int
set_add_key(register PySetObject *so, PyObject *key)
{
- register long hash;
+ register Py_hash_t hash;
register Py_ssize_t n_used;
if (!PyUnicode_CheckExact(key) ||
{ register setentry *entry;
PyObject *old_key;
- entry = (so->lookup)(so, oldentry->key, (long) oldentry->hash);
+ entry = (so->lookup)(so, oldentry->key, oldentry->hash);
if (entry == NULL)
return -1;
if (entry->key == NULL || entry->key == dummy)
static int
set_discard_key(PySetObject *so, PyObject *key)
{
- register long hash;
+ register Py_hash_t hash;
register setentry *entry;
PyObject *old_key;
static int
set_contains_key(PySetObject *so, PyObject *key)
{
- long hash;
+ Py_hash_t hash;
setentry *entry;
if (!PyUnicode_CheckExact(key) ||
PyObject *key;
setentry *lu_entry;
- lu_entry = (so->lookup)(so, entry->key, (long) entry->hash);
+ lu_entry = (so->lookup)(so, entry->key, entry->hash);
if (lu_entry == NULL)
return -1;
key = lu_entry->key;
return 0;
}
-static long
+static Py_hash_t
frozenset_hash(PyObject *self)
{
PySetObject *so = (PySetObject *)self;
- long h, hash = 1927868237L;
+ Py_hash_t h, hash = 1927868237L;
setentry *entry;
Py_ssize_t pos = 0;
if (PyDict_CheckExact(other)) {
PyObject *value;
Py_ssize_t pos = 0;
- long hash;
+ Py_hash_t hash;
Py_ssize_t dictsize = PyDict_Size(other);
/* Do one big resize at the start, rather than
{
Py_ssize_t t;
setentry *u;
- setentry *(*f)(PySetObject *so, PyObject *key, long hash);
+ setentry *(*f)(PySetObject *so, PyObject *key, Py_ssize_t hash);
setentry tab[PySet_MINSIZE];
long h;
while ((key = PyIter_Next(it)) != NULL) {
int rv;
setentry entry;
- long hash = PyObject_Hash(key);
+ Py_hash_t hash = PyObject_Hash(key);
if (hash == -1) {
Py_DECREF(it);
while ((key = PyIter_Next(it)) != NULL) {
int rv;
setentry entry;
- long hash = PyObject_Hash(key);
+ Py_hash_t hash = PyObject_Hash(key);
if (hash == -1) {
Py_DECREF(key);
if (PyDict_CheckExact(other)) {
PyObject *value;
int rv;
- long hash;
+ Py_hash_t hash;
while (_PyDict_Next(other, &pos, &key, &value, &hash)) {
setentry an_entry;
}
int
-_PySet_NextEntry(PyObject *set, Py_ssize_t *pos, PyObject **key, long *hash)
+_PySet_NextEntry(PyObject *set, Py_ssize_t *pos, PyObject **key, Py_hash_t *hash)
{
setentry *entry;
if (set_next((PySetObject *)set, pos, &entry) == 0)
return 0;
*key = entry->key;
- *hash = (long) entry->hash;
+ *hash = entry->hash;
return 1;
}
Py_ssize_t i;
PyObject *elem=NULL, *dup=NULL, *t, *f, *dup2, *x;
PyObject *ob = (PyObject *)so;
- long hash;
+ Py_hash_t hash;
PyObject *str;
/* Verify preconditions */
1330111, 1412633, 1165069, 1247599, 1495177, 1577699
*/
-static long
+static Py_hash_t
tuplehash(PyTupleObject *v)
{
- register long x, y;
+ register Py_hash_t x, y;
register Py_ssize_t len = Py_SIZE(v);
register PyObject **p;
long mult = 1000003L;
}
}
-static long
+static Py_hash_t
slot_tp_hash(PyObject *self)
{
PyObject *func, *res;
static PyObject *hash_str;
- long h;
- int overflow;
+ Py_ssize_t h;
func = lookup_method(self, "__hash__", &hash_str);
"__hash__ method should return an integer");
return -1;
}
- /* Transform the PyLong `res` to a C long `h`. For an existing
- hashable Python object x, hash(x) will always lie within the range
- of a C long. Therefore our transformation must preserve values
- that already lie within this range, to ensure that if x.__hash__()
- returns hash(y) then hash(x) == hash(y). */
- h = PyLong_AsLongAndOverflow(res, &overflow);
- if (overflow)
- /* res was not within the range of a C long, so we're free to
+ /* Transform the PyLong `res` to a Py_hash_t `h`. For an existing
+ hashable Python object x, hash(x) will always lie within the range of
+ Py_hash_t. Therefore our transformation must preserve values that
+ already lie within this range, to ensure that if x.__hash__() returns
+ hash(y) then hash(x) == hash(y). */
+ h = PyLong_AsSsize_t(res);
+ if (h == -1 && PyErr_Occurred()) {
+ /* res was not within the range of a Py_hash_t, so we're free to
use any sufficiently bit-mixing transformation;
long.__hash__ will do nicely. */
+ PyErr_Clear();
h = PyLong_Type.tp_hash(res);
+ }
Py_DECREF(res);
- if (h == -1 && !PyErr_Occurred())
- h = -2;
return h;
}
/* Believe it or not, this produces the same value for ASCII strings
as string_hash(). */
-static long
+static Py_hash_t
unicode_hash(PyUnicodeObject *self)
{
Py_ssize_t len;
Py_UNICODE *p;
- long x;
+ Py_hash_t x;
if (self->hash != -1)
return self->hash;
}
-static long
+static Py_hash_t
weakref_hash(PyWeakReference *self)
{
if (self->hash != -1)
static PyObject *
builtin_hash(PyObject *self, PyObject *v)
{
- long x;
+ Py_hash_t x;
x = PyObject_Hash(v);
if (x == -1)
return NULL;
- return PyLong_FromLong(x);
+ return PyLong_FromSsize_t(x);
}
PyDoc_STRVAR(hash_doc,
/* Inline the PyDict_GetItem() calls.
WARNING: this is an extreme speed hack.
Do not try this at home. */
- long hash = ((PyUnicodeObject *)w)->hash;
+ Py_hash_t hash = ((PyUnicodeObject *)w)->hash;
if (hash != -1) {
PyDictObject *d;
PyDictEntry *e;
if (hash_info == NULL)
return NULL;
PyStructSequence_SET_ITEM(hash_info, field++,
- PyLong_FromLong(8*sizeof(long)));
+ PyLong_FromLong(8*sizeof(Py_hash_t)));
PyStructSequence_SET_ITEM(hash_info, field++,
PyLong_FromLong(_PyHASH_MODULUS));
PyStructSequence_SET_ITEM(hash_info, field++,
projects / thirdparty / Python / cpython.git / commitdiff
