Treat an empty kwdict argument the same as a missing one.

Undefine and redefine PRAGMA_ALIGN_SUPPORTED under Carbon. Apple's "solution" of a funny define makes portable code impossible:-(

Use #if TARGET_API_MAC_CARBON to determine carbon/classic macos, not #ifdef.

Make the 'time' argument to the timemodule functions strftime, asctime,
ctime, gmtime and localtime optional, defaulting to 'the current time' in
all cases. Adjust docs, add news item. Also convert all argument-handling to
METH_VARARGS. Closes SF patch #103265.

Fixed a bunch of typos caught by Gilles Civario.

Clarify comments about returning None using a return without an expression;
this is not hard to explain!

Closes SF bug #129345.

Now that Marc-Andre has retracted unistr(), remove the tests.

A hack to augment sys.path with the build/lib.<platform> directory
created by Andrew's setup.py script, *if* we're actually running from
the build directory.  (The test for that: whether the sys.path[-1]
ends in "/Modules".)

This has one disadvantage: it imports a fair amount of code from the
distutils package, just in order to be able to calculate the correct
pathname.  See if I care. :-)

Run tests twice by default, first time deleting .pyc/.pyo files.
New option "-q" to leave .pyc/.pyo alone.

Backed out the unistr() builtin.

Use a saner test filename, to work on Windows.

Delete the bytecode from the library and tests before running the
tests for the first time -- like the Unix Makefile does.  This
avoids not catching problems in the bytecode generator and/or bytecode
marshalling.

"make test" was still broken when building in a subdirectory: Andrew's
fix set PYTHONPATH to something starting with $(srcdir)/build/lib....
The use of $(srcdir) was wrong here, it should be ./build/lib...

OK, checking in patch 103329.
Please check it against your nearest pop server --
mine doesn't support APOP (I checked I'm getting the same error
message, though)

Add some regression tests of coredump bugs in funcobject.c 2.31.  Also
added a test of a coredump that would occur when del'ing
func_defaults (put here for convenience).

Application and elaboration of patch #103305 to fix core dumps when
del'ing func.func_dict.  I took the opportunity to also clean up some
other nits with the code, namely core dumps when del'ing func_defaults
and KeyError instead of AttributeError when del'ing a non-existant
function attribute.

Specifically,

func_memberlist: Move func_dict and __dict__ into here instead of
special casing them in the setattro and getattro methods.  I don't
remember why I took them out of here before I first uploaded the PEP
232 patch. :/

func_getattro(): No need to special case __dict__/func_dict since
their now in the func_memberlist and PyMember_Get() should Do The
Right Thing (i.e. transforms NULL values into Py_None).

func_setattro(): Document the intended behavior of del'ing or setting
to None one of the special func_* attributes.  I.e.:

    func_code - can only be set to a code object.  It can't be del'd
    or set to None.

    func_defaults - can be del'd.  Can only be set to None or a tuple.

    func_dict - can be del'd.  Can only be set to None or a
    dictionary.

Fix core dumps and incorrect exceptions as described above.  Also, if
we're del'ing an arbitrary function attribute but func_dict is NULL,
don't create func_dict before discovering that we'll get an
AttributeError anyway.

gethash/cmpname both looked beyond the end of the character name.
This patch makes u"\N{x}" a bit less dependent on pure luck...

Repair "selective cut-&-paste" screwup.

Change verify() function to raise TestFailed, not AssertionError.

