The Distutils needs some Python modules to be able to build
modules. Currently I believe the minimal list is posix, _sre,
and string.

These modules will have to be built before the Distutils can be
used, so they'll simply be hardwired into Modules/Makefile and
be automatically built.

A top-level setup.py script will be written that checks the
libraries installed on the system and compiles as many modules
as possible.

Modules/Setup will be kept and settings in it will override
setup.py's usual behavior, so you can disable a module known
to be buggy, or specify particular compilation or linker flags.
However, in the common case where setup.py works correctly,
everything in Setup will remain commented out. The other
Setup.* become unnecessary, since nothing will be generating
Setup automatically.

The patch was checked in for Python 2.1, and has been subsequently
modified.

Patch #102588 on SourceForge contains the proposed patch.
Currently the patch tries to be conservative and to change as few
files as possible, in order to simplify backing out the patch.
For example, no attempt is made to rip out the existing build
mechanisms. Such simplifications can wait for later in the beta
cycle, when we're certain the patch will be left in, or they can
wait for Python 2.2.

The patch makes the following changes:

Makes some required changes to distutils/sysconfig (these will
be checked in separately)

Modules/Setup.config.in only contains entries for the gc and thread
modules; the readline, curses, and db modules are removed because
it's now setup.py's job to handle them.

Modules/Setup.dist now contains entries for only 3 modules --
_sre, posix, and strop.

The configure script builds setup.cfg from setup.cfg.in. This
is needed for two reasons: to make building in subdirectories
work, and to get the configured installation prefix.

Adds setup.py to the top directory of the source tree. setup.py
is the largest piece of the puzzle, though not the most
complicated. setup.py contains a subclass of the BuildExt
class, and extends it with a detect_modules() method that does
the work of figuring out when modules can be compiled, and adding
them to the 'exts' list.

Do we need to make it possible to disable the 3 hard-wired modules
without manually hacking the Makefiles? [Answer: No.]

The Distutils always compile modules as shared libraries. How do
we support compiling them statically into the resulting Python
binary?

[Answer: building a Python binary with the Distutils should be
feasible, though no one has implemented it yet. This should be
done someday, but isn't a pressing priority as messing around with
the top-level Makefile.pre.in is good enough.]