tempfile's mkstemp():  Changed last argument from

    binary=True
to
    text=False

by BDFL Pronouncement.  All other changes follow from this.  The change
to the docs is ready to go, but blocked by another JackMacLock in the
doc directory.

Remove a broken example of extreme backward compatibility; it is
simply not relevant any more.
Closes SF bug #595032.

Patch #595014: Cygwin tempfile patch

Although Cygwin attempts to be as Posix compliant
as possible, it has difficulties unlinking open
files. This is not surprising given that Cygwin is
dependent on Win32 which in turn has this problem
itself.

The attached tempfile patch acknowledges this
Cygwin limitation. Without this patch, Cygwin
fails test_tempfile (i.e., test_has_no_name) as
follows:

$ ./python -E -tt ../Lib/test/regrtest.py -l test_tempfile
test_tempfile
test test_tempfile failed -- Traceback (most recent call last):
  File "/home/jt/src/PythonCvs/Lib/test/test_tempfile.py", line 689, in test_has_no_name
    self.failOnException("rmdir", ei)
  File "/home/jt/src/PythonCvs/Lib/test/test_tempfile.py", line 33, in failOnException
    self.fail("%s raised %s: %s" % (what, ei[0], ei[1]))
  File "/home/jt/src/PythonCvs/Lib/unittest.py", line 260, in fail
    raise self.failureException, msg
AssertionError: rmdir raised exceptions.OSError: [Errno 90] Directory not empty: '/mnt/c/DOCUME~1/jatis/LOCALS~1/Temp/tmpM_z8nj'

Patch by Tim to shut up the compiler's DeprecationWarnings on the
high-bit-set hex constants.

test_many(): open only 100 temp files, not 1000.  Some systems don't
allow that many open files per process.  I don't see that 1000 makes
any difference for the test.

Patch #588564: _locale library patch

This patch enables setup.py to find gettext routines when they are
located in libintl instead of libc.  Although I developed this patch for
Cygwin, I hope that it can be easily updated to support other platforms
(if necessary). I tested this patch under Cygwin and Red Hat Linux 7.1.

Check for trailing backslash. Fixes #593656.

Patch #505705: Remove eval in pickle and cPickle.

tightening up a few except: clauses
see bug 411881

Fix memory leaks reported by valgrind

add some example docstrings using PyDoc_STR

add PyDoc_STR and PyDoc_STRVAR calls as examples for module authors

runtest():  I don't know why we don't just use TESTFN, but if we have to
do bizarre things to get a temp file, I changed it to use mkstemp instead
of NamedTemporaryFile.  This tried to leave the file open while passing
its name to execfile().  On Win2K (but not Win9X), though, a file created
with O_TEMPORARY cannot be opened again, so the test failed with a
permission error when execfile tried to open it.  Closer to the truth:
a file created with O_TEMPORARY can be opened again, but only if the
file is also created with SHARE_DELETE access via the Win32 CreateFile()
function.  There's no way to get at that from MS's version of libc, though
(we'd have to ditch the "std" C file functions in favor of Win32 API
calls).

mkstemp():  Repaired error in docstring (the sense of the 'binary' flag
was reversed).

mkstemp():  The optional "binary" argument is clearly intended to be a
Boolean, so changed its default value from 1 to True.

NamedTemporaryFile(), TemporaryFile():  removed needless local vrbl 'bin'.

template:  removed special-casing for NT; there isn't an 8-character limit.

_once():  Removed obfuscating aliasing of _once_lock.

_once():  Simplified dict manipulation.

Allow more docstrings to be removed during compilation in some modules

Allow more docstrings to be removed during compilation

Added a test specifically to tickle Karatsuba; it costs no appreciable
runtime.

Add a missing call to _strclass().

Fixed error in new comment.

k_mul():  The fix for (ah+al)*(bh+bl) spilling 1 bit beyond the allocated
space is no longer needed, so removed the code.  It was only possible when
a degenerate (ah->ob_size == 0) split happened, but after that fix went
in I added k_lopsided_mul(), which saves the body of k_mul() from seeing
a degenerate split.  So this removes code, and adds a honking long comment
block explaining why spilling out of bounds isn't possible anymore.  Note:
ff we end up spilling out of bounds anyway <wink>, an assert in v_iadd()
is certain to trigger.

Regress Guido's change of 2002/08/06 to check for the zlib version
1.1.4.  Redhat hasn't upgraded but does provide a patched 1.1.3
package, so checking for 1.1.4 just makes life difficult.

Allow docstrings to be removed during compilation for *SLOT macro and friends

