[Python-checkins] python/nondist/sandbox/set setobject.c, 1.6, 1.7 setobject.h, 1.1, 1.2
rhettinger@users.sourceforge.net
rhettinger at users.sourceforge.net
Sat Jul 30 23:07:31 CEST 2005
Update of /cvsroot/python/python/nondist/sandbox/set
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv12279
Modified Files:
setobject.c setobject.h
Log Message:
Improve variable names and other minor clean-up.
Index: setobject.c
===================================================================
RCS file: /cvsroot/python/python/nondist/sandbox/set/setobject.c,v
retrieving revision 1.6
retrieving revision 1.7
diff -u -d -r1.6 -r1.7
--- setobject.c 30 Jul 2005 16:21:17 -0000 1.6
+++ setobject.c 30 Jul 2005 21:07:28 -0000 1.7
@@ -16,13 +16,13 @@
/* forward declarations */
static setentry *
-set_lookkey_string(setobject *mp, PyObject *key, long hash);
+set_lookkey_string(setobject *so, PyObject *key, long hash);
-#define EMPTY_TO_MINSIZE(mp) do { \
- memset((mp)->ma_smalltable, 0, sizeof((mp)->ma_smalltable)); \
- (mp)->ma_used = (mp)->ma_fill = 0; \
- (mp)->ma_table = (mp)->ma_smalltable; \
- (mp)->ma_mask = PySet_MINSIZE - 1; \
+#define EMPTY_TO_MINSIZE(so) do { \
+ memset((so)->smalltable, 0, sizeof((so)->smalltable)); \
+ (so)->used = (so)->fill = 0; \
+ (so)->table = (so)->smalltable; \
+ (so)->mask = PySet_MINSIZE - 1; \
} while(0)
@@ -38,18 +38,18 @@
All arithmetic on hash should ignore overflow.
This function must never return NULL; failures are indicated by returning
-a setentry* for which the me_value field is NULL. Exceptions are never
+a setentry* for which the value field is NULL. Exceptions are never
reported by this function, and outstanding exceptions are maintained.
*/
static setentry *
-set_lookkey(setobject *mp, PyObject *key, register long hash)
+set_lookkey(setobject *so, PyObject *key, register long hash)
{
register int i;
register unsigned int perturb;
register setentry *freeslot;
- register unsigned int mask = mp->ma_mask;
- setentry *ep0 = mp->ma_table;
+ register unsigned int mask = so->mask;
+ setentry *ep0 = so->table;
register setentry *ep;
register int restore_error;
register int checked_error;
@@ -59,25 +59,25 @@
i = hash & mask;
ep = &ep0[i];
- if (ep->me_key == NULL || ep->me_key == key)
+ if (ep->key == NULL || ep->key == key)
return ep;
restore_error = checked_error = 0;
- if (ep->me_key == dummy)
+ if (ep->key == dummy)
freeslot = ep;
else {
- if (ep->me_hash == hash) {
+ if (ep->hash == hash) {
/* error can't have been checked yet */
checked_error = 1;
if (PyErr_Occurred()) {
restore_error = 1;
PyErr_Fetch(&err_type, &err_value, &err_tb);
}
- startkey = ep->me_key;
+ startkey = ep->key;
cmp = PyObject_RichCompareBool(startkey, key, Py_EQ);
if (cmp < 0)
PyErr_Clear();
- if (ep0 == mp->ma_table && ep->me_key == startkey) {
+ if (ep0 == so->table && ep->key == startkey) {
if (cmp > 0)
goto Done;
}
@@ -87,26 +87,26 @@
* XXX A clever adversary could prevent this
* XXX from terminating.
*/
- ep = set_lookkey(mp, key, hash);
+ ep = set_lookkey(so, key, hash);
goto Done;
}
}
freeslot = NULL;
}
- /* In the loop, me_key == dummy is by far (factor of 100s) the
+ /* In the loop, key == dummy is by far (factor of 100s) the
least likely outcome, so test for that last. */
for (perturb = hash; ; perturb >>= PERTURB_SHIFT) {
i = (i << 2) + i + perturb + 1;
ep = &ep0[i & mask];
- if (ep->me_key == NULL) {
+ if (ep->key == NULL) {
if (freeslot != NULL)
ep = freeslot;
break;
}
- if (ep->me_key == key)
+ if (ep->key == key)
break;
- if (ep->me_hash == hash && ep->me_key != dummy) {
+ if (ep->hash == hash && ep->key != dummy) {
if (!checked_error) {
checked_error = 1;
if (PyErr_Occurred()) {
@@ -115,11 +115,11 @@
&err_tb);
}
}
- startkey = ep->me_key;
+ startkey = ep->key;
cmp = PyObject_RichCompareBool(startkey, key, Py_EQ);
if (cmp < 0)
PyErr_Clear();
- if (ep0 == mp->ma_table && ep->me_key == startkey) {
+ if (ep0 == so->table && ep->key == startkey) {
if (cmp > 0)
break;
}
@@ -129,11 +129,11 @@
* XXX A clever adversary could prevent this
* XXX from terminating.
*/
- ep = set_lookkey(mp, key, hash);
+ ep = set_lookkey(so, key, hash);
break;
}
}
- else if (ep->me_key == dummy && freeslot == NULL)
+ else if (ep->key == dummy && freeslot == NULL)
freeslot = ep;
}
@@ -154,13 +154,13 @@
* expensive, and sets with pure-string keys may be very common.
*/
static setentry *
-set_lookkey_string(setobject *mp, PyObject *key, register long hash)
+set_lookkey_string(setobject *so, PyObject *key, register long hash)
{
register int i;
register unsigned int perturb;
register setentry *freeslot;
- register unsigned int mask = mp->ma_mask;
- setentry *ep0 = mp->ma_table;
+ register unsigned int mask = so->mask;
+ setentry *ep0 = so->table;
register setentry *ep;
/* Make sure this function doesn't have to handle non-string keys,
@@ -168,36 +168,34 @@
strings is to override __eq__, and for speed we don't cater to
that here. */
if (!PyString_CheckExact(key)) {
- mp->ma_lookup = set_lookkey;
- return set_lookkey(mp, key, hash);
+ so->lookup = set_lookkey;
+ return set_lookkey(so, key, hash);
}
i = hash & mask;
ep = &ep0[i];
- if (ep->me_key == NULL || ep->me_key == key)
+ if (ep->key == NULL || ep->key == key)
return ep;
- if (ep->me_key == dummy)
+ if (ep->key == dummy)
freeslot = ep;
else {
- if (ep->me_hash == hash
- && _PyString_Eq(ep->me_key, key)) {
+ if (ep->hash == hash && _PyString_Eq(ep->key, key))
return ep;
- }
freeslot = NULL;
}
- /* In the loop, me_key == dummy is by far (factor of 100s) the
+ /* In the loop, key == dummy is by far (factor of 100s) the
least likely outcome, so test for that last. */
for (perturb = hash; ; perturb >>= PERTURB_SHIFT) {
i = (i << 2) + i + perturb + 1;
ep = &ep0[i & mask];
- if (ep->me_key == NULL)
+ if (ep->key == NULL)
return freeslot == NULL ? ep : freeslot;
- if (ep->me_key == key
- || (ep->me_hash == hash
- && ep->me_key != dummy
- && _PyString_Eq(ep->me_key, key)))
+ if (ep->key == key
+ || (ep->hash == hash
+ && ep->key != dummy
+ && _PyString_Eq(ep->key, key)))
return ep;
- if (ep->me_key == dummy && freeslot == NULL)
+ if (ep->key == dummy && freeslot == NULL)
freeslot = ep;
}
}
@@ -208,31 +206,27 @@
Eats a reference to key.
*/
static void
-set_insert_key(register setobject *mp, PyObject *key, long hash)
+set_insert_key(register setobject *so, PyObject *key, long hash)
{
register setentry *ep;
typedef PySetEntry *(*lookupfunc)(PySetObject *, PyObject *, long);
- assert(mp->ma_lookup != NULL);
+ assert(so->lookup != NULL);
- ep = mp->ma_lookup(mp, key, hash);
- if (ep->me_key == NULL) {
+ ep = so->lookup(so, key, hash);
+ if (ep->key == NULL) {
/* UNUSED */
- mp->ma_fill++;
- ep->me_key = key;
- ep->me_hash = hash;
- mp->ma_used++;
- }
-
- else if (ep->me_key == dummy) {
+ so->fill++;
+ ep->key = key;
+ ep->hash = hash;
+ so->used++;
+ } else if (ep->key == dummy) {
/* DUMMY */
Py_DECREF(dummy);
- ep->me_key = key;
- ep->me_hash = hash;
- mp->ma_used++;
- }
-
- else {
+ ep->key = key;
+ ep->hash = hash;
+ so->used++;
+ } else {
/* ACTIVE */
Py_DECREF(key);
}
@@ -244,7 +238,7 @@
actually be smaller than the old one.
*/
static int
-set_table_resize(setobject *mp, int minused)
+set_table_resize(setobject *so, int minused)
{
int newsize;
setentry *oldtable, *newtable, *ep;
@@ -265,15 +259,15 @@
}
/* Get space for a new table. */
- oldtable = mp->ma_table;
+ oldtable = so->table;
assert(oldtable != NULL);
- is_oldtable_malloced = oldtable != mp->ma_smalltable;
+ is_oldtable_malloced = oldtable != so->smalltable;
if (newsize == PySet_MINSIZE) {
/* A large table is shrinking, or we can't get any smaller. */
- newtable = mp->ma_smalltable;
+ newtable = so->smalltable;
if (newtable == oldtable) {
- if (mp->ma_fill == mp->ma_used) {
+ if (so->fill == so->used) {
/* No dummies, so no point doing anything. */
return 0;
}
@@ -283,7 +277,7 @@
as set_lookkey needs at least one virgin slot to
terminate failing searches. If fill < size, it's
merely desirable, as dummies slow searches. */
- assert(mp->ma_fill > mp->ma_used);
+ assert(so->fill > so->used);
memcpy(small_copy, oldtable, sizeof(small_copy));
oldtable = small_copy;
}
@@ -298,33 +292,28 @@
/* Make the set empty, using the new table. */
assert(newtable != oldtable);
- mp->ma_table = newtable;
- mp->ma_mask = newsize - 1;
+ so->table = newtable;
+ so->mask = newsize - 1;
memset(newtable, 0, sizeof(setentry) * newsize);
- mp->ma_used = 0;
- i = mp->ma_fill;
- mp->ma_fill = 0;
+ so->used = 0;
+ i = so->fill;
+ so->fill = 0;
/* Copy the data over; this is refcount-neutral for active entries;
dummy entries aren't copied over, of course */
for (ep = oldtable; i > 0; ep++) {
-
- if (ep->me_key == NULL) {
+ if (ep->key == NULL) {
// UNUSED
;
- }
-
- else if (ep->me_key == dummy) {
+ } else if (ep->key == dummy) {
// DUMMY
--i;
- assert(ep->me_key == dummy);
- Py_DECREF(ep->me_key);
- }
-
- else {
+ assert(ep->key == dummy);
+ Py_DECREF(ep->key);
+ } else {
// ACTIVE
--i;
- set_insert_key(mp, ep->me_key, ep->me_hash);
+ set_insert_key(so, ep->key, ep->hash);
}
}
@@ -338,7 +327,7 @@
/* CAUTION: set_add_internal() must guarantee that it won't resize the table */
static int
-set_add_internal(register PySetObject *mp, PyObject *key)
+set_add_internal(register PySetObject *so, PyObject *key)
{
register long hash;
register int n_used;
@@ -347,63 +336,50 @@
hash = ((PyStringObject *)key)->ob_shash;
if (hash == -1)
hash = PyObject_Hash(key);
- }
- else {
+ } else {
hash = PyObject_Hash(key);
if (hash == -1)
return -1;
}
- assert(mp->ma_fill <= mp->ma_mask); /* at least one empty slot */
- n_used = mp->ma_used;
+ assert(so->fill <= so->mask); /* at least one empty slot */
+ n_used = so->used;
Py_INCREF(key);
- set_insert_key(mp, key, hash);
- if (!(mp->ma_used > n_used && mp->ma_fill*3 >= (mp->ma_mask+1)*2))
+ set_insert_key(so, key, hash);
+ if (!(so->used > n_used && so->fill*3 >= (so->mask+1)*2))
return 0;
- return set_table_resize(mp, mp->ma_used*(mp->ma_used>50000 ? 2 : 4));
+ return set_table_resize(so, so->used*(so->used>50000 ? 2 : 4));
}
#define DISCARD_FOUND 0
#define DISCARD_NOTFOUND 1
static int
-set_discard_internal(PySetObject *mp, PyObject *key)
+set_discard_internal(PySetObject *so, PyObject *key)
{
register long hash;
register setentry *ep;
PyObject *old_key;
- assert (PyAnySet_Check(mp));
+ assert (PyAnySet_Check(so));
if (!PyString_CheckExact(key) ||
(hash = ((PyStringObject *) key)->ob_shash) == -1) {
hash = PyObject_Hash(key);
if (hash == -1)
return -1;
}
- ep = (mp->ma_lookup)(mp, key, hash);
- if (ep->me_key == NULL || ep->me_key == dummy)
+ ep = (so->lookup)(so, key, hash);
+ if (ep->key == NULL || ep->key == dummy)
return DISCARD_NOTFOUND;
- old_key = ep->me_key;
+ old_key = ep->key;
Py_INCREF(dummy);
- ep->me_key = dummy;
- mp->ma_used--;
+ ep->key = dummy;
+ so->used--;
Py_DECREF(old_key);
return DISCARD_FOUND;
}
-static int
-set_remove_internal(PySetObject *mp, PyObject *key)
-{
- int rv = set_discard_internal(mp, key);
-
- if (rv == 1) {
- PyErr_SetObject(PyExc_KeyError, key);
- return -1;
- }
- return rv;
-}
-
static void
-set_clear_internal(PySetObject *mp)
+set_clear_internal(PySetObject *so)
{
setentry *ep, *table;
int table_is_malloced;
@@ -413,15 +389,15 @@
int i, n;
#endif
- assert (PyAnySet_Check(mp));
+ assert (PyAnySet_Check(so));
#ifdef Py_DEBUG
- n = mp->ma_mask + 1;
+ n = so->mask + 1;
i = 0;
#endif
- table = mp->ma_table;
+ table = so->table;
assert(table != NULL);
- table_is_malloced = table != mp->ma_smalltable;
+ table_is_malloced = table != so->smalltable;
/* This is delicate. During the process of clearing the set,
* decrefs can cause the set to mutate. To avoid fatal confusion
@@ -429,9 +405,9 @@
* clearing the slots, and never refer to anything via mp->ref while
* clearing.
*/
- fill = mp->ma_fill;
+ fill = so->fill;
if (table_is_malloced)
- EMPTY_TO_MINSIZE(mp);
+ EMPTY_TO_MINSIZE(so);
else if (fill > 0) {
/* It's a small table with something that needs to be cleared.
@@ -440,7 +416,7 @@
*/
memcpy(small_copy, table, sizeof(small_copy));
table = small_copy;
- EMPTY_TO_MINSIZE(mp);
+ EMPTY_TO_MINSIZE(so);
}
/* else it's a small table that's already empty */
@@ -453,13 +429,13 @@
assert(i < n);
++i;
#endif
- if (ep->me_key) {
+ if (ep->key) {
--fill;
- Py_DECREF(ep->me_key);
+ Py_DECREF(ep->key);
}
#ifdef Py_DEBUG
else
- assert(ep->me_key == NULL || ep->me_key == dummy);
+ assert(ep->key == NULL || ep->key == dummy);
#endif
}
@@ -481,67 +457,64 @@
* mutates the table.
*/
static int
-set_next_internal(PySetObject *mp, int *ppos, PyObject **pkey)
+set_next_internal(PySetObject *so, int *ppos, PyObject **pkey)
{
register int i, mask;
register setentry *ep;
- assert (PyAnySet_Check(mp));
+ assert (PyAnySet_Check(so));
i = *ppos;
if (i < 0)
return 0;
- ep = mp->ma_table;
- mask = mp->ma_mask;
- while (i <= mask && (ep[i].me_key == NULL || ep[i].me_key == dummy))
+ ep = so->table;
+ mask = so->mask;
+ while (i <= mask && (ep[i].key == NULL || ep[i].key == dummy))
i++;
*ppos = i+1;
if (i > mask)
return 0;
if (pkey)
- *pkey = ep[i].me_key;
+ *pkey = ep[i].key;
return 1;
}
/* Methods */
static int
-set_merge_internal(PySetObject *mp, PyObject *b)
+set_merge_internal(PySetObject *so, PyObject *b)
{
register PySetObject *other;
register int i;
setentry *entry;
- assert (PyAnySet_Check(mp));
+ assert (PyAnySet_Check(so));
assert (PyAnySet_Check(b));
other = (setobject*)b;
- if (other == mp || other->ma_used == 0)
+ if (other == so || other->used == 0)
/* a.update(a) or a.update({}); nothing to do */
return 0;
/* Do one big resize at the start, rather than
* incrementally resizing as we insert new items. Expect
* that there will be no (or few) overlapping keys.
*/
- if ((mp->ma_fill + other->ma_used)*3 >= (mp->ma_mask+1)*2) {
- if (set_table_resize(mp, (mp->ma_used + other->ma_used)*2) != 0)
+ if ((so->fill + other->used)*3 >= (so->mask+1)*2) {
+ if (set_table_resize(so, (so->used + other->used)*2) != 0)
return -1;
}
- for (i = 0; i <= other->ma_mask; i++) {
- entry = &other->ma_table[i];
- if (entry->me_key != NULL &&
- entry->me_key != dummy) {
- Py_INCREF(entry->me_key);
- set_insert_key(mp, entry->me_key, entry->me_hash);
+ for (i = 0; i <= other->mask; i++) {
+ entry = &other->table[i];
+ if (entry->key != NULL &&
+ entry->key != dummy) {
+ Py_INCREF(entry->key);
+ set_insert_key(so, entry->key, entry->hash);
}
}
return 0;
}
-static PyTypeObject PysetiterKey_Type; /* Forward */
-static PyObject *set_iter(setobject *);
-
static int
-set_contains_internal(PySetObject *mp, PyObject *key)
+set_contains_internal(PySetObject *so, PyObject *key)
{
long hash;
@@ -551,51 +524,49 @@
if (hash == -1)
return -1;
}
- key = (mp->ma_lookup)(mp, key, hash)->me_key;
+ key = (so->lookup)(so, key, hash)->key;
return key != NULL && key != dummy;
}
+static PyTypeObject PySetIter_Type; /* Forward */
+static PyObject *set_iter(setobject *);
/* Set iterator types */
typedef struct {
PyObject_HEAD
- setobject *di_set; /* Set to NULL when iterator is exhausted */
- int di_used;
- int di_pos;
- PyObject* di_result; /* reusable result tuple for iteritems */
+ setobject *si_set; /* Set to NULL when iterator is exhausted */
+ int si_used;
+ int si_pos;
long len;
} setiterobject;
static PyObject *
set_iter(setobject *so)
{
- setiterobject *di;
- di = PyObject_New(setiterobject, &PysetiterKey_Type);
- if (di == NULL)
+ setiterobject *si = PyObject_New(setiterobject, &PySetIter_Type);
+ if (si == NULL)
return NULL;
Py_INCREF(so);
- di->di_set = so;
- di->di_used = so->ma_used;
- di->di_pos = 0;
- di->len = so->ma_used;
- di->di_result = NULL;
- return (PyObject *)di;
+ si->si_set = so;
+ si->si_used = so->used;
+ si->si_pos = 0;
+ si->len = so->used;
+ return (PyObject *)si;
}
static void
-setiter_dealloc(setiterobject *di)
+setiter_dealloc(setiterobject *si)
{
- Py_XDECREF(di->di_set);
- Py_XDECREF(di->di_result);
- PyObject_Del(di);
+ Py_XDECREF(si->si_set);
+ PyObject_Del(si);
}
static int
-setiter_len(setiterobject *di)
+setiter_len(setiterobject *si)
{
- if (di->di_set != NULL && di->di_used == di->di_set->ma_used)
- return di->len;
+ if (si->si_set != NULL && si->si_used == si->si_set->used)
+ return si->len;
return 0;
}
@@ -604,49 +575,49 @@
0, /* sq_concat */
};
-static PyObject *setiter_iternextkey(setiterobject *di)
+static PyObject *setiter_iternextkey(setiterobject *si)
{
PyObject *key;
register int i, mask;
register setentry *ep;
- setobject *d = di->di_set;
+ setobject *d = si->si_set;
if (d == NULL)
return NULL;
assert (PyAnySet_Check(d));
- if (di->di_used != d->ma_used) {
+ if (si->si_used != d->used) {
PyErr_SetString(PyExc_RuntimeError,
"Set changed size during iteration");
- di->di_used = -1; /* Make this state sticky */
+ si->si_used = -1; /* Make this state sticky */
return NULL;
}
- i = di->di_pos;
+ i = si->si_pos;
if (i < 0)
goto fail;
- ep = d->ma_table;
- mask = d->ma_mask;
- while (i <= mask && (ep[i].me_key == NULL || ep[i].me_key == dummy))
+ ep = d->table;
+ mask = d->mask;
+ while (i <= mask && (ep[i].key == NULL || ep[i].key == dummy))
i++;
- di->di_pos = i+1;
+ si->si_pos = i+1;
if (i > mask)
goto fail;
- di->len--;
- key = ep[i].me_key;
+ si->len--;
+ key = ep[i].key;
Py_INCREF(key);
return key;
fail:
Py_DECREF(d);
- di->di_set = NULL;
+ si->si_set = NULL;
return NULL;
}
-PyTypeObject PysetiterKey_Type = {
+PyTypeObject PySetIter_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
- "Set-keyiterator", /* tp_name */
+ "Set-keyiterator", /* tp_name */
sizeof(setiterobject), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
@@ -748,8 +719,7 @@
return NULL;
EMPTY_TO_MINSIZE(so);
- so->ma_lookup = set_lookkey_string;
- //_PyObject_GC_TRACK(so);
+ so->lookup = set_lookkey_string;
so->hash = -1;
so->weakreflist = NULL;
@@ -762,7 +732,6 @@
Py_DECREF(tmp);
}
- assert (so->hash == -1);
return (PyObject *)so;
}
@@ -790,21 +759,21 @@
set_dealloc(PySetObject *so)
{
register setentry *ep;
- int fill = so->ma_fill;
+ int fill = so->fill;
PyObject_GC_UnTrack(so);
Py_TRASHCAN_SAFE_BEGIN(so)
if (so->weakreflist != NULL)
PyObject_ClearWeakRefs((PyObject *) so);
- for (ep = so->ma_table; fill > 0; ep++) {
- if (ep->me_key) {
+ for (ep = so->table; fill > 0; ep++) {
+ if (ep->key) {
--fill;
- Py_DECREF(ep->me_key);
+ Py_DECREF(ep->key);
}
}
- if (so->ma_table != so->ma_smalltable)
- PyMem_DEL(so->ma_table);
+ if (so->table != so->smalltable)
+ PyMem_DEL(so->table);
so->ob_type->tp_free(so);
Py_TRASHCAN_SAFE_END(so)
@@ -813,21 +782,18 @@
static int
set_traverse(PySetObject *so, visitproc visit, void *arg)
{
- int i = 0, err;
+ int i = 0;
PyObject *pk;
- while (set_next_internal(so, &i, &pk)) {
- err = visit(pk, arg);
- if (err)
- return err;
- }
+ while (set_next_internal(so, &i, &pk))
+ Py_VISIT(pk);
return 0;
}
static int
set_len(PyObject *so)
{
- return ((PySetObject *)so)->ma_used;
+ return ((PySetObject *)so)->used;
}
static void
@@ -835,28 +801,28 @@
{
int t;
PySetEntry *u;
- PySetEntry *(*f)(PySetObject *mp, PyObject *key, long hash);
+ PySetEntry *(*f)(PySetObject *so, PyObject *key, long hash);
PySetEntry tab[PySet_MINSIZE];
long h;
- t = a->ma_fill; a->ma_fill = b->ma_fill; b->ma_fill = t;
- t = a->ma_used; a->ma_used = b->ma_used; b->ma_used = t;
- t = a->ma_mask; a->ma_mask = b->ma_mask; b->ma_mask = t;
+ t = a->fill; a->fill = b->fill; b->fill = t;
+ t = a->used; a->used = b->used; b->used = t;
+ t = a->mask; a->mask = b->mask; b->mask = t;
- u = a->ma_table;
- if (a->ma_table == a->ma_smalltable)
- u = b->ma_smalltable;
- a->ma_table = b->ma_table;
- if (b->ma_table == b->ma_smalltable)
- a->ma_table = a->ma_smalltable;
- b->ma_table = u;
+ u = a->table;
+ if (a->table == a->smalltable)
+ u = b->smalltable;
+ a->table = b->table;
+ if (b->table == b->smalltable)
+ a->table = a->smalltable;
+ b->table = u;
- f = a->ma_lookup; a->ma_lookup = b->ma_lookup; b->ma_lookup = f;
+ f = a->lookup; a->lookup = b->lookup; b->lookup = f;
- if (a->ma_table == a->ma_smalltable || b->ma_table == b->ma_smalltable) {
- memcpy(tab, a->ma_smalltable, sizeof(tab));
- memcpy(a->ma_smalltable, b->ma_smalltable, sizeof(tab));
- memcpy(b->ma_smalltable, tab, sizeof(tab));
+ if (a->table == a->smalltable || b->table == b->smalltable) {
+ memcpy(tab, a->smalltable, sizeof(tab));
+ memcpy(a->smalltable, b->smalltable, sizeof(tab));
+ memcpy(b->smalltable, tab, sizeof(tab));
}
h = a->hash; a->hash = b->hash; b->hash = h;
@@ -1466,6 +1432,7 @@
set_remove(PySetObject *so, PyObject *item)
{
PyObject *tmp, *result;
+ int rv;
if (PyType_IsSubtype(item->ob_type, &PySet_Type)) {
tmp = make_new_set(&PyFrozenSet_Type, NULL);
@@ -1478,8 +1445,13 @@
return result;
}
- if (set_remove_internal(so, item) == -1)
+ rv = set_discard_internal(so, item);
+ if (rv == -1)
+ return NULL;
+ else if (rv == DISCARD_NOTFOUND) {
+ PyErr_SetObject(PyExc_KeyError, item);
return NULL;
+ }
Py_RETURN_NONE;
}
@@ -1519,14 +1491,21 @@
{
PyObject *key;
int pos = 0;
+ int rv;
if (!set_next_internal(so, &pos, &key)) {
PyErr_SetString(PyExc_KeyError, "pop from an empty set");
return NULL;
}
Py_INCREF(key);
- if (set_remove_internal(so, key) == -1) {
+
+ rv = set_discard_internal(so, key);
+ if (rv == -1) {
+ Py_DECREF(key);
+ return NULL;
+ } else if (rv == DISCARD_NOTFOUND) {
Py_DECREF(key);
+ PyErr_SetObject(PyExc_KeyError, key);
return NULL;
}
return key;
Index: setobject.h
===================================================================
RCS file: /cvsroot/python/python/nondist/sandbox/set/setobject.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- setobject.h 22 Jul 2005 15:32:30 -0000 1.1
+++ setobject.h 30 Jul 2005 21:07:28 -0000 1.2
@@ -10,16 +10,16 @@
/*
There are three kinds of slots in the table:
-1. Unused: me_key == NULL
-2. Active: me_key != NULL and me_key != dummy
-3. Dummy: me_key == dummy
+1. Unused: key == NULL
+2. Active: key != NULL and key != dummy
+3. Dummy: key == dummy
*/
#define PySet_MINSIZE 8
typedef struct {
- long me_hash; /* cached hash code of me_key */
- PyObject *me_key;
+ long hash; /* cached hash code for the entry key */
+ PyObject *key;
} PySetEntry;
@@ -31,23 +31,23 @@
struct _setobject {
PyObject_HEAD
- int ma_fill; /* # Active + # Dummy */
- int ma_used; /* # Active */
+ int fill; /* # Active + # Dummy */
+ int used; /* # Active */
- /* The table contains ma_mask + 1 slots, and that's a power of 2.
+ /* The table contains mask + 1 slots, and that's a power of 2.
* We store the mask instead of the size because the mask is more
* frequently needed.
*/
- int ma_mask;
+ int mask;
- /* ma_table points to ma_smalltable for small tables, else to
- * additional malloc'ed memory. ma_table is never NULL! This rule
+ /* table points to smalltable for small tables, else to
+ * additional malloc'ed memory. table is never NULL! This rule
* saves repeated runtime null-tests in the workhorse getitem and
* setitem calls.
*/
- PySetEntry *ma_table;
- PySetEntry *(*ma_lookup)(PySetObject *mp, PyObject *key, long hash);
- PySetEntry ma_smalltable[PySet_MINSIZE];
+ PySetEntry *table;
+ PySetEntry *(*lookup)(PySetObject *so, PyObject *key, long hash);
+ PySetEntry smalltable[PySet_MINSIZE];
long hash; /* only used by frozenset objects */
PyObject *weakreflist; /* List of weak references */
More information about the Python-checkins
mailing list