Test for more edge strip cases; leading and trailing separator gets removed
even with strip(..., 0)

Eeked out another 3% or so performance in split whitespace by cleaning up the algorithm.

Enable PY_USE_INT_WHEN_POSSIBLE in struct

Fix _struct typo that broke some 64-bit platforms

Fix distutils so that libffi will cross-compile between darwin/x86 and darwin/ppc

Typo fix

Add buffer support for struct, socket

Explicitly close files.  I'm trying to stop the frequent spurious test_tarfile
failures on Windows buildbots, but it's hard to know how since the regrtest
failure output is useless here, and it never fails when a buildbot slave runs
test_tarfile the second time in verbose mode.

Changes to string.split/rsplit on whitespace to preallocate space in the
results list.

Originally it allocated 0 items and used the list growth during append.  Now
it preallocates 12 items so the first few appends don't need list reallocs.

("Here are some words ."*2).split(None, 1) is 7% faster
("Here are some words ."*2).split() is is 15% faster

  (Your milage may vary, see dealership for details.)

File parsing like this

    for line in f:
        count += len(line.split())

is also about 15% faster.  There is a slowdown of about 3% for large
strings because of the additional overhead of checking if the append is
to a preallocated region of the list or not.  This will be the rare case.
It could be improved with special case code but we decided it was not
useful enough.

There is a cost of 12*sizeof(PyObject *) bytes per list.  For the normal
case of file parsing this is not a problem because of the lists have
a short lifetime.  We have not come up with cases where this is a problem
in real life.

I chose 12 because human text averages about 11 words per line in books,
one of my data sets averages 6.2 words with a final peak at 11 words per
line, and I work with a tab delimited data set with 8 tabs per line (or
9 words per line).  12 encompasses all of these.

Also changed the last rstrip code to append then reverse, rather than
doing insert(0).  The strip() and rstrip() times are now comparable.

Use open() to open files (was using file()).

fix #1229380 No struct.pack exception for some out of range integers

Added more rstrip tests, including for prealloc'ed arrays

quick hack to fix busted binhex test

Add str.partition()

Whitespace normalization.

Test cases for off-by-one errors in string split with multicharacter pattern.

I like tests.

The new split functions use a preallocated list.  Added tests which exceed
the preallocation size, to exercise list appends/resizes.

Also added more edge case tests.

Whitespace normalization.

- Remove previous version of the binary distribution script for OSX
- Some small bugfixes for the IDLE.app wrapper
- Tweaks to build-installer to ensure that python gets build in the right way,
  including sqlite3.
- Updated readme files

Support for buffer protocol for socket and struct.

* Added socket.recv_buf() and socket.recvfrom_buf() methods, that use the buffer
  protocol (send and sendto already did).

* Added struct.pack_to(), that is the corresponding buffer compatible method to
  unpack_from().

* Fixed minor typos in arraymodule.

Py_LOCAL shouldn't be used for data; it works for some .NET 2003 compilers,
but Trent's copy thinks that it's an anachronism...

Typo fixes

needforspeed: added PY_LOCAL_AGGRESSIVE macro to enable "aggressive"
LOCAL inlining; also added some missing whitespace

Integrate installing a framework in the 'make install'
target. Until now users had to use 'make frameworkinstall'
to install python when it is configured with '--enable-framework'.
This tends to confuse users that don't hunt for readme files
hidden in platform specific directories :-)

- Search the sqlite specific search directories
  after the normal include directories when looking
  for the version of sqlite to use.
- On OSX:
  * Extract additional include and link directories
    from the CFLAGS and LDFLAGS, if the user has
    bothered to specify them we might as wel use them.
  * Add '-Wl,-search_paths_first' to the extra_link_args
    for readline and sqlite. This makes it possible to
    use a static library to override the system provided
    dynamic library.

use Py_LOCAL also for string and unicode objects

when generating python code prefer to generate valid python code

needforspeed: added Py_LOCAL macro, based on the LOCAL macro used
for SRE and others.  applied Py_LOCAL to relevant portion of ceval,
which gives a 1-2% speedup on my machine.  ymmv.

Add "partition" to UserString.

Fix buglet in postinstall script, it would generate an invalid .cshrc file.

Added split whitespace checks for characters other than space.

