/Objects/setobject.c
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