XXX The code is still widely inaccurate, but most (all?) of the time
it's an overestimate.

in which case it will hang because the import lock is already held
by the main thread.

As the doc string for _lookupName() explains:

    This routine uses a list instead of a dictionary, because a
    dictionary can't store two different keys if the keys have the
    same value but different types, e.g. 2 and 2L.  The compiler
    must treat these two separately, so it does an explicit type
    comparison before comparing the values.

Generate SET_LINENO for del statements.

Define klass=1 for PyFlowGraph constructor for a class statement.  A
class has no varnames.

Avoid if/elif/elif/else tests where the final else is supposed to
handle exactly one case instead of all other cases.  When the list of
operators is extended, the catchall else treats all new operators as
the last operator in the set of tests.  Instead, raise an exception if
an unexpected operator occurs.

Fix bug in handling of statements like "l[x:y] = 2".  The visitor was
treating this as assignments to l, x, and y!

Use a dictionary instead of a list to map objects to their offsets in
a const/name tuple of a code object.

XXX The conversion is perhaps incomplete, in that we shouldn't have to
do the list2dict to start.

Add support for floor division (// and //=)

The implementation of getChildren() and getChildNodes() is intended to
be faster, because it avoids calling flatten() on every return value.
But it's not clear that it is a lot faster, because constructing a
tuple with just the right values ends up being slow.  (Too many
attribute lookups probably.)

The ast.txt file is much more complicated, with funny characters at
the ends of names (*, &, !) to indicate the types of each child node.

The astgen script is also much more complex, making me wonder if it's
still useful.

non-subclassability.  (More tests for number subclassing should follow.)

This uses a slightly wimpy and wasteful approach, but it works. :-)

In particular, the second argument can now be a subclass of the first
as well (normally it must be an instance though).

not enough for Python. Increased the stacksize to a (somewhat arbitrary)
64KB.

ints, convert to PyLong (rather than throwing away the high-order 32 bits).

PyString_FromFormat().  Also fixed one grammar problem, and a few
other mark-up issues.  Sample code not checked.

Rewrite snprintf() item a bit
Bump version number

64-bit INTs on 32-bit boxes (where they become longs).  Also exploit that
int(str) and long(str) will ignore a trailing newline (saves creating a
new string at the Python level).

pickletester.py:  Simulate reading a pickle produced by a 64-bit box.

couldn't succeed.  Fixed.

Dunno why I didn't catch this before.

directly.

This closes SF bug #456222.

don't use getattr, but only look in the dict of the type and base types.
This prevents picking up all sorts of weird stuff, including things defined
by the metaclass when the object is a class (type).

For this purpose, a helper function lookup_method() was added.  One or two
other places also use this.

contiguous.

rather than a type equality test.

varnames should list all the local variables (with arguments first).
The XXX_NAME ops typically occur at the module level and assignment
ops should create locals.

the contents will be shared by multiple references.

This closes SF bug #455694.

while \0 doesn't do what one might expect, \g<0> does.