use Py_ssize_t in places that may need it

Added a few more test cases for whitespace split.  These strings have leading whitespace.

needforspeed: use Py_ssize_t for the fastsearch counter and skip
length (thanks, neal!).  and yes, I've verified that this doesn't
slow things down ;-)

needforspeed: use METH_O for argument handling, which made partition some
~15% faster for the current tests (which is noticable faster than a corre-
sponding find call).  thanks to neal-who-never-sleeps for the tip.

Clarify docs for str.partition().

needforspeed: partition implementation, part two.

feel free to improve the documentation and the docstrings.

Without this patch OSX users couldn't add new help sources because the code
tried to update one item in a tuple.

Add Soc student

needforspeed: partition for 8-bit strings.  for some simple tests,
this is on par with a corresponding find, and nearly twice as fast
as split(sep, 1)

full tests, a unicode version, and documentation will follow to-
morrow.

Patch #1494387: SVN longobject.c compiler warnings

The SIGCHECK macro defined here has always been bizarre, but
it apparently causes compiler warnings on "Sun Studio 11".
I believe the warnings are bogus, but it doesn't hurt to make
the macro definition saner.

Bugfix candidate (but I'm not going to bother).

Repair idiot typo, and complete the job of trying to
use the Windows time.clock() implementation on Win64.

Move over to use of METH_O and METH_NOARGS.

Add missing files from x86 darwin ctypes patch

Whitespace normalization.

Some Win64 pre-release in 2000 didn't support
QueryPerformanceCounter(), but we believe Win64 does
support it now.  So use in time.clock().

It would be peachy if someone with a Win64 box tried
this ;-)

Change test_values so that it compares the lowercasing of group names since getgrall() can return all lowercase names while getgrgid() returns proper casing.

Discovered on Ubuntu 5.04 (custom).

Fix minor typo in prep_cif.c

Add a x-ref to newer calling APIs.

fix test_float regression and 64-bit size mismatch issue

squelch gcc4 darwin/x86 compiler warnings

Swap out bare malloc()/free() use for PyMem_MALLOC()/PyMem_FREE() .

Someone seems to just have copy-pasted the docs of
tp_compare to tp_richcompare ;)

