PageRenderTime 115ms CodeModel.GetById 10ms app.highlight 92ms RepoModel.GetById 1ms app.codeStats 0ms

/Objects/setobject.c

http://unladen-swallow.googlecode.com/
C | 2493 lines | 2042 code | 274 blank | 177 comment | 583 complexity | 83aa6706f588590611971490b493aaa4 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1
   2/* set object implementation 
   3   Written and maintained by Raymond D. Hettinger <python@rcn.com>
   4   Derived from Lib/sets.py and Objects/dictobject.c.
   5
   6   Copyright (c) 2003-2007 Python Software Foundation.
   7   All rights reserved.
   8*/
   9
  10#include "Python.h"
  11#include "structmember.h"
  12
  13/* Set a key error with the specified argument, wrapping it in a
  14 * tuple automatically so that tuple keys are not unpacked as the
  15 * exception arguments. */
  16static void
  17set_key_error(PyObject *arg)
  18{
  19	PyObject *tup;
  20	tup = PyTuple_Pack(1, arg);
  21	if (!tup)
  22		return; /* caller will expect error to be set anyway */
  23	PyErr_SetObject(PyExc_KeyError, tup);
  24	Py_DECREF(tup);
  25}
  26
  27/* This must be >= 1. */
  28#define PERTURB_SHIFT 5
  29
  30/* Object used as dummy key to fill deleted entries */
  31static PyObject *dummy = NULL; /* Initialized by first call to make_new_set() */
  32
  33#ifdef Py_REF_DEBUG
  34PyObject *
  35_PySet_Dummy(void)
  36{
  37	return dummy;
  38}
  39#endif
  40
  41#define INIT_NONZERO_SET_SLOTS(so) do {				\
  42	(so)->table = (so)->smalltable;				\
  43	(so)->mask = PySet_MINSIZE - 1;				\
  44	(so)->hash = -1;					\
  45    } while(0)
  46
  47#define EMPTY_TO_MINSIZE(so) do {				\
  48	memset((so)->smalltable, 0, sizeof((so)->smalltable));	\
  49	(so)->used = (so)->fill = 0;				\
  50	INIT_NONZERO_SET_SLOTS(so);				\
  51    } while(0)
  52
  53/* Reuse scheme to save calls to malloc, free, and memset */
  54#ifndef PySet_MAXFREELIST
  55#define PySet_MAXFREELIST 80
  56#endif
  57static PySetObject *free_list[PySet_MAXFREELIST];
  58static int numfree = 0;
  59
  60/*
  61The basic lookup function used by all operations.
  62This is based on Algorithm D from Knuth Vol. 3, Sec. 6.4.
  63Open addressing is preferred over chaining since the link overhead for
  64chaining would be substantial (100% with typical malloc overhead).
  65
  66The initial probe index is computed as hash mod the table size. Subsequent
  67probe indices are computed as explained in Objects/dictobject.c.
  68
  69All arithmetic on hash should ignore overflow.
  70
  71Unlike the dictionary implementation, the lookkey functions can return
  72NULL if the rich comparison returns an error.
  73*/
  74
  75static setentry *
  76set_lookkey(PySetObject *so, PyObject *key, register long hash)
  77{
  78	register Py_ssize_t i;
  79	register size_t perturb;
  80	register setentry *freeslot;
  81	register size_t mask = so->mask;
  82	setentry *table = so->table;
  83	register setentry *entry;
  84	register int cmp;
  85	PyObject *startkey;
  86
  87	i = hash & mask;
  88	entry = &table[i];
  89	if (entry->key == NULL || entry->key == key)
  90		return entry;
  91
  92	if (entry->key == dummy)
  93		freeslot = entry;
  94	else {
  95		if (entry->hash == hash) {
  96			startkey = entry->key;
  97			Py_INCREF(startkey);
  98			cmp = PyObject_RichCompareBool(startkey, key, Py_EQ);
  99			Py_DECREF(startkey);
 100			if (cmp < 0)
 101				return NULL;
 102			if (table == so->table && entry->key == startkey) {
 103				if (cmp > 0)
 104					return entry;
 105			}
 106			else {
 107				/* The compare did major nasty stuff to the
 108				 * set:  start over.
 109 				 */
 110 				return set_lookkey(so, key, hash);
 111 			}
 112		}
 113		freeslot = NULL;
 114	}
 115
 116	/* In the loop, key == dummy is by far (factor of 100s) the
 117	   least likely outcome, so test for that last. */
 118	for (perturb = hash; ; perturb >>= PERTURB_SHIFT) {
 119		i = (i << 2) + i + perturb + 1;
 120		entry = &table[i & mask];
 121		if (entry->key == NULL) {
 122			if (freeslot != NULL)
 123				entry = freeslot;
 124			break;
 125		}
 126		if (entry->key == key)
 127			break;
 128		if (entry->hash == hash && entry->key != dummy) {
 129			startkey = entry->key;
 130			Py_INCREF(startkey);
 131			cmp = PyObject_RichCompareBool(startkey, key, Py_EQ);
 132			Py_DECREF(startkey);
 133			if (cmp < 0)
 134				return NULL;
 135			if (table == so->table && entry->key == startkey) {
 136				if (cmp > 0)
 137					break;
 138			}
 139			else {
 140				/* The compare did major nasty stuff to the
 141				 * set:  start over.
 142 				 */
 143 				return set_lookkey(so, key, hash);
 144 			}
 145		}
 146		else if (entry->key == dummy && freeslot == NULL)
 147			freeslot = entry;
 148	}
 149	return entry;
 150}
 151
 152/*
 153 * Hacked up version of set_lookkey which can assume keys are always strings;
 154 * This means we can always use _PyString_Eq directly and not have to check to
 155 * see if the comparison altered the table.
 156 */
 157static setentry *
 158set_lookkey_string(PySetObject *so, PyObject *key, register long hash)
 159{
 160	register Py_ssize_t i;
 161	register size_t perturb;
 162	register setentry *freeslot;
 163	register size_t mask = so->mask;
 164	setentry *table = so->table;
 165	register setentry *entry;
 166
 167	/* Make sure this function doesn't have to handle non-string keys,
 168	   including subclasses of str; e.g., one reason to subclass
 169	   strings is to override __eq__, and for speed we don't cater to
 170	   that here. */
 171	if (!PyString_CheckExact(key)) {
 172		so->lookup = set_lookkey;
 173		return set_lookkey(so, key, hash);
 174	}
 175	i = hash & mask;
 176	entry = &table[i];
 177	if (entry->key == NULL || entry->key == key)
 178		return entry;
 179	if (entry->key == dummy)
 180		freeslot = entry;
 181	else {
 182		if (entry->hash == hash && _PyString_Eq(entry->key, key))
 183			return entry;
 184		freeslot = NULL;
 185	}
 186
 187	/* In the loop, key == dummy is by far (factor of 100s) the
 188	   least likely outcome, so test for that last. */
 189	for (perturb = hash; ; perturb >>= PERTURB_SHIFT) {
 190		i = (i << 2) + i + perturb + 1;
 191		entry = &table[i & mask];
 192		if (entry->key == NULL)
 193			return freeslot == NULL ? entry : freeslot;
 194		if (entry->key == key
 195		    || (entry->hash == hash
 196			&& entry->key != dummy
 197			&& _PyString_Eq(entry->key, key)))
 198			return entry;
 199		if (entry->key == dummy && freeslot == NULL)
 200			freeslot = entry;
 201	}
 202	assert(0);	/* NOT REACHED */
 203	return 0;
 204}
 205
 206/*
 207Internal routine to insert a new key into the table.
 208Used by the public insert routine.
 209Eats a reference to key.
 210*/
 211static int
 212set_insert_key(register PySetObject *so, PyObject *key, long hash)
 213{
 214	register setentry *entry;
 215	typedef setentry *(*lookupfunc)(PySetObject *, PyObject *, long);
 216
 217	assert(so->lookup != NULL);
 218	entry = so->lookup(so, key, hash);
 219	if (entry == NULL)
 220		return -1;
 221	if (entry->key == NULL) {
 222		/* UNUSED */
 223		so->fill++; 
 224		entry->key = key;
 225		entry->hash = hash;
 226		so->used++;
 227	} else if (entry->key == dummy) {
 228		/* DUMMY */
 229		entry->key = key;
 230		entry->hash = hash;
 231		so->used++;
 232		Py_DECREF(dummy);
 233	} else {
 234		/* ACTIVE */
 235		Py_DECREF(key);
 236	}
 237	return 0;
 238}
 239
 240/*
 241Internal routine used by set_table_resize() to insert an item which is
 242known to be absent from the set.  This routine also assumes that
 243the set contains no deleted entries.  Besides the performance benefit,
 244using set_insert_clean() in set_table_resize() is dangerous (SF bug #1456209).
 245Note that no refcounts are changed by this routine; if needed, the caller
 246is responsible for incref'ing `key`.
 247*/
 248static void
 249set_insert_clean(register PySetObject *so, PyObject *key, long hash)
 250{
 251	register size_t i;
 252	register size_t perturb;
 253	register size_t mask = (size_t)so->mask;
 254	setentry *table = so->table;
 255	register setentry *entry;
 256
 257	i = hash & mask;
 258	entry = &table[i];
 259	for (perturb = hash; entry->key != NULL; perturb >>= PERTURB_SHIFT) {
 260		i = (i << 2) + i + perturb + 1;
 261		entry = &table[i & mask];
 262	}
 263	so->fill++;
 264	entry->key = key;
 265	entry->hash = hash;
 266	so->used++;
 267}
 268
 269/*
 270Restructure the table by allocating a new table and reinserting all
 271keys again.  When entries have been deleted, the new table may
 272actually be smaller than the old one.
 273*/
 274static int
 275set_table_resize(PySetObject *so, Py_ssize_t minused)
 276{
 277	Py_ssize_t newsize;
 278	setentry *oldtable, *newtable, *entry;
 279	Py_ssize_t i;
 280	int is_oldtable_malloced;
 281	setentry small_copy[PySet_MINSIZE];
 282
 283	assert(minused >= 0);
 284
 285	/* Find the smallest table size > minused. */
 286	for (newsize = PySet_MINSIZE;
 287	     newsize <= minused && newsize > 0;
 288	     newsize <<= 1)
 289		;
 290	if (newsize <= 0) {
 291		PyErr_NoMemory();
 292		return -1;
 293	}
 294
 295	/* Get space for a new table. */
 296	oldtable = so->table;
 297	assert(oldtable != NULL);
 298	is_oldtable_malloced = oldtable != so->smalltable;
 299
 300	if (newsize == PySet_MINSIZE) {
 301		/* A large table is shrinking, or we can't get any smaller. */
 302		newtable = so->smalltable;
 303		if (newtable == oldtable) {
 304			if (so->fill == so->used) {
 305				/* No dummies, so no point doing anything. */
 306				return 0;
 307			}
 308			/* We're not going to resize it, but rebuild the
 309			   table anyway to purge old dummy entries.
 310			   Subtle:  This is *necessary* if fill==size,
 311			   as set_lookkey needs at least one virgin slot to
 312			   terminate failing searches.  If fill < size, it's
 313			   merely desirable, as dummies slow searches. */
 314			assert(so->fill > so->used);
 315			memcpy(small_copy, oldtable, sizeof(small_copy));
 316			oldtable = small_copy;
 317		}
 318	}
 319	else {
 320		newtable = PyMem_NEW(setentry, newsize);
 321		if (newtable == NULL) {
 322			PyErr_NoMemory();
 323			return -1;
 324		}
 325	}
 326
 327	/* Make the set empty, using the new table. */
 328	assert(newtable != oldtable);
 329	so->table = newtable;
 330	so->mask = newsize - 1;
 331	memset(newtable, 0, sizeof(setentry) * newsize);
 332	so->used = 0;
 333	i = so->fill;
 334	so->fill = 0;
 335
 336	/* Copy the data over; this is refcount-neutral for active entries;
 337	   dummy entries aren't copied over, of course */
 338	for (entry = oldtable; i > 0; entry++) {
 339		if (entry->key == NULL) {
 340			/* UNUSED */
 341			;
 342		} else if (entry->key == dummy) {
 343			/* DUMMY */
 344			--i;
 345			assert(entry->key == dummy);
 346			Py_DECREF(entry->key);
 347		} else {
 348			/* ACTIVE */
 349			--i;
 350			set_insert_clean(so, entry->key, entry->hash);
 351		}
 352	}
 353
 354	if (is_oldtable_malloced)
 355		PyMem_DEL(oldtable);
 356	return 0;
 357}
 358
 359/* CAUTION: set_add_key/entry() must guarantee it won't resize the table */
 360
 361static int
 362set_add_entry(register PySetObject *so, setentry *entry)
 363{
 364	register Py_ssize_t n_used;
 365
 366	assert(so->fill <= so->mask);  /* at least one empty slot */
 367	n_used = so->used;
 368	Py_INCREF(entry->key);
 369	if (set_insert_key(so, entry->key, entry->hash) == -1) {
 370		Py_DECREF(entry->key);
 371		return -1;
 372	}
 373	if (!(so->used > n_used && so->fill*3 >= (so->mask+1)*2))
 374		return 0;
 375	return set_table_resize(so, so->used>50000 ? so->used*2 : so->used*4);
 376}
 377
 378static int
 379set_add_key(register PySetObject *so, PyObject *key)
 380{
 381	register long hash;
 382	register Py_ssize_t n_used;
 383
 384	if (!PyString_CheckExact(key) ||
 385	    (hash = ((PyStringObject *) key)->ob_shash) == -1) {
 386		hash = PyObject_Hash(key);
 387		if (hash == -1)
 388			return -1;
 389	}
 390	assert(so->fill <= so->mask);  /* at least one empty slot */
 391	n_used = so->used;
 392	Py_INCREF(key);
 393	if (set_insert_key(so, key, hash) == -1) {
 394		Py_DECREF(key);
 395		return -1;
 396	}
 397	if (!(so->used > n_used && so->fill*3 >= (so->mask+1)*2))
 398		return 0;
 399	return set_table_resize(so, so->used>50000 ? so->used*2 : so->used*4);
 400}
 401
 402#define DISCARD_NOTFOUND 0
 403#define DISCARD_FOUND 1
 404
 405static int
 406set_discard_entry(PySetObject *so, setentry *oldentry)
 407{	register setentry *entry;
 408	PyObject *old_key;
 409
 410	entry = (so->lookup)(so, oldentry->key, oldentry->hash);
 411	if (entry == NULL)
 412		return -1;
 413	if (entry->key == NULL  ||  entry->key == dummy)
 414		return DISCARD_NOTFOUND;
 415	old_key = entry->key;
 416	Py_INCREF(dummy);
 417	entry->key = dummy;
 418	so->used--;
 419	Py_DECREF(old_key);
 420	return DISCARD_FOUND;
 421}
 422
 423static int
 424set_discard_key(PySetObject *so, PyObject *key)
 425{
 426	register long hash;
 427	register setentry *entry;
 428	PyObject *old_key;
 429
 430	assert (PyAnySet_Check(so));
 431	if (!PyString_CheckExact(key) ||
 432	    (hash = ((PyStringObject *) key)->ob_shash) == -1) {
 433		hash = PyObject_Hash(key);
 434		if (hash == -1)
 435			return -1;
 436	}
 437	entry = (so->lookup)(so, key, hash);
 438	if (entry == NULL)
 439		return -1;
 440	if (entry->key == NULL  ||  entry->key == dummy)
 441		return DISCARD_NOTFOUND;
 442	old_key = entry->key;
 443	Py_INCREF(dummy);
 444	entry->key = dummy;
 445	so->used--;
 446	Py_DECREF(old_key);
 447	return DISCARD_FOUND;
 448}
 449
 450static int
 451set_clear_internal(PySetObject *so)
 452{
 453	setentry *entry, *table;
 454	int table_is_malloced;
 455	Py_ssize_t fill;
 456	setentry small_copy[PySet_MINSIZE];
 457#ifdef Py_DEBUG
 458	Py_ssize_t i, n;
 459	assert (PyAnySet_Check(so));
 460
 461	n = so->mask + 1;
 462	i = 0;
 463#endif
 464
 465	table = so->table;
 466	assert(table != NULL);
 467	table_is_malloced = table != so->smalltable;
 468
 469	/* This is delicate.  During the process of clearing the set,
 470	 * decrefs can cause the set to mutate.  To avoid fatal confusion
 471	 * (voice of experience), we have to make the set empty before
 472	 * clearing the slots, and never refer to anything via so->ref while
 473	 * clearing.
 474	 */
 475	fill = so->fill;
 476	if (table_is_malloced)
 477		EMPTY_TO_MINSIZE(so);
 478
 479	else if (fill > 0) {
 480		/* It's a small table with something that needs to be cleared.
 481		 * Afraid the only safe way is to copy the set entries into
 482		 * another small table first.
 483		 */
 484		memcpy(small_copy, table, sizeof(small_copy));
 485		table = small_copy;
 486		EMPTY_TO_MINSIZE(so);
 487	}
 488	/* else it's a small table that's already empty */
 489
 490	/* Now we can finally clear things.  If C had refcounts, we could
 491	 * assert that the refcount on table is 1 now, i.e. that this function
 492	 * has unique access to it, so decref side-effects can't alter it.
 493	 */
 494	for (entry = table; fill > 0; ++entry) {
 495#ifdef Py_DEBUG
 496		assert(i < n);
 497		++i;
 498#endif
 499		if (entry->key) {
 500			--fill;
 501			Py_DECREF(entry->key);
 502		}
 503#ifdef Py_DEBUG
 504		else
 505			assert(entry->key == NULL);
 506#endif
 507	}
 508
 509	if (table_is_malloced)
 510		PyMem_DEL(table);
 511	return 0;
 512}
 513
 514/*
 515 * Iterate over a set table.  Use like so:
 516 *
 517 *     Py_ssize_t pos;
 518 *     setentry *entry;
 519 *     pos = 0;   # important!  pos should not otherwise be changed by you
 520 *     while (set_next(yourset, &pos, &entry)) {
 521 *              Refer to borrowed reference in entry->key.
 522 *     }
 523 *
 524 * CAUTION:  In general, it isn't safe to use set_next in a loop that
 525 * mutates the table.  
 526 */
 527static int
 528set_next(PySetObject *so, Py_ssize_t *pos_ptr, setentry **entry_ptr)
 529{
 530	Py_ssize_t i;
 531	Py_ssize_t mask;
 532	register setentry *table;
 533
 534	assert (PyAnySet_Check(so));
 535	i = *pos_ptr;
 536	assert(i >= 0);
 537	table = so->table;
 538	mask = so->mask;
 539	while (i <= mask && (table[i].key == NULL || table[i].key == dummy))
 540		i++;
 541	*pos_ptr = i+1;
 542	if (i > mask)
 543		return 0;
 544	assert(table[i].key != NULL);
 545	*entry_ptr = &table[i];
 546	return 1;
 547}
 548
 549static void
 550set_dealloc(PySetObject *so)
 551{
 552	register setentry *entry;
 553	Py_ssize_t fill = so->fill;
 554	PyObject_GC_UnTrack(so);
 555	Py_TRASHCAN_SAFE_BEGIN(so)
 556	if (so->weakreflist != NULL)
 557		PyObject_ClearWeakRefs((PyObject *) so);
 558
 559	for (entry = so->table; fill > 0; entry++) {
 560		if (entry->key) {
 561			--fill;
 562			Py_DECREF(entry->key);
 563		}
 564	}
 565	if (so->table != so->smalltable)
 566		PyMem_DEL(so->table);
 567	if (numfree < PySet_MAXFREELIST && PyAnySet_CheckExact(so))
 568		free_list[numfree++] = so;
 569	else 
 570		Py_TYPE(so)->tp_free(so);
 571	Py_TRASHCAN_SAFE_END(so)
 572}
 573
 574static int
 575set_tp_print(PySetObject *so, FILE *fp, int flags)
 576{
 577	setentry *entry;
 578	Py_ssize_t pos=0;
 579	char *emit = "";	/* No separator emitted on first pass */
 580	char *separator = ", ";
 581	int status = Py_ReprEnter((PyObject*)so);
 582
 583	if (status != 0) {
 584		if (status < 0)
 585			return status;
 586		Py_BEGIN_ALLOW_THREADS
 587		fprintf(fp, "%s(...)", so->ob_type->tp_name);
 588		Py_END_ALLOW_THREADS
 589		return 0;
 590	}        
 591
 592	Py_BEGIN_ALLOW_THREADS
 593	fprintf(fp, "%s([", so->ob_type->tp_name);
 594	Py_END_ALLOW_THREADS
 595	while (set_next(so, &pos, &entry)) {
 596		Py_BEGIN_ALLOW_THREADS
 597		fputs(emit, fp);
 598		Py_END_ALLOW_THREADS
 599		emit = separator;
 600		if (PyObject_Print(entry->key, fp, 0) != 0) {
 601			Py_ReprLeave((PyObject*)so);
 602			return -1;
 603		}
 604	}
 605	Py_BEGIN_ALLOW_THREADS
 606	fputs("])", fp);
 607	Py_END_ALLOW_THREADS
 608	Py_ReprLeave((PyObject*)so);        
 609	return 0;
 610}
 611
 612static PyObject *
 613set_repr(PySetObject *so)
 614{
 615	PyObject *keys, *result=NULL, *listrepr;
 616	int status = Py_ReprEnter((PyObject*)so);
 617
 618	if (status != 0) {
 619		if (status < 0)
 620			return NULL;
 621		return PyString_FromFormat("%s(...)", so->ob_type->tp_name);
 622	}
 623
 624	keys = PySequence_List((PyObject *)so);
 625	if (keys == NULL)
 626		goto done;
 627	listrepr = PyObject_Repr(keys);
 628	Py_DECREF(keys);
 629	if (listrepr == NULL)
 630		goto done;
 631
 632	result = PyString_FromFormat("%s(%s)", so->ob_type->tp_name,
 633		PyString_AS_STRING(listrepr));
 634	Py_DECREF(listrepr);
 635done:
 636	Py_ReprLeave((PyObject*)so);
 637	return result;
 638}
 639
 640static Py_ssize_t
 641set_len(PyObject *so)
 642{
 643	return ((PySetObject *)so)->used;
 644}
 645
 646static int
 647set_merge(PySetObject *so, PyObject *otherset)
 648{
 649	PySetObject *other;
 650	register Py_ssize_t i;
 651	register setentry *entry;
 652
 653	assert (PyAnySet_Check(so));
 654	assert (PyAnySet_Check(otherset));
 655
 656	other = (PySetObject*)otherset;
 657	if (other == so || other->used == 0)
 658		/* a.update(a) or a.update({}); nothing to do */
 659		return 0;
 660	/* Do one big resize at the start, rather than
 661	 * incrementally resizing as we insert new keys.  Expect
 662	 * that there will be no (or few) overlapping keys.
 663	 */
 664	if ((so->fill + other->used)*3 >= (so->mask+1)*2) {
 665	   if (set_table_resize(so, (so->used + other->used)*2) != 0)
 666		   return -1;
 667	}
 668	for (i = 0; i <= other->mask; i++) {
 669		entry = &other->table[i];
 670		if (entry->key != NULL && 
 671		    entry->key != dummy) {
 672			Py_INCREF(entry->key);
 673			if (set_insert_key(so, entry->key, entry->hash) == -1) {
 674				Py_DECREF(entry->key);
 675				return -1;
 676			}
 677		}
 678	}
 679	return 0;
 680}
 681
 682static int
 683set_contains_key(PySetObject *so, PyObject *key)
 684{
 685	long hash;
 686	setentry *entry;
 687
 688	if (!PyString_CheckExact(key) ||
 689	    (hash = ((PyStringObject *) key)->ob_shash) == -1) {
 690		hash = PyObject_Hash(key);
 691		if (hash == -1)
 692			return -1;
 693	}
 694	entry = (so->lookup)(so, key, hash);
 695	if (entry == NULL)
 696		return -1;
 697	key = entry->key;
 698	return key != NULL && key != dummy;
 699}
 700
 701static int
 702set_contains_entry(PySetObject *so, setentry *entry)
 703{
 704	PyObject *key;
 705	setentry *lu_entry;
 706
 707	lu_entry = (so->lookup)(so, entry->key, entry->hash);
 708	if (lu_entry == NULL)
 709		return -1;
 710	key = lu_entry->key; 
 711	return key != NULL && key != dummy;
 712}
 713
 714static PyObject *
 715set_pop(PySetObject *so)
 716{
 717	register Py_ssize_t i = 0;
 718	register setentry *entry;
 719	PyObject *key;
 720
 721	assert (PyAnySet_Check(so));
 722	if (so->used == 0) {
 723		PyErr_SetString(PyExc_KeyError, "pop from an empty set");
 724		return NULL;
 725	}
 726
 727	/* Set entry to "the first" unused or dummy set entry.  We abuse
 728	 * the hash field of slot 0 to hold a search finger:
 729	 * If slot 0 has a value, use slot 0.
 730	 * Else slot 0 is being used to hold a search finger,
 731	 * and we use its hash value as the first index to look.
 732	 */
 733	entry = &so->table[0];
 734	if (entry->key == NULL || entry->key == dummy) {
 735		i = entry->hash;
 736		/* The hash field may be a real hash value, or it may be a
 737		 * legit search finger, or it may be a once-legit search
 738		 * finger that's out of bounds now because it wrapped around
 739		 * or the table shrunk -- simply make sure it's in bounds now.
 740		 */
 741		if (i > so->mask || i < 1)
 742			i = 1;	/* skip slot 0 */
 743		while ((entry = &so->table[i])->key == NULL || entry->key==dummy) {
 744			i++;
 745			if (i > so->mask)
 746				i = 1;
 747		}
 748	}
 749	key = entry->key;
 750	Py_INCREF(dummy);
 751	entry->key = dummy;
 752	so->used--;
 753	so->table[0].hash = i + 1;  /* next place to start */
 754	return key;
 755}
 756
 757PyDoc_STRVAR(pop_doc, "Remove and return an arbitrary set element.\n\
 758Raises KeyError if the set is empty.");
 759
 760static int
 761set_traverse(PySetObject *so, visitproc visit, void *arg)
 762{
 763	Py_ssize_t pos = 0;
 764	setentry *entry;
 765
 766	while (set_next(so, &pos, &entry))
 767		Py_VISIT(entry->key);
 768	return 0;
 769}
 770
 771static long
 772frozenset_hash(PyObject *self)
 773{
 774	PySetObject *so = (PySetObject *)self;
 775	long h, hash = 1927868237L;
 776	setentry *entry;
 777	Py_ssize_t pos = 0;
 778
 779	if (so->hash != -1)
 780		return so->hash;
 781
 782	hash *= PySet_GET_SIZE(self) + 1;
 783	while (set_next(so, &pos, &entry)) {
 784		/* Work to increase the bit dispersion for closely spaced hash
 785		   values.  The is important because some use cases have many 
 786		   combinations of a small number of elements with nearby 
 787		   hashes so that many distinct combinations collapse to only 
 788		   a handful of distinct hash values. */
 789		h = entry->hash;
 790		hash ^= (h ^ (h << 16) ^ 89869747L)  * 3644798167u;
 791	}
 792	hash = hash * 69069L + 907133923L;
 793	if (hash == -1)
 794		hash = 590923713L;
 795	so->hash = hash;
 796	return hash;
 797}
 798
 799/***** Set iterator type ***********************************************/
 800
 801typedef struct {
 802	PyObject_HEAD
 803	PySetObject *si_set; /* Set to NULL when iterator is exhausted */
 804	Py_ssize_t si_used;
 805	Py_ssize_t si_pos;
 806	Py_ssize_t len;
 807} setiterobject;
 808
 809static void
 810setiter_dealloc(setiterobject *si)
 811{
 812	Py_XDECREF(si->si_set);
 813	PyObject_GC_Del(si);
 814}
 815
 816static int
 817setiter_traverse(setiterobject *si, visitproc visit, void *arg)
 818{
 819	Py_VISIT(si->si_set);
 820	return 0;
 821}
 822
 823static PyObject *
 824setiter_len(setiterobject *si)
 825{
 826	Py_ssize_t len = 0;
 827	if (si->si_set != NULL && si->si_used == si->si_set->used)
 828		len = si->len;
 829	return PyInt_FromLong(len);
 830}
 831
 832PyDoc_STRVAR(length_hint_doc, "Private method returning an estimate of len(list(it)).");
 833
 834static PyMethodDef setiter_methods[] = {
 835	{"__length_hint__", (PyCFunction)setiter_len, METH_NOARGS, length_hint_doc},
 836 	{NULL,		NULL}		/* sentinel */
 837};
 838
 839static PyObject *setiter_iternext(setiterobject *si)
 840{
 841	PyObject *key;
 842	register Py_ssize_t i, mask;
 843	register setentry *entry;
 844	PySetObject *so = si->si_set;
 845
 846	if (so == NULL)
 847		return NULL;
 848	assert (PyAnySet_Check(so));
 849
 850	if (si->si_used != so->used) {
 851		PyErr_SetString(PyExc_RuntimeError,
 852				"Set changed size during iteration");
 853		si->si_used = -1; /* Make this state sticky */
 854		return NULL;
 855	}
 856
 857	i = si->si_pos;
 858	assert(i>=0);
 859	entry = so->table;
 860	mask = so->mask;
 861	while (i <= mask && (entry[i].key == NULL || entry[i].key == dummy))
 862		i++;
 863	si->si_pos = i+1;
 864	if (i > mask)
 865		goto fail;
 866	si->len--;
 867	key = entry[i].key;
 868	Py_INCREF(key);
 869	return key;
 870
 871fail:
 872	Py_DECREF(so);
 873	si->si_set = NULL;
 874	return NULL;
 875}
 876
 877static PyTypeObject PySetIter_Type = {
 878	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 879	"setiterator",				/* tp_name */
 880	sizeof(setiterobject),			/* tp_basicsize */
 881	0,					/* tp_itemsize */
 882	/* methods */
 883	(destructor)setiter_dealloc, 		/* tp_dealloc */
 884	0,					/* tp_print */
 885	0,					/* tp_getattr */
 886	0,					/* tp_setattr */
 887	0,					/* tp_compare */
 888	0,					/* tp_repr */
 889	0,					/* tp_as_number */
 890	0,					/* tp_as_sequence */
 891	0,					/* tp_as_mapping */
 892	0,					/* tp_hash */
 893	0,					/* tp_call */
 894	0,					/* tp_str */
 895	PyObject_GenericGetAttr,		/* tp_getattro */
 896	0,					/* tp_setattro */
 897	0,					/* tp_as_buffer */
 898	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
 899 	0,					/* tp_doc */
 900 	(traverseproc)setiter_traverse,		/* tp_traverse */
 901 	0,					/* tp_clear */
 902	0,					/* tp_richcompare */
 903	0,					/* tp_weaklistoffset */
 904	PyObject_SelfIter,			/* tp_iter */
 905	(iternextfunc)setiter_iternext,		/* tp_iternext */
 906	setiter_methods,			/* tp_methods */
 907	0,
 908};
 909
 910static PyObject *
 911set_iter(PySetObject *so)
 912{
 913	setiterobject *si = PyObject_GC_New(setiterobject, &PySetIter_Type);
 914	if (si == NULL)
 915		return NULL;
 916	Py_INCREF(so);
 917	si->si_set = so;
 918	si->si_used = so->used;
 919	si->si_pos = 0;
 920	si->len = so->used;
 921	_PyObject_GC_TRACK(si);
 922	return (PyObject *)si;
 923}
 924
 925static int
 926set_update_internal(PySetObject *so, PyObject *other)
 927{
 928	PyObject *key, *it;
 929
 930	if (PyAnySet_Check(other))
 931		return set_merge(so, other);
 932
 933	if (PyDict_CheckExact(other)) {
 934		PyObject *value;
 935		Py_ssize_t pos = 0;
 936		long hash;
 937		Py_ssize_t dictsize = PyDict_Size(other);
 938
 939		/* Do one big resize at the start, rather than
 940		* incrementally resizing as we insert new keys.  Expect
 941		* that there will be no (or few) overlapping keys.
 942		*/
 943		if (dictsize == -1)
 944			return -1;
 945		if ((so->fill + dictsize)*3 >= (so->mask+1)*2) {
 946			if (set_table_resize(so, (so->used + dictsize)*2) != 0)
 947				return -1;
 948		}
 949		while (_PyDict_Next(other, &pos, &key, &value, &hash)) {
 950			setentry an_entry;
 951
 952			an_entry.hash = hash;
 953			an_entry.key = key;
 954			if (set_add_entry(so, &an_entry) == -1)
 955				return -1;
 956		}
 957		return 0;
 958	}
 959
 960	it = PyObject_GetIter(other);
 961	if (it == NULL)
 962		return -1;
 963
 964	while ((key = PyIter_Next(it)) != NULL) {
 965                if (set_add_key(so, key) == -1) {
 966			Py_DECREF(it);
 967			Py_DECREF(key);
 968			return -1;
 969                } 
 970		Py_DECREF(key);
 971	}
 972	Py_DECREF(it);
 973	if (PyErr_Occurred())
 974		return -1;
 975	return 0;
 976}
 977
 978static PyObject *
 979set_update(PySetObject *so, PyObject *args)
 980{
 981	Py_ssize_t i;
 982
 983	for (i=0 ; i<PyTuple_GET_SIZE(args) ; i++) {
 984		PyObject *other = PyTuple_GET_ITEM(args, i);
 985		if (set_update_internal(so, other) == -1)
 986			return NULL;
 987	}
 988	Py_RETURN_NONE;
 989}
 990
 991PyDoc_STRVAR(update_doc, 
 992"Update a set with the union of itself and others.");
 993
 994static PyObject *
 995make_new_set(PyTypeObject *type, PyObject *iterable)
 996{
 997	register PySetObject *so = NULL;
 998
 999	if (dummy == NULL) { /* Auto-initialize dummy */
1000		dummy = PyString_FromString("<dummy key>");
1001		if (dummy == NULL)
1002			return NULL;
1003	}
1004
1005	/* create PySetObject structure */
1006	if (numfree &&
1007	    (type == &PySet_Type  ||  type == &PyFrozenSet_Type)) {
1008		so = free_list[--numfree];
1009		assert (so != NULL && PyAnySet_CheckExact(so));
1010		Py_TYPE(so) = type;
1011		_Py_NewReference((PyObject *)so);
1012		EMPTY_TO_MINSIZE(so);
1013		PyObject_GC_Track(so);
1014	} else {
1015		so = (PySetObject *)type->tp_alloc(type, 0);
1016		if (so == NULL)
1017			return NULL;
1018		/* tp_alloc has already zeroed the structure */
1019		assert(so->table == NULL && so->fill == 0 && so->used == 0);
1020		INIT_NONZERO_SET_SLOTS(so);
1021	}
1022
1023	so->lookup = set_lookkey_string;
1024	so->weakreflist = NULL;
1025
1026	if (iterable != NULL) {
1027		if (set_update_internal(so, iterable) == -1) {
1028			Py_DECREF(so);
1029			return NULL;
1030		}
1031	}
1032
1033	return (PyObject *)so;
1034}
1035
1036/* The empty frozenset is a singleton */
1037static PyObject *emptyfrozenset = NULL;
1038
1039static PyObject *
1040frozenset_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
1041{
1042	PyObject *iterable = NULL, *result;
1043
1044	if (type == &PyFrozenSet_Type && !_PyArg_NoKeywords("frozenset()", kwds))
1045		return NULL;
1046
1047	if (!PyArg_UnpackTuple(args, type->tp_name, 0, 1, &iterable))
1048		return NULL;
1049
1050	if (type != &PyFrozenSet_Type)
1051		return make_new_set(type, iterable);
1052
1053	if (iterable != NULL) {
1054		/* frozenset(f) is idempotent */
1055		if (PyFrozenSet_CheckExact(iterable)) {
1056			Py_INCREF(iterable);
1057			return iterable;
1058		}
1059		result = make_new_set(type, iterable);
1060		if (result == NULL || PySet_GET_SIZE(result))
1061			return result;
1062		Py_DECREF(result);
1063	}
1064	/* The empty frozenset is a singleton */
1065	if (emptyfrozenset == NULL)
1066		emptyfrozenset = make_new_set(type, NULL);
1067	Py_XINCREF(emptyfrozenset);
1068	return emptyfrozenset;
1069}
1070
1071void
1072PySet_Fini(void)
1073{
1074	PySetObject *so;
1075
1076	while (numfree) {
1077		numfree--;
1078		so = free_list[numfree];
1079		PyObject_GC_Del(so);
1080	}
1081	Py_CLEAR(dummy);
1082	Py_CLEAR(emptyfrozenset);
1083}
1084
1085static PyObject *
1086set_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
1087{
1088	if (type == &PySet_Type && !_PyArg_NoKeywords("set()", kwds))
1089		return NULL;
1090	
1091	return make_new_set(type, NULL);
1092}
1093
1094/* set_swap_bodies() switches the contents of any two sets by moving their
1095   internal data pointers and, if needed, copying the internal smalltables.
1096   Semantically equivalent to:
1097
1098     t=set(a); a.clear(); a.update(b); b.clear(); b.update(t); del t
1099
1100   The function always succeeds and it leaves both objects in a stable state.
1101   Useful for creating temporary frozensets from sets for membership testing 
1102   in __contains__(), discard(), and remove().  Also useful for operations
1103   that update in-place (by allowing an intermediate result to be swapped 
1104   into one of the original inputs).
1105*/
1106
1107static void
1108set_swap_bodies(PySetObject *a, PySetObject *b)
1109{
1110	Py_ssize_t t;
1111	setentry *u;
1112	setentry *(*f)(PySetObject *so, PyObject *key, long hash);
1113	setentry tab[PySet_MINSIZE];
1114	long h;
1115
1116	t = a->fill;     a->fill   = b->fill;        b->fill  = t;
1117	t = a->used;     a->used   = b->used;        b->used  = t;
1118	t = a->mask;     a->mask   = b->mask;        b->mask  = t;
1119
1120	u = a->table;
1121	if (a->table == a->smalltable)
1122		u = b->smalltable;
1123	a->table  = b->table;
1124	if (b->table == b->smalltable)
1125		a->table = a->smalltable;
1126	b->table = u;
1127
1128	f = a->lookup;   a->lookup = b->lookup;      b->lookup = f;
1129
1130	if (a->table == a->smalltable || b->table == b->smalltable) {
1131		memcpy(tab, a->smalltable, sizeof(tab));
1132		memcpy(a->smalltable, b->smalltable, sizeof(tab));
1133		memcpy(b->smalltable, tab, sizeof(tab));
1134	}
1135
1136	if (PyType_IsSubtype(Py_TYPE(a), &PyFrozenSet_Type)  &&
1137	    PyType_IsSubtype(Py_TYPE(b), &PyFrozenSet_Type)) {
1138		h = a->hash;     a->hash = b->hash;  b->hash = h;
1139	} else {
1140		a->hash = -1;
1141		b->hash = -1;
1142	}
1143}
1144
1145static PyObject *
1146set_copy(PySetObject *so)
1147{
1148	return make_new_set(Py_TYPE(so), (PyObject *)so);
1149}
1150
1151static PyObject *
1152frozenset_copy(PySetObject *so)
1153{
1154	if (PyFrozenSet_CheckExact(so)) {
1155		Py_INCREF(so);
1156		return (PyObject *)so;
1157	}
1158	return set_copy(so);
1159}
1160
1161PyDoc_STRVAR(copy_doc, "Return a shallow copy of a set.");
1162
1163static PyObject *
1164set_clear(PySetObject *so)
1165{
1166	set_clear_internal(so);
1167	Py_RETURN_NONE;
1168}
1169
1170PyDoc_STRVAR(clear_doc, "Remove all elements from this set.");
1171
1172static PyObject *
1173set_union(PySetObject *so, PyObject *args)
1174{
1175	PySetObject *result;
1176	PyObject *other;
1177	Py_ssize_t i;
1178
1179	result = (PySetObject *)set_copy(so);
1180	if (result == NULL)
1181		return NULL;
1182
1183	for (i=0 ; i<PyTuple_GET_SIZE(args) ; i++) {
1184		other = PyTuple_GET_ITEM(args, i);
1185		if ((PyObject *)so == other)
1186			continue;
1187		if (set_update_internal(result, other) == -1) {
1188			Py_DECREF(result);
1189			return NULL;
1190		}
1191	}
1192	return (PyObject *)result;
1193}
1194
1195PyDoc_STRVAR(union_doc,
1196 "Return the union of sets as a new set.\n\
1197\n\
1198(i.e. all elements that are in either set.)");
1199
1200static PyObject *
1201set_or(PySetObject *so, PyObject *other)
1202{
1203	PySetObject *result;
1204
1205	if (!PyAnySet_Check(so) || !PyAnySet_Check(other)) {
1206		Py_INCREF(Py_NotImplemented);
1207		return Py_NotImplemented;
1208	}
1209
1210	result = (PySetObject *)set_copy(so);
1211	if (result == NULL)
1212		return NULL;
1213	if ((PyObject *)so == other)
1214		return (PyObject *)result;
1215	if (set_update_internal(result, other) == -1) {
1216		Py_DECREF(result);
1217		return NULL;
1218	}
1219	return (PyObject *)result;
1220}
1221
1222static PyObject *
1223set_ior(PySetObject *so, PyObject *other)
1224{
1225	if (!PyAnySet_Check(other)) {
1226		Py_INCREF(Py_NotImplemented);
1227		return Py_NotImplemented;
1228	}
1229	if (set_update_internal(so, other) == -1)
1230		return NULL;
1231	Py_INCREF(so);
1232	return (PyObject *)so;
1233}
1234
1235static PyObject *
1236set_intersection(PySetObject *so, PyObject *other)
1237{
1238	PySetObject *result;
1239	PyObject *key, *it, *tmp;
1240
1241	if ((PyObject *)so == other)
1242		return set_copy(so);
1243
1244	result = (PySetObject *)make_new_set(Py_TYPE(so), NULL);
1245	if (result == NULL)
1246		return NULL;
1247
1248	if (PyAnySet_Check(other)) {		
1249		Py_ssize_t pos = 0;
1250		setentry *entry;
1251
1252		if (PySet_GET_SIZE(other) > PySet_GET_SIZE(so)) {
1253			tmp = (PyObject *)so;
1254			so = (PySetObject *)other;
1255			other = tmp;
1256		}
1257
1258		while (set_next((PySetObject *)other, &pos, &entry)) {
1259			int rv = set_contains_entry(so, entry);
1260			if (rv == -1) {
1261				Py_DECREF(result);
1262				return NULL;
1263			}
1264			if (rv) {
1265				if (set_add_entry(result, entry) == -1) {
1266					Py_DECREF(result);
1267					return NULL;
1268				}
1269			}
1270		}
1271		return (PyObject *)result;
1272	}
1273
1274	it = PyObject_GetIter(other);
1275	if (it == NULL) {
1276		Py_DECREF(result);
1277		return NULL;
1278	}
1279
1280	while ((key = PyIter_Next(it)) != NULL) {
1281		int rv;
1282		setentry entry;
1283		long hash = PyObject_Hash(key);
1284
1285		if (hash == -1) {
1286			Py_DECREF(it);
1287			Py_DECREF(result);
1288			Py_DECREF(key);
1289			return NULL;
1290		}
1291		entry.hash = hash;
1292		entry.key = key;
1293		rv = set_contains_entry(so, &entry);
1294		if (rv == -1) {
1295			Py_DECREF(it);
1296			Py_DECREF(result);
1297			Py_DECREF(key);
1298			return NULL;
1299		}
1300		if (rv) {
1301			if (set_add_entry(result, &entry) == -1) {
1302				Py_DECREF(it);
1303				Py_DECREF(result);
1304				Py_DECREF(key);
1305				return NULL;
1306			}
1307		}
1308		Py_DECREF(key);
1309	}
1310	Py_DECREF(it);
1311	if (PyErr_Occurred()) {
1312		Py_DECREF(result);
1313		return NULL;
1314	}
1315	return (PyObject *)result;
1316}
1317
1318static PyObject *
1319set_intersection_multi(PySetObject *so, PyObject *args)
1320{
1321	Py_ssize_t i;
1322	PyObject *result = (PyObject *)so;
1323
1324	if (PyTuple_GET_SIZE(args) == 0)
1325		return set_copy(so);
1326
1327	Py_INCREF(so);
1328	for (i=0 ; i<PyTuple_GET_SIZE(args) ; i++) {
1329		PyObject *other = PyTuple_GET_ITEM(args, i);
1330		PyObject *newresult = set_intersection((PySetObject *)result, other);
1331		if (newresult == NULL) {
1332			Py_DECREF(result);
1333			return NULL;
1334		}
1335		Py_DECREF(result);
1336		result = newresult;
1337	}
1338	return result;
1339}
1340
1341PyDoc_STRVAR(intersection_doc,
1342"Return the intersection of two sets as a new set.\n\
1343\n\
1344(i.e. all elements that are in both sets.)");
1345
1346static PyObject *
1347set_intersection_update(PySetObject *so, PyObject *other)
1348{
1349	PyObject *tmp;
1350
1351	tmp = set_intersection(so, other);
1352	if (tmp == NULL)
1353		return NULL;
1354	set_swap_bodies(so, (PySetObject *)tmp);
1355	Py_DECREF(tmp);
1356	Py_RETURN_NONE;
1357}
1358
1359static PyObject *
1360set_intersection_update_multi(PySetObject *so, PyObject *args)
1361{
1362	PyObject *tmp;
1363
1364	tmp = set_intersection_multi(so, args);
1365	if (tmp == NULL)
1366		return NULL;
1367	set_swap_bodies(so, (PySetObject *)tmp);
1368	Py_DECREF(tmp);
1369	Py_RETURN_NONE;
1370}
1371
1372PyDoc_STRVAR(intersection_update_doc,
1373"Update a set with the intersection of itself and another.");
1374
1375static PyObject *
1376set_and(PySetObject *so, PyObject *other)
1377{
1378	if (!PyAnySet_Check(so) || !PyAnySet_Check(other)) {
1379		Py_INCREF(Py_NotImplemented);
1380		return Py_NotImplemented;
1381	}
1382	return set_intersection(so, other);
1383}
1384
1385static PyObject *
1386set_iand(PySetObject *so, PyObject *other)
1387{
1388	PyObject *result;
1389
1390	if (!PyAnySet_Check(other)) {
1391		Py_INCREF(Py_NotImplemented);
1392		return Py_NotImplemented;
1393	}
1394	result = set_intersection_update(so, other);
1395	if (result == NULL)
1396		return NULL;
1397	Py_DECREF(result);
1398	Py_INCREF(so);
1399	return (PyObject *)so;
1400}
1401
1402static PyObject *
1403set_isdisjoint(PySetObject *so, PyObject *other)
1404{
1405	PyObject *key, *it, *tmp;
1406
1407	if ((PyObject *)so == other) {
1408		if (PySet_GET_SIZE(so) == 0)
1409			Py_RETURN_TRUE;
1410		else
1411			Py_RETURN_FALSE;
1412	}
1413
1414	if (PyAnySet_CheckExact(other)) {		
1415		Py_ssize_t pos = 0;
1416		setentry *entry;
1417
1418		if (PySet_GET_SIZE(other) > PySet_GET_SIZE(so)) {
1419			tmp = (PyObject *)so;
1420			so = (PySetObject *)other;
1421			other = tmp;
1422		}
1423		while (set_next((PySetObject *)other, &pos, &entry)) {
1424			int rv = set_contains_entry(so, entry);
1425			if (rv == -1)
1426				return NULL;
1427			if (rv)
1428				Py_RETURN_FALSE;
1429		}
1430		Py_RETURN_TRUE;
1431	}
1432
1433	it = PyObject_GetIter(other);
1434	if (it == NULL)
1435		return NULL;
1436
1437	while ((key = PyIter_Next(it)) != NULL) {
1438		int rv;
1439		setentry entry;
1440		long hash = PyObject_Hash(key);
1441
1442		if (hash == -1) {
1443			Py_DECREF(key);
1444			Py_DECREF(it);
1445			return NULL;
1446		}
1447		entry.hash = hash;
1448		entry.key = key;
1449		rv = set_contains_entry(so, &entry);
1450		Py_DECREF(key);
1451		if (rv == -1) {
1452			Py_DECREF(it);
1453			return NULL;
1454		}
1455		if (rv) {
1456			Py_DECREF(it);
1457			Py_RETURN_FALSE;
1458		}
1459	}
1460	Py_DECREF(it);
1461	if (PyErr_Occurred())
1462		return NULL;
1463	Py_RETURN_TRUE;
1464}
1465
1466PyDoc_STRVAR(isdisjoint_doc,
1467"Return True if two sets have a null intersection.");
1468
1469static int
1470set_difference_update_internal(PySetObject *so, PyObject *other)
1471{
1472	if ((PyObject *)so == other)
1473		return set_clear_internal(so);
1474	
1475	if (PyAnySet_Check(other)) {
1476		setentry *entry;
1477		Py_ssize_t pos = 0;
1478
1479		while (set_next((PySetObject *)other, &pos, &entry))
1480			if (set_discard_entry(so, entry) == -1)
1481				return -1;
1482	} else {
1483		PyObject *key, *it;
1484		it = PyObject_GetIter(other);
1485		if (it == NULL)
1486			return -1;
1487
1488		while ((key = PyIter_Next(it)) != NULL) {
1489			if (set_discard_key(so, key) == -1) {
1490				Py_DECREF(it);
1491				Py_DECREF(key);
1492				return -1;
1493			}
1494			Py_DECREF(key);
1495		}
1496		Py_DECREF(it);
1497		if (PyErr_Occurred())
1498			return -1;
1499	}
1500	/* If more than 1/5 are dummies, then resize them away. */
1501	if ((so->fill - so->used) * 5 < so->mask)
1502		return 0;
1503	return set_table_resize(so, so->used>50000 ? so->used*2 : so->used*4);
1504}
1505
1506static PyObject *
1507set_difference_update(PySetObject *so, PyObject *args)
1508{
1509	Py_ssize_t i;
1510
1511	for (i=0 ; i<PyTuple_GET_SIZE(args) ; i++) {
1512		PyObject *other = PyTuple_GET_ITEM(args, i);
1513		if (set_difference_update_internal(so, other) == -1)
1514			return NULL;
1515	}
1516	Py_RETURN_NONE;
1517}
1518
1519PyDoc_STRVAR(difference_update_doc,
1520"Remove all elements of another set from this set.");
1521
1522static PyObject *
1523set_difference(PySetObject *so, PyObject *other)
1524{
1525	PyObject *result;
1526	setentry *entry;
1527	Py_ssize_t pos = 0;
1528
1529	if (!PyAnySet_Check(other)  && !PyDict_CheckExact(other)) {
1530		result = set_copy(so);
1531		if (result == NULL)
1532			return NULL;
1533		if (set_difference_update_internal((PySetObject *)result, other) != -1)
1534			return result;
1535		Py_DECREF(result);
1536		return NULL;
1537	}
1538	
1539	result = make_new_set(Py_TYPE(so), NULL);
1540	if (result == NULL)
1541		return NULL;
1542
1543	if (PyDict_CheckExact(other)) {
1544		while (set_next(so, &pos, &entry)) {
1545			setentry entrycopy;
1546			entrycopy.hash = entry->hash;
1547			entrycopy.key = entry->key;
1548			if (!_PyDict_Contains(other, entry->key, entry->hash)) {
1549				if (set_add_entry((PySetObject *)result, &entrycopy) == -1) {
1550					Py_DECREF(result);
1551					return NULL;
1552				}
1553			}
1554		}
1555		return result;
1556	}
1557
1558	while (set_next(so, &pos, &entry)) {
1559		int rv = set_contains_entry((PySetObject *)other, entry);
1560		if (rv == -1) {
1561			Py_DECREF(result);
1562			return NULL;
1563		}
1564		if (!rv) {
1565			if (set_add_entry((PySetObject *)result, entry) == -1) {
1566				Py_DECREF(result);
1567				return NULL;
1568			}
1569		}
1570	}
1571	return result;
1572}
1573
1574static PyObject *
1575set_difference_multi(PySetObject *so, PyObject *args)
1576{
1577	Py_ssize_t i;
1578	PyObject *result, *other;
1579
1580	if (PyTuple_GET_SIZE(args) == 0)
1581		return set_copy(so);
1582
1583	other = PyTuple_GET_ITEM(args, 0);
1584	result = set_difference(so, other);
1585	if (result == NULL)
1586		return NULL;
1587
1588	for (i=1 ; i<PyTuple_GET_SIZE(args) ; i++) {
1589		other = PyTuple_GET_ITEM(args, i);
1590		if (set_difference_update_internal((PySetObject *)result, other) == -1) {
1591			Py_DECREF(result);
1592			return NULL;
1593		}
1594	}
1595	return result;
1596}
1597
1598PyDoc_STRVAR(difference_doc,
1599"Return the difference of two or more sets as a new set.\n\
1600\n\
1601(i.e. all elements that are in this set but not the others.)");
1602static PyObject *
1603set_sub(PySetObject *so, PyObject *other)
1604{
1605	if (!PyAnySet_Check(so) || !PyAnySet_Check(other)) {
1606		Py_INCREF(Py_NotImplemented);
1607		return Py_NotImplemented;
1608	}
1609	return set_difference(so, other);
1610}
1611
1612static PyObject *
1613set_isub(PySetObject *so, PyObject *other)
1614{
1615	if (!PyAnySet_Check(other)) {
1616		Py_INCREF(Py_NotImplemented);
1617		return Py_NotImplemented;
1618	}
1619	if (set_difference_update_internal(so, other) == -1)
1620		return NULL;
1621	Py_INCREF(so);
1622	return (PyObject *)so;
1623}
1624
1625static PyObject *
1626set_symmetric_difference_update(PySetObject *so, PyObject *other)
1627{
1628	PySetObject *otherset;
1629	PyObject *key;
1630	Py_ssize_t pos = 0;
1631	setentry *entry;
1632
1633	if ((PyObject *)so == other)
1634		return set_clear(so);
1635
1636	if (PyDict_CheckExact(other)) {
1637		PyObject *value;
1638		int rv;
1639		long hash;
1640		while (_PyDict_Next(other, &pos, &key, &value, &hash)) {
1641			setentry an_entry;
1642
1643			an_entry.hash = hash;
1644			an_entry.key = key;
1645			rv = set_discard_entry(so, &an_entry);
1646			if (rv == -1)
1647				return NULL;
1648			if (rv == DISCARD_NOTFOUND) {
1649				if (set_add_entry(so, &an_entry) == -1)
1650					return NULL;
1651			}
1652		}
1653		Py_RETURN_NONE;
1654	}
1655
1656	if (PyAnySet_Check(other)) {
1657		Py_INCREF(other);
1658		otherset = (PySetObject *)other;
1659	} else {
1660		otherset = (PySetObject *)make_new_set(Py_TYPE(so), other);
1661		if (otherset == NULL)
1662			return NULL;
1663	}
1664
1665	while (set_next(otherset, &pos, &entry)) {
1666		int rv = set_discard_entry(so, entry);
1667		if (rv == -1) {
1668			Py_DECREF(otherset);
1669			return NULL;
1670		}
1671		if (rv == DISCARD_NOTFOUND) {
1672			if (set_add_entry(so, entry) == -1) {
1673				Py_DECREF(otherset);
1674				return NULL;
1675			}
1676		}
1677	}
1678	Py_DECREF(otherset);
1679	Py_RETURN_NONE;
1680}
1681
1682PyDoc_STRVAR(symmetric_difference_update_doc,
1683"Update a set with the symmetric difference of itself and another.");
1684
1685static PyObject *
1686set_symmetric_difference(PySetObject *so, PyObject *other)
1687{
1688	PyObject *rv;
1689	PySetObject *otherset;
1690
1691	otherset = (PySetObject *)make_new_set(Py_TYPE(so), other);
1692	if (otherset == NULL)
1693		return NULL;
1694	rv = set_symmetric_difference_update(otherset, (PyObject *)so);
1695	if (rv == NULL)
1696		return NULL;
1697	Py_DECREF(rv);
1698	return (PyObject *)otherset;
1699}
1700
1701PyDoc_STRVAR(symmetric_difference_doc,
1702"Return the symmetric difference of two sets as a new set.\n\
1703\n\
1704(i.e. all elements that are in exactly one of the sets.)");
1705
1706static PyObject *
1707set_xor(PySetObject *so, PyObject *other)
1708{
1709	if (!PyAnySet_Check(so) || !PyAnySet_Check(other)) {
1710		Py_INCREF(Py_NotImplemented);
1711		return Py_NotImplemented;
1712	}
1713	return set_symmetric_difference(so, other);
1714}
1715
1716static PyObject *
1717set_ixor(PySetObject *so, PyObject *other)
1718{
1719	PyObject *result;
1720
1721	if (!PyAnySet_Check(other)) {
1722		Py_INCREF(Py_NotImplemented);
1723		return Py_NotImplemented;
1724	}
1725	result = set_symmetric_difference_update(so, other);
1726	if (result == NULL)
1727		return NULL;
1728	Py_DECREF(result);
1729	Py_INCREF(so);
1730	return (PyObject *)so;
1731}
1732
1733static PyObject *
1734set_issubset(PySetObject *so, PyObject *other)
1735{
1736	setentry *entry;
1737	Py_ssize_t pos = 0;
1738
1739	if (!PyAnySet_Check(other)) {
1740		PyObject *tmp, *result;
1741		tmp = make_new_set(&PySet_Type, other);
1742		if (tmp == NULL)
1743			return NULL;
1744		result = set_issubset(so, tmp);
1745		Py_DECREF(tmp);
1746		return result;
1747	}
1748	if (PySet_GET_SIZE(so) > PySet_GET_SIZE(other)) 
1749		Py_RETURN_FALSE;
1750
1751	while (set_next(so, &pos, &entry)) {
1752		int rv = set_contains_entry((PySetObject *)other, entry);
1753		if (rv == -1)
1754			return NULL;
1755		if (!rv)
1756			Py_RETURN_FALSE;
1757	}
1758	Py_RETURN_TRUE;
1759}
1760
1761PyDoc_STRVAR(issubset_doc, "Report whether another set contains this set.");
1762
1763static PyObject *
1764set_issuperset(PySetObject *so, PyObject *other)
1765{
1766	PyObject *tmp, *result;
1767
1768	if (!PyAnySet_Check(other)) {
1769		tmp = make_new_set(&PySet_Type, other);
1770		if (tmp == NULL)
1771			return NULL;
1772		result = set_issuperset(so, tmp);
1773		Py_DECREF(tmp);
1774		return result;
1775	}
1776	return set_issubset((PySetObject *)other, (PyObject *)so);
1777}
1778
1779PyDoc_STRVAR(issuperset_doc, "Report whether this set contains another set.");
1780
1781static PyObject *
1782set_richcompare(PySetObject *v, PyObject *w, int op)
1783{
1784	PyObject *r1, *r2;
1785
1786	if(!PyAnySet_Check(w)) {
1787		if (op == Py_EQ)
1788			Py_RETURN_FALSE;
1789		if (op == Py_NE)
1790			Py_RETURN_TRUE;
1791		PyErr_SetString(PyExc_TypeError, "can only compare to a set");
1792		return NULL;
1793	}
1794	switch (op) {
1795	case Py_EQ:
1796		if (PySet_GET_SIZE(v) != PySet_GET_SIZE(w))
1797			Py_RETURN_FALSE;
1798		if (v->hash != -1  &&
1799		    ((PySetObject *)w)->hash != -1 &&
1800		    v->hash != ((PySetObject *)w)->hash)
1801			Py_RETURN_FALSE;
1802		return set_issubset(v, w);
1803	case Py_NE:
1804		r1 = set_richcompare(v, w, Py_EQ);
1805		if (r1 == NULL)
1806			return NULL;
1807		r2 = PyBool_FromLong(PyObject_Not(r1));
1808		Py_DECREF(r1);
1809		return r2;
1810	case Py_LE:
1811		return set_issubset(v, w);
1812	case Py_GE:
1813		return set_issuperset(v, w);
1814	case Py_LT:
1815		if (PySet_GET_SIZE(v) >= PySet_GET_SIZE(w))
1816			Py_RETURN_FALSE;		
1817		return set_issubset(v, w);
1818	case Py_GT:
1819		if (PySet_GET_SIZE(v) <= PySet_GET_SIZE(w))
1820			Py_RETURN_FALSE;
1821		return set_issuperset(v, w);
1822	}
1823	Py_INCREF(Py_NotImplemented);
1824	return Py_NotImplemented;
1825}
1826
1827static int
1828set_nocmp(PyObject *self, PyObject *other)
1829{
1830	PyErr_SetString(PyExc_TypeError, "cannot compare sets using cmp()");
1831	return -1;
1832}
1833
1834static PyObject *
1835set_add(PySetObject *so, PyObject *key)
1836{
1837	if (set_add_key(so, key) == -1)
1838		return NULL;
1839	Py_RETURN_NONE;
1840}
1841
1842PyDoc_STRVAR(add_doc, 
1843"Add an element to a set.\n\
1844\n\
1845This has no effect if the element is already present.");
1846
1847static int
1848set_contains(PySetObject *so, PyObject *key)
1849{
1850	PyObject *tmpkey;
1851	int rv;
1852
1853	rv = set_contains_key(so, key);
1854	if (rv == -1) {
1855		if (!PySet_Check(key) || !PyErr_ExceptionMatches(PyExc_TypeError))
1856			return -1;
1857		PyErr_Clear();
1858		tmpkey = make_new_set(&PyFrozenSet_Type, NULL);
1859		if (tmpkey == NULL)
1860			return -1;
1861		set_swap_bodies((PySetObject *)tmpkey, (PySetObject *)key);
1862		rv = set_contains(so, tmpkey);
1863		set_swap_bodies((PySetObject *)tmpkey, (PySetObject *)key);
1864		Py_DECREF(tmpkey);
1865	}
1866	return rv;
1867}
1868
1869static PyObject *
1870set_direct_contains(PySetObject *so, PyObject *key)
1871{
1872	long result;
1873
1874	result = set_contains(so, key);
1875	if (result == -1)
1876		return NULL;
1877	return PyBool_FromLong(result);
1878}
1879
1880PyDoc_STRVAR(contains_doc, "x.__contains__(y) <==> y in x.");
1881
1882static PyObject *
1883set_remove(PySetObject *so, PyObject *key)
1884{
1885	PyObject *tmpkey;
1886	int rv;
1887
1888	rv = set_discard_key(so, key);
1889	if (rv == -1) {
1890		if (!PySet_Check(key) || !PyErr_ExceptionMatches(PyExc_TypeError))
1891			return NULL;
1892		PyErr_Clear();
1893		tmpkey = make_new_set(&PyFrozenSet_Type, NULL);
1894		if (tmpkey == NULL)
1895			return NULL;
1896		set_swap_bodies((PySetObject *)tmpkey, (PySetObject *)key);
1897		rv = set_discard_key(so, tmpkey);
1898		set_swap_bodies((PySetObject *)tmpkey, (PySetObject *)key);
1899		Py_DECREF(tmpkey);
1900		if (rv == -1)
1901			return NULL;
1902	} 
1903
1904	if (rv == DISCARD_NOTFOUND) {
1905		set_key_error(key);
1906		return NULL;
1907	}
1908	Py_RETURN_NONE;
1909}
1910
1911PyDoc_STRVAR(remove_doc,
1912"Remove an element from a set; it must be a member.\n\
1913\n\
1914If the element is not a member, raise a KeyError.");
1915
1916static PyObject *
1917set_discard(PySetObject *so, PyObject *key)
1918{
1919	PyObject *tmpkey, *result;
1920	int rv;
1921
1922	rv = set_discard_key(so, key);
1923	if (rv == -1) {
1924		if (!PySet_Check(key) || !PyErr_ExceptionMatches(PyExc_TypeError))
1925			return NULL;
1926		PyErr_Clear();
1927		tmpkey = make_new_set(&PyFrozenSet_Type, NULL);
1928		if (tmpkey == NULL)
1929			return NULL;
1930		set_swap_bodies((PySetObject *)tmpkey, (PySetObject *)key);
1931		result = set_discard(so, tmpkey);
1932		set_swap_bodies((PySetObject *)tmpkey, (PySetObject *)key);
1933		Py_DECREF(tmpkey);
1934		return result;
1935	}
1936	Py_RETURN_NONE;
1937}
1938
1939PyDoc_STRVAR(discard_doc,
1940"Remove an element from a set if it is a member.\n\
1941\n\
1942If the element is not a member, do nothing."); 
1943
1944static PyObject *
1945set_reduce(PySetObject *so)
1946{
1947	PyObject *keys=NULL, *args=NULL, *result=NULL, *dict=NULL;
1948
1949	keys = PySequence_List((PyObject *)so);
1950	if (keys == NULL)
1951		goto done;
1952	args = PyTuple_Pack(1, keys);
1953	if (args == NULL)
1954		goto done;
1955	dict = PyObject_GetAttrString((PyObject *)so, "__dict__");
1956	if (dict == NULL) {
1957		PyErr_Clear();
1958		dict = Py_None;
1959		Py_INCREF(dict);
1960	}
1961	result = PyTuple_Pack(3, Py_TYPE(so), args, dict);
1962done:
1963	Py_XDECREF(args);
1964	Py_XDECREF(keys);
1965	Py_XDECREF(dict);
1966	return result;
1967}
1968
1969PyDoc_STRVAR(reduce_doc, "Return state information for pickling.");
1970
1971static PyObject *
1972set_sizeof(PySetObject *so)
1973{
1974	Py_ssize_t res;
1975
1976	res = sizeof(PySetObject);
1977	if (so->table != so->smalltable)
1978		res = res + (so->mask + 1) * sizeof(setentry);
1979	return PyInt_FromSsize_t(res);
1980}
1981
1982PyDoc_STRVAR(sizeof_doc, "S.__sizeof__() -> size of S in memory, in bytes");
1983static int
1984set_init(PySetObject *self, PyObject *args, PyObject *kwds)
1985{
1986	PyObject *iterable = NULL;
1987
1988	if (!PyAnySet_Check(self))
1989		return -1;
1990	if (!PyArg_UnpackTuple(args, Py_TYPE(self)->tp_name, 0, 1, &iterable))
1991		return -1;
1992	set_clear_internal(self);
1993	self->hash = -1;
1994	if (iterable == NULL)
1995		return 0;
1996	return set_update_internal(self, iterable);
1997}
1998
1999static PySequenceMethods set_as_sequence = {
2000	set_len,			/* sq_length */
2001	0,				/* sq_concat */
2002	0,				/* sq_repeat */
2003	0,				/* sq_item */
2004	0,				/* sq_slice */
2005	0,				/* sq_ass_item */
2006	0,				/* sq_ass_slice */
2007	(objobjproc)set_contains,	/* sq_contains */
2008};
2009
2010/* set object ********************************************************/
2011
2012#ifdef Py_DEBUG
2013static PyObject *test_c_api(PySetObject *so);
2014
2015PyDoc_STRVAR(test_c_api_doc, "Exercises C API.  Returns True.\n\
2016All is well if assertions don't fail.");
2017#endif
2018
2019static PyMethodDef set_methods[] = {
2020	{"add",		(PyCFunction)set_add,		METH_O,
2021	 add_doc},
2022	{"clear",	(PyCFunction)set_clear,		METH_NOARGS,
2023	 clear_doc},
2024	{"__contains__",(PyCFunction)set_direct_contains,	METH_O | METH_COEXIST,
2025	 contains_doc},
2026	{"copy",	(PyCFunction)set_copy,		METH_NOARGS,
2027	 copy_doc},
2028	{"discard",	(PyCFunction)set_discard,	METH_O,
2029	 discard_doc},
2030	{"difference",	(PyCFunction)set_difference_multi,	METH_VARARGS,
2031	 difference_doc},
2032	{"difference_update",	(PyCFunction)set_difference_update,	METH_VARARGS,
2033	 difference_update_doc},
2034	{"intersection",(PyCFunction)set_intersection_multi,	METH_VARARGS,
2035	 intersection_doc},
2036	{"intersection_update",(PyCFunction)set_intersection_update_multi,	METH_VARARGS,
2037	 intersection_update_doc},
2038	{"isdisjoint",	(PyCFunction)set_isdisjoint,	METH_O,
2039	 isdisjoint_doc},
2040	{"issubset",	(PyCFunction)set_issubset,	METH_O,
2041	 issubset_doc},
2042	{"issuperset",	(PyCFunction)set_issuperset,	METH_O,
2043	 issuperset_doc},
2044	{"pop",		(PyCFunction)set_pop,		METH_NOARGS,
2045	 pop_doc},
2046	{"__reduce__",	(PyCFunction)set_reduce,	METH_NOARGS,
2047	 reduce_doc},
2048	{"remove",	(PyCFunction)set_remove,	METH_O,
2049	 remove_doc},
2050	{"__sizeof__",	(PyCFunction)set_sizeof,	METH_NOARGS,
2051	 sizeof_doc},
2052	{"symmetric_difference",(PyCFunction)set_symmetric_difference,	METH_O,
2053	 symmetric_difference_doc},
2054	{"symmetric_difference_update",(PyCFunction)set_symmetric_difference_update,	METH_O,
2055	 symmetric_difference_update_doc},
2056#ifdef Py_DEBUG
2057	{"test_c_api",	(PyCFunction)test_c_api,	METH_NOARGS,
2058	 test_c_api_doc},
2059#endif
2060	{"union",	(PyCFunction)set_union,		METH_VARARGS,
2061	 union_doc},
2062	{"update",	(PyCFunction)set_update,	METH_VARARGS,
2063	 update_doc},
2064	{NULL,		NULL}	/* sentinel */
2065};
2066
2067static PyNumberMethods set_as_number = {
2068	0,				/*nb_add*/
2069	(binaryfunc)set_sub,		/*nb_subtract*/
2070	0,				/*nb_multiply*/
2071	0,				/*nb_divide*/
2072	0,				/*nb_remainder*/
2073	0,				/*nb_divmod*/
2074	0,				/*nb_power*/
2075	0,				/*nb_negative*/
2076	0,				/*nb_positive*/
2077	0,				/*nb_absolute*/
2078	0,				/*nb_nonzero*/
2079	0,				/*nb_invert*/
2080	0,				/*nb_lshift*/
2081	0,				/*nb_rshift*/
2082	(binaryfunc)set_and,		/*nb_and*/
2083	(binaryfunc)set_xor,		/*nb_xor*/
2084	(binaryfunc)set_or,		/*nb_or*/
2085	0,				/*nb_coerce*/
2086	0,				/*nb_int*/
2087	0,				/*nb_long*/
2088	0,				/*nb_float*/
2089	0,				/*nb_oct*/
2090	0, 				/*nb_hex*/
2091	0,				/*nb_inplace_add*/
2092	(binaryfunc)set_isub,		/*nb_inplace_subtract*/
2093	0,				/*nb_inplace_multiply*/
2094	0,				/*nb_inplace_divide*/
2095	0,				/*nb_inplace_remainder*/
2096	0,				/*nb_inplace_power*/
2097	0,				/*nb_inplace_lshift*/
2098	0,				/*nb_inplace_rshift*/
2099	(binaryfunc)set_iand,		/*nb_inplace_and*/
2100	(binaryfunc)set_ixor,		/*nb_inplace_xor*/
2101	(binaryfunc)set_ior,		/*nb_inplace_or*/
2102};
2103
2104PyDoc_STRVAR(set_doc,
2105"set(iterable) --> set object\n\
2106\n\
2107Build an unordered collection of unique elements.");
2108
2109PyTypeObject PySet_Type = {
2110	PyVarObject_HEAD_INIT(&PyType_Type, 0)
2111	"set",				/* tp_name */
2112	sizeof(PySetObject),		/* tp_basicsize */
2113	0,				/* tp_itemsize */
2114	/* methods */
2115	(destructor)set_dealloc,	/* tp_dealloc */
2116	(printfunc)set_tp_print,	/* tp_print */
2117	0,				/* tp_getattr */
2118	0,				/* tp_setattr */
2119	set_nocmp,			/* tp_compare */
2120	(reprfunc)set_repr,		/* tp_repr */
2121	&set_as_number,			/* tp_as_number */
2122	&set_as_sequence,		/* tp_as_sequence */
2123	0,				/* tp_as_mapping */
2124	(hashfunc)PyObject_HashNotImplemented,	/* tp_hash */
2125	0,				/* tp_call */
2126	0,				/* tp_str */
2127	PyObject_GenericGetAttr,	/* tp_getattro */
2128	0,				/* tp_setattro */
2129	0,				/* tp_as_buffer */
2130	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_CHECKTYPES |
2131		Py_TPFLAGS_BASETYPE,	/* tp_flags */
2132	set_doc,			/* tp_doc */
2133	(traversepro

Large files files are truncated, but you can click here to view the full file