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.

misc library work

Paste kind of uses it.

It might also be ok to just have it throw an ImportError()

This gets pycurl and PIL working.

Unfortunately I can't figure out a great way to test this; pycurl
has external dependencies, and PIL only works with some workarounds
that I don't want to check in.  I think these features are
innoccuous enough that it's worth getting these in.

Surprisingly, setting tp_getattr and tp_getattro have pretty different behavior;
we can kind of make tp_getattro work with subclassing but apparently don't
do very will with tp_getattr.

Punt on fixing that for now and switch thread._local to use getattro

Class slot handling is getting pretty messy

Don't pass path to this version of find_module (unlike finders in meta_path).