New entries to track the DOM API growth.  These match names exposed in
PyXML 0.8.

When installing the "python" link in bindir also test for a pre-existing
symlink and remove it.

- Precompile py files in Mac subtree after installing
- Pre-cache .rsrc files in Mac subtree after installing
- Fixed nameclash in Make variables

- Check not only that cache file exists, but also that it is newer than
  the applesingle file.
- Added optional verbose option for cachersrc tool.

Tool to pre-created cached .rsrc.df.rsrc files in the Lib directories,
similar to compileall.py.

Document that -u puts stdin, stdout, and stderr in binary mode.

On Cygwin, put stdin, stderr, and stdout in binary mode when the -u
flag is given (to mimic native Windows).

Obsolete now that there's a python implementation of strptime in the
standard lib.

Patch by Russel Owen: if we have command line arguments zap pyc files
in the directories given.

Fix to ensure consistent 'repr' and 'str' results between Python
versions, since 'repr(new_style_class) != repr(classic_class)'.
Suggested by Jeremy Hylton.

Depracated some non-carbon modules.

This file should have gone long ago.

Repaired a braino in the description of bad minrun values.

SF bug #592645 fix memory leak in socket.getaddrinfo

Update the text on the Expat module and library.

Major speedup for new-style class creation.  Turns out there was some
trampolining going on with the tp_new descriptor, where the inherited
PyType_GenericNew was overwritten with the much slower slot_tp_new
which would end up calling tp_new_wrapper which would eventually call
PyType_GenericNew.  Add a special case for this to update_one_slot().

XXX Hope there isn't a loophole in this.  I'll buy the first person to
point out a bug in the reasoning a beer.

Backport candidate (but I won't do it).

Moved inplace add and multiply methods from UserString to MutableString.
Closes SF Bug #592573 where inplace add mutated a UserString.
Added unittests to verify the bug is cleared.

Moved special case for tuples from iterobject.c to
tupleobject.c. Makes the code in iterobject.c cleaner
and speeds-up the general case by not checking for
tuples everytime.   SF Patch #592065.

Revised the test suite for 'contains' to use the test() function argument
rather than vereq().  While it was effectively testing regular strings, it
ignored the test() function argument when called by test_userstring.py.

By popular demand the frameworkinstall target now installs everything:
the framework, the MacOSX apps and the unix tools.
Most of the hard work is done by Mac/OSX/Makefile.

Also, it should now be possible to install in a different directory,
such as /tmp/dist/Library/Frameworks, for building binary installers.
The fink crowd wanted this.

Significant speedup in new-style object creation: in slot_tp_new(),
intern the string "__new__" so we can call PyObject_GetAttr() rather
than PyObject_GetAttrString().  (Though it's a mystery why slot_tp_new
is being called when a class doesn't define __new__.  I'll look into
that tomorrow.)

2.2 backport candidate (but I won't do it).

Use hex escape for non-ascii chars, now that the parser wants that.
Good thing, too: some of the characters had been mangled by OS9->CVS->OSX
roundtrips.

A modest speedup of object deallocation.  call_finalizer() did rather
a lot of work: it had to save and restore the current exception around
a call to lookup_maybe(), because that could fail in rare cases, and
most objects don't have a __del__ method, so the whole exercise was
usually a waste of time.  Changed this to cache the __del__ method in
the type object just like all other special methods, in a new slot
tp_del.  So now subtype_dealloc() can test whether tp_del is NULL and
skip the whole exercise if it is.  The new slot doesn't need a new
flag bit: subtype_dealloc() is only called if the type was dynamically
allocated by type_new(), so it's guaranteed to have all current slots.
Types defined in C cannot fill in tp_del with a function of their own,
so there's no corresponding "wrapper".  (That functionality is already
available through tp_dealloc.)

The other half of the patches added to SF patch 555085 by A I
MacIntyre.  At least on OS/2, a subsequent connect() on a nonblocking
socket returns errno==EISCONN to indicate success.  This seems
harmless on Unix.

Clean up some docstrings.  Some docstrings didn't show their return
value; others were inconsistent in what to name the argument or return
value; a few module-global functions had "socket." in front of their
name, against convention.

testSendAll(): loop until all data is read; this was necessary at
least on OS/2 (see note on SF patch 555085 by A I MacIntyre) but
looks like the test *could* fail on any other platform too -- there's
no guarantee that recv() reads all data.

Whitespace normalization.

Delete junk attributes left behind by _socketobject class construction.

Patch #588561: Cygwin _hotshot patch

YA Cygwin module patch very similar to other patches
that I have submitted.  I tested under Cygwin and Red
Hat Linux 7.1.

The _socketobject class has no need for a __del__ method: all it did was
to delete the reference to self._sock, and the regular destructor will
do that just fine.  This made some hacks in close() unnecessary.

The _fileobject class still has a __del__ method, because it must flush.

OK, one more hack: speed up the case of readline() in unbuffered mode.
This is important IMO because httplib reads the headers this way.

Another refactoring of read() and readline(), this time based on the
observation that _rbuf could never have more than one string in it.
So make _rbuf a string.  The code branches for size<0 and size>=0
are completely separate now, both in read() and in readline().

I checked for tabs this time. :-)

