Remove pointless comment

    I have no way of testing this.

type_repr() for when to show or not to show it).

info.  Caught by the tests that I'm writing now.

+ test_compare.  While None compares less than anything else, it's not
  always the case that None has the smallest id().
+ test_descr.  The output of %p (pointer) formats varies across platforms.
  In particular, on Windows it doesn't produce a leading "0x".

    the "#ifdef MS_WINDOWS" to "#ifdef SELECT_USES_HEAP" and by
    setting SELECT_USES_HEAP when FD_SETSIZE > 1024.

    The indirection seems useful since this subtly changes the path
    that "normal" Windows programs take (where Timmie sez FD_SETSIZE =
    512).  If that's a problem for Windows, he has only one place to
    change.

parameter, but did not.  This was found because it can create failures
elsewhere based on the presence of mime.types files in some common locations
the module searches by default.

(I will be writing a test for this module shortly!)

optimization for dynamic classes.  If __getattr__ is not found as an
attribute on the type, slot_tp_getattro replaces itself with
PyObject_GenericGetAttr.  This means you can't add a __getattr__
method to a class after the fact -- but you can still *change* a
__getattr__ method into a different one.

(A similar restriction exists for classic classes.)

have to do "from PIL import Image" instead of "import Image".

performance changes since the affected functions are not expected to be
used frequently, but reduces the volume of code.

    Add executable extension, needed to get the program name right on Win32

    Provide include_dirs argument to all calls to ._preprocess and ._compile
    Fix typo: pattern.search(pattern) should be pattern.search(line)

- type_module(), type_name(): if tp_name contains one or more period,
  the part before the last period is __module__, the part after that
  is __name__.  Otherwise, for non-heap types, __module__ is
  "__builtin__".  For heap types, __module__ is looked up in
  tp_defined.

- type_new(): heap types have their __module__ set from
  globals().__name__; a pre-existing __module__ in their dict is not
  overridden.  This is not inherited.

- type_repr(): if __module__ exists and is not "__builtin__", it is
  included in the string representation (just as it already is for
  classes).  For example <type '__main__.C'>.

test in a trivial way.  Fixed.

- descrobject.c:descr_check(): only believe None means the same as
  NULL if the type given is None's type.

- typeobject.c:wrap_descr_get(): don't "conventiently" default an
  absent type to the type of the object argument.  Let the called
  function figure it out.

- initsigs(): Ignore SIGXFZ so writing files beyond the file system
  size limit won't kill us.

- Py_Initialize(): call _Py_ReadyTypes() instead of readying types
  here.

- Py_Initialize(): call _PyImport_FixupExtension() for module
  "extensions".  (SF bug #422004.)

types -- currently Type, List, None and NotImplemented.  To be called
from Py_Initialize() instead of accumulating calls there.

Also rename type(None) to NoneType and type(NotImplemented) to
NotImplementedType -- naming the type identical to the object was
confusing.

returns that.  (This fix is also by MvL; checkin it in because I want
to make more changes here.  I'm still not 100% satisfied -- see
comments attached to the patch.)

checkin, the Wise uninstaller *will* delete the Python DLL from the system
directory, but if and only if there wasn't a same-named Python DLL already
in the system directory at the time the installer ran.  That (no same-named
DLL) should be the typical case for most most people (I'm different because
I've run perhaps hundreds of 2.2 installs over the last several weeks).
IOW, the change was worth making.

They should.  Added a line that's supposed to fix that -- it doesn't
actually work on my box, but checking it in anyway.

(__hash__ etc.), in static and dynamic classes, overridden and
default.

  operators for which a default implementation exist now work, both in
  dynamic classes and in static classes, overridden or not.  This
  affects __repr__, __str__, __hash__, __contains__, __nonzero__,
  __cmp__, and the rich comparisons (__lt__ etc.).  For dynamic
  classes, this meant copying a lot of code from classobject!  (XXX
  There are still some holes, because the comparison code in object.c
  uses PyInstance_Check(), meaning new-style classes don't get the
  same dispensation.  This needs more thinking.)

- Add object.__hash__, object.__repr__, object.__str__.  The __str__
  dispatcher now calls the __repr__ dispatcher, as it should.

- For static classes, the tp_compare, tp_richcompare and tp_hash slots
  are now inherited together, or not at all.  (XXX I fear there are
  still some situations where you can inherit __hash__ when you
  shouldn't, but mostly it's OK now, and I think there's no way we can
  get that 100% right.)

that class should compare the id() of those instances.  Add a test
that verifies this.  This test currently fails; I believe this is
caused by object.c:2.132 (Patch #424475 by loewis).

in the type object is used for, for many of the more commonly used slots.
Thanks!

(But there is still a lot more to write on this topic.)
Markup and organizational changes by your friendly neighborhood
documentation czar.

section of the Extending & Embedding manual -- thanks!

so the backward compatibility issues will be easier to understand.  I only
added comments indicating additions and assignments back to Python 2.0.

example.

example.