Style consistency, so "grep ^function ..." works as expected.

dis():  Simplified stack emulation a bit.

I was in this module anyway, so I did some janitorial things.

METH_NOARGS functions are still called with two arguments, one NULL,
so put that back into the function definitions (I didn't know this
until recently).

Make get_history_length() METH_NOARGS.

Add the get_completer() function based on Michael Stone's patch in

[ 676342 ] after using pdb readline does not work correctly

which is required to fix that bug.  So maaybe a bugfix candidate.

There was a subtle big in save_newobj(): it used self.save_global(t)
on the type instead of self.save(t).  This defeated the purpose of
NEWOBJ, because it didn't generate a BINGET opcode when t was already
memoized; but moreover, it would generate multiple BINPUT opcodes for
the same type!  pickletools.dis() doesn't like this.

How I found this?  I was playing with picklesize.py in the datetime
sandbox, and noticed that protocol 2 pickles for multiple objects were
in fact larger than protocol 1 pickles!  That was suspicious, so I
decided to disassemble one of the pickles.

This really needs a unit test, but I'm exhausted.  I'll be late for
work as it is. :-(

Slight code rearrangement to avoid testing getstate twice.

In save_newobj(), if an object's __getnewargs__ and __getstate__ are
the same function, don't save the state or write a BUILD opcode.  This
is so that a type (e.g. datetime :-) can support protocol 2 using
__getnewargs__ while also supporting protocol 0 and 1 using
__getstate__.  (Without this, the state would be pickled twice with
protocol 2, unless __getstate__ is defined to return None, which
breaks protocol 0 and 1.)

Author markup:  Andrew got to it first

SF patch 672098: Three __contains__ implementations

Contributed by Jp Calderone.

Fix [ 583477 ] wrong dest size.

Note this code is not used by the core on Win32, but in a block used only
by Windows CE.

Use %c rather than chr() to turn some ints into chars.

dis():  This had a problem with proto 0 pickles, in that POP sometimes
popped a MARK, but without stack emulation the disassembler couldn't
know that, and subsequent indentation got hosed.

Now the disassembler does do enough stack emulation to catch this.  While
I was at it, also added lots of sanity checks for other stack operations,
and correct use of the memo.  This goes (I think) a long way toward being
a "pickle verifier" now too.

Implement appropriate __getnewargs__ for all immutable subclassable builtin
types.  The special handling for these can now be removed from save_newobj().
Add some testing for this.

Also add support for setting the 'fast' flag on the Python Pickler class,
which suppresses use of the memo.

Only log a message and chmod() when the mode isn't already what we
want it to be.  Log both the old and new mode.

- The mac-specific tests should also be run on darwin.
- Added test_aepack to the mac/darwin specific tests.

minor grammar tweaks

Teach the parsermodule about floor division.  Fixes

[ 676521 ] parser module validation failure

bugfix candidate.

Moved aepack test code to the test suite.

Some objects could have uninitialized attributes. Fixed.

test_macfs found an error on the first day of its existence: round trips for date values to FSSpec.{Get,Set}Dates didn't work in MacPython-OS9. Fixed.

Document the demise of all pretenses of safety, and the difference
between cPickle and pickle.py regarding __safe_for_unpickling__ before
Python 2.3.

Declare Protocol 2 as implemented.

Support for extension codes.  (By accident I checked in the tests first.)

Test all three EXT opcodes, and move these tests into
TempAbstractPickleTests, because they don't work with cPickle yet.

Make the footer at the end of a \verbatiminput stand out a little
more, to make it easier to tell apart from the verbatim content.

Move a footnote to the end of the sentence, so the note mark won't
interfere with the flow of the sentence.

Whitespace normalization.

pickle:  Comment repair.
pickletools:  Import decode_long from pickle instead of duplicating it.

Updated info about test_bsddb3 failures.

Expect test_macostools and test_macfs to get skipped whenever
sys.platform != mac.  Likewise expect test_win{reg,sound} to get skipped
on non-win32 platforms.

Test aliases too.

Converted to not use macfs whenever possible.

Added a missing INCREF in pathname().

Temporary hacks to arrange that the pickle tests relying on protocol 2
only get run by test_pickle.py now (& not by test_cpickle.py).  This
should be undone when protocol 2 is implemented in cPickle too.
test_cpickle should pass again.

Add a comment about how some built-in types should grow a
__getnewargs__ method.

Get rid of __safe_for_unpickling__ and safe_constructors.

Also tidied up a few lines, got rid of apply(), added a comment.

Renamed "bin" arguments to "proto".  Note that this test currently
fails, for reasons unrelated to this patch.

More markup changes for consistency.

Various minor markup adjustments.

Add a test for a list subclass with a __dict__ as well as slots.

Instead of bad hacks trying to worm around the inherited
object.__reduce__, do a getattr() on the class so we can explicitly
test for it.  The reduce()-calling code becomes a bit more regular as
a result.

Also add support slots: if an object has slots, the default state is
(dict, slots) where dict is the __dict__ or None, and slots is a dict
mapping slot names to slot values.  We do a best-effort approach to
find slot names, assuming the __slots__ fields of classes aren't
modified after class definition time to misrepresent the actual list
of slots defined by a class.

Added missing dependency.

Install "python$(VERSION)" into /usr/local as the symlink to the framework,
and also create a symlink "python" pointing to "python$(VERSION)".
Fixes #675745.

Don't import Nav. It isn't needed, and importing it doesn't work in a
non-windowing Python.

Finally created the first two tests for MacPython modules: macfs and
macostools.

Comment out a test that was anticipating SF patch 661536 -- but that
isn't checked in yet. :-(

Added new private API function _PyLong_NumBits.  This will be used at the
start for the C implemention of new pickle LONG1 and LONG4 opcodes (the
linear-time way to pickle a long is to call _PyLong_AsByteArray, but
the caller has no idea how big an array to allocate, and correct
calculation is a bit subtle).

The default __reduce__ on the base object type obscured any
possibility of calling save_reduce().  Add a special hack for this.
The tests for this are much simpler now (no __getstate__ or
__getnewargs__ needed).

Fix SF bug# 676155, RuntimeWarning with tp_compare

Check return value of PyLong_AsDouble(), it can return an error.

Move the NEWOBJ-generating code to a separate function, and invoke it
after checking for __reduce__.

Some experimental support for generating NEWOBJ with proto=2, and
fixed a bug in load_newobj().

Verify treatment of unary minus on negative numbers SF bug #660455.

Bump the version number

Everything worked in both the distutils distro and in Python 2.3cvs,
so merge from the bsddb-bsddb3-schizo-branch back to the trunk.

save_empty_tuple():  Comment on why we can't get rid of this.

save_dict():  Added a comment about the control flow NealN missed.

_is_string_secure():  This method is no longer used; removed it.  (It
was used before string-escape codecs were added to the core.)

Made save() fit on a page, while adding comments.  (I moved some type
checks to save_reduce(), which can also be called from a subclass.)

Also tweaked some more comments.

Got rid of the _quotes global.  Used only once, and is trivial.

Use raw-mode docstring whenever there's an escape code in an example --
they're easier to read this way.

_dis_test should be a raw string now that it contains \x escapes.

dis():  Not all opcodes are printable anymore, so print the repr
of the opcode character instead (but stripping the quotes).

Added a proto 2 test section for the canonical recursive-tuple case.
Note that since pickle's save_tuple() takes different paths depending on
tuple length now, beefier tests are really needed (but not in pickletools);
the "short tuple" case tried here was actually broken yesterday, and it's
subtle stuff so needs to be tested.

Add a few comments.  Change the way the protocol is checked (it must
be one of 0, 1 or 2).

I should note that the previous checkin also added NEWOBJ support to
the unpickler -- but there's nothing yet that generates this.

Rename all variables 'object' to 'obj' to avoid conflicts with the
type 'object'.  Also minor docstring tweakage, and rearranged a few
lines in save().

Fix one disassembly output now that empty tuples are no longer
memoized in text mode.  Fixed some variable names in the disassembler
doctest.

Don't memoize the empty tuple in protocol 0.

Update to the final version released as Expat 1.95.6 (maintaining
Martin's integration changes).

save_tuple():  So long as the charter is rewriting for clarity, the snaky
control flow had to be simplified.

save_tuple():  I believe the new code for TUPLE{1,2,3} in proto 2 was
incorrect for recursive tuples.  Tried to repair; seems to work OK, but
there are no checked-in tests for this yet.

Comments.

Now that proto2 is defined, replaced XXX blocks with text about it.

Also moved the proto2 opcode descriptors into the sections they fit (like
TUPLE{1,2,3} in the group of tuple-building opcodes; etc).

OK, this is really the last one tonight!

NEWFALSE and NEWTRUE.

Shouldn't test short tuples with all items equal -- one potential bug
would be that the tuple is reversed on unpickling, and we should catch
that. :-)

Goodnight -- that's it for toniht!

More protocol 2: TUPLE1, TUPLE2, TUPLE3.

Also moved the special case for empty tuples from save() to save_tuple().

Rename 'bin' arg to 'proto'.  Keep the default at 0 lest the tests
change in meaning.

save_inst():  Rewrote to have only one branch on self.bin.  Also got rid
of my recent XXX comment, taking a (what appears to be vanishingly small)
chance and calling self.memoize() instead.

First baby steps towards implementing protocol 2: PROTO, LONG1 and LONG4.

Fixed odd whitespace after "if", which I believe I introduced long ago.

save_int():  Fixed two new off-by-1 glitches.

Add a comment explaining that struct.pack() beats marshal.dumps(), but
marshal.loads() beats struct.unpack()!  Possibly because the latter
creates a one-tuple. :-(

Got rid of mdumps; I timed it, and struct.pack("<i", x) is more than
40% faster than marshal.dumps(x)[1:]!  (That's not counting the
module attribute lookups, which can be avoided in either case.)

save_tuple():  Minor rewriting, and added a comment about the subtlety
created by recursive tuples.

load_appends():  replaced .append() loop with an .extend().

Comments.

save_dict():  Untangled most of the bin-vs-not-bin logic.  Also used
iteritems() instead of materializing a (possibly giant) list of the
items.

save_list():  Rewrote, to untangle the proto 0 from the proto 1 cases.
The code is much easier to follow now, and I bet it's faster too.

save_list():  removed unused local "d".

save_list():  removed unused local "memo".

save_pers():  Switched the order of cases, to get rid of a "not", and to
make the bin-vs-not-bin order consistent with what other routines try to
do (they almost all handle the bin case first).

Several routines appeared to inline the guts of memoize(), possibly for
some notion of low-level efficiency.  Undid that, but left one routine
alone:  save_inst() claims it has a reason for not using memoize().
I don't understand that comment, so added an XXX comment there.

save():  Fiddled the control flow to put the normal case where it
belongs.  This is a much smaller change than it may appear:  the bulk
of the function merely got unindented by one level.

Added XXX about save()'s special-casing of tuples -- I don't get it.

save_bool():  simplified.

Repaired grammar in new comment.

clear_memo():  Repaired grammar in docstring.

Added one-line comments to the proto 2 opcodes.

Use proper function name in exception messages

Removed the new LONG2 opcode:  it's extravagant.  If LONG1 isn't enough,
then the embedded argument consumes at least 256 bytes.  The difference
between a 3-byte prefix (LONG2 + 2 bytes) and a 5-byte prefix (LONG4 +
4 bytes) is at worst less than 1%.  Note that binary strings and binary
Unicode strings also have only "size is 1 byte, or size is 4 bytes?"
flavors, and I expect for the same reason.  The only place a 2-byte
thingie was used was in BININT2, where the 2 bytes make up the *entire*
embedded argument (and now EXT2 also does this); that's a large savings
over 4 bytes, because the total opcode+argument size is so small in
the BININT2/EXT2 case.

Removed the TAKEN_FROM_ARGUMENT "number of bytes" code, and bifurcated it
into TAKEN_FROM_ARGUMENT1 and TAKEN_FROM_ARGUMENT4.  Now there's enough
info in ArgumentDescriptor objects to deduce the # of bytes consumed by
each opcode.

Rearranged the order in which proto2 opcodes are listed in pickle.py.

Documented the 2's-comp business for the new long opcodes.

Whitespace normalization.