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.

return 0 on misses, not -1.

Get the Windows build working again (recover from
`struct` module changes).

Add item

fix typo in _struct

forward declaration for PyStructType

Add two items

fix linking issue, warnings, in struct

patch #1493701: performance enhancements for struct module

patch #1493701: performance enhancements for struct module

revert #1493701

Remove duplicate item

Patch #1493701: performance enhancements for struct module.

Bug #1334662 / patch #1335972:  int(string, base) wrong answers.

In rare cases of strings specifying true values near sys.maxint,
and oddball bases (not decimal or a power of 2), int(string, base)
could deliver insane answers.  This repairs all such problems, and
also speeds string->int significantly.  On my box, here are %
speedups for decimal strings of various lengths:

length speedup
------ -------
 1       12.4%
 2       15.7%
 3       20.6%
 4       28.1%
 5       33.2%
 6       37.5%
 7       41.9%
 8       46.3%
 9       51.2%
10       19.5%
11       19.9%
12       23.9%
13       23.7%
14       23.3%
15       24.9%
16       25.3%
17       28.3%
18       27.9%
19       35.7%

Note that the difference between 9 and 10 is the difference between
short and long Python ints on a 32-bit box.  The patch doesn't
actually do anything to speed conversion to long:  the speedup is
due to detecting "unsigned long" overflow more quickly.

This is a bugfix candidate, but it's a non-trivial patch and it
would be painful to separate the "bug fix" from the "speed up" parts.

needforspeed: use append+reverse for rsplit, use "bloom filters" to
speed up splitlines and strip with charsets; etc.  rsplit is now as
fast as split in all our tests (reverse takes no time at all), and
splitlines() is nearly as fast as a plain split("\n") in our tests.
and we're not done yet... ;-)

Update Misc/NEWS for gzip patch #1281707

Update Misc/NEWS for gzip patch #1281707

fix broken merge

Applied patch 1337051 by Neal Norwitz, saving 4 ints on frame objects.

An improved script for building the binary distribution on MacOSX.

Use 'speed' instead of 'performance', because I agree with the argument
at http://zestyping.livejournal.com/193260.html that 'erformance' really means
something more general.

Mention string improvements

Add some items; mention the sprint

Patch #1488098.

This patchs makes it possible to create a universal build on OSX 10.4 and use
the result to build extensions on 10.3. It also makes it possible to override
the '-arch' and '-isysroot' compiler arguments for specific extensions.

Disable linking extensions with -lpython2.5 for darwin. This should fix bug
#1487105.

PyErr_NewException now accepts a tuple of base classes as its
"base" parameter.

Avoid creating a mess when installing a framework for the second time.

Merge from rjones-funccall branch.

Applied patch zombie-frames-2.diff from sf patch 876206 with updates for
Python 2.5 and also modified to retain the free_list to avoid the 67%
slow-down in pybench recursion test. 5% speed up in function call pybench.

needforspeed: fixed unicode "in" operator to use same implementation
approach as find/index

needforspeed: check first *and* last character before doing a full memcmp

unicode_repeat():  Change type of local to Py_ssize_t,
since that's what it should be.

PyUnicode_Join():  Recent code changes introduced new
compiler warnings on Windows (signed vs unsigned mismatch
in comparisons).  Cleaned that up by switching more locals
to Py_ssize_t.  Simplified overflow checking (it can _be_
simpler because while these things are declared as
Py_ssize_t, then should in fact never be negative).

needforspeed: use memcpy for "long" strings; use a better algorithm
for long repeats.

needforspeed: speed up unicode repeat, unicode string copy

Apply revised patch for GzipFile.readline performance #1281707

docstring tweaks: count counts non-overlapping substrings, not
total number of occurences