GitLab

Use "re" module, making it threadsafe.

first.  Don't store the traceback as a local variable, to avoid
circular references.

os.fdopen() calls unbuffered.  I presume that it's enough if we can
make all three of them (for stdin, stdout, and stderr) unbuffered and
don't need to specify different buffer sizes per file -- that would
complicate the interface more than I care for.

This one works!  However it requires using a modified version of
tclNotify.c (provided), which requires access to the Tcl source
to compile it.  In order to enable this hack, add the following
to the Setup line for _tkinter:
   tclNotify.c -DHAVE_PYTCL_WAITUNTILEVENT -I$(TCL)/generic
where TCL points to the source tree of Tcl 8.0.  Other versions
of Tcl are not supported.

The tclNotify.c file is copyrighted by Sun Microsystems; the
licensing terms are in the file license.terms.  According to this
file, no further permission to distribute this is required,
provided the file license.terms is included.  Hence, I am checking
that in, too.

instead it is added to MACHDEPPATH in Modules/Setup.in

maps errno numbers to errno names (e.g. EINTR), and errorcode maps
them to message strings.  (The latter is redundant because
the new call posix.strerror() now does the same, but alla...)

Apparently the traceback object doesn't contains the right linenumber
when -O is used.  Rather than guessing whether -O is on or off, use
tb_lineno() unconditionally.

When completing a simple identifier, it completes keywords, built-ins
and globals in __main__; when completing NAME.NAME..., it evaluates
(!) the expression up to the last dot and completes its attributes.

It's very cool to do "import string" type "string.", hit the
completion key (twice), and see the list of names defined by the
string module!

Tip: to use the tab key as the completion key, call

    readline.parse_and_bind("tab: complete")

set_completer(function)
parse_and_bind(string)
read_init_file(filename)

The first is the most exciting feature: with an appropriate Python
completer function, it can do dynamic completion based on the contents
of your namespace!

to Python.

arguments for execvp (for those who don't want the shell's argument
parsing).

the phase 2 init of the __builtin__ module, so that multiple
interpreters will get the right exceptions.

but annoying memory leak.  This was introduced when PyExc_Exception
was added; the loop above populating the PyExc_StandardError exception
tuple started at index 1 in bltin_exc, but PyExc_Exception was added
at index 0, so PyExc_StandardError was getting inserted in itself!
How else can a tuple include itself?!

Change the loop to start at index 2.

This was a *fun* one! :-)

__module__ string and if found, print <module>.<class>, unless
<module> == "exceptions".

(1) Introduce Exception as the conceptual root class for all exceptions.

(2) Do less work in __init__(), and more in __str__ (store args
unchanged).

"-i" is given.  (Yes, I know, giving in to Marc Lemburg who wanted
this :-)

explanatory message when the manual directories aren't found.
(I have to say I'm surprised that it actually still works!)

(Includes a patch he sent me a few days later.)

- Don't use "from copy_reg import *".

- Use cls.__module__ instead of calling whichobject(cls, cls.__name__);
  also try __module__ in whichmodule(), just in case.

- After calling save_reduce(), add the object to the memo.