Add alloc stats to the base Box::operator new(), which is where non-builtin
types get allocated.

Also add stats for non-Python allocations (typically, conservative memory);
turns out that we are allocating a lot of conservative memory (both in terms
of allocations but also in terms of allocation size) for dicts.

Hopefully this makes it more clear which stats are subsets of others,
and which ones should add up to other ones.

ex it was easy to think that "rewriter_attempts" succeeded as long
as "rewriter_aborts" didn't get incremented, but it could also not
have gotten started, etc.

Here's an example of the new stats:
ic_attempts: 1724625
ic_attempts_nopatch: 1306007
ic_attempts_skipped: 404969
ic_attempts_skipped_megamorphic: 85558
ic_attempts_successful: 13649
ic_rewrites: 13649
ic_rewrites_aborted: 3248
ic_rewrites_aborted_assemblyfail: 65
ic_rewrites_committed: 10401

implement float.hex and float.fromhex

remove the llvm::StringRef from BoxedString

support arg unpacking

tracebacks, struct.pack

The struct module just defers to PyLong_As* methods, so the
actual change here is improving our implementation of
_PyLong_AsByteArray, to add
- overflow and underflow checking
- twos-complement conversion (mpz_export ignores the sign)
- endianness

Now that we have frame support including f_back, we can
use the cpython implementations of these functions.

We don't have the same traceback objects (don't have
tb_frame or tb_next), so there are still some modifications
to the traceback library.

Copy all HAVE_FOO defines from cpython

Previously we were only copying them when we noticed they were needed,
but we've been spending a fair bit of time hunting down issues that
are caused by a missing HAVE_ define.

So instead, bulk-copy the ones that the CPython configure script determined.
I bet we'll start running into some that were available on my 14.04
machine but won't be on other configurations; I'm hoping that an extra
define is easier to debug than a missing one (build error vs run error),
making this the better approach.

Add full_check and fix a couple misc things

Add PyWrapperDescr_Type, allow cls->tp_descr_get, allow overwriting attributes inside PyType_Ready

Add support for compile('single') and func.__globals__/func.func_globals

fix linter to allow comments after includes

When loading a shared library let the GC know about the static variables

Add PyClass_New, PyMethod_New, capifunc.__module__, missing gc handles, file.truncate

Fix `exec s in other_module`

the ast interpreter would incorrectly think it could OSR out to
the JIT, which would barf.

Mostly related to handling of building shared-library dependencies.
The current system is getting pretty messy, of which libraries (test extension
built for pyston/cpython, sharedmods) are pulled from which builds
(source directory vs cmake directory) in which modes (check_ vs run_).

This commit doesn't change the actual functionality but tries to just
make it clearer what is getting built when.

(also fixes a missing dependency)

Add pycurl as an 'extra' test

I don't feel like it's worth adding libcurl to our dependencies
just so that we can test pycurl.  Let's try adding it as a
Travis-CI-only test; I'm slightly worried that that will confuse people,
but I think we're already pretty used to travis-ci being a more
comprehensive test suite.

Multiprocessing

by adding from_cpython/setup.py.

This way we can build _multiprocessing as a shared module to be
loaded on-demand, since it's quite expensive right now for us to
import it.

CPython has a similar setup.py, but theirs is pretty large (2kloc)
so I don't feel like we need to try copying yet.

We could/should move other modules to use this strategy.

I'm not 100% happy with the build system support, but we can iterate
on that.

Encountered this one with the mixed tab and spaces test before it got fixed in pypa

Add PyClass_New, PyMethod_New, capifunc.__module__, missing gc handler, fix instancemethodGet if obj == NULL

For weakly-referenced objects that are garbage, we end up freeing their
attributes within that collection (assuming they are garbage as well).
This means that these objects are in a state that is not quite dead (we
don't want to allocate anything else in that space and clobber their
weakreflist), and not quite alive (their attributes point to garbage
memory).

So, change the handling to finish looking at those objects in the collection
that they become garbage, and then free them to make them properly dead.

weakrefs-handling is unavoidably reentrant, but now we only have to worry
about fully-dead (the referents) or fully-alive (the weakrefs) objects.

(pickle does this)

attrwrapper.iteritems also need to return an iterator (previously, a list)
since pickle calls next on those directly as well.

Our initialization is a bit different from CPython's, and multiprocessing
seems pretty sensitive to that.

So initialize it in a different place than we load the rest of the builtin
modules.

Some of the functionality relies on ctypes so it doesn't work, but it looks
like ctypes doesn't get imported until you try to use those features.