Extend __all__ with the exports list of the _ssl module.

Oops, stupid tabs.  Sorry again.

Another refactoring.  Changed 'socket' from being a factory function
to being a new-style class, to be more similar to the socket class
in the _socket module; it is now the same as the _socketobject class.
Added __slots__.  Added docstrings, copied from the real socket class
where possible.

The _fileobject class is now also a new-style class with __slots__
(though without docstrings).  The mode, name, softspace, bufsize and
closed attributes are properly supported (closed as a property; name
as a class attributes; the softspace, mode and bufsize as slots).

Add module-wide "__metaclass__ = type", as requested by Jim Fulton.
(Synched from pyunit CVS)

Added info about highwater heap-memory use for the sortperf.py tests; + a
couple of minor edits elsewhere.

PyList_Reverse():  This was leaking a reference to Py_None on every call.
I believe I introduced this bug when I refactored the reversal code so
that the mergesort could use it too.  It's not a problem on the 2.2 branch.

Major restructuring of _fileobject.  Hopefully several things now work
correctly (the test at least succeed, but they don't test everything yet).

Also fix a performance problem in read(-1): in unbuffered mode, this would
read 1 byte at a time.  Since we're reading until EOF, that doesn't make
sense.  Use the default buffer size if _rbufsize is <= 1.

Replace docstrings on test functions witrh comments -- then unittest
prints function and module names, which is more informative now that
we repeat some tests in slightly modified subclasses.

Add a test for read() until EOF.

Add test suites for line-buffered (bufsize==1) and a small custom
buffer size (bufsize==2).

Restructure testUnbufferedRead() somewhat to avoid a potentially
infinite loop.

Added info about the right way to leave the body of a trashcan-protected
destructor early.

Fix a subtle bug in the trashcan code I added yesterday to
subtype_dealloc().

When call_finalizer() failed, it would return without going through
the trashcan end macro, thereby unbalancing the trashcan nesting level
counter, and thereby defeating the test case (slottrash() in
test_descr.py).  This in turn meant that the assert in the GC_UNTRACK
macro wasn't triggered by the slottrash() test despite a bug in the
code: _PyTrash_destroy_chain() calls the dealloc routine with an
object that's untracked, and the assert in the GC_UNTRACK macro would
fail on this; but because of an earlier test that resurrects an
object, causing call_finalizer() to fail and the trashcan nesting
level to be unbalanced, so _PyTrash_destroy_chain() was never called.
Calling the slottrash() test in isolation *did* trigger the assert,
however.

So the fix is twofold: (1) call the GC_UnTrack() function instead of
the GC_UNTRACK macro, because the function is safe when the object is
already untracked; (2) when call_finalizer() fails, jump to a label
that exits through the trashcan end macro, keeping the trashcan
nesting balanced.

GvR pointed out that only enclosing function bodies are part of nested scopes.

Add -E and -tt options to the python invocations, as for the Unix tests.
The -tt means modules that mix tabs and spaces will be rejected.
The -E refuses to believe Python options in the environment.

Replace tabs with spaces.  (Sorry!)

Tighten the unbuffered readline test to distinguish between the two lines.

Simplify heapreplace() -- there's no need for an explicit test for
empty heap, since heap[0] raises the appropriate IndexError already.

Document that heappop() and heapreplace() raise IndexError if the heap
is empty.

Apply character{} markup.

Replace abort with Py_FatalError.

Described responsibilty of weakly referenced extension types to initialize
the weakreflist to NULL in the constructor and to fill the tp_flags
slot with Py_TPFLAGS_HAVE_WEAKREFS.  Closes SF bug 586583.

Describe nested scopes in the tutorial.  Closes SF bug 500704.

Oops.  I accidentally commented out some tests.

Regenerated with OSA class inheritance and fix for non-ascii chars.

Fixed incorrect  logic in determining whether we should initialize
the classes' attribute list.

Documented os.fsync and os.fdatasync.  Closes SF bug 584695.

"Unbuffered" mode of class _fileobject wasn't actually unbuffered,
and this broke a Zope "pipelining" test which read multiple responses
from the same connection (this attaches a new file object to the
socket for each response).  Added a test for this too.

(I want to do some code cleanup too, but I thought I'd first fix
the problem with as little code as possible, and add a unit test
for this case.  So that's what this checkin is about.)

- If an OSA identifier is a Python reserved word we now append an _
  in stead of prepending it, which messes up "import * from".
- A few ascii()s added again.
- Changed the getbaseclasses a little, but it still isn't perfect.

Clarify that the bool instances are acceptable return values from
__nonzero__(), in response to SF bug #579991.

Use Py_FatalError instead of abort.

Don't be over-enthusiastic with the ascii() calls: we don't need it if
the result passes through backticks.

Donovan Preston's patch #538395, with some mods by me.

This patch makes inheritance for OSA classes work. The implementation is a
bit convoluted, but I don't immedeately see a simpler way of doing it.

I added calls to ascii() everywhere we output strings that may contain
non-ascii characters (Python has gotten very picky since the encoding
patch:-).

I also removed Donovan's different way of opening resource files: I don't
seem to need it.

Quote the arguments, they may contain strings.

Fix up some more markup problems.

Change the markup a bit more; the parameter was not marked as \var in the
sample code, and the note was marked as a logical thing.

Fix PEP 263 code --without-unicode. Fixes #591943.

Fix markup errors.

Expanded the unittests for the new width sensitive PyUnicode_Contains().

Document handling of raw-unicode-escapes.  Closes SF bug 587087.

internal_connect():  Windows.  When sock_timeout > 0 and connect() yields
WSAEWOULDBLOCK, the second connect() attempt appears to yield WSAEISCONN
on Win98 but WSAEINVAL on Win2K.  So accept either as meaning "yawn,
fine".  This allows test_socket to succeed on my Win2K box (which it
already did on my Win98SE box).

Added a note about the inability to specify a pathname to a non-existing
file in unix-Python.

Changed a sentence that confused some people.

Make more functions static

Make readahead functions static

Fix SF bug 574207 (chained __slots__ dealloc segfault).

This is inspired by SF patch 581742 (by Jonathan Hogg, who also
submitted the bug report, and two other suggested patches), but
separates the non-GC case from the GC case to avoid testing for GC
several times.

Had to fix an assert() from call_finalizer() that asserted that the
object wasn't untracked, because it's possible that the object isn't
GC'ed!

Fix the markup so it doesn't break formatting.

Add testcase for SF bug 574207 (chained __slots__ dealloc segfault).
Fix forthcoming.

Added references to the email package.
Closes SF bug #586937.

Added a test for PyUnicode_Contains() taking into account the width of
Py_UNICODE.

PyUnicode_Contains(): The memcmp() call didn't take into account the
width of Py_UNICODE.  Good catch, MAL.

get rid of GETNAMEV macro - use GETITEM directly
same idea as getting rid of GETCONST & GETNAME (see patch #506436)

Add a coding cookie, because of the møøse quote.

Update the URL for getting zlib, and update the minimal required
version to 1.1.4 (because of the 1.1.3 security problem).  Also
replace a funny use of line.find() with line.startswith().

Bump the LOOPS count.  50,000 iterations takes about 5 seconds on my
machine -- that feels just right.

Add some fine points: METH_KEYWORDS implies METH_VARARGS, and ob_size
is no longer unused in type objects.

Mark xreadlines deprecated.  Don't use f.xreadlines() in test_iter.py.

Remove mention of deprecated xreadlines method.

Describe new "str1 in str2" behavior.

Document file.next().  Mark xreadlines obsolete (both method and
module).  (One thing remains to be done: the gzip class has an
xreadline method; this ought to be replaced by an iterator as well.)

Committing patch #591250 which provides "str1 in str2" when str1 is a
string of longer than 1 character.

Files are now their own iterator.  The xreadlines method and module
are obsolete.

Add comment about os.path.walk()'s behavior with symbolic links.

Add next and __iter__ to the list of file methods that should raise
ValueError when called for a closed file.

SF patch 580331 by Oren Tirosh: make file objects their own iterator.

For a file f, iter(f) now returns f (unless f is closed), and f.next()
is similar to f.readline() when EOF is not reached; however, f.next()
uses a readahead buffer that messes up the file position, so mixing
f.next() and f.readline() (or other methods) doesn't work right.
Calling f.seek() drops the readahead buffer, but other operations
don't.

The real purpose of this change is to reduce the confusion between
objects and their iterators.  By making a file its own iterator, it's
made clearer that using the iterator modifies the file object's state
(in particular the current position).

A nice side effect is that this speeds up "for line in f:" by not
having to use the xreadlines module.  The f.xreadlines() method is
still supported for backwards compatibility, though it is the same as
iter(f) now.

(I made some cosmetic changes to Oren's code, and added a test for
"file closed" to file_iternext() and file_iter().)

In the altbininstall target, which is the first subtarget for "make install",
if we are running in an OSX framework enabled build directory, test that
the framework infrastructure exists. This catches the very common
error of doing "make install" in stead of "make frameworkinstall".

Patch #567296 by Pim Buurman, slightly modified by me so it can be disabled
at compile time: use PBGetCatInfoSync() to get FInfo data in stead of
GetFInfo. The latter doesn't work for folders. The former does, at
least on OSX, and insofar the info makes sense for a folder.

Wrapper around _IBCarbon.

Mention list.sort()
Document heapq module
Add PEP263 section (not sure I really understand the PEP's effect on 8-bit
   strings, though -- will have to experiment with it)

SF patch #591305 Documentation err in bytecode defs

We only need to check for StopIteration here.