1990-10-14 09:07:46 -03:00
|
|
|
/* List object implementation */
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
#include "Python.h"
|
2012-03-22 10:38:16 -03:00
|
|
|
#include "accu.h"
|
1997-05-02 00:12:38 -03:00
|
|
|
|
1994-08-29 09:45:32 -03:00
|
|
|
#ifdef STDC_HEADERS
|
|
|
|
#include <stddef.h>
|
|
|
|
#else
|
2010-05-09 12:52:27 -03:00
|
|
|
#include <sys/types.h> /* For size_t */
|
1994-08-29 09:45:32 -03:00
|
|
|
#endif
|
1990-10-14 09:07:46 -03:00
|
|
|
|
2004-07-30 23:24:20 -03:00
|
|
|
/* Ensure ob_item has room for at least newsize elements, and set
|
|
|
|
* ob_size to newsize. If newsize > ob_size on entry, the content
|
|
|
|
* of the new slots at exit is undefined heap trash; it's the caller's
|
2011-03-16 06:05:33 -03:00
|
|
|
* responsibility to overwrite them with sane values.
|
2004-07-30 23:24:20 -03:00
|
|
|
* The number of allocated elements may grow, shrink, or stay the same.
|
|
|
|
* Failure is impossible if newsize <= self.allocated on entry, although
|
|
|
|
* that partly relies on an assumption that the system realloc() never
|
|
|
|
* fails when passed a number of bytes <= the number of bytes last
|
|
|
|
* allocated (the C standard doesn't guarantee this, but it's hard to
|
|
|
|
* imagine a realloc implementation where it wouldn't be true).
|
|
|
|
* Note that self->ob_item may change, and even if newsize is less
|
|
|
|
* than ob_size on entry.
|
|
|
|
*/
|
1995-01-26 18:59:43 -04:00
|
|
|
static int
|
2006-02-15 13:27:45 -04:00
|
|
|
list_resize(PyListObject *self, Py_ssize_t newsize)
|
* Optimized list appends and pops by making fewer calls the underlying system
realloc(). This is achieved by tracking the overallocation size in a new
field and using that information to skip calls to realloc() whenever
possible.
* Simplified and tightened the amount of overallocation. For larger lists,
this overallocates by 1/8th (compared to the previous scheme which ranged
between 1/4th to 1/32nd over-allocation). For smaller lists (n<6), the
maximum overallocation is one byte (formerly it could be upto eight bytes).
This saves memory in applications with large numbers of small lists.
* Eliminated the NRESIZE macro in favor of a new, static list_resize function
that encapsulates the resizing logic. Coverting this back to macro would
give a small (under 1%) speed-up. This was too small to warrant the loss
of readability, maintainability, and de-coupling.
* Some functions using NRESIZE had grown unnecessarily complex in their
efforts to bend to the macro's calling pattern. With the new list_resize
function in place, those other functions could be simplified. That is
being saved for a separate patch.
* The ob_item==NULL check could be eliminated from the new list_resize
function. This would entail finding each piece of code that sets ob_item
to NULL and adding a new line to invalidate the overallocation tracking
field. Rather than impose a new requirement on other pieces of list code,
it was preferred to leave the NULL check in place and retain the benefits
of decoupling, maintainability and information hiding (only PyList_New()
and list_sort() need to know about the new field). This approach also
reduces the odds of breaking an extension module.
(Collaborative effort by Raymond Hettinger, Hye-Shik Chang, Tim Peters,
and Armin Rigo.)
2004-02-13 07:36:39 -04:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
PyObject **items;
|
|
|
|
size_t new_allocated;
|
|
|
|
Py_ssize_t allocated = self->allocated;
|
|
|
|
|
|
|
|
/* Bypass realloc() when a previous overallocation is large enough
|
|
|
|
to accommodate the newsize. If the newsize falls lower than half
|
|
|
|
the allocated size, then proceed with the realloc() to shrink the list.
|
|
|
|
*/
|
|
|
|
if (allocated >= newsize && newsize >= (allocated >> 1)) {
|
|
|
|
assert(self->ob_item != NULL || newsize == 0);
|
|
|
|
Py_SIZE(self) = newsize;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This over-allocates proportional to the list size, making room
|
|
|
|
* for additional growth. The over-allocation is mild, but is
|
|
|
|
* enough to give linear-time amortized behavior over a long
|
|
|
|
* sequence of appends() in the presence of a poorly-performing
|
|
|
|
* system realloc().
|
|
|
|
* The growth pattern is: 0, 4, 8, 16, 25, 35, 46, 58, 72, 88, ...
|
|
|
|
*/
|
|
|
|
new_allocated = (newsize >> 3) + (newsize < 9 ? 3 : 6);
|
|
|
|
|
|
|
|
/* check for integer overflow */
|
2016-09-07 13:26:18 -03:00
|
|
|
if (new_allocated > SIZE_MAX - newsize) {
|
2010-05-09 12:52:27 -03:00
|
|
|
PyErr_NoMemory();
|
|
|
|
return -1;
|
|
|
|
} else {
|
|
|
|
new_allocated += newsize;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (newsize == 0)
|
|
|
|
new_allocated = 0;
|
|
|
|
items = self->ob_item;
|
2016-09-07 13:26:18 -03:00
|
|
|
if (new_allocated <= (SIZE_MAX / sizeof(PyObject *)))
|
2010-05-09 12:52:27 -03:00
|
|
|
PyMem_RESIZE(items, PyObject *, new_allocated);
|
|
|
|
else
|
|
|
|
items = NULL;
|
|
|
|
if (items == NULL) {
|
|
|
|
PyErr_NoMemory();
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
self->ob_item = items;
|
|
|
|
Py_SIZE(self) = newsize;
|
|
|
|
self->allocated = new_allocated;
|
|
|
|
return 0;
|
* Optimized list appends and pops by making fewer calls the underlying system
realloc(). This is achieved by tracking the overallocation size in a new
field and using that information to skip calls to realloc() whenever
possible.
* Simplified and tightened the amount of overallocation. For larger lists,
this overallocates by 1/8th (compared to the previous scheme which ranged
between 1/4th to 1/32nd over-allocation). For smaller lists (n<6), the
maximum overallocation is one byte (formerly it could be upto eight bytes).
This saves memory in applications with large numbers of small lists.
* Eliminated the NRESIZE macro in favor of a new, static list_resize function
that encapsulates the resizing logic. Coverting this back to macro would
give a small (under 1%) speed-up. This was too small to warrant the loss
of readability, maintainability, and de-coupling.
* Some functions using NRESIZE had grown unnecessarily complex in their
efforts to bend to the macro's calling pattern. With the new list_resize
function in place, those other functions could be simplified. That is
being saved for a separate patch.
* The ob_item==NULL check could be eliminated from the new list_resize
function. This would entail finding each piece of code that sets ob_item
to NULL and adding a new line to invalidate the overallocation tracking
field. Rather than impose a new requirement on other pieces of list code,
it was preferred to leave the NULL check in place and retain the benefits
of decoupling, maintainability and information hiding (only PyList_New()
and list_sort() need to know about the new field). This approach also
reduces the odds of breaking an extension module.
(Collaborative effort by Raymond Hettinger, Hye-Shik Chang, Tim Peters,
and Armin Rigo.)
2004-02-13 07:36:39 -04:00
|
|
|
}
|
1995-01-26 18:59:43 -04:00
|
|
|
|
Merged revisions 60481,60485,60489-60492,60494-60496,60498-60499,60501-60503,60505-60506,60508-60509,60523-60524,60532,60543,60545,60547-60548,60552,60554,60556-60559,60561-60562,60569,60571-60572,60574,60576-60583,60585-60586,60589,60591,60594-60595,60597-60598,60600-60601,60606-60612,60615,60617-60678 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r60618 | walter.doerwald | 2008-02-06 15:31:55 +0100 (Wed, 06 Feb 2008) | 6 lines
Remove month parameter from Calendar.yeardatescalendar(),
Calendar.yeardays2calendar() and Calendar.yeardayscalendar() as the methods
don't have such a parameter. Fixes issue #2017.
Rewrap content to 80 chars.
........
r60622 | facundo.batista | 2008-02-06 20:28:49 +0100 (Wed, 06 Feb 2008) | 4 lines
Fixes issue 1959. Converted tests to unittest.
Thanks Giampaolo Rodola.
........
r60626 | thomas.heller | 2008-02-06 21:29:17 +0100 (Wed, 06 Feb 2008) | 3 lines
Fixed refcounts and error handling.
Should not be merged to py3k branch.
........
r60630 | mark.dickinson | 2008-02-06 23:10:50 +0100 (Wed, 06 Feb 2008) | 4 lines
Issue 1979: Make Decimal comparisons (other than !=, ==) involving NaN
raise InvalidOperation (and return False if InvalidOperation is trapped).
........
r60632 | mark.dickinson | 2008-02-06 23:25:16 +0100 (Wed, 06 Feb 2008) | 2 lines
Remove incorrect usage of :const: in documentation.
........
r60634 | georg.brandl | 2008-02-07 00:45:51 +0100 (Thu, 07 Feb 2008) | 2 lines
Revert accidental changes to test_queue in r60605.
........
r60636 | raymond.hettinger | 2008-02-07 01:54:20 +0100 (Thu, 07 Feb 2008) | 1 line
Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence.
........
r60637 | mark.dickinson | 2008-02-07 02:14:23 +0100 (Thu, 07 Feb 2008) | 2 lines
Fix broken link in decimal documentation.
........
r60638 | mark.dickinson | 2008-02-07 02:42:06 +0100 (Thu, 07 Feb 2008) | 3 lines
IEEE 754 should be IEEE 854; give precise reference for
comparisons involving NaNs.
........
r60639 | raymond.hettinger | 2008-02-07 03:12:52 +0100 (Thu, 07 Feb 2008) | 1 line
Return ints instead of longs for tuple.count() and tuple.index().
........
r60640 | raymond.hettinger | 2008-02-07 04:10:33 +0100 (Thu, 07 Feb 2008) | 1 line
Merge 60627.
........
r60641 | raymond.hettinger | 2008-02-07 04:25:46 +0100 (Thu, 07 Feb 2008) | 1 line
Merge r60628, r60631, and r60633. Register UserList and UserString will the appropriate ABCs.
........
r60642 | brett.cannon | 2008-02-07 08:47:31 +0100 (Thu, 07 Feb 2008) | 3 lines
Cast a struct to a void pointer so as to do a type-safe pointer comparison
(mistmatch found by clang).
........
r60643 | brett.cannon | 2008-02-07 09:04:07 +0100 (Thu, 07 Feb 2008) | 2 lines
Remove unnecessary curly braces around an int literal.
........
r60644 | andrew.kuchling | 2008-02-07 12:43:47 +0100 (Thu, 07 Feb 2008) | 1 line
Update URL
........
r60645 | facundo.batista | 2008-02-07 17:16:29 +0100 (Thu, 07 Feb 2008) | 4 lines
Fixes issue 2026. Tests converted to unittest. Thanks
Giampaolo Rodola.
........
r60646 | christian.heimes | 2008-02-07 18:15:30 +0100 (Thu, 07 Feb 2008) | 1 line
Added some statistics code to dict and list object code. I wanted to test how a larger freelist affects the reusage of freed objects. Contrary to my gut feelings 80 objects is more than fine for small apps. I haven't profiled a large app yet.
........
r60648 | facundo.batista | 2008-02-07 20:06:52 +0100 (Thu, 07 Feb 2008) | 6 lines
Fixes Issue 1401. When redirected, a possible POST get converted
to GET, so it loses its payload. So, it also must lose the
headers related to the payload (if it has no content any more,
it shouldn't indicate content length and type).
........
r60649 | walter.doerwald | 2008-02-07 20:30:22 +0100 (Thu, 07 Feb 2008) | 3 lines
Clarify that the output of TextCalendar.formatmonth() and
TextCalendar.formatyear() for custom instances won't be influenced by calls
to the module global setfirstweekday() function. Fixes #2018.
........
r60651 | walter.doerwald | 2008-02-07 20:48:34 +0100 (Thu, 07 Feb 2008) | 3 lines
Fix documentation for Calendar.iterweekdays(): firstweekday is a property.
Fixes second part of #2018.
........
r60653 | walter.doerwald | 2008-02-07 20:57:32 +0100 (Thu, 07 Feb 2008) | 2 lines
Fix typo in docstring for Calendar.itermonthdays().
........
r60655 | raymond.hettinger | 2008-02-07 21:04:37 +0100 (Thu, 07 Feb 2008) | 1 line
The float conversion recipe is simpler in Py2.6
........
r60657 | raymond.hettinger | 2008-02-07 21:10:49 +0100 (Thu, 07 Feb 2008) | 1 line
Fix typo
........
r60660 | brett.cannon | 2008-02-07 23:27:10 +0100 (Thu, 07 Feb 2008) | 3 lines
Make sure a switch statement does not have repetitive case statements.
Error found through LLVM post-2.1 svn.
........
r60661 | christian.heimes | 2008-02-08 01:11:31 +0100 (Fri, 08 Feb 2008) | 1 line
Deallocate content of the dict free list on interpreter shutdown
........
r60662 | christian.heimes | 2008-02-08 01:14:34 +0100 (Fri, 08 Feb 2008) | 1 line
Use prefix decrement
........
r60663 | amaury.forgeotdarc | 2008-02-08 01:56:02 +0100 (Fri, 08 Feb 2008) | 5 lines
issue 2045: Infinite recursion when printing a subclass of defaultdict,
if default_factory is set to a bound method.
Will backport.
........
r60667 | jeffrey.yasskin | 2008-02-08 07:45:40 +0100 (Fri, 08 Feb 2008) | 2 lines
Oops! 2.6's Rational.__ne__ didn't work.
........
r60671 | hyeshik.chang | 2008-02-08 18:10:20 +0100 (Fri, 08 Feb 2008) | 2 lines
Update big5hkscs codec to conform to the HKSCS:2004 revision.
........
r60673 | raymond.hettinger | 2008-02-08 23:30:04 +0100 (Fri, 08 Feb 2008) | 4 lines
Remove unnecessary modulo division.
The preceding test guarantees that 0 <= i < len.
........
r60674 | raymond.hettinger | 2008-02-09 00:02:27 +0100 (Sat, 09 Feb 2008) | 1 line
Speed-up __iter__() mixin method.
........
r60675 | raymond.hettinger | 2008-02-09 00:34:21 +0100 (Sat, 09 Feb 2008) | 1 line
Fill-in missing Set comparisons
........
r60677 | raymond.hettinger | 2008-02-09 00:57:06 +0100 (Sat, 09 Feb 2008) | 1 line
Add advice on choosing between DictMixin and MutableMapping
........
2008-02-08 22:18:51 -04:00
|
|
|
/* Debug statistic to compare allocations with reuse through the free list */
|
|
|
|
#undef SHOW_ALLOC_COUNT
|
|
|
|
#ifdef SHOW_ALLOC_COUNT
|
|
|
|
static size_t count_alloc = 0;
|
|
|
|
static size_t count_reuse = 0;
|
|
|
|
|
|
|
|
static void
|
|
|
|
show_alloc(void)
|
|
|
|
{
|
2016-07-03 15:03:53 -03:00
|
|
|
PyObject *xoptions, *value;
|
|
|
|
_Py_IDENTIFIER(showalloccount);
|
|
|
|
|
|
|
|
xoptions = PySys_GetXOptions();
|
|
|
|
if (xoptions == NULL)
|
|
|
|
return;
|
|
|
|
value = _PyDict_GetItemId(xoptions, &PyId_showalloccount);
|
|
|
|
if (value != Py_True)
|
|
|
|
return;
|
|
|
|
|
2010-05-09 12:52:27 -03:00
|
|
|
fprintf(stderr, "List allocations: %" PY_FORMAT_SIZE_T "d\n",
|
|
|
|
count_alloc);
|
|
|
|
fprintf(stderr, "List reuse through freelist: %" PY_FORMAT_SIZE_T
|
|
|
|
"d\n", count_reuse);
|
|
|
|
fprintf(stderr, "%.2f%% reuse rate\n\n",
|
|
|
|
(100.0*count_reuse/(count_alloc+count_reuse)));
|
Merged revisions 60481,60485,60489-60492,60494-60496,60498-60499,60501-60503,60505-60506,60508-60509,60523-60524,60532,60543,60545,60547-60548,60552,60554,60556-60559,60561-60562,60569,60571-60572,60574,60576-60583,60585-60586,60589,60591,60594-60595,60597-60598,60600-60601,60606-60612,60615,60617-60678 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r60618 | walter.doerwald | 2008-02-06 15:31:55 +0100 (Wed, 06 Feb 2008) | 6 lines
Remove month parameter from Calendar.yeardatescalendar(),
Calendar.yeardays2calendar() and Calendar.yeardayscalendar() as the methods
don't have such a parameter. Fixes issue #2017.
Rewrap content to 80 chars.
........
r60622 | facundo.batista | 2008-02-06 20:28:49 +0100 (Wed, 06 Feb 2008) | 4 lines
Fixes issue 1959. Converted tests to unittest.
Thanks Giampaolo Rodola.
........
r60626 | thomas.heller | 2008-02-06 21:29:17 +0100 (Wed, 06 Feb 2008) | 3 lines
Fixed refcounts and error handling.
Should not be merged to py3k branch.
........
r60630 | mark.dickinson | 2008-02-06 23:10:50 +0100 (Wed, 06 Feb 2008) | 4 lines
Issue 1979: Make Decimal comparisons (other than !=, ==) involving NaN
raise InvalidOperation (and return False if InvalidOperation is trapped).
........
r60632 | mark.dickinson | 2008-02-06 23:25:16 +0100 (Wed, 06 Feb 2008) | 2 lines
Remove incorrect usage of :const: in documentation.
........
r60634 | georg.brandl | 2008-02-07 00:45:51 +0100 (Thu, 07 Feb 2008) | 2 lines
Revert accidental changes to test_queue in r60605.
........
r60636 | raymond.hettinger | 2008-02-07 01:54:20 +0100 (Thu, 07 Feb 2008) | 1 line
Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence.
........
r60637 | mark.dickinson | 2008-02-07 02:14:23 +0100 (Thu, 07 Feb 2008) | 2 lines
Fix broken link in decimal documentation.
........
r60638 | mark.dickinson | 2008-02-07 02:42:06 +0100 (Thu, 07 Feb 2008) | 3 lines
IEEE 754 should be IEEE 854; give precise reference for
comparisons involving NaNs.
........
r60639 | raymond.hettinger | 2008-02-07 03:12:52 +0100 (Thu, 07 Feb 2008) | 1 line
Return ints instead of longs for tuple.count() and tuple.index().
........
r60640 | raymond.hettinger | 2008-02-07 04:10:33 +0100 (Thu, 07 Feb 2008) | 1 line
Merge 60627.
........
r60641 | raymond.hettinger | 2008-02-07 04:25:46 +0100 (Thu, 07 Feb 2008) | 1 line
Merge r60628, r60631, and r60633. Register UserList and UserString will the appropriate ABCs.
........
r60642 | brett.cannon | 2008-02-07 08:47:31 +0100 (Thu, 07 Feb 2008) | 3 lines
Cast a struct to a void pointer so as to do a type-safe pointer comparison
(mistmatch found by clang).
........
r60643 | brett.cannon | 2008-02-07 09:04:07 +0100 (Thu, 07 Feb 2008) | 2 lines
Remove unnecessary curly braces around an int literal.
........
r60644 | andrew.kuchling | 2008-02-07 12:43:47 +0100 (Thu, 07 Feb 2008) | 1 line
Update URL
........
r60645 | facundo.batista | 2008-02-07 17:16:29 +0100 (Thu, 07 Feb 2008) | 4 lines
Fixes issue 2026. Tests converted to unittest. Thanks
Giampaolo Rodola.
........
r60646 | christian.heimes | 2008-02-07 18:15:30 +0100 (Thu, 07 Feb 2008) | 1 line
Added some statistics code to dict and list object code. I wanted to test how a larger freelist affects the reusage of freed objects. Contrary to my gut feelings 80 objects is more than fine for small apps. I haven't profiled a large app yet.
........
r60648 | facundo.batista | 2008-02-07 20:06:52 +0100 (Thu, 07 Feb 2008) | 6 lines
Fixes Issue 1401. When redirected, a possible POST get converted
to GET, so it loses its payload. So, it also must lose the
headers related to the payload (if it has no content any more,
it shouldn't indicate content length and type).
........
r60649 | walter.doerwald | 2008-02-07 20:30:22 +0100 (Thu, 07 Feb 2008) | 3 lines
Clarify that the output of TextCalendar.formatmonth() and
TextCalendar.formatyear() for custom instances won't be influenced by calls
to the module global setfirstweekday() function. Fixes #2018.
........
r60651 | walter.doerwald | 2008-02-07 20:48:34 +0100 (Thu, 07 Feb 2008) | 3 lines
Fix documentation for Calendar.iterweekdays(): firstweekday is a property.
Fixes second part of #2018.
........
r60653 | walter.doerwald | 2008-02-07 20:57:32 +0100 (Thu, 07 Feb 2008) | 2 lines
Fix typo in docstring for Calendar.itermonthdays().
........
r60655 | raymond.hettinger | 2008-02-07 21:04:37 +0100 (Thu, 07 Feb 2008) | 1 line
The float conversion recipe is simpler in Py2.6
........
r60657 | raymond.hettinger | 2008-02-07 21:10:49 +0100 (Thu, 07 Feb 2008) | 1 line
Fix typo
........
r60660 | brett.cannon | 2008-02-07 23:27:10 +0100 (Thu, 07 Feb 2008) | 3 lines
Make sure a switch statement does not have repetitive case statements.
Error found through LLVM post-2.1 svn.
........
r60661 | christian.heimes | 2008-02-08 01:11:31 +0100 (Fri, 08 Feb 2008) | 1 line
Deallocate content of the dict free list on interpreter shutdown
........
r60662 | christian.heimes | 2008-02-08 01:14:34 +0100 (Fri, 08 Feb 2008) | 1 line
Use prefix decrement
........
r60663 | amaury.forgeotdarc | 2008-02-08 01:56:02 +0100 (Fri, 08 Feb 2008) | 5 lines
issue 2045: Infinite recursion when printing a subclass of defaultdict,
if default_factory is set to a bound method.
Will backport.
........
r60667 | jeffrey.yasskin | 2008-02-08 07:45:40 +0100 (Fri, 08 Feb 2008) | 2 lines
Oops! 2.6's Rational.__ne__ didn't work.
........
r60671 | hyeshik.chang | 2008-02-08 18:10:20 +0100 (Fri, 08 Feb 2008) | 2 lines
Update big5hkscs codec to conform to the HKSCS:2004 revision.
........
r60673 | raymond.hettinger | 2008-02-08 23:30:04 +0100 (Fri, 08 Feb 2008) | 4 lines
Remove unnecessary modulo division.
The preceding test guarantees that 0 <= i < len.
........
r60674 | raymond.hettinger | 2008-02-09 00:02:27 +0100 (Sat, 09 Feb 2008) | 1 line
Speed-up __iter__() mixin method.
........
r60675 | raymond.hettinger | 2008-02-09 00:34:21 +0100 (Sat, 09 Feb 2008) | 1 line
Fill-in missing Set comparisons
........
r60677 | raymond.hettinger | 2008-02-09 00:57:06 +0100 (Sat, 09 Feb 2008) | 1 line
Add advice on choosing between DictMixin and MutableMapping
........
2008-02-08 22:18:51 -04:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2004-05-05 02:37:53 -03:00
|
|
|
/* Empty list reuse scheme to save calls to malloc and free */
|
Merged revisions 60481,60485,60489-60492,60494-60496,60498-60499,60501-60503,60505-60506,60508-60509,60523-60524,60532,60543,60545,60547-60548,60552,60554,60556-60559,60561-60562,60568-60598,60600-60616 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r60568 | christian.heimes | 2008-02-04 19:48:38 +0100 (Mon, 04 Feb 2008) | 1 line
Increase debugging to investige failing tests on some build bots
........
r60570 | christian.heimes | 2008-02-04 20:30:05 +0100 (Mon, 04 Feb 2008) | 1 line
Small adjustments for test compact freelist test. It's no passing on Windows as well.
........
r60573 | amaury.forgeotdarc | 2008-02-04 21:53:14 +0100 (Mon, 04 Feb 2008) | 2 lines
Correct quotes in NEWS file
........
r60575 | amaury.forgeotdarc | 2008-02-04 22:45:05 +0100 (Mon, 04 Feb 2008) | 13 lines
#1750076: Debugger did not step on every iteration of a while statement.
The mapping between bytecode offsets and source lines (lnotab) did not contain
an entry for the beginning of the loop.
Now it does, and the lnotab can be a bit larger:
in particular, several statements on the same line generate several entries.
However, this does not bother the settrace function, which will trigger only
one 'line' event.
The lnotab seems to be exactly the same as with python2.4.
........
r60584 | amaury.forgeotdarc | 2008-02-05 01:26:21 +0100 (Tue, 05 Feb 2008) | 3 lines
Change r60575 broke test_compile:
there is no need to emit co_lnotab item when both offsets are zeros.
........
r60587 | skip.montanaro | 2008-02-05 03:32:16 +0100 (Tue, 05 Feb 2008) | 1 line
sync with most recent version from python-mode sf project
........
r60588 | lars.gustaebel | 2008-02-05 12:51:40 +0100 (Tue, 05 Feb 2008) | 5 lines
Issue #2004: Use mode 0700 for temporary directories and default
permissions for missing directories.
(will backport to 2.5)
........
r60590 | georg.brandl | 2008-02-05 13:01:24 +0100 (Tue, 05 Feb 2008) | 2 lines
Convert external links to internal links. Fixes #2010.
........
r60592 | marc-andre.lemburg | 2008-02-05 15:50:40 +0100 (Tue, 05 Feb 2008) | 3 lines
Keep distutils Python 2.1 compatible (or even Python 2.4 in this case).
........
r60593 | andrew.kuchling | 2008-02-05 17:06:57 +0100 (Tue, 05 Feb 2008) | 5 lines
Update PEP URL.
(This code is duplicated between pydoc and DocXMLRPCServer; maybe it
should be refactored as a GHOP project.)
2.5.2 backport candidate.
........
r60596 | guido.van.rossum | 2008-02-05 18:32:15 +0100 (Tue, 05 Feb 2008) | 2 lines
In the experimental 'Scanner' feature, the group count was set wrong.
........
r60602 | facundo.batista | 2008-02-05 20:03:32 +0100 (Tue, 05 Feb 2008) | 3 lines
Issue 1951. Converts wave test cases to unittest.
........
r60603 | georg.brandl | 2008-02-05 20:07:10 +0100 (Tue, 05 Feb 2008) | 2 lines
Actually run the test.
........
r60604 | skip.montanaro | 2008-02-05 20:24:30 +0100 (Tue, 05 Feb 2008) | 2 lines
correct object name
........
r60605 | georg.brandl | 2008-02-05 20:58:17 +0100 (Tue, 05 Feb 2008) | 7 lines
* Use the same code to profile for test_profile and test_cprofile.
* Convert both to unittest.
* Use the same unit testing code.
* Include the expected output in both test files.
* Make it possible to regenerate the expected output by running
the file as a script with an '-r' argument.
........
r60613 | raymond.hettinger | 2008-02-06 02:49:00 +0100 (Wed, 06 Feb 2008) | 1 line
Sync-up with Py3k work.
........
r60614 | christian.heimes | 2008-02-06 13:44:34 +0100 (Wed, 06 Feb 2008) | 1 line
Limit free list of method and builtin function objects to 256 entries each.
........
r60616 | christian.heimes | 2008-02-06 14:33:44 +0100 (Wed, 06 Feb 2008) | 7 lines
Unified naming convention for free lists and their limits. All free lists
in Object/ are named ``free_list``, the counter ``numfree`` and the upper
limit is a macro ``PyName_MAXFREELIST`` inside an #ifndef block.
The chances should make it easier to adjust Python for platforms with
less memory, e.g. mobile phones.
........
2008-02-06 10:31:34 -04:00
|
|
|
#ifndef PyList_MAXFREELIST
|
|
|
|
#define PyList_MAXFREELIST 80
|
|
|
|
#endif
|
|
|
|
static PyListObject *free_list[PyList_MAXFREELIST];
|
|
|
|
static int numfree = 0;
|
2004-05-05 02:37:53 -03:00
|
|
|
|
2011-11-14 19:00:12 -04:00
|
|
|
int
|
|
|
|
PyList_ClearFreeList(void)
|
2004-10-07 00:58:07 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
PyListObject *op;
|
2011-11-14 19:00:12 -04:00
|
|
|
int ret = numfree;
|
2010-05-09 12:52:27 -03:00
|
|
|
while (numfree) {
|
|
|
|
op = free_list[--numfree];
|
|
|
|
assert(PyList_CheckExact(op));
|
|
|
|
PyObject_GC_Del(op);
|
|
|
|
}
|
2011-11-14 19:00:12 -04:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
PyList_Fini(void)
|
|
|
|
{
|
|
|
|
PyList_ClearFreeList();
|
2004-10-07 00:58:07 -03:00
|
|
|
}
|
|
|
|
|
2012-06-22 15:55:41 -03:00
|
|
|
/* Print summary info about the state of the optimized allocator */
|
|
|
|
void
|
|
|
|
_PyList_DebugMallocStats(FILE *out)
|
|
|
|
{
|
|
|
|
_PyDebugAllocatorStats(out,
|
|
|
|
"free PyListObject",
|
|
|
|
numfree, sizeof(PyListObject));
|
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
PyObject *
|
2006-02-15 13:27:45 -04:00
|
|
|
PyList_New(Py_ssize_t size)
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
PyListObject *op;
|
Merged revisions 60481,60485,60489-60492,60494-60496,60498-60499,60501-60503,60505-60506,60508-60509,60523-60524,60532,60543,60545,60547-60548,60552,60554,60556-60559,60561-60562,60569,60571-60572,60574,60576-60583,60585-60586,60589,60591,60594-60595,60597-60598,60600-60601,60606-60612,60615,60617-60678 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r60618 | walter.doerwald | 2008-02-06 15:31:55 +0100 (Wed, 06 Feb 2008) | 6 lines
Remove month parameter from Calendar.yeardatescalendar(),
Calendar.yeardays2calendar() and Calendar.yeardayscalendar() as the methods
don't have such a parameter. Fixes issue #2017.
Rewrap content to 80 chars.
........
r60622 | facundo.batista | 2008-02-06 20:28:49 +0100 (Wed, 06 Feb 2008) | 4 lines
Fixes issue 1959. Converted tests to unittest.
Thanks Giampaolo Rodola.
........
r60626 | thomas.heller | 2008-02-06 21:29:17 +0100 (Wed, 06 Feb 2008) | 3 lines
Fixed refcounts and error handling.
Should not be merged to py3k branch.
........
r60630 | mark.dickinson | 2008-02-06 23:10:50 +0100 (Wed, 06 Feb 2008) | 4 lines
Issue 1979: Make Decimal comparisons (other than !=, ==) involving NaN
raise InvalidOperation (and return False if InvalidOperation is trapped).
........
r60632 | mark.dickinson | 2008-02-06 23:25:16 +0100 (Wed, 06 Feb 2008) | 2 lines
Remove incorrect usage of :const: in documentation.
........
r60634 | georg.brandl | 2008-02-07 00:45:51 +0100 (Thu, 07 Feb 2008) | 2 lines
Revert accidental changes to test_queue in r60605.
........
r60636 | raymond.hettinger | 2008-02-07 01:54:20 +0100 (Thu, 07 Feb 2008) | 1 line
Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence.
........
r60637 | mark.dickinson | 2008-02-07 02:14:23 +0100 (Thu, 07 Feb 2008) | 2 lines
Fix broken link in decimal documentation.
........
r60638 | mark.dickinson | 2008-02-07 02:42:06 +0100 (Thu, 07 Feb 2008) | 3 lines
IEEE 754 should be IEEE 854; give precise reference for
comparisons involving NaNs.
........
r60639 | raymond.hettinger | 2008-02-07 03:12:52 +0100 (Thu, 07 Feb 2008) | 1 line
Return ints instead of longs for tuple.count() and tuple.index().
........
r60640 | raymond.hettinger | 2008-02-07 04:10:33 +0100 (Thu, 07 Feb 2008) | 1 line
Merge 60627.
........
r60641 | raymond.hettinger | 2008-02-07 04:25:46 +0100 (Thu, 07 Feb 2008) | 1 line
Merge r60628, r60631, and r60633. Register UserList and UserString will the appropriate ABCs.
........
r60642 | brett.cannon | 2008-02-07 08:47:31 +0100 (Thu, 07 Feb 2008) | 3 lines
Cast a struct to a void pointer so as to do a type-safe pointer comparison
(mistmatch found by clang).
........
r60643 | brett.cannon | 2008-02-07 09:04:07 +0100 (Thu, 07 Feb 2008) | 2 lines
Remove unnecessary curly braces around an int literal.
........
r60644 | andrew.kuchling | 2008-02-07 12:43:47 +0100 (Thu, 07 Feb 2008) | 1 line
Update URL
........
r60645 | facundo.batista | 2008-02-07 17:16:29 +0100 (Thu, 07 Feb 2008) | 4 lines
Fixes issue 2026. Tests converted to unittest. Thanks
Giampaolo Rodola.
........
r60646 | christian.heimes | 2008-02-07 18:15:30 +0100 (Thu, 07 Feb 2008) | 1 line
Added some statistics code to dict and list object code. I wanted to test how a larger freelist affects the reusage of freed objects. Contrary to my gut feelings 80 objects is more than fine for small apps. I haven't profiled a large app yet.
........
r60648 | facundo.batista | 2008-02-07 20:06:52 +0100 (Thu, 07 Feb 2008) | 6 lines
Fixes Issue 1401. When redirected, a possible POST get converted
to GET, so it loses its payload. So, it also must lose the
headers related to the payload (if it has no content any more,
it shouldn't indicate content length and type).
........
r60649 | walter.doerwald | 2008-02-07 20:30:22 +0100 (Thu, 07 Feb 2008) | 3 lines
Clarify that the output of TextCalendar.formatmonth() and
TextCalendar.formatyear() for custom instances won't be influenced by calls
to the module global setfirstweekday() function. Fixes #2018.
........
r60651 | walter.doerwald | 2008-02-07 20:48:34 +0100 (Thu, 07 Feb 2008) | 3 lines
Fix documentation for Calendar.iterweekdays(): firstweekday is a property.
Fixes second part of #2018.
........
r60653 | walter.doerwald | 2008-02-07 20:57:32 +0100 (Thu, 07 Feb 2008) | 2 lines
Fix typo in docstring for Calendar.itermonthdays().
........
r60655 | raymond.hettinger | 2008-02-07 21:04:37 +0100 (Thu, 07 Feb 2008) | 1 line
The float conversion recipe is simpler in Py2.6
........
r60657 | raymond.hettinger | 2008-02-07 21:10:49 +0100 (Thu, 07 Feb 2008) | 1 line
Fix typo
........
r60660 | brett.cannon | 2008-02-07 23:27:10 +0100 (Thu, 07 Feb 2008) | 3 lines
Make sure a switch statement does not have repetitive case statements.
Error found through LLVM post-2.1 svn.
........
r60661 | christian.heimes | 2008-02-08 01:11:31 +0100 (Fri, 08 Feb 2008) | 1 line
Deallocate content of the dict free list on interpreter shutdown
........
r60662 | christian.heimes | 2008-02-08 01:14:34 +0100 (Fri, 08 Feb 2008) | 1 line
Use prefix decrement
........
r60663 | amaury.forgeotdarc | 2008-02-08 01:56:02 +0100 (Fri, 08 Feb 2008) | 5 lines
issue 2045: Infinite recursion when printing a subclass of defaultdict,
if default_factory is set to a bound method.
Will backport.
........
r60667 | jeffrey.yasskin | 2008-02-08 07:45:40 +0100 (Fri, 08 Feb 2008) | 2 lines
Oops! 2.6's Rational.__ne__ didn't work.
........
r60671 | hyeshik.chang | 2008-02-08 18:10:20 +0100 (Fri, 08 Feb 2008) | 2 lines
Update big5hkscs codec to conform to the HKSCS:2004 revision.
........
r60673 | raymond.hettinger | 2008-02-08 23:30:04 +0100 (Fri, 08 Feb 2008) | 4 lines
Remove unnecessary modulo division.
The preceding test guarantees that 0 <= i < len.
........
r60674 | raymond.hettinger | 2008-02-09 00:02:27 +0100 (Sat, 09 Feb 2008) | 1 line
Speed-up __iter__() mixin method.
........
r60675 | raymond.hettinger | 2008-02-09 00:34:21 +0100 (Sat, 09 Feb 2008) | 1 line
Fill-in missing Set comparisons
........
r60677 | raymond.hettinger | 2008-02-09 00:57:06 +0100 (Sat, 09 Feb 2008) | 1 line
Add advice on choosing between DictMixin and MutableMapping
........
2008-02-08 22:18:51 -04:00
|
|
|
#ifdef SHOW_ALLOC_COUNT
|
2010-05-09 12:52:27 -03:00
|
|
|
static int initialized = 0;
|
|
|
|
if (!initialized) {
|
|
|
|
Py_AtExit(show_alloc);
|
|
|
|
initialized = 1;
|
|
|
|
}
|
Merged revisions 60481,60485,60489-60492,60494-60496,60498-60499,60501-60503,60505-60506,60508-60509,60523-60524,60532,60543,60545,60547-60548,60552,60554,60556-60559,60561-60562,60569,60571-60572,60574,60576-60583,60585-60586,60589,60591,60594-60595,60597-60598,60600-60601,60606-60612,60615,60617-60678 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r60618 | walter.doerwald | 2008-02-06 15:31:55 +0100 (Wed, 06 Feb 2008) | 6 lines
Remove month parameter from Calendar.yeardatescalendar(),
Calendar.yeardays2calendar() and Calendar.yeardayscalendar() as the methods
don't have such a parameter. Fixes issue #2017.
Rewrap content to 80 chars.
........
r60622 | facundo.batista | 2008-02-06 20:28:49 +0100 (Wed, 06 Feb 2008) | 4 lines
Fixes issue 1959. Converted tests to unittest.
Thanks Giampaolo Rodola.
........
r60626 | thomas.heller | 2008-02-06 21:29:17 +0100 (Wed, 06 Feb 2008) | 3 lines
Fixed refcounts and error handling.
Should not be merged to py3k branch.
........
r60630 | mark.dickinson | 2008-02-06 23:10:50 +0100 (Wed, 06 Feb 2008) | 4 lines
Issue 1979: Make Decimal comparisons (other than !=, ==) involving NaN
raise InvalidOperation (and return False if InvalidOperation is trapped).
........
r60632 | mark.dickinson | 2008-02-06 23:25:16 +0100 (Wed, 06 Feb 2008) | 2 lines
Remove incorrect usage of :const: in documentation.
........
r60634 | georg.brandl | 2008-02-07 00:45:51 +0100 (Thu, 07 Feb 2008) | 2 lines
Revert accidental changes to test_queue in r60605.
........
r60636 | raymond.hettinger | 2008-02-07 01:54:20 +0100 (Thu, 07 Feb 2008) | 1 line
Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence.
........
r60637 | mark.dickinson | 2008-02-07 02:14:23 +0100 (Thu, 07 Feb 2008) | 2 lines
Fix broken link in decimal documentation.
........
r60638 | mark.dickinson | 2008-02-07 02:42:06 +0100 (Thu, 07 Feb 2008) | 3 lines
IEEE 754 should be IEEE 854; give precise reference for
comparisons involving NaNs.
........
r60639 | raymond.hettinger | 2008-02-07 03:12:52 +0100 (Thu, 07 Feb 2008) | 1 line
Return ints instead of longs for tuple.count() and tuple.index().
........
r60640 | raymond.hettinger | 2008-02-07 04:10:33 +0100 (Thu, 07 Feb 2008) | 1 line
Merge 60627.
........
r60641 | raymond.hettinger | 2008-02-07 04:25:46 +0100 (Thu, 07 Feb 2008) | 1 line
Merge r60628, r60631, and r60633. Register UserList and UserString will the appropriate ABCs.
........
r60642 | brett.cannon | 2008-02-07 08:47:31 +0100 (Thu, 07 Feb 2008) | 3 lines
Cast a struct to a void pointer so as to do a type-safe pointer comparison
(mistmatch found by clang).
........
r60643 | brett.cannon | 2008-02-07 09:04:07 +0100 (Thu, 07 Feb 2008) | 2 lines
Remove unnecessary curly braces around an int literal.
........
r60644 | andrew.kuchling | 2008-02-07 12:43:47 +0100 (Thu, 07 Feb 2008) | 1 line
Update URL
........
r60645 | facundo.batista | 2008-02-07 17:16:29 +0100 (Thu, 07 Feb 2008) | 4 lines
Fixes issue 2026. Tests converted to unittest. Thanks
Giampaolo Rodola.
........
r60646 | christian.heimes | 2008-02-07 18:15:30 +0100 (Thu, 07 Feb 2008) | 1 line
Added some statistics code to dict and list object code. I wanted to test how a larger freelist affects the reusage of freed objects. Contrary to my gut feelings 80 objects is more than fine for small apps. I haven't profiled a large app yet.
........
r60648 | facundo.batista | 2008-02-07 20:06:52 +0100 (Thu, 07 Feb 2008) | 6 lines
Fixes Issue 1401. When redirected, a possible POST get converted
to GET, so it loses its payload. So, it also must lose the
headers related to the payload (if it has no content any more,
it shouldn't indicate content length and type).
........
r60649 | walter.doerwald | 2008-02-07 20:30:22 +0100 (Thu, 07 Feb 2008) | 3 lines
Clarify that the output of TextCalendar.formatmonth() and
TextCalendar.formatyear() for custom instances won't be influenced by calls
to the module global setfirstweekday() function. Fixes #2018.
........
r60651 | walter.doerwald | 2008-02-07 20:48:34 +0100 (Thu, 07 Feb 2008) | 3 lines
Fix documentation for Calendar.iterweekdays(): firstweekday is a property.
Fixes second part of #2018.
........
r60653 | walter.doerwald | 2008-02-07 20:57:32 +0100 (Thu, 07 Feb 2008) | 2 lines
Fix typo in docstring for Calendar.itermonthdays().
........
r60655 | raymond.hettinger | 2008-02-07 21:04:37 +0100 (Thu, 07 Feb 2008) | 1 line
The float conversion recipe is simpler in Py2.6
........
r60657 | raymond.hettinger | 2008-02-07 21:10:49 +0100 (Thu, 07 Feb 2008) | 1 line
Fix typo
........
r60660 | brett.cannon | 2008-02-07 23:27:10 +0100 (Thu, 07 Feb 2008) | 3 lines
Make sure a switch statement does not have repetitive case statements.
Error found through LLVM post-2.1 svn.
........
r60661 | christian.heimes | 2008-02-08 01:11:31 +0100 (Fri, 08 Feb 2008) | 1 line
Deallocate content of the dict free list on interpreter shutdown
........
r60662 | christian.heimes | 2008-02-08 01:14:34 +0100 (Fri, 08 Feb 2008) | 1 line
Use prefix decrement
........
r60663 | amaury.forgeotdarc | 2008-02-08 01:56:02 +0100 (Fri, 08 Feb 2008) | 5 lines
issue 2045: Infinite recursion when printing a subclass of defaultdict,
if default_factory is set to a bound method.
Will backport.
........
r60667 | jeffrey.yasskin | 2008-02-08 07:45:40 +0100 (Fri, 08 Feb 2008) | 2 lines
Oops! 2.6's Rational.__ne__ didn't work.
........
r60671 | hyeshik.chang | 2008-02-08 18:10:20 +0100 (Fri, 08 Feb 2008) | 2 lines
Update big5hkscs codec to conform to the HKSCS:2004 revision.
........
r60673 | raymond.hettinger | 2008-02-08 23:30:04 +0100 (Fri, 08 Feb 2008) | 4 lines
Remove unnecessary modulo division.
The preceding test guarantees that 0 <= i < len.
........
r60674 | raymond.hettinger | 2008-02-09 00:02:27 +0100 (Sat, 09 Feb 2008) | 1 line
Speed-up __iter__() mixin method.
........
r60675 | raymond.hettinger | 2008-02-09 00:34:21 +0100 (Sat, 09 Feb 2008) | 1 line
Fill-in missing Set comparisons
........
r60677 | raymond.hettinger | 2008-02-09 00:57:06 +0100 (Sat, 09 Feb 2008) | 1 line
Add advice on choosing between DictMixin and MutableMapping
........
2008-02-08 22:18:51 -04:00
|
|
|
#endif
|
2004-07-28 23:28:42 -03:00
|
|
|
|
2010-05-09 12:52:27 -03:00
|
|
|
if (size < 0) {
|
|
|
|
PyErr_BadInternalCall();
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (numfree) {
|
|
|
|
numfree--;
|
|
|
|
op = free_list[numfree];
|
|
|
|
_Py_NewReference((PyObject *)op);
|
Merged revisions 60481,60485,60489-60492,60494-60496,60498-60499,60501-60503,60505-60506,60508-60509,60523-60524,60532,60543,60545,60547-60548,60552,60554,60556-60559,60561-60562,60569,60571-60572,60574,60576-60583,60585-60586,60589,60591,60594-60595,60597-60598,60600-60601,60606-60612,60615,60617-60678 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r60618 | walter.doerwald | 2008-02-06 15:31:55 +0100 (Wed, 06 Feb 2008) | 6 lines
Remove month parameter from Calendar.yeardatescalendar(),
Calendar.yeardays2calendar() and Calendar.yeardayscalendar() as the methods
don't have such a parameter. Fixes issue #2017.
Rewrap content to 80 chars.
........
r60622 | facundo.batista | 2008-02-06 20:28:49 +0100 (Wed, 06 Feb 2008) | 4 lines
Fixes issue 1959. Converted tests to unittest.
Thanks Giampaolo Rodola.
........
r60626 | thomas.heller | 2008-02-06 21:29:17 +0100 (Wed, 06 Feb 2008) | 3 lines
Fixed refcounts and error handling.
Should not be merged to py3k branch.
........
r60630 | mark.dickinson | 2008-02-06 23:10:50 +0100 (Wed, 06 Feb 2008) | 4 lines
Issue 1979: Make Decimal comparisons (other than !=, ==) involving NaN
raise InvalidOperation (and return False if InvalidOperation is trapped).
........
r60632 | mark.dickinson | 2008-02-06 23:25:16 +0100 (Wed, 06 Feb 2008) | 2 lines
Remove incorrect usage of :const: in documentation.
........
r60634 | georg.brandl | 2008-02-07 00:45:51 +0100 (Thu, 07 Feb 2008) | 2 lines
Revert accidental changes to test_queue in r60605.
........
r60636 | raymond.hettinger | 2008-02-07 01:54:20 +0100 (Thu, 07 Feb 2008) | 1 line
Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence.
........
r60637 | mark.dickinson | 2008-02-07 02:14:23 +0100 (Thu, 07 Feb 2008) | 2 lines
Fix broken link in decimal documentation.
........
r60638 | mark.dickinson | 2008-02-07 02:42:06 +0100 (Thu, 07 Feb 2008) | 3 lines
IEEE 754 should be IEEE 854; give precise reference for
comparisons involving NaNs.
........
r60639 | raymond.hettinger | 2008-02-07 03:12:52 +0100 (Thu, 07 Feb 2008) | 1 line
Return ints instead of longs for tuple.count() and tuple.index().
........
r60640 | raymond.hettinger | 2008-02-07 04:10:33 +0100 (Thu, 07 Feb 2008) | 1 line
Merge 60627.
........
r60641 | raymond.hettinger | 2008-02-07 04:25:46 +0100 (Thu, 07 Feb 2008) | 1 line
Merge r60628, r60631, and r60633. Register UserList and UserString will the appropriate ABCs.
........
r60642 | brett.cannon | 2008-02-07 08:47:31 +0100 (Thu, 07 Feb 2008) | 3 lines
Cast a struct to a void pointer so as to do a type-safe pointer comparison
(mistmatch found by clang).
........
r60643 | brett.cannon | 2008-02-07 09:04:07 +0100 (Thu, 07 Feb 2008) | 2 lines
Remove unnecessary curly braces around an int literal.
........
r60644 | andrew.kuchling | 2008-02-07 12:43:47 +0100 (Thu, 07 Feb 2008) | 1 line
Update URL
........
r60645 | facundo.batista | 2008-02-07 17:16:29 +0100 (Thu, 07 Feb 2008) | 4 lines
Fixes issue 2026. Tests converted to unittest. Thanks
Giampaolo Rodola.
........
r60646 | christian.heimes | 2008-02-07 18:15:30 +0100 (Thu, 07 Feb 2008) | 1 line
Added some statistics code to dict and list object code. I wanted to test how a larger freelist affects the reusage of freed objects. Contrary to my gut feelings 80 objects is more than fine for small apps. I haven't profiled a large app yet.
........
r60648 | facundo.batista | 2008-02-07 20:06:52 +0100 (Thu, 07 Feb 2008) | 6 lines
Fixes Issue 1401. When redirected, a possible POST get converted
to GET, so it loses its payload. So, it also must lose the
headers related to the payload (if it has no content any more,
it shouldn't indicate content length and type).
........
r60649 | walter.doerwald | 2008-02-07 20:30:22 +0100 (Thu, 07 Feb 2008) | 3 lines
Clarify that the output of TextCalendar.formatmonth() and
TextCalendar.formatyear() for custom instances won't be influenced by calls
to the module global setfirstweekday() function. Fixes #2018.
........
r60651 | walter.doerwald | 2008-02-07 20:48:34 +0100 (Thu, 07 Feb 2008) | 3 lines
Fix documentation for Calendar.iterweekdays(): firstweekday is a property.
Fixes second part of #2018.
........
r60653 | walter.doerwald | 2008-02-07 20:57:32 +0100 (Thu, 07 Feb 2008) | 2 lines
Fix typo in docstring for Calendar.itermonthdays().
........
r60655 | raymond.hettinger | 2008-02-07 21:04:37 +0100 (Thu, 07 Feb 2008) | 1 line
The float conversion recipe is simpler in Py2.6
........
r60657 | raymond.hettinger | 2008-02-07 21:10:49 +0100 (Thu, 07 Feb 2008) | 1 line
Fix typo
........
r60660 | brett.cannon | 2008-02-07 23:27:10 +0100 (Thu, 07 Feb 2008) | 3 lines
Make sure a switch statement does not have repetitive case statements.
Error found through LLVM post-2.1 svn.
........
r60661 | christian.heimes | 2008-02-08 01:11:31 +0100 (Fri, 08 Feb 2008) | 1 line
Deallocate content of the dict free list on interpreter shutdown
........
r60662 | christian.heimes | 2008-02-08 01:14:34 +0100 (Fri, 08 Feb 2008) | 1 line
Use prefix decrement
........
r60663 | amaury.forgeotdarc | 2008-02-08 01:56:02 +0100 (Fri, 08 Feb 2008) | 5 lines
issue 2045: Infinite recursion when printing a subclass of defaultdict,
if default_factory is set to a bound method.
Will backport.
........
r60667 | jeffrey.yasskin | 2008-02-08 07:45:40 +0100 (Fri, 08 Feb 2008) | 2 lines
Oops! 2.6's Rational.__ne__ didn't work.
........
r60671 | hyeshik.chang | 2008-02-08 18:10:20 +0100 (Fri, 08 Feb 2008) | 2 lines
Update big5hkscs codec to conform to the HKSCS:2004 revision.
........
r60673 | raymond.hettinger | 2008-02-08 23:30:04 +0100 (Fri, 08 Feb 2008) | 4 lines
Remove unnecessary modulo division.
The preceding test guarantees that 0 <= i < len.
........
r60674 | raymond.hettinger | 2008-02-09 00:02:27 +0100 (Sat, 09 Feb 2008) | 1 line
Speed-up __iter__() mixin method.
........
r60675 | raymond.hettinger | 2008-02-09 00:34:21 +0100 (Sat, 09 Feb 2008) | 1 line
Fill-in missing Set comparisons
........
r60677 | raymond.hettinger | 2008-02-09 00:57:06 +0100 (Sat, 09 Feb 2008) | 1 line
Add advice on choosing between DictMixin and MutableMapping
........
2008-02-08 22:18:51 -04:00
|
|
|
#ifdef SHOW_ALLOC_COUNT
|
2010-05-09 12:52:27 -03:00
|
|
|
count_reuse++;
|
Merged revisions 60481,60485,60489-60492,60494-60496,60498-60499,60501-60503,60505-60506,60508-60509,60523-60524,60532,60543,60545,60547-60548,60552,60554,60556-60559,60561-60562,60569,60571-60572,60574,60576-60583,60585-60586,60589,60591,60594-60595,60597-60598,60600-60601,60606-60612,60615,60617-60678 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r60618 | walter.doerwald | 2008-02-06 15:31:55 +0100 (Wed, 06 Feb 2008) | 6 lines
Remove month parameter from Calendar.yeardatescalendar(),
Calendar.yeardays2calendar() and Calendar.yeardayscalendar() as the methods
don't have such a parameter. Fixes issue #2017.
Rewrap content to 80 chars.
........
r60622 | facundo.batista | 2008-02-06 20:28:49 +0100 (Wed, 06 Feb 2008) | 4 lines
Fixes issue 1959. Converted tests to unittest.
Thanks Giampaolo Rodola.
........
r60626 | thomas.heller | 2008-02-06 21:29:17 +0100 (Wed, 06 Feb 2008) | 3 lines
Fixed refcounts and error handling.
Should not be merged to py3k branch.
........
r60630 | mark.dickinson | 2008-02-06 23:10:50 +0100 (Wed, 06 Feb 2008) | 4 lines
Issue 1979: Make Decimal comparisons (other than !=, ==) involving NaN
raise InvalidOperation (and return False if InvalidOperation is trapped).
........
r60632 | mark.dickinson | 2008-02-06 23:25:16 +0100 (Wed, 06 Feb 2008) | 2 lines
Remove incorrect usage of :const: in documentation.
........
r60634 | georg.brandl | 2008-02-07 00:45:51 +0100 (Thu, 07 Feb 2008) | 2 lines
Revert accidental changes to test_queue in r60605.
........
r60636 | raymond.hettinger | 2008-02-07 01:54:20 +0100 (Thu, 07 Feb 2008) | 1 line
Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence.
........
r60637 | mark.dickinson | 2008-02-07 02:14:23 +0100 (Thu, 07 Feb 2008) | 2 lines
Fix broken link in decimal documentation.
........
r60638 | mark.dickinson | 2008-02-07 02:42:06 +0100 (Thu, 07 Feb 2008) | 3 lines
IEEE 754 should be IEEE 854; give precise reference for
comparisons involving NaNs.
........
r60639 | raymond.hettinger | 2008-02-07 03:12:52 +0100 (Thu, 07 Feb 2008) | 1 line
Return ints instead of longs for tuple.count() and tuple.index().
........
r60640 | raymond.hettinger | 2008-02-07 04:10:33 +0100 (Thu, 07 Feb 2008) | 1 line
Merge 60627.
........
r60641 | raymond.hettinger | 2008-02-07 04:25:46 +0100 (Thu, 07 Feb 2008) | 1 line
Merge r60628, r60631, and r60633. Register UserList and UserString will the appropriate ABCs.
........
r60642 | brett.cannon | 2008-02-07 08:47:31 +0100 (Thu, 07 Feb 2008) | 3 lines
Cast a struct to a void pointer so as to do a type-safe pointer comparison
(mistmatch found by clang).
........
r60643 | brett.cannon | 2008-02-07 09:04:07 +0100 (Thu, 07 Feb 2008) | 2 lines
Remove unnecessary curly braces around an int literal.
........
r60644 | andrew.kuchling | 2008-02-07 12:43:47 +0100 (Thu, 07 Feb 2008) | 1 line
Update URL
........
r60645 | facundo.batista | 2008-02-07 17:16:29 +0100 (Thu, 07 Feb 2008) | 4 lines
Fixes issue 2026. Tests converted to unittest. Thanks
Giampaolo Rodola.
........
r60646 | christian.heimes | 2008-02-07 18:15:30 +0100 (Thu, 07 Feb 2008) | 1 line
Added some statistics code to dict and list object code. I wanted to test how a larger freelist affects the reusage of freed objects. Contrary to my gut feelings 80 objects is more than fine for small apps. I haven't profiled a large app yet.
........
r60648 | facundo.batista | 2008-02-07 20:06:52 +0100 (Thu, 07 Feb 2008) | 6 lines
Fixes Issue 1401. When redirected, a possible POST get converted
to GET, so it loses its payload. So, it also must lose the
headers related to the payload (if it has no content any more,
it shouldn't indicate content length and type).
........
r60649 | walter.doerwald | 2008-02-07 20:30:22 +0100 (Thu, 07 Feb 2008) | 3 lines
Clarify that the output of TextCalendar.formatmonth() and
TextCalendar.formatyear() for custom instances won't be influenced by calls
to the module global setfirstweekday() function. Fixes #2018.
........
r60651 | walter.doerwald | 2008-02-07 20:48:34 +0100 (Thu, 07 Feb 2008) | 3 lines
Fix documentation for Calendar.iterweekdays(): firstweekday is a property.
Fixes second part of #2018.
........
r60653 | walter.doerwald | 2008-02-07 20:57:32 +0100 (Thu, 07 Feb 2008) | 2 lines
Fix typo in docstring for Calendar.itermonthdays().
........
r60655 | raymond.hettinger | 2008-02-07 21:04:37 +0100 (Thu, 07 Feb 2008) | 1 line
The float conversion recipe is simpler in Py2.6
........
r60657 | raymond.hettinger | 2008-02-07 21:10:49 +0100 (Thu, 07 Feb 2008) | 1 line
Fix typo
........
r60660 | brett.cannon | 2008-02-07 23:27:10 +0100 (Thu, 07 Feb 2008) | 3 lines
Make sure a switch statement does not have repetitive case statements.
Error found through LLVM post-2.1 svn.
........
r60661 | christian.heimes | 2008-02-08 01:11:31 +0100 (Fri, 08 Feb 2008) | 1 line
Deallocate content of the dict free list on interpreter shutdown
........
r60662 | christian.heimes | 2008-02-08 01:14:34 +0100 (Fri, 08 Feb 2008) | 1 line
Use prefix decrement
........
r60663 | amaury.forgeotdarc | 2008-02-08 01:56:02 +0100 (Fri, 08 Feb 2008) | 5 lines
issue 2045: Infinite recursion when printing a subclass of defaultdict,
if default_factory is set to a bound method.
Will backport.
........
r60667 | jeffrey.yasskin | 2008-02-08 07:45:40 +0100 (Fri, 08 Feb 2008) | 2 lines
Oops! 2.6's Rational.__ne__ didn't work.
........
r60671 | hyeshik.chang | 2008-02-08 18:10:20 +0100 (Fri, 08 Feb 2008) | 2 lines
Update big5hkscs codec to conform to the HKSCS:2004 revision.
........
r60673 | raymond.hettinger | 2008-02-08 23:30:04 +0100 (Fri, 08 Feb 2008) | 4 lines
Remove unnecessary modulo division.
The preceding test guarantees that 0 <= i < len.
........
r60674 | raymond.hettinger | 2008-02-09 00:02:27 +0100 (Sat, 09 Feb 2008) | 1 line
Speed-up __iter__() mixin method.
........
r60675 | raymond.hettinger | 2008-02-09 00:34:21 +0100 (Sat, 09 Feb 2008) | 1 line
Fill-in missing Set comparisons
........
r60677 | raymond.hettinger | 2008-02-09 00:57:06 +0100 (Sat, 09 Feb 2008) | 1 line
Add advice on choosing between DictMixin and MutableMapping
........
2008-02-08 22:18:51 -04:00
|
|
|
#endif
|
2010-05-09 12:52:27 -03:00
|
|
|
} else {
|
|
|
|
op = PyObject_GC_New(PyListObject, &PyList_Type);
|
|
|
|
if (op == NULL)
|
|
|
|
return NULL;
|
Merged revisions 60481,60485,60489-60492,60494-60496,60498-60499,60501-60503,60505-60506,60508-60509,60523-60524,60532,60543,60545,60547-60548,60552,60554,60556-60559,60561-60562,60569,60571-60572,60574,60576-60583,60585-60586,60589,60591,60594-60595,60597-60598,60600-60601,60606-60612,60615,60617-60678 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r60618 | walter.doerwald | 2008-02-06 15:31:55 +0100 (Wed, 06 Feb 2008) | 6 lines
Remove month parameter from Calendar.yeardatescalendar(),
Calendar.yeardays2calendar() and Calendar.yeardayscalendar() as the methods
don't have such a parameter. Fixes issue #2017.
Rewrap content to 80 chars.
........
r60622 | facundo.batista | 2008-02-06 20:28:49 +0100 (Wed, 06 Feb 2008) | 4 lines
Fixes issue 1959. Converted tests to unittest.
Thanks Giampaolo Rodola.
........
r60626 | thomas.heller | 2008-02-06 21:29:17 +0100 (Wed, 06 Feb 2008) | 3 lines
Fixed refcounts and error handling.
Should not be merged to py3k branch.
........
r60630 | mark.dickinson | 2008-02-06 23:10:50 +0100 (Wed, 06 Feb 2008) | 4 lines
Issue 1979: Make Decimal comparisons (other than !=, ==) involving NaN
raise InvalidOperation (and return False if InvalidOperation is trapped).
........
r60632 | mark.dickinson | 2008-02-06 23:25:16 +0100 (Wed, 06 Feb 2008) | 2 lines
Remove incorrect usage of :const: in documentation.
........
r60634 | georg.brandl | 2008-02-07 00:45:51 +0100 (Thu, 07 Feb 2008) | 2 lines
Revert accidental changes to test_queue in r60605.
........
r60636 | raymond.hettinger | 2008-02-07 01:54:20 +0100 (Thu, 07 Feb 2008) | 1 line
Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence.
........
r60637 | mark.dickinson | 2008-02-07 02:14:23 +0100 (Thu, 07 Feb 2008) | 2 lines
Fix broken link in decimal documentation.
........
r60638 | mark.dickinson | 2008-02-07 02:42:06 +0100 (Thu, 07 Feb 2008) | 3 lines
IEEE 754 should be IEEE 854; give precise reference for
comparisons involving NaNs.
........
r60639 | raymond.hettinger | 2008-02-07 03:12:52 +0100 (Thu, 07 Feb 2008) | 1 line
Return ints instead of longs for tuple.count() and tuple.index().
........
r60640 | raymond.hettinger | 2008-02-07 04:10:33 +0100 (Thu, 07 Feb 2008) | 1 line
Merge 60627.
........
r60641 | raymond.hettinger | 2008-02-07 04:25:46 +0100 (Thu, 07 Feb 2008) | 1 line
Merge r60628, r60631, and r60633. Register UserList and UserString will the appropriate ABCs.
........
r60642 | brett.cannon | 2008-02-07 08:47:31 +0100 (Thu, 07 Feb 2008) | 3 lines
Cast a struct to a void pointer so as to do a type-safe pointer comparison
(mistmatch found by clang).
........
r60643 | brett.cannon | 2008-02-07 09:04:07 +0100 (Thu, 07 Feb 2008) | 2 lines
Remove unnecessary curly braces around an int literal.
........
r60644 | andrew.kuchling | 2008-02-07 12:43:47 +0100 (Thu, 07 Feb 2008) | 1 line
Update URL
........
r60645 | facundo.batista | 2008-02-07 17:16:29 +0100 (Thu, 07 Feb 2008) | 4 lines
Fixes issue 2026. Tests converted to unittest. Thanks
Giampaolo Rodola.
........
r60646 | christian.heimes | 2008-02-07 18:15:30 +0100 (Thu, 07 Feb 2008) | 1 line
Added some statistics code to dict and list object code. I wanted to test how a larger freelist affects the reusage of freed objects. Contrary to my gut feelings 80 objects is more than fine for small apps. I haven't profiled a large app yet.
........
r60648 | facundo.batista | 2008-02-07 20:06:52 +0100 (Thu, 07 Feb 2008) | 6 lines
Fixes Issue 1401. When redirected, a possible POST get converted
to GET, so it loses its payload. So, it also must lose the
headers related to the payload (if it has no content any more,
it shouldn't indicate content length and type).
........
r60649 | walter.doerwald | 2008-02-07 20:30:22 +0100 (Thu, 07 Feb 2008) | 3 lines
Clarify that the output of TextCalendar.formatmonth() and
TextCalendar.formatyear() for custom instances won't be influenced by calls
to the module global setfirstweekday() function. Fixes #2018.
........
r60651 | walter.doerwald | 2008-02-07 20:48:34 +0100 (Thu, 07 Feb 2008) | 3 lines
Fix documentation for Calendar.iterweekdays(): firstweekday is a property.
Fixes second part of #2018.
........
r60653 | walter.doerwald | 2008-02-07 20:57:32 +0100 (Thu, 07 Feb 2008) | 2 lines
Fix typo in docstring for Calendar.itermonthdays().
........
r60655 | raymond.hettinger | 2008-02-07 21:04:37 +0100 (Thu, 07 Feb 2008) | 1 line
The float conversion recipe is simpler in Py2.6
........
r60657 | raymond.hettinger | 2008-02-07 21:10:49 +0100 (Thu, 07 Feb 2008) | 1 line
Fix typo
........
r60660 | brett.cannon | 2008-02-07 23:27:10 +0100 (Thu, 07 Feb 2008) | 3 lines
Make sure a switch statement does not have repetitive case statements.
Error found through LLVM post-2.1 svn.
........
r60661 | christian.heimes | 2008-02-08 01:11:31 +0100 (Fri, 08 Feb 2008) | 1 line
Deallocate content of the dict free list on interpreter shutdown
........
r60662 | christian.heimes | 2008-02-08 01:14:34 +0100 (Fri, 08 Feb 2008) | 1 line
Use prefix decrement
........
r60663 | amaury.forgeotdarc | 2008-02-08 01:56:02 +0100 (Fri, 08 Feb 2008) | 5 lines
issue 2045: Infinite recursion when printing a subclass of defaultdict,
if default_factory is set to a bound method.
Will backport.
........
r60667 | jeffrey.yasskin | 2008-02-08 07:45:40 +0100 (Fri, 08 Feb 2008) | 2 lines
Oops! 2.6's Rational.__ne__ didn't work.
........
r60671 | hyeshik.chang | 2008-02-08 18:10:20 +0100 (Fri, 08 Feb 2008) | 2 lines
Update big5hkscs codec to conform to the HKSCS:2004 revision.
........
r60673 | raymond.hettinger | 2008-02-08 23:30:04 +0100 (Fri, 08 Feb 2008) | 4 lines
Remove unnecessary modulo division.
The preceding test guarantees that 0 <= i < len.
........
r60674 | raymond.hettinger | 2008-02-09 00:02:27 +0100 (Sat, 09 Feb 2008) | 1 line
Speed-up __iter__() mixin method.
........
r60675 | raymond.hettinger | 2008-02-09 00:34:21 +0100 (Sat, 09 Feb 2008) | 1 line
Fill-in missing Set comparisons
........
r60677 | raymond.hettinger | 2008-02-09 00:57:06 +0100 (Sat, 09 Feb 2008) | 1 line
Add advice on choosing between DictMixin and MutableMapping
........
2008-02-08 22:18:51 -04:00
|
|
|
#ifdef SHOW_ALLOC_COUNT
|
2010-05-09 12:52:27 -03:00
|
|
|
count_alloc++;
|
Merged revisions 60481,60485,60489-60492,60494-60496,60498-60499,60501-60503,60505-60506,60508-60509,60523-60524,60532,60543,60545,60547-60548,60552,60554,60556-60559,60561-60562,60569,60571-60572,60574,60576-60583,60585-60586,60589,60591,60594-60595,60597-60598,60600-60601,60606-60612,60615,60617-60678 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r60618 | walter.doerwald | 2008-02-06 15:31:55 +0100 (Wed, 06 Feb 2008) | 6 lines
Remove month parameter from Calendar.yeardatescalendar(),
Calendar.yeardays2calendar() and Calendar.yeardayscalendar() as the methods
don't have such a parameter. Fixes issue #2017.
Rewrap content to 80 chars.
........
r60622 | facundo.batista | 2008-02-06 20:28:49 +0100 (Wed, 06 Feb 2008) | 4 lines
Fixes issue 1959. Converted tests to unittest.
Thanks Giampaolo Rodola.
........
r60626 | thomas.heller | 2008-02-06 21:29:17 +0100 (Wed, 06 Feb 2008) | 3 lines
Fixed refcounts and error handling.
Should not be merged to py3k branch.
........
r60630 | mark.dickinson | 2008-02-06 23:10:50 +0100 (Wed, 06 Feb 2008) | 4 lines
Issue 1979: Make Decimal comparisons (other than !=, ==) involving NaN
raise InvalidOperation (and return False if InvalidOperation is trapped).
........
r60632 | mark.dickinson | 2008-02-06 23:25:16 +0100 (Wed, 06 Feb 2008) | 2 lines
Remove incorrect usage of :const: in documentation.
........
r60634 | georg.brandl | 2008-02-07 00:45:51 +0100 (Thu, 07 Feb 2008) | 2 lines
Revert accidental changes to test_queue in r60605.
........
r60636 | raymond.hettinger | 2008-02-07 01:54:20 +0100 (Thu, 07 Feb 2008) | 1 line
Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence.
........
r60637 | mark.dickinson | 2008-02-07 02:14:23 +0100 (Thu, 07 Feb 2008) | 2 lines
Fix broken link in decimal documentation.
........
r60638 | mark.dickinson | 2008-02-07 02:42:06 +0100 (Thu, 07 Feb 2008) | 3 lines
IEEE 754 should be IEEE 854; give precise reference for
comparisons involving NaNs.
........
r60639 | raymond.hettinger | 2008-02-07 03:12:52 +0100 (Thu, 07 Feb 2008) | 1 line
Return ints instead of longs for tuple.count() and tuple.index().
........
r60640 | raymond.hettinger | 2008-02-07 04:10:33 +0100 (Thu, 07 Feb 2008) | 1 line
Merge 60627.
........
r60641 | raymond.hettinger | 2008-02-07 04:25:46 +0100 (Thu, 07 Feb 2008) | 1 line
Merge r60628, r60631, and r60633. Register UserList and UserString will the appropriate ABCs.
........
r60642 | brett.cannon | 2008-02-07 08:47:31 +0100 (Thu, 07 Feb 2008) | 3 lines
Cast a struct to a void pointer so as to do a type-safe pointer comparison
(mistmatch found by clang).
........
r60643 | brett.cannon | 2008-02-07 09:04:07 +0100 (Thu, 07 Feb 2008) | 2 lines
Remove unnecessary curly braces around an int literal.
........
r60644 | andrew.kuchling | 2008-02-07 12:43:47 +0100 (Thu, 07 Feb 2008) | 1 line
Update URL
........
r60645 | facundo.batista | 2008-02-07 17:16:29 +0100 (Thu, 07 Feb 2008) | 4 lines
Fixes issue 2026. Tests converted to unittest. Thanks
Giampaolo Rodola.
........
r60646 | christian.heimes | 2008-02-07 18:15:30 +0100 (Thu, 07 Feb 2008) | 1 line
Added some statistics code to dict and list object code. I wanted to test how a larger freelist affects the reusage of freed objects. Contrary to my gut feelings 80 objects is more than fine for small apps. I haven't profiled a large app yet.
........
r60648 | facundo.batista | 2008-02-07 20:06:52 +0100 (Thu, 07 Feb 2008) | 6 lines
Fixes Issue 1401. When redirected, a possible POST get converted
to GET, so it loses its payload. So, it also must lose the
headers related to the payload (if it has no content any more,
it shouldn't indicate content length and type).
........
r60649 | walter.doerwald | 2008-02-07 20:30:22 +0100 (Thu, 07 Feb 2008) | 3 lines
Clarify that the output of TextCalendar.formatmonth() and
TextCalendar.formatyear() for custom instances won't be influenced by calls
to the module global setfirstweekday() function. Fixes #2018.
........
r60651 | walter.doerwald | 2008-02-07 20:48:34 +0100 (Thu, 07 Feb 2008) | 3 lines
Fix documentation for Calendar.iterweekdays(): firstweekday is a property.
Fixes second part of #2018.
........
r60653 | walter.doerwald | 2008-02-07 20:57:32 +0100 (Thu, 07 Feb 2008) | 2 lines
Fix typo in docstring for Calendar.itermonthdays().
........
r60655 | raymond.hettinger | 2008-02-07 21:04:37 +0100 (Thu, 07 Feb 2008) | 1 line
The float conversion recipe is simpler in Py2.6
........
r60657 | raymond.hettinger | 2008-02-07 21:10:49 +0100 (Thu, 07 Feb 2008) | 1 line
Fix typo
........
r60660 | brett.cannon | 2008-02-07 23:27:10 +0100 (Thu, 07 Feb 2008) | 3 lines
Make sure a switch statement does not have repetitive case statements.
Error found through LLVM post-2.1 svn.
........
r60661 | christian.heimes | 2008-02-08 01:11:31 +0100 (Fri, 08 Feb 2008) | 1 line
Deallocate content of the dict free list on interpreter shutdown
........
r60662 | christian.heimes | 2008-02-08 01:14:34 +0100 (Fri, 08 Feb 2008) | 1 line
Use prefix decrement
........
r60663 | amaury.forgeotdarc | 2008-02-08 01:56:02 +0100 (Fri, 08 Feb 2008) | 5 lines
issue 2045: Infinite recursion when printing a subclass of defaultdict,
if default_factory is set to a bound method.
Will backport.
........
r60667 | jeffrey.yasskin | 2008-02-08 07:45:40 +0100 (Fri, 08 Feb 2008) | 2 lines
Oops! 2.6's Rational.__ne__ didn't work.
........
r60671 | hyeshik.chang | 2008-02-08 18:10:20 +0100 (Fri, 08 Feb 2008) | 2 lines
Update big5hkscs codec to conform to the HKSCS:2004 revision.
........
r60673 | raymond.hettinger | 2008-02-08 23:30:04 +0100 (Fri, 08 Feb 2008) | 4 lines
Remove unnecessary modulo division.
The preceding test guarantees that 0 <= i < len.
........
r60674 | raymond.hettinger | 2008-02-09 00:02:27 +0100 (Sat, 09 Feb 2008) | 1 line
Speed-up __iter__() mixin method.
........
r60675 | raymond.hettinger | 2008-02-09 00:34:21 +0100 (Sat, 09 Feb 2008) | 1 line
Fill-in missing Set comparisons
........
r60677 | raymond.hettinger | 2008-02-09 00:57:06 +0100 (Sat, 09 Feb 2008) | 1 line
Add advice on choosing between DictMixin and MutableMapping
........
2008-02-08 22:18:51 -04:00
|
|
|
#endif
|
2010-05-09 12:52:27 -03:00
|
|
|
}
|
|
|
|
if (size <= 0)
|
|
|
|
op->ob_item = NULL;
|
|
|
|
else {
|
2016-08-21 04:55:15 -03:00
|
|
|
op->ob_item = (PyObject **) PyMem_Calloc(size, sizeof(PyObject *));
|
2010-05-09 12:52:27 -03:00
|
|
|
if (op->ob_item == NULL) {
|
|
|
|
Py_DECREF(op);
|
|
|
|
return PyErr_NoMemory();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Py_SIZE(op) = size;
|
|
|
|
op->allocated = size;
|
|
|
|
_PyObject_GC_TRACK(op);
|
|
|
|
return (PyObject *) op;
|
1990-10-14 09:07:46 -03:00
|
|
|
}
|
|
|
|
|
2006-02-15 13:27:45 -04:00
|
|
|
Py_ssize_t
|
2000-07-09 12:16:51 -03:00
|
|
|
PyList_Size(PyObject *op)
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
if (!PyList_Check(op)) {
|
|
|
|
PyErr_BadInternalCall();
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return Py_SIZE(op);
|
1990-10-14 09:07:46 -03:00
|
|
|
}
|
|
|
|
|
2004-05-05 03:28:16 -03:00
|
|
|
static PyObject *indexerr = NULL;
|
1996-08-09 17:51:27 -03:00
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
PyObject *
|
2006-02-15 13:27:45 -04:00
|
|
|
PyList_GetItem(PyObject *op, Py_ssize_t i)
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
if (!PyList_Check(op)) {
|
|
|
|
PyErr_BadInternalCall();
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (i < 0 || i >= Py_SIZE(op)) {
|
|
|
|
if (indexerr == NULL) {
|
|
|
|
indexerr = PyUnicode_FromString(
|
|
|
|
"list index out of range");
|
|
|
|
if (indexerr == NULL)
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
PyErr_SetObject(PyExc_IndexError, indexerr);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return ((PyListObject *)op) -> ob_item[i];
|
1990-10-14 09:07:46 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2013-08-13 15:18:52 -03:00
|
|
|
PyList_SetItem(PyObject *op, Py_ssize_t i,
|
|
|
|
PyObject *newitem)
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
2013-08-13 15:18:52 -03:00
|
|
|
PyObject **p;
|
2010-05-09 12:52:27 -03:00
|
|
|
if (!PyList_Check(op)) {
|
|
|
|
Py_XDECREF(newitem);
|
|
|
|
PyErr_BadInternalCall();
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (i < 0 || i >= Py_SIZE(op)) {
|
|
|
|
Py_XDECREF(newitem);
|
|
|
|
PyErr_SetString(PyExc_IndexError,
|
|
|
|
"list assignment index out of range");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
p = ((PyListObject *)op) -> ob_item + i;
|
2016-04-06 03:50:03 -03:00
|
|
|
Py_XSETREF(*p, newitem);
|
2010-05-09 12:52:27 -03:00
|
|
|
return 0;
|
1990-10-14 09:07:46 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2006-02-15 13:27:45 -04:00
|
|
|
ins1(PyListObject *self, Py_ssize_t where, PyObject *v)
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_ssize_t i, n = Py_SIZE(self);
|
|
|
|
PyObject **items;
|
|
|
|
if (v == NULL) {
|
|
|
|
PyErr_BadInternalCall();
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (n == PY_SSIZE_T_MAX) {
|
|
|
|
PyErr_SetString(PyExc_OverflowError,
|
|
|
|
"cannot add more objects to list");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2016-01-25 14:33:30 -04:00
|
|
|
if (list_resize(self, n+1) < 0)
|
2010-05-09 12:52:27 -03:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (where < 0) {
|
|
|
|
where += n;
|
|
|
|
if (where < 0)
|
|
|
|
where = 0;
|
|
|
|
}
|
|
|
|
if (where > n)
|
|
|
|
where = n;
|
|
|
|
items = self->ob_item;
|
|
|
|
for (i = n; --i >= where; )
|
|
|
|
items[i+1] = items[i];
|
|
|
|
Py_INCREF(v);
|
|
|
|
items[where] = v;
|
|
|
|
return 0;
|
1990-10-14 09:07:46 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2006-02-15 13:27:45 -04:00
|
|
|
PyList_Insert(PyObject *op, Py_ssize_t where, PyObject *newitem)
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
if (!PyList_Check(op)) {
|
|
|
|
PyErr_BadInternalCall();
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return ins1((PyListObject *)op, where, newitem);
|
1990-10-14 09:07:46 -03:00
|
|
|
}
|
|
|
|
|
2004-04-12 10:05:09 -03:00
|
|
|
static int
|
|
|
|
app1(PyListObject *self, PyObject *v)
|
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_ssize_t n = PyList_GET_SIZE(self);
|
2004-04-12 10:05:09 -03:00
|
|
|
|
2010-05-09 12:52:27 -03:00
|
|
|
assert (v != NULL);
|
|
|
|
if (n == PY_SSIZE_T_MAX) {
|
|
|
|
PyErr_SetString(PyExc_OverflowError,
|
|
|
|
"cannot add more objects to list");
|
|
|
|
return -1;
|
|
|
|
}
|
2004-04-12 10:05:09 -03:00
|
|
|
|
2016-01-25 14:33:30 -04:00
|
|
|
if (list_resize(self, n+1) < 0)
|
2010-05-09 12:52:27 -03:00
|
|
|
return -1;
|
2004-04-12 10:05:09 -03:00
|
|
|
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_INCREF(v);
|
|
|
|
PyList_SET_ITEM(self, n, v);
|
|
|
|
return 0;
|
2004-04-12 10:05:09 -03:00
|
|
|
}
|
|
|
|
|
1990-10-14 09:07:46 -03:00
|
|
|
int
|
2000-07-09 12:16:51 -03:00
|
|
|
PyList_Append(PyObject *op, PyObject *newitem)
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
if (PyList_Check(op) && (newitem != NULL))
|
|
|
|
return app1((PyListObject *)op, newitem);
|
|
|
|
PyErr_BadInternalCall();
|
|
|
|
return -1;
|
1990-10-14 09:07:46 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Methods */
|
|
|
|
|
|
|
|
static void
|
2000-07-09 12:16:51 -03:00
|
|
|
list_dealloc(PyListObject *op)
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_ssize_t i;
|
|
|
|
PyObject_GC_UnTrack(op);
|
|
|
|
Py_TRASHCAN_SAFE_BEGIN(op)
|
|
|
|
if (op->ob_item != NULL) {
|
|
|
|
/* Do it backwards, for Christian Tismer.
|
|
|
|
There's a simple test case where somehow this reduces
|
|
|
|
thrashing when a *very* large list is created and
|
|
|
|
immediately deleted. */
|
|
|
|
i = Py_SIZE(op);
|
|
|
|
while (--i >= 0) {
|
|
|
|
Py_XDECREF(op->ob_item[i]);
|
|
|
|
}
|
|
|
|
PyMem_FREE(op->ob_item);
|
|
|
|
}
|
|
|
|
if (numfree < PyList_MAXFREELIST && PyList_CheckExact(op))
|
|
|
|
free_list[numfree++] = op;
|
|
|
|
else
|
|
|
|
Py_TYPE(op)->tp_free((PyObject *)op);
|
|
|
|
Py_TRASHCAN_SAFE_END(op)
|
1990-10-14 09:07:46 -03:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2000-07-09 12:16:51 -03:00
|
|
|
list_repr(PyListObject *v)
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_ssize_t i;
|
2013-11-18 16:11:57 -04:00
|
|
|
PyObject *s;
|
|
|
|
_PyUnicodeWriter writer;
|
2011-10-06 13:57:27 -03:00
|
|
|
|
|
|
|
if (Py_SIZE(v) == 0) {
|
|
|
|
return PyUnicode_FromString("[]");
|
|
|
|
}
|
|
|
|
|
2010-05-09 12:52:27 -03:00
|
|
|
i = Py_ReprEnter((PyObject*)v);
|
|
|
|
if (i != 0) {
|
|
|
|
return i > 0 ? PyUnicode_FromString("[...]") : NULL;
|
|
|
|
}
|
|
|
|
|
2013-11-18 16:11:57 -04:00
|
|
|
_PyUnicodeWriter_Init(&writer);
|
|
|
|
writer.overallocate = 1;
|
2013-11-18 17:15:44 -04:00
|
|
|
/* "[" + "1" + ", 2" * (len - 1) + "]" */
|
|
|
|
writer.min_length = 1 + 1 + (2 + 1) * (Py_SIZE(v) - 1) + 1;
|
2010-05-09 12:52:27 -03:00
|
|
|
|
2013-11-18 16:11:57 -04:00
|
|
|
if (_PyUnicodeWriter_WriteChar(&writer, '[') < 0)
|
2011-10-06 13:57:27 -03:00
|
|
|
goto error;
|
2010-05-09 12:52:27 -03:00
|
|
|
|
|
|
|
/* Do repr() on each element. Note that this may mutate the list,
|
|
|
|
so must refetch the list size on each iteration. */
|
|
|
|
for (i = 0; i < Py_SIZE(v); ++i) {
|
2013-11-18 16:11:57 -04:00
|
|
|
if (i > 0) {
|
2013-11-19 07:54:53 -04:00
|
|
|
if (_PyUnicodeWriter_WriteASCIIString(&writer, ", ", 2) < 0)
|
2013-11-18 16:11:57 -04:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2010-05-09 12:52:27 -03:00
|
|
|
s = PyObject_Repr(v->ob_item[i]);
|
2013-11-18 16:11:57 -04:00
|
|
|
if (s == NULL)
|
2011-10-06 13:57:27 -03:00
|
|
|
goto error;
|
2013-11-18 16:11:57 -04:00
|
|
|
|
|
|
|
if (_PyUnicodeWriter_WriteStr(&writer, s) < 0) {
|
|
|
|
Py_DECREF(s);
|
2011-10-06 13:57:27 -03:00
|
|
|
goto error;
|
2013-11-18 16:11:57 -04:00
|
|
|
}
|
|
|
|
Py_DECREF(s);
|
2010-05-09 12:52:27 -03:00
|
|
|
}
|
2013-11-18 16:11:57 -04:00
|
|
|
|
2013-11-19 07:09:00 -04:00
|
|
|
writer.overallocate = 0;
|
2013-11-18 16:11:57 -04:00
|
|
|
if (_PyUnicodeWriter_WriteChar(&writer, ']') < 0)
|
2011-10-06 13:57:27 -03:00
|
|
|
goto error;
|
2010-05-09 12:52:27 -03:00
|
|
|
|
2011-10-06 13:57:27 -03:00
|
|
|
Py_ReprLeave((PyObject *)v);
|
2013-11-18 16:11:57 -04:00
|
|
|
return _PyUnicodeWriter_Finish(&writer);
|
2010-05-09 12:52:27 -03:00
|
|
|
|
2011-10-06 13:57:27 -03:00
|
|
|
error:
|
2013-11-18 16:11:57 -04:00
|
|
|
_PyUnicodeWriter_Dealloc(&writer);
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_ReprLeave((PyObject *)v);
|
2011-10-06 13:57:27 -03:00
|
|
|
return NULL;
|
1990-10-14 09:07:46 -03:00
|
|
|
}
|
|
|
|
|
2006-02-15 13:27:45 -04:00
|
|
|
static Py_ssize_t
|
2000-07-09 12:16:51 -03:00
|
|
|
list_length(PyListObject *a)
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
return Py_SIZE(a);
|
1990-10-14 09:07:46 -03:00
|
|
|
}
|
|
|
|
|
2000-04-27 18:41:03 -03:00
|
|
|
static int
|
2000-07-09 12:16:51 -03:00
|
|
|
list_contains(PyListObject *a, PyObject *el)
|
2000-04-27 18:41:03 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_ssize_t i;
|
|
|
|
int cmp;
|
2000-04-27 18:41:03 -03:00
|
|
|
|
2010-05-09 12:52:27 -03:00
|
|
|
for (i = 0, cmp = 0 ; cmp == 0 && i < Py_SIZE(a); ++i)
|
|
|
|
cmp = PyObject_RichCompareBool(el, PyList_GET_ITEM(a, i),
|
|
|
|
Py_EQ);
|
|
|
|
return cmp;
|
2000-04-27 18:41:03 -03:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2006-02-15 13:27:45 -04:00
|
|
|
list_item(PyListObject *a, Py_ssize_t i)
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
if (i < 0 || i >= Py_SIZE(a)) {
|
|
|
|
if (indexerr == NULL) {
|
|
|
|
indexerr = PyUnicode_FromString(
|
|
|
|
"list index out of range");
|
|
|
|
if (indexerr == NULL)
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
PyErr_SetObject(PyExc_IndexError, indexerr);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
Py_INCREF(a->ob_item[i]);
|
|
|
|
return a->ob_item[i];
|
1990-10-14 09:07:46 -03:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2006-02-15 13:27:45 -04:00
|
|
|
list_slice(PyListObject *a, Py_ssize_t ilow, Py_ssize_t ihigh)
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
PyListObject *np;
|
|
|
|
PyObject **src, **dest;
|
|
|
|
Py_ssize_t i, len;
|
|
|
|
if (ilow < 0)
|
|
|
|
ilow = 0;
|
|
|
|
else if (ilow > Py_SIZE(a))
|
|
|
|
ilow = Py_SIZE(a);
|
|
|
|
if (ihigh < ilow)
|
|
|
|
ihigh = ilow;
|
|
|
|
else if (ihigh > Py_SIZE(a))
|
|
|
|
ihigh = Py_SIZE(a);
|
|
|
|
len = ihigh - ilow;
|
|
|
|
np = (PyListObject *) PyList_New(len);
|
|
|
|
if (np == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
src = a->ob_item + ilow;
|
|
|
|
dest = np->ob_item;
|
|
|
|
for (i = 0; i < len; i++) {
|
|
|
|
PyObject *v = src[i];
|
|
|
|
Py_INCREF(v);
|
|
|
|
dest[i] = v;
|
|
|
|
}
|
|
|
|
return (PyObject *)np;
|
1990-10-14 09:07:46 -03:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
PyObject *
|
2006-02-15 13:27:45 -04:00
|
|
|
PyList_GetSlice(PyObject *a, Py_ssize_t ilow, Py_ssize_t ihigh)
|
1993-06-17 09:35:49 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
if (!PyList_Check(a)) {
|
|
|
|
PyErr_BadInternalCall();
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return list_slice((PyListObject *)a, ilow, ihigh);
|
1993-06-17 09:35:49 -03:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2000-07-09 12:16:51 -03:00
|
|
|
list_concat(PyListObject *a, PyObject *bb)
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_ssize_t size;
|
|
|
|
Py_ssize_t i;
|
|
|
|
PyObject **src, **dest;
|
|
|
|
PyListObject *np;
|
|
|
|
if (!PyList_Check(bb)) {
|
|
|
|
PyErr_Format(PyExc_TypeError,
|
|
|
|
"can only concatenate list (not \"%.200s\") to list",
|
|
|
|
bb->ob_type->tp_name);
|
|
|
|
return NULL;
|
|
|
|
}
|
1997-05-02 00:12:38 -03:00
|
|
|
#define b ((PyListObject *)bb)
|
2016-07-24 23:39:20 -03:00
|
|
|
if (Py_SIZE(a) > PY_SSIZE_T_MAX - Py_SIZE(b))
|
2010-05-09 12:52:27 -03:00
|
|
|
return PyErr_NoMemory();
|
2016-07-24 23:39:20 -03:00
|
|
|
size = Py_SIZE(a) + Py_SIZE(b);
|
2010-05-09 12:52:27 -03:00
|
|
|
np = (PyListObject *) PyList_New(size);
|
|
|
|
if (np == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
src = a->ob_item;
|
|
|
|
dest = np->ob_item;
|
|
|
|
for (i = 0; i < Py_SIZE(a); i++) {
|
|
|
|
PyObject *v = src[i];
|
|
|
|
Py_INCREF(v);
|
|
|
|
dest[i] = v;
|
|
|
|
}
|
|
|
|
src = b->ob_item;
|
|
|
|
dest = np->ob_item + Py_SIZE(a);
|
|
|
|
for (i = 0; i < Py_SIZE(b); i++) {
|
|
|
|
PyObject *v = src[i];
|
|
|
|
Py_INCREF(v);
|
|
|
|
dest[i] = v;
|
|
|
|
}
|
|
|
|
return (PyObject *)np;
|
1990-10-14 09:07:46 -03:00
|
|
|
#undef b
|
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2006-02-15 13:27:45 -04:00
|
|
|
list_repeat(PyListObject *a, Py_ssize_t n)
|
1991-03-06 09:07:53 -04:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_ssize_t i, j;
|
|
|
|
Py_ssize_t size;
|
|
|
|
PyListObject *np;
|
|
|
|
PyObject **p, **items;
|
|
|
|
PyObject *elem;
|
|
|
|
if (n < 0)
|
|
|
|
n = 0;
|
2011-09-19 15:18:37 -03:00
|
|
|
if (n > 0 && Py_SIZE(a) > PY_SSIZE_T_MAX / n)
|
2010-05-09 12:52:27 -03:00
|
|
|
return PyErr_NoMemory();
|
2011-09-19 15:18:37 -03:00
|
|
|
size = Py_SIZE(a) * n;
|
2010-05-09 12:52:27 -03:00
|
|
|
if (size == 0)
|
|
|
|
return PyList_New(0);
|
|
|
|
np = (PyListObject *) PyList_New(size);
|
|
|
|
if (np == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
items = np->ob_item;
|
|
|
|
if (Py_SIZE(a) == 1) {
|
|
|
|
elem = a->ob_item[0];
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
items[i] = elem;
|
|
|
|
Py_INCREF(elem);
|
|
|
|
}
|
|
|
|
return (PyObject *) np;
|
|
|
|
}
|
|
|
|
p = np->ob_item;
|
|
|
|
items = a->ob_item;
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
for (j = 0; j < Py_SIZE(a); j++) {
|
|
|
|
*p = items[j];
|
|
|
|
Py_INCREF(*p);
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return (PyObject *) np;
|
1991-03-06 09:07:53 -04:00
|
|
|
}
|
|
|
|
|
2004-07-29 09:40:23 -03:00
|
|
|
static int
|
|
|
|
list_clear(PyListObject *a)
|
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_ssize_t i;
|
|
|
|
PyObject **item = a->ob_item;
|
|
|
|
if (item != NULL) {
|
|
|
|
/* Because XDECREF can recursively invoke operations on
|
|
|
|
this list, we make it empty first. */
|
|
|
|
i = Py_SIZE(a);
|
|
|
|
Py_SIZE(a) = 0;
|
|
|
|
a->ob_item = NULL;
|
|
|
|
a->allocated = 0;
|
|
|
|
while (--i >= 0) {
|
|
|
|
Py_XDECREF(item[i]);
|
|
|
|
}
|
|
|
|
PyMem_FREE(item);
|
|
|
|
}
|
|
|
|
/* Never fails; the return value can be ignored.
|
|
|
|
Note that there is no guarantee that the list is actually empty
|
|
|
|
at this point, because XDECREF may have populated it again! */
|
|
|
|
return 0;
|
2004-07-29 09:40:23 -03:00
|
|
|
}
|
|
|
|
|
2004-07-31 18:53:19 -03:00
|
|
|
/* a[ilow:ihigh] = v if v != NULL.
|
|
|
|
* del a[ilow:ihigh] if v == NULL.
|
|
|
|
*
|
|
|
|
* Special speed gimmick: when v is NULL and ihigh - ilow <= 8, it's
|
|
|
|
* guaranteed the call cannot fail.
|
|
|
|
*/
|
1990-10-14 09:07:46 -03:00
|
|
|
static int
|
2006-02-15 13:27:45 -04:00
|
|
|
list_ass_slice(PyListObject *a, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v)
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
/* Because [X]DECREF can recursively invoke list operations on
|
|
|
|
this list, we must postpone all [X]DECREF activity until
|
|
|
|
after the list is back in its canonical shape. Therefore
|
|
|
|
we must allocate an additional array, 'recycle', into which
|
|
|
|
we temporarily copy the items that are deleted from the
|
|
|
|
list. :-( */
|
|
|
|
PyObject *recycle_on_stack[8];
|
|
|
|
PyObject **recycle = recycle_on_stack; /* will allocate more if needed */
|
|
|
|
PyObject **item;
|
|
|
|
PyObject **vitem = NULL;
|
|
|
|
PyObject *v_as_SF = NULL; /* PySequence_Fast(v) */
|
|
|
|
Py_ssize_t n; /* # of elements in replacement list */
|
|
|
|
Py_ssize_t norig; /* # of elements in list getting replaced */
|
|
|
|
Py_ssize_t d; /* Change in size */
|
|
|
|
Py_ssize_t k;
|
|
|
|
size_t s;
|
|
|
|
int result = -1; /* guilty until proved innocent */
|
1997-05-02 00:12:38 -03:00
|
|
|
#define b ((PyListObject *)v)
|
2010-05-09 12:52:27 -03:00
|
|
|
if (v == NULL)
|
|
|
|
n = 0;
|
|
|
|
else {
|
|
|
|
if (a == b) {
|
|
|
|
/* Special case "a[i:j] = a" -- copy b first */
|
|
|
|
v = list_slice(b, 0, Py_SIZE(b));
|
|
|
|
if (v == NULL)
|
|
|
|
return result;
|
|
|
|
result = list_ass_slice(a, ilow, ihigh, v);
|
|
|
|
Py_DECREF(v);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
v_as_SF = PySequence_Fast(v, "can only assign an iterable");
|
|
|
|
if(v_as_SF == NULL)
|
|
|
|
goto Error;
|
|
|
|
n = PySequence_Fast_GET_SIZE(v_as_SF);
|
|
|
|
vitem = PySequence_Fast_ITEMS(v_as_SF);
|
|
|
|
}
|
|
|
|
if (ilow < 0)
|
|
|
|
ilow = 0;
|
|
|
|
else if (ilow > Py_SIZE(a))
|
|
|
|
ilow = Py_SIZE(a);
|
|
|
|
|
|
|
|
if (ihigh < ilow)
|
|
|
|
ihigh = ilow;
|
|
|
|
else if (ihigh > Py_SIZE(a))
|
|
|
|
ihigh = Py_SIZE(a);
|
|
|
|
|
|
|
|
norig = ihigh - ilow;
|
|
|
|
assert(norig >= 0);
|
|
|
|
d = n - norig;
|
|
|
|
if (Py_SIZE(a) + d == 0) {
|
|
|
|
Py_XDECREF(v_as_SF);
|
|
|
|
return list_clear(a);
|
|
|
|
}
|
|
|
|
item = a->ob_item;
|
|
|
|
/* recycle the items that we are about to remove */
|
|
|
|
s = norig * sizeof(PyObject *);
|
2016-09-06 21:58:25 -03:00
|
|
|
/* If norig == 0, item might be NULL, in which case we may not memcpy from it. */
|
|
|
|
if (s) {
|
|
|
|
if (s > sizeof(recycle_on_stack)) {
|
|
|
|
recycle = (PyObject **)PyMem_MALLOC(s);
|
|
|
|
if (recycle == NULL) {
|
|
|
|
PyErr_NoMemory();
|
|
|
|
goto Error;
|
|
|
|
}
|
2010-05-09 12:52:27 -03:00
|
|
|
}
|
2016-09-06 21:58:25 -03:00
|
|
|
memcpy(recycle, &item[ilow], s);
|
2010-05-09 12:52:27 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
if (d < 0) { /* Delete -d items */
|
2013-07-19 18:06:21 -03:00
|
|
|
Py_ssize_t tail;
|
|
|
|
tail = (Py_SIZE(a) - ihigh) * sizeof(PyObject *);
|
|
|
|
memmove(&item[ihigh+d], &item[ihigh], tail);
|
|
|
|
if (list_resize(a, Py_SIZE(a) + d) < 0) {
|
|
|
|
memmove(&item[ihigh], &item[ihigh+d], tail);
|
|
|
|
memcpy(&item[ilow], recycle, s);
|
|
|
|
goto Error;
|
|
|
|
}
|
2010-05-09 12:52:27 -03:00
|
|
|
item = a->ob_item;
|
|
|
|
}
|
|
|
|
else if (d > 0) { /* Insert d items */
|
|
|
|
k = Py_SIZE(a);
|
|
|
|
if (list_resize(a, k+d) < 0)
|
|
|
|
goto Error;
|
|
|
|
item = a->ob_item;
|
|
|
|
memmove(&item[ihigh+d], &item[ihigh],
|
|
|
|
(k - ihigh)*sizeof(PyObject *));
|
|
|
|
}
|
|
|
|
for (k = 0; k < n; k++, ilow++) {
|
|
|
|
PyObject *w = vitem[k];
|
|
|
|
Py_XINCREF(w);
|
|
|
|
item[ilow] = w;
|
|
|
|
}
|
|
|
|
for (k = norig - 1; k >= 0; --k)
|
|
|
|
Py_XDECREF(recycle[k]);
|
|
|
|
result = 0;
|
2004-07-30 23:24:20 -03:00
|
|
|
Error:
|
2010-05-09 12:52:27 -03:00
|
|
|
if (recycle != recycle_on_stack)
|
|
|
|
PyMem_FREE(recycle);
|
|
|
|
Py_XDECREF(v_as_SF);
|
|
|
|
return result;
|
1990-10-14 09:07:46 -03:00
|
|
|
#undef b
|
|
|
|
}
|
|
|
|
|
1993-06-17 09:35:49 -03:00
|
|
|
int
|
2006-02-15 13:27:45 -04:00
|
|
|
PyList_SetSlice(PyObject *a, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v)
|
1993-06-17 09:35:49 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
if (!PyList_Check(a)) {
|
|
|
|
PyErr_BadInternalCall();
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return list_ass_slice((PyListObject *)a, ilow, ihigh, v);
|
1993-06-17 09:35:49 -03:00
|
|
|
}
|
|
|
|
|
2000-08-24 17:08:19 -03:00
|
|
|
static PyObject *
|
2006-02-15 13:27:45 -04:00
|
|
|
list_inplace_repeat(PyListObject *self, Py_ssize_t n)
|
2000-08-24 17:08:19 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
PyObject **items;
|
|
|
|
Py_ssize_t size, i, j, p;
|
2000-08-24 17:08:19 -03:00
|
|
|
|
|
|
|
|
2010-05-09 12:52:27 -03:00
|
|
|
size = PyList_GET_SIZE(self);
|
|
|
|
if (size == 0 || n == 1) {
|
|
|
|
Py_INCREF(self);
|
|
|
|
return (PyObject *)self;
|
|
|
|
}
|
2000-08-24 17:08:19 -03:00
|
|
|
|
2010-05-09 12:52:27 -03:00
|
|
|
if (n < 1) {
|
|
|
|
(void)list_clear(self);
|
|
|
|
Py_INCREF(self);
|
|
|
|
return (PyObject *)self;
|
|
|
|
}
|
2000-08-24 17:08:19 -03:00
|
|
|
|
2010-05-09 12:52:27 -03:00
|
|
|
if (size > PY_SSIZE_T_MAX / n) {
|
|
|
|
return PyErr_NoMemory();
|
|
|
|
}
|
Merged revisions 60284-60349 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r60286 | christian.heimes | 2008-01-25 15:54:23 +0100 (Fri, 25 Jan 2008) | 1 line
setup.py doesn't pick up changes to a header file
........
r60287 | christian.heimes | 2008-01-25 16:52:11 +0100 (Fri, 25 Jan 2008) | 2 lines
Added the Python core headers Include/*.h and pyconfig.h as dependencies for the extensions in Modules/
It forces a rebuild of all extensions when a header files has been modified
........
r60291 | raymond.hettinger | 2008-01-25 20:24:46 +0100 (Fri, 25 Jan 2008) | 4 lines
Changes 54857 and 54840 broke code and were reverted in Py2.5 just before
it was released, but that reversion never made it to the Py2.6 head.
........
r60296 | guido.van.rossum | 2008-01-25 20:50:26 +0100 (Fri, 25 Jan 2008) | 2 lines
Rewrite the list_inline_repeat overflow check slightly differently.
........
r60301 | thomas.wouters | 2008-01-25 22:09:34 +0100 (Fri, 25 Jan 2008) | 4 lines
Use the right (portable) definition of the max of a Py_ssize_t.
........
r60303 | thomas.wouters | 2008-01-26 02:47:05 +0100 (Sat, 26 Jan 2008) | 5 lines
Make 'testall' work again when building in a separate directory.
test_distutils still fails when doing that.
........
r60305 | neal.norwitz | 2008-01-26 06:54:48 +0100 (Sat, 26 Jan 2008) | 3 lines
Prevent this test from failing if there are transient network problems
by retrying the host for up to 3 times.
........
r60306 | neal.norwitz | 2008-01-26 08:26:12 +0100 (Sat, 26 Jan 2008) | 12 lines
Use a condition variable (threading.Event) rather than sleeps and checking a
global to determine when the server is ready to be used. This slows the test
down, but should make it correct. There was a race condition before where the
server could have assigned a port, yet it wasn't ready to serve requests. If
the client sent a request before the server was completely ready, it would get
an exception. There was machinery to try to handle this condition. All of
that should be unnecessary and removed if this change works. A NOTE was
added as a comment about what needs to be fixed.
The buildbots will tell us if there are more errors or
if this test is now stable.
........
r60307 | neal.norwitz | 2008-01-26 08:38:03 +0100 (Sat, 26 Jan 2008) | 3 lines
Fix exception in tearDown on ppc buildbot. If there's no directory,
that shouldn't cause the test to fail. Just like it setUp.
........
r60308 | raymond.hettinger | 2008-01-26 09:19:06 +0100 (Sat, 26 Jan 2008) | 3 lines
Make PySet_Add() work with frozensets. Works like PyTuple_SetItem() to build-up values in a brand new frozenset.
........
r60309 | neal.norwitz | 2008-01-26 09:26:00 +0100 (Sat, 26 Jan 2008) | 1 line
The OS X buildbot had errors with the unavailable exceptions disabled. Restore it.
........
r60310 | raymond.hettinger | 2008-01-26 09:37:28 +0100 (Sat, 26 Jan 2008) | 4 lines
Let marshal build-up sets and frozensets one element at a time.
Saves the unnecessary creation of a tuple as intermediate container.
........
r60311 | raymond.hettinger | 2008-01-26 09:41:13 +0100 (Sat, 26 Jan 2008) | 1 line
Update test code for change to PySet_Add().
........
r60312 | raymond.hettinger | 2008-01-26 10:31:11 +0100 (Sat, 26 Jan 2008) | 1 line
Revert PySet_Add() changes.
........
r60314 | georg.brandl | 2008-01-26 10:43:35 +0100 (Sat, 26 Jan 2008) | 2 lines
#1934: fix os.path.isabs docs.
........
r60316 | georg.brandl | 2008-01-26 12:00:18 +0100 (Sat, 26 Jan 2008) | 2 lines
Add missing things in re docstring.
........
r60317 | georg.brandl | 2008-01-26 12:02:22 +0100 (Sat, 26 Jan 2008) | 2 lines
Slashes allowed on Windows.
........
r60319 | georg.brandl | 2008-01-26 14:41:21 +0100 (Sat, 26 Jan 2008) | 2 lines
Fix markup again.
........
r60320 | andrew.kuchling | 2008-01-26 14:50:51 +0100 (Sat, 26 Jan 2008) | 1 line
Add some items
........
r60321 | georg.brandl | 2008-01-26 15:02:38 +0100 (Sat, 26 Jan 2008) | 2 lines
Clarify "b" mode under Unix.
........
r60322 | georg.brandl | 2008-01-26 15:03:47 +0100 (Sat, 26 Jan 2008) | 3 lines
#1940: make it possible to use curses.filter() before curses.initscr()
as the documentation says.
........
r60324 | georg.brandl | 2008-01-26 15:14:20 +0100 (Sat, 26 Jan 2008) | 3 lines
#1473257: add generator.gi_code attribute that refers to
the original code object backing the generator. Patch by Collin Winter.
........
r60325 | georg.brandl | 2008-01-26 15:19:22 +0100 (Sat, 26 Jan 2008) | 2 lines
Move C API entries to the corresponding section.
........
r60326 | christian.heimes | 2008-01-26 17:43:35 +0100 (Sat, 26 Jan 2008) | 1 line
Unit test fix from Giampaolo Rodola, #1938
........
r60327 | gregory.p.smith | 2008-01-26 19:51:05 +0100 (Sat, 26 Jan 2008) | 2 lines
Update docs for new callpack params added in r60188
........
r60329 | neal.norwitz | 2008-01-26 21:24:36 +0100 (Sat, 26 Jan 2008) | 3 lines
Cleanup the code a bit. test_rfind is failing on PPC and PPC64 buildbots,
this might fix the problem.
........
r60330 | neal.norwitz | 2008-01-26 22:02:45 +0100 (Sat, 26 Jan 2008) | 1 line
Always try to remove the test file even if close raises an exception
........
r60331 | neal.norwitz | 2008-01-26 22:21:59 +0100 (Sat, 26 Jan 2008) | 3 lines
Reduce the race condition by signalling when the server is ready
and not trying to connect before.
........
r60334 | neal.norwitz | 2008-01-27 00:13:46 +0100 (Sun, 27 Jan 2008) | 5 lines
On some systems (e.g., Ubuntu on hppa) the flush()
doesn't cause the exception, but the close() does.
Will backport.
........
r60335 | neal.norwitz | 2008-01-27 00:14:17 +0100 (Sun, 27 Jan 2008) | 2 lines
Consistently use tempfile.tempdir for the db_home directory.
........
r60338 | neal.norwitz | 2008-01-27 02:44:05 +0100 (Sun, 27 Jan 2008) | 4 lines
Eliminate the sleeps that assume the server will start in .5 seconds.
This should make the test less flaky. It also speeds up the test
by about 75% on my box (20+ seconds -> ~4 seconds).
........
r60342 | neal.norwitz | 2008-01-27 06:02:34 +0100 (Sun, 27 Jan 2008) | 6 lines
Try to prevent this test from being flaky. We might need a sleep in here
which isn't as bad as it sounds. The close() *should* raise an exception,
so if it didn't we should give more time to sync and really raise it.
Will backport.
........
r60344 | jeffrey.yasskin | 2008-01-27 06:40:35 +0100 (Sun, 27 Jan 2008) | 3 lines
Make rational.gcd() public and allow Rational to take decimal strings, per
Raymond's advice.
........
r60345 | neal.norwitz | 2008-01-27 08:36:03 +0100 (Sun, 27 Jan 2008) | 3 lines
Mostly reformat. Also set an error and return NULL if neither MS_WINDOWS
nor UNIX is defined. This may have caused problems on cygwin.
........
r60346 | neal.norwitz | 2008-01-27 08:37:38 +0100 (Sun, 27 Jan 2008) | 3 lines
Use int for the sign rather than a char. char can be signed or unsigned.
It's system dependent. This might fix the problem with test_rfind failing.
........
r60347 | neal.norwitz | 2008-01-27 08:41:33 +0100 (Sun, 27 Jan 2008) | 1 line
Add stdarg include for va_list to get this to compile on cygwin
........
r60348 | raymond.hettinger | 2008-01-27 11:13:57 +0100 (Sun, 27 Jan 2008) | 1 line
Docstring nit
........
r60349 | raymond.hettinger | 2008-01-27 11:47:55 +0100 (Sun, 27 Jan 2008) | 1 line
Removed an unnecessary and confusing paragraph from the namedtuple docs.
........
2008-01-27 11:18:18 -04:00
|
|
|
|
2016-01-25 14:33:30 -04:00
|
|
|
if (list_resize(self, size*n) < 0)
|
2010-05-09 12:52:27 -03:00
|
|
|
return NULL;
|
* Optimized list appends and pops by making fewer calls the underlying system
realloc(). This is achieved by tracking the overallocation size in a new
field and using that information to skip calls to realloc() whenever
possible.
* Simplified and tightened the amount of overallocation. For larger lists,
this overallocates by 1/8th (compared to the previous scheme which ranged
between 1/4th to 1/32nd over-allocation). For smaller lists (n<6), the
maximum overallocation is one byte (formerly it could be upto eight bytes).
This saves memory in applications with large numbers of small lists.
* Eliminated the NRESIZE macro in favor of a new, static list_resize function
that encapsulates the resizing logic. Coverting this back to macro would
give a small (under 1%) speed-up. This was too small to warrant the loss
of readability, maintainability, and de-coupling.
* Some functions using NRESIZE had grown unnecessarily complex in their
efforts to bend to the macro's calling pattern. With the new list_resize
function in place, those other functions could be simplified. That is
being saved for a separate patch.
* The ob_item==NULL check could be eliminated from the new list_resize
function. This would entail finding each piece of code that sets ob_item
to NULL and adding a new line to invalidate the overallocation tracking
field. Rather than impose a new requirement on other pieces of list code,
it was preferred to leave the NULL check in place and retain the benefits
of decoupling, maintainability and information hiding (only PyList_New()
and list_sort() need to know about the new field). This approach also
reduces the odds of breaking an extension module.
(Collaborative effort by Raymond Hettinger, Hye-Shik Chang, Tim Peters,
and Armin Rigo.)
2004-02-13 07:36:39 -04:00
|
|
|
|
2010-05-09 12:52:27 -03:00
|
|
|
p = size;
|
|
|
|
items = self->ob_item;
|
|
|
|
for (i = 1; i < n; i++) { /* Start counting at 1, not 0 */
|
|
|
|
for (j = 0; j < size; j++) {
|
|
|
|
PyObject *o = items[j];
|
|
|
|
Py_INCREF(o);
|
|
|
|
items[p++] = o;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Py_INCREF(self);
|
|
|
|
return (PyObject *)self;
|
2000-08-24 17:08:19 -03:00
|
|
|
}
|
|
|
|
|
1991-04-03 15:05:18 -04:00
|
|
|
static int
|
2006-02-15 13:27:45 -04:00
|
|
|
list_ass_item(PyListObject *a, Py_ssize_t i, PyObject *v)
|
1991-04-03 15:05:18 -04:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
if (i < 0 || i >= Py_SIZE(a)) {
|
|
|
|
PyErr_SetString(PyExc_IndexError,
|
|
|
|
"list assignment index out of range");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (v == NULL)
|
|
|
|
return list_ass_slice(a, i, i+1, v);
|
|
|
|
Py_INCREF(v);
|
2016-04-10 12:12:01 -03:00
|
|
|
Py_SETREF(a->ob_item[i], v);
|
2010-05-09 12:52:27 -03:00
|
|
|
return 0;
|
1991-04-03 15:05:18 -04:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2000-07-09 12:16:51 -03:00
|
|
|
listinsert(PyListObject *self, PyObject *args)
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_ssize_t i;
|
|
|
|
PyObject *v;
|
|
|
|
if (!PyArg_ParseTuple(args, "nO:insert", &i, &v))
|
|
|
|
return NULL;
|
|
|
|
if (ins1(self, i, v) == 0)
|
|
|
|
Py_RETURN_NONE;
|
|
|
|
return NULL;
|
1990-10-14 09:07:46 -03:00
|
|
|
}
|
|
|
|
|
2011-02-25 01:47:53 -04:00
|
|
|
static PyObject *
|
|
|
|
listclear(PyListObject *self)
|
|
|
|
{
|
|
|
|
list_clear(self);
|
|
|
|
Py_RETURN_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *
|
|
|
|
listcopy(PyListObject *self)
|
|
|
|
{
|
|
|
|
return list_slice(self, 0, Py_SIZE(self));
|
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2001-08-16 10:15:00 -03:00
|
|
|
listappend(PyListObject *self, PyObject *v)
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
if (app1(self, v) == 0)
|
|
|
|
Py_RETURN_NONE;
|
|
|
|
return NULL;
|
1990-10-14 09:07:46 -03:00
|
|
|
}
|
|
|
|
|
2000-08-24 17:08:19 -03:00
|
|
|
static PyObject *
|
2001-08-16 10:15:00 -03:00
|
|
|
listextend(PyListObject *self, PyObject *b)
|
2000-08-24 17:08:19 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
PyObject *it; /* iter(v) */
|
|
|
|
Py_ssize_t m; /* size of self */
|
|
|
|
Py_ssize_t n; /* guess for size of b */
|
|
|
|
Py_ssize_t mn; /* m + n */
|
|
|
|
Py_ssize_t i;
|
|
|
|
PyObject *(*iternext)(PyObject *);
|
|
|
|
|
|
|
|
/* Special cases:
|
|
|
|
1) lists and tuples which can use PySequence_Fast ops
|
|
|
|
2) extending self to self requires making a copy first
|
|
|
|
*/
|
|
|
|
if (PyList_CheckExact(b) || PyTuple_CheckExact(b) || (PyObject *)self == b) {
|
|
|
|
PyObject **src, **dest;
|
|
|
|
b = PySequence_Fast(b, "argument must be iterable");
|
|
|
|
if (!b)
|
|
|
|
return NULL;
|
|
|
|
n = PySequence_Fast_GET_SIZE(b);
|
|
|
|
if (n == 0) {
|
|
|
|
/* short circuit when b is empty */
|
|
|
|
Py_DECREF(b);
|
|
|
|
Py_RETURN_NONE;
|
|
|
|
}
|
|
|
|
m = Py_SIZE(self);
|
2016-01-25 14:33:30 -04:00
|
|
|
if (list_resize(self, m + n) < 0) {
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_DECREF(b);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
/* note that we may still have self == b here for the
|
|
|
|
* situation a.extend(a), but the following code works
|
|
|
|
* in that case too. Just make sure to resize self
|
|
|
|
* before calling PySequence_Fast_ITEMS.
|
|
|
|
*/
|
|
|
|
/* populate the end of self with b's items */
|
|
|
|
src = PySequence_Fast_ITEMS(b);
|
|
|
|
dest = self->ob_item + m;
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
PyObject *o = src[i];
|
|
|
|
Py_INCREF(o);
|
|
|
|
dest[i] = o;
|
|
|
|
}
|
|
|
|
Py_DECREF(b);
|
|
|
|
Py_RETURN_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
it = PyObject_GetIter(b);
|
|
|
|
if (it == NULL)
|
|
|
|
return NULL;
|
|
|
|
iternext = *it->ob_type->tp_iternext;
|
|
|
|
|
|
|
|
/* Guess a result list size. */
|
2012-10-06 09:03:24 -03:00
|
|
|
n = PyObject_LengthHint(b, 8);
|
2016-01-25 14:33:30 -04:00
|
|
|
if (n < 0) {
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_DECREF(it);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
m = Py_SIZE(self);
|
2016-07-24 23:39:20 -03:00
|
|
|
if (m > PY_SSIZE_T_MAX - n) {
|
|
|
|
/* m + n overflowed; on the chance that n lied, and there really
|
|
|
|
* is enough room, ignore it. If n was telling the truth, we'll
|
|
|
|
* eventually run out of memory during the loop.
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
mn = m + n;
|
2010-05-09 12:52:27 -03:00
|
|
|
/* Make room. */
|
2016-01-25 14:33:30 -04:00
|
|
|
if (list_resize(self, mn) < 0)
|
2010-05-09 12:52:27 -03:00
|
|
|
goto error;
|
|
|
|
/* Make the list sane again. */
|
|
|
|
Py_SIZE(self) = m;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Run iterator to exhaustion. */
|
|
|
|
for (;;) {
|
|
|
|
PyObject *item = iternext(it);
|
|
|
|
if (item == NULL) {
|
|
|
|
if (PyErr_Occurred()) {
|
|
|
|
if (PyErr_ExceptionMatches(PyExc_StopIteration))
|
|
|
|
PyErr_Clear();
|
|
|
|
else
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (Py_SIZE(self) < self->allocated) {
|
|
|
|
/* steals ref */
|
|
|
|
PyList_SET_ITEM(self, Py_SIZE(self), item);
|
|
|
|
++Py_SIZE(self);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
int status = app1(self, item);
|
|
|
|
Py_DECREF(item); /* append creates a new ref */
|
|
|
|
if (status < 0)
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Cut back result list if initial guess was too large. */
|
2013-07-16 16:45:58 -03:00
|
|
|
if (Py_SIZE(self) < self->allocated) {
|
|
|
|
if (list_resize(self, Py_SIZE(self)) < 0)
|
|
|
|
goto error;
|
|
|
|
}
|
2010-05-09 12:52:27 -03:00
|
|
|
|
|
|
|
Py_DECREF(it);
|
|
|
|
Py_RETURN_NONE;
|
2004-02-14 23:57:00 -04:00
|
|
|
|
|
|
|
error:
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_DECREF(it);
|
|
|
|
return NULL;
|
2000-08-24 17:08:19 -03:00
|
|
|
}
|
1998-10-09 13:37:25 -03:00
|
|
|
|
2004-03-11 05:13:12 -04:00
|
|
|
PyObject *
|
|
|
|
_PyList_Extend(PyListObject *self, PyObject *b)
|
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
return listextend(self, b);
|
2004-03-11 05:13:12 -04:00
|
|
|
}
|
|
|
|
|
2004-03-11 03:34:19 -04:00
|
|
|
static PyObject *
|
|
|
|
list_inplace_concat(PyListObject *self, PyObject *other)
|
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
PyObject *result;
|
2004-03-11 03:34:19 -04:00
|
|
|
|
2010-05-09 12:52:27 -03:00
|
|
|
result = listextend(self, other);
|
|
|
|
if (result == NULL)
|
|
|
|
return result;
|
|
|
|
Py_DECREF(result);
|
|
|
|
Py_INCREF(self);
|
|
|
|
return (PyObject *)self;
|
2004-03-11 03:34:19 -04:00
|
|
|
}
|
|
|
|
|
1998-06-30 12:36:32 -03:00
|
|
|
static PyObject *
|
2000-07-09 12:16:51 -03:00
|
|
|
listpop(PyListObject *self, PyObject *args)
|
1998-06-30 12:36:32 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_ssize_t i = -1;
|
|
|
|
PyObject *v;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
if (!PyArg_ParseTuple(args, "|n:pop", &i))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (Py_SIZE(self) == 0) {
|
|
|
|
/* Special-case most common failure cause */
|
|
|
|
PyErr_SetString(PyExc_IndexError, "pop from empty list");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (i < 0)
|
|
|
|
i += Py_SIZE(self);
|
|
|
|
if (i < 0 || i >= Py_SIZE(self)) {
|
|
|
|
PyErr_SetString(PyExc_IndexError, "pop index out of range");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
v = self->ob_item[i];
|
|
|
|
if (i == Py_SIZE(self) - 1) {
|
|
|
|
status = list_resize(self, Py_SIZE(self) - 1);
|
2013-07-08 17:20:44 -03:00
|
|
|
if (status >= 0)
|
|
|
|
return v; /* and v now owns the reference the list had */
|
|
|
|
else
|
|
|
|
return NULL;
|
2010-05-09 12:52:27 -03:00
|
|
|
}
|
|
|
|
Py_INCREF(v);
|
|
|
|
status = list_ass_slice(self, i, i+1, (PyObject *)NULL);
|
2013-07-17 16:58:01 -03:00
|
|
|
if (status < 0) {
|
|
|
|
Py_DECREF(v);
|
|
|
|
return NULL;
|
|
|
|
}
|
2010-05-09 12:52:27 -03:00
|
|
|
return v;
|
1998-06-30 12:36:32 -03:00
|
|
|
}
|
|
|
|
|
2002-07-18 23:33:08 -03:00
|
|
|
/* Reverse a slice of a list in place, from lo up to (exclusive) hi. */
|
|
|
|
static void
|
|
|
|
reverse_slice(PyObject **lo, PyObject **hi)
|
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
assert(lo && hi);
|
2002-07-18 23:33:08 -03:00
|
|
|
|
2010-05-09 12:52:27 -03:00
|
|
|
--hi;
|
|
|
|
while (lo < hi) {
|
|
|
|
PyObject *t = *lo;
|
|
|
|
*lo = *hi;
|
|
|
|
*hi = t;
|
|
|
|
++lo;
|
|
|
|
--hi;
|
|
|
|
}
|
2002-07-18 23:33:08 -03:00
|
|
|
}
|
|
|
|
|
2002-07-31 23:13:36 -03:00
|
|
|
/* Lots of code for an adaptive, stable, natural mergesort. There are many
|
|
|
|
* pieces to this algorithm; read listsort.txt for overviews and details.
|
|
|
|
*/
|
1996-12-10 19:55:39 -04:00
|
|
|
|
2010-12-02 17:55:33 -04:00
|
|
|
/* A sortslice contains a pointer to an array of keys and a pointer to
|
|
|
|
* an array of corresponding values. In other words, keys[i]
|
|
|
|
* corresponds with values[i]. If values == NULL, then the keys are
|
|
|
|
* also the values.
|
|
|
|
*
|
|
|
|
* Several convenience routines are provided here, so that keys and
|
|
|
|
* values are always moved in sync.
|
|
|
|
*/
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
PyObject **keys;
|
|
|
|
PyObject **values;
|
|
|
|
} sortslice;
|
|
|
|
|
|
|
|
Py_LOCAL_INLINE(void)
|
|
|
|
sortslice_copy(sortslice *s1, Py_ssize_t i, sortslice *s2, Py_ssize_t j)
|
|
|
|
{
|
|
|
|
s1->keys[i] = s2->keys[j];
|
|
|
|
if (s1->values != NULL)
|
|
|
|
s1->values[i] = s2->values[j];
|
|
|
|
}
|
|
|
|
|
|
|
|
Py_LOCAL_INLINE(void)
|
2010-12-02 21:44:10 -04:00
|
|
|
sortslice_copy_incr(sortslice *dst, sortslice *src)
|
|
|
|
{
|
2010-12-02 17:55:33 -04:00
|
|
|
*dst->keys++ = *src->keys++;
|
|
|
|
if (dst->values != NULL)
|
|
|
|
*dst->values++ = *src->values++;
|
|
|
|
}
|
|
|
|
|
|
|
|
Py_LOCAL_INLINE(void)
|
2010-12-02 21:44:10 -04:00
|
|
|
sortslice_copy_decr(sortslice *dst, sortslice *src)
|
|
|
|
{
|
2010-12-02 17:55:33 -04:00
|
|
|
*dst->keys-- = *src->keys--;
|
|
|
|
if (dst->values != NULL)
|
|
|
|
*dst->values-- = *src->values--;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Py_LOCAL_INLINE(void)
|
|
|
|
sortslice_memcpy(sortslice *s1, Py_ssize_t i, sortslice *s2, Py_ssize_t j,
|
2010-12-02 21:44:10 -04:00
|
|
|
Py_ssize_t n)
|
|
|
|
{
|
2010-12-02 17:55:33 -04:00
|
|
|
memcpy(&s1->keys[i], &s2->keys[j], sizeof(PyObject *) * n);
|
|
|
|
if (s1->values != NULL)
|
|
|
|
memcpy(&s1->values[i], &s2->values[j], sizeof(PyObject *) * n);
|
|
|
|
}
|
|
|
|
|
|
|
|
Py_LOCAL_INLINE(void)
|
|
|
|
sortslice_memmove(sortslice *s1, Py_ssize_t i, sortslice *s2, Py_ssize_t j,
|
2010-12-02 21:44:10 -04:00
|
|
|
Py_ssize_t n)
|
|
|
|
{
|
2010-12-02 17:55:33 -04:00
|
|
|
memmove(&s1->keys[i], &s2->keys[j], sizeof(PyObject *) * n);
|
|
|
|
if (s1->values != NULL)
|
|
|
|
memmove(&s1->values[i], &s2->values[j], sizeof(PyObject *) * n);
|
|
|
|
}
|
|
|
|
|
|
|
|
Py_LOCAL_INLINE(void)
|
2010-12-02 21:44:10 -04:00
|
|
|
sortslice_advance(sortslice *slice, Py_ssize_t n)
|
|
|
|
{
|
2010-12-02 17:55:33 -04:00
|
|
|
slice->keys += n;
|
|
|
|
if (slice->values != NULL)
|
|
|
|
slice->values += n;
|
|
|
|
}
|
|
|
|
|
2008-01-30 16:15:17 -04:00
|
|
|
/* Comparison function: PyObject_RichCompareBool with Py_LT.
|
2002-07-31 23:13:36 -03:00
|
|
|
* Returns -1 on error, 1 if x < y, 0 if x >= y.
|
|
|
|
*/
|
1996-12-10 19:55:39 -04:00
|
|
|
|
2008-01-30 16:15:17 -04:00
|
|
|
#define ISLT(X, Y) (PyObject_RichCompareBool(X, Y, Py_LT))
|
2002-08-04 14:47:26 -03:00
|
|
|
|
|
|
|
/* Compare X to Y via "<". Goto "fail" if the comparison raises an
|
2002-07-19 00:30:57 -03:00
|
|
|
error. Else "k" is set to true iff X<Y, and an "if (k)" block is
|
|
|
|
started. It makes more sense in context <wink>. X and Y are PyObject*s.
|
|
|
|
*/
|
2008-01-30 16:15:17 -04:00
|
|
|
#define IFLT(X, Y) if ((k = ISLT(X, Y)) < 0) goto fail; \
|
2010-05-09 12:52:27 -03:00
|
|
|
if (k)
|
1998-06-16 12:18:28 -03:00
|
|
|
|
|
|
|
/* binarysort is the best method for sorting small arrays: it does
|
|
|
|
few compares, but can do data movement quadratic in the number of
|
|
|
|
elements.
|
1998-06-17 11:15:44 -03:00
|
|
|
[lo, hi) is a contiguous slice of a list, and is sorted via
|
2002-07-19 00:30:57 -03:00
|
|
|
binary insertion. This sort is stable.
|
1998-06-16 12:18:28 -03:00
|
|
|
On entry, must have lo <= start <= hi, and that [lo, start) is already
|
|
|
|
sorted (pass start == lo if you don't know!).
|
2002-07-19 00:30:57 -03:00
|
|
|
If islt() complains return -1, else 0.
|
1998-06-16 12:18:28 -03:00
|
|
|
Even in case of error, the output slice will be some permutation of
|
|
|
|
the input (nothing is lost or duplicated).
|
|
|
|
*/
|
|
|
|
static int
|
2010-12-02 17:55:33 -04:00
|
|
|
binarysort(sortslice lo, PyObject **hi, PyObject **start)
|
1998-06-16 12:18:28 -03:00
|
|
|
{
|
2013-08-13 15:18:52 -03:00
|
|
|
Py_ssize_t k;
|
|
|
|
PyObject **l, **p, **r;
|
|
|
|
PyObject *pivot;
|
2010-05-09 12:52:27 -03:00
|
|
|
|
2010-12-02 17:55:33 -04:00
|
|
|
assert(lo.keys <= start && start <= hi);
|
2010-05-09 12:52:27 -03:00
|
|
|
/* assert [lo, start) is sorted */
|
2010-12-02 17:55:33 -04:00
|
|
|
if (lo.keys == start)
|
2010-05-09 12:52:27 -03:00
|
|
|
++start;
|
|
|
|
for (; start < hi; ++start) {
|
|
|
|
/* set l to where *start belongs */
|
2010-12-02 17:55:33 -04:00
|
|
|
l = lo.keys;
|
2010-05-09 12:52:27 -03:00
|
|
|
r = start;
|
|
|
|
pivot = *r;
|
|
|
|
/* Invariants:
|
|
|
|
* pivot >= all in [lo, l).
|
|
|
|
* pivot < all in [r, start).
|
|
|
|
* The second is vacuously true at the start.
|
|
|
|
*/
|
|
|
|
assert(l < r);
|
|
|
|
do {
|
|
|
|
p = l + ((r - l) >> 1);
|
|
|
|
IFLT(pivot, *p)
|
|
|
|
r = p;
|
|
|
|
else
|
|
|
|
l = p+1;
|
|
|
|
} while (l < r);
|
|
|
|
assert(l == r);
|
|
|
|
/* The invariants still hold, so pivot >= all in [lo, l) and
|
|
|
|
pivot < all in [l, start), so pivot belongs at l. Note
|
|
|
|
that if there are elements equal to pivot, l points to the
|
|
|
|
first slot after them -- that's why this sort is stable.
|
|
|
|
Slide over to make room.
|
|
|
|
Caution: using memmove is much slower under MSVC 5;
|
|
|
|
we're not usually moving many slots. */
|
|
|
|
for (p = start; p > l; --p)
|
|
|
|
*p = *(p-1);
|
|
|
|
*l = pivot;
|
2010-12-02 17:55:33 -04:00
|
|
|
if (lo.values != NULL) {
|
|
|
|
Py_ssize_t offset = lo.values - lo.keys;
|
|
|
|
p = start + offset;
|
|
|
|
pivot = *p;
|
|
|
|
l += offset;
|
|
|
|
for (p = start + offset; p > l; --p)
|
|
|
|
*p = *(p-1);
|
|
|
|
*l = pivot;
|
|
|
|
}
|
2010-05-09 12:52:27 -03:00
|
|
|
}
|
|
|
|
return 0;
|
1996-12-10 19:55:39 -04:00
|
|
|
|
1998-06-16 12:18:28 -03:00
|
|
|
fail:
|
2010-05-09 12:52:27 -03:00
|
|
|
return -1;
|
1998-06-16 12:18:28 -03:00
|
|
|
}
|
|
|
|
|
2002-07-31 23:13:36 -03:00
|
|
|
/*
|
|
|
|
Return the length of the run beginning at lo, in the slice [lo, hi). lo < hi
|
|
|
|
is required on entry. "A run" is the longest ascending sequence, with
|
1998-06-16 12:18:28 -03:00
|
|
|
|
2002-07-31 23:13:36 -03:00
|
|
|
lo[0] <= lo[1] <= lo[2] <= ...
|
1998-06-16 12:18:28 -03:00
|
|
|
|
2002-07-31 23:13:36 -03:00
|
|
|
or the longest descending sequence, with
|
1998-06-16 12:18:28 -03:00
|
|
|
|
2002-07-31 23:13:36 -03:00
|
|
|
lo[0] > lo[1] > lo[2] > ...
|
|
|
|
|
|
|
|
Boolean *descending is set to 0 in the former case, or to 1 in the latter.
|
|
|
|
For its intended use in a stable mergesort, the strictness of the defn of
|
|
|
|
"descending" is needed so that the caller can safely reverse a descending
|
|
|
|
sequence without violating stability (strict > ensures there are no equal
|
|
|
|
elements to get out of order).
|
1996-12-10 19:55:39 -04:00
|
|
|
|
2002-07-31 23:13:36 -03:00
|
|
|
Returns -1 in case of error.
|
|
|
|
*/
|
2006-02-15 13:27:45 -04:00
|
|
|
static Py_ssize_t
|
2008-01-30 16:15:17 -04:00
|
|
|
count_run(PyObject **lo, PyObject **hi, int *descending)
|
1996-12-10 19:55:39 -04:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_ssize_t k;
|
|
|
|
Py_ssize_t n;
|
|
|
|
|
|
|
|
assert(lo < hi);
|
|
|
|
*descending = 0;
|
|
|
|
++lo;
|
|
|
|
if (lo == hi)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
n = 2;
|
|
|
|
IFLT(*lo, *(lo-1)) {
|
|
|
|
*descending = 1;
|
|
|
|
for (lo = lo+1; lo < hi; ++lo, ++n) {
|
|
|
|
IFLT(*lo, *(lo-1))
|
|
|
|
;
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
for (lo = lo+1; lo < hi; ++lo, ++n) {
|
|
|
|
IFLT(*lo, *(lo-1))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return n;
|
2002-07-31 23:13:36 -03:00
|
|
|
fail:
|
2010-05-09 12:52:27 -03:00
|
|
|
return -1;
|
2002-07-31 23:13:36 -03:00
|
|
|
}
|
1998-06-16 12:18:28 -03:00
|
|
|
|
2002-07-31 23:13:36 -03:00
|
|
|
/*
|
|
|
|
Locate the proper position of key in a sorted vector; if the vector contains
|
|
|
|
an element equal to key, return the position immediately to the left of
|
|
|
|
the leftmost equal element. [gallop_right() does the same except returns
|
|
|
|
the position to the right of the rightmost equal element (if any).]
|
1998-06-16 12:18:28 -03:00
|
|
|
|
2002-07-31 23:13:36 -03:00
|
|
|
"a" is a sorted vector with n elements, starting at a[0]. n must be > 0.
|
1998-05-26 12:06:32 -03:00
|
|
|
|
2002-07-31 23:13:36 -03:00
|
|
|
"hint" is an index at which to begin the search, 0 <= hint < n. The closer
|
|
|
|
hint is to the final result, the faster this runs.
|
|
|
|
|
|
|
|
The return value is the int k in 0..n such that
|
|
|
|
|
|
|
|
a[k-1] < key <= a[k]
|
|
|
|
|
|
|
|
pretending that *(a-1) is minus infinity and a[n] is plus infinity. IOW,
|
|
|
|
key belongs at index k; or, IOW, the first k elements of a should precede
|
|
|
|
key, and the last n-k should follow key.
|
|
|
|
|
|
|
|
Returns -1 on error. See listsort.txt for info on the method.
|
|
|
|
*/
|
2006-02-15 13:27:45 -04:00
|
|
|
static Py_ssize_t
|
2008-01-30 16:15:17 -04:00
|
|
|
gallop_left(PyObject *key, PyObject **a, Py_ssize_t n, Py_ssize_t hint)
|
2002-07-31 23:13:36 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_ssize_t ofs;
|
|
|
|
Py_ssize_t lastofs;
|
|
|
|
Py_ssize_t k;
|
|
|
|
|
|
|
|
assert(key && a && n > 0 && hint >= 0 && hint < n);
|
|
|
|
|
|
|
|
a += hint;
|
|
|
|
lastofs = 0;
|
|
|
|
ofs = 1;
|
|
|
|
IFLT(*a, key) {
|
|
|
|
/* a[hint] < key -- gallop right, until
|
|
|
|
* a[hint + lastofs] < key <= a[hint + ofs]
|
|
|
|
*/
|
|
|
|
const Py_ssize_t maxofs = n - hint; /* &a[n-1] is highest */
|
|
|
|
while (ofs < maxofs) {
|
|
|
|
IFLT(a[ofs], key) {
|
|
|
|
lastofs = ofs;
|
|
|
|
ofs = (ofs << 1) + 1;
|
|
|
|
if (ofs <= 0) /* int overflow */
|
|
|
|
ofs = maxofs;
|
|
|
|
}
|
|
|
|
else /* key <= a[hint + ofs] */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (ofs > maxofs)
|
|
|
|
ofs = maxofs;
|
|
|
|
/* Translate back to offsets relative to &a[0]. */
|
|
|
|
lastofs += hint;
|
|
|
|
ofs += hint;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* key <= a[hint] -- gallop left, until
|
|
|
|
* a[hint - ofs] < key <= a[hint - lastofs]
|
|
|
|
*/
|
|
|
|
const Py_ssize_t maxofs = hint + 1; /* &a[0] is lowest */
|
|
|
|
while (ofs < maxofs) {
|
|
|
|
IFLT(*(a-ofs), key)
|
|
|
|
break;
|
|
|
|
/* key <= a[hint - ofs] */
|
|
|
|
lastofs = ofs;
|
|
|
|
ofs = (ofs << 1) + 1;
|
|
|
|
if (ofs <= 0) /* int overflow */
|
|
|
|
ofs = maxofs;
|
|
|
|
}
|
|
|
|
if (ofs > maxofs)
|
|
|
|
ofs = maxofs;
|
|
|
|
/* Translate back to positive offsets relative to &a[0]. */
|
|
|
|
k = lastofs;
|
|
|
|
lastofs = hint - ofs;
|
|
|
|
ofs = hint - k;
|
|
|
|
}
|
|
|
|
a -= hint;
|
|
|
|
|
|
|
|
assert(-1 <= lastofs && lastofs < ofs && ofs <= n);
|
|
|
|
/* Now a[lastofs] < key <= a[ofs], so key belongs somewhere to the
|
|
|
|
* right of lastofs but no farther right than ofs. Do a binary
|
|
|
|
* search, with invariant a[lastofs-1] < key <= a[ofs].
|
|
|
|
*/
|
|
|
|
++lastofs;
|
|
|
|
while (lastofs < ofs) {
|
|
|
|
Py_ssize_t m = lastofs + ((ofs - lastofs) >> 1);
|
|
|
|
|
|
|
|
IFLT(a[m], key)
|
|
|
|
lastofs = m+1; /* a[m] < key */
|
|
|
|
else
|
|
|
|
ofs = m; /* key <= a[m] */
|
|
|
|
}
|
|
|
|
assert(lastofs == ofs); /* so a[ofs-1] < key <= a[ofs] */
|
|
|
|
return ofs;
|
1996-12-10 19:55:39 -04:00
|
|
|
|
2002-07-31 23:13:36 -03:00
|
|
|
fail:
|
2010-05-09 12:52:27 -03:00
|
|
|
return -1;
|
2002-07-31 23:13:36 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
Exactly like gallop_left(), except that if key already exists in a[0:n],
|
|
|
|
finds the position immediately to the right of the rightmost equal value.
|
|
|
|
|
|
|
|
The return value is the int k in 0..n such that
|
|
|
|
|
|
|
|
a[k-1] <= key < a[k]
|
|
|
|
|
|
|
|
or -1 if error.
|
|
|
|
|
|
|
|
The code duplication is massive, but this is enough different given that
|
|
|
|
we're sticking to "<" comparisons that it's much harder to follow if
|
|
|
|
written as one routine with yet another "left or right?" flag.
|
|
|
|
*/
|
2006-02-15 13:27:45 -04:00
|
|
|
static Py_ssize_t
|
2008-01-30 16:15:17 -04:00
|
|
|
gallop_right(PyObject *key, PyObject **a, Py_ssize_t n, Py_ssize_t hint)
|
2002-07-31 23:13:36 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_ssize_t ofs;
|
|
|
|
Py_ssize_t lastofs;
|
|
|
|
Py_ssize_t k;
|
|
|
|
|
|
|
|
assert(key && a && n > 0 && hint >= 0 && hint < n);
|
|
|
|
|
|
|
|
a += hint;
|
|
|
|
lastofs = 0;
|
|
|
|
ofs = 1;
|
|
|
|
IFLT(key, *a) {
|
|
|
|
/* key < a[hint] -- gallop left, until
|
|
|
|
* a[hint - ofs] <= key < a[hint - lastofs]
|
|
|
|
*/
|
|
|
|
const Py_ssize_t maxofs = hint + 1; /* &a[0] is lowest */
|
|
|
|
while (ofs < maxofs) {
|
|
|
|
IFLT(key, *(a-ofs)) {
|
|
|
|
lastofs = ofs;
|
|
|
|
ofs = (ofs << 1) + 1;
|
|
|
|
if (ofs <= 0) /* int overflow */
|
|
|
|
ofs = maxofs;
|
|
|
|
}
|
|
|
|
else /* a[hint - ofs] <= key */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (ofs > maxofs)
|
|
|
|
ofs = maxofs;
|
|
|
|
/* Translate back to positive offsets relative to &a[0]. */
|
|
|
|
k = lastofs;
|
|
|
|
lastofs = hint - ofs;
|
|
|
|
ofs = hint - k;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* a[hint] <= key -- gallop right, until
|
|
|
|
* a[hint + lastofs] <= key < a[hint + ofs]
|
|
|
|
*/
|
|
|
|
const Py_ssize_t maxofs = n - hint; /* &a[n-1] is highest */
|
|
|
|
while (ofs < maxofs) {
|
|
|
|
IFLT(key, a[ofs])
|
|
|
|
break;
|
|
|
|
/* a[hint + ofs] <= key */
|
|
|
|
lastofs = ofs;
|
|
|
|
ofs = (ofs << 1) + 1;
|
|
|
|
if (ofs <= 0) /* int overflow */
|
|
|
|
ofs = maxofs;
|
|
|
|
}
|
|
|
|
if (ofs > maxofs)
|
|
|
|
ofs = maxofs;
|
|
|
|
/* Translate back to offsets relative to &a[0]. */
|
|
|
|
lastofs += hint;
|
|
|
|
ofs += hint;
|
|
|
|
}
|
|
|
|
a -= hint;
|
|
|
|
|
|
|
|
assert(-1 <= lastofs && lastofs < ofs && ofs <= n);
|
|
|
|
/* Now a[lastofs] <= key < a[ofs], so key belongs somewhere to the
|
|
|
|
* right of lastofs but no farther right than ofs. Do a binary
|
|
|
|
* search, with invariant a[lastofs-1] <= key < a[ofs].
|
|
|
|
*/
|
|
|
|
++lastofs;
|
|
|
|
while (lastofs < ofs) {
|
|
|
|
Py_ssize_t m = lastofs + ((ofs - lastofs) >> 1);
|
|
|
|
|
|
|
|
IFLT(key, a[m])
|
|
|
|
ofs = m; /* key < a[m] */
|
|
|
|
else
|
|
|
|
lastofs = m+1; /* a[m] <= key */
|
|
|
|
}
|
|
|
|
assert(lastofs == ofs); /* so a[ofs-1] <= key < a[ofs] */
|
|
|
|
return ofs;
|
2002-07-31 23:13:36 -03:00
|
|
|
|
|
|
|
fail:
|
2010-05-09 12:52:27 -03:00
|
|
|
return -1;
|
2002-07-31 23:13:36 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* The maximum number of entries in a MergeState's pending-runs stack.
|
|
|
|
* This is enough to sort arrays of size up to about
|
|
|
|
* 32 * phi ** MAX_MERGE_PENDING
|
|
|
|
* where phi ~= 1.618. 85 is ridiculouslylarge enough, good for an array
|
|
|
|
* with 2**64 elements.
|
|
|
|
*/
|
|
|
|
#define MAX_MERGE_PENDING 85
|
|
|
|
|
2002-08-10 02:21:15 -03:00
|
|
|
/* When we get into galloping mode, we stay there until both runs win less
|
|
|
|
* often than MIN_GALLOP consecutive times. See listsort.txt for more info.
|
2002-07-31 23:13:36 -03:00
|
|
|
*/
|
2002-08-10 02:21:15 -03:00
|
|
|
#define MIN_GALLOP 7
|
2002-07-31 23:13:36 -03:00
|
|
|
|
|
|
|
/* Avoid malloc for small temp arrays. */
|
|
|
|
#define MERGESTATE_TEMP_SIZE 256
|
|
|
|
|
|
|
|
/* One MergeState exists on the stack per invocation of mergesort. It's just
|
|
|
|
* a convenient way to pass state around among the helper functions.
|
|
|
|
*/
|
2002-08-10 02:21:15 -03:00
|
|
|
struct s_slice {
|
2010-12-02 17:55:33 -04:00
|
|
|
sortslice base;
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_ssize_t len;
|
2002-08-10 02:21:15 -03:00
|
|
|
};
|
|
|
|
|
2002-07-31 23:13:36 -03:00
|
|
|
typedef struct s_MergeState {
|
2010-05-09 12:52:27 -03:00
|
|
|
/* This controls when we get *into* galloping mode. It's initialized
|
|
|
|
* to MIN_GALLOP. merge_lo and merge_hi tend to nudge it higher for
|
|
|
|
* random data, and lower for highly structured data.
|
|
|
|
*/
|
|
|
|
Py_ssize_t min_gallop;
|
|
|
|
|
|
|
|
/* 'a' is temp storage to help with merges. It contains room for
|
|
|
|
* alloced entries.
|
|
|
|
*/
|
2010-12-02 17:55:33 -04:00
|
|
|
sortslice a; /* may point to temparray below */
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_ssize_t alloced;
|
|
|
|
|
|
|
|
/* A stack of n pending runs yet to be merged. Run #i starts at
|
|
|
|
* address base[i] and extends for len[i] elements. It's always
|
|
|
|
* true (so long as the indices are in bounds) that
|
|
|
|
*
|
|
|
|
* pending[i].base + pending[i].len == pending[i+1].base
|
|
|
|
*
|
|
|
|
* so we could cut the storage for this, but it's a minor amount,
|
|
|
|
* and keeping all the info explicit simplifies the code.
|
|
|
|
*/
|
|
|
|
int n;
|
|
|
|
struct s_slice pending[MAX_MERGE_PENDING];
|
|
|
|
|
|
|
|
/* 'a' points to this when possible, rather than muck with malloc. */
|
|
|
|
PyObject *temparray[MERGESTATE_TEMP_SIZE];
|
2002-07-31 23:13:36 -03:00
|
|
|
} MergeState;
|
|
|
|
|
|
|
|
/* Conceptually a MergeState's constructor. */
|
|
|
|
static void
|
2011-01-04 08:59:15 -04:00
|
|
|
merge_init(MergeState *ms, Py_ssize_t list_size, int has_keyfunc)
|
2002-07-31 23:13:36 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
assert(ms != NULL);
|
2010-12-02 17:55:33 -04:00
|
|
|
if (has_keyfunc) {
|
|
|
|
/* The temporary space for merging will need at most half the list
|
|
|
|
* size rounded up. Use the minimum possible space so we can use the
|
|
|
|
* rest of temparray for other things. In particular, if there is
|
|
|
|
* enough extra space, listsort() will use it to store the keys.
|
|
|
|
*/
|
|
|
|
ms->alloced = (list_size + 1) / 2;
|
|
|
|
|
|
|
|
/* ms->alloced describes how many keys will be stored at
|
|
|
|
ms->temparray, but we also need to store the values. Hence,
|
|
|
|
ms->alloced is capped at half of MERGESTATE_TEMP_SIZE. */
|
|
|
|
if (MERGESTATE_TEMP_SIZE / 2 < ms->alloced)
|
|
|
|
ms->alloced = MERGESTATE_TEMP_SIZE / 2;
|
|
|
|
ms->a.values = &ms->temparray[ms->alloced];
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
ms->alloced = MERGESTATE_TEMP_SIZE;
|
|
|
|
ms->a.values = NULL;
|
|
|
|
}
|
|
|
|
ms->a.keys = ms->temparray;
|
2010-05-09 12:52:27 -03:00
|
|
|
ms->n = 0;
|
|
|
|
ms->min_gallop = MIN_GALLOP;
|
2002-07-31 23:13:36 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Free all the temp memory owned by the MergeState. This must be called
|
|
|
|
* when you're done with a MergeState, and may be called before then if
|
|
|
|
* you want to free the temp memory early.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
merge_freemem(MergeState *ms)
|
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
assert(ms != NULL);
|
2010-12-02 17:55:33 -04:00
|
|
|
if (ms->a.keys != ms->temparray)
|
|
|
|
PyMem_Free(ms->a.keys);
|
2002-07-31 23:13:36 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Ensure enough temp memory for 'need' array slots is available.
|
|
|
|
* Returns 0 on success and -1 if the memory can't be gotten.
|
|
|
|
*/
|
|
|
|
static int
|
2006-02-15 13:27:45 -04:00
|
|
|
merge_getmem(MergeState *ms, Py_ssize_t need)
|
2002-07-31 23:13:36 -03:00
|
|
|
{
|
2010-12-02 17:55:33 -04:00
|
|
|
int multiplier;
|
|
|
|
|
2010-05-09 12:52:27 -03:00
|
|
|
assert(ms != NULL);
|
|
|
|
if (need <= ms->alloced)
|
|
|
|
return 0;
|
2010-12-02 17:55:33 -04:00
|
|
|
|
|
|
|
multiplier = ms->a.values != NULL ? 2 : 1;
|
|
|
|
|
2010-05-09 12:52:27 -03:00
|
|
|
/* Don't realloc! That can cost cycles to copy the old data, but
|
|
|
|
* we don't care what's in the block.
|
|
|
|
*/
|
|
|
|
merge_freemem(ms);
|
2010-12-02 17:55:33 -04:00
|
|
|
if ((size_t)need > PY_SSIZE_T_MAX / sizeof(PyObject*) / multiplier) {
|
2010-05-09 12:52:27 -03:00
|
|
|
PyErr_NoMemory();
|
|
|
|
return -1;
|
|
|
|
}
|
2010-12-02 17:55:33 -04:00
|
|
|
ms->a.keys = (PyObject**)PyMem_Malloc(multiplier * need
|
|
|
|
* sizeof(PyObject *));
|
|
|
|
if (ms->a.keys != NULL) {
|
2010-05-09 12:52:27 -03:00
|
|
|
ms->alloced = need;
|
2010-12-02 17:55:33 -04:00
|
|
|
if (ms->a.values != NULL)
|
|
|
|
ms->a.values = &ms->a.keys[need];
|
2010-05-09 12:52:27 -03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
PyErr_NoMemory();
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
#define MERGE_GETMEM(MS, NEED) ((NEED) <= (MS)->alloced ? 0 : \
|
|
|
|
merge_getmem(MS, NEED))
|
2002-07-31 23:13:36 -03:00
|
|
|
|
2010-12-02 17:55:33 -04:00
|
|
|
/* Merge the na elements starting at ssa with the nb elements starting at
|
|
|
|
* ssb.keys = ssa.keys + na in a stable way, in-place. na and nb must be > 0.
|
|
|
|
* Must also have that ssa.keys[na-1] belongs at the end of the merge, and
|
|
|
|
* should have na <= nb. See listsort.txt for more info. Return 0 if
|
|
|
|
* successful, -1 if error.
|
2002-07-31 23:13:36 -03:00
|
|
|
*/
|
2006-02-15 13:27:45 -04:00
|
|
|
static Py_ssize_t
|
2010-12-02 17:55:33 -04:00
|
|
|
merge_lo(MergeState *ms, sortslice ssa, Py_ssize_t na,
|
|
|
|
sortslice ssb, Py_ssize_t nb)
|
2002-07-31 23:13:36 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_ssize_t k;
|
2010-12-02 17:55:33 -04:00
|
|
|
sortslice dest;
|
2010-05-09 12:52:27 -03:00
|
|
|
int result = -1; /* guilty until proved innocent */
|
|
|
|
Py_ssize_t min_gallop;
|
|
|
|
|
2010-12-02 17:55:33 -04:00
|
|
|
assert(ms && ssa.keys && ssb.keys && na > 0 && nb > 0);
|
|
|
|
assert(ssa.keys + na == ssb.keys);
|
2010-05-09 12:52:27 -03:00
|
|
|
if (MERGE_GETMEM(ms, na) < 0)
|
|
|
|
return -1;
|
2010-12-02 17:55:33 -04:00
|
|
|
sortslice_memcpy(&ms->a, 0, &ssa, 0, na);
|
|
|
|
dest = ssa;
|
|
|
|
ssa = ms->a;
|
2010-05-09 12:52:27 -03:00
|
|
|
|
2010-12-02 17:55:33 -04:00
|
|
|
sortslice_copy_incr(&dest, &ssb);
|
2010-05-09 12:52:27 -03:00
|
|
|
--nb;
|
|
|
|
if (nb == 0)
|
|
|
|
goto Succeed;
|
|
|
|
if (na == 1)
|
|
|
|
goto CopyB;
|
|
|
|
|
|
|
|
min_gallop = ms->min_gallop;
|
|
|
|
for (;;) {
|
|
|
|
Py_ssize_t acount = 0; /* # of times A won in a row */
|
|
|
|
Py_ssize_t bcount = 0; /* # of times B won in a row */
|
|
|
|
|
|
|
|
/* Do the straightforward thing until (if ever) one run
|
|
|
|
* appears to win consistently.
|
|
|
|
*/
|
|
|
|
for (;;) {
|
|
|
|
assert(na > 1 && nb > 0);
|
2010-12-02 17:55:33 -04:00
|
|
|
k = ISLT(ssb.keys[0], ssa.keys[0]);
|
2010-05-09 12:52:27 -03:00
|
|
|
if (k) {
|
|
|
|
if (k < 0)
|
|
|
|
goto Fail;
|
2010-12-02 17:55:33 -04:00
|
|
|
sortslice_copy_incr(&dest, &ssb);
|
2010-05-09 12:52:27 -03:00
|
|
|
++bcount;
|
|
|
|
acount = 0;
|
|
|
|
--nb;
|
|
|
|
if (nb == 0)
|
|
|
|
goto Succeed;
|
|
|
|
if (bcount >= min_gallop)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
else {
|
2010-12-02 17:55:33 -04:00
|
|
|
sortslice_copy_incr(&dest, &ssa);
|
2010-05-09 12:52:27 -03:00
|
|
|
++acount;
|
|
|
|
bcount = 0;
|
|
|
|
--na;
|
|
|
|
if (na == 1)
|
|
|
|
goto CopyB;
|
|
|
|
if (acount >= min_gallop)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* One run is winning so consistently that galloping may
|
|
|
|
* be a huge win. So try that, and continue galloping until
|
|
|
|
* (if ever) neither run appears to be winning consistently
|
|
|
|
* anymore.
|
|
|
|
*/
|
|
|
|
++min_gallop;
|
|
|
|
do {
|
|
|
|
assert(na > 1 && nb > 0);
|
|
|
|
min_gallop -= min_gallop > 1;
|
|
|
|
ms->min_gallop = min_gallop;
|
2010-12-02 17:55:33 -04:00
|
|
|
k = gallop_right(ssb.keys[0], ssa.keys, na, 0);
|
2010-05-09 12:52:27 -03:00
|
|
|
acount = k;
|
|
|
|
if (k) {
|
|
|
|
if (k < 0)
|
|
|
|
goto Fail;
|
2010-12-02 17:55:33 -04:00
|
|
|
sortslice_memcpy(&dest, 0, &ssa, 0, k);
|
|
|
|
sortslice_advance(&dest, k);
|
|
|
|
sortslice_advance(&ssa, k);
|
2010-05-09 12:52:27 -03:00
|
|
|
na -= k;
|
|
|
|
if (na == 1)
|
|
|
|
goto CopyB;
|
|
|
|
/* na==0 is impossible now if the comparison
|
|
|
|
* function is consistent, but we can't assume
|
|
|
|
* that it is.
|
|
|
|
*/
|
|
|
|
if (na == 0)
|
|
|
|
goto Succeed;
|
|
|
|
}
|
2010-12-02 17:55:33 -04:00
|
|
|
sortslice_copy_incr(&dest, &ssb);
|
2010-05-09 12:52:27 -03:00
|
|
|
--nb;
|
|
|
|
if (nb == 0)
|
|
|
|
goto Succeed;
|
|
|
|
|
2010-12-02 17:55:33 -04:00
|
|
|
k = gallop_left(ssa.keys[0], ssb.keys, nb, 0);
|
2010-05-09 12:52:27 -03:00
|
|
|
bcount = k;
|
|
|
|
if (k) {
|
|
|
|
if (k < 0)
|
|
|
|
goto Fail;
|
2010-12-02 17:55:33 -04:00
|
|
|
sortslice_memmove(&dest, 0, &ssb, 0, k);
|
|
|
|
sortslice_advance(&dest, k);
|
|
|
|
sortslice_advance(&ssb, k);
|
2010-05-09 12:52:27 -03:00
|
|
|
nb -= k;
|
|
|
|
if (nb == 0)
|
|
|
|
goto Succeed;
|
|
|
|
}
|
2010-12-02 17:55:33 -04:00
|
|
|
sortslice_copy_incr(&dest, &ssa);
|
2010-05-09 12:52:27 -03:00
|
|
|
--na;
|
|
|
|
if (na == 1)
|
|
|
|
goto CopyB;
|
|
|
|
} while (acount >= MIN_GALLOP || bcount >= MIN_GALLOP);
|
|
|
|
++min_gallop; /* penalize it for leaving galloping mode */
|
|
|
|
ms->min_gallop = min_gallop;
|
|
|
|
}
|
2002-07-31 23:13:36 -03:00
|
|
|
Succeed:
|
2010-05-09 12:52:27 -03:00
|
|
|
result = 0;
|
2002-07-31 23:13:36 -03:00
|
|
|
Fail:
|
2010-05-09 12:52:27 -03:00
|
|
|
if (na)
|
2010-12-02 17:55:33 -04:00
|
|
|
sortslice_memcpy(&dest, 0, &ssa, 0, na);
|
2010-05-09 12:52:27 -03:00
|
|
|
return result;
|
2002-07-31 23:13:36 -03:00
|
|
|
CopyB:
|
2010-05-09 12:52:27 -03:00
|
|
|
assert(na == 1 && nb > 0);
|
2010-12-02 17:55:33 -04:00
|
|
|
/* The last element of ssa belongs at the end of the merge. */
|
|
|
|
sortslice_memmove(&dest, 0, &ssb, 0, nb);
|
|
|
|
sortslice_copy(&dest, nb, &ssa, 0);
|
2010-05-09 12:52:27 -03:00
|
|
|
return 0;
|
2002-07-31 23:13:36 -03:00
|
|
|
}
|
|
|
|
|
2010-12-02 17:55:33 -04:00
|
|
|
/* Merge the na elements starting at pa with the nb elements starting at
|
|
|
|
* ssb.keys = ssa.keys + na in a stable way, in-place. na and nb must be > 0.
|
|
|
|
* Must also have that ssa.keys[na-1] belongs at the end of the merge, and
|
|
|
|
* should have na >= nb. See listsort.txt for more info. Return 0 if
|
|
|
|
* successful, -1 if error.
|
2002-07-31 23:13:36 -03:00
|
|
|
*/
|
2006-02-15 13:27:45 -04:00
|
|
|
static Py_ssize_t
|
2010-12-02 17:55:33 -04:00
|
|
|
merge_hi(MergeState *ms, sortslice ssa, Py_ssize_t na,
|
|
|
|
sortslice ssb, Py_ssize_t nb)
|
2002-07-31 23:13:36 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_ssize_t k;
|
2010-12-02 17:55:33 -04:00
|
|
|
sortslice dest, basea, baseb;
|
2010-05-09 12:52:27 -03:00
|
|
|
int result = -1; /* guilty until proved innocent */
|
|
|
|
Py_ssize_t min_gallop;
|
|
|
|
|
2010-12-02 17:55:33 -04:00
|
|
|
assert(ms && ssa.keys && ssb.keys && na > 0 && nb > 0);
|
|
|
|
assert(ssa.keys + na == ssb.keys);
|
2010-05-09 12:52:27 -03:00
|
|
|
if (MERGE_GETMEM(ms, nb) < 0)
|
|
|
|
return -1;
|
2010-12-02 17:55:33 -04:00
|
|
|
dest = ssb;
|
|
|
|
sortslice_advance(&dest, nb-1);
|
|
|
|
sortslice_memcpy(&ms->a, 0, &ssb, 0, nb);
|
|
|
|
basea = ssa;
|
2010-05-09 12:52:27 -03:00
|
|
|
baseb = ms->a;
|
2010-12-02 17:55:33 -04:00
|
|
|
ssb.keys = ms->a.keys + nb - 1;
|
|
|
|
if (ssb.values != NULL)
|
|
|
|
ssb.values = ms->a.values + nb - 1;
|
|
|
|
sortslice_advance(&ssa, na - 1);
|
2010-05-09 12:52:27 -03:00
|
|
|
|
2010-12-02 17:55:33 -04:00
|
|
|
sortslice_copy_decr(&dest, &ssa);
|
2010-05-09 12:52:27 -03:00
|
|
|
--na;
|
|
|
|
if (na == 0)
|
|
|
|
goto Succeed;
|
|
|
|
if (nb == 1)
|
|
|
|
goto CopyA;
|
|
|
|
|
|
|
|
min_gallop = ms->min_gallop;
|
|
|
|
for (;;) {
|
|
|
|
Py_ssize_t acount = 0; /* # of times A won in a row */
|
|
|
|
Py_ssize_t bcount = 0; /* # of times B won in a row */
|
|
|
|
|
|
|
|
/* Do the straightforward thing until (if ever) one run
|
|
|
|
* appears to win consistently.
|
|
|
|
*/
|
|
|
|
for (;;) {
|
|
|
|
assert(na > 0 && nb > 1);
|
2010-12-02 17:55:33 -04:00
|
|
|
k = ISLT(ssb.keys[0], ssa.keys[0]);
|
2010-05-09 12:52:27 -03:00
|
|
|
if (k) {
|
|
|
|
if (k < 0)
|
|
|
|
goto Fail;
|
2010-12-02 17:55:33 -04:00
|
|
|
sortslice_copy_decr(&dest, &ssa);
|
2010-05-09 12:52:27 -03:00
|
|
|
++acount;
|
|
|
|
bcount = 0;
|
|
|
|
--na;
|
|
|
|
if (na == 0)
|
|
|
|
goto Succeed;
|
|
|
|
if (acount >= min_gallop)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
else {
|
2010-12-02 17:55:33 -04:00
|
|
|
sortslice_copy_decr(&dest, &ssb);
|
2010-05-09 12:52:27 -03:00
|
|
|
++bcount;
|
|
|
|
acount = 0;
|
|
|
|
--nb;
|
|
|
|
if (nb == 1)
|
|
|
|
goto CopyA;
|
|
|
|
if (bcount >= min_gallop)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* One run is winning so consistently that galloping may
|
|
|
|
* be a huge win. So try that, and continue galloping until
|
|
|
|
* (if ever) neither run appears to be winning consistently
|
|
|
|
* anymore.
|
|
|
|
*/
|
|
|
|
++min_gallop;
|
|
|
|
do {
|
|
|
|
assert(na > 0 && nb > 1);
|
|
|
|
min_gallop -= min_gallop > 1;
|
|
|
|
ms->min_gallop = min_gallop;
|
2010-12-02 17:55:33 -04:00
|
|
|
k = gallop_right(ssb.keys[0], basea.keys, na, na-1);
|
2010-05-09 12:52:27 -03:00
|
|
|
if (k < 0)
|
|
|
|
goto Fail;
|
|
|
|
k = na - k;
|
|
|
|
acount = k;
|
|
|
|
if (k) {
|
2010-12-02 17:55:33 -04:00
|
|
|
sortslice_advance(&dest, -k);
|
|
|
|
sortslice_advance(&ssa, -k);
|
|
|
|
sortslice_memmove(&dest, 1, &ssa, 1, k);
|
2010-05-09 12:52:27 -03:00
|
|
|
na -= k;
|
|
|
|
if (na == 0)
|
|
|
|
goto Succeed;
|
|
|
|
}
|
2010-12-02 17:55:33 -04:00
|
|
|
sortslice_copy_decr(&dest, &ssb);
|
2010-05-09 12:52:27 -03:00
|
|
|
--nb;
|
|
|
|
if (nb == 1)
|
|
|
|
goto CopyA;
|
|
|
|
|
2010-12-02 17:55:33 -04:00
|
|
|
k = gallop_left(ssa.keys[0], baseb.keys, nb, nb-1);
|
2010-05-09 12:52:27 -03:00
|
|
|
if (k < 0)
|
|
|
|
goto Fail;
|
|
|
|
k = nb - k;
|
|
|
|
bcount = k;
|
|
|
|
if (k) {
|
2010-12-02 17:55:33 -04:00
|
|
|
sortslice_advance(&dest, -k);
|
|
|
|
sortslice_advance(&ssb, -k);
|
|
|
|
sortslice_memcpy(&dest, 1, &ssb, 1, k);
|
2010-05-09 12:52:27 -03:00
|
|
|
nb -= k;
|
|
|
|
if (nb == 1)
|
|
|
|
goto CopyA;
|
|
|
|
/* nb==0 is impossible now if the comparison
|
|
|
|
* function is consistent, but we can't assume
|
|
|
|
* that it is.
|
|
|
|
*/
|
|
|
|
if (nb == 0)
|
|
|
|
goto Succeed;
|
|
|
|
}
|
2010-12-02 17:55:33 -04:00
|
|
|
sortslice_copy_decr(&dest, &ssa);
|
2010-05-09 12:52:27 -03:00
|
|
|
--na;
|
|
|
|
if (na == 0)
|
|
|
|
goto Succeed;
|
|
|
|
} while (acount >= MIN_GALLOP || bcount >= MIN_GALLOP);
|
|
|
|
++min_gallop; /* penalize it for leaving galloping mode */
|
|
|
|
ms->min_gallop = min_gallop;
|
|
|
|
}
|
2002-07-31 23:13:36 -03:00
|
|
|
Succeed:
|
2010-05-09 12:52:27 -03:00
|
|
|
result = 0;
|
2002-07-31 23:13:36 -03:00
|
|
|
Fail:
|
2010-05-09 12:52:27 -03:00
|
|
|
if (nb)
|
2010-12-02 17:55:33 -04:00
|
|
|
sortslice_memcpy(&dest, -(nb-1), &baseb, 0, nb);
|
2010-05-09 12:52:27 -03:00
|
|
|
return result;
|
2002-07-31 23:13:36 -03:00
|
|
|
CopyA:
|
2010-05-09 12:52:27 -03:00
|
|
|
assert(nb == 1 && na > 0);
|
2010-12-02 17:55:33 -04:00
|
|
|
/* The first element of ssb belongs at the front of the merge. */
|
|
|
|
sortslice_memmove(&dest, 1-na, &ssa, 1-na, na);
|
|
|
|
sortslice_advance(&dest, -na);
|
|
|
|
sortslice_advance(&ssa, -na);
|
|
|
|
sortslice_copy(&dest, 0, &ssb, 0);
|
2010-05-09 12:52:27 -03:00
|
|
|
return 0;
|
2002-07-31 23:13:36 -03:00
|
|
|
}
|
1998-05-13 18:20:49 -03:00
|
|
|
|
2002-07-31 23:13:36 -03:00
|
|
|
/* Merge the two runs at stack indices i and i+1.
|
|
|
|
* Returns 0 on success, -1 on error.
|
|
|
|
*/
|
2006-02-15 13:27:45 -04:00
|
|
|
static Py_ssize_t
|
|
|
|
merge_at(MergeState *ms, Py_ssize_t i)
|
2002-07-31 23:13:36 -03:00
|
|
|
{
|
2010-12-02 17:55:33 -04:00
|
|
|
sortslice ssa, ssb;
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_ssize_t na, nb;
|
|
|
|
Py_ssize_t k;
|
|
|
|
|
|
|
|
assert(ms != NULL);
|
|
|
|
assert(ms->n >= 2);
|
|
|
|
assert(i >= 0);
|
|
|
|
assert(i == ms->n - 2 || i == ms->n - 3);
|
|
|
|
|
2010-12-02 17:55:33 -04:00
|
|
|
ssa = ms->pending[i].base;
|
2010-05-09 12:52:27 -03:00
|
|
|
na = ms->pending[i].len;
|
2010-12-02 17:55:33 -04:00
|
|
|
ssb = ms->pending[i+1].base;
|
2010-05-09 12:52:27 -03:00
|
|
|
nb = ms->pending[i+1].len;
|
|
|
|
assert(na > 0 && nb > 0);
|
2010-12-02 17:55:33 -04:00
|
|
|
assert(ssa.keys + na == ssb.keys);
|
2010-05-09 12:52:27 -03:00
|
|
|
|
|
|
|
/* Record the length of the combined runs; if i is the 3rd-last
|
|
|
|
* run now, also slide over the last run (which isn't involved
|
|
|
|
* in this merge). The current run i+1 goes away in any case.
|
|
|
|
*/
|
|
|
|
ms->pending[i].len = na + nb;
|
|
|
|
if (i == ms->n - 3)
|
|
|
|
ms->pending[i+1] = ms->pending[i+2];
|
|
|
|
--ms->n;
|
|
|
|
|
|
|
|
/* Where does b start in a? Elements in a before that can be
|
|
|
|
* ignored (already in place).
|
|
|
|
*/
|
2010-12-02 17:55:33 -04:00
|
|
|
k = gallop_right(*ssb.keys, ssa.keys, na, 0);
|
2010-05-09 12:52:27 -03:00
|
|
|
if (k < 0)
|
|
|
|
return -1;
|
2010-12-02 17:55:33 -04:00
|
|
|
sortslice_advance(&ssa, k);
|
2010-05-09 12:52:27 -03:00
|
|
|
na -= k;
|
|
|
|
if (na == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Where does a end in b? Elements in b after that can be
|
|
|
|
* ignored (already in place).
|
|
|
|
*/
|
2010-12-02 17:55:33 -04:00
|
|
|
nb = gallop_left(ssa.keys[na-1], ssb.keys, nb, nb-1);
|
2010-05-09 12:52:27 -03:00
|
|
|
if (nb <= 0)
|
|
|
|
return nb;
|
|
|
|
|
|
|
|
/* Merge what remains of the runs, using a temp array with
|
|
|
|
* min(na, nb) elements.
|
|
|
|
*/
|
|
|
|
if (na <= nb)
|
2010-12-02 17:55:33 -04:00
|
|
|
return merge_lo(ms, ssa, na, ssb, nb);
|
2010-05-09 12:52:27 -03:00
|
|
|
else
|
2010-12-02 17:55:33 -04:00
|
|
|
return merge_hi(ms, ssa, na, ssb, nb);
|
2002-07-31 23:13:36 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Examine the stack of runs waiting to be merged, merging adjacent runs
|
|
|
|
* until the stack invariants are re-established:
|
|
|
|
*
|
|
|
|
* 1. len[-3] > len[-2] + len[-1]
|
|
|
|
* 2. len[-2] > len[-1]
|
|
|
|
*
|
|
|
|
* See listsort.txt for more info.
|
|
|
|
*
|
|
|
|
* Returns 0 on success, -1 on error.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
merge_collapse(MergeState *ms)
|
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
struct s_slice *p = ms->pending;
|
|
|
|
|
|
|
|
assert(ms);
|
|
|
|
while (ms->n > 1) {
|
|
|
|
Py_ssize_t n = ms->n - 2;
|
2015-02-25 11:12:26 -04:00
|
|
|
if ((n > 0 && p[n-1].len <= p[n].len + p[n+1].len) ||
|
|
|
|
(n > 1 && p[n-2].len <= p[n-1].len + p[n].len)) {
|
2010-05-09 12:52:27 -03:00
|
|
|
if (p[n-1].len < p[n+1].len)
|
|
|
|
--n;
|
|
|
|
if (merge_at(ms, n) < 0)
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
else if (p[n].len <= p[n+1].len) {
|
|
|
|
if (merge_at(ms, n) < 0)
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return 0;
|
2002-07-31 23:13:36 -03:00
|
|
|
}
|
1997-12-10 11:14:24 -04:00
|
|
|
|
2002-07-31 23:13:36 -03:00
|
|
|
/* Regardless of invariants, merge all runs on the stack until only one
|
|
|
|
* remains. This is used at the end of the mergesort.
|
|
|
|
*
|
|
|
|
* Returns 0 on success, -1 on error.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
merge_force_collapse(MergeState *ms)
|
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
struct s_slice *p = ms->pending;
|
2002-07-31 23:13:36 -03:00
|
|
|
|
2010-05-09 12:52:27 -03:00
|
|
|
assert(ms);
|
|
|
|
while (ms->n > 1) {
|
|
|
|
Py_ssize_t n = ms->n - 2;
|
|
|
|
if (n > 0 && p[n-1].len < p[n+1].len)
|
|
|
|
--n;
|
|
|
|
if (merge_at(ms, n) < 0)
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
2002-07-31 23:13:36 -03:00
|
|
|
}
|
1998-05-29 14:56:32 -03:00
|
|
|
|
2002-07-31 23:13:36 -03:00
|
|
|
/* Compute a good value for the minimum run length; natural runs shorter
|
|
|
|
* than this are boosted artificially via binary insertion.
|
|
|
|
*
|
|
|
|
* If n < 64, return n (it's too small to bother with fancy stuff).
|
|
|
|
* Else if n is an exact power of 2, return 32.
|
|
|
|
* Else return an int k, 32 <= k <= 64, such that n/k is close to, but
|
|
|
|
* strictly less than, an exact power of 2.
|
|
|
|
*
|
|
|
|
* See listsort.txt for more info.
|
|
|
|
*/
|
2006-02-15 13:27:45 -04:00
|
|
|
static Py_ssize_t
|
|
|
|
merge_compute_minrun(Py_ssize_t n)
|
2002-07-31 23:13:36 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_ssize_t r = 0; /* becomes 1 if any 1 bits are shifted off */
|
2002-07-31 23:13:36 -03:00
|
|
|
|
2010-05-09 12:52:27 -03:00
|
|
|
assert(n >= 0);
|
|
|
|
while (n >= 64) {
|
|
|
|
r |= n & 1;
|
|
|
|
n >>= 1;
|
|
|
|
}
|
|
|
|
return n + r;
|
1998-06-16 12:18:28 -03:00
|
|
|
}
|
1998-05-29 14:56:32 -03:00
|
|
|
|
2006-04-21 07:40:58 -03:00
|
|
|
static void
|
2010-12-02 17:55:33 -04:00
|
|
|
reverse_sortslice(sortslice *s, Py_ssize_t n)
|
2003-10-16 00:41:09 -03:00
|
|
|
{
|
2010-12-02 17:55:33 -04:00
|
|
|
reverse_slice(s->keys, &s->keys[n]);
|
|
|
|
if (s->values != NULL)
|
|
|
|
reverse_slice(s->values, &s->values[n]);
|
2003-10-16 00:41:09 -03:00
|
|
|
}
|
|
|
|
|
2002-07-31 23:13:36 -03:00
|
|
|
/* An adaptive, stable, natural mergesort. See listsort.txt.
|
|
|
|
* Returns Py_None on success, NULL on error. Even in case of error, the
|
|
|
|
* list will be some permutation of its input state (nothing is lost or
|
|
|
|
* duplicated).
|
|
|
|
*/
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2003-10-16 00:41:09 -03:00
|
|
|
listsort(PyListObject *self, PyObject *args, PyObject *kwds)
|
1996-12-10 19:55:39 -04:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
MergeState ms;
|
|
|
|
Py_ssize_t nremaining;
|
|
|
|
Py_ssize_t minrun;
|
2010-12-02 17:55:33 -04:00
|
|
|
sortslice lo;
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_ssize_t saved_ob_size, saved_allocated;
|
|
|
|
PyObject **saved_ob_item;
|
|
|
|
PyObject **final_ob_item;
|
|
|
|
PyObject *result = NULL; /* guilty until proved innocent */
|
|
|
|
int reverse = 0;
|
|
|
|
PyObject *keyfunc = NULL;
|
|
|
|
Py_ssize_t i;
|
|
|
|
static char *kwlist[] = {"key", "reverse", 0};
|
2010-12-02 17:55:33 -04:00
|
|
|
PyObject **keys;
|
2010-05-09 12:52:27 -03:00
|
|
|
|
|
|
|
assert(self != NULL);
|
|
|
|
assert (PyList_Check(self));
|
|
|
|
if (args != NULL) {
|
|
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Oi:sort",
|
|
|
|
kwlist, &keyfunc, &reverse))
|
|
|
|
return NULL;
|
|
|
|
if (Py_SIZE(args) > 0) {
|
|
|
|
PyErr_SetString(PyExc_TypeError,
|
|
|
|
"must use keyword argument for key function");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (keyfunc == Py_None)
|
|
|
|
keyfunc = NULL;
|
|
|
|
|
|
|
|
/* The list is temporarily made empty, so that mutations performed
|
|
|
|
* by comparison functions can't affect the slice of memory we're
|
|
|
|
* sorting (allowing mutations during sorting is a core-dump
|
|
|
|
* factory, since ob_item may change).
|
|
|
|
*/
|
|
|
|
saved_ob_size = Py_SIZE(self);
|
|
|
|
saved_ob_item = self->ob_item;
|
|
|
|
saved_allocated = self->allocated;
|
|
|
|
Py_SIZE(self) = 0;
|
|
|
|
self->ob_item = NULL;
|
|
|
|
self->allocated = -1; /* any operation will reset it to >= 0 */
|
|
|
|
|
2010-12-02 17:55:33 -04:00
|
|
|
if (keyfunc == NULL) {
|
|
|
|
keys = NULL;
|
|
|
|
lo.keys = saved_ob_item;
|
|
|
|
lo.values = NULL;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (saved_ob_size < MERGESTATE_TEMP_SIZE/2)
|
|
|
|
/* Leverage stack space we allocated but won't otherwise use */
|
|
|
|
keys = &ms.temparray[saved_ob_size+1];
|
|
|
|
else {
|
|
|
|
keys = PyMem_MALLOC(sizeof(PyObject *) * saved_ob_size);
|
2015-04-23 18:04:36 -03:00
|
|
|
if (keys == NULL) {
|
|
|
|
PyErr_NoMemory();
|
|
|
|
goto keyfunc_fail;
|
|
|
|
}
|
2010-12-02 17:55:33 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < saved_ob_size ; i++) {
|
|
|
|
keys[i] = PyObject_CallFunctionObjArgs(keyfunc, saved_ob_item[i],
|
|
|
|
NULL);
|
|
|
|
if (keys[i] == NULL) {
|
|
|
|
for (i=i-1 ; i>=0 ; i--)
|
|
|
|
Py_DECREF(keys[i]);
|
2014-03-15 14:21:28 -03:00
|
|
|
if (saved_ob_size >= MERGESTATE_TEMP_SIZE/2)
|
2011-03-02 19:37:50 -04:00
|
|
|
PyMem_FREE(keys);
|
2010-12-02 17:55:33 -04:00
|
|
|
goto keyfunc_fail;
|
2010-05-09 12:52:27 -03:00
|
|
|
}
|
|
|
|
}
|
2010-12-02 17:55:33 -04:00
|
|
|
|
|
|
|
lo.keys = keys;
|
|
|
|
lo.values = saved_ob_item;
|
2010-05-09 12:52:27 -03:00
|
|
|
}
|
|
|
|
|
2010-12-02 17:55:33 -04:00
|
|
|
merge_init(&ms, saved_ob_size, keys != NULL);
|
2010-05-09 12:52:27 -03:00
|
|
|
|
|
|
|
nremaining = saved_ob_size;
|
|
|
|
if (nremaining < 2)
|
|
|
|
goto succeed;
|
|
|
|
|
2010-08-23 16:35:39 -03:00
|
|
|
/* Reverse sort stability achieved by initially reversing the list,
|
|
|
|
applying a stable forward sort, then reversing the final result. */
|
2010-12-02 17:55:33 -04:00
|
|
|
if (reverse) {
|
|
|
|
if (keys != NULL)
|
|
|
|
reverse_slice(&keys[0], &keys[saved_ob_size]);
|
|
|
|
reverse_slice(&saved_ob_item[0], &saved_ob_item[saved_ob_size]);
|
|
|
|
}
|
2010-08-23 16:35:39 -03:00
|
|
|
|
2010-05-09 12:52:27 -03:00
|
|
|
/* March over the array once, left to right, finding natural runs,
|
|
|
|
* and extending short natural runs to minrun elements.
|
|
|
|
*/
|
|
|
|
minrun = merge_compute_minrun(nremaining);
|
|
|
|
do {
|
|
|
|
int descending;
|
|
|
|
Py_ssize_t n;
|
|
|
|
|
|
|
|
/* Identify next run. */
|
2010-12-02 17:55:33 -04:00
|
|
|
n = count_run(lo.keys, lo.keys + nremaining, &descending);
|
2010-05-09 12:52:27 -03:00
|
|
|
if (n < 0)
|
|
|
|
goto fail;
|
|
|
|
if (descending)
|
2010-12-02 17:55:33 -04:00
|
|
|
reverse_sortslice(&lo, n);
|
2010-05-09 12:52:27 -03:00
|
|
|
/* If short, extend to min(minrun, nremaining). */
|
|
|
|
if (n < minrun) {
|
|
|
|
const Py_ssize_t force = nremaining <= minrun ?
|
|
|
|
nremaining : minrun;
|
2010-12-02 17:55:33 -04:00
|
|
|
if (binarysort(lo, lo.keys + force, lo.keys + n) < 0)
|
2010-05-09 12:52:27 -03:00
|
|
|
goto fail;
|
|
|
|
n = force;
|
|
|
|
}
|
|
|
|
/* Push run onto pending-runs stack, and maybe merge. */
|
|
|
|
assert(ms.n < MAX_MERGE_PENDING);
|
|
|
|
ms.pending[ms.n].base = lo;
|
|
|
|
ms.pending[ms.n].len = n;
|
|
|
|
++ms.n;
|
|
|
|
if (merge_collapse(&ms) < 0)
|
|
|
|
goto fail;
|
|
|
|
/* Advance to find next run. */
|
2010-12-02 17:55:33 -04:00
|
|
|
sortslice_advance(&lo, n);
|
2010-05-09 12:52:27 -03:00
|
|
|
nremaining -= n;
|
|
|
|
} while (nremaining);
|
|
|
|
|
|
|
|
if (merge_force_collapse(&ms) < 0)
|
|
|
|
goto fail;
|
|
|
|
assert(ms.n == 1);
|
2010-12-02 17:55:33 -04:00
|
|
|
assert(keys == NULL
|
|
|
|
? ms.pending[0].base.keys == saved_ob_item
|
|
|
|
: ms.pending[0].base.keys == &keys[0]);
|
2010-05-09 12:52:27 -03:00
|
|
|
assert(ms.pending[0].len == saved_ob_size);
|
2010-12-02 17:55:33 -04:00
|
|
|
lo = ms.pending[0].base;
|
2002-07-19 04:05:44 -03:00
|
|
|
|
2002-07-31 23:13:36 -03:00
|
|
|
succeed:
|
2010-05-09 12:52:27 -03:00
|
|
|
result = Py_None;
|
2002-07-19 04:05:44 -03:00
|
|
|
fail:
|
2010-12-02 17:55:33 -04:00
|
|
|
if (keys != NULL) {
|
|
|
|
for (i = 0; i < saved_ob_size; i++)
|
|
|
|
Py_DECREF(keys[i]);
|
2014-03-14 23:54:31 -03:00
|
|
|
if (saved_ob_size >= MERGESTATE_TEMP_SIZE/2)
|
2010-12-02 17:55:33 -04:00
|
|
|
PyMem_FREE(keys);
|
2010-05-09 12:52:27 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
if (self->allocated != -1 && result != NULL) {
|
|
|
|
/* The user mucked with the list during the sort,
|
|
|
|
* and we don't already have another error to report.
|
|
|
|
*/
|
|
|
|
PyErr_SetString(PyExc_ValueError, "list modified during sort");
|
|
|
|
result = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (reverse && saved_ob_size > 1)
|
|
|
|
reverse_slice(saved_ob_item, saved_ob_item + saved_ob_size);
|
|
|
|
|
|
|
|
merge_freemem(&ms);
|
2003-10-16 00:41:09 -03:00
|
|
|
|
2010-12-02 17:55:33 -04:00
|
|
|
keyfunc_fail:
|
2010-05-09 12:52:27 -03:00
|
|
|
final_ob_item = self->ob_item;
|
|
|
|
i = Py_SIZE(self);
|
|
|
|
Py_SIZE(self) = saved_ob_size;
|
|
|
|
self->ob_item = saved_ob_item;
|
|
|
|
self->allocated = saved_allocated;
|
|
|
|
if (final_ob_item != NULL) {
|
|
|
|
/* we cannot use list_clear() for this because it does not
|
|
|
|
guarantee that the list is really empty when it returns */
|
|
|
|
while (--i >= 0) {
|
|
|
|
Py_XDECREF(final_ob_item[i]);
|
|
|
|
}
|
|
|
|
PyMem_FREE(final_ob_item);
|
|
|
|
}
|
|
|
|
Py_XINCREF(result);
|
|
|
|
return result;
|
1996-12-10 19:55:39 -04:00
|
|
|
}
|
2002-07-19 04:05:44 -03:00
|
|
|
#undef IFLT
|
2002-08-04 14:47:26 -03:00
|
|
|
#undef ISLT
|
2002-07-19 04:05:44 -03:00
|
|
|
|
1998-06-16 12:18:28 -03:00
|
|
|
int
|
2000-07-09 12:16:51 -03:00
|
|
|
PyList_Sort(PyObject *v)
|
1998-06-16 12:18:28 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
if (v == NULL || !PyList_Check(v)) {
|
|
|
|
PyErr_BadInternalCall();
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
v = listsort((PyListObject *)v, (PyObject *)NULL, (PyObject *)NULL);
|
|
|
|
if (v == NULL)
|
|
|
|
return -1;
|
|
|
|
Py_DECREF(v);
|
|
|
|
return 0;
|
1998-06-16 12:18:28 -03:00
|
|
|
}
|
|
|
|
|
2001-02-12 18:06:02 -04:00
|
|
|
static PyObject *
|
2001-08-16 10:15:00 -03:00
|
|
|
listreverse(PyListObject *self)
|
2001-02-12 18:06:02 -04:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
if (Py_SIZE(self) > 1)
|
|
|
|
reverse_slice(self->ob_item, self->ob_item + Py_SIZE(self));
|
|
|
|
Py_RETURN_NONE;
|
1991-03-06 09:07:53 -04:00
|
|
|
}
|
|
|
|
|
1995-01-17 12:34:45 -04:00
|
|
|
int
|
2000-07-09 12:16:51 -03:00
|
|
|
PyList_Reverse(PyObject *v)
|
1995-01-17 12:34:45 -04:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
PyListObject *self = (PyListObject *)v;
|
2002-08-07 22:06:39 -03:00
|
|
|
|
2010-05-09 12:52:27 -03:00
|
|
|
if (v == NULL || !PyList_Check(v)) {
|
|
|
|
PyErr_BadInternalCall();
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (Py_SIZE(self) > 1)
|
|
|
|
reverse_slice(self->ob_item, self->ob_item + Py_SIZE(self));
|
|
|
|
return 0;
|
1995-01-17 12:34:45 -04:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
PyObject *
|
2000-07-09 12:16:51 -03:00
|
|
|
PyList_AsTuple(PyObject *v)
|
1994-08-29 09:45:32 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
PyObject *w;
|
|
|
|
PyObject **p, **q;
|
|
|
|
Py_ssize_t n;
|
|
|
|
if (v == NULL || !PyList_Check(v)) {
|
|
|
|
PyErr_BadInternalCall();
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
n = Py_SIZE(v);
|
|
|
|
w = PyTuple_New(n);
|
|
|
|
if (w == NULL)
|
|
|
|
return NULL;
|
|
|
|
p = ((PyTupleObject *)w)->ob_item;
|
|
|
|
q = ((PyListObject *)v)->ob_item;
|
|
|
|
while (--n >= 0) {
|
|
|
|
Py_INCREF(*q);
|
|
|
|
*p = *q;
|
|
|
|
p++;
|
|
|
|
q++;
|
|
|
|
}
|
|
|
|
return w;
|
1994-08-29 09:45:32 -03:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2003-06-17 02:05:49 -03:00
|
|
|
listindex(PyListObject *self, PyObject *args)
|
1991-03-06 09:07:53 -04:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_ssize_t i, start=0, stop=Py_SIZE(self);
|
2011-11-06 10:10:48 -04:00
|
|
|
PyObject *v;
|
2010-05-09 12:52:27 -03:00
|
|
|
|
2011-11-06 15:02:39 -04:00
|
|
|
if (!PyArg_ParseTuple(args, "O|O&O&:index", &v,
|
2017-03-30 13:46:59 -03:00
|
|
|
_PyEval_SliceIndexNotNone, &start,
|
|
|
|
_PyEval_SliceIndexNotNone, &stop))
|
2010-05-09 12:52:27 -03:00
|
|
|
return NULL;
|
|
|
|
if (start < 0) {
|
|
|
|
start += Py_SIZE(self);
|
|
|
|
if (start < 0)
|
|
|
|
start = 0;
|
|
|
|
}
|
|
|
|
if (stop < 0) {
|
|
|
|
stop += Py_SIZE(self);
|
|
|
|
if (stop < 0)
|
|
|
|
stop = 0;
|
|
|
|
}
|
|
|
|
for (i = start; i < stop && i < Py_SIZE(self); i++) {
|
|
|
|
int cmp = PyObject_RichCompareBool(self->ob_item[i], v, Py_EQ);
|
|
|
|
if (cmp > 0)
|
|
|
|
return PyLong_FromSsize_t(i);
|
|
|
|
else if (cmp < 0)
|
|
|
|
return NULL;
|
|
|
|
}
|
2011-11-06 10:10:48 -04:00
|
|
|
PyErr_Format(PyExc_ValueError, "%R is not in list", v);
|
2010-05-09 12:52:27 -03:00
|
|
|
return NULL;
|
1991-03-06 09:07:53 -04:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2001-08-16 10:15:00 -03:00
|
|
|
listcount(PyListObject *self, PyObject *v)
|
1991-10-20 17:20:40 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_ssize_t count = 0;
|
|
|
|
Py_ssize_t i;
|
2000-02-24 11:23:03 -04:00
|
|
|
|
2010-05-09 12:52:27 -03:00
|
|
|
for (i = 0; i < Py_SIZE(self); i++) {
|
|
|
|
int cmp = PyObject_RichCompareBool(self->ob_item[i], v, Py_EQ);
|
|
|
|
if (cmp > 0)
|
|
|
|
count++;
|
|
|
|
else if (cmp < 0)
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return PyLong_FromSsize_t(count);
|
1991-10-20 17:20:40 -03:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2001-08-16 10:15:00 -03:00
|
|
|
listremove(PyListObject *self, PyObject *v)
|
1991-03-06 09:07:53 -04:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_ssize_t i;
|
2000-02-24 11:23:03 -04:00
|
|
|
|
2010-05-09 12:52:27 -03:00
|
|
|
for (i = 0; i < Py_SIZE(self); i++) {
|
|
|
|
int cmp = PyObject_RichCompareBool(self->ob_item[i], v, Py_EQ);
|
|
|
|
if (cmp > 0) {
|
|
|
|
if (list_ass_slice(self, i, i+1,
|
|
|
|
(PyObject *)NULL) == 0)
|
|
|
|
Py_RETURN_NONE;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
else if (cmp < 0)
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
PyErr_SetString(PyExc_ValueError, "list.remove(x): x not in list");
|
|
|
|
return NULL;
|
1991-03-06 09:07:53 -04:00
|
|
|
}
|
|
|
|
|
2000-06-23 11:18:11 -03:00
|
|
|
static int
|
|
|
|
list_traverse(PyListObject *o, visitproc visit, void *arg)
|
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_ssize_t i;
|
2006-04-21 07:40:58 -03:00
|
|
|
|
2010-05-09 12:52:27 -03:00
|
|
|
for (i = Py_SIZE(o); --i >= 0; )
|
|
|
|
Py_VISIT(o->ob_item[i]);
|
|
|
|
return 0;
|
2000-06-23 11:18:11 -03:00
|
|
|
}
|
|
|
|
|
2001-01-17 18:11:59 -04:00
|
|
|
static PyObject *
|
|
|
|
list_richcompare(PyObject *v, PyObject *w, int op)
|
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
PyListObject *vl, *wl;
|
|
|
|
Py_ssize_t i;
|
|
|
|
|
2011-08-10 22:28:54 -03:00
|
|
|
if (!PyList_Check(v) || !PyList_Check(w))
|
|
|
|
Py_RETURN_NOTIMPLEMENTED;
|
2010-05-09 12:52:27 -03:00
|
|
|
|
|
|
|
vl = (PyListObject *)v;
|
|
|
|
wl = (PyListObject *)w;
|
|
|
|
|
|
|
|
if (Py_SIZE(vl) != Py_SIZE(wl) && (op == Py_EQ || op == Py_NE)) {
|
|
|
|
/* Shortcut: if the lengths differ, the lists differ */
|
|
|
|
PyObject *res;
|
|
|
|
if (op == Py_EQ)
|
|
|
|
res = Py_False;
|
|
|
|
else
|
|
|
|
res = Py_True;
|
|
|
|
Py_INCREF(res);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Search for the first index where items are different */
|
|
|
|
for (i = 0; i < Py_SIZE(vl) && i < Py_SIZE(wl); i++) {
|
|
|
|
int k = PyObject_RichCompareBool(vl->ob_item[i],
|
|
|
|
wl->ob_item[i], Py_EQ);
|
|
|
|
if (k < 0)
|
|
|
|
return NULL;
|
|
|
|
if (!k)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (i >= Py_SIZE(vl) || i >= Py_SIZE(wl)) {
|
|
|
|
/* No more items to compare -- compare sizes */
|
|
|
|
Py_ssize_t vs = Py_SIZE(vl);
|
|
|
|
Py_ssize_t ws = Py_SIZE(wl);
|
|
|
|
int cmp;
|
|
|
|
PyObject *res;
|
|
|
|
switch (op) {
|
|
|
|
case Py_LT: cmp = vs < ws; break;
|
|
|
|
case Py_LE: cmp = vs <= ws; break;
|
|
|
|
case Py_EQ: cmp = vs == ws; break;
|
|
|
|
case Py_NE: cmp = vs != ws; break;
|
|
|
|
case Py_GT: cmp = vs > ws; break;
|
|
|
|
case Py_GE: cmp = vs >= ws; break;
|
|
|
|
default: return NULL; /* cannot happen */
|
|
|
|
}
|
|
|
|
if (cmp)
|
|
|
|
res = Py_True;
|
|
|
|
else
|
|
|
|
res = Py_False;
|
|
|
|
Py_INCREF(res);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We have an item that differs -- shortcuts for EQ/NE */
|
|
|
|
if (op == Py_EQ) {
|
|
|
|
Py_INCREF(Py_False);
|
|
|
|
return Py_False;
|
|
|
|
}
|
|
|
|
if (op == Py_NE) {
|
|
|
|
Py_INCREF(Py_True);
|
|
|
|
return Py_True;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Compare the final item again using the proper operator */
|
|
|
|
return PyObject_RichCompare(vl->ob_item[i], wl->ob_item[i], op);
|
2001-01-17 18:11:59 -04:00
|
|
|
}
|
|
|
|
|
2001-08-02 01:15:00 -03:00
|
|
|
static int
|
|
|
|
list_init(PyListObject *self, PyObject *args, PyObject *kw)
|
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
PyObject *arg = NULL;
|
|
|
|
static char *kwlist[] = {"sequence", 0};
|
2001-08-02 01:15:00 -03:00
|
|
|
|
2010-05-09 12:52:27 -03:00
|
|
|
if (!PyArg_ParseTupleAndKeywords(args, kw, "|O:list", kwlist, &arg))
|
|
|
|
return -1;
|
2004-07-29 20:31:29 -03:00
|
|
|
|
2010-05-09 12:52:27 -03:00
|
|
|
/* Verify list invariants established by PyType_GenericAlloc() */
|
|
|
|
assert(0 <= Py_SIZE(self));
|
|
|
|
assert(Py_SIZE(self) <= self->allocated || self->allocated == -1);
|
|
|
|
assert(self->ob_item != NULL ||
|
|
|
|
self->allocated == 0 || self->allocated == -1);
|
2004-07-29 20:31:29 -03:00
|
|
|
|
2010-05-09 12:52:27 -03:00
|
|
|
/* Empty previous contents */
|
|
|
|
if (self->ob_item != NULL) {
|
|
|
|
(void)list_clear(self);
|
|
|
|
}
|
|
|
|
if (arg != NULL) {
|
|
|
|
PyObject *rv = listextend(self, arg);
|
|
|
|
if (rv == NULL)
|
|
|
|
return -1;
|
|
|
|
Py_DECREF(rv);
|
|
|
|
}
|
|
|
|
return 0;
|
2001-08-02 01:15:00 -03:00
|
|
|
}
|
|
|
|
|
2008-06-04 11:18:43 -03:00
|
|
|
static PyObject *
|
|
|
|
list_sizeof(PyListObject *self)
|
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_ssize_t res;
|
2008-06-04 11:18:43 -03:00
|
|
|
|
2015-12-19 14:05:25 -04:00
|
|
|
res = _PyObject_SIZE(Py_TYPE(self)) + self->allocated * sizeof(void*);
|
2010-05-09 12:52:27 -03:00
|
|
|
return PyLong_FromSsize_t(res);
|
2008-06-04 11:18:43 -03:00
|
|
|
}
|
|
|
|
|
2003-11-07 11:38:09 -04:00
|
|
|
static PyObject *list_iter(PyObject *seq);
|
|
|
|
static PyObject *list_reversed(PyListObject* seq, PyObject* unused);
|
|
|
|
|
2003-12-13 07:26:12 -04:00
|
|
|
PyDoc_STRVAR(getitem_doc,
|
|
|
|
"x.__getitem__(y) <==> x[y]");
|
2003-11-07 11:38:09 -04:00
|
|
|
PyDoc_STRVAR(reversed_doc,
|
|
|
|
"L.__reversed__() -- return a reverse iterator over the list");
|
2008-06-04 11:18:43 -03:00
|
|
|
PyDoc_STRVAR(sizeof_doc,
|
|
|
|
"L.__sizeof__() -- size of L in memory, in bytes");
|
2011-02-25 01:47:53 -04:00
|
|
|
PyDoc_STRVAR(clear_doc,
|
|
|
|
"L.clear() -> None -- remove all items from L");
|
|
|
|
PyDoc_STRVAR(copy_doc,
|
|
|
|
"L.copy() -> list -- a shallow copy of L");
|
2002-06-13 17:33:02 -03:00
|
|
|
PyDoc_STRVAR(append_doc,
|
2011-10-08 13:32:40 -03:00
|
|
|
"L.append(object) -> None -- append object to end");
|
2002-06-13 17:33:02 -03:00
|
|
|
PyDoc_STRVAR(extend_doc,
|
2011-10-08 13:32:40 -03:00
|
|
|
"L.extend(iterable) -> None -- extend list by appending elements from the iterable");
|
2002-06-13 17:33:02 -03:00
|
|
|
PyDoc_STRVAR(insert_doc,
|
|
|
|
"L.insert(index, object) -- insert object before index");
|
|
|
|
PyDoc_STRVAR(pop_doc,
|
2008-10-10 21:49:57 -03:00
|
|
|
"L.pop([index]) -> item -- remove and return item at index (default last).\n"
|
|
|
|
"Raises IndexError if list is empty or index is out of range.");
|
2002-06-13 17:33:02 -03:00
|
|
|
PyDoc_STRVAR(remove_doc,
|
2011-10-08 13:32:40 -03:00
|
|
|
"L.remove(value) -> None -- remove first occurrence of value.\n"
|
2008-10-10 21:49:57 -03:00
|
|
|
"Raises ValueError if the value is not present.");
|
2002-06-13 17:33:02 -03:00
|
|
|
PyDoc_STRVAR(index_doc,
|
2008-10-10 21:49:57 -03:00
|
|
|
"L.index(value, [start, [stop]]) -> integer -- return first index of value.\n"
|
|
|
|
"Raises ValueError if the value is not present.");
|
2002-06-13 17:33:02 -03:00
|
|
|
PyDoc_STRVAR(count_doc,
|
|
|
|
"L.count(value) -> integer -- return number of occurrences of value");
|
|
|
|
PyDoc_STRVAR(reverse_doc,
|
|
|
|
"L.reverse() -- reverse *IN PLACE*");
|
|
|
|
PyDoc_STRVAR(sort_doc,
|
2011-10-08 13:32:40 -03:00
|
|
|
"L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*");
|
1998-06-30 12:36:32 -03:00
|
|
|
|
2003-12-13 07:26:12 -04:00
|
|
|
static PyObject *list_subscript(PyListObject*, PyObject*);
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyMethodDef list_methods[] = {
|
2010-05-09 12:52:27 -03:00
|
|
|
{"__getitem__", (PyCFunction)list_subscript, METH_O|METH_COEXIST, getitem_doc},
|
|
|
|
{"__reversed__",(PyCFunction)list_reversed, METH_NOARGS, reversed_doc},
|
|
|
|
{"__sizeof__", (PyCFunction)list_sizeof, METH_NOARGS, sizeof_doc},
|
2011-02-25 01:47:53 -04:00
|
|
|
{"clear", (PyCFunction)listclear, METH_NOARGS, clear_doc},
|
|
|
|
{"copy", (PyCFunction)listcopy, METH_NOARGS, copy_doc},
|
2010-05-09 12:52:27 -03:00
|
|
|
{"append", (PyCFunction)listappend, METH_O, append_doc},
|
|
|
|
{"insert", (PyCFunction)listinsert, METH_VARARGS, insert_doc},
|
2011-02-25 01:47:53 -04:00
|
|
|
{"extend", (PyCFunction)listextend, METH_O, extend_doc},
|
2010-05-09 12:52:27 -03:00
|
|
|
{"pop", (PyCFunction)listpop, METH_VARARGS, pop_doc},
|
|
|
|
{"remove", (PyCFunction)listremove, METH_O, remove_doc},
|
|
|
|
{"index", (PyCFunction)listindex, METH_VARARGS, index_doc},
|
|
|
|
{"count", (PyCFunction)listcount, METH_O, count_doc},
|
|
|
|
{"reverse", (PyCFunction)listreverse, METH_NOARGS, reverse_doc},
|
|
|
|
{"sort", (PyCFunction)listsort, METH_VARARGS | METH_KEYWORDS, sort_doc},
|
|
|
|
{NULL, NULL} /* sentinel */
|
1990-10-14 09:07:46 -03:00
|
|
|
};
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PySequenceMethods list_as_sequence = {
|
2010-05-09 12:52:27 -03:00
|
|
|
(lenfunc)list_length, /* sq_length */
|
|
|
|
(binaryfunc)list_concat, /* sq_concat */
|
|
|
|
(ssizeargfunc)list_repeat, /* sq_repeat */
|
|
|
|
(ssizeargfunc)list_item, /* sq_item */
|
|
|
|
0, /* sq_slice */
|
|
|
|
(ssizeobjargproc)list_ass_item, /* sq_ass_item */
|
|
|
|
0, /* sq_ass_slice */
|
|
|
|
(objobjproc)list_contains, /* sq_contains */
|
|
|
|
(binaryfunc)list_inplace_concat, /* sq_inplace_concat */
|
|
|
|
(ssizeargfunc)list_inplace_repeat, /* sq_inplace_repeat */
|
1990-10-14 09:07:46 -03:00
|
|
|
};
|
|
|
|
|
2002-06-13 23:04:18 -03:00
|
|
|
PyDoc_STRVAR(list_doc,
|
2010-03-01 00:08:34 -04:00
|
|
|
"list() -> new empty list\n"
|
|
|
|
"list(iterable) -> new list initialized from iterable's items");
|
2001-08-02 01:15:00 -03:00
|
|
|
|
2002-07-13 00:51:17 -03:00
|
|
|
static PyObject *
|
2002-06-11 07:55:12 -03:00
|
|
|
list_subscript(PyListObject* self, PyObject* item)
|
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
if (PyIndex_Check(item)) {
|
|
|
|
Py_ssize_t i;
|
|
|
|
i = PyNumber_AsSsize_t(item, PyExc_IndexError);
|
|
|
|
if (i == -1 && PyErr_Occurred())
|
|
|
|
return NULL;
|
|
|
|
if (i < 0)
|
|
|
|
i += PyList_GET_SIZE(self);
|
|
|
|
return list_item(self, i);
|
|
|
|
}
|
|
|
|
else if (PySlice_Check(item)) {
|
|
|
|
Py_ssize_t start, stop, step, slicelength, cur, i;
|
|
|
|
PyObject* result;
|
|
|
|
PyObject* it;
|
|
|
|
PyObject **src, **dest;
|
|
|
|
|
2017-04-08 05:18:14 -03:00
|
|
|
if (PySlice_Unpack(item, &start, &stop, &step) < 0) {
|
2010-05-09 12:52:27 -03:00
|
|
|
return NULL;
|
|
|
|
}
|
2017-04-08 05:18:14 -03:00
|
|
|
slicelength = PySlice_AdjustIndices(Py_SIZE(self), &start, &stop,
|
|
|
|
step);
|
2010-05-09 12:52:27 -03:00
|
|
|
|
|
|
|
if (slicelength <= 0) {
|
|
|
|
return PyList_New(0);
|
|
|
|
}
|
|
|
|
else if (step == 1) {
|
|
|
|
return list_slice(self, start, stop);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
result = PyList_New(slicelength);
|
|
|
|
if (!result) return NULL;
|
|
|
|
|
|
|
|
src = self->ob_item;
|
|
|
|
dest = ((PyListObject *)result)->ob_item;
|
|
|
|
for (cur = start, i = 0; i < slicelength;
|
2011-09-25 11:34:32 -03:00
|
|
|
cur += (size_t)step, i++) {
|
2010-05-09 12:52:27 -03:00
|
|
|
it = src[cur];
|
|
|
|
Py_INCREF(it);
|
|
|
|
dest[i] = it;
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
PyErr_Format(PyExc_TypeError,
|
2014-08-02 02:30:37 -03:00
|
|
|
"list indices must be integers or slices, not %.200s",
|
2010-05-09 12:52:27 -03:00
|
|
|
item->ob_type->tp_name);
|
|
|
|
return NULL;
|
|
|
|
}
|
2002-06-11 07:55:12 -03:00
|
|
|
}
|
|
|
|
|
2002-07-18 23:35:45 -03:00
|
|
|
static int
|
2002-06-11 07:55:12 -03:00
|
|
|
list_ass_subscript(PyListObject* self, PyObject* item, PyObject* value)
|
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
if (PyIndex_Check(item)) {
|
|
|
|
Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
|
|
|
|
if (i == -1 && PyErr_Occurred())
|
|
|
|
return -1;
|
|
|
|
if (i < 0)
|
|
|
|
i += PyList_GET_SIZE(self);
|
|
|
|
return list_ass_item(self, i, value);
|
|
|
|
}
|
|
|
|
else if (PySlice_Check(item)) {
|
|
|
|
Py_ssize_t start, stop, step, slicelength;
|
|
|
|
|
2017-04-08 05:18:14 -03:00
|
|
|
if (PySlice_Unpack(item, &start, &stop, &step) < 0) {
|
2010-05-09 12:52:27 -03:00
|
|
|
return -1;
|
|
|
|
}
|
2017-04-08 05:18:14 -03:00
|
|
|
slicelength = PySlice_AdjustIndices(Py_SIZE(self), &start, &stop,
|
|
|
|
step);
|
2010-05-09 12:52:27 -03:00
|
|
|
|
|
|
|
if (step == 1)
|
|
|
|
return list_ass_slice(self, start, stop, value);
|
|
|
|
|
|
|
|
/* Make sure s[5:2] = [..] inserts at the right place:
|
|
|
|
before 5, not before 2. */
|
|
|
|
if ((step < 0 && start < stop) ||
|
|
|
|
(step > 0 && start > stop))
|
|
|
|
stop = start;
|
|
|
|
|
|
|
|
if (value == NULL) {
|
|
|
|
/* delete slice */
|
|
|
|
PyObject **garbage;
|
|
|
|
size_t cur;
|
|
|
|
Py_ssize_t i;
|
2013-11-21 07:16:35 -04:00
|
|
|
int res;
|
2010-05-09 12:52:27 -03:00
|
|
|
|
|
|
|
if (slicelength <= 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (step < 0) {
|
|
|
|
stop = start + 1;
|
|
|
|
start = stop + step*(slicelength - 1) - 1;
|
|
|
|
step = -step;
|
|
|
|
}
|
|
|
|
|
|
|
|
garbage = (PyObject**)
|
|
|
|
PyMem_MALLOC(slicelength*sizeof(PyObject*));
|
|
|
|
if (!garbage) {
|
|
|
|
PyErr_NoMemory();
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* drawing pictures might help understand these for
|
|
|
|
loops. Basically, we memmove the parts of the
|
|
|
|
list that are *not* part of the slice: step-1
|
|
|
|
items for each item that is part of the slice,
|
|
|
|
and then tail end of the list that was not
|
|
|
|
covered by the slice */
|
|
|
|
for (cur = start, i = 0;
|
|
|
|
cur < (size_t)stop;
|
|
|
|
cur += step, i++) {
|
|
|
|
Py_ssize_t lim = step - 1;
|
|
|
|
|
|
|
|
garbage[i] = PyList_GET_ITEM(self, cur);
|
|
|
|
|
|
|
|
if (cur + step >= (size_t)Py_SIZE(self)) {
|
|
|
|
lim = Py_SIZE(self) - cur - 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
memmove(self->ob_item + cur - i,
|
|
|
|
self->ob_item + cur + 1,
|
|
|
|
lim * sizeof(PyObject *));
|
|
|
|
}
|
2011-09-25 11:34:32 -03:00
|
|
|
cur = start + (size_t)slicelength * step;
|
2010-05-09 12:52:27 -03:00
|
|
|
if (cur < (size_t)Py_SIZE(self)) {
|
|
|
|
memmove(self->ob_item + cur - slicelength,
|
|
|
|
self->ob_item + cur,
|
|
|
|
(Py_SIZE(self) - cur) *
|
|
|
|
sizeof(PyObject *));
|
|
|
|
}
|
|
|
|
|
|
|
|
Py_SIZE(self) -= slicelength;
|
2013-11-21 07:16:35 -04:00
|
|
|
res = list_resize(self, Py_SIZE(self));
|
2010-05-09 12:52:27 -03:00
|
|
|
|
|
|
|
for (i = 0; i < slicelength; i++) {
|
|
|
|
Py_DECREF(garbage[i]);
|
|
|
|
}
|
|
|
|
PyMem_FREE(garbage);
|
|
|
|
|
2013-11-21 07:16:35 -04:00
|
|
|
return res;
|
2010-05-09 12:52:27 -03:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* assign slice */
|
|
|
|
PyObject *ins, *seq;
|
|
|
|
PyObject **garbage, **seqitems, **selfitems;
|
|
|
|
Py_ssize_t cur, i;
|
|
|
|
|
|
|
|
/* protect against a[::-1] = a */
|
|
|
|
if (self == (PyListObject*)value) {
|
|
|
|
seq = list_slice((PyListObject*)value, 0,
|
|
|
|
PyList_GET_SIZE(value));
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
seq = PySequence_Fast(value,
|
|
|
|
"must assign iterable "
|
|
|
|
"to extended slice");
|
|
|
|
}
|
|
|
|
if (!seq)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (PySequence_Fast_GET_SIZE(seq) != slicelength) {
|
|
|
|
PyErr_Format(PyExc_ValueError,
|
|
|
|
"attempt to assign sequence of "
|
|
|
|
"size %zd to extended slice of "
|
|
|
|
"size %zd",
|
|
|
|
PySequence_Fast_GET_SIZE(seq),
|
|
|
|
slicelength);
|
|
|
|
Py_DECREF(seq);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!slicelength) {
|
|
|
|
Py_DECREF(seq);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
garbage = (PyObject**)
|
|
|
|
PyMem_MALLOC(slicelength*sizeof(PyObject*));
|
|
|
|
if (!garbage) {
|
|
|
|
Py_DECREF(seq);
|
|
|
|
PyErr_NoMemory();
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
selfitems = self->ob_item;
|
|
|
|
seqitems = PySequence_Fast_ITEMS(seq);
|
|
|
|
for (cur = start, i = 0; i < slicelength;
|
2011-09-25 11:34:32 -03:00
|
|
|
cur += (size_t)step, i++) {
|
2010-05-09 12:52:27 -03:00
|
|
|
garbage[i] = selfitems[cur];
|
|
|
|
ins = seqitems[i];
|
|
|
|
Py_INCREF(ins);
|
|
|
|
selfitems[cur] = ins;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < slicelength; i++) {
|
|
|
|
Py_DECREF(garbage[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
PyMem_FREE(garbage);
|
|
|
|
Py_DECREF(seq);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
PyErr_Format(PyExc_TypeError,
|
2014-08-02 02:30:37 -03:00
|
|
|
"list indices must be integers or slices, not %.200s",
|
2010-05-09 12:52:27 -03:00
|
|
|
item->ob_type->tp_name);
|
|
|
|
return -1;
|
|
|
|
}
|
2002-06-11 07:55:12 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
static PyMappingMethods list_as_mapping = {
|
2010-05-09 12:52:27 -03:00
|
|
|
(lenfunc)list_length,
|
|
|
|
(binaryfunc)list_subscript,
|
|
|
|
(objobjargproc)list_ass_subscript
|
2002-06-11 07:55:12 -03:00
|
|
|
};
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
PyTypeObject PyList_Type = {
|
2010-05-09 12:52:27 -03:00
|
|
|
PyVarObject_HEAD_INIT(&PyType_Type, 0)
|
|
|
|
"list",
|
|
|
|
sizeof(PyListObject),
|
|
|
|
0,
|
|
|
|
(destructor)list_dealloc, /* tp_dealloc */
|
|
|
|
0, /* tp_print */
|
|
|
|
0, /* tp_getattr */
|
|
|
|
0, /* tp_setattr */
|
|
|
|
0, /* tp_reserved */
|
|
|
|
(reprfunc)list_repr, /* tp_repr */
|
|
|
|
0, /* tp_as_number */
|
|
|
|
&list_as_sequence, /* tp_as_sequence */
|
|
|
|
&list_as_mapping, /* tp_as_mapping */
|
2010-10-18 04:32:48 -03:00
|
|
|
PyObject_HashNotImplemented, /* tp_hash */
|
2010-05-09 12:52:27 -03:00
|
|
|
0, /* tp_call */
|
|
|
|
0, /* tp_str */
|
|
|
|
PyObject_GenericGetAttr, /* tp_getattro */
|
|
|
|
0, /* tp_setattro */
|
|
|
|
0, /* tp_as_buffer */
|
|
|
|
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
|
|
|
|
Py_TPFLAGS_BASETYPE | Py_TPFLAGS_LIST_SUBCLASS, /* tp_flags */
|
|
|
|
list_doc, /* tp_doc */
|
|
|
|
(traverseproc)list_traverse, /* tp_traverse */
|
|
|
|
(inquiry)list_clear, /* tp_clear */
|
|
|
|
list_richcompare, /* tp_richcompare */
|
|
|
|
0, /* tp_weaklistoffset */
|
|
|
|
list_iter, /* tp_iter */
|
|
|
|
0, /* tp_iternext */
|
|
|
|
list_methods, /* tp_methods */
|
|
|
|
0, /* tp_members */
|
|
|
|
0, /* tp_getset */
|
|
|
|
0, /* tp_base */
|
|
|
|
0, /* tp_dict */
|
|
|
|
0, /* tp_descr_get */
|
|
|
|
0, /* tp_descr_set */
|
|
|
|
0, /* tp_dictoffset */
|
|
|
|
(initproc)list_init, /* tp_init */
|
|
|
|
PyType_GenericAlloc, /* tp_alloc */
|
|
|
|
PyType_GenericNew, /* tp_new */
|
|
|
|
PyObject_GC_Del, /* tp_free */
|
1990-10-14 09:07:46 -03:00
|
|
|
};
|
1998-06-16 12:18:28 -03:00
|
|
|
|
|
|
|
|
2002-05-31 18:40:38 -03:00
|
|
|
/*********************** List Iterator **************************/
|
|
|
|
|
|
|
|
typedef struct {
|
2010-05-09 12:52:27 -03:00
|
|
|
PyObject_HEAD
|
2013-06-24 18:59:24 -03:00
|
|
|
Py_ssize_t it_index;
|
2010-05-09 12:52:27 -03:00
|
|
|
PyListObject *it_seq; /* Set to NULL when iterator is exhausted */
|
2002-05-31 18:40:38 -03:00
|
|
|
} listiterobject;
|
|
|
|
|
2006-04-21 07:40:58 -03:00
|
|
|
static PyObject *list_iter(PyObject *);
|
|
|
|
static void listiter_dealloc(listiterobject *);
|
|
|
|
static int listiter_traverse(listiterobject *, visitproc, void *);
|
|
|
|
static PyObject *listiter_next(listiterobject *);
|
|
|
|
static PyObject *listiter_len(listiterobject *);
|
2012-04-03 07:49:41 -03:00
|
|
|
static PyObject *listiter_reduce_general(void *_it, int forward);
|
|
|
|
static PyObject *listiter_reduce(listiterobject *);
|
|
|
|
static PyObject *listiter_setstate(listiterobject *, PyObject *state);
|
2006-04-21 07:40:58 -03:00
|
|
|
|
|
|
|
PyDoc_STRVAR(length_hint_doc, "Private method returning an estimate of len(list(it)).");
|
2012-04-03 07:49:41 -03:00
|
|
|
PyDoc_STRVAR(reduce_doc, "Return state information for pickling.");
|
|
|
|
PyDoc_STRVAR(setstate_doc, "Set state information for unpickling.");
|
2006-04-21 07:40:58 -03:00
|
|
|
|
|
|
|
static PyMethodDef listiter_methods[] = {
|
2010-05-09 12:52:27 -03:00
|
|
|
{"__length_hint__", (PyCFunction)listiter_len, METH_NOARGS, length_hint_doc},
|
2012-04-03 07:49:41 -03:00
|
|
|
{"__reduce__", (PyCFunction)listiter_reduce, METH_NOARGS, reduce_doc},
|
|
|
|
{"__setstate__", (PyCFunction)listiter_setstate, METH_O, setstate_doc},
|
2010-05-09 12:52:27 -03:00
|
|
|
{NULL, NULL} /* sentinel */
|
2006-04-21 07:40:58 -03:00
|
|
|
};
|
|
|
|
|
|
|
|
PyTypeObject PyListIter_Type = {
|
2010-05-09 12:52:27 -03:00
|
|
|
PyVarObject_HEAD_INIT(&PyType_Type, 0)
|
|
|
|
"list_iterator", /* tp_name */
|
|
|
|
sizeof(listiterobject), /* tp_basicsize */
|
|
|
|
0, /* tp_itemsize */
|
|
|
|
/* methods */
|
|
|
|
(destructor)listiter_dealloc, /* tp_dealloc */
|
|
|
|
0, /* tp_print */
|
|
|
|
0, /* tp_getattr */
|
|
|
|
0, /* tp_setattr */
|
|
|
|
0, /* tp_reserved */
|
|
|
|
0, /* tp_repr */
|
|
|
|
0, /* tp_as_number */
|
|
|
|
0, /* tp_as_sequence */
|
|
|
|
0, /* tp_as_mapping */
|
|
|
|
0, /* tp_hash */
|
|
|
|
0, /* tp_call */
|
|
|
|
0, /* tp_str */
|
|
|
|
PyObject_GenericGetAttr, /* tp_getattro */
|
|
|
|
0, /* tp_setattro */
|
|
|
|
0, /* tp_as_buffer */
|
|
|
|
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
|
|
|
|
0, /* tp_doc */
|
|
|
|
(traverseproc)listiter_traverse, /* tp_traverse */
|
|
|
|
0, /* tp_clear */
|
|
|
|
0, /* tp_richcompare */
|
|
|
|
0, /* tp_weaklistoffset */
|
|
|
|
PyObject_SelfIter, /* tp_iter */
|
|
|
|
(iternextfunc)listiter_next, /* tp_iternext */
|
|
|
|
listiter_methods, /* tp_methods */
|
|
|
|
0, /* tp_members */
|
2006-04-21 07:40:58 -03:00
|
|
|
};
|
|
|
|
|
2002-05-31 18:40:38 -03:00
|
|
|
|
2002-07-16 12:56:52 -03:00
|
|
|
static PyObject *
|
2002-05-31 18:40:38 -03:00
|
|
|
list_iter(PyObject *seq)
|
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
listiterobject *it;
|
2002-07-16 17:10:23 -03:00
|
|
|
|
2010-05-09 12:52:27 -03:00
|
|
|
if (!PyList_Check(seq)) {
|
|
|
|
PyErr_BadInternalCall();
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
it = PyObject_GC_New(listiterobject, &PyListIter_Type);
|
|
|
|
if (it == NULL)
|
|
|
|
return NULL;
|
|
|
|
it->it_index = 0;
|
|
|
|
Py_INCREF(seq);
|
|
|
|
it->it_seq = (PyListObject *)seq;
|
|
|
|
_PyObject_GC_TRACK(it);
|
|
|
|
return (PyObject *)it;
|
2002-05-31 18:40:38 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
listiter_dealloc(listiterobject *it)
|
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
_PyObject_GC_UNTRACK(it);
|
|
|
|
Py_XDECREF(it->it_seq);
|
|
|
|
PyObject_GC_Del(it);
|
2002-05-31 18:40:38 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
listiter_traverse(listiterobject *it, visitproc visit, void *arg)
|
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_VISIT(it->it_seq);
|
|
|
|
return 0;
|
2002-05-31 18:40:38 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *
|
2002-06-01 02:22:55 -03:00
|
|
|
listiter_next(listiterobject *it)
|
2002-05-31 18:40:38 -03:00
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
PyListObject *seq;
|
|
|
|
PyObject *item;
|
2002-05-31 18:40:38 -03:00
|
|
|
|
2010-05-09 12:52:27 -03:00
|
|
|
assert(it != NULL);
|
|
|
|
seq = it->it_seq;
|
|
|
|
if (seq == NULL)
|
|
|
|
return NULL;
|
|
|
|
assert(PyList_Check(seq));
|
2002-05-31 18:40:38 -03:00
|
|
|
|
2010-05-09 12:52:27 -03:00
|
|
|
if (it->it_index < PyList_GET_SIZE(seq)) {
|
|
|
|
item = PyList_GET_ITEM(seq, it->it_index);
|
|
|
|
++it->it_index;
|
|
|
|
Py_INCREF(item);
|
|
|
|
return item;
|
|
|
|
}
|
2002-07-16 17:07:32 -03:00
|
|
|
|
2010-05-09 12:52:27 -03:00
|
|
|
it->it_seq = NULL;
|
Issue #26494: Fixed crash on iterating exhausting iterators.
Affected classes are generic sequence iterators, iterators of str, bytes,
bytearray, list, tuple, set, frozenset, dict, OrderedDict, corresponding
views and os.scandir() iterator.
2016-03-30 14:40:02 -03:00
|
|
|
Py_DECREF(seq);
|
2010-05-09 12:52:27 -03:00
|
|
|
return NULL;
|
2002-05-31 18:40:38 -03:00
|
|
|
}
|
|
|
|
|
2005-09-24 18:23:05 -03:00
|
|
|
static PyObject *
|
2004-03-18 18:43:10 -04:00
|
|
|
listiter_len(listiterobject *it)
|
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_ssize_t len;
|
|
|
|
if (it->it_seq) {
|
|
|
|
len = PyList_GET_SIZE(it->it_seq) - it->it_index;
|
|
|
|
if (len >= 0)
|
|
|
|
return PyLong_FromSsize_t(len);
|
|
|
|
}
|
|
|
|
return PyLong_FromLong(0);
|
2004-03-18 18:43:10 -04:00
|
|
|
}
|
2012-04-03 07:49:41 -03:00
|
|
|
|
|
|
|
static PyObject *
|
|
|
|
listiter_reduce(listiterobject *it)
|
|
|
|
{
|
|
|
|
return listiter_reduce_general(it, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *
|
|
|
|
listiter_setstate(listiterobject *it, PyObject *state)
|
|
|
|
{
|
2013-06-24 18:59:24 -03:00
|
|
|
Py_ssize_t index = PyLong_AsSsize_t(state);
|
2012-04-03 07:49:41 -03:00
|
|
|
if (index == -1 && PyErr_Occurred())
|
|
|
|
return NULL;
|
|
|
|
if (it->it_seq != NULL) {
|
|
|
|
if (index < 0)
|
|
|
|
index = 0;
|
2014-03-05 09:47:57 -04:00
|
|
|
else if (index > PyList_GET_SIZE(it->it_seq))
|
|
|
|
index = PyList_GET_SIZE(it->it_seq); /* iterator exhausted */
|
2012-04-03 07:49:41 -03:00
|
|
|
it->it_index = index;
|
|
|
|
}
|
|
|
|
Py_RETURN_NONE;
|
|
|
|
}
|
|
|
|
|
2006-04-21 07:40:58 -03:00
|
|
|
/*********************** List Reverse Iterator **************************/
|
2004-03-18 18:43:10 -04:00
|
|
|
|
2006-04-21 07:40:58 -03:00
|
|
|
typedef struct {
|
2010-05-09 12:52:27 -03:00
|
|
|
PyObject_HEAD
|
|
|
|
Py_ssize_t it_index;
|
|
|
|
PyListObject *it_seq; /* Set to NULL when iterator is exhausted */
|
2006-04-21 07:40:58 -03:00
|
|
|
} listreviterobject;
|
2005-09-24 18:23:05 -03:00
|
|
|
|
2006-04-21 07:40:58 -03:00
|
|
|
static PyObject *list_reversed(PyListObject *, PyObject *);
|
|
|
|
static void listreviter_dealloc(listreviterobject *);
|
|
|
|
static int listreviter_traverse(listreviterobject *, visitproc, void *);
|
|
|
|
static PyObject *listreviter_next(listreviterobject *);
|
2008-12-02 17:33:45 -04:00
|
|
|
static PyObject *listreviter_len(listreviterobject *);
|
2012-04-03 07:49:41 -03:00
|
|
|
static PyObject *listreviter_reduce(listreviterobject *);
|
|
|
|
static PyObject *listreviter_setstate(listreviterobject *, PyObject *);
|
2006-04-21 07:40:58 -03:00
|
|
|
|
2008-12-02 17:33:45 -04:00
|
|
|
static PyMethodDef listreviter_methods[] = {
|
2010-05-09 12:52:27 -03:00
|
|
|
{"__length_hint__", (PyCFunction)listreviter_len, METH_NOARGS, length_hint_doc},
|
2012-04-03 07:49:41 -03:00
|
|
|
{"__reduce__", (PyCFunction)listreviter_reduce, METH_NOARGS, reduce_doc},
|
|
|
|
{"__setstate__", (PyCFunction)listreviter_setstate, METH_O, setstate_doc},
|
2010-05-09 12:52:27 -03:00
|
|
|
{NULL, NULL} /* sentinel */
|
2004-03-18 18:43:10 -04:00
|
|
|
};
|
|
|
|
|
2006-04-21 07:40:58 -03:00
|
|
|
PyTypeObject PyListRevIter_Type = {
|
2010-05-09 12:52:27 -03:00
|
|
|
PyVarObject_HEAD_INIT(&PyType_Type, 0)
|
|
|
|
"list_reverseiterator", /* tp_name */
|
|
|
|
sizeof(listreviterobject), /* tp_basicsize */
|
|
|
|
0, /* tp_itemsize */
|
|
|
|
/* methods */
|
|
|
|
(destructor)listreviter_dealloc, /* tp_dealloc */
|
|
|
|
0, /* tp_print */
|
|
|
|
0, /* tp_getattr */
|
|
|
|
0, /* tp_setattr */
|
|
|
|
0, /* tp_reserved */
|
|
|
|
0, /* tp_repr */
|
|
|
|
0, /* tp_as_number */
|
|
|
|
0, /* tp_as_sequence */
|
|
|
|
0, /* tp_as_mapping */
|
|
|
|
0, /* tp_hash */
|
|
|
|
0, /* tp_call */
|
|
|
|
0, /* tp_str */
|
|
|
|
PyObject_GenericGetAttr, /* tp_getattro */
|
|
|
|
0, /* tp_setattro */
|
|
|
|
0, /* tp_as_buffer */
|
|
|
|
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
|
|
|
|
0, /* tp_doc */
|
|
|
|
(traverseproc)listreviter_traverse, /* tp_traverse */
|
|
|
|
0, /* tp_clear */
|
|
|
|
0, /* tp_richcompare */
|
|
|
|
0, /* tp_weaklistoffset */
|
|
|
|
PyObject_SelfIter, /* tp_iter */
|
|
|
|
(iternextfunc)listreviter_next, /* tp_iternext */
|
|
|
|
listreviter_methods, /* tp_methods */
|
|
|
|
0,
|
2002-05-31 18:40:38 -03:00
|
|
|
};
|
2003-11-07 11:38:09 -04:00
|
|
|
|
|
|
|
static PyObject *
|
|
|
|
list_reversed(PyListObject *seq, PyObject *unused)
|
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
listreviterobject *it;
|
2003-11-07 11:38:09 -04:00
|
|
|
|
2010-05-09 12:52:27 -03:00
|
|
|
it = PyObject_GC_New(listreviterobject, &PyListRevIter_Type);
|
|
|
|
if (it == NULL)
|
|
|
|
return NULL;
|
|
|
|
assert(PyList_Check(seq));
|
|
|
|
it->it_index = PyList_GET_SIZE(seq) - 1;
|
|
|
|
Py_INCREF(seq);
|
|
|
|
it->it_seq = seq;
|
|
|
|
PyObject_GC_Track(it);
|
|
|
|
return (PyObject *)it;
|
2003-11-07 11:38:09 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
listreviter_dealloc(listreviterobject *it)
|
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
PyObject_GC_UnTrack(it);
|
|
|
|
Py_XDECREF(it->it_seq);
|
|
|
|
PyObject_GC_Del(it);
|
2003-11-07 11:38:09 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
listreviter_traverse(listreviterobject *it, visitproc visit, void *arg)
|
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_VISIT(it->it_seq);
|
|
|
|
return 0;
|
2003-11-07 11:38:09 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *
|
|
|
|
listreviter_next(listreviterobject *it)
|
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
PyObject *item;
|
Issue #26494: Fixed crash on iterating exhausting iterators.
Affected classes are generic sequence iterators, iterators of str, bytes,
bytearray, list, tuple, set, frozenset, dict, OrderedDict, corresponding
views and os.scandir() iterator.
2016-03-30 14:40:02 -03:00
|
|
|
Py_ssize_t index;
|
|
|
|
PyListObject *seq;
|
|
|
|
|
|
|
|
assert(it != NULL);
|
|
|
|
seq = it->it_seq;
|
|
|
|
if (seq == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
assert(PyList_Check(seq));
|
2003-11-07 11:38:09 -04:00
|
|
|
|
Issue #26494: Fixed crash on iterating exhausting iterators.
Affected classes are generic sequence iterators, iterators of str, bytes,
bytearray, list, tuple, set, frozenset, dict, OrderedDict, corresponding
views and os.scandir() iterator.
2016-03-30 14:40:02 -03:00
|
|
|
index = it->it_index;
|
2010-05-09 12:52:27 -03:00
|
|
|
if (index>=0 && index < PyList_GET_SIZE(seq)) {
|
|
|
|
item = PyList_GET_ITEM(seq, index);
|
|
|
|
it->it_index--;
|
|
|
|
Py_INCREF(item);
|
|
|
|
return item;
|
|
|
|
}
|
|
|
|
it->it_index = -1;
|
Issue #26494: Fixed crash on iterating exhausting iterators.
Affected classes are generic sequence iterators, iterators of str, bytes,
bytearray, list, tuple, set, frozenset, dict, OrderedDict, corresponding
views and os.scandir() iterator.
2016-03-30 14:40:02 -03:00
|
|
|
it->it_seq = NULL;
|
|
|
|
Py_DECREF(seq);
|
2010-05-09 12:52:27 -03:00
|
|
|
return NULL;
|
2003-11-07 11:38:09 -04:00
|
|
|
}
|
|
|
|
|
2008-12-02 17:33:45 -04:00
|
|
|
static PyObject *
|
2004-03-10 06:10:42 -04:00
|
|
|
listreviter_len(listreviterobject *it)
|
|
|
|
{
|
2010-05-09 12:52:27 -03:00
|
|
|
Py_ssize_t len = it->it_index + 1;
|
|
|
|
if (it->it_seq == NULL || PyList_GET_SIZE(it->it_seq) < len)
|
|
|
|
len = 0;
|
|
|
|
return PyLong_FromSsize_t(len);
|
2004-03-10 06:10:42 -04:00
|
|
|
}
|
2012-04-03 07:49:41 -03:00
|
|
|
|
|
|
|
static PyObject *
|
|
|
|
listreviter_reduce(listreviterobject *it)
|
|
|
|
{
|
|
|
|
return listiter_reduce_general(it, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *
|
|
|
|
listreviter_setstate(listreviterobject *it, PyObject *state)
|
|
|
|
{
|
|
|
|
Py_ssize_t index = PyLong_AsSsize_t(state);
|
|
|
|
if (index == -1 && PyErr_Occurred())
|
|
|
|
return NULL;
|
|
|
|
if (it->it_seq != NULL) {
|
|
|
|
if (index < -1)
|
|
|
|
index = -1;
|
|
|
|
else if (index > PyList_GET_SIZE(it->it_seq) - 1)
|
|
|
|
index = PyList_GET_SIZE(it->it_seq) - 1;
|
|
|
|
it->it_index = index;
|
|
|
|
}
|
|
|
|
Py_RETURN_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* common pickling support */
|
|
|
|
|
|
|
|
static PyObject *
|
|
|
|
listiter_reduce_general(void *_it, int forward)
|
|
|
|
{
|
|
|
|
PyObject *list;
|
|
|
|
|
|
|
|
/* the objects are not the same, index is of different types! */
|
|
|
|
if (forward) {
|
|
|
|
listiterobject *it = (listiterobject *)_it;
|
|
|
|
if (it->it_seq)
|
2013-06-24 18:59:24 -03:00
|
|
|
return Py_BuildValue("N(O)n", _PyObject_GetBuiltin("iter"),
|
2012-04-03 07:49:41 -03:00
|
|
|
it->it_seq, it->it_index);
|
|
|
|
} else {
|
|
|
|
listreviterobject *it = (listreviterobject *)_it;
|
|
|
|
if (it->it_seq)
|
2012-04-04 19:04:20 -03:00
|
|
|
return Py_BuildValue("N(O)n", _PyObject_GetBuiltin("reversed"),
|
2012-04-03 07:49:41 -03:00
|
|
|
it->it_seq, it->it_index);
|
|
|
|
}
|
|
|
|
/* empty iterator, create an empty list */
|
|
|
|
list = PyList_New(0);
|
|
|
|
if (list == NULL)
|
|
|
|
return NULL;
|
2012-04-04 19:04:20 -03:00
|
|
|
return Py_BuildValue("N(N)", _PyObject_GetBuiltin("iter"), list);
|
2012-04-03 07:49:41 -03:00
|
|
|
}
|