enable darwin/x86 support for libffi and hence ctypes (doesn't yet support --enable-universalsdk)

Use faster struct pack/unpack functions for the endian table that matches the host's

Use LONG_MIN and LONG_MAX to check Python integer bounds instead of the incorrect INT_MIN and INT_MAX

needforspeed: use insert+reverse instead of append

Replace PyObject_CallFunction calls with only object args
with PyObject_CallFunctionObjArgs, which is 30% faster.

fix a struct regression where long would be returned for short unsigned integers

Fix Cygwin compiler issue

* eliminate warning by reverting tmp_s type to 'const char*'

Struct now unpacks to PY_LONG_LONG directly when possible, also include #ifdef'ed out code that will return int instead of long when in bounds (not active since it's an API and doc change)

needforspeed: use fastsearch also for find/index and contains.  the
related tests are now about 10x faster.

Guard the _active.remove() call to avoid errors when there is no _active list.

Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm

Added overflow test for adding two (very) large strings where the
new string is over max Py_ssize_t.  I have no way to test it on my
box or any box I have access to.  At least it doesn't break anything.

Comment typo

Code had returned an ssize_t, upcast to long, then converted with PyInt_FromLong.
Now using PyInt_FromSsize_t.

needforspeed: use "fastsearch" for count.  this results in a 3x speedup
for the related stringbench tests.

Fixed problem identified by Georg.  The special-case in-place code for replace
made a copy of the string using PyString_FromStringAndSize(s, n) and modify
the copied string in-place.  However, 1 (and 0) character strings are shared
from a cache.  This cause "A".replace("A", "a") to change the cached version
of "A" -- used by everyone.

Now may the copy with NULL as the string and do the memcpy manually.  I've
added regression tests to check if this happens in the future.  Perhaps
there should be a PyString_Copy for this case?

A new table to help string->integer conversion was added yesterday to
both mystrtoul.c and longobject.c.  Share the table instead.  Also
cut its size by 64 entries (they had been used for an inscrutable
trick originally, but the code no longer tries to use that trick).

needforspeed: new replace implementation by Andrew Dalke.  replace is
now about 3x faster on my machine, for the replace tests from string-
bench.

needforspeed: check for overflow in replace (from Andrew Dalke)

Fix incorrect documentation for the Py_IS_FINITE(X) macro.

Fix another typo

Added tests for implementation error we came up with in the need for speed sprint.

Fix comment typos

needforspeed: _toupper/_tolower is a SUSv2 thing; fall back on ISO C
versions if they're not defined.

Added a new macro, Py_IS_FINITE(X).  On windows there is an intrinsic for this and it is more efficient than to use !Py_IS_INFINITE(X) && !Py_IS_NAN(X).  No change on other platforms

needforspeed: make new upper/lower work properly for single-character
strings too... (thanks to georg brandl for spotting the exact problem
faster than anyone else)

needforspeed: speed up upper and lower for 8-bit string objects.
(the unicode versions of these are still 2x faster on windows,
though...)

based on work by Andrew Dalke, with tweaks by yours truly.

Add entry; and fix a typo

Update graminit.c for the fix for #1488915, Multiple dots in relative import
statement raise SyntaxError, and add testcase.

Fix #1488915, Multiple dots in relative import statement raise SyntaxError.

Replace tab inside comment with space.

fix broken links in PDF
(SF patch #1281291, contributed by Rory Yorke)

Minor edits; add an item

Heavily fiddled variant of patch #1442927: PyLong_FromString optimization.

``long(str, base)`` is now up to 6x faster for non-power-of-2 bases.  The
largest speedup is for inputs with about 1000 decimal digits.  Conversion
from non-power-of-2 bases remains quadratic-time in the number of input
digits (it was and remains linear-time for bases 2, 4, 8, 16 and 32).

Speedups at various lengths for decimal inputs, comparing 2.4.3 with
current trunk.  Note that it's actually a bit slower for 1-digit strings:

  len  speedup
 ----  -------
   1     -4.5%
   2      4.6%
   3      8.3%
   4     12.7%
   5     16.9%
   6     28.6%
   7     35.5%
   8     44.3%
   9     46.6%
  10     55.3%
  11     65.7%
  12     77.7%
  13     73.4%
  14     75.3%
  15     85.2%
  16    103.0%
  17     95.1%
  18    112.8%
  19    117.9%
  20    128.3%
  30    174.5%
  40    209.3%
  50    236.3%
  60    254.3%
  70    262.9%
  80    295.8%
  90    297.3%
 100    324.5%
 200    374.6%
 300    403.1%
 400    391.1%
 500    388.7%
 600    440.6%
 700    468.7%
 800    498.0%
 900    507.2%
1000    501.2%
2000    450.2%
3000    463.2%
4000    452.5%
5000    440.6%
6000    439.6%
7000    424.8%
8000    418.1%
9000    417.7%

Disable the damn empty-string replace test -- it can't
be make to pass now for unicode if it passes for str, or
vice versa.

Whitespace normalization.

We can't leave the checked-in tests broken.

Added a slew of test for string replace, based various corner cases from
the Need For Speed sprint coding.  Includes commented out overflow tests
which will be uncommented once the code is fixed.

This test will break the 8-bit string tests because
    "".replace("", "A") == "" when it should == "A"

We have a fix for it, which should be added tomorrow.

needforspeed: refactored the replace code slightly; special-case
constant-length changes; use fastsearch to locate the first match.

refactor unpack, add unpack_from

needforspeedindeed: use fastsearch also for __contains__

needforspeed: use "fastsearch" for count and findstring helpers.  this
results in a 2.5x speedup on the stringbench count tests, and a 20x (!)
speedup on the stringbench search/find/contains test, compared to 2.5a2.

for more on the algorithm, see:

    http://effbot.org/zone/stringlib.htm

if you get weird results, you can disable the new algoritm by undefining
USE_FAST in Objects/unicodeobject.c.

enjoy /F

use Py_ssize_t for string indexes (thanks, neal!)

Add missing svn:eol-style property to text files.

Whitespace normalization.

test_struct grew weird behavior under regrtest.py -R,
due to a module-level cache.  Clearing the cache should
make it stop showing up in refleak reports.