Add tests for including __dict__ and/or __weakref__ in __slots__.
Add some more rigor to slotmultipleinheritance().

SF bug #574235, convert_path fails with empty pathname

Allow docstrings to be removed during compilation

Add test for SF bug # 575229, multiple inheritance w/ slots dumps core
Fix already checked in by Guido

Remove ugly irregular spaces from in front of some comments.

Bug #556025: list(xrange(1e9)) --> seg fault

Close the bug report again -- this time for Cygwin due to a newlib bug.
See the following for the details:

http://sources.redhat.com/ml/newlib/2002/msg00369.html

Note that this commit is only a documentation (i.e., comment) change.

Add an improvement wrinkle to Neil Schemenauer's change to int_mul
(rev. 2.86).  The other type is only disqualified from sq_repeat when
it has the CHECKTYPES flag.  This means that for extension types that
only support "old-style" numeric ops, such as Zope 2's ExtensionClass,
sq_repeat still trumps nb_multiply.

test_division():  Added one larger digits value, to ensure that the
"lopsided Karatsuba" driver also gets some exercise.

Machines-- and Python --are a lot faster in relevant ways since this
test was written.  So boosted the number of "digits" this generates, and
also beefed up the "* / divmod" test to tickle numbers big enough to
trigger the Karatsuba algorithm.  It takes about 2 seconds now on my box.

Fix comment for PyLong_AsUnsignedLong() to say that the return value
is an *unsigned* long.

Fix wanrings about unsigned hex constants.

k_lopsided_mul():  This allocated more space for bslice than necessary.

The auto-reply text for the python-docs address.  This is not automatically
updated when checkins are made, but I can get that updated when needed.

Added new function k_lopsided_mul(), which is much more efficient than
k_mul() when inputs have vastly different sizes, and a little more
efficient when they're close to a factor of 2 out of whack.

I consider this done now, although I'll set up some more correctness
tests to run overnight.

Don't use hex constants representing negative numbers.

Suppress warnings about test_grammar.py that can't be suppressed inside
that file itself (because it's the parser that reports them).

Use PyErr_WarnExplicit() to warn about hex/oct constants, so the
correct filename and line number are reported.

Updated for the current state of affairs.

New names.

Make sure that *any* object whose id() is used as a memo key is kept
alive in the memo.  This fixes SF bug 592567.

k_mul():  Moved an assert down.  In a debug build, interrupting a
multiply via Ctrl+C could cause a NULL-pointer dereference due to
the assert.

k_mul():  Heh -- I checked in two fixes for the last problem.  Only keep
the good one <wink>.  Also checked in a test-aid by mistake.

k_mul():  White-box testing turned up that (ah+al)*(bh+bl) can, in rare
cases, overflow the allocated result object by 1 bit.  In such cases,
it would have been brought back into range if we subtracted al*bl and
ah*bh from it first, but I don't want to do that because it hurts cache
behavior.  Instead we just ignore the excess bit when it appears -- in
effect, this is forcing unsigned mod BASE**(asize + bsize) arithmetic
in a case where that doesn't happen all by itself.

Fix MSVC warnings.

Refactor how __dict__ and __weakref__ interact with __slots__.

1. You can now have __dict__ and/or __weakref__ in your __slots__
   (before only __weakref__ was supported).  This is treated
   differently than before: it merely sets a flag that the object
   should support the corresponding magic.

2. Dynamic types now always have descriptors __dict__ and __weakref__
   thrust upon them.  If the type in fact does not support one or the
   other, that descriptor's __get__ method will raise AttributeError.

3. (This is the reason for all this; it fixes SF bug 575229, reported
   by Cesar Douady.)  Given this code:
      class A(object): __slots__ = []
      class B(object): pass
      class C(A, B): __slots__ = []
   the class object for C was broken; its size was less than that of
   B, and some descriptors on B could cause a segfault.  C now
   correctly inherits __weakrefs__ and __dict__ from B, even though A
   is the "primary" base (C.__base__ is A).

4. Some code cleanup, and a few comments added.

x_mul():  Made life easier for C optimizers in the "grade school"
algorithm.  MSVC 6 wasn't impressed <wink>.

Something odd:  the x_mul algorithm appears to get substantially worse
than quadratic time as the inputs grow larger:

bits in each input   x_mul time   k_mul time
------------------   ----------   ----------
             15360         0.01         0.00
             30720         0.04         0.01
             61440         0.16         0.04
            122880         0.64         0.14
            245760         2.56         0.40
            491520        10.76         1.23
            983040        71.28         3.69
           1966080       459.31        11.07

That is, x_mul is perfectly quadratic-time until a little burp at
2.56->10.76, and after that goes to hell in a hurry.  Under Karatsuba,
doubling the input size "should take" 3 times longer instead of 4, and
that remains the case throughout this range.  I conclude that my "be nice
to the cache" reworkings of k_mul() are paying.

k_mul() and long_mul():  I'm confident that the Karatsuba algorithm is
correct now, so added some final comments, did some cleanup, and enabled
it for all long-int multiplies.  The KARAT envar no longer matters,
although I left some #if 0'ed code in there for my own use (temporary).
k_mul() is still much slower than x_mul() if the inputs have very
differenent sizes, and that still needs to be addressed.

Portable way of producing unsigned 32-bit hex output to print the
CRCs.

Shut up warnings about hex()/oct() that can't be avoided.

Avoid warnings about <<.  external_attr is now an unsigned long.

k_mul:  Rearranged computation for better cache use.  Ignored overflow
(it's possible, but should be harmless -- this requires more thought,
and allocating enough space in advance to prevent it requires exactly
as much thought, to know exactly how much that is -- the end result
certainly fits in the allocated space -- hmm, but that's really all
the thought it needs!  borrows/carries out of the high digits really
are harmless).

Correct PyAPI_FUNC to PyAPI_DATA - sorry Jack.

Add name mangling for new PyUnicode_FromOrdinal() and fix declaration
to use new extern macro.

Excise DL_EXPORT from Include.

Thanks to Skip Montanaro and Kalle Svensson for the patches.

x_mul():  This failed to normalize its result.

k_mul():  This didn't allocate enough result space when one input had
more than twice as many bits as the other.  This was partly hidden by
that x_mul() didn't normalize its result.

The Karatsuba recurrence is pretty much hosed if the inputs aren't
roughly the same size.  If one has at least twice as many bits as the
other, we get a degenerate case where the "high half" of the smaller
input is 0.  Added a special case for that, for speed, but despite that
it helped, this can still be much slower than the "grade school" method.
It seems to take a really wild imbalance to trigger that; e.g., a
2**22-bit input times a 1000-bit input on my box runs about twice as slow
under k_mul than under x_mul.  This still needs to be addressed.

I'm also not sure that allocating a->ob_size + b->ob_size digits is
enough, given that this is computing k = (ah+al)*(bh+bl) instead of
k = (ah-al)*(bl-bh); i.e., it's certainly enough for the final result,
but it's vaguely possible that adding in the "artificially" large k may
overflow that temporarily.  If so, an assert will trigger in the debug
build, but we'll probably compute the right result anyway(!).

Introduced helper functions v_iadd and v_isub, for in-place digit-vector
addition and subtraction.  Reworked the tail end of k_mul() to use them.
This saves oodles of one-shot longobject allocations (this is a triply-
recursive routine, so saving one allocation in the body saves 3**n
allocations at depth n; we actually save 2 allocations in the body).

New news about __class__ assignment restrictions and speed-up of
new-style object creation/deallocation.

Moved all news about type/class unification and new-stype classes to a
separate section at the top.

Revert what looks like a typo from the last checkin

k_mul():  Repaired another typo in another comment.

k_mul():  Repaired typo in comment.

Cautious introduction of a patch that started from
SF 560379:  Karatsuba multiplication.
Lots of things were changed from that.  This needs a lot more testing,
for correctness and speed, the latter especially when bit lengths are
unbalanced.  For now, the Karatsuba code gets invoked if and only if
envar KARAT exists.

Fixed misspelling in comment.

int_lshift():  Simplified/sped overflow-checking.

Extend stripid() to handle strings ending in more than one '>'.
Add resolve() to handle looking up objects and names (fix SF bug 586931).
Add a nicer error message when given a filename that doesn't exist.

Reset errno to zero after calling PyErr_Warn().  It can potentially do
a lot of work, including I/O (e.g. to import warnings.py), which might
affect errno.

Use a better check for overflow from a<<b.

Add C API PyUnicode_FromOrdinal() which exposes unichr() at C level.

u'%c' will now raise a ValueError in case the argument is an
integer outside the valid range of Unicode code point ordinals.

Closes SF bug #593581.

Implement stage B0 of PEP 237: add warnings for operations that
currently return inconsistent results for ints and longs; in
particular: hex/oct/%u/%o/%x/%X of negative short ints, and x<<n that
either loses bits or changes sign.  (No warnings for repr() of a long,
though that will also change to lose the trailing 'L' eventually.)

This introduces some warnings in the test suite; I'll take care of
those later.

test_saveall():  Another small simplification; plus s/l/L/g.
test_del(), test_del_newclass():  No need to use apply() in these.

And one more simplification to test_saveall().

test_saveall():  Simplified a little, given that we only expect one item
in gc.garbage (so no need to loop looking for it -- it's there or it's
not).

If any trash happened to be sitting around waiting to get collected at
the time it's called, test_saveall() made it look a leak, triggering
bogus warnings from regrtest's -l (findleaks) mode.

Convert characters from the locale's encoding on output.
Reject characters outside the locale's encoding on input.

Fixed new typos, added a little info about ~sort versus "hint"s.

Clarify that the interruptable popen fixes aren't used under Win9x.

Disallow class assignment completely unless both old and new are heap
types.  This prevents nonsense like 2.__class__ = bool or
True.__class__ = int.

1. Combined the base and length arrays into a single array of structs.
   This is friendlier for caches.

2. Cut MIN_GALLOP to 7, but added a per-sort min_gallop vrbl that adapts
   the "get into galloping mode" threshold higher when galloping isn't
   paying, and lower when it is.  There's no known case where this hurts.
   It's (of course) neutral for /sort, \sort and =sort.  It also happens
   to be neutral for !sort.  It cuts a tiny # of compares in 3sort and +sort.
   For *sort, it reduces the # of compares to better than what this used to
   do when MIN_GALLOP was hardcoded to 10 (it did about 0.1% more *sort
   compares before, but given how close we are to the limit, this is "a
   lot"!).  %sort used to do about 1.5% more compares, and ~sort about
   3.6% more.  Here are exact counts:

 i    *sort    3sort    +sort    %sort    ~sort    !sort
15   449235    33019    33016    51328   188720    65534  before
     448885    33016    33007    50426   182083    65534  after
      0.08%    0.01%    0.03%    1.79%    3.65%    0.00%  %ch from after

16   963714    65824    65809   103409   377634   131070
     962991    65821    65808   101667   364341   131070
      0.08%    0.00%    0.00%    1.71%    3.65%    0.00%

17  2059092   131413   131362   209130   755476   262142
    2057533   131410   131361   206193   728871   262142
      0.08%    0.00%    0.00%    1.42%    3.65%    0.00%

18  4380687   262440   262460   421998  1511174   524286
    4377402   262437   262459   416347  1457945   524286
      0.08%    0.00%    0.00%    1.36%    3.65%    0.00%

19  9285709   524581   524634   848590  3022584  1048574
    9278734   524580   524633   837947  2916107  1048574
      0.08%    0.00%    0.00%    1.27%    3.65%    0.00%

20 19621118  1048960  1048942  1715806  6045418  2097150
   19606028  1048958  1048941  1694896  5832445  2097150
      0.08%    0.00%    0.00%    1.23%    3.65%    0.00%

3. Added some key asserts I overlooked before.

4. Updated the doc file.

The samplesort-vs-mergesort #-of-comparisons comparisons were captured
before %sort was introduced.  Redid them (the numbers change, but the
conclusions don't).  Also did the samplesort counts with the released
2.2.1, as they're slightly different under the last CVS 2.3 samplesort
(some higher, some lower -- CVS had been changed to stop doing the
special-case business on recursive samplesort calls).

Fix a typo in the mktemp -> mkstemp patch.

Accomodate the packaging changes when we unpack into the dev/doc/ area
on python.org.

Lots of changes to the packaging of the documentation, all to keep
directories clean where the packages are unpacked.  Each package now
contains a single directory, Python-Docs-<version>/, which contains the
files for that version of the documentation.

Closes SF feature request #567576.

A tool to transform gprof(1) output into HTML, so you can click on a
function name and go to the corresponding entry.

Whitespace normalization.

Add tests for weakref support for generator-iterators.
Part of fixing SF bug #591704.

Add weakref support generator-iterators.
Part of fixing SF bug #591704.

Add support for the iterator protocol to weakref proxy objects.
Part of fixing SF bug #591704.

There's no distinction among 'user', 'group' and 'world' permissions
on Win32, so tests that assume there are such distinctions can't
pass.  Fiddled them to work.

Whitespace normalization.

For new-style classes, we can now test for tp_del instead of asking
for a __del__ attribute, to see if there's a finalizer.

Test finalizers and GC from inside __del__ for new classes.

Credit to Oren for the file-iterator patch.

News about the tempfile rewrite.

Massive changes from SF 589982 (tempfile.py rewrite, by Zack
Weinberg).  This changes all uses of deprecated tempfile functions to
the recommended ones.