- Move `FutureFlags` from `BoxedModule` to `SourceInfo`.
- Handle `__future__` imports in exec statements.
- Handle the `division` import in cfg gen rather than later.

allocate runtime ics using mmap (with PROT_EXEC)

output stderr/stdout diffs for failed tests

free generator even if the don't exit

also, output both in KEEP_GOING mode if VERBOSE

Specify all package versions in virtualenv_test

We were doing this for the main packages, but we would get different
versions of their dependencies dependending on what the latest version
was.

Also, add some extra debugging output in the parser in case that
issue crops up again.

Try to make weakref4 less flaky

Slightly change generator StopIteration handling

Make multiple copies of all of the objects we expect to get
collected, and just assert than any of them get collected.

Unconditionally raise a StopIteration when trying to iterate
a finished generator, regardless of what originally stopped
it from iterating.

Generator: don't generate the traceback for the StopIteration exc when the generator is exiting back to a hasnext call.

Add the _elementtree and update libpypa

Remove redundant code and pave way for #254

Fix compile error when enabling memstats + call tp_richcompare even if rewrite_args == NULL

I think this makes sense and I having different behaviour depending on rewrite_args is strange.

unifying behaviour -- step 2

unifying behaviour -- step 3

Generator: don't generate the traceback for the StopIteration exc when the generator is exiting back to a hasnext call.
This is a small perf improvement for django-template.py: took  7.4ms for last iteration from 8.2ms

added some files that test_float needs

Optimize stattimers

Main change is separating the representation of the timer stack (StatTimer) from
the manipulation of it (ScopedStatTimer).  This makes it easier to keep the different
use cases (top level timers vs non-top-level) separate without having the individual
functions check whether they think they are a top-level timer or not.

I would have expected this to help a bunch but it seems to actually hurt

This roughly halves stattimer overhead, from +80% to +40%
(on a very small benchmark; more complex benchmarks probably
have lower overhead)

I don't think we regularly run make check anymore, and it's a pain
to make sure the user has an up-to-date gcc (would need to come up
with a good set of instructions for anyone on 12.04).  So just remove
it from make check for now.

tp_richcompare

virtualenv_test currently takes ~7m for me.  we should probably move
most of the stuff it does to the "extra" tests, but for now at least
make `make check` not fail.

int, long, str, tuple, type

int and long are implemented using tp_compare in CPython,
which is the old-style comparison method.  I don't really understand
its semantics which rely on type coercion, and we don't have the
methods it needs, so just implement it as tp_richcompare for now.
I think this is still an overall compatibility improvement.

str_richcompare is very odd where we have to do some weird things
to convince the compiler to produce the best code it can.

The notable places that are changed are PyEq, PyLt, and
compare/compareInternal.

The old codepaths are still in there (though thankfully
now with reduced duplication with cpython), since for anything
that defines a Python-level __lt__, it's better to call that
with our rewriting support, rather than calling it through
slot_tp_richcompare.

The control flow is kind of messy, since I don't think we
know what the right long-term organization is for these kinds of
things.  But basically, it's:
- if we can't rewrite, just call the C slot
- if we can rewrite, and we think calling tp_richcompare is profitable
  (ie it's not slot_tp_richcompare), we call that and emit a call to
  it in the patchpoint
- otherwise, we try calling the python attribute

Actual conversion of our attributes to tp_richcompare in the next commit.