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 */