/Modules/_collectionsmodule.c

http://unladen-swallow.googlecode.com/ · C · 1468 lines · 1221 code · 145 blank · 102 comment · 290 complexity · 3542d3fd9fbff427f1edf1b2f43e68d7 MD5 · raw file

  1. #include "Python.h"
  2. #include "structmember.h"
  3. /* collections module implementation of a deque() datatype
  4. Written and maintained by Raymond D. Hettinger <python@rcn.com>
  5. Copyright (c) 2004 Python Software Foundation.
  6. All rights reserved.
  7. */
  8. /* The block length may be set to any number over 1. Larger numbers
  9. * reduce the number of calls to the memory allocator but take more
  10. * memory. Ideally, BLOCKLEN should be set with an eye to the
  11. * length of a cache line.
  12. */
  13. #define BLOCKLEN 62
  14. #define CENTER ((BLOCKLEN - 1) / 2)
  15. /* A `dequeobject` is composed of a doubly-linked list of `block` nodes.
  16. * This list is not circular (the leftmost block has leftlink==NULL,
  17. * and the rightmost block has rightlink==NULL). A deque d's first
  18. * element is at d.leftblock[leftindex] and its last element is at
  19. * d.rightblock[rightindex]; note that, unlike as for Python slice
  20. * indices, these indices are inclusive on both ends. By being inclusive
  21. * on both ends, algorithms for left and right operations become
  22. * symmetrical which simplifies the design.
  23. *
  24. * The list of blocks is never empty, so d.leftblock and d.rightblock
  25. * are never equal to NULL.
  26. *
  27. * The indices, d.leftindex and d.rightindex are always in the range
  28. * 0 <= index < BLOCKLEN.
  29. * Their exact relationship is:
  30. * (d.leftindex + d.len - 1) % BLOCKLEN == d.rightindex.
  31. *
  32. * Empty deques have d.len == 0; d.leftblock==d.rightblock;
  33. * d.leftindex == CENTER+1; and d.rightindex == CENTER.
  34. * Checking for d.len == 0 is the intended way to see whether d is empty.
  35. *
  36. * Whenever d.leftblock == d.rightblock,
  37. * d.leftindex + d.len - 1 == d.rightindex.
  38. *
  39. * However, when d.leftblock != d.rightblock, d.leftindex and d.rightindex
  40. * become indices into distinct blocks and either may be larger than the
  41. * other.
  42. */
  43. typedef struct BLOCK {
  44. struct BLOCK *leftlink;
  45. struct BLOCK *rightlink;
  46. PyObject *data[BLOCKLEN];
  47. } block;
  48. #define MAXFREEBLOCKS 10
  49. static Py_ssize_t numfreeblocks = 0;
  50. static block *freeblocks[MAXFREEBLOCKS];
  51. static block *
  52. newblock(block *leftlink, block *rightlink, Py_ssize_t len) {
  53. block *b;
  54. /* To prevent len from overflowing PY_SSIZE_T_MAX on 64-bit machines, we
  55. * refuse to allocate new blocks if the current len is dangerously
  56. * close. There is some extra margin to prevent spurious arithmetic
  57. * overflows at various places. The following check ensures that
  58. * the blocks allocated to the deque, in the worst case, can only
  59. * have PY_SSIZE_T_MAX-2 entries in total.
  60. */
  61. if (len >= PY_SSIZE_T_MAX - 2*BLOCKLEN) {
  62. PyErr_SetString(PyExc_OverflowError,
  63. "cannot add more blocks to the deque");
  64. return NULL;
  65. }
  66. if (numfreeblocks) {
  67. numfreeblocks -= 1;
  68. b = freeblocks[numfreeblocks];
  69. } else {
  70. b = PyMem_Malloc(sizeof(block));
  71. if (b == NULL) {
  72. PyErr_NoMemory();
  73. return NULL;
  74. }
  75. }
  76. b->leftlink = leftlink;
  77. b->rightlink = rightlink;
  78. return b;
  79. }
  80. static void
  81. freeblock(block *b)
  82. {
  83. if (numfreeblocks < MAXFREEBLOCKS) {
  84. freeblocks[numfreeblocks] = b;
  85. numfreeblocks++;
  86. } else {
  87. PyMem_Free(b);
  88. }
  89. }
  90. typedef struct {
  91. PyObject_HEAD
  92. block *leftblock;
  93. block *rightblock;
  94. Py_ssize_t leftindex; /* in range(BLOCKLEN) */
  95. Py_ssize_t rightindex; /* in range(BLOCKLEN) */
  96. Py_ssize_t len;
  97. Py_ssize_t maxlen;
  98. long state; /* incremented whenever the indices move */
  99. PyObject *weakreflist; /* List of weak references */
  100. } dequeobject;
  101. /* The deque's size limit is d.maxlen. The limit can be zero or positive.
  102. * If there is no limit, then d.maxlen == -1.
  103. *
  104. * After an item is added to a deque, we check to see if the size has grown past
  105. * the limit. If it has, we get the size back down to the limit by popping an
  106. * item off of the opposite end. The methods that can trigger this are append(),
  107. * appendleft(), extend(), and extendleft().
  108. */
  109. #define TRIM(d, popfunction) \
  110. if (d->maxlen != -1 && d->len > d->maxlen) { \
  111. PyObject *rv = popfunction(d, NULL); \
  112. assert(rv != NULL && d->len <= d->maxlen); \
  113. Py_DECREF(rv); \
  114. }
  115. static PyTypeObject deque_type;
  116. static PyObject *
  117. deque_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
  118. {
  119. dequeobject *deque;
  120. block *b;
  121. /* create dequeobject structure */
  122. deque = (dequeobject *)type->tp_alloc(type, 0);
  123. if (deque == NULL)
  124. return NULL;
  125. b = newblock(NULL, NULL, 0);
  126. if (b == NULL) {
  127. Py_DECREF(deque);
  128. return NULL;
  129. }
  130. assert(BLOCKLEN >= 2);
  131. deque->leftblock = b;
  132. deque->rightblock = b;
  133. deque->leftindex = CENTER + 1;
  134. deque->rightindex = CENTER;
  135. deque->len = 0;
  136. deque->state = 0;
  137. deque->weakreflist = NULL;
  138. deque->maxlen = -1;
  139. return (PyObject *)deque;
  140. }
  141. static PyObject *
  142. deque_pop(dequeobject *deque, PyObject *unused)
  143. {
  144. PyObject *item;
  145. block *prevblock;
  146. if (deque->len == 0) {
  147. PyErr_SetString(PyExc_IndexError, "pop from an empty deque");
  148. return NULL;
  149. }
  150. item = deque->rightblock->data[deque->rightindex];
  151. deque->rightindex--;
  152. deque->len--;
  153. deque->state++;
  154. if (deque->rightindex == -1) {
  155. if (deque->len == 0) {
  156. assert(deque->leftblock == deque->rightblock);
  157. assert(deque->leftindex == deque->rightindex+1);
  158. /* re-center instead of freeing a block */
  159. deque->leftindex = CENTER + 1;
  160. deque->rightindex = CENTER;
  161. } else {
  162. prevblock = deque->rightblock->leftlink;
  163. assert(deque->leftblock != deque->rightblock);
  164. freeblock(deque->rightblock);
  165. prevblock->rightlink = NULL;
  166. deque->rightblock = prevblock;
  167. deque->rightindex = BLOCKLEN - 1;
  168. }
  169. }
  170. return item;
  171. }
  172. PyDoc_STRVAR(pop_doc, "Remove and return the rightmost element.");
  173. static PyObject *
  174. deque_popleft(dequeobject *deque, PyObject *unused)
  175. {
  176. PyObject *item;
  177. block *prevblock;
  178. if (deque->len == 0) {
  179. PyErr_SetString(PyExc_IndexError, "pop from an empty deque");
  180. return NULL;
  181. }
  182. assert(deque->leftblock != NULL);
  183. item = deque->leftblock->data[deque->leftindex];
  184. deque->leftindex++;
  185. deque->len--;
  186. deque->state++;
  187. if (deque->leftindex == BLOCKLEN) {
  188. if (deque->len == 0) {
  189. assert(deque->leftblock == deque->rightblock);
  190. assert(deque->leftindex == deque->rightindex+1);
  191. /* re-center instead of freeing a block */
  192. deque->leftindex = CENTER + 1;
  193. deque->rightindex = CENTER;
  194. } else {
  195. assert(deque->leftblock != deque->rightblock);
  196. prevblock = deque->leftblock->rightlink;
  197. freeblock(deque->leftblock);
  198. assert(prevblock != NULL);
  199. prevblock->leftlink = NULL;
  200. deque->leftblock = prevblock;
  201. deque->leftindex = 0;
  202. }
  203. }
  204. return item;
  205. }
  206. PyDoc_STRVAR(popleft_doc, "Remove and return the leftmost element.");
  207. static PyObject *
  208. deque_append(dequeobject *deque, PyObject *item)
  209. {
  210. deque->state++;
  211. if (deque->rightindex == BLOCKLEN-1) {
  212. block *b = newblock(deque->rightblock, NULL, deque->len);
  213. if (b == NULL)
  214. return NULL;
  215. assert(deque->rightblock->rightlink == NULL);
  216. deque->rightblock->rightlink = b;
  217. deque->rightblock = b;
  218. deque->rightindex = -1;
  219. }
  220. Py_INCREF(item);
  221. deque->len++;
  222. deque->rightindex++;
  223. deque->rightblock->data[deque->rightindex] = item;
  224. TRIM(deque, deque_popleft);
  225. Py_RETURN_NONE;
  226. }
  227. PyDoc_STRVAR(append_doc, "Add an element to the right side of the deque.");
  228. static PyObject *
  229. deque_appendleft(dequeobject *deque, PyObject *item)
  230. {
  231. deque->state++;
  232. if (deque->leftindex == 0) {
  233. block *b = newblock(NULL, deque->leftblock, deque->len);
  234. if (b == NULL)
  235. return NULL;
  236. assert(deque->leftblock->leftlink == NULL);
  237. deque->leftblock->leftlink = b;
  238. deque->leftblock = b;
  239. deque->leftindex = BLOCKLEN;
  240. }
  241. Py_INCREF(item);
  242. deque->len++;
  243. deque->leftindex--;
  244. deque->leftblock->data[deque->leftindex] = item;
  245. TRIM(deque, deque_pop);
  246. Py_RETURN_NONE;
  247. }
  248. PyDoc_STRVAR(appendleft_doc, "Add an element to the left side of the deque.");
  249. static PyObject *
  250. deque_extend(dequeobject *deque, PyObject *iterable)
  251. {
  252. PyObject *it, *item;
  253. it = PyObject_GetIter(iterable);
  254. if (it == NULL)
  255. return NULL;
  256. while ((item = PyIter_Next(it)) != NULL) {
  257. deque->state++;
  258. if (deque->rightindex == BLOCKLEN-1) {
  259. block *b = newblock(deque->rightblock, NULL,
  260. deque->len);
  261. if (b == NULL) {
  262. Py_DECREF(item);
  263. Py_DECREF(it);
  264. return NULL;
  265. }
  266. assert(deque->rightblock->rightlink == NULL);
  267. deque->rightblock->rightlink = b;
  268. deque->rightblock = b;
  269. deque->rightindex = -1;
  270. }
  271. deque->len++;
  272. deque->rightindex++;
  273. deque->rightblock->data[deque->rightindex] = item;
  274. TRIM(deque, deque_popleft);
  275. }
  276. Py_DECREF(it);
  277. if (PyErr_Occurred())
  278. return NULL;
  279. Py_RETURN_NONE;
  280. }
  281. PyDoc_STRVAR(extend_doc,
  282. "Extend the right side of the deque with elements from the iterable");
  283. static PyObject *
  284. deque_extendleft(dequeobject *deque, PyObject *iterable)
  285. {
  286. PyObject *it, *item;
  287. it = PyObject_GetIter(iterable);
  288. if (it == NULL)
  289. return NULL;
  290. while ((item = PyIter_Next(it)) != NULL) {
  291. deque->state++;
  292. if (deque->leftindex == 0) {
  293. block *b = newblock(NULL, deque->leftblock,
  294. deque->len);
  295. if (b == NULL) {
  296. Py_DECREF(item);
  297. Py_DECREF(it);
  298. return NULL;
  299. }
  300. assert(deque->leftblock->leftlink == NULL);
  301. deque->leftblock->leftlink = b;
  302. deque->leftblock = b;
  303. deque->leftindex = BLOCKLEN;
  304. }
  305. deque->len++;
  306. deque->leftindex--;
  307. deque->leftblock->data[deque->leftindex] = item;
  308. TRIM(deque, deque_pop);
  309. }
  310. Py_DECREF(it);
  311. if (PyErr_Occurred())
  312. return NULL;
  313. Py_RETURN_NONE;
  314. }
  315. PyDoc_STRVAR(extendleft_doc,
  316. "Extend the left side of the deque with elements from the iterable");
  317. static int
  318. _deque_rotate(dequeobject *deque, Py_ssize_t n)
  319. {
  320. Py_ssize_t i, len=deque->len, halflen=(len+1)>>1;
  321. PyObject *item, *rv;
  322. if (len == 0)
  323. return 0;
  324. if (n > halflen || n < -halflen) {
  325. n %= len;
  326. if (n > halflen)
  327. n -= len;
  328. else if (n < -halflen)
  329. n += len;
  330. }
  331. for (i=0 ; i<n ; i++) {
  332. item = deque_pop(deque, NULL);
  333. assert (item != NULL);
  334. rv = deque_appendleft(deque, item);
  335. Py_DECREF(item);
  336. if (rv == NULL)
  337. return -1;
  338. Py_DECREF(rv);
  339. }
  340. for (i=0 ; i>n ; i--) {
  341. item = deque_popleft(deque, NULL);
  342. assert (item != NULL);
  343. rv = deque_append(deque, item);
  344. Py_DECREF(item);
  345. if (rv == NULL)
  346. return -1;
  347. Py_DECREF(rv);
  348. }
  349. return 0;
  350. }
  351. static PyObject *
  352. deque_rotate(dequeobject *deque, PyObject *args)
  353. {
  354. Py_ssize_t n=1;
  355. if (!PyArg_ParseTuple(args, "|n:rotate", &n))
  356. return NULL;
  357. if (_deque_rotate(deque, n) == 0)
  358. Py_RETURN_NONE;
  359. return NULL;
  360. }
  361. PyDoc_STRVAR(rotate_doc,
  362. "Rotate the deque n steps to the right (default n=1). If n is negative, rotates left.");
  363. static Py_ssize_t
  364. deque_len(dequeobject *deque)
  365. {
  366. return deque->len;
  367. }
  368. static PyObject *
  369. deque_remove(dequeobject *deque, PyObject *value)
  370. {
  371. Py_ssize_t i, n=deque->len;
  372. for (i=0 ; i<n ; i++) {
  373. PyObject *item = deque->leftblock->data[deque->leftindex];
  374. int cmp = PyObject_RichCompareBool(item, value, Py_EQ);
  375. if (deque->len != n) {
  376. PyErr_SetString(PyExc_IndexError,
  377. "deque mutated during remove().");
  378. return NULL;
  379. }
  380. if (cmp > 0) {
  381. PyObject *tgt = deque_popleft(deque, NULL);
  382. assert (tgt != NULL);
  383. Py_DECREF(tgt);
  384. if (_deque_rotate(deque, i) == -1)
  385. return NULL;
  386. Py_RETURN_NONE;
  387. }
  388. else if (cmp < 0) {
  389. _deque_rotate(deque, i);
  390. return NULL;
  391. }
  392. _deque_rotate(deque, -1);
  393. }
  394. PyErr_SetString(PyExc_ValueError, "deque.remove(x): x not in deque");
  395. return NULL;
  396. }
  397. PyDoc_STRVAR(remove_doc,
  398. "D.remove(value) -- remove first occurrence of value.");
  399. static int
  400. deque_clear(dequeobject *deque)
  401. {
  402. PyObject *item;
  403. while (deque->len) {
  404. item = deque_pop(deque, NULL);
  405. assert (item != NULL);
  406. Py_DECREF(item);
  407. }
  408. assert(deque->leftblock == deque->rightblock &&
  409. deque->leftindex - 1 == deque->rightindex &&
  410. deque->len == 0);
  411. return 0;
  412. }
  413. static PyObject *
  414. deque_item(dequeobject *deque, Py_ssize_t i)
  415. {
  416. block *b;
  417. PyObject *item;
  418. Py_ssize_t n, index=i;
  419. if (i < 0 || i >= deque->len) {
  420. PyErr_SetString(PyExc_IndexError,
  421. "deque index out of range");
  422. return NULL;
  423. }
  424. if (i == 0) {
  425. i = deque->leftindex;
  426. b = deque->leftblock;
  427. } else if (i == deque->len - 1) {
  428. i = deque->rightindex;
  429. b = deque->rightblock;
  430. } else {
  431. i += deque->leftindex;
  432. n = i / BLOCKLEN;
  433. i %= BLOCKLEN;
  434. if (index < (deque->len >> 1)) {
  435. b = deque->leftblock;
  436. while (n--)
  437. b = b->rightlink;
  438. } else {
  439. n = (deque->leftindex + deque->len - 1) / BLOCKLEN - n;
  440. b = deque->rightblock;
  441. while (n--)
  442. b = b->leftlink;
  443. }
  444. }
  445. item = b->data[i];
  446. Py_INCREF(item);
  447. return item;
  448. }
  449. /* delitem() implemented in terms of rotate for simplicity and reasonable
  450. performance near the end points. If for some reason this method becomes
  451. popular, it is not hard to re-implement this using direct data movement
  452. (similar to code in list slice assignment) and achieve a two or threefold
  453. performance boost.
  454. */
  455. static int
  456. deque_del_item(dequeobject *deque, Py_ssize_t i)
  457. {
  458. PyObject *item;
  459. assert (i >= 0 && i < deque->len);
  460. if (_deque_rotate(deque, -i) == -1)
  461. return -1;
  462. item = deque_popleft(deque, NULL);
  463. assert (item != NULL);
  464. Py_DECREF(item);
  465. return _deque_rotate(deque, i);
  466. }
  467. static int
  468. deque_ass_item(dequeobject *deque, Py_ssize_t i, PyObject *v)
  469. {
  470. PyObject *old_value;
  471. block *b;
  472. Py_ssize_t n, len=deque->len, halflen=(len+1)>>1, index=i;
  473. if (i < 0 || i >= len) {
  474. PyErr_SetString(PyExc_IndexError,
  475. "deque index out of range");
  476. return -1;
  477. }
  478. if (v == NULL)
  479. return deque_del_item(deque, i);
  480. i += deque->leftindex;
  481. n = i / BLOCKLEN;
  482. i %= BLOCKLEN;
  483. if (index <= halflen) {
  484. b = deque->leftblock;
  485. while (n--)
  486. b = b->rightlink;
  487. } else {
  488. n = (deque->leftindex + len - 1) / BLOCKLEN - n;
  489. b = deque->rightblock;
  490. while (n--)
  491. b = b->leftlink;
  492. }
  493. Py_INCREF(v);
  494. old_value = b->data[i];
  495. b->data[i] = v;
  496. Py_DECREF(old_value);
  497. return 0;
  498. }
  499. static PyObject *
  500. deque_clearmethod(dequeobject *deque)
  501. {
  502. int rv;
  503. rv = deque_clear(deque);
  504. assert (rv != -1);
  505. Py_RETURN_NONE;
  506. }
  507. PyDoc_STRVAR(clear_doc, "Remove all elements from the deque.");
  508. static void
  509. deque_dealloc(dequeobject *deque)
  510. {
  511. PyObject_GC_UnTrack(deque);
  512. if (deque->weakreflist != NULL)
  513. PyObject_ClearWeakRefs((PyObject *) deque);
  514. if (deque->leftblock != NULL) {
  515. deque_clear(deque);
  516. assert(deque->leftblock != NULL);
  517. freeblock(deque->leftblock);
  518. }
  519. deque->leftblock = NULL;
  520. deque->rightblock = NULL;
  521. Py_TYPE(deque)->tp_free(deque);
  522. }
  523. static int
  524. deque_traverse(dequeobject *deque, visitproc visit, void *arg)
  525. {
  526. block *b;
  527. PyObject *item;
  528. Py_ssize_t index;
  529. Py_ssize_t indexlo = deque->leftindex;
  530. for (b = deque->leftblock; b != NULL; b = b->rightlink) {
  531. const Py_ssize_t indexhi = b == deque->rightblock ?
  532. deque->rightindex :
  533. BLOCKLEN - 1;
  534. for (index = indexlo; index <= indexhi; ++index) {
  535. item = b->data[index];
  536. Py_VISIT(item);
  537. }
  538. indexlo = 0;
  539. }
  540. return 0;
  541. }
  542. static PyObject *
  543. deque_copy(PyObject *deque)
  544. {
  545. if (((dequeobject *)deque)->maxlen == -1)
  546. return PyObject_CallFunction((PyObject *)(Py_TYPE(deque)), "O", deque, NULL);
  547. else
  548. return PyObject_CallFunction((PyObject *)(Py_TYPE(deque)), "Oi",
  549. deque, ((dequeobject *)deque)->maxlen, NULL);
  550. }
  551. PyDoc_STRVAR(copy_doc, "Return a shallow copy of a deque.");
  552. static PyObject *
  553. deque_reduce(dequeobject *deque)
  554. {
  555. PyObject *dict, *result, *aslist;
  556. dict = PyObject_GetAttrString((PyObject *)deque, "__dict__");
  557. if (dict == NULL)
  558. PyErr_Clear();
  559. aslist = PySequence_List((PyObject *)deque);
  560. if (aslist == NULL) {
  561. Py_XDECREF(dict);
  562. return NULL;
  563. }
  564. if (dict == NULL) {
  565. if (deque->maxlen == -1)
  566. result = Py_BuildValue("O(O)", Py_TYPE(deque), aslist);
  567. else
  568. result = Py_BuildValue("O(On)", Py_TYPE(deque), aslist, deque->maxlen);
  569. } else {
  570. if (deque->maxlen == -1)
  571. result = Py_BuildValue("O(OO)O", Py_TYPE(deque), aslist, Py_None, dict);
  572. else
  573. result = Py_BuildValue("O(On)O", Py_TYPE(deque), aslist, deque->maxlen, dict);
  574. }
  575. Py_XDECREF(dict);
  576. Py_DECREF(aslist);
  577. return result;
  578. }
  579. PyDoc_STRVAR(reduce_doc, "Return state information for pickling.");
  580. static PyObject *
  581. deque_repr(PyObject *deque)
  582. {
  583. PyObject *aslist, *result, *fmt;
  584. int i;
  585. i = Py_ReprEnter(deque);
  586. if (i != 0) {
  587. if (i < 0)
  588. return NULL;
  589. return PyString_FromString("[...]");
  590. }
  591. aslist = PySequence_List(deque);
  592. if (aslist == NULL) {
  593. Py_ReprLeave(deque);
  594. return NULL;
  595. }
  596. if (((dequeobject *)deque)->maxlen != -1)
  597. fmt = PyString_FromFormat("deque(%%r, maxlen=%zd)",
  598. ((dequeobject *)deque)->maxlen);
  599. else
  600. fmt = PyString_FromString("deque(%r)");
  601. if (fmt == NULL) {
  602. Py_DECREF(aslist);
  603. Py_ReprLeave(deque);
  604. return NULL;
  605. }
  606. result = PyString_Format(fmt, aslist);
  607. Py_DECREF(fmt);
  608. Py_DECREF(aslist);
  609. Py_ReprLeave(deque);
  610. return result;
  611. }
  612. static int
  613. deque_tp_print(PyObject *deque, FILE *fp, int flags)
  614. {
  615. PyObject *it, *item;
  616. char *emit = ""; /* No separator emitted on first pass */
  617. char *separator = ", ";
  618. int i;
  619. i = Py_ReprEnter(deque);
  620. if (i != 0) {
  621. if (i < 0)
  622. return i;
  623. Py_BEGIN_ALLOW_THREADS
  624. fputs("[...]", fp);
  625. Py_END_ALLOW_THREADS
  626. return 0;
  627. }
  628. it = PyObject_GetIter(deque);
  629. if (it == NULL)
  630. return -1;
  631. Py_BEGIN_ALLOW_THREADS
  632. fputs("deque([", fp);
  633. Py_END_ALLOW_THREADS
  634. while ((item = PyIter_Next(it)) != NULL) {
  635. Py_BEGIN_ALLOW_THREADS
  636. fputs(emit, fp);
  637. Py_END_ALLOW_THREADS
  638. emit = separator;
  639. if (PyObject_Print(item, fp, 0) != 0) {
  640. Py_DECREF(item);
  641. Py_DECREF(it);
  642. Py_ReprLeave(deque);
  643. return -1;
  644. }
  645. Py_DECREF(item);
  646. }
  647. Py_ReprLeave(deque);
  648. Py_DECREF(it);
  649. if (PyErr_Occurred())
  650. return -1;
  651. Py_BEGIN_ALLOW_THREADS
  652. if (((dequeobject *)deque)->maxlen == -1)
  653. fputs("])", fp);
  654. else
  655. fprintf(fp, "], maxlen=%" PY_FORMAT_SIZE_T "d)", ((dequeobject *)deque)->maxlen);
  656. Py_END_ALLOW_THREADS
  657. return 0;
  658. }
  659. static PyObject *
  660. deque_richcompare(PyObject *v, PyObject *w, int op)
  661. {
  662. PyObject *it1=NULL, *it2=NULL, *x, *y;
  663. Py_ssize_t vs, ws;
  664. int b, cmp=-1;
  665. if (!PyObject_TypeCheck(v, &deque_type) ||
  666. !PyObject_TypeCheck(w, &deque_type)) {
  667. Py_INCREF(Py_NotImplemented);
  668. return Py_NotImplemented;
  669. }
  670. /* Shortcuts */
  671. vs = ((dequeobject *)v)->len;
  672. ws = ((dequeobject *)w)->len;
  673. if (op == Py_EQ) {
  674. if (v == w)
  675. Py_RETURN_TRUE;
  676. if (vs != ws)
  677. Py_RETURN_FALSE;
  678. }
  679. if (op == Py_NE) {
  680. if (v == w)
  681. Py_RETURN_FALSE;
  682. if (vs != ws)
  683. Py_RETURN_TRUE;
  684. }
  685. /* Search for the first index where items are different */
  686. it1 = PyObject_GetIter(v);
  687. if (it1 == NULL)
  688. goto done;
  689. it2 = PyObject_GetIter(w);
  690. if (it2 == NULL)
  691. goto done;
  692. for (;;) {
  693. x = PyIter_Next(it1);
  694. if (x == NULL && PyErr_Occurred())
  695. goto done;
  696. y = PyIter_Next(it2);
  697. if (x == NULL || y == NULL)
  698. break;
  699. b = PyObject_RichCompareBool(x, y, Py_EQ);
  700. if (b == 0) {
  701. cmp = PyObject_RichCompareBool(x, y, op);
  702. Py_DECREF(x);
  703. Py_DECREF(y);
  704. goto done;
  705. }
  706. Py_DECREF(x);
  707. Py_DECREF(y);
  708. if (b == -1)
  709. goto done;
  710. }
  711. /* We reached the end of one deque or both */
  712. Py_XDECREF(x);
  713. Py_XDECREF(y);
  714. if (PyErr_Occurred())
  715. goto done;
  716. switch (op) {
  717. case Py_LT: cmp = y != NULL; break; /* if w was longer */
  718. case Py_LE: cmp = x == NULL; break; /* if v was not longer */
  719. case Py_EQ: cmp = x == y; break; /* if we reached the end of both */
  720. case Py_NE: cmp = x != y; break; /* if one deque continues */
  721. case Py_GT: cmp = x != NULL; break; /* if v was longer */
  722. case Py_GE: cmp = y == NULL; break; /* if w was not longer */
  723. }
  724. done:
  725. Py_XDECREF(it1);
  726. Py_XDECREF(it2);
  727. if (cmp == 1)
  728. Py_RETURN_TRUE;
  729. if (cmp == 0)
  730. Py_RETURN_FALSE;
  731. return NULL;
  732. }
  733. static int
  734. deque_init(dequeobject *deque, PyObject *args, PyObject *kwdargs)
  735. {
  736. PyObject *iterable = NULL;
  737. PyObject *maxlenobj = NULL;
  738. Py_ssize_t maxlen = -1;
  739. char *kwlist[] = {"iterable", "maxlen", 0};
  740. if (!PyArg_ParseTupleAndKeywords(args, kwdargs, "|OO:deque", kwlist, &iterable, &maxlenobj))
  741. return -1;
  742. if (maxlenobj != NULL && maxlenobj != Py_None) {
  743. maxlen = PyInt_AsSsize_t(maxlenobj);
  744. if (maxlen == -1 && PyErr_Occurred())
  745. return -1;
  746. if (maxlen < 0) {
  747. PyErr_SetString(PyExc_ValueError, "maxlen must be non-negative");
  748. return -1;
  749. }
  750. }
  751. deque->maxlen = maxlen;
  752. deque_clear(deque);
  753. if (iterable != NULL) {
  754. PyObject *rv = deque_extend(deque, iterable);
  755. if (rv == NULL)
  756. return -1;
  757. Py_DECREF(rv);
  758. }
  759. return 0;
  760. }
  761. static PySequenceMethods deque_as_sequence = {
  762. (lenfunc)deque_len, /* sq_length */
  763. 0, /* sq_concat */
  764. 0, /* sq_repeat */
  765. (ssizeargfunc)deque_item, /* sq_item */
  766. 0, /* sq_slice */
  767. (ssizeobjargproc)deque_ass_item, /* sq_ass_item */
  768. };
  769. /* deque object ********************************************************/
  770. static PyObject *deque_iter(dequeobject *deque);
  771. static PyObject *deque_reviter(dequeobject *deque);
  772. PyDoc_STRVAR(reversed_doc,
  773. "D.__reversed__() -- return a reverse iterator over the deque");
  774. static PyMethodDef deque_methods[] = {
  775. {"append", (PyCFunction)deque_append,
  776. METH_O, append_doc},
  777. {"appendleft", (PyCFunction)deque_appendleft,
  778. METH_O, appendleft_doc},
  779. {"clear", (PyCFunction)deque_clearmethod,
  780. METH_NOARGS, clear_doc},
  781. {"__copy__", (PyCFunction)deque_copy,
  782. METH_NOARGS, copy_doc},
  783. {"extend", (PyCFunction)deque_extend,
  784. METH_O, extend_doc},
  785. {"extendleft", (PyCFunction)deque_extendleft,
  786. METH_O, extendleft_doc},
  787. {"pop", (PyCFunction)deque_pop,
  788. METH_NOARGS, pop_doc},
  789. {"popleft", (PyCFunction)deque_popleft,
  790. METH_NOARGS, popleft_doc},
  791. {"__reduce__", (PyCFunction)deque_reduce,
  792. METH_NOARGS, reduce_doc},
  793. {"remove", (PyCFunction)deque_remove,
  794. METH_O, remove_doc},
  795. {"__reversed__", (PyCFunction)deque_reviter,
  796. METH_NOARGS, reversed_doc},
  797. {"rotate", (PyCFunction)deque_rotate,
  798. METH_VARARGS, rotate_doc},
  799. {NULL, NULL} /* sentinel */
  800. };
  801. PyDoc_STRVAR(deque_doc,
  802. "deque(iterable[, maxlen]) --> deque object\n\
  803. \n\
  804. Build an ordered collection accessible from endpoints only.");
  805. static PyTypeObject deque_type = {
  806. PyVarObject_HEAD_INIT(NULL, 0)
  807. "collections.deque", /* tp_name */
  808. sizeof(dequeobject), /* tp_basicsize */
  809. 0, /* tp_itemsize */
  810. /* methods */
  811. (destructor)deque_dealloc, /* tp_dealloc */
  812. deque_tp_print, /* tp_print */
  813. 0, /* tp_getattr */
  814. 0, /* tp_setattr */
  815. 0, /* tp_compare */
  816. deque_repr, /* tp_repr */
  817. 0, /* tp_as_number */
  818. &deque_as_sequence, /* tp_as_sequence */
  819. 0, /* tp_as_mapping */
  820. (hashfunc)PyObject_HashNotImplemented, /* tp_hash */
  821. 0, /* tp_call */
  822. 0, /* tp_str */
  823. PyObject_GenericGetAttr, /* tp_getattro */
  824. 0, /* tp_setattro */
  825. 0, /* tp_as_buffer */
  826. Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC |
  827. Py_TPFLAGS_HAVE_WEAKREFS, /* tp_flags */
  828. deque_doc, /* tp_doc */
  829. (traverseproc)deque_traverse, /* tp_traverse */
  830. (inquiry)deque_clear, /* tp_clear */
  831. (richcmpfunc)deque_richcompare, /* tp_richcompare */
  832. offsetof(dequeobject, weakreflist), /* tp_weaklistoffset*/
  833. (getiterfunc)deque_iter, /* tp_iter */
  834. 0, /* tp_iternext */
  835. deque_methods, /* tp_methods */
  836. 0, /* tp_members */
  837. 0, /* tp_getset */
  838. 0, /* tp_base */
  839. 0, /* tp_dict */
  840. 0, /* tp_descr_get */
  841. 0, /* tp_descr_set */
  842. 0, /* tp_dictoffset */
  843. (initproc)deque_init, /* tp_init */
  844. PyType_GenericAlloc, /* tp_alloc */
  845. deque_new, /* tp_new */
  846. PyObject_GC_Del, /* tp_free */
  847. };
  848. /*********************** Deque Iterator **************************/
  849. typedef struct {
  850. PyObject_HEAD
  851. Py_ssize_t index;
  852. block *b;
  853. dequeobject *deque;
  854. long state; /* state when the iterator is created */
  855. Py_ssize_t counter; /* number of items remaining for iteration */
  856. } dequeiterobject;
  857. static PyTypeObject dequeiter_type;
  858. static PyObject *
  859. deque_iter(dequeobject *deque)
  860. {
  861. dequeiterobject *it;
  862. it = PyObject_GC_New(dequeiterobject, &dequeiter_type);
  863. if (it == NULL)
  864. return NULL;
  865. it->b = deque->leftblock;
  866. it->index = deque->leftindex;
  867. Py_INCREF(deque);
  868. it->deque = deque;
  869. it->state = deque->state;
  870. it->counter = deque->len;
  871. PyObject_GC_Track(it);
  872. return (PyObject *)it;
  873. }
  874. static int
  875. dequeiter_traverse(dequeiterobject *dio, visitproc visit, void *arg)
  876. {
  877. Py_VISIT(dio->deque);
  878. return 0;
  879. }
  880. static void
  881. dequeiter_dealloc(dequeiterobject *dio)
  882. {
  883. Py_XDECREF(dio->deque);
  884. PyObject_GC_Del(dio);
  885. }
  886. static PyObject *
  887. dequeiter_next(dequeiterobject *it)
  888. {
  889. PyObject *item;
  890. if (it->deque->state != it->state) {
  891. it->counter = 0;
  892. PyErr_SetString(PyExc_RuntimeError,
  893. "deque mutated during iteration");
  894. return NULL;
  895. }
  896. if (it->counter == 0)
  897. return NULL;
  898. assert (!(it->b == it->deque->rightblock &&
  899. it->index > it->deque->rightindex));
  900. item = it->b->data[it->index];
  901. it->index++;
  902. it->counter--;
  903. if (it->index == BLOCKLEN && it->counter > 0) {
  904. assert (it->b->rightlink != NULL);
  905. it->b = it->b->rightlink;
  906. it->index = 0;
  907. }
  908. Py_INCREF(item);
  909. return item;
  910. }
  911. static PyObject *
  912. dequeiter_len(dequeiterobject *it)
  913. {
  914. return PyInt_FromLong(it->counter);
  915. }
  916. PyDoc_STRVAR(length_hint_doc, "Private method returning an estimate of len(list(it)).");
  917. static PyMethodDef dequeiter_methods[] = {
  918. {"__length_hint__", (PyCFunction)dequeiter_len, METH_NOARGS, length_hint_doc},
  919. {NULL, NULL} /* sentinel */
  920. };
  921. static PyTypeObject dequeiter_type = {
  922. PyVarObject_HEAD_INIT(NULL, 0)
  923. "deque_iterator", /* tp_name */
  924. sizeof(dequeiterobject), /* tp_basicsize */
  925. 0, /* tp_itemsize */
  926. /* methods */
  927. (destructor)dequeiter_dealloc, /* tp_dealloc */
  928. 0, /* tp_print */
  929. 0, /* tp_getattr */
  930. 0, /* tp_setattr */
  931. 0, /* tp_compare */
  932. 0, /* tp_repr */
  933. 0, /* tp_as_number */
  934. 0, /* tp_as_sequence */
  935. 0, /* tp_as_mapping */
  936. 0, /* tp_hash */
  937. 0, /* tp_call */
  938. 0, /* tp_str */
  939. PyObject_GenericGetAttr, /* tp_getattro */
  940. 0, /* tp_setattro */
  941. 0, /* tp_as_buffer */
  942. Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
  943. 0, /* tp_doc */
  944. (traverseproc)dequeiter_traverse, /* tp_traverse */
  945. 0, /* tp_clear */
  946. 0, /* tp_richcompare */
  947. 0, /* tp_weaklistoffset */
  948. PyObject_SelfIter, /* tp_iter */
  949. (iternextfunc)dequeiter_next, /* tp_iternext */
  950. dequeiter_methods, /* tp_methods */
  951. 0,
  952. };
  953. /*********************** Deque Reverse Iterator **************************/
  954. static PyTypeObject dequereviter_type;
  955. static PyObject *
  956. deque_reviter(dequeobject *deque)
  957. {
  958. dequeiterobject *it;
  959. it = PyObject_GC_New(dequeiterobject, &dequereviter_type);
  960. if (it == NULL)
  961. return NULL;
  962. it->b = deque->rightblock;
  963. it->index = deque->rightindex;
  964. Py_INCREF(deque);
  965. it->deque = deque;
  966. it->state = deque->state;
  967. it->counter = deque->len;
  968. PyObject_GC_Track(it);
  969. return (PyObject *)it;
  970. }
  971. static PyObject *
  972. dequereviter_next(dequeiterobject *it)
  973. {
  974. PyObject *item;
  975. if (it->counter == 0)
  976. return NULL;
  977. if (it->deque->state != it->state) {
  978. it->counter = 0;
  979. PyErr_SetString(PyExc_RuntimeError,
  980. "deque mutated during iteration");
  981. return NULL;
  982. }
  983. assert (!(it->b == it->deque->leftblock &&
  984. it->index < it->deque->leftindex));
  985. item = it->b->data[it->index];
  986. it->index--;
  987. it->counter--;
  988. if (it->index == -1 && it->counter > 0) {
  989. assert (it->b->leftlink != NULL);
  990. it->b = it->b->leftlink;
  991. it->index = BLOCKLEN - 1;
  992. }
  993. Py_INCREF(item);
  994. return item;
  995. }
  996. static PyTypeObject dequereviter_type = {
  997. PyVarObject_HEAD_INIT(NULL, 0)
  998. "deque_reverse_iterator", /* tp_name */
  999. sizeof(dequeiterobject), /* tp_basicsize */
  1000. 0, /* tp_itemsize */
  1001. /* methods */
  1002. (destructor)dequeiter_dealloc, /* tp_dealloc */
  1003. 0, /* tp_print */
  1004. 0, /* tp_getattr */
  1005. 0, /* tp_setattr */
  1006. 0, /* tp_compare */
  1007. 0, /* tp_repr */
  1008. 0, /* tp_as_number */
  1009. 0, /* tp_as_sequence */
  1010. 0, /* tp_as_mapping */
  1011. 0, /* tp_hash */
  1012. 0, /* tp_call */
  1013. 0, /* tp_str */
  1014. PyObject_GenericGetAttr, /* tp_getattro */
  1015. 0, /* tp_setattro */
  1016. 0, /* tp_as_buffer */
  1017. Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
  1018. 0, /* tp_doc */
  1019. (traverseproc)dequeiter_traverse, /* tp_traverse */
  1020. 0, /* tp_clear */
  1021. 0, /* tp_richcompare */
  1022. 0, /* tp_weaklistoffset */
  1023. PyObject_SelfIter, /* tp_iter */
  1024. (iternextfunc)dequereviter_next, /* tp_iternext */
  1025. dequeiter_methods, /* tp_methods */
  1026. 0,
  1027. };
  1028. /* defaultdict type *********************************************************/
  1029. typedef struct {
  1030. PyDictObject dict;
  1031. PyObject *default_factory;
  1032. } defdictobject;
  1033. static PyTypeObject defdict_type; /* Forward */
  1034. PyDoc_STRVAR(defdict_missing_doc,
  1035. "__missing__(key) # Called by __getitem__ for missing key; pseudo-code:\n\
  1036. if self.default_factory is None: raise KeyError((key,))\n\
  1037. self[key] = value = self.default_factory()\n\
  1038. return value\n\
  1039. ");
  1040. static PyObject *
  1041. defdict_missing(defdictobject *dd, PyObject *key)
  1042. {
  1043. PyObject *factory = dd->default_factory;
  1044. PyObject *value;
  1045. if (factory == NULL || factory == Py_None) {
  1046. /* XXX Call dict.__missing__(key) */
  1047. PyObject *tup;
  1048. tup = PyTuple_Pack(1, key);
  1049. if (!tup) return NULL;
  1050. PyErr_SetObject(PyExc_KeyError, tup);
  1051. Py_DECREF(tup);
  1052. return NULL;
  1053. }
  1054. value = PyEval_CallObject(factory, NULL);
  1055. if (value == NULL)
  1056. return value;
  1057. if (PyObject_SetItem((PyObject *)dd, key, value) < 0) {
  1058. Py_DECREF(value);
  1059. return NULL;
  1060. }
  1061. return value;
  1062. }
  1063. PyDoc_STRVAR(defdict_copy_doc, "D.copy() -> a shallow copy of D.");
  1064. static PyObject *
  1065. defdict_copy(defdictobject *dd)
  1066. {
  1067. /* This calls the object's class. That only works for subclasses
  1068. whose class constructor has the same signature. Subclasses that
  1069. define a different constructor signature must override copy().
  1070. */
  1071. if (dd->default_factory == NULL)
  1072. return PyObject_CallFunctionObjArgs((PyObject*)Py_TYPE(dd), Py_None, dd, NULL);
  1073. return PyObject_CallFunctionObjArgs((PyObject*)Py_TYPE(dd),
  1074. dd->default_factory, dd, NULL);
  1075. }
  1076. static PyObject *
  1077. defdict_reduce(defdictobject *dd)
  1078. {
  1079. /* __reduce__ must return a 5-tuple as follows:
  1080. - factory function
  1081. - tuple of args for the factory function
  1082. - additional state (here None)
  1083. - sequence iterator (here None)
  1084. - dictionary iterator (yielding successive (key, value) pairs
  1085. This API is used by pickle.py and copy.py.
  1086. For this to be useful with pickle.py, the default_factory
  1087. must be picklable; e.g., None, a built-in, or a global
  1088. function in a module or package.
  1089. Both shallow and deep copying are supported, but for deep
  1090. copying, the default_factory must be deep-copyable; e.g. None,
  1091. or a built-in (functions are not copyable at this time).
  1092. This only works for subclasses as long as their constructor
  1093. signature is compatible; the first argument must be the
  1094. optional default_factory, defaulting to None.
  1095. */
  1096. PyObject *args;
  1097. PyObject *items;
  1098. PyObject *result;
  1099. if (dd->default_factory == NULL || dd->default_factory == Py_None)
  1100. args = PyTuple_New(0);
  1101. else
  1102. args = PyTuple_Pack(1, dd->default_factory);
  1103. if (args == NULL)
  1104. return NULL;
  1105. items = PyObject_CallMethod((PyObject *)dd, "iteritems", "()");
  1106. if (items == NULL) {
  1107. Py_DECREF(args);
  1108. return NULL;
  1109. }
  1110. result = PyTuple_Pack(5, Py_TYPE(dd), args,
  1111. Py_None, Py_None, items);
  1112. Py_DECREF(items);
  1113. Py_DECREF(args);
  1114. return result;
  1115. }
  1116. static PyMethodDef defdict_methods[] = {
  1117. {"__missing__", (PyCFunction)defdict_missing, METH_O,
  1118. defdict_missing_doc},
  1119. {"copy", (PyCFunction)defdict_copy, METH_NOARGS,
  1120. defdict_copy_doc},
  1121. {"__copy__", (PyCFunction)defdict_copy, METH_NOARGS,
  1122. defdict_copy_doc},
  1123. {"__reduce__", (PyCFunction)defdict_reduce, METH_NOARGS,
  1124. reduce_doc},
  1125. {NULL}
  1126. };
  1127. static PyMemberDef defdict_members[] = {
  1128. {"default_factory", T_OBJECT,
  1129. offsetof(defdictobject, default_factory), 0,
  1130. PyDoc_STR("Factory for default value called by __missing__().")},
  1131. {NULL}
  1132. };
  1133. static void
  1134. defdict_dealloc(defdictobject *dd)
  1135. {
  1136. Py_CLEAR(dd->default_factory);
  1137. PyDict_Type.tp_dealloc((PyObject *)dd);
  1138. }
  1139. static int
  1140. defdict_print(defdictobject *dd, FILE *fp, int flags)
  1141. {
  1142. int sts;
  1143. Py_BEGIN_ALLOW_THREADS
  1144. fprintf(fp, "defaultdict(");
  1145. Py_END_ALLOW_THREADS
  1146. if (dd->default_factory == NULL) {
  1147. Py_BEGIN_ALLOW_THREADS
  1148. fprintf(fp, "None");
  1149. Py_END_ALLOW_THREADS
  1150. } else {
  1151. PyObject_Print(dd->default_factory, fp, 0);
  1152. }
  1153. Py_BEGIN_ALLOW_THREADS
  1154. fprintf(fp, ", ");
  1155. Py_END_ALLOW_THREADS
  1156. sts = PyDict_Type.tp_print((PyObject *)dd, fp, 0);
  1157. Py_BEGIN_ALLOW_THREADS
  1158. fprintf(fp, ")");
  1159. Py_END_ALLOW_THREADS
  1160. return sts;
  1161. }
  1162. static PyObject *
  1163. defdict_repr(defdictobject *dd)
  1164. {
  1165. PyObject *defrepr;
  1166. PyObject *baserepr;
  1167. PyObject *result;
  1168. baserepr = PyDict_Type.tp_repr((PyObject *)dd);
  1169. if (baserepr == NULL)
  1170. return NULL;
  1171. if (dd->default_factory == NULL)
  1172. defrepr = PyString_FromString("None");
  1173. else
  1174. {
  1175. int status = Py_ReprEnter(dd->default_factory);
  1176. if (status != 0) {
  1177. if (status < 0)
  1178. return NULL;
  1179. defrepr = PyString_FromString("...");
  1180. }
  1181. else
  1182. defrepr = PyObject_Repr(dd->default_factory);
  1183. Py_ReprLeave(dd->default_factory);
  1184. }
  1185. if (defrepr == NULL) {
  1186. Py_DECREF(baserepr);
  1187. return NULL;
  1188. }
  1189. result = PyString_FromFormat("defaultdict(%s, %s)",
  1190. PyString_AS_STRING(defrepr),
  1191. PyString_AS_STRING(baserepr));
  1192. Py_DECREF(defrepr);
  1193. Py_DECREF(baserepr);
  1194. return result;
  1195. }
  1196. static int
  1197. defdict_traverse(PyObject *self, visitproc visit, void *arg)
  1198. {
  1199. Py_VISIT(((defdictobject *)self)->default_factory);
  1200. return PyDict_Type.tp_traverse(self, visit, arg);
  1201. }
  1202. static int
  1203. defdict_tp_clear(defdictobject *dd)
  1204. {
  1205. Py_CLEAR(dd->default_factory);
  1206. return PyDict_Type.tp_clear((PyObject *)dd);
  1207. }
  1208. static int
  1209. defdict_init(PyObject *self, PyObject *args, PyObject *kwds)
  1210. {
  1211. defdictobject *dd = (defdictobject *)self;
  1212. PyObject *olddefault = dd->default_factory;
  1213. PyObject *newdefault = NULL;
  1214. PyObject *newargs;
  1215. int result;
  1216. if (args == NULL || !PyTuple_Check(args))
  1217. newargs = PyTuple_New(0);
  1218. else {
  1219. Py_ssize_t n = PyTuple_GET_SIZE(args);
  1220. if (n > 0) {
  1221. newdefault = PyTuple_GET_ITEM(args, 0);
  1222. if (!PyCallable_Check(newdefault) && newdefault != Py_None) {
  1223. PyErr_SetString(PyExc_TypeError,
  1224. "first argument must be callable");
  1225. return -1;
  1226. }
  1227. }
  1228. newargs = PySequence_GetSlice(args, 1, n);
  1229. }
  1230. if (newargs == NULL)
  1231. return -1;
  1232. Py_XINCREF(newdefault);
  1233. dd->default_factory = newdefault;
  1234. result = PyDict_Type.tp_init(self, newargs, kwds);
  1235. Py_DECREF(newargs);
  1236. Py_XDECREF(olddefault);
  1237. return result;
  1238. }
  1239. PyDoc_STRVAR(defdict_doc,
  1240. "defaultdict(default_factory) --> dict with default factory\n\
  1241. \n\
  1242. The default factory is called without arguments to produce\n\
  1243. a new value when a key is not present, in __getitem__ only.\n\
  1244. A defaultdict compares equal to a dict with the same items.\n\
  1245. ");
  1246. /* See comment in xxsubtype.c */
  1247. #define DEFERRED_ADDRESS(ADDR) 0
  1248. static PyTypeObject defdict_type = {
  1249. PyVarObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type), 0)
  1250. "collections.defaultdict", /* tp_name */
  1251. sizeof(defdictobject), /* tp_basicsize */
  1252. 0, /* tp_itemsize */
  1253. /* methods */
  1254. (destructor)defdict_dealloc, /* tp_dealloc */
  1255. (printfunc)defdict_print, /* tp_print */
  1256. 0, /* tp_getattr */
  1257. 0, /* tp_setattr */
  1258. 0, /* tp_compare */
  1259. (reprfunc)defdict_repr, /* tp_repr */
  1260. 0, /* tp_as_number */
  1261. 0, /* tp_as_sequence */
  1262. 0, /* tp_as_mapping */
  1263. 0, /* tp_hash */
  1264. 0, /* tp_call */
  1265. 0, /* tp_str */
  1266. PyObject_GenericGetAttr, /* tp_getattro */
  1267. 0, /* tp_setattro */
  1268. 0, /* tp_as_buffer */
  1269. Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC |
  1270. Py_TPFLAGS_HAVE_WEAKREFS, /* tp_flags */
  1271. defdict_doc, /* tp_doc */
  1272. defdict_traverse, /* tp_traverse */
  1273. (inquiry)defdict_tp_clear, /* tp_clear */
  1274. 0, /* tp_richcompare */
  1275. 0, /* tp_weaklistoffset*/
  1276. 0, /* tp_iter */
  1277. 0, /* tp_iternext */
  1278. defdict_methods, /* tp_methods */
  1279. defdict_members, /* tp_members */
  1280. 0, /* tp_getset */
  1281. DEFERRED_ADDRESS(&PyDict_Type), /* tp_base */
  1282. 0, /* tp_dict */
  1283. 0, /* tp_descr_get */
  1284. 0, /* tp_descr_set */
  1285. 0, /* tp_dictoffset */
  1286. defdict_init, /* tp_init */
  1287. PyType_GenericAlloc, /* tp_alloc */
  1288. 0, /* tp_new */
  1289. PyObject_GC_Del, /* tp_free */
  1290. };
  1291. /* module level code ********************************************************/
  1292. PyDoc_STRVAR(module_doc,
  1293. "High performance data structures.\n\
  1294. - deque: ordered collection accessible from endpoints only\n\
  1295. - defaultdict: dict subclass with a default value factory\n\
  1296. ");
  1297. PyMODINIT_FUNC
  1298. init_collections(void)
  1299. {
  1300. PyObject *m;
  1301. m = Py_InitModule3("_collections", NULL, module_doc);
  1302. if (m == NULL)
  1303. return;
  1304. if (PyType_Ready(&deque_type) < 0)
  1305. return;
  1306. Py_INCREF(&deque_type);
  1307. PyModule_AddObject(m, "deque", (PyObject *)&deque_type);
  1308. defdict_type.tp_base = &PyDict_Type;
  1309. if (PyType_Ready(&defdict_type) < 0)
  1310. return;
  1311. Py_INCREF(&defdict_type);
  1312. PyModule_AddObject(m, "defaultdict", (PyObject *)&defdict_type);
  1313. if (PyType_Ready(&dequeiter_type) < 0)
  1314. return;
  1315. if (PyType_Ready(&dequereviter_type) < 0)
  1316. return;
  1317. return;
  1318. }