(I realize that I didn't really test this, because all the tests
succeed, so verify() never raised an AssertionError -- but the test
suite still succeeds, so I'm not too worried.)

GvR pointed out the correct way to check for statically built modules;
    sys.builtin_module_names
Add SSL directories in /usr/contrib/ for FreeBSD

Bump __version__; add authorship note for the BaseServer patch.

Add Jason Tishler to the ACKS file

Patch #103220 from Jason Tishler:
  This patch adds support for Cygwin to util.get_platform(). A Cygwin
  specific case is needed due to the format of Cygwin's uname command,
  which contains '/' characters.

Minor patch from Thomas Gellekum:
   * Deletes the Panel_NoArgReturnStringFunction() macro, which isn't used
     anymore
   * Adjusts two comments.

new unicode name database (~160k)

improved the ucnhash test a bit

added "getcode" and "getname" methods to the ucnhash module (they're
probably more useful for the test code than for any applications, but
one never knows...)

Color all word instances of "as" after "import", & on the same line, as if
keywords.  Cheap approximation to the truth.

refactored the unicodeobject/ucnhash interface, to hide the
implementation details inside the ucnhash module.

also cleaned up the unicode copyright blurb a little; Secret Labs'
internal revision history isn't that interesting...

Update the example DLL instructions for 2.1.  Add example.def to the
MSVC project file (as the instructions always recommended doing).

urllib.py very recently changed to produce uppercase escapes, but no
corresponding changes were made to its std test.

Whitespace normalization.

test_urllib is failing on Windows.  I don't know why, but I can at least
change the test to give a clue about *where* it's failing.

Use constructor form of "raise"; normalize <wink> docstrings.

Jeremy's patch #103323:  trivial tests of all untested modules.

This still mentioned IdlePrefs.py as the place to edit color
preferences.  It is now in config.txt or ~/.idle.

make the output of _test() suitable for use in the regression test

Anonymous SF bug 129288: "The python 2.0 urllib has %%%x as a format
when quoting forbidden characters. There are scripts out there that
break with lower case, therefore I guess %%%X should be used."

I agree, so am fixing this.

make error msg more informative when test of exec fails

add test for SyntaxError on
    def f(a):
        global a

clearer error messages for apply() and "no locals"

add test of bastion and rexec to std regression test suite

This patch introduces an extra pass to the compiler that generates a
symbol table for each top-level compilation unit.  The information in
the symbol table allows the elimination of the later optimize() pass;
the bytecode generation emits the correct opcodes.

The current version passes the complete regression test, but may still
contain some bugs.  It's a fairly substantial revision.  The current
code adds an assert() and a test that may lead to a Py_FatalError().
I expect to remove these before 2.1 beta 1.

The symbol table (struct symtable) is described in comments in the
code.

The changes affects the several com_XXX() functions that were used to
emit LOAD_NAME and its ilk.  The primary interface for this bytecode
is now com_addop_varname() which takes a kind and a name, where kind
is one of VAR_LOAD, VAR_STORE, or VAR_DELETE.

There are many other smaller changes:

- The name mangling code is no longer contained in ifdefs.  There are
  two functions that expose the mangling logical: com_mangle() and
  symtable_mangle().

- The com_error() function can accept NULL for its first argument;
  this is useful with is_constant_false() is called during symbol
  table generation.

- The loop index names used by list comprehensions have been changed
  from __1__ to [1], so that they can not be accessed by Python code.

- in com_funcdef(), com_argdefs() is now called before the body of the
  function is compiled.  This provides consistency with com_lambdef()
  and symtable_funcdef().

- Helpers do_pad(), dump(), and DUMP() are added to aid in debugging
  the compiler.

Derivative of patch #102549, "simpler, faster(!) implementation of string.join".
Also fixes two long-standing bugs (present in 2.0):
1. .join() didn't check that the result size fit in an int.
2. string.join(s) when len(s)==1 returned s[0] regardless of s[0]'s
   type; e.g., "".join([3]) returned 3 (overly optimistic optimization).
I resisted a keen temptation to make .join() apply str() automagically.

Revert a single line of my large change earlier today; this broke the ability
    to build in a subdirectory.  The additional directory is unfortunately
    redundant when *not* building in a subdirectory, which is why I took
    it out.

Checking in a slight variation of Barry's patch 103303.

Fix for the bug in complex() just reported by Ping.

SF Patch #102980, by Luke Kenneth Casson Leighton: BaseServer class
for SocketServer.py (inherited by TCPServer)

Luke wrote:

  The socketserver code, with a little bit of tweaking, can be made
  sufficiently general to service "requests" of any kind, not just by sockets.
  The BaseServer class was created, for example, to poll a table in a MYSQL
  database every 2 seconds. each entry in the table can be allocated a
  Handler which deals with the entry.

  With this patch, using BaseServer and ThreadedServer classes, the creation
  of the server that reads and handles MySQL table entries instead of a
  socket was utterly trivial: about 50 lines of python code.

  You may consider this code to be utterly useless [why would anyone else
  want to do anything like this???] - you are entitled to your opinion. if you
  think so, then think of this: have you considered how to cleanly add SSL to
  the TCPSocketServer? What about using shared memory as the
  communications mechanism for a server, instead of sockets? What about
  communication using files?

  The SocketServer code is extremely good every useful. it's just that as it
  stands, it is tied to sockets, which is not as useful.

I heartily approve of this idea.

SF Patch #103188, by Donn Cave: BeOS/ar-fake support for extra
libraries.

(I have no way to test this, I just trust Donn.)

SF Patch #103185, by jlt63: Some more standard modules cleanup for Cygwin

Support building this as a DLL under Cygwin.

Support building this as a DLL under Cygwin.

SF Patch #103250, by pj99: Optimize a strspn() out of startup.

Minor startup speedup: avoid a call to strspn().

Add test that ensures hash() of objects defining __cmp__ or __eq__ but
not __hash__ raises TypeError.

Rich comparisons fallout: instance_hash() should check for both
__cmp__ and __eq__ absent before deciding to do a quickie
based on the object address.  (Tim Peters discovered this.)

Add test that ensures hash([]) and hash({}) raise TypeError.

Rich comparisons fallout: PyObject_Hash() should check for both
tp_compare and tp_richcompare NULL before deciding to do a quickie
based on the object address.  (Tim Peters discovered this.)

Changes to recursive-object comparisons, having to do with a test case
I found where rich comparison of unequal recursive objects gave
unintuituve results.  In a discussion with Tim, where we discovered
that our intuition on when a<=b should be true was failing, we decided
to outlaw ordering comparisons on recursive objects.  (Once we have
fixed our intuition and designed a matching algorithm that's practical
and reasonable to implement, we can allow such orderings again.)

- Refactored the recursive-object comparison framework; more is now
  done in the support routines so less needs to be done in the calling
  routines (even at the expense of slowing it down a bit -- this
  should normally never be invoked, it's mostly just there to avoid
  blowing up the interpreter).

- Changed the framework so that the comparison operator used is also
  stored.  (The dictionary now stores triples (v, w, op) instead of
  pairs (v, w).)

- Changed the nesting limit to a more reasonable small 20; this only
  slows down comparisons of very deeply nested objects (unlikely to
  occur in practice), while speeding up comparisons of recursive
  objects (previously, this would first waste time and space on 500
  nested comparisons before it would start detecting recursion).

- Changed rich comparisons for recursive objects to raise a ValueError
  exception when recursion is detected for ordering oprators (<, <=,
  >, >=).

Unrelated change:

- Moved PyObject_Unicode() to just under PyObject_Str(), where it
  belongs.  MAL's patch must've inserted in a random spot between two
  functions in the file -- between two helpers for rich comparison...

Since I'm about to check in a change to the recursion-detection code
for comparisons that outlaws requets for ordering on recursive data
structures, remove the tests for ordering recursive data structures.

Patch #103313: Fixes "make test" by adding a little file named
    "platform", running the Python binary to create it, and then
    using it to set PYTHONPATH.

Patch from Barry: gets rid of two unused imports,
   wraps to 80chars, and adds some really hacky setting of compiler
   options when CC and LDSHARED are given on the make command line.
   (The Distutils should probably provide a utility function to
    automatically handle a number of common environment variables)

Clarifications.

Sizable reorganization of how header and library files are found
Check additional include directories for SSL
Don't build modules that are linked into the Python binary statically
Factored out the detection of Tkinter out into a method, since it's
    the most complicated module to set up
Simplify the logic for detecting Tkinter

Minor markup cleaning, and one required fix in the unistr() description.

Use openssl/*.h to include the OpenSSL header files

A dumb test for the dumdbm module.

Add test for comparing recursive data types.

Make the original, makesetup-based, targets for building shared modules
   available as "oldsharedmods" and "oldsharedinstall".  You'll need
   to get a copy of the full Setup.dist out of the CVS for them to
   actually do much.

Bite the bullet: use rich comparisons here, too.

Add test for misbehaving rich comparisons (always returning 0) --
these fall back to __cmp__.

Rich comparison tests

Document rich comparisons.

Updated for 2.1; removed references to BeOpen.com and PythonLabs.
Added Copyright GvR.

Add my name to the copyright notice.

Add note about copyright ownership and license situation.

- Add note about complex numbers.

- Changed description of rich comparisons to emphasize that < and >
  (etc.) are each other's reflection.  Also use this word in the note
  about the demise of __rcmp__.

correct typo - closes bug #129205

Fix the example (it didn't seem to reflect reality).

Remove build/ subdirectory in "clean" target, not "clobber"

Variant of SF patch 103252: Startup optimize: read *.pyc as string, not with getc().

Move distributed and duplicated config for stat() and fstat() into pyport.h.

Whitespace normalization.  Leaving tokenize_tests.py alone for now.

Use rich comparisons to fulfill an old wish: complex numbers now raise
exceptions when compared using <, <=, > or >=.

NOTE: This is a tentative change: this means that cmp() involving
complex numbers will raise an exception when the numbers differ, and
that in turn means that e.g. dictionaries and certain other compounds
(e.g. UserLists) containing complex numbers can't be compared either.
So we'll have to decide whether this is acceptable.  The alpha test
cycle is a good time to keep an eye on this!

Same treatment as listobject.c:

- In count(), remove(), index(): call RichCompare(Py_EQ).

- Get rid of array_compare(), in favor of new array_richcompare() (a
  near clone of list_compare()).

- Aligned items in array_methods initializer and comments for type
  struct initializer.

- Folded a few long lines.

Rich comparisons:

- Use PyObject_RichCompareBool() when comparing keys; this makes the
  error handling cleaner.

- There were two implementations for dictionary comparison, an old one
  (#ifdef'ed out) and a new one.  Got rid of the old one, which was
  abandoned years ago.

- In the characterize() function, part of dictionary comparison, use
  PyObject_RichCompareBool() to compare keys and values instead.  But
  continue to use PyObject_Compare() for comparing the final
  (deciding) elements.

- Align the comments in the type struct initializer.

Note: I don't implement rich comparison for dictionaries -- there
doesn't seem to be much to be gained.  (The existing comparison
already decides that shorter dicts are always smaller than longer
dicts.)

Same treatment as listobject.c:

- tuplecontains(): call RichCompare(Py_EQ).

- Get rid of tuplecompare(), in favor of new tuplerichcompare() (a
  clone of list_compare()).

- Aligned the comments for large struct initializers.

Fix a leak in instance_coerce().  This was introduced by Neil's
earlier coercion changes, not by rich comparisons.  When a coercion
function returns 1 (meaning it cannot do it), it should not INCREF the
arguments.  When no __coerce__() method was found, instance_coerce()
originally returned 0, pretending it did it.  Neil changed the return
value to 1, more accurately reflecting that it didn't do anything, but
forgot to take out the two INCREF calls.

Windows:  2.1a1 changes so Python runs again.  Note that the python20
subproject is gone, replaced by the new pythoncore subproject.

The signal module has to be compiled statically, so add it to Setup.dist
    and remove support for it from setup.py

Convert to rich comparisons:

- sort's docompare() calls RichCompare(Py_LT).

- list_contains(), list_index(), listcount(), listremove() call
  RichCompare(Py_EQ).

- Get rid of list_compare(), in favor of new list_richcompare().  The
  latter does some nice shortcuts, like when == or != is requested, it
  first compares the lengths for trivial accept/reject.  Then it goes
  over the items until it finds an index where the items differe; then
  it does more shortcut magic to minimize the number of additional
  comparisons.

- Aligned the comments for large struct initializers.

Bump up version number.

- compile struct module
- get version number from sys.version_info

a bold attempt to fix things broken by MAL's verify patch: import
'verify' iff it's used by a test module...

Marc-Andre must not have run these tests -- they used verify() but
didn't import it.  Also got rid of some inconsistent spaces inside
parentheses in test_gzip.py.

Get rid of the declaration for _PyCompareState_Key.

Get rid of the initialization of _PyCompareState_Key.

Deal properly (?) with comparing recursive datastructures.

- Use the compare nesting level and in-progress dictionary properly in
  PyObject_RichCompare().

- Change the in-progress code to use static variables instead of
  globals (both the nesting level and the key for the thread dict were
  globals but have no reason to be globals; the key can even be a
  function-static variable in get_inprogress_dict()).

- Rewrote try_rich_to_3way_compare() to benefit from the similarity of
  the three cases, making it table-driven.

- In try_rich_to_3way_compare(), test for EQ before LT and GT.  This
  turns out essential when comparing recursive UserList instances;
  with the old code, these would recurse into rich comparison three
  times for each nesting level up to NESTING_LIMIT/2, making the total
  number of calls in the order of 3**(NESTING_LIMIT/2)!

NOTE: I'm not 100% comfortable with this.  It works for the standard
test suite (which compares a few trivial recursive data structures
only), but I'm not sure that the in-progress dictionary is used
properly by the rich comparison code.  Jeremy suggested that maybe the
operation should be included in the dict.  Currently I presume that
objects in the dict are equal unless proven otherwise, and I set the
outcome for the rich comparison accordingly: true for operators EQ,
LE, GE, and false for the other three.  But Jeremy seems to think that
there may be counter-examples where this doesn't do the right thing.

Fix for bug #129173, reported by Skip Montanaro:
   Check for the two possible headers for Expat, expat.h and xmlparse.h,
   and only compile the pyexpat module if one of them is found.

strop doesn't actually seem to be needed

Use the extended library search path when looking for readline (simple
   oversight in using self.compiler.library_dirs)

Restore lost AFMT_S16_NE entry.