开源软件构建与测试

Changes of Revision 3

_service:tar_scm:python-greenlet.spec Changed

_service:tar_scm:0001-add-loongarch64-architecture-support.patch Changed

_service:tar_scm:greenlet-1.1.2.tar.gz/src/greenlet/greenlet.c Deleted

@@ -1,2135 +0,0 @@
-/* -*- indent-tabs-mode: nil; tab-width: 4; -*- */
-/* Format with:
- *  clang-format -i --style=file src/greenlet/greenlet.c
- *
- *
- * Fix missing braces with:
- *   clang-tidy src/greenlet/greenlet.c -fix -checks="readability-braces-around-statements"
-*/
-#define GREENLET_MODULE
-
-#include "greenlet.h"
-
-#include "structmember.h"
-
-#ifdef __clang__
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wunused-parameter"
-#    pragma clang diagnostic ignored "-Wmissing-field-initializers"
-#endif
-
-/***********************************************************
-
-A PyGreenlet is a range of C stack addresses that must be
-saved and restored in such a way that the full range of the
-stack contains valid data when we switch to it.
-
-Stack layout for a greenlet:
-
-               |     ^^^       |
-               |  older data   |
-               |               |
-  stack_stop . |_______________|
-        .      |               |
-        .      | greenlet data |
-        .      |   in stack    |
-        .    * |_______________| . .  _____________  stack_copy + stack_saved
-        .      |               |     |             |
-        .      |     data      |     |greenlet data|
-        .      |   unrelated   |     |    saved    |
-        .      |      to       |     |   in heap   |
- stack_start . |     this      | . . |_____________| stack_copy
-               |   greenlet    |
-               |               |
-               |  newer data   |
-               |     vvv       |
-
-
-Note that a greenlet's stack data is typically partly at its correct
-place in the stack, and partly saved away in the heap, but always in
-the above configuration: two blocks, the more recent one in the heap
-and the older one still in the stack (either block may be empty).
-
-Greenlets are chained: each points to the previous greenlet, which is
-the one that owns the data currently in the C stack above my
-stack_stop.  The currently running greenlet is the first element of
-this chain.  The main (initial) greenlet is the last one.  Greenlets
-whose stack is entirely in the heap can be skipped from the chain.
-
-The chain is not related to execution order, but only to the order
-in which bits of C stack happen to belong to greenlets at a particular
-point in time.
-
-The main greenlet doesn't have a stack_stop: it is responsible for the
-complete rest of the C stack, and we don't know where it begins.  We
-use (char*) -1, the largest possible address.
-
-States:
-  stack_stop == NULL && stack_start == NULL:  did not start yet
-  stack_stop != NULL && stack_start == NULL:  already finished
-  stack_stop != NULL && stack_start != NULL:  active
-
-The running greenlet's stack_start is undefined but not NULL.
-
- ***********************************************************/
-
-/*** global state ***/
-
-/* In the presence of multithreading, this is a bit tricky:
-
-   - ts_current always store a reference to a greenlet, but it is
-     not really the current greenlet after a thread switch occurred.
-
-   - each *running* greenlet uses its run_info field to know which
-     thread it is attached to.  A greenlet can only run in the thread
-     where it was created.  This run_info is a ref to tstate->dict.
-
-   - the thread state dict is used to save and restore ts_current,
-     using the dictionary key 'ts_curkey'.
-*/
-
-extern PyTypeObject PyGreenlet_Type;
-
-#if PY_VERSION_HEX >= 0x030700A3
-#    define GREENLET_PY37 1
-#else
-#    define GREENLET_PY37 0
-#endif
-
-#if PY_VERSION_HEX >= 0x30A00B1
-/*
-Python 3.10 beta 1 changed tstate->use_tracing to a nested cframe member.
-See https://github.com/python/cpython/pull/25276
-We have to save and restore this as well.
-*/
-#define TSTATE_USE_TRACING(tstate) (tstate->cframe->use_tracing)
-#define GREENLET_USE_CFRAME 1
-#else
-#define TSTATE_USE_TRACING(tstate) (tstate->use_tracing)
-#define GREENLET_USE_CFRAME 0
-#endif
-
-#ifndef Py_SET_REFCNT
-/* Py_REFCNT and Py_SIZE macros are converted to functions
-https://bugs.python.org/issue39573 */
-#    define Py_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt)
-#endif
-
-#ifndef _Py_DEC_REFTOTAL
-/* _Py_DEC_REFTOTAL macro has been removed from Python 3.9 by:
-  https://github.com/python/cpython/commit/49932fec62c616ec88da52642339d83ae719e924
-*/
-#    ifdef Py_REF_DEBUG
-#        define _Py_DEC_REFTOTAL _Py_RefTotal--
-#    else
-#        define _Py_DEC_REFTOTAL
-#    endif
-#endif
-
-/* Weak reference to the switching-to greenlet during the slp switch */
-static PyGreenlet* volatile ts_target = NULL;
-/* Strong reference to the switching from greenlet after the switch */
-static PyGreenlet* volatile ts_origin = NULL;
-/* Strong reference to the current greenlet in this thread state */
-static PyGreenlet* volatile ts_current = NULL;
-/* NULL if error, otherwise args tuple to pass around during slp switch */
-static PyObject* volatile ts_passaround_args = NULL;
-static PyObject* volatile ts_passaround_kwargs = NULL;
-
-/* Used internally in ``g_switchstack()`` */
-#if GREENLET_USE_CFRAME
-static int volatile ts__g_switchstack_use_tracing = 0;
-#endif
-
-/***********************************************************/
-/* Thread-aware routines, switching global variables when needed */
-
-#define STATE_OK                                          \
-    (ts_current->run_info == PyThreadState_GET()->dict || \
-     !green_updatecurrent())
-
-static PyObject* ts_curkey;
-static PyObject* ts_delkey;
-static PyObject* ts_tracekey;
-static PyObject* ts_event_switch;
-static PyObject* ts_event_throw;
-static PyObject* PyExc_GreenletError;
-static PyObject* PyExc_GreenletExit;
-static PyObject* ts_empty_tuple;
-static PyObject* ts_empty_dict;
-
-#define GREENLET_GC_FLAGS Py_TPFLAGS_HAVE_GC
-#define GREENLET_tp_alloc PyType_GenericAlloc
-#define GREENLET_tp_free PyObject_GC_Del
-#define GREENLET_tp_traverse green_traverse
-#define GREENLET_tp_clear green_clear
-#define GREENLET_tp_is_gc green_is_gc
-
-static void
-green_clear_exc(PyGreenlet* g)
-{
-#if GREENLET_PY37
-    g->exc_info = NULL;
-    g->exc_state.exc_type = NULL;
-    g->exc_state.exc_value = NULL;
-    g->exc_state.exc_traceback = NULL;
-    g->exc_state.previous_item = NULL;
-#else
-    g->exc_type = NULL;
-    g->exc_value = NULL;
-    g->exc_traceback = NULL;
-#endif
-}
-
-static PyGreenlet*
-green_create_main(void)
-{
-    PyGreenlet* gmain;
-    PyObject* dict = PyThreadState_GetDict();
-    if (dict == NULL) {
-        if (!PyErr_Occurred()) {
-            PyErr_NoMemory();
-        }
-        return NULL;
-    }
-
-    /* create the main greenlet for this thread */
-    gmain = (PyGreenlet*)PyType_GenericAlloc(&PyGreenlet_Type, 0);
-    if (gmain == NULL) {
-        return NULL;
-    }
-    gmain->stack_start = (char*)1;
-    gmain->stack_stop = (char*)-1;
-    /* GetDict() returns a borrowed reference. Make it strong. */
-    gmain->run_info = dict;
-    Py_INCREF(dict);
-    return gmain;
-}
-
-static int
-green_updatecurrent(void)
-{
-    PyObject *exc, *val, *tb;
-    PyThreadState* tstate;
-    PyGreenlet* current;
-    PyGreenlet* previous;
-    PyObject* deleteme;
-
-green_updatecurrent_restart:
-    /* save current exception */
-    PyErr_Fetch(&exc, &val, &tb);
-
-    /* get ts_current from the active tstate */
-    tstate = PyThreadState_GET();
-    if (tstate->dict &&
-        (current = (PyGreenlet*)PyDict_GetItem(tstate->dict, ts_curkey))) {
-        /* found -- remove it, to avoid keeping a ref */
-        Py_INCREF(current);
-        PyDict_DelItem(tstate->dict, ts_curkey);
-    }
-    else {
-        /* first time we see this tstate */
-        current = green_create_main();
-        if (current == NULL) {
-            Py_XDECREF(exc);
-            Py_XDECREF(val);
-            Py_XDECREF(tb);
-            return -1;
-        }
-    }
-    assert(current->run_info == tstate->dict);
-
-green_updatecurrent_retry:
-    /* update ts_current as soon as possible, in case of nested switches */
-    Py_INCREF(current);
-    previous = ts_current;
-    ts_current = current;
-
-    /* save ts_current as the current greenlet of its own thread */
-    if (PyDict_SetItem(previous->run_info, ts_curkey, (PyObject*)previous)) {
-        Py_DECREF(previous);
-        Py_DECREF(current);
-        Py_XDECREF(exc);
-        Py_XDECREF(val);
-        Py_XDECREF(tb);
-        return -1;
-    }
-    Py_DECREF(previous);
-
-    /* green_dealloc() cannot delete greenlets from other threads, so
-       it stores them in the thread dict; delete them now. */
-    deleteme = PyDict_GetItem(tstate->dict, ts_delkey);
-    if (deleteme != NULL) {
-        /* The only reference to these greenlets should be in this list, so
-           clearing the list should let them be deleted again, triggering
-           calls to green_dealloc() in the correct thread. This may run
-           arbitrary Python code?
-         */
-        PyList_SetSlice(deleteme, 0, INT_MAX, NULL);
-    }
-
-    if (ts_current != current) {
-        /* some Python code executed above and there was a thread switch,
-         * so ts_current points to some other thread again. We need to
-         * delete ts_curkey (it's likely there) and retry. */
-        PyDict_DelItem(tstate->dict, ts_curkey);
-        goto green_updatecurrent_retry;
-    }
-
-    /* release an extra reference */
-    Py_DECREF(current);
-    /* restore current exception */
-    PyErr_Restore(exc, val, tb);
-
-    /* thread switch could happen during PyErr_Restore, in that
-       case there's nothing to do except restart from scratch. */
-    if (ts_current->run_info != tstate->dict) {
-        goto green_updatecurrent_restart;
-    }
-    return 0;
-}
-
-static PyObject*
-green_statedict(PyGreenlet* g)
-{
-    while (!PyGreenlet_STARTED(g)) {
-        g = g->parent;
-        if (g == NULL) {
-            /* garbage collected greenlet in chain */
-            return NULL;
-        }
-    }
-    return g->run_info;
-}
-
-/***********************************************************/
-
-/* Some functions must not be inlined:
-   * slp_restore_state, when inlined into slp_switch might cause
-     it to restore stack over its own local variables
-   * slp_save_state, when inlined would add its own local
-     variables to the saved stack, wasting space
-   * slp_switch, cannot be inlined for obvious reasons
-   * g_initialstub, when inlined would receive a pointer into its
-     own stack frame, leading to incomplete stack save/restore
-*/
-
-#if defined(__GNUC__) && \
-    (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
-#    define GREENLET_NOINLINE_SUPPORTED
-#    define GREENLET_NOINLINE(name) __attribute__((noinline)) name
-#elif defined(_MSC_VER) && (_MSC_VER >= 1300)
-#    define GREENLET_NOINLINE_SUPPORTED
-#    define GREENLET_NOINLINE(name) __declspec(noinline) name
-#endif
-
-#ifdef GREENLET_NOINLINE_SUPPORTED
-/* add forward declarations */
-static void GREENLET_NOINLINE(slp_restore_state)(void);
-static int GREENLET_NOINLINE(slp_save_state)(char*);
-#    if !(defined(MS_WIN64) && defined(_M_X64))
-static int GREENLET_NOINLINE(slp_switch)(void);
-#    endif
-static int GREENLET_NOINLINE(g_initialstub)(void*);
-#    define GREENLET_NOINLINE_INIT() \
-        do {                         \
-        } while (0)
-#else
-/* force compiler to call functions via pointers */
-static void (*slp_restore_state)(void);
-static int (*slp_save_state)(char*);
-static int (*slp_switch)(void);
-static int (*g_initialstub)(void*);
-#    define GREENLET_NOINLINE(name) cannot_inline_##name
-#    define GREENLET_NOINLINE_INIT()                                  \
-        do {                                                          \
-            slp_restore_state = GREENLET_NOINLINE(slp_restore_state); \
-            slp_save_state = GREENLET_NOINLINE(slp_save_state);       \
-            slp_switch = GREENLET_NOINLINE(slp_switch);               \
-            g_initialstub = GREENLET_NOINLINE(g_initialstub);         \
-        } while (0)
-#endif
-
-/*
- * the following macros are spliced into the OS/compiler
- * specific code, in order to simplify maintenance.
- */
-
-#define SLP_SAVE_STATE(stackref, stsizediff) \
-    stackref += STACK_MAGIC;                 \
-    if (slp_save_state((char*)stackref))     \
-        return -1;                           \
-    if (!PyGreenlet_ACTIVE(ts_target))       \
-        return 1;                            \
-    stsizediff = ts_target->stack_start - (char*)stackref
-
-#define SLP_RESTORE_STATE() slp_restore_state()
-
-#define SLP_EVAL
-#define slp_switch GREENLET_NOINLINE(slp_switch)
-#include "slp_platformselect.h"
-#undef slp_switch
-
-#ifndef STACK_MAGIC
-#    error \
-        "greenlet needs to be ported to this platform, or taught how to detect your compiler properly."
-#endif /* !STACK_MAGIC */
-
-#ifdef EXTERNAL_ASM
-/* CCP addition: Make these functions, to be called from assembler.
- * The token include file for the given platform should enable the
- * EXTERNAL_ASM define so that this is included.
- */
-
-intptr_t
-slp_save_state_asm(intptr_t* ref)
-{
-    intptr_t diff;
-    SLP_SAVE_STATE(ref, diff);
-    return diff;
-}
-
-void
-slp_restore_state_asm(void)
-{
-    SLP_RESTORE_STATE();
-}
-
-extern int
-slp_switch(void);
-
-#endif
-
-/***********************************************************/
-
-static int
-g_save(PyGreenlet* g, char* stop)
-{
-    /* Save more of g's stack into the heap -- at least up to 'stop'
-
-       g->stack_stop |________|
-                     |        |
-                     |    __ stop       . . . . .
-                     |        |    ==>  .       .
-                     |________|          _______
-                     |        |         |       |
-                     |        |         |       |
-      g->stack_start |        |         |_______| g->stack_copy
-
-     */
-    intptr_t sz1 = g->stack_saved;
-    intptr_t sz2 = stop - g->stack_start;
-    assert(g->stack_start != NULL);
-    if (sz2 > sz1) {
-        char* c = (char*)PyMem_Realloc(g->stack_copy, sz2);
-        if (!c) {
-            PyErr_NoMemory();
-            return -1;
-        }
-        memcpy(c + sz1, g->stack_start + sz1, sz2 - sz1);
-        g->stack_copy = c;
-        g->stack_saved = sz2;
-    }
-    return 0;
-}
-
-static void GREENLET_NOINLINE(slp_restore_state)(void)
-{
-    PyGreenlet* g = ts_target;
-    PyGreenlet* owner = ts_current;
-
-#ifdef SLP_BEFORE_RESTORE_STATE
-    SLP_BEFORE_RESTORE_STATE();
-#endif
-
-    /* Restore the heap copy back into the C stack */
-    if (g->stack_saved != 0) {
-        memcpy(g->stack_start, g->stack_copy, g->stack_saved);
-        PyMem_Free(g->stack_copy);
-        g->stack_copy = NULL;
-        g->stack_saved = 0;
-    }
-    if (owner->stack_start == NULL) {
-        owner = owner->stack_prev; /* greenlet is dying, skip it */
-    }
-    while (owner && owner->stack_stop <= g->stack_stop) {
-        owner = owner->stack_prev; /* find greenlet with more stack */
-    }
-    g->stack_prev = owner;
-}
-
-static int GREENLET_NOINLINE(slp_save_state)(char* stackref)
-{
-    /* must free all the C stack up to target_stop */
-    char* target_stop = ts_target->stack_stop;
-    PyGreenlet* owner = ts_current;
-    assert(owner->stack_saved == 0);
-    if (owner->stack_start == NULL) {
-        owner = owner->stack_prev; /* not saved if dying */
-    }
-    else {
-        owner->stack_start = stackref;
-    }
-
-#ifdef SLP_BEFORE_SAVE_STATE
-    SLP_BEFORE_SAVE_STATE();
-#endif
-
-    while (owner->stack_stop < target_stop) {
-        /* ts_current is entierely within the area to free */
-        if (g_save(owner, owner->stack_stop)) {
-            return -1; /* XXX */
-        }
-        owner = owner->stack_prev;
-    }
-    if (owner != ts_target) {
-        if (g_save(owner, target_stop)) {
-            return -1; /* XXX */
-        }
-    }
-    return 0;
-}
-
-/**
-   Perform a stack switch according to some global variables
-   that must be set before calling this function. Those variables
-   are:
-
-   - ts_current: current greenlet (holds a reference)
-   - ts_target: greenlet to switch to (weak reference)
-   - ts_passaround_args: NULL if PyErr_Occurred(),
-     else a tuple of args sent to ts_target (holds a reference)
-   - ts_passaround_kwargs: switch kwargs (holds a reference)
-
-   Because the stack switch happens in this function, this function can't use
-   its own stack (local) variables, set before the switch, and then accessed after the
-   switch. Global variables beginning with ``ts__g_switchstack`` are used
-   internally instead.
-
-   On return results are passed via global variables as well:
-
-   - ts_origin: originating greenlet (holds a reference)
-   - ts_current: current greenlet (holds a reference)
-   - ts_passaround_args: NULL if PyErr_Occurred(),
-     else a tuple of args sent to ts_current (holds a reference)
-   - ts_passaround_kwargs: switch kwargs (holds a reference)
-
-   It is very important that stack switch is 'atomic', i.e. no
-   calls into other Python code allowed (except very few that
-   are safe), because global variables are very fragile.
-*/
-static int
-g_switchstack(void)
-{
-    int err;
-    { /* save state */
-        PyGreenlet* current = ts_current;
-        PyThreadState* tstate = PyThreadState_GET();
-        current->recursion_depth = tstate->recursion_depth;
-        current->top_frame = tstate->frame;
-#if GREENLET_PY37
-        current->context = tstate->context;
-#endif
-#if GREENLET_PY37
-        current->exc_info = tstate->exc_info;
-        current->exc_state = tstate->exc_state;
-#else
-        current->exc_type = tstate->exc_type;
-        current->exc_value = tstate->exc_value;
-        current->exc_traceback = tstate->exc_traceback;
-#endif
-#if GREENLET_USE_CFRAME
-        /*
-         IMPORTANT: ``cframe`` is a pointer into the STACK.
-         Thus, because the call to ``slp_switch()``
-         changes the contents of the stack, you cannot read from
-         ``ts_current->cframe`` after that call and necessarily
-         get the same values you get from reading it here. Anything
-         you need to restore from now to then must be saved
-         in a global variable (because we can't use stack variables
-         here either).
-         */
-        current->cframe = tstate->cframe;
-        ts__g_switchstack_use_tracing = tstate->cframe->use_tracing;
-#endif
-    }
-
-    err = slp_switch();
-
-    if (err < 0) { /* error */
-        PyGreenlet* current = ts_current;
-        current->top_frame = NULL;
-#if GREENLET_PY37
-        green_clear_exc(current);
-#else
-        current->exc_type = NULL;
-        current->exc_value = NULL;
-        current->exc_traceback = NULL;
-#endif
-
-        assert(ts_origin == NULL);
-        ts_target = NULL;
-    }
-    else {
-        PyGreenlet* target = ts_target;
-        PyGreenlet* origin = ts_current;
-        PyThreadState* tstate = PyThreadState_GET();
-        tstate->recursion_depth = target->recursion_depth;
-        tstate->frame = target->top_frame;
-        target->top_frame = NULL;
-
-#if GREENLET_PY37
-        tstate->context = target->context;
-        target->context = NULL;
-        /* Incrementing this value invalidates the contextvars cache,
-           which would otherwise remain valid across switches */
-        tstate->context_ver++;
-#endif
-
-#if GREENLET_PY37
-        tstate->exc_state = target->exc_state;
-        tstate->exc_info =
-            target->exc_info ? target->exc_info : &tstate->exc_state;
-#else
-        tstate->exc_type = target->exc_type;
-        tstate->exc_value = target->exc_value;
-        tstate->exc_traceback = target->exc_traceback;
-#endif
-        green_clear_exc(target);
-
-#if GREENLET_USE_CFRAME
-        tstate->cframe = target->cframe;
-        /*
-          If we were tracing, we need to keep tracing.
-          There should never be the possibility of hitting the
-          root_cframe here. See note above about why we can't
-          just copy this from ``origin->cframe->use_tracing``.
-        */
-        tstate->cframe->use_tracing = ts__g_switchstack_use_tracing;
-#endif
-
-        assert(ts_origin == NULL);
-        Py_INCREF(target);
-        ts_current = target;
-        ts_origin = origin;
-        ts_target = NULL;
-    }
-    return err;
-}
-
-static int
-g_calltrace(PyObject* tracefunc, PyObject* event, PyGreenlet* origin,
-            PyGreenlet* target)
-{
-    PyObject* retval;
-    PyObject *exc_type, *exc_val, *exc_tb;
-    PyThreadState* tstate;
-    PyErr_Fetch(&exc_type, &exc_val, &exc_tb);
-    tstate = PyThreadState_GET();
-    tstate->tracing++;
-    TSTATE_USE_TRACING(tstate) = 0;
-    retval = PyObject_CallFunction(tracefunc, "O(OO)", event, origin, target);
-    tstate->tracing--;
-    TSTATE_USE_TRACING(tstate) =
-        (tstate->tracing <= 0 &&
-         ((tstate->c_tracefunc != NULL) || (tstate->c_profilefunc != NULL)));
-    if (retval == NULL) {
-        /* In case of exceptions trace function is removed */
-        if (PyDict_GetItem(tstate->dict, ts_tracekey)) {
-            PyDict_DelItem(tstate->dict, ts_tracekey);
-        }
-        Py_XDECREF(exc_type);
-        Py_XDECREF(exc_val);
-        Py_XDECREF(exc_tb);
-        return -1;
-    }
-    else {
-        Py_DECREF(retval);
-    }
-    PyErr_Restore(exc_type, exc_val, exc_tb);
-    return 0;
-}
-
-static PyObject*
-g_switch(PyGreenlet* target, PyObject* args, PyObject* kwargs)
-{
-    /* _consumes_ a reference to the args tuple and kwargs dict,
-       and return a new tuple reference */
-    int err = 0;
-    PyObject* run_info;
-
-    /* check ts_current */
-    if (!STATE_OK) {
-        Py_XDECREF(args);
-        Py_XDECREF(kwargs);
-        return NULL;
-    }
-    run_info = green_statedict(target);
-    if (run_info == NULL || run_info != ts_current->run_info) {
-        Py_XDECREF(args);
-        Py_XDECREF(kwargs);
-        PyErr_SetString(PyExc_GreenletError,
-                        run_info ?
-                            "cannot switch to a different thread" :
-                            "cannot switch to a garbage collected greenlet");
-        return NULL;
-    }
-
-    ts_passaround_args = args;
-    ts_passaround_kwargs = kwargs;
-
-    /* find the real target by ignoring dead greenlets,
-       and if necessary starting a greenlet. */
-    while (target) {
-        if (PyGreenlet_ACTIVE(target)) {
-            ts_target = target;
-            err = g_switchstack();
-            break;
-        }
-        if (!PyGreenlet_STARTED(target)) {
-            void* dummymarker;
-            ts_target = target;
-            err = g_initialstub(&dummymarker);
-            if (err == 1) {
-                continue; /* retry the switch */
-            }
-            break;
-        }
-        target = target->parent;
-    }
-
-    /* For a very short time, immediately after the 'atomic'
-       g_switchstack() call, global variables are in a known state.
-       We need to save everything we need, before it is destroyed
-       by calls into arbitrary Python code. */
-    args = ts_passaround_args;
-    ts_passaround_args = NULL;
-    kwargs = ts_passaround_kwargs;
-    ts_passaround_kwargs = NULL;
-    if (err < 0) {
-        /* Turn switch errors into switch throws */
-        assert(ts_origin == NULL);
-        Py_CLEAR(kwargs);
-        Py_CLEAR(args);
-    }
-    else {
-        PyGreenlet* origin;
-        PyGreenlet* current;
-        PyObject* tracefunc;
-        origin = ts_origin;
-        ts_origin = NULL;
-        current = ts_current;
-        if ((tracefunc = PyDict_GetItem(current->run_info, ts_tracekey)) != NULL) {
-            Py_INCREF(tracefunc);
-            if (g_calltrace(tracefunc,
-                            args ? ts_event_switch : ts_event_throw,
-                            origin,
-                            current) < 0) {
-                /* Turn trace errors into switch throws */
-                Py_CLEAR(kwargs);
-                Py_CLEAR(args);
-            }
-            Py_DECREF(tracefunc);
-        }
-
-        Py_DECREF(origin);
-    }
-
-    /* We need to figure out what values to pass to the target greenlet
-       based on the arguments that have been passed to greenlet.switch(). If
-       switch() was just passed an arg tuple, then we'll just return that.
-       If only keyword arguments were passed, then we'll pass the keyword
-       argument dict. Otherwise, we'll create a tuple of (args, kwargs) and
-       return both. */
-    if (kwargs == NULL) {
-        return args;
-    }
-    else if (PyDict_Size(kwargs) == 0) {
-        Py_DECREF(kwargs);
-        return args;
-    }
-    else if (PySequence_Length(args) == 0) {
-        Py_DECREF(args);
-        return kwargs;
-    }
-    else {
-        PyObject* tuple = PyTuple_New(2);
-        if (tuple == NULL) {
-            Py_DECREF(args);
-            Py_DECREF(kwargs);
-            return NULL;
-        }
-        PyTuple_SET_ITEM(tuple, 0, args);
-        PyTuple_SET_ITEM(tuple, 1, kwargs);
-        return tuple;
-    }
-}
-
-static PyObject*
-g_handle_exit(PyObject* result)
-{
-    if (result == NULL && PyErr_ExceptionMatches(PyExc_GreenletExit)) {
-        /* catch and ignore GreenletExit */
-        PyObject *exc, *val, *tb;
-        PyErr_Fetch(&exc, &val, &tb);
-        if (val == NULL) {
-            Py_INCREF(Py_None);
-            val = Py_None;
-        }
-        result = val;
-        Py_DECREF(exc);
-        Py_XDECREF(tb);
-    }
-    if (result != NULL) {
-        /* package the result into a 1-tuple */
-        PyObject* r = result;
-        result = PyTuple_New(1);
-        if (result) {
-            PyTuple_SET_ITEM(result, 0, r);
-        }
-        else {
-            Py_DECREF(r);
-        }
-    }
-    return result;
-}
-
-static int GREENLET_NOINLINE(g_initialstub)(void* mark)
-{
-    int err;
-    PyObject *o, *run;
-    PyObject *exc, *val, *tb;
-    PyObject* run_info;
-    PyGreenlet* self = ts_target;
-    PyObject* args = ts_passaround_args;
-    PyObject* kwargs = ts_passaround_kwargs;
-#if GREENLET_USE_CFRAME
-    /*
-      See green_new(). This is a stack-allocated variable used
-      while *self* is in PyObject_Call().
-      We want to defer copying the state info until we're sure
-      we need it and are in a stable place to do so.
-    */
-    CFrame trace_info;
-#endif
-    /* save exception in case getattr clears it */
-    PyErr_Fetch(&exc, &val, &tb);
-    /* self.run is the object to call in the new greenlet */
-    run = PyObject_GetAttrString((PyObject*)self, "run");
-    if (run == NULL) {
-        Py_XDECREF(exc);
-        Py_XDECREF(val);
-        Py_XDECREF(tb);
-        return -1;
-    }
-    /* restore saved exception */
-    PyErr_Restore(exc, val, tb);
-
-    /* recheck the state in case getattr caused thread switches */
-    if (!STATE_OK) {
-        Py_DECREF(run);
-        return -1;
-    }
-
-    /* recheck run_info in case greenlet reparented anywhere above */
-    run_info = green_statedict(self);
-    if (run_info == NULL || run_info != ts_current->run_info) {
-        Py_DECREF(run);
-        PyErr_SetString(PyExc_GreenletError,
-                        run_info ?
-                            "cannot switch to a different thread" :
-                            "cannot switch to a garbage collected greenlet");
-        return -1;
-    }
-
-    /* by the time we got here another start could happen elsewhere,
-     * that means it should now be a regular switch
-     */
-    if (PyGreenlet_STARTED(self)) {
-        Py_DECREF(run);
-        ts_passaround_args = args;
-        ts_passaround_kwargs = kwargs;
-        return 1;
-    }
-
-#if GREENLET_USE_CFRAME
-    /* OK, we need it, we're about to switch greenlets, save the state. */
-    trace_info = *PyThreadState_GET()->cframe;
-    /* Make the target greenlet refer to the stack value. */
-    self->cframe = &trace_info;
-    /*
-      And restore the link to the previous frame so this one gets
-      unliked appropriately.
-    */
-    self->cframe->previous = &PyThreadState_GET()->root_cframe;
-#endif
-    /* start the greenlet */
-    self->stack_start = NULL;
-    self->stack_stop = (char*)mark;
-    if (ts_current->stack_start == NULL) {
-        /* ts_current is dying */
-        self->stack_prev = ts_current->stack_prev;
-    }
-    else {
-        self->stack_prev = ts_current;
-    }
-    self->top_frame = NULL;
-    green_clear_exc(self);
-    self->recursion_depth = PyThreadState_GET()->recursion_depth;
-
-    /* restore arguments in case they are clobbered */
-    ts_target = self;
-    ts_passaround_args = args;
-    ts_passaround_kwargs = kwargs;
-
-    /* perform the initial switch */
-    err = g_switchstack();
-
-    /* returns twice!
-       The 1st time with ``err == 1``: we are in the new greenlet
-       The 2nd time with ``err <= 0``: back in the caller's greenlet
-    */
-    if (err == 1) {
-        /* in the new greenlet */
-        PyGreenlet* origin;
-        PyObject* tracefunc;
-        PyObject* result;
-        PyGreenlet* parent;
-        self->stack_start = (char*)1; /* running */
-
-        /* grab origin while we still can */
-        origin = ts_origin;
-        ts_origin = NULL;
-
-        /* now use run_info to store the statedict */
-        o = self->run_info;
-        self->run_info = green_statedict(self->parent);
-        Py_INCREF(self->run_info);
-        Py_XDECREF(o);
-
-        if ((tracefunc = PyDict_GetItem(self->run_info, ts_tracekey)) != NULL) {
-            Py_INCREF(tracefunc);
-            if (g_calltrace(tracefunc,
-                            args ? ts_event_switch : ts_event_throw,
-                            origin,
-                            self) < 0) {
-                /* Turn trace errors into switch throws */
-                Py_CLEAR(kwargs);
-                Py_CLEAR(args);
-            }
-            Py_DECREF(tracefunc);
-        }
-
-        Py_DECREF(origin);
-
-        if (args == NULL) {
-            /* pending exception */
-            result = NULL;
-        }
-        else {
-            /* call g.run(*args, **kwargs) */
-            result = PyObject_Call(run, args, kwargs);
-            Py_DECREF(args);
-            Py_XDECREF(kwargs);
-        }
-        Py_DECREF(run);
-        result = g_handle_exit(result);
-
-        /* jump back to parent */
-        self->stack_start = NULL; /* dead */
-        for (parent = self->parent; parent != NULL; parent = parent->parent) {
-            result = g_switch(parent, result, NULL);
-            /* Return here means switch to parent failed,
-             * in which case we throw *current* exception
-             * to the next parent in chain.
-             */
-            assert(result == NULL);
-        }
-        /* We ran out of parents, cannot continue */
-        PyErr_WriteUnraisable((PyObject*)self);
-        Py_FatalError("greenlets cannot continue");
-    }
-    /* back in the parent */
-    if (err < 0) {
-        /* start failed badly, restore greenlet state */
-        self->stack_start = NULL;
-        self->stack_stop = NULL;
-        self->stack_prev = NULL;
-    }
-    return err;
-}
-
-/***********************************************************/
-
-static PyObject*
-green_new(PyTypeObject* type, PyObject* args, PyObject* kwds)
-{
-    PyObject* o =
-        PyBaseObject_Type.tp_new(type, ts_empty_tuple, ts_empty_dict);
-    if (o != NULL) {
-        if (!STATE_OK) {
-            Py_DECREF(o);
-            return NULL;
-        }
-        Py_INCREF(ts_current);
-        ((PyGreenlet*)o)->parent = ts_current;
-#if GREENLET_USE_CFRAME
-        /*
-          The PyThreadState->cframe pointer usually points to memory on the
-          stack, alloceted in a call into PyEval_EvalFrameDefault.
-
-          Initially, before any evaluation begins, it points to the initial
-          PyThreadState object's ``root_cframe`` object, which is statically
-          allocated for the lifetime of the thread.
-
-          A greenlet can last for longer than a call to
-          PyEval_EvalFrameDefault, so we can't set its ``cframe`` pointer to
-          be the current ``PyThreadState->cframe``; nor could we use one from
-          the greenlet parent for the same reason. Yet a further no: we can't
-          allocate one scoped to the greenlet and then destroy it when the
-          greenlet is deallocated, because inside the interpreter the CFrame
-          objects form a linked list, and that too can result in accessing
-          memory beyond its dynamic lifetime (if the greenlet doesn't actually
-          finish before it dies, its entry could still be in the list).
-
-          Using the ``root_cframe`` is problematic, though, because its
-          members are never modified by the interpreter and are set to 0,
-          meaning that its ``use_tracing`` flag is never updated. We don't
-          want to modify that value in the ``root_cframe`` ourself: it
-          *shouldn't* matter much because we should probably never get back to
-          the point where that's the only cframe on the stack; even if it did
-          matter, the major consequence of an incorrect value for
-          ``use_tracing`` is that if its true the interpreter does some extra
-          work --- however, it's just good code hygiene.
-
-          Our solution: before a greenlet runs, after its initial creation,
-          it uses the ``root_cframe`` just to have something to put there.
-          However, once the greenlet is actually switched to for the first
-          time, ``g_initialstub`` (which doesn't actually "return" while the
-          greenlet is running) stores a new CFrame on its local stack, and
-          copies the appropriate values from the currently running CFrame;
-          this is then made the CFrame for the newly-minted greenlet.
-          ``g_initialstub`` then proceeds to call ``glet.run()``, which
-          results in ``PyEval_...`` adding the CFrame to the list. Switches
-          continue as normal. Finally, when the greenlet finishes, the call to
-          ``glet.run()`` returns and the CFrame is taken out of the linked
-          list and the stack value is now unused and free to expire.
-        */
-        ((PyGreenlet*)o)->cframe = &PyThreadState_GET()->root_cframe;
-#endif
-    }
-    return o;
-}
-
-static int
-green_setrun(PyGreenlet* self, PyObject* nrun, void* c);
-static int
-green_setparent(PyGreenlet* self, PyObject* nparent, void* c);
-
-static int
-green_init(PyGreenlet* self, PyObject* args, PyObject* kwargs)
-{
-    PyObject* run = NULL;
-    PyObject* nparent = NULL;
-    static char* kwlist = {"run", "parent", 0};
-    if (!PyArg_ParseTupleAndKeywords(
-            args, kwargs, "|OO:green", kwlist, &run, &nparent)) {
-        return -1;
-    }
-
-    if (run != NULL) {
-        if (green_setrun(self, run, NULL)) {
-            return -1;
-        }
-    }
-    if (nparent != NULL && nparent != Py_None) {
-        return green_setparent(self, nparent, NULL);
-    }
-    return 0;
-}
-
-static int
-kill_greenlet(PyGreenlet* self)
-{
-    /* Cannot raise an exception to kill the greenlet if
-       it is not running in the same thread! */
-    if (self->run_info == PyThreadState_GET()->dict) {
-        /* The dying greenlet cannot be a parent of ts_current
-           because the 'parent' field chain would hold a
-           reference */
-        PyObject* result;
-        PyGreenlet* oldparent;
-        PyGreenlet* tmp;
-        if (!STATE_OK) {
-            return -1;
-        }
-        oldparent = self->parent;
-        self->parent = ts_current;
-        Py_INCREF(self->parent);
-        /* Send the greenlet a GreenletExit exception. */
-        PyErr_SetNone(PyExc_GreenletExit);
-        result = g_switch(self, NULL, NULL);
-        tmp = self->parent;
-        self->parent = oldparent;
-        Py_XDECREF(tmp);
-        if (result == NULL) {
-            return -1;
-        }
-        Py_DECREF(result);
-        return 0;
-    }
-    else {
-        /* Not the same thread! Temporarily save the greenlet
-           into its thread's ts_delkey list. */
-        PyObject* lst;
-        lst = PyDict_GetItem(self->run_info, ts_delkey);
-        if (lst == NULL) {
-            lst = PyList_New(0);
-            if (lst == NULL
-                || PyDict_SetItem(self->run_info, ts_delkey, lst) < 0) {
-                return -1;
-            }
-            /* PyDict_SetItem now holds a strong reference. PyList_New also
-               returned a fresh reference. We need to DECREF it now and let
-               the dictionary keep sole ownership. Frow now on, we're working
-               with a borrowed reference that will go away when the thread
-               dies. */
-            Py_DECREF(lst);
-        }
-        if (PyList_Append(lst, (PyObject*)self) < 0) {
-            return -1;
-        }
-        if (!STATE_OK) { /* to force ts_delkey to be reconsidered */
-            return -1;
-        }
-        return 0;
-    }
-}
-
-static int
-green_traverse(PyGreenlet* self, visitproc visit, void* arg)
-{
-    /* We must only visit referenced objects, i.e. only objects
-       Py_INCREF'ed by this greenlet (directly or indirectly):
-       - stack_prev is not visited: holds previous stack pointer, but it's not
-       referenced
-       - frames are not visited: alive greenlets are not garbage collected
-       anyway */
-    Py_VISIT((PyObject*)self->parent);
-    Py_VISIT(self->run_info);
-#if GREENLET_PY37
-    Py_VISIT(self->context);
-#endif
-#if GREENLET_PY37
-    Py_VISIT(self->exc_state.exc_type);
-    Py_VISIT(self->exc_state.exc_value);
-    Py_VISIT(self->exc_state.exc_traceback);
-#else
-    Py_VISIT(self->exc_type);
-    Py_VISIT(self->exc_value);
-    Py_VISIT(self->exc_traceback);
-#endif
-    Py_VISIT(self->dict);
-    return 0;
-}
-
-static int
-green_is_gc(PyGreenlet* self)
-{
-    /* Main greenlet can be garbage collected since it can only
-       become unreachable if the underlying thread exited.
-       Active greenlet cannot be garbage collected, however. */
-    if (PyGreenlet_MAIN(self) || !PyGreenlet_ACTIVE(self)) {
-        return 1;
-    }
-    return 0;
-}
-
-static int
-green_clear(PyGreenlet* self)
-{
-    /* Greenlet is only cleared if it is about to be collected.
-       Since active greenlets are not garbage collectable, we can
-       be sure that, even if they are deallocated during clear,
-       nothing they reference is in unreachable or finalizers,
-       so even if it switches we are relatively safe. */
-    Py_CLEAR(self->parent);
-    Py_CLEAR(self->run_info);
-#if GREENLET_PY37
-    Py_CLEAR(self->context);
-#endif
-#if GREENLET_PY37
-    Py_CLEAR(self->exc_state.exc_type);
-    Py_CLEAR(self->exc_state.exc_value);
-    Py_CLEAR(self->exc_state.exc_traceback);
-#else
-    Py_CLEAR(self->exc_type);
-    Py_CLEAR(self->exc_value);
-    Py_CLEAR(self->exc_traceback);
-#endif
-    Py_CLEAR(self->dict);
-    return 0;
-}
-
-static void
-green_dealloc(PyGreenlet* self)
-{
-    PyObject *error_type, *error_value, *error_traceback;
-    Py_ssize_t refcnt;
-
-    PyObject_GC_UnTrack(self);
-
-    if (PyGreenlet_ACTIVE(self) && self->run_info != NULL &&
-        !PyGreenlet_MAIN(self)) {
-        /* Hacks hacks hacks copied from instance_dealloc() */
-        /* Temporarily resurrect the greenlet. */
-        assert(Py_REFCNT(self) == 0);
-        Py_SET_REFCNT(self, 1);
-        /* Save the current exception, if any. */
-        PyErr_Fetch(&error_type, &error_value, &error_traceback);
-        if (kill_greenlet(self) < 0) {
-            PyErr_WriteUnraisable((PyObject*)self);
-            /* XXX what else should we do? */
-        }
-        /* Check for no resurrection must be done while we keep
-         * our internal reference, otherwise PyFile_WriteObject
-         * causes recursion if using Py_INCREF/Py_DECREF
-         */
-        if (Py_REFCNT(self) == 1 && PyGreenlet_ACTIVE(self)) {
-            /* Not resurrected, but still not dead!
-               XXX what else should we do? we complain. */
-            PyObject* f = PySys_GetObject("stderr");
-            Py_INCREF(self); /* leak! */
-            if (f != NULL) {
-                PyFile_WriteString("GreenletExit did not kill ", f);
-                PyFile_WriteObject((PyObject*)self, f, 0);
-                PyFile_WriteString("\n", f);
-            }
-        }
-        /* Restore the saved exception. */
-        PyErr_Restore(error_type, error_value, error_traceback);
-        /* Undo the temporary resurrection; can't use DECREF here,
-         * it would cause a recursive call.
-         */
-        assert(Py_REFCNT(self) > 0);
-
-        refcnt = Py_REFCNT(self) - 1;
-        Py_SET_REFCNT(self, refcnt);
-        if (refcnt != 0) {
-            /* Resurrected! */
-            _Py_NewReference((PyObject*)self);
-            Py_SET_REFCNT(self, refcnt);
-            /* Better to use tp_finalizer slot (PEP 442)
-             * and call ``PyObject_CallFinalizerFromDealloc``,
-             * but that's only supported in Python 3.4+; see
-             * Modules/_io/iobase.c for an example.
-             *
-             * The following approach is copied from iobase.c in CPython 2.7.
-             * (along with much of this function in general). Here's their
-             * comment:
-             *
-             * When called from a heap type's dealloc, the type will be
-             * decref'ed on return (see e.g. subtype_dealloc in typeobject.c). */
-            if (PyType_HasFeature(Py_TYPE(self), Py_TPFLAGS_HEAPTYPE)) {
-                Py_INCREF(Py_TYPE(self));
-            }
-
-            PyObject_GC_Track((PyObject*)self);
-
-            _Py_DEC_REFTOTAL;
-#ifdef COUNT_ALLOCS
-            --Py_TYPE(self)->tp_frees;
-            --Py_TYPE(self)->tp_allocs;
-#endif /* COUNT_ALLOCS */
-            return;
-        }
-    }
-    if (self->weakreflist != NULL) {
-        PyObject_ClearWeakRefs((PyObject*)self);
-    }
-    Py_CLEAR(self->parent);
-    Py_CLEAR(self->run_info);
-#if GREENLET_PY37
-    Py_CLEAR(self->context);
-#endif
-#if GREENLET_PY37
-    Py_CLEAR(self->exc_state.exc_type);
-    Py_CLEAR(self->exc_state.exc_value);
-    Py_CLEAR(self->exc_state.exc_traceback);
-#else
-    Py_CLEAR(self->exc_type);
-    Py_CLEAR(self->exc_value);
-    Py_CLEAR(self->exc_traceback);
-#endif
-    Py_CLEAR(self->dict);
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-static PyObject*
-single_result(PyObject* results)
-{
-    if (results != NULL && PyTuple_Check(results) &&
-        PyTuple_GET_SIZE(results) == 1) {
-        PyObject* result = PyTuple_GET_ITEM(results, 0);
-        Py_INCREF(result);
-        Py_DECREF(results);
-        return result;
-    }
-    else {
-        return results;
-    }
-}
-
-static PyObject*
-throw_greenlet(PyGreenlet* self, PyObject* typ, PyObject* val, PyObject* tb)
-{
-    /* Note: _consumes_ a reference to typ, val, tb */
-    PyObject* result = NULL;
-    PyErr_Restore(typ, val, tb);
-    if (PyGreenlet_STARTED(self) && !PyGreenlet_ACTIVE(self)) {
-        /* dead greenlet: turn GreenletExit into a regular return */
-        result = g_handle_exit(result);
-    }
-    return single_result(g_switch(self, result, NULL));
-}
-
-PyDoc_STRVAR(
-    green_switch_doc,
-    "switch(*args, **kwargs)\n"
-    "\n"
-    "Switch execution to this greenlet.\n"
-    "\n"
-    "If this greenlet has never been run, then this greenlet\n"
-    "will be switched to using the body of ``self.run(*args, **kwargs)``.\n"
-    "\n"
-    "If the greenlet is active (has been run, but was switch()'ed\n"
-    "out before leaving its run function), then this greenlet will\n"
-    "be resumed and the return value to its switch call will be\n"
-    "None if no arguments are given, the given argument if one\n"
-    "argument is given, or the args tuple and keyword args dict if\n"
-    "multiple arguments are given.\n"
-    "\n"
-    "If the greenlet is dead, or is the current greenlet then this\n"
-    "function will simply return the arguments using the same rules as\n"
-    "above.\n");
-
-static PyObject*
-green_switch(PyGreenlet* self, PyObject* args, PyObject* kwargs)
-{
-    Py_INCREF(args);
-    Py_XINCREF(kwargs);
-    return single_result(g_switch(self, args, kwargs));
-}
-
-PyDoc_STRVAR(
-    green_throw_doc,
-    "Switches execution to this greenlet, but immediately raises the\n"
-    "given exception in this greenlet.  If no argument is provided, the "
-    "exception\n"
-    "defaults to `greenlet.GreenletExit`.  The normal exception\n"
-    "propagation rules apply, as described for `switch`.  Note that calling "
-    "this\n"
-    "method is almost equivalent to the following::\n"
-    "\n"
-    "    def raiser():\n"
-    "        raise typ, val, tb\n"
-    "    g_raiser = greenlet(raiser, parent=g)\n"
-    "    g_raiser.switch()\n"
-    "\n"
-    "except that this trick does not work for the\n"
-    "`greenlet.GreenletExit` exception, which would not propagate\n"
-    "from ``g_raiser`` to ``g``.\n");
-
-static PyObject*
-green_throw(PyGreenlet* self, PyObject* args)
-{
-    PyObject* typ = PyExc_GreenletExit;
-    PyObject* val = NULL;
-    PyObject* tb = NULL;
-
-    if (!PyArg_ParseTuple(args, "|OOO:throw", &typ, &val, &tb)) {
-        return NULL;
-    }
-
-    /* First, check the traceback argument, replacing None, with NULL */
-    if (tb == Py_None) {
-        tb = NULL;
-    }
-    else if (tb != NULL && !PyTraceBack_Check(tb)) {
-        PyErr_SetString(PyExc_TypeError,
-                        "throw() third argument must be a traceback object");
-        return NULL;
-    }
-
-    Py_INCREF(typ);
-    Py_XINCREF(val);
-    Py_XINCREF(tb);
-
-    if (PyExceptionClass_Check(typ)) {
-        PyErr_NormalizeException(&typ, &val, &tb);
-    }
-    else if (PyExceptionInstance_Check(typ)) {
-        /* Raising an instance. The value should be a dummy. */
-        if (val && val != Py_None) {
-            PyErr_SetString(
-                PyExc_TypeError,
-                "instance exception may not have a separate value");
-            goto failed_throw;
-        }
-        else {
-            /* Normalize to raise <class>, <instance> */
-            Py_XDECREF(val);
-            val = typ;
-            typ = PyExceptionInstance_Class(typ);
-            Py_INCREF(typ);
-        }
-    }
-    else {
-        /* Not something you can raise. throw() fails. */
-        PyErr_Format(PyExc_TypeError,
-                     "exceptions must be classes, or instances, not %s",
-                     Py_TYPE(typ)->tp_name);
-        goto failed_throw;
-    }
-
-    return throw_greenlet(self, typ, val, tb);
-
-failed_throw:
-    /* Didn't use our arguments, so restore their original refcounts */
-    Py_DECREF(typ);
-    Py_XDECREF(val);
-    Py_XDECREF(tb);
-    return NULL;
-}
-
-static int
-green_bool(PyGreenlet* self)
-{
-    return PyGreenlet_ACTIVE(self);
-}
-
-static PyObject*
-green_getdict(PyGreenlet* self, void* c)
-{
-    if (self->dict == NULL) {
-        self->dict = PyDict_New();
-        if (self->dict == NULL) {
-            return NULL;
-        }
-    }
-    Py_INCREF(self->dict);
-    return self->dict;
-}
-
-static int
-green_setdict(PyGreenlet* self, PyObject* val, void* c)
-{
-    PyObject* tmp;
-
-    if (val == NULL) {
-        PyErr_SetString(PyExc_TypeError, "__dict__ may not be deleted");
-        return -1;
-    }
-    if (!PyDict_Check(val)) {
-        PyErr_SetString(PyExc_TypeError, "__dict__ must be a dictionary");
-        return -1;
-    }
-    tmp = self->dict;
-    Py_INCREF(val);
-    self->dict = val;
-    Py_XDECREF(tmp);
-    return 0;
-}
-
-static int
-_green_not_dead(PyGreenlet* self)
-{
-    return PyGreenlet_ACTIVE(self) || !PyGreenlet_STARTED(self);
-}
-
-
-static PyObject*
-green_getdead(PyGreenlet* self, void* c)
-{
-    if (_green_not_dead(self)) {
-        Py_RETURN_FALSE;
-    }
-    else {
-        Py_RETURN_TRUE;
-    }
-}
-
-static PyObject*
-green_get_stack_saved(PyGreenlet* self, void* c)
-{
-    return PyLong_FromSsize_t(self->stack_saved);
-}
-
-static PyObject*
-green_getrun(PyGreenlet* self, void* c)
-{
-    if (PyGreenlet_STARTED(self) || self->run_info == NULL) {
-        PyErr_SetString(PyExc_AttributeError, "run");
-        return NULL;
-    }
-    Py_INCREF(self->run_info);
-    return self->run_info;
-}
-
-static int
-green_setrun(PyGreenlet* self, PyObject* nrun, void* c)
-{
-    PyObject* o;
-    if (PyGreenlet_STARTED(self)) {
-        PyErr_SetString(PyExc_AttributeError,
-                        "run cannot be set "
-                        "after the start of the greenlet");
-        return -1;
-    }
-    o = self->run_info;
-    self->run_info = nrun;
-    Py_XINCREF(nrun);
-    Py_XDECREF(o);
-    return 0;
-}
-
-static PyObject*
-green_getparent(PyGreenlet* self, void* c)
-{
-    PyObject* result = self->parent ? (PyObject*)self->parent : Py_None;
-    Py_INCREF(result);
-    return result;
-}
-
-static int
-green_setparent(PyGreenlet* self, PyObject* nparent, void* c)
-{
-    PyGreenlet* p;
-    PyObject* run_info = NULL;
-    if (nparent == NULL) {
-        PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
-        return -1;
-    }
-    if (!PyGreenlet_Check(nparent)) {
-        PyErr_SetString(PyExc_TypeError, "parent must be a greenlet");
-        return -1;
-    }
-    for (p = (PyGreenlet*)nparent; p; p = p->parent) {
-        if (p == self) {
-            PyErr_SetString(PyExc_ValueError, "cyclic parent chain");
-            return -1;
-        }
-        run_info = PyGreenlet_ACTIVE(p) ? p->run_info : NULL;
-    }
-    if (run_info == NULL) {
-        PyErr_SetString(PyExc_ValueError,
-                        "parent must not be garbage collected");
-        return -1;
-    }
-    if (PyGreenlet_STARTED(self) && self->run_info != run_info) {
-        PyErr_SetString(PyExc_ValueError,
-                        "parent cannot be on a different thread");
-        return -1;
-    }
-    p = self->parent;
-    self->parent = (PyGreenlet*)nparent;
-    Py_INCREF(nparent);
-    Py_XDECREF(p);
-    return 0;
-}
-
-#ifdef Py_CONTEXT_H
-#    define GREENLET_NO_CONTEXTVARS_REASON "This build of greenlet"
-#else
-#    define GREENLET_NO_CONTEXTVARS_REASON "This Python interpreter"
-#endif
-
-static PyObject*
-green_getcontext(PyGreenlet* self, void* c)
-{
-#if GREENLET_PY37
-    PyThreadState* tstate = PyThreadState_GET();
-    PyObject* result;
-
-    if (!STATE_OK) {
-        return NULL;
-    }
-    if (PyGreenlet_ACTIVE(self) && self->top_frame == NULL) {
-        /* Currently running greenlet: context is stored in the thread state,
-           not the greenlet object. */
-        if (self == ts_current) {
-            result = tstate->context;
-        }
-        else {
-            PyErr_SetString(PyExc_ValueError,
-                            "cannot get context of a "
-                            "greenlet that is running in a different thread");
-            return NULL;
-        }
-    }
-    else {
-        /* Greenlet is not running: just return context. */
-        result = self->context;
-    }
-    if (result == NULL) {
-        result = Py_None;
-    }
-    Py_INCREF(result);
-    return result;
-#else
-    PyErr_SetString(PyExc_AttributeError,
-                    GREENLET_NO_CONTEXTVARS_REASON
-                    " does not support context variables");
-    return NULL;
-#endif
-}
-
-static int
-green_setcontext(PyGreenlet* self, PyObject* nctx, void* c)
-{
-#if GREENLET_PY37
-    PyThreadState* tstate;
-    PyObject* octx = NULL;
-    if (!STATE_OK) {
-        return -1;
-    }
-    if (nctx == NULL) {
-        PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
-        return -1;
-    }
-    if (nctx == Py_None) {
-        /* "Empty context" is stored as NULL, not None. */
-        nctx = NULL;
-    }
-    else if (!PyContext_CheckExact(nctx)) {
-        PyErr_SetString(PyExc_TypeError,
-                        "greenlet context must be a "
-                        "contextvars.Context or None");
-        return -1;
-    }
-    tstate = PyThreadState_GET();
-    if (PyGreenlet_ACTIVE(self) && self->top_frame == NULL) {
-        /* Currently running greenlet: context is stored in the thread state,
-           not the greenlet object. */
-        if (self == ts_current) {
-            octx = tstate->context;
-            tstate->context = nctx;
-            tstate->context_ver++;
-            Py_XINCREF(nctx);
-        }
-        else {
-            PyErr_SetString(PyExc_ValueError,
-                            "cannot set context of a "
-                            "greenlet that is running in a different thread");
-            return -1;
-        }
-    }
-    else {
-        /* Greenlet is not running: just set context. */
-        octx = self->context;
-        self->context = nctx;
-        Py_XINCREF(nctx);
-    }
-    Py_XDECREF(octx);
-    return 0;
-#else
-    PyErr_SetString(PyExc_AttributeError,
-                    GREENLET_NO_CONTEXTVARS_REASON
-                    " does not support context variables");
-    return -1;
-#endif
-}
-
-#undef GREENLET_NO_CONTEXTVARS_REASON
-
-static PyObject*
-green_getframe(PyGreenlet* self, void* c)
-{
-    PyObject* result = self->top_frame ? (PyObject*)self->top_frame : Py_None;
-    Py_INCREF(result);
-    return result;
-}
-
-static PyObject*
-green_getstate(PyGreenlet* self)
-{
-    PyErr_Format(PyExc_TypeError,
-                 "cannot serialize '%s' object",
-                 Py_TYPE(self)->tp_name);
-    return NULL;
-}
-
-static PyObject*
-green_repr(PyGreenlet* self)
-{
-    /*
-      Return a string like
-      <greenlet.greenlet at 0xdeadbeef currentactive started|dead main>
-
-      The handling of greenlets across threads is not super good.
-      We mostly use the internal definitions of these terms, but they
-      generally should make sense to users as well.
-     */
-    PyObject* result;
-    int never_started = !PyGreenlet_STARTED(self) && !PyGreenlet_ACTIVE(self);
-
-    if (!STATE_OK) {
-        return NULL;
-    }
-
-#if PY_MAJOR_VERSION >= 3
-# define GNative_FromFormat PyUnicode_FromFormat
-#else
-# define GNative_FromFormat PyString_FromFormat
-#endif
-
-    if (_green_not_dead(self)) {
-        /* XXX: The otid= is almost useless becasue you can't correlate it to
-         any thread identifier exposed to Python. We could use
-         PyThreadState_GET()->thread_id, but we'd need to save that in the
-         greenlet, or save the whole PyThreadState object itself.
-
-         As it stands, its only useful for identifying greenlets from the same thread.
-        */
-        result = GNative_FromFormat(
-            "<%s object at %p (otid=%p)%s%s%s%s>",
-            Py_TYPE(self)->tp_name,
-            self,
-            self->run_info,
-            ts_current == self
-                ? " current"
-                : (PyGreenlet_STARTED(self) ? " suspended" : ""),
-            PyGreenlet_ACTIVE(self) ? " active" : "",
-            never_started ? " pending" : " started",
-            PyGreenlet_MAIN(self) ? " main" : ""
-        );
-    }
-    else {
-        /* main greenlets never really appear dead. */
-        result = GNative_FromFormat(
-            "<%s object at %p (otid=%p) dead>",
-            Py_TYPE(self)->tp_name,
-            self,
-            self->run_info
-            );
-    }
-#undef GNative_FromFormat
-
-    return result;
-}
-
-/*****************************************************************************
- * C interface
- *
- * These are exported using the CObject API
- */
-
-static PyGreenlet*
-PyGreenlet_GetCurrent(void)
-{
-    if (!STATE_OK) {
-        return NULL;
-    }
-    Py_INCREF(ts_current);
-    return ts_current;
-}
-
-static int
-PyGreenlet_SetParent(PyGreenlet* g, PyGreenlet* nparent)
-{
-    if (!PyGreenlet_Check(g)) {
-        PyErr_SetString(PyExc_TypeError, "parent must be a greenlet");
-        return -1;
-    }
-
-    return green_setparent((PyGreenlet*)g, (PyObject*)nparent, NULL);
-}
-
-static PyGreenlet*
-PyGreenlet_New(PyObject* run, PyGreenlet* parent)
-{
-    /* XXX: Why doesn't this call green_new()? There's some duplicate
-     code. */
-    PyGreenlet* g = NULL;
-    g = (PyGreenlet*)PyType_GenericAlloc(&PyGreenlet_Type, 0);
-    if (g == NULL) {
-        return NULL;
-    }
-
-    if (run != NULL) {
-        Py_INCREF(run);
-        g->run_info = run;
-    }
-
-    if (parent != NULL) {
-        if (PyGreenlet_SetParent(g, parent)) {
-            Py_DECREF(g);
-            return NULL;
-        }
-    }
-    else {
-        if ((g->parent = PyGreenlet_GetCurrent()) == NULL) {
-            Py_DECREF(g);
-            return NULL;
-        }
-    }
-#if GREENLET_USE_CFRAME
-    g->cframe = &PyThreadState_GET()->root_cframe;
-#endif
-    return g;
-}
-
-static PyObject*
-PyGreenlet_Switch(PyGreenlet* g, PyObject* args, PyObject* kwargs)
-{
-    PyGreenlet* self = (PyGreenlet*)g;
-
-    if (!PyGreenlet_Check(self)) {
-        PyErr_BadArgument();
-        return NULL;
-    }
-
-    if (args == NULL) {
-        args = Py_BuildValue("()");
-    }
-    else {
-        Py_INCREF(args);
-    }
-
-    if (kwargs != NULL && PyDict_Check(kwargs)) {
-        Py_INCREF(kwargs);
-    }
-    else {
-        kwargs = NULL;
-    }
-
-    return single_result(g_switch(self, args, kwargs));
-}
-
-static PyObject*
-PyGreenlet_Throw(PyGreenlet* self, PyObject* typ, PyObject* val, PyObject* tb)
-{
-    if (!PyGreenlet_Check(self)) {
-        PyErr_BadArgument();
-        return NULL;
-    }
-    Py_INCREF(typ);
-    Py_XINCREF(val);
-    Py_XINCREF(tb);
-    return throw_greenlet(self, typ, val, tb);
-}
-
-/** End C API ****************************************************************/
-
-static PyMethodDef green_methods = {
-    {"switch",
-     (PyCFunction)green_switch,
-     METH_VARARGS | METH_KEYWORDS,
-     green_switch_doc},
-    {"throw", (PyCFunction)green_throw, METH_VARARGS, green_throw_doc},
-    {"__getstate__", (PyCFunction)green_getstate, METH_NOARGS, NULL},
-    {NULL, NULL} /* sentinel */
-};
-
-static PyGetSetDef green_getsets = {
-    {"__dict__", (getter)green_getdict, (setter)green_setdict, /*XXX*/ NULL},
-    {"run", (getter)green_getrun, (setter)green_setrun, /*XXX*/ NULL},
-    {"parent", (getter)green_getparent, (setter)green_setparent, /*XXX*/ NULL},
-    {"gr_frame", (getter)green_getframe, NULL, /*XXX*/ NULL},
-    {"gr_context",
-     (getter)green_getcontext,
-     (setter)green_setcontext,
-     /*XXX*/ NULL},
-    {"dead", (getter)green_getdead, NULL, /*XXX*/ NULL},
-    {"_stack_saved", (getter)green_get_stack_saved, NULL, /*XXX*/ NULL},
-    {NULL}};
-
-static PyNumberMethods green_as_number = {
-    NULL, /* nb_add */
-    NULL, /* nb_subtract */
-    NULL, /* nb_multiply */
-#if PY_MAJOR_VERSION < 3
-    NULL, /* nb_divide */
-#endif
-    NULL,                /* nb_remainder */
-    NULL,                /* nb_divmod */
-    NULL,                /* nb_power */
-    NULL,                /* nb_negative */
-    NULL,                /* nb_positive */
-    NULL,                /* nb_absolute */
-    (inquiry)green_bool, /* nb_bool */
-};
-
-PyTypeObject PyGreenlet_Type = {
-    PyVarObject_HEAD_INIT(NULL, 0)
-    "greenlet.greenlet", /* tp_name */
-    sizeof(PyGreenlet),  /* tp_basicsize */
-    0,                   /* tp_itemsize */
-    /* methods */
-    (destructor)green_dealloc, /* tp_dealloc */
-    0,                         /* tp_print */
-    0,                         /* tp_getattr */
-    0,                         /* tp_setattr */
-    0,                         /* tp_compare */
-    (reprfunc)green_repr,      /* tp_repr */
-    &green_as_number,          /* tp_as _number*/
-    0,                         /* tp_as _sequence*/
-    0,                         /* tp_as _mapping*/
-    0,                         /* tp_hash */
-    0,                         /* tp_call */
-    0,                         /* tp_str */
-    0,                         /* tp_getattro */
-    0,                         /* tp_setattro */
-    0,                         /* tp_as_buffer*/
-    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE |
-        GREENLET_GC_FLAGS, /* tp_flags */
-    "greenlet(run=None, parent=None) -> greenlet\n\n"
-    "Creates a new greenlet object (without running it).\n\n"
-    " - *run* -- The callable to invoke.\n"
-    " - *parent* -- The parent greenlet. The default is the current "
-    "greenlet.",                        /* tp_doc */
-    (traverseproc)GREENLET_tp_traverse, /* tp_traverse */
-    (inquiry)GREENLET_tp_clear,         /* tp_clear */
-    0,                                  /* tp_richcompare */
-    offsetof(PyGreenlet, weakreflist),  /* tp_weaklistoffset */
-    0,                                  /* tp_iter */
-    0,                                  /* tp_iternext */
-    green_methods,                      /* tp_methods */
-    0,                                  /* tp_members */
-    green_getsets,                      /* tp_getset */
-    0,                                  /* tp_base */
-    0,                                  /* tp_dict */
-    0,                                  /* tp_descr_get */
-    0,                                  /* tp_descr_set */
-    offsetof(PyGreenlet, dict),         /* tp_dictoffset */
-    (initproc)green_init,               /* tp_init */
-    GREENLET_tp_alloc,                  /* tp_alloc */
-    green_new,                          /* tp_new */
-    GREENLET_tp_free,                   /* tp_free */
-    (inquiry)GREENLET_tp_is_gc,         /* tp_is_gc */
-};
-
-PyDoc_STRVAR(mod_getcurrent_doc,
-             "getcurrent() -> greenlet\n"
-             "\n"
-             "Returns the current greenlet (i.e. the one which called this "
-             "function).\n");
-
-static PyObject*
-mod_getcurrent(PyObject* self)
-{
-    if (!STATE_OK) {
-        return NULL;
-    }
-    Py_INCREF(ts_current);
-    return (PyObject*)ts_current;
-}
-
-PyDoc_STRVAR(mod_settrace_doc,
-             "settrace(callback) -> object\n"
-             "\n"
-             "Sets a new tracing function and returns the previous one.\n");
-static PyObject*
-mod_settrace(PyObject* self, PyObject* args)
-{
-    int err;
-    PyObject* previous;
-    PyObject* tracefunc;
-    PyGreenlet* current;
-    if (!PyArg_ParseTuple(args, "O", &tracefunc)) {
-        return NULL;
-    }
-    if (!STATE_OK) {
-        return NULL;
-    }
-    current = ts_current;
-    previous = PyDict_GetItem(current->run_info, ts_tracekey);
-    if (previous == NULL) {
-        previous = Py_None;
-    }
-    Py_INCREF(previous);
-    if (tracefunc == Py_None) {
-        err = previous != Py_None ?
-                  PyDict_DelItem(current->run_info, ts_tracekey) :
-                  0;
-    }
-    else {
-        err = PyDict_SetItem(current->run_info, ts_tracekey, tracefunc);
-    }
-    if (err < 0) {
-        Py_CLEAR(previous);
-    }
-    return previous;
-}
-
-PyDoc_STRVAR(mod_gettrace_doc,
-             "gettrace() -> object\n"
-             "\n"
-             "Returns the currently set tracing function, or None.\n");
-
-static PyObject*
-mod_gettrace(PyObject* self)
-{
-    PyObject* tracefunc;
-    if (!STATE_OK) {
-        return NULL;
-    }
-    tracefunc = PyDict_GetItem(ts_current->run_info, ts_tracekey);
-    if (tracefunc == NULL) {
-        tracefunc = Py_None;
-    }
-    Py_INCREF(tracefunc);
-    return tracefunc;
-}
-
-static PyMethodDef GreenMethods = {
-    {"getcurrent",
-     (PyCFunction)mod_getcurrent,
-     METH_NOARGS,
-     mod_getcurrent_doc},
-    {"settrace", (PyCFunction)mod_settrace, METH_VARARGS, mod_settrace_doc},
-    {"gettrace", (PyCFunction)mod_gettrace, METH_NOARGS, mod_gettrace_doc},
-    {NULL, NULL} /* Sentinel */
-};
-
-static char* copy_on_greentype = {
-    "getcurrent", "error", "GreenletExit", "settrace", "gettrace", NULL};
-
-#if PY_MAJOR_VERSION >= 3
-#    define INITERROR return NULL
-
-static struct PyModuleDef greenlet_module_def = {
-    PyModuleDef_HEAD_INIT,
-    "greenlet._greenlet",
-    NULL,
-    -1,
-    GreenMethods,
-};
-
-PyMODINIT_FUNC
-PyInit__greenlet(void)
-#else
-#    define INITERROR return
-
-PyMODINIT_FUNC
-init_greenlet(void)
-#endif
-{
-    PyObject* m = NULL;
-    char** p = NULL;
-    PyObject* c_api_object;
-    static void* _PyGreenlet_APIPyGreenlet_API_pointers;
-
-    GREENLET_NOINLINE_INIT();
-
-#if PY_MAJOR_VERSION >= 3
-    m = PyModule_Create(&greenlet_module_def);
-#else
-    m = Py_InitModule("greenlet._greenlet", GreenMethods);
-#endif
-    if (m == NULL) {
-        INITERROR;
-    }
-
-#if PY_MAJOR_VERSION >= 3
-#    define Greenlet_Intern PyUnicode_InternFromString
-#else
-#    define Greenlet_Intern PyString_InternFromString
-#endif
-    ts_curkey = Greenlet_Intern("__greenlet_ts_curkey");
-    ts_delkey = Greenlet_Intern("__greenlet_ts_delkey");
-    ts_tracekey = Greenlet_Intern("__greenlet_ts_tracekey");
-    ts_event_switch = Greenlet_Intern("switch");
-    ts_event_throw = Greenlet_Intern("throw");
-#undef Greenlet_Intern
-
-    if (ts_curkey == NULL || ts_delkey == NULL) {
-        INITERROR;
-    }
-    if (PyType_Ready(&PyGreenlet_Type) < 0) {
-        INITERROR;
-    }
-    PyExc_GreenletError = PyErr_NewException("greenlet.error", NULL, NULL);
-    if (PyExc_GreenletError == NULL) {
-        INITERROR;
-    }
-    PyExc_GreenletExit =
-        PyErr_NewException("greenlet.GreenletExit", PyExc_BaseException, NULL);
-    if (PyExc_GreenletExit == NULL) {
-        INITERROR;
-    }
-
-    ts_empty_tuple = PyTuple_New(0);
-    if (ts_empty_tuple == NULL) {
-        INITERROR;
-    }
-
-    ts_empty_dict = PyDict_New();
-    if (ts_empty_dict == NULL) {
-        INITERROR;
-    }
-
-    ts_current = green_create_main();
-    if (ts_current == NULL) {
-        INITERROR;
-    }
-
-    Py_INCREF(&PyGreenlet_Type);
-    PyModule_AddObject(m, "greenlet", (PyObject*)&PyGreenlet_Type);
-    Py_INCREF(PyExc_GreenletError);
-    PyModule_AddObject(m, "error", PyExc_GreenletError);
-    Py_INCREF(PyExc_GreenletExit);
-    PyModule_AddObject(m, "GreenletExit", PyExc_GreenletExit);
-
-    PyModule_AddObject(m, "GREENLET_USE_GC", PyBool_FromLong(1));
-    PyModule_AddObject(m, "GREENLET_USE_TRACING", PyBool_FromLong(1));
-    PyModule_AddObject(
-        m, "GREENLET_USE_CONTEXT_VARS", PyBool_FromLong(GREENLET_PY37));
-
-    /* also publish module-level data as attributes of the greentype. */
-    /* XXX: Why? */
-    for (p = copy_on_greentype; *p; p++) {
-        PyObject* o = PyObject_GetAttrString(m, *p);
-        if (!o) {
-            continue;
-        }
-        PyDict_SetItemString(PyGreenlet_Type.tp_dict, *p, o);
-        Py_DECREF(o);
-    }
-
-    /*
-     * Expose C API
-     */
-
-    /* types */
-    _PyGreenlet_APIPyGreenlet_Type_NUM = (void*)&PyGreenlet_Type;
-
-    /* exceptions */
-    _PyGreenlet_APIPyExc_GreenletError_NUM = (void*)PyExc_GreenletError;
-    _PyGreenlet_APIPyExc_GreenletExit_NUM = (void*)PyExc_GreenletExit;
-
-    /* methods */
-    _PyGreenlet_APIPyGreenlet_New_NUM = (void*)PyGreenlet_New;
-    _PyGreenlet_APIPyGreenlet_GetCurrent_NUM = (void*)PyGreenlet_GetCurrent;
-    _PyGreenlet_APIPyGreenlet_Throw_NUM = (void*)PyGreenlet_Throw;
-    _PyGreenlet_APIPyGreenlet_Switch_NUM = (void*)PyGreenlet_Switch;
-    _PyGreenlet_APIPyGreenlet_SetParent_NUM = (void*)PyGreenlet_SetParent;
-
-    /* XXX: Note that our module name is ``greenlet._greenlet``, but for
-       backwards compatibility with existing C code, we need the _C_API to
-       be directly in greenlet.
-    */
-    c_api_object =
-        PyCapsule_New((void*)_PyGreenlet_API, "greenlet._C_API", NULL);
-    if (c_api_object != NULL) {
-        PyModule_AddObject(m, "_C_API", c_api_object);
-    }
-
-#if PY_MAJOR_VERSION >= 3
-    return m;
-#endif
-}
-
-#ifdef __clang__
-#    pragma clang diagnostic pop
-#endif

_service:tar_scm:greenlet-1.1.2.tar.gz/.github/workflows/tests.yml -> _service:tar_scm:greenlet-2.0.2.tar.gz/.github/workflows/tests.yml Changed

@@ -1,6 +1,6 @@
 name: tests
 
-on: push, pull_request
+on: push, pull_request, workflow_dispatch
 
 env:
   PYTHONHASHSEED: 1042466059
@@ -8,6 +8,7 @@
   PYTHONUNBUFFERED: 1
   PYTHONDONTWRITEBYTECODE: 1
   PYTHONDEVMODE: 1
+  PYTHONFAULTHANDLER: 1
   PIP_UPGRADE_STRATEGY: eager
   # Don't get warnings about Python 2 support being deprecated. We
   # know. The env var works for pip 20.
@@ -24,45 +25,61 @@
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        python-version: 2.7, 3.5, 3.6, 3.7, 3.8, 3.9, 3.10.0-rc.1
-        os: ubuntu-latest, macos-latest
+        python-version: 2.7, 3.5, 3.6, 3.7, 3.8, 3.9, "3.10", "3.11"
+        # Jan 2023: We have pinned back from ubuntu-latest (which is
+        # now ubuntu 22.04) because older Python versions like
+        # 3.5, 3.6 and presumably 2.7 are not available in it.
+        os: ubuntu-20.04, macos-latest
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
     - name: Set up Python
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v4
       with:
         python-version: ${{ matrix.python-version }}
-    - name: Pip cache
-      uses: actions/cache@v2
-      with:
-        path: ~/.cache/pip
-        key: ${{ runner.os }}-pip-${{ hashFiles('setup.*') }}
-        restore-keys: |
-          ${{ runner.os }}-pip-
+        cache: 'pip'
+        cache-dependency-path: setup.py
     - name: Install dependencies
       run: |
         python -m pip install -U pip setuptools wheel
         python -m pip install -U twine
-    - name: Install greenlet
+    - name: Install greenlet (non-Mac)
+      if: ${{ ! startsWith(runner.os, 'Mac') }}
       run: |
         python setup.py bdist_wheel
         python -m pip install -U -e ".test,docs"
+      env:
+        # Ensure we test with assertions enabled.
+        # As opposed to the manylinux builds, which we distribute and
+        # thus only use O3 (because Ofast enables fast-math, which has
+        # process-wide effects), we test with Ofast here, because we
+        # expect that some people will compile it themselves with that setting.
+        CPPFLAGS: "-Ofast -UNDEBUG"
+    - name: Install greenlet (Mac)
+      if: startsWith(runner.os, 'Mac')
+      run: |
+        python setup.py bdist_wheel
+        python -m pip install -U -e ".test,docs"
+      env:
+        # Unlike the above, we are actually distributing these
+        # wheels, so they need to be built for production use.
+        CPPFLAGS: "-O3"
+        # Build for both architectures
+        ARCHFLAGS: "-arch x86_64 -arch arm64"
+
     - name: Check greenlet build
       run: |
         ls -l dist
         twine check dist/*
     - name: Store greenlet wheel
-      uses: actions/upload-artifact@v2
+      uses: actions/upload-artifact@v3
       with:
         name: greenlet-${{ runner.os }}-${{ matrix.python-version }}.whl
         path: dist/*whl
     - name: Test
       run: |
+        python -c 'import greenlet._greenlet as G; assert G.GREENLET_USE_STANDARD_THREADING'
         python -m unittest discover -v greenlet.tests
     - name: Doctest
-      # FIXME: This conditional can go away when a Sphinx greater than 4.1.2
-      # is released. See https://github.com/sphinx-doc/sphinx/issues/9512
-      if: matrix.python-version != '3.10.0-rc.1'
       run: |
         sphinx-build -b doctest -d docs/_build/doctrees2 docs docs/_build/doctest2
     - name: Publish package to PyPI (mac)
@@ -75,6 +92,70 @@
       run: |
         twine upload --skip-existing dist/*
 
+  test_non_standard_thread:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        python-version: 2.7, 3.5, "3.11"
+        os: ubuntu-20.04, macos-latest
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ matrix.python-version }}
+        cache: 'pip'
+        cache-dependency-path: setup.py
+    - name: Install dependencies
+      run: |
+        python -m pip install -U pip setuptools wheel
+        python -m pip install -U twine
+    - name: Install greenlet
+      env:
+        CPPFLAGS: "-DG_USE_STANDARD_THREADING=0 -UNDEBUG -Ofast"
+      run: |
+        python setup.py bdist_wheel
+        python -m pip install -U -v -e ".test,docs"
+    - name: Test
+      run: |
+        python -c 'import greenlet._greenlet as G; assert not G.GREENLET_USE_STANDARD_THREADING'
+        python -m unittest discover -v greenlet.tests
+
+  CodeQL:
+    runs-on: ubuntu-latest
+    permissions:
+      # required for all workflows
+      security-events: write
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: "3.10"
+          cache: 'pip'
+          cache-dependency-path: setup.py
+      - name: Install dependencies
+        run: |
+          python -m pip install -U pip
+          python -m pip install -U setuptools wheel
+          # Set the `CODEQL-PYTHON` environment variable to the Python executable
+          # that includes the dependencies
+          echo "CODEQL_PYTHON=$(which python)" >> $GITHUB_ENV
+      # Initializes the CodeQL tools for scanning.
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v2
+        with:
+          languages: python, cpp
+          # Override the default behavior so that the action doesn't attempt
+          # to auto-install Python dependencies
+          setup-python-dependencies: false
+      - name: Install greenlet
+        run: |
+          python setup.py build
+      # - name: Autobuild
+      #   uses: github/codeql-action/autobuild@v1
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@v2
 
   manylinux:
 
@@ -83,16 +164,22 @@
     strategy:
       matrix:
         python-version: 3.9
-        image: manylinux2010_x86_64, manylinux2014_aarch64, manylinux2014_ppc64le, manylinux2014_x86_64
+        image:
+          - manylinux2010_x86_64
+          - manylinux2014_aarch64
+          - manylinux2014_ppc64le
+          - manylinux2014_x86_64
+          - musllinux_1_1_x86_64
+          - musllinux_1_1_aarch64
+    name: ${{ matrix.image }}
 
     steps:
       - name: checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v2
+        uses: actions/setup-python@v4
         with:
           python-version: ${{ matrix.python-version }}
-
       - name: Enable emulation
         run: |
           docker run --rm --privileged hypriot/qemu-register
@@ -116,7 +203,7 @@
           DOCKER_IMAGE: quay.io/pypa/${{ matrix.image }}
         run: bash ./make-manylinux
       - name: Store greenlet wheels
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@v3
         with:
           path: wheelhouse/*whl
           name: ${{ matrix.image }}_wheels.zip

_service:tar_scm:greenlet-2.0.2.tar.gz/.gitignore Added

_service:tar_scm:greenlet-2.0.2.tar.gz/.pylintrc Added

@@ -0,0 +1,124 @@
+MASTER
+extension-pkg-whitelist=greenlet._greenlet,greenlet.tests._test_extension
+extension-pkg-allow-list=greenlet._greenlet,greenlet.tests._test_extension
+
+
+MESSAGES CONTROL
+
+# Disable the message, report, category or checker with the given id(s). You
+# can either give multiple identifier separated by comma (,) or put this option
+# multiple time (only on the command line, not in the configuration file where
+# it should appear only once).
+# NOTE: comments must go ABOVE the statement. In Python 2, mixing in
+# comments disables all directives that follow, while in Python 3, putting
+# comments at the end of the line does the same thing (though Py3 supports
+# mixing)
+
+
+# invalid-name, ; We get lots of these, especially in scripts. should fix many of them
+# protected-access, ; We have many cases of this; legit ones need to be examinid and commented, then this removed
+# no-self-use, ; common in superclasses with extension points
+# too-few-public-methods, ; Exception and marker classes get tagged with this
+# exec-used, ; should tag individual instances with this, there are some but not too many
+# global-statement,     ; should tag individual instances
+# multiple-statements, ; "from gevent import monkey; monkey.patch_all()"
+# locally-disabled, ; yes, we know we're doing this. don't replace one warning with another
+# cyclic-import, ; most of these are deferred imports
+# too-many-arguments, ; these are almost always because that's what the stdlib does
+# redefined-builtin, ; likewise: these tend to be keyword arguments like len= in the stdlib
+# undefined-all-variable,     ; XXX: This crashes with pylint 1.5.4 on Travis (but not locally on Py2/3
+#     ; or landscape.io on Py3). The file causing the problem is unclear. UPDATE: identified and disabled
+#   that file.
+#   see https://github.com/PyCQA/pylint/issues/846
+# useless-suppression: the only way to avoid repeating it for specific statements everywhere that we
+#   do Py2/Py3 stuff is to put it here. Sadly this means that we might get better but not realize it.
+# duplicate-code: Yeah, the compatibility ssl modules are much the same
+# In pylint 1.8.0, inconsistent-return-statements are created for the wrong reasons.
+# This code raises it, even though there's only one return (the implicit 'return None' is presumably
+# what triggers it):
+#  def foo():
+#    if baz:
+#      return 1
+# In Pylint 2dev1, needed for Python 3.7, we get spurious 'useless return' errors:
+# @property
+# def foo(self):
+#   return None # generates useless-return
+# Pylint 2.4 adds import-outside-toplevel. But we do that a lot to defer imports because of patching.
+# Pylint 2.4 adds self-assigning-variable. But we do *that* to avoid unused-import when we
+# "export" the variable and don't have a __all__.
+# Pylint 2.6+ adds some python-3-only things that don't apply: raise-missing-from, super-with-arguments, consider-using-f-string, redundant-u-string-prefix
+disable=missing-docstring,
+    ungrouped-imports,
+    invalid-name,
+    protected-access,
+    no-self-use,
+    too-few-public-methods,
+    exec-used,
+    global-statement,
+    multiple-statements,
+    locally-disabled,
+    cyclic-import,
+    too-many-arguments,
+    redefined-builtin,
+    useless-suppression,
+    duplicate-code,
+    undefined-all-variable,
+    inconsistent-return-statements,
+    useless-return,
+    useless-object-inheritance,
+    import-outside-toplevel,
+    self-assigning-variable,
+    raise-missing-from,
+    super-with-arguments,
+    consider-using-f-string,
+    redundant-u-string-prefix
+
+FORMAT
+# duplicated from setup.cfg
+max-line-length=160
+max-module-lines=1100
+
+MISCELLANEOUS
+# List of note tags to take in consideration, separated by a comma.
+#notes=FIXME,XXX,TODO
+# Disable that, we don't want them in the report (???)
+notes=
+
+VARIABLES
+
+dummy-variables-rgx=_.*
+
+TYPECHECK
+
+# List of members which are set dynamically and missed by pylint inference
+# system, and so shouldn't trigger E1101 when accessed. Python regular
+# expressions are accepted.
+# gevent: this is helpful for py3/py2 code.
+generated-members=exc_clear
+
+# List of classes names for which member attributes should not be checked
+# (useful for classes with attributes dynamically set). This can work
+# with qualified names.
+#ignored-classes=SSLContext, SSLSocket, greenlet, Greenlet, parent, dead
+
+
+# List of module names for which member attributes should not be checked
+# (useful for modules/projects where namespaces are manipulated during runtime
+# and thus existing member attributes cannot be deduced by static analysis. It
+# supports qualified module names, as well as Unix pattern matching.
+ignored-modules=gevent._corecffi,gevent.os,os,threading,gevent.libev.corecffi,gevent.socket,gevent.core,gevent.testing.support
+
+DESIGN
+max-attributes=12
+max-parents=10
+
+BASIC
+bad-functions=input
+# Prospector turns ot unsafe-load-any-extension by default, but
+# pylint leaves it off. This is the proximal cause of the
+# undefined-all-variable crash.
+unsafe-load-any-extension = yes
+
+# Local Variables:
+# mode: conf
+# End:

_service:tar_scm:greenlet-1.1.2.tar.gz/CHANGES.rst -> _service:tar_scm:greenlet-2.0.2.tar.gz/CHANGES.rst Changed

@@ -2,6 +2,183 @@
  Changes
 =========
 
+2.0.2 (2023-01-28)
+==================
+
+- Fix calling ``greenlet.settrace()`` with the same tracer object that
+  was currently active. See `issue 332
+  <https://github.com/python-greenlet/greenlet/issues/332>`_.
+- Various compilation and standards conformance fixes. See #335, #336,
+  #300, #302, #334.
+
+
+
+2.0.1 (2022-11-07)
+==================
+
+- Python 3.11: Fix a memory leak. See `issue 328
+  <https://github.com/python-greenlet/greenlet/issues/328>`_ and
+  `gevent issue 1924 <https://github.com/gevent/gevent/issues/1924>`_.
+
+
+2.0.0.post0 (2022-11-03)
+========================
+
+- Add ``Programming Language :: Python :: 3.11`` to the PyPI
+  classifier metadata.
+
+
+2.0.0 (2022-10-31)
+==================
+
+- Nothing changed yet.
+
+
+2.0.0rc5 (2022-10-31)
+=====================
+
+- Linux: Fix another group of rare crashes that could occur when shutting down an
+  interpeter running multiple threads. See `issue 325 <https://github.com/python-greenlet/greenlet/issues/325>`_.
+
+
+2.0.0rc4 (2022-10-30)
+=====================
+
+- Linux: Fix a rare crash that could occur when shutting down an
+  interpreter running multiple threads, when some of those threads are
+  in greenlets making calls to functions that release the GIL.
+
+
+2.0.0rc3 (2022-10-29)
+=====================
+
+- Python 2: Fix a crash that could occur when raising an old-style
+  instance object.
+
+
+2.0.0rc2 (2022-10-28)
+=====================
+
+- Workaround `a CPython 3.8 bug
+  <https://github.com/python/cpython/issues/81308>`_ that could cause
+  the interpreter to crash during an early phase of shutdown with the
+  message "Fatal Python error: Python memory allocator called without
+  holding the GI." This only impacted CPython 3.8a3 through CPython
+  3.9a5; the fix is only applied to CPython 3.8 releases (please don't
+  use an early alpha release of CPython 3.9).
+
+
+2.0.0rc1 (2022-10-27)
+=====================
+
+- Deal gracefully with greenlet switches that occur while deferred
+  deallocation of objects is happening using CPython's "trash can"
+  mechanism. Previously, if a large nested container held items that
+  switched greenlets during delayed deallocation, and that second
+  greenlet also invoked the trash can, CPython's internal state could
+  become corrupt. This was visible as an assertion error in debug
+  builds. Now, the relevant internal state is saved and restored
+  during greenlet switches. See also `gevent issue 1909
+  <https://github.com/gevent/gevent/issues/1909>`_.
+- Rename the C API function ``PyGreenlet_GET_PARENT`` to
+  ``PyGreenlet_GetParent`` for consistency. The old name remains
+  available as a deprecated alias.
+
+
+
+2.0.0a2 (2022-03-24)
+====================
+
+- Fix a crash on older versions of the Windows C runtime when an
+  unhandled C++ exception was thrown inside a greenlet by another
+  native extension. This is a bug in that extension, and the
+  interpreter will still abort, but at least it does so deliberately.
+  Thanks to Kirill Smelkov. See `PR 286
+  <https://github.com/python-greenlet/greenlet/pull/286>`_.
+- Musllinux wheels for aarch64 are now built, tested, and uploaded to
+  PyPI. Thanks to Alexander Piskun.
+- This version of greenlet is known to compile and pass tests on
+  CPython 3.11.0a6. Earlier 3.11 releases will not work; later
+  releases may or may not work. See `PR 294
+  <https://github.com/python-greenlet/greenlet/pull/294>`_. Special
+  thanks to Victor Stinner, Brandt Bucher and the CPython developers.
+
+
+2.0.0a1 (2022-01-20)
+====================
+
+Platforms
+---------
+
+- Add experimental, untested support for 64-bit Windows on ARM using
+  MSVC. See `PR 271 <https://github.com/python-greenlet/greenlet/pull/271>`_.
+
+- Drop support for very old versions of GCC and MSVC.
+
+- Compilation now requires a compiler that either supports C++11 or
+  has some other intrinsic way to create thread local variables; for
+  older GCC, clang and SunStudio we use ``__thread``, while for older
+  MSVC we use ``__declspec(thread)``.
+
+- Wheels compatible with the musllinux specification are built,
+  tested, and uploaded to PyPI for x86_64. (This was retroactively
+  done for version 1.1.2 as well.)
+
+- This version of greenlet is known to compile and pass tests on
+  CPython 3.11.0a4. Earlier or later 3.11 releases may or may not
+  work. See `PR 280
+  <https://github.com/python-greenlet/greenlet/pull/280>`_. Special
+  thanks to Brandt Bucher and the CPython developers.
+
+Fixes
+-----
+
+- Fix several leaks that could occur when using greenlets from
+  multiple threads. For example, it is no longer necessary to call
+  ``getcurrent()`` before exiting a thread to allow its main greenlet
+  to be cleaned up. See `issue 252 <https://github.com/python-greenlet/greenlet/issues/251>`_.
+
+- Fix the C API ``PyGreenlet_Throw`` to perform the same error
+  checking that the Python API ``greenlet.throw()`` does. Previously,
+  it did no error checking.
+
+- Fix C++ exception handling on 32-bit Windows. This might have
+  ramifications if you embed Python in your application and also use
+  SEH on 32-bit windows, or if you embed Python in a C++ application.
+  Please contact the maintainers if you have problems in this area.
+
+  In general, C++ exception handling is expected to be better on most
+  platforms. This work is ongoing.
+
+Changes
+-------
+
+- The repr of some greenlets has changed. In particular, if the
+  greenlet object was running in a thread that has exited, the repr
+  now indicates that. *NOTE:* The repr of a greenlet is not part of
+  the API and should not be relied upon by production code. It is
+  likely to differ in other implementations such as PyPy.
+
+- Main greenlets from threads that have exited are now marked as dead.
+
+
+1.1.3.post0 (2022-10-10)
+========================
+
+- Add musllinux (Alpine) binary wheels.
+
+.. important:: This preliminary support for Python 3.11 leaks memory.
+               Please upgrade to greenlet 2 if you're using Python 3.11.
+
+1.1.3 (2022-08-25)
+==================
+
+- Add support for Python 3.11. Please note that Windows binary wheels
+  are not available at this time.
+
+.. important:: This preliminary support for Python 3.11 leaks memory.
+               Please upgrade to greenlet 2 if you're using Python 3.11.
+
 1.1.2 (2021-09-29)
 ==================
 
@@ -25,6 +202,7 @@
   <https://github.com/python-greenlet/greenlet/issues/256>`_, reported
   by Joe Rickerby.
 
+
 1.1.1 (2021-08-06)
 ==================
 
@@ -223,9 +401,9 @@
 =====
 * Greenlet has an instance dictionary now, which means it can be
   used for implementing greenlet local storage, etc. However, this
-  might introduce incompatibility if subclasses have __dict__ in their
-  __slots__. Classes like that will fail, because greenlet already
-  has __dict__ out of the box.
+  might introduce incompatibility if subclasses have ``__dict__`` in their
+  ``__slots__``. Classes like that will fail, because greenlet already
+  has ``__dict__`` out of the box.
 * Greenlet no longer leaks memory after thread termination, as long as
   terminated thread has no running greenlets left at the time.
 * Add support for debian sparc and openbsd5-sparc64

_service:tar_scm:greenlet-1.1.2.tar.gz/MANIFEST.in -> _service:tar_scm:greenlet-2.0.2.tar.gz/MANIFEST.in Changed

_service:tar_scm:greenlet-1.1.2.tar.gz/PKG-INFO -> _service:tar_scm:greenlet-2.0.2.tar.gz/PKG-INFO Changed

@@ -1,78 +1,16 @@
 Metadata-Version: 2.1
 Name: greenlet
-Version: 1.1.2
+Version: 2.0.2
 Summary: Lightweight in-process concurrent programming
 Home-page: https://greenlet.readthedocs.io/
 Author: Alexey Borzenkov
 Author-email: snaury@gmail.com
 Maintainer: Jason Madden
-Maintainer-email: jason@nextthought.com
+Maintainer-email: jason@seecoresoftware.com
 License: MIT License
 Project-URL: Bug Tracker, https://github.com/python-greenlet/greenlet/issues
 Project-URL: Source Code, https://github.com/python-greenlet/greenlet/
 Project-URL: Documentation, https://greenlet.readthedocs.io/
-Description: .. This file is included into docs/history.rst
-        
-        .. image:: https://github.com/python-greenlet/greenlet/workflows/tests/badge.svg
-           :target: https://github.com/python-greenlet/greenlet/actions
-        
-        Greenlets are lightweight coroutines for in-process concurrent
-        programming.
-        
-        The "greenlet" package is a spin-off of `Stackless`_, a version of
-        CPython that supports micro-threads called "tasklets". Tasklets run
-        pseudo-concurrently (typically in a single or a few OS-level threads)
-        and are synchronized with data exchanges on "channels".
-        
-        A "greenlet", on the other hand, is a still more primitive notion of
-        micro-thread with no implicit scheduling; coroutines, in other words.
-        This is useful when you want to control exactly when your code runs.
-        You can build custom scheduled micro-threads on top of greenlet;
-        however, it seems that greenlets are useful on their own as a way to
-        make advanced control flow structures. For example, we can recreate
-        generators; the difference with Python's own generators is that our
-        generators can call nested functions and the nested functions can
-        yield values too. (Additionally, you don't need a "yield" keyword. See
-        the example in `test_generator.py
-        <https://github.com/python-greenlet/greenlet/blob/adca19bf1f287b3395896a8f41f3f4fd1797fdc7/src/greenlet/tests/test_generator.py#L1>`_).
-        
-        Greenlets are provided as a C extension module for the regular unmodified
-        interpreter.
-        
-        .. _`Stackless`: http://www.stackless.com
-        
-        
-        Who is using Greenlet?
-        ======================
-        
-        There are several libraries that use Greenlet as a more flexible
-        alternative to Python's built in coroutine support:
-        
-         - `Concurrence`_
-         - `Eventlet`_
-         - `Gevent`_
-        
-        .. _Concurrence: http://opensource.hyves.org/concurrence/
-        .. _Eventlet: http://eventlet.net/
-        .. _Gevent: http://www.gevent.org/
-        
-        Getting Greenlet
-        ================
-        
-        The easiest way to get Greenlet is to install it with pip::
-        
-          pip install greenlet
-        
-        
-        Source code archives and binary distributions are vailable on the
-        python package index at https://pypi.org/project/greenlet
-        
-        The source code repository is hosted on github:
-        https://github.com/python-greenlet/greenlet
-        
-        Documentation is available on readthedocs.org:
-        https://greenlet.readthedocs.io
-        
 Keywords: greenlet coroutine concurrency threads cooperative
 Platform: any
 Classifier: Development Status :: 5 - Production/Stable
@@ -90,9 +28,75 @@
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*
 Description-Content-Type: text/x-rst
 Provides-Extra: docs
 Provides-Extra: test
+License-File: LICENSE
+License-File: LICENSE.PSF
+License-File: AUTHORS
+
+.. This file is included into docs/history.rst
+
+.. image:: https://github.com/python-greenlet/greenlet/workflows/tests/badge.svg
+   :target: https://github.com/python-greenlet/greenlet/actions
+
+Greenlets are lightweight coroutines for in-process concurrent
+programming.
+
+The "greenlet" package is a spin-off of `Stackless`_, a version of
+CPython that supports micro-threads called "tasklets". Tasklets run
+pseudo-concurrently (typically in a single or a few OS-level threads)
+and are synchronized with data exchanges on "channels".
+
+A "greenlet", on the other hand, is a still more primitive notion of
+micro-thread with no implicit scheduling; coroutines, in other words.
+This is useful when you want to control exactly when your code runs.
+You can build custom scheduled micro-threads on top of greenlet;
+however, it seems that greenlets are useful on their own as a way to
+make advanced control flow structures. For example, we can recreate
+generators; the difference with Python's own generators is that our
+generators can call nested functions and the nested functions can
+yield values too. (Additionally, you don't need a "yield" keyword. See
+the example in `test_generator.py
+<https://github.com/python-greenlet/greenlet/blob/adca19bf1f287b3395896a8f41f3f4fd1797fdc7/src/greenlet/tests/test_generator.py#L1>`_).
+
+Greenlets are provided as a C extension module for the regular unmodified
+interpreter.
+
+.. _`Stackless`: http://www.stackless.com
+
+
+Who is using Greenlet?
+======================
+
+There are several libraries that use Greenlet as a more flexible
+alternative to Python's built in coroutine support:
+
+ - `Concurrence`_
+ - `Eventlet`_
+ - `Gevent`_
+
+.. _Concurrence: http://opensource.hyves.org/concurrence/
+.. _Eventlet: http://eventlet.net/
+.. _Gevent: http://www.gevent.org/
+
+Getting Greenlet
+================
+
+The easiest way to get Greenlet is to install it with pip::
+
+  pip install greenlet
+
+
+Source code archives and binary distributions are available on the
+python package index at https://pypi.org/project/greenlet
+
+The source code repository is hosted on github:
+https://github.com/python-greenlet/greenlet
+
+Documentation is available on readthedocs.org:
+https://greenlet.readthedocs.io

_service:tar_scm:greenlet-1.1.2.tar.gz/README.rst -> _service:tar_scm:greenlet-2.0.2.tar.gz/README.rst Changed

_service:tar_scm:greenlet-1.1.2.tar.gz/appveyor.yml -> _service:tar_scm:greenlet-2.0.2.tar.gz/appveyor.yml Changed

@@ -17,9 +17,11 @@
     # /E:ON and /V:ON options are not enabled in the batch script interpreter
     # See: http://stackoverflow.com/a/13751649/163740
     CMD_IN_ENV: "cmd /E:ON /V:ON /C .\\appveyor\\run_with_env.cmd"
-    # Use a fixed hash seed for reproducability
+    # Use a fixed hash seed for reproducibility
     PYTHONHASHSEED: 8675309
     PYTHONDEVMODE: 1
+    PYTHONFAULTHANDLER: 1
+    PYTHONUNBUFFERED: 1
     # Don't get warnings about Python 2 support being deprecated. We
     # know.
     PIP_NO_PYTHON_VERSION_WARNING: 1
@@ -34,8 +36,17 @@
 
   matrix:
     # http://www.appveyor.com/docs/installed-software#python
+
+    # Fully supported 64-bit versions, with testing. This should be
+    # all the current (non EOL) versions.
+    - PYTHON: "C:\\Python311-x64"
+      PYTHON_VERSION: "3.11.0"
+      PYTHON_ARCH: "64"
+      PYTHON_EXE: python
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+
     - PYTHON: "C:\\Python310-x64"
-      PYTHON_VERSION: "3.10.0rc2"
+      PYTHON_VERSION: "3.10.0"
       PYTHON_ARCH: "64"
       PYTHON_EXE: python
       APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
@@ -46,6 +57,27 @@
       PYTHON_EXE: python
       APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
 
+    - PYTHON: "C:\\Python38-x64"
+      PYTHON_ARCH: "64"
+      PYTHON_VERSION: "3.8.x"
+      PYTHON_EXE: python
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+
+    - PYTHON: "C:\\Python37-x64"
+      PYTHON_ARCH: "64"
+      PYTHON_VERSION: "3.7.x"
+      PYTHON_EXE: python
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+
+    - PYTHON: "C:\\Python27-x64"
+      PYTHON_ARCH: "64"
+      PYTHON_VERSION: "2.7.x"
+      PYTHON_EXE: python
+
+    # Tested 32-bit versions. A small, hand-picked selection covering
+    # important variations. No need to include newer versions of
+    # cpython here, 32-bit x86 windows is on the way out.
+
     - PYTHON: "C:\\Python39"
       PYTHON_ARCH: "32"
       PYTHON_VERSION: "3.9.x"
@@ -57,50 +89,49 @@
       PYTHON_VERSION: "2.7.x"
       PYTHON_EXE: python
 
-    - PYTHON: "C:\\Python27-x64"
-      PYTHON_ARCH: "64"
-      PYTHON_VERSION: "2.7.x"
-      PYTHON_EXE: python
 
-    - PYTHON: "C:\\Python35"
-      PYTHON_ARCH: "32"
-      PYTHON_VERSION: "3.5.x"
+    # Untested 64-bit versions. We don't expect any variance here from
+    # the other tested 64-bit versions, OR they are very EOL
+
+    - PYTHON: "C:\\Python36-x64"
+      PYTHON_ARCH: "64"
+      PYTHON_VERSION: "3.6.x"
       PYTHON_EXE: python
+      GWHEEL_ONLY: true
 
     - PYTHON: "C:\\Python35-x64"
       PYTHON_ARCH: "64"
       PYTHON_VERSION: "3.5.x"
       PYTHON_EXE: python
+      GWHEEL_ONLY: true
 
-    - PYTHON: "C:\\Python36"
-      PYTHON_ARCH: "32"
-      PYTHON_VERSION: "3.6.x"
-      PYTHON_EXE: python
+    # Untested 32-bit versions. As above, we don't expect any variance
+    # from the tested 32-bit versions, OR they are very EOL.
 
-    - PYTHON: "C:\\Python36-x64"
-      PYTHON_ARCH: "64"
-      PYTHON_VERSION: "3.6.x"
+    - PYTHON: "C:\\Python38"
+      PYTHON_ARCH: "32"
+      PYTHON_VERSION: "3.8.x"
       PYTHON_EXE: python
+      GWHEEL_ONLY: true
 
     - PYTHON: "C:\\Python37"
       PYTHON_ARCH: "32"
       PYTHON_VERSION: "3.7.x"
       PYTHON_EXE: python
+      GWHEEL_ONLY: true
 
-    - PYTHON: "C:\\Python37-x64"
-      PYTHON_ARCH: "64"
-      PYTHON_VERSION: "3.7.x"
+    - PYTHON: "C:\\Python36"
+      PYTHON_ARCH: "32"
+      PYTHON_VERSION: "3.6.x"
       PYTHON_EXE: python
+      GWHEEL_ONLY: true
 
-    - PYTHON: "C:\\Python38"
+    - PYTHON: "C:\\Python35"
       PYTHON_ARCH: "32"
-      PYTHON_VERSION: "3.8.x"
+      PYTHON_VERSION: "3.5.x"
       PYTHON_EXE: python
+      GWHEEL_ONLY: true
 
-    - PYTHON: "C:\\Python38-x64"
-      PYTHON_ARCH: "64"
-      PYTHON_VERSION: "3.8.x"
-      PYTHON_EXE: python
 
 
 cache:
@@ -118,8 +149,8 @@
         Where-Object pullRequestId -eq $env:APPVEYOR_PULL_REQUEST_NUMBER)0.buildNumber) { `
           throw "There are newer queued builds for this pull request, failing early." }
   ## Debugging
-  # - ECHO "Filesystem root:"
-  # - ps: "ls \"C:/\""
+  - ECHO "Filesystem root:"
+  - ps: "ls \"C:/\""
 
   # - ECHO "Installed SDKs:"
   # - ps: "if(Test-Path(\"C:/Program Files/Microsoft SDKs/Windows\")) {ls \"C:/Program Files/Microsoft SDKs/Windows\";}"
@@ -162,11 +193,14 @@
   - "%CMD_IN_ENV% pip install --upgrade -r dev-requirements.txt"
 
 build_script:
+# Show any compiler warnings.
+  - "%CMD_IN_ENV% python setup.py build_ext"
   - "%CMD_IN_ENV% python -m pip install -U -e .test,docs"
+  - "%CMD_IN_ENV% python -m pip install -U zope.testrunner"
 
 
 test_script:
-  - "%CMD_IN_ENV% python -m unittest discover -v greenlet.tests"
+  -  if not "%GWHEEL_ONLY%"=="true" %PYEXE% -m zope.testrunner --test-path=src -vvv
 # XXX: Doctest disabled pending sphinx release for 3.10; see tests.yml.
 #  - "%CMD_IN_ENV% python -m sphinx -b doctest -d docs/_build/doctrees docs docs/_build/doctest"

_service:tar_scm:greenlet-1.1.2.tar.gz/benchmarks/chain.py -> _service:tar_scm:greenlet-2.0.2.tar.gz/benchmarks/chain.py Changed

@@ -1,39 +1,112 @@
 #!/usr/bin/env python
-
-"""Create a chain of coroutines and pass a value from one end to the other,
-where each coroutine will increment the value before passing it along.
+"""
+Create a chain of coroutines and pass a value from one end to the
+other, where each coroutine will increment the value before passing it
+along.
 """
 
-import optparse
-import time
-
+import pyperf
 import greenlet
 
 
+
 def link(next_greenlet):
     value = greenlet.getcurrent().parent.switch()
     next_greenlet.switch(value + 1)
 
 
-def chain(n):
-    start_node = greenlet.getcurrent()
-    for i in xrange(n):
-        g = greenlet.greenlet(link)
-        g.switch(start_node)
-        start_node = g
-    return start_node.switch(0)
+CHAIN_GREENLET_COUNT = 100000
+
+def bm_chain(loops):
+    begin = pyperf.perf_counter()
+    for _ in range(loops):
+        start_node = greenlet.getcurrent()
+        for _ in range(CHAIN_GREENLET_COUNT):
+            g = greenlet.greenlet(link)
+            g.switch(start_node)
+            start_node = g
+        x = start_node.switch(0)
+        assert x == CHAIN_GREENLET_COUNT
+    end = pyperf.perf_counter()
+    return end - begin
+
+GETCURRENT_INNER_LOOPS = 10
+def bm_getcurrent(loops):
+    getcurrent = greenlet.getcurrent
+    getcurrent() # Factor out the overhead of creating the initial main greenlet
+    begin = pyperf.perf_counter()
+    for _ in range(loops):
+        # Manual unroll
+        getcurrent()
+        getcurrent()
+        getcurrent()
+        getcurrent()
+        getcurrent()
+        getcurrent()
+        getcurrent()
+        getcurrent()
+        getcurrent()
+        getcurrent()
+    end = pyperf.perf_counter()
+    return end - begin
+
+SWITCH_INNER_LOOPS = 10000
+def bm_switch(loops):
+    class G(greenlet.greenlet):
+        other = None
+        def run(self):
+            o = self.other
+            for _ in range(SWITCH_INNER_LOOPS):
+                o.switch()
+
+    begin = pyperf.perf_counter()
+    for _ in range(loops):
+        gl1 = G()
+        gl2 = G()
+        gl1.other = gl2
+        gl2.other = gl1
+        gl1.switch()
+    end = pyperf.perf_counter()
+    return end - begin
+
+CREATE_INNER_LOOPS = 10
+def bm_create(loops):
+    gl = greenlet.greenlet
+    begin = pyperf.perf_counter()
+    for _ in range(loops):
+        gl()
+        gl()
+        gl()
+        gl()
+        gl()
+        gl()
+        gl()
+        gl()
+        gl()
+        gl()
+    end = pyperf.perf_counter()
+    return end - begin
 
 if __name__ == '__main__':
-    p = optparse.OptionParser(
-        usage='%prog -n NUM_COROUTINES', description=__doc__)
-    p.add_option(
-        '-n', type='int', dest='num_greenlets', default=100000,
-        help='The number of greenlets in the chain.')
-    options, args = p.parse_args()
-
-    if len(args) != 0:
-        p.error('unexpected arguments: %s' % ', '.join(args))
-
-    start_time = time.clock()
-    print 'Result:', chain(options.num_greenlets)
-    print time.clock() - start_time, 'seconds'
+    runner = pyperf.Runner()
+    runner.bench_time_func(
+        'create a greenlet',
+        bm_create,
+        inner_loops=CREATE_INNER_LOOPS
+    )
+
+    runner.bench_time_func(
+        'switch between two greenlets',
+        bm_switch,
+        inner_loops=SWITCH_INNER_LOOPS
+    )
+
+    runner.bench_time_func(
+        'getcurrent single thread',
+        bm_getcurrent,
+        inner_loops=GETCURRENT_INNER_LOOPS
+    )
+    runner.bench_time_func(
+        'chain(%s)' % CHAIN_GREENLET_COUNT,
+        bm_chain,
+    )

_service:tar_scm:greenlet-1.1.2.tar.gz/docs/c_api.rst -> _service:tar_scm:greenlet-2.0.2.tar.gz/docs/c_api.rst Changed

_service:tar_scm:greenlet-1.1.2.tar.gz/docs/conf.py -> _service:tar_scm:greenlet-2.0.2.tar.gz/docs/conf.py Changed

_service:tar_scm:greenlet-1.1.2.tar.gz/docs/python_threads.rst -> _service:tar_scm:greenlet-2.0.2.tar.gz/docs/python_threads.rst Changed

@@ -10,35 +10,61 @@
 .. doctest::
 
    >>> from greenlet import getcurrent
+   >>> from greenlet import greenlet
    >>> from threading import Thread
    >>> from threading import Event
    >>> started = Event()
    >>> switched = Event()
    >>> class T(Thread):
    ...     def run(self):
-   ...         self.glet = getcurrent()
+   ...         self.main_glet = getcurrent()
+   ...         self.child_glet = greenlet(lambda: None)
+   ...         self.child_glet.switch()
    ...         started.set()
    ...         switched.wait()
    >>> t = T()
    >>> t.start()
    >>> _ = started.wait()
-   >>> t.glet.switch()
+   >>> t.main_glet.switch()
    Traceback (most recent call last):
    ...
    greenlet.error: cannot switch to a different thread
    >>> switched.set()
    >>> t.join()
 
-Note that when a thread dies, the thread's main greenlet is not
-considered to be dead.
+Prior to greenlet 2.0, when a thread dies, the thread's main greenlet was not
+considered to be dead. This has been changed in greenlet 2.0; however,
+observing this property is still a race condition, and, on some
+platforms (those that cannot use the C runtime to detect when a thread
+exits), not guaranteed (because of the potential for uncollectible
+reference cycles to keep the Python thread state alive). In addition,
+this is considered an implementation detail and may not be true in all
+greenlet implementations.
 
 .. doctest::
 
-   >>> t.glet.dead
-   False
+   >>> t.main_glet.dead
+   True
 
 .. caution::
 
    For these reasons, it's best to not pass references to a greenlet
    running in one thread to another thread. If you do, take caution to
-   carefully manage the lifetime of the references.
+   carefully manage the lifetime of the references. If greenlets that
+   are suspended in one thread are referenced from another thread,
+   row memory and Python objects can leak.
+
+In greenlet 2.0, the error message for attempting to switch into a
+dead thread makes that fact clear; again, this is an implementation
+detail and should not be relied upon.
+
+.. doctest::
+
+   >>> t.child_glet.switch()
+   Traceback (most recent call last):
+   ...
+   greenlet.error: cannot switch to a different thread (which happens to have exited)
+   >>> t.main_glet.switch()
+   Traceback (most recent call last):
+   ...
+   greenlet.error: cannot switch to a garbage collected greenlet

_service:tar_scm:greenlet-1.1.2.tar.gz/make-manylinux -> _service:tar_scm:greenlet-2.0.2.tar.gz/make-manylinux Changed

@@ -5,7 +5,7 @@
 set -e
 export PYTHONUNBUFFERED=1
 export PYTHONDONTWRITEBYTECODE=1
-# Use a fixed hash seed for reproducability
+# Use a fixed hash seed for reproducibility
 export PYTHONHASHSEED=8675309
 export CI=1
 export TRAVIS=true
@@ -17,7 +17,12 @@
 
 if  -d /greenlet -a -d /opt/python ; then
     # Running inside docker
-
+    export GREENLET_MANYLINUX=1
+    # Build for speed (we're going to test this anyway) and without assertions.
+    # Note: -Ofast includes -ffast-math which affects process-wide floating-point flags (e.g. can affect numpy).
+    # It may also violate standards compliance in a few ways. Rather than opt-out with -fno-fast-math,
+    # we use O3, which has neither of those problems.
+    export CFLAGS="-O3 -DNDEBUG"
     # Build in an isolated directory
     mkdir /tmp/build
     cd /tmp/build
@@ -27,13 +32,13 @@
     mkdir -p /greenlet/wheelhouse
     OPATH="$PATH"
     which auditwheel
-    for variant in `ls -d /opt/python/cp{27,35,36,37,38,39,310}*`; do
+    for variant in `ls -d /opt/python/cp{27,35,36,37,38,39,310,311}*`; do
         export PATH="$variant/bin:$OPATH"
         echo "Building $variant $(python --version)"
 
         python -mpip install -U pip
         python setup.py bdist_wheel
-        python -mpip install -U .
+        python -mpip install -U .test
         python -m unittest discover -v greenlet.tests
         PATH="$OPATH" auditwheel repair dist/greenlet*.whl
         cp wheelhouse/greenlet*.whl /greenlet/wheelhouse

_service:tar_scm:greenlet-1.1.2.tar.gz/setup.py -> _service:tar_scm:greenlet-2.0.2.tar.gz/setup.py Changed

@@ -1,5 +1,6 @@
 #! /usr/bin/env python
-
+# -*- coding: utf-8 -*-
+from __future__ import print_function
 import sys
 import os
 import glob
@@ -10,21 +11,101 @@
 from setuptools import Extension
 from setuptools import find_packages
 
+# Extra compiler arguments passed to *all* extensions.
+global_compile_args = 
+
+# Extra compiler arguments passed to C++ extensions
+cpp_compile_args = 
+
+# Extra linker arguments passed to C++ extensions
+cpp_link_args = 
+
+# Extra compiler arguments passed to the main extension
+main_compile_args = 
+
+is_win = sys.platform.startswith("win")
+
 # workaround segfaults on openbsd and RHEL 3 / CentOS 3 . see
 # https://bitbucket.org/ambroff/greenlet/issue/11/segfault-on-openbsd-i386
 # https://github.com/python-greenlet/greenlet/issues/4
 # https://github.com/python-greenlet/greenlet/issues/94
 # pylint:disable=too-many-boolean-expressions
-if ((sys.platform == "openbsd4" and os.uname()-1 == "i386")
-    or ("-with-redhat-3." in platform.platform() and platform.machine() == 'i686')
-    or (sys.platform == "sunos5" and os.uname()-1 == "sun4v")
-    or ("SunOS" in platform.platform() and platform.machine() == "sun4v")
-    or (sys.platform == "linux" and platform.machine() == "ppc")):
-    os.environ"CFLAGS" = ("%s %s" % (os.environ.get("CFLAGS", ""), "-Os")).lstrip()
+is_linux = sys.platform.startswith('linux') # could be linux or linux2
+plat_platform = platform.platform()
+plat_machine = platform.machine()
+plat_compiler = platform.python_compiler()
+try:
+    # (sysname, nodename, release, version, machine)
+    unam_machine = os.uname()-1
+except AttributeError:
+    unam_machine = ''
+if (
+       (sys.platform == "openbsd4" and unam_machine == "i386")
+    or ("-with-redhat-3." in plat_platform and plat_machine == 'i686')
+    or (sys.platform == "sunos5" and unam_machine == "sun4v") # SysV-based Solaris
+    or ("SunOS" in plat_platform and plat_machine == "sun4v") # Old BSD-based SunOS
+    or (is_linux and plat_machine == "ppc")
+    # https://github.com/python-greenlet/greenlet/pull/300: When compiling for RISC-V the command
+    # ``riscv64-linux-gnu-gcc -pthread -fno-strict-aliasing -Wdate-time \
+    #   -D_FORTIFY_SOURCE=2 -g -ffile-prefix-map=/build/python2.7-7GU7VT/python2.7-2.7.18=. \
+    #   -fstack-protector-strong -Wformat -Werror=format-security -fPIC \
+    #   -I/usr/include/python2.7
+    #   -c src/greenlet/greenlet.cpp  -o build/temp.linux-riscv64-2.7/src/greenlet/greenlet.o``
+    #
+    # fails with:
+    #
+    # src/greenlet/platform/switch_riscv_unix.h:30:1: error: s0 cannot be used in 'asm' here
+    #
+    # Adding the -Os flag fixes the problem.
+    or (is_linux and plat_machine == "riscv64")
+):
+    global_compile_args.append("-Os")
+
+
+if sys.platform == 'darwin' or 'clang' in plat_compiler:
+    # The clang compiler doesn't use --std=c++11 by default
+    cpp_compile_args.append("--std=gnu++11")
+elif is_win and "MSC" in plat_compiler:
+    # Older versions of MSVC (Python 2.7) don't handle C++ exceptions
+    # correctly by default. While newer versions do handle exceptions by default,
+    # they don't do it fully correctly. So we need an argument on all versions.
+    #"/EH" == exception handling.
+    #    "s" == standard C++,
+    #    "c" == extern C functions don't throw
+    # OR
+    #   "a" == standard C++, and Windows SEH; anything may throw, compiler optimizations
+    #          around try blocks are less aggressive.
+    # /EHsc is suggested, and /EHa isn't supposed to be linked to other things not built
+    # with it. Leaving off the "c" should just result in slower, safer code.
+    # Other options:
+    #    "r" == Always generate standard confirming checks for noexcept blocks, terminating
+    #           if violated. IMPORTANT: We rely on this.
+    # See https://docs.microsoft.com/en-us/cpp/build/reference/eh-exception-handling-model?view=msvc-160
+    handler = "/EHsr"
+    cpp_compile_args.append(handler)
+    # To disable most optimizations:
+    #cpp_compile_args.append('/Od')
 
+    # To enable assertions:
+    #cpp_compile_args.append('/UNDEBUG')
+
+    # To enable more compile-time warnings (/Wall produces a mountain of output).
+    #cpp_compile_args.append('/W4')
+
+    # To link with the debug C runtime...except we can't because we need
+    # the Python debug lib too, and they're not around by default
+    # cpp_compile_args.append('/MDd')
+
+    # Support fiber-safe thread-local storage: "the compiler mustn't
+    # cache the address of the TLS array, or optimize it as a common
+    # subexpression across a function call." This would probably solve
+    # some of the issues we had with MSVC caching the thread local
+    # variables on the stack, leading to having to split some
+    # functions up. Revisit those.
+    cpp_compile_args.append("/GT")
 
 def readfile(filename):
-    with open(filename, 'r') as f:
+    with open(filename, 'r') as f: # pylint:disable=unspecified-encoding
         return f.read()
 
 GREENLET_SRC_DIR = 'src/greenlet/'
@@ -38,6 +119,9 @@
 def _find_platform_headers():
     return glob.glob(GREENLET_PLATFORM_DIR + "switch_*.h")
 
+def _find_impl_headers():
+    return glob.glob(GREENLET_SRC_DIR + "*.hpp")
+
 if hasattr(sys, "pypy_version_info"):
     ext_modules = 
     headers = 
@@ -45,30 +129,38 @@
 
     headers = GREENLET_HEADER
 
-    if sys.platform == 'win32' and '64 bit' in sys.version:
+    if is_win and '64 bit' in sys.version:
         # this works when building with msvc, not with 64 bit gcc
-        # switch_x64_masm.obj can be created with setup_switch_x64_masm.cmd
-        extra_objects = GREENLET_PLATFORM_DIR + 'switch_x64_masm.obj'
+        # switch_<platform>_masm.obj can be created with setup_switch_<platform>_masm.cmd
+        obj_fn = 'switch_arm64_masm.obj' if plat_machine == 'ARM64' else 'switch_x64_masm.obj'
+        extra_objects = os.path.join(GREENLET_PLATFORM_DIR, obj_fn)
     else:
         extra_objects = 
 
-    if sys.platform == 'win32' and os.environ.get('GREENLET_STATIC_RUNTIME') in ('1', 'yes'):
-        extra_compile_args = '/MT'
-    elif hasattr(os, 'uname') and os.uname()4 in 'ppc64el', 'ppc64le':
-        extra_compile_args = '-fno-tree-dominator-opts'
-    else:
-        extra_compile_args = 
+    if is_win and os.environ.get('GREENLET_STATIC_RUNTIME') in ('1', 'yes'):
+        main_compile_args.append('/MT')
+    elif unam_machine in ('ppc64el', 'ppc64le'):
+        main_compile_args.append('-fno-tree-dominator-opts')
 
     ext_modules = 
         Extension(
             name='greenlet._greenlet',
-            sources=GREENLET_SRC_DIR + 'greenlet.c',
+            sources=
+                GREENLET_SRC_DIR + 'greenlet.cpp',
+            ,
+            language='c++',
             extra_objects=extra_objects,
-            extra_compile_args=extra_compile_args,
+            extra_compile_args=global_compile_args + main_compile_args + cpp_compile_args,
+            extra_link_args=cpp_link_args,
             depends=
                 GREENLET_HEADER,
                 GREENLET_SRC_DIR + 'slp_platformselect.h',
-             + _find_platform_headers()
+             + _find_platform_headers() + _find_impl_headers(),
+            define_macros=
+             + (
+                ('WIN32', '1'),
+             if is_win else 
+            )
         ),
         # Test extensions.
         #
@@ -81,22 +173,22 @@
         Extension(
             name='greenlet.tests._test_extension',
             sources=GREENLET_TEST_DIR + '_test_extension.c',
-            include_dirs=GREENLET_HEADER_DIR
+            include_dirs=GREENLET_HEADER_DIR,
+            extra_compile_args=global_compile_args,
+        ),
+        Extension(
+            name='greenlet.tests._test_extension_cpp',
+            sources=GREENLET_TEST_DIR + '_test_extension_cpp.cpp',
+            language="c++",
+            include_dirs=GREENLET_HEADER_DIR,
+            extra_compile_args=global_compile_args + cpp_compile_args,
+            extra_link_args=cpp_link_args,
         ),
     
 
-    if os.environ.get('GREENLET_TEST_CPP', 'yes').lower() not in ('0', 'no', 'false'):
-        ext_modules.append(
-            Extension(
-                name='greenlet.tests._test_extension_cpp',
-                sources=GREENLET_TEST_DIR + '_test_extension_cpp.cpp',
-                language="c++",
-                include_dirs=GREENLET_HEADER_DIR),
-        )
-
 
 def get_greenlet_version():
-    with open('src/greenlet/__init__.py') as f:
+    with open('src/greenlet/__init__.py') as f: # pylint:disable=unspecified-encoding
         looking_for = '__version__ = \''
         for line in f:
             if line.startswith(looking_for):
@@ -116,7 +208,7 @@
     author="Alexey Borzenkov",
     author_email="snaury@gmail.com",
     maintainer='Jason Madden',
-    maintainer_email='jason@nextthought.com',
+    maintainer_email='jason@seecoresoftware.com',
     project_urls={
         'Bug Tracker': 'https://github.com/python-greenlet/greenlet/issues',
         'Source Code': 'https://github.com/python-greenlet/greenlet/',
@@ -145,14 +237,22 @@
         'Programming Language :: Python :: 3.8',
         'Programming Language :: Python :: 3.9',
         'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
         'Operating System :: OS Independent',
         'Topic :: Software Development :: Libraries :: Python Modules'
     ,
     extras_require={
         'docs': 
             'Sphinx',
+            # 0.18b1 breaks sphinx 1.8.5 which is the latest version that runs
+            # on Python 2. The version pin sphinx itself contains isn't specific enough.
+            'docutils < 0.18; python_version < "3"',
         ,
         'test': 
+            'objgraph',
+            # Sigh, all releases of this were yanked from PyPI.
+            #'faulthandler; python_version == "2.7" and platform_python_implementation == "CPython"',
+            'psutil',
         ,
     },
     python_requires=">=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*",

_service:tar_scm:greenlet-1.1.2.tar.gz/src/greenlet.egg-info/PKG-INFO -> _service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet.egg-info/PKG-INFO Changed

_service:tar_scm:greenlet-1.1.2.tar.gz/src/greenlet.egg-info/SOURCES.txt -> _service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet.egg-info/SOURCES.txt Changed

@@ -1,4 +1,6 @@
 .clang-format
+.gitignore
+.pylintrc
 .readthedocs.yml
 AUTHORS
 CHANGES.rst
@@ -35,8 +37,19 @@
 docs/switching.rst
 docs/tracing.rst
 src/greenlet/__init__.py
-src/greenlet/greenlet.c
+src/greenlet/greenlet.cpp
 src/greenlet/greenlet.h
+src/greenlet/greenlet_allocator.hpp
+src/greenlet/greenlet_compiler_compat.hpp
+src/greenlet/greenlet_cpython_compat.hpp
+src/greenlet/greenlet_exceptions.hpp
+src/greenlet/greenlet_greenlet.hpp
+src/greenlet/greenlet_internal.hpp
+src/greenlet/greenlet_refs.hpp
+src/greenlet/greenlet_slp_switch.hpp
+src/greenlet/greenlet_thread_state.hpp
+src/greenlet/greenlet_thread_state_dict_cleanup.hpp
+src/greenlet/greenlet_thread_support.hpp
 src/greenlet/slp_platformselect.h
 src/greenlet.egg-info/PKG-INFO
 src/greenlet.egg-info/SOURCES.txt
@@ -44,12 +57,16 @@
 src/greenlet.egg-info/not-zip-safe
 src/greenlet.egg-info/requires.txt
 src/greenlet.egg-info/top_level.txt
+src/greenlet/platform/__init__.py
 src/greenlet/platform/setup_switch_x64_masm.cmd
 src/greenlet/platform/switch_aarch64_gcc.h
 src/greenlet/platform/switch_alpha_unix.h
 src/greenlet/platform/switch_amd64_unix.h
 src/greenlet/platform/switch_arm32_gcc.h
 src/greenlet/platform/switch_arm32_ios.h
+src/greenlet/platform/switch_arm64_masm.asm
+src/greenlet/platform/switch_arm64_masm.obj
+src/greenlet/platform/switch_arm64_msvc.h
 src/greenlet/platform/switch_csky_gcc.h
 src/greenlet/platform/switch_m68k_gcc.h
 src/greenlet/platform/switch_mips_unix.h
@@ -71,6 +88,7 @@
 src/greenlet/tests/__init__.py
 src/greenlet/tests/_test_extension.c
 src/greenlet/tests/_test_extension_cpp.cpp
+src/greenlet/tests/leakcheck.py
 src/greenlet/tests/test_contextvars.py
 src/greenlet/tests/test_cpp.py
 src/greenlet/tests/test_extension_interface.py
@@ -78,6 +96,7 @@
 src/greenlet/tests/test_generator.py
 src/greenlet/tests/test_generator_nested.py
 src/greenlet/tests/test_greenlet.py
+src/greenlet/tests/test_greenlet_trash.py
 src/greenlet/tests/test_leaks.py
 src/greenlet/tests/test_stack_saved.py
 src/greenlet/tests/test_throw.py

_service:tar_scm:greenlet-1.1.2.tar.gz/src/greenlet.egg-info/requires.txt -> _service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet.egg-info/requires.txt Changed

_service:tar_scm:greenlet-1.1.2.tar.gz/src/greenlet/__init__.py -> _service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/__init__.py Changed

_service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/greenlet.cpp Added

@@ -0,0 +1,3256 @@
+/* -*- indent-tabs-mode: nil; tab-width: 4; -*- */
+/* Format with:
+ *  clang-format -i --style=file src/greenlet/greenlet.c
+ *
+ *
+ * Fix missing braces with:
+ *   clang-tidy src/greenlet/greenlet.c -fix -checks="readability-braces-around-statements"
+*/
+#include <cstdlib>
+#include <string>
+#include <algorithm>
+#include <exception>
+
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include "structmember.h" // PyMemberDef
+
+#include "greenlet_internal.hpp"
+#include "greenlet_refs.hpp"
+#include "greenlet_slp_switch.hpp"
+#include "greenlet_thread_state.hpp"
+#include "greenlet_thread_support.hpp"
+#include "greenlet_greenlet.hpp"
+
+using greenlet::ThreadState;
+using greenlet::Mutex;
+using greenlet::LockGuard;
+using greenlet::LockInitError;
+using greenlet::PyErrOccurred;
+using greenlet::Require;
+using greenlet::PyFatalError;
+using greenlet::ExceptionState;
+using greenlet::StackState;
+using greenlet::Greenlet;
+
+
+// Helpers for reference counting.
+// XXX: running the test cases for greenlet 1.1.2 under Python 3.10+pydebug
+// with zope.testrunner's "report refcounts" option shows a growth of
+// over 500 references when running 90 tests at a steady state (10 repeats)
+// Running in verbose mode and adding objgraph to report gives us this
+// info in a steady state:
+//   Ran 90 tests with 0 failures, 0 errors and 1 skipped in 2.120 seconds.
+// Showing growth
+// tuple                 2811       +16
+// list                  1733       +14
+// function              6304       +11
+// dict                  3604        +9
+// cell                   707        +9
+// greenlet                81        +8
+// method                 103        +5
+// Genlet                  40        +4
+// list_iterator           30        +3
+// getset_descriptor      916        +2
+//   sum detail refcount=341678   sys refcount=379357   change=523
+//     Leak details, changes in instances and refcounts by type/class:
+//     type/class                                               insts   refs
+//     -------------------------------------------------------  -----   ----
+//     builtins.NoneType                                            0      2
+//     builtins.cell                                                9     20
+//     builtins.code                                                0     31
+//     builtins.dict                                               18     91
+//     builtins.frame                                              20     32
+//     builtins.function                                           11     28
+//     builtins.getset_descriptor                                   2      2
+//     builtins.int                                                 2     42
+//     builtins.list                                               14     37
+//     builtins.list_iterator                                       3      3
+//     builtins.method                                              5      5
+//     builtins.method_descriptor                                   0      9
+//     builtins.str                                                11     76
+//     builtins.traceback                                           1      2
+//     builtins.tuple                                              20     42
+//     builtins.type                                                2     28
+//     builtins.weakref                                             2      2
+//     greenlet.GreenletExit                                        1      1
+//     greenlet.greenlet                                            8     26
+//     greenlet.tests.test_contextvars.NoContextVarsTests           0      1
+//     greenlet.tests.test_gc.object_with_finalizer                 1      1
+//     greenlet.tests.test_generator_nested.Genlet                  4     26
+//     greenlet.tests.test_greenlet.convoluted                      1      2
+//     -------------------------------------------------------  -----   ----
+//     total                                                      135    509
+//
+// As of the commit that adds this comment, we're doing better than
+// 1.1.2, but still not perfect:
+//   Ran 115 tests with 0 failures, 0 errors, 1 skipped in 8.623 seconds.
+// tuple            21310       +23
+// dict              5428       +18
+// frame              183       +17
+// list              1760       +14
+// function          6359       +11
+// cell               698        +8
+// method             105        +5
+// int               2709        +4
+// TheGenlet           40        +4
+// list_iterator       30        +3
+//   sum detail refcount=345051   sys refcount=383043   change=494
+//     Leak details, changes in instances and refcounts by type/class:
+//     type/class                                               insts   refs
+//     -------------------------------------------------------  -----   ----
+//     builtins.NoneType                                            0     12
+//     builtins.bool                                                0      2
+//     builtins.cell                                                8     16
+//     builtins.code                                                0     28
+//     builtins.dict                                               18     74
+//     builtins.frame                                              17     28
+//     builtins.function                                           11     28
+//     builtins.getset_descriptor                                   2      2
+//     builtins.int                                                 4     44
+//     builtins.list                                               14     39
+//     builtins.list_iterator                                       3      3
+//     builtins.method                                              5      5
+//     builtins.method_descriptor                                   0      8
+//     builtins.str                                                -2     69
+//     builtins.tuple                                              23     42
+//     builtins.type                                                2     28
+//     builtins.weakref                                             2      2
+//     greenlet.greenlet                                            1      1
+//     greenlet.main_greenlet                                       1     16
+//     greenlet.tests.test_contextvars.NoContextVarsTests           0      1
+//     greenlet.tests.test_gc.object_with_finalizer                 1      1
+//     greenlet.tests.test_generator_nested.TheGenlet               4     29
+//     greenlet.tests.test_greenlet.convoluted                      1      2
+//     greenlet.tests.test_leaks.HasFinalizerTracksInstances        2      2
+//     -------------------------------------------------------  -----   ----
+//     total                                                      117    482
+
+using greenlet::refs::BorrowedObject;
+using greenlet::refs::BorrowedGreenlet;
+using greenlet::refs::BorrowedMainGreenlet;
+using greenlet::refs::OwnedObject;
+using greenlet::refs::PyErrFetchParam;
+using greenlet::refs::PyArgParseParam;
+using greenlet::refs::ImmortalString;
+using greenlet::refs::ImmortalObject;
+using greenlet::refs::CreatedModule;
+using greenlet::refs::PyErrPieces;
+using greenlet::refs::PyObjectPointer;
+using greenlet::Greenlet;
+using greenlet::UserGreenlet;
+using greenlet::MainGreenlet;
+
+
+// ******* Implementation of things from included files
+template<typename T, greenlet::refs::TypeChecker TC>
+greenlet::refs::_BorrowedGreenlet<T, TC>& greenlet::refs::_BorrowedGreenlet<T, TC>::operator=(const greenlet::refs::BorrowedObject& other)
+{
+    this->_set_raw_pointer(static_cast<PyObject*>(other));
+    return *this;
+}
+
+template <typename T, greenlet::refs::TypeChecker TC>
+inline greenlet::refs::_BorrowedGreenlet<T, TC>::operator Greenlet*() const G_NOEXCEPT
+{
+    if (!this->p) {
+        return nullptr;
+    }
+    return reinterpret_cast<PyGreenlet*>(this->p)->pimpl;
+}
+
+template<typename T, greenlet::refs::TypeChecker TC>
+greenlet::refs::_BorrowedGreenlet<T, TC>::_BorrowedGreenlet(const BorrowedObject& p)
+    : BorrowedReference<T, TC>(nullptr)
+{
+
+    this->_set_raw_pointer(p.borrow());
+}
+
+template <typename T, greenlet::refs::TypeChecker TC>
+inline greenlet::refs::_OwnedGreenlet<T, TC>::operator Greenlet*() const G_NOEXCEPT
+{
+    if (!this->p) {
+        return nullptr;
+    }
+    return reinterpret_cast<PyGreenlet*>(this->p)->pimpl;
+}
+
+
+
+#ifdef __clang__
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wmissing-field-initializers"
+#    pragma clang diagnostic ignored "-Wwritable-strings"
+#elif defined(__GNUC__)
+#    pragma GCC diagnostic push
+//  warning: ISO C++ forbids converting a string constant to ‘char*’
+// (The python APIs aren't const correct and accept writable char*)
+#    pragma GCC diagnostic ignored "-Wwrite-strings"
+#endif
+
+
+/***********************************************************
+
+A PyGreenlet is a range of C stack addresses that must be
+saved and restored in such a way that the full range of the
+stack contains valid data when we switch to it.
+
+Stack layout for a greenlet:
+
+               |     ^^^       |
+               |  older data   |
+               |               |
+  stack_stop . |_______________|
+        .      |               |
+        .      | greenlet data |
+        .      |   in stack    |
+        .    * |_______________| . .  _____________  stack_copy + stack_saved
+        .      |               |     |             |
+        .      |     data      |     |greenlet data|
+        .      |   unrelated   |     |    saved    |
+        .      |      to       |     |   in heap   |
+ stack_start . |     this      | . . |_____________| stack_copy
+               |   greenlet    |
+               |               |
+               |  newer data   |
+               |     vvv       |
+
+
+Note that a greenlet's stack data is typically partly at its correct
+place in the stack, and partly saved away in the heap, but always in
+the above configuration: two blocks, the more recent one in the heap
+and the older one still in the stack (either block may be empty).
+
+Greenlets are chained: each points to the previous greenlet, which is
+the one that owns the data currently in the C stack above my
+stack_stop.  The currently running greenlet is the first element of
+this chain.  The main (initial) greenlet is the last one.  Greenlets
+whose stack is entirely in the heap can be skipped from the chain.
+
+The chain is not related to execution order, but only to the order
+in which bits of C stack happen to belong to greenlets at a particular
+point in time.
+
+The main greenlet doesn't have a stack_stop: it is responsible for the
+complete rest of the C stack, and we don't know where it begins.  We
+use (char*) -1, the largest possible address.
+
+States:
+  stack_stop == NULL && stack_start == NULL:  did not start yet
+  stack_stop != NULL && stack_start == NULL:  already finished
+  stack_stop != NULL && stack_start != NULL:  active
+
+The running greenlet's stack_start is undefined but not NULL.
+
+ ***********************************************************/
+
+/*** global state ***/
+
+/* In the presence of multithreading, this is a bit tricky; see
+   greenlet_thread_state.hpp for details.
+*/
+
+
+static inline OwnedObject
+single_result(const OwnedObject& results)
+{
+    if (results
+        && PyTuple_Check(results.borrow())
+        && PyTuple_GET_SIZE(results.borrow()) == 1) {
+        PyObject* result = PyTuple_GET_ITEM(results.borrow(), 0);
+        return OwnedObject::owning(result);
+    }
+    return results;
+}
+
+
+
+class ImmortalEventName : public ImmortalString
+{
+private:
+    G_NO_COPIES_OF_CLS(ImmortalEventName);
+public:
+    ImmortalEventName(const char* const str) : ImmortalString(str)
+    {}
+};
+
+class ImmortalException : public ImmortalObject
+{
+private:
+    G_NO_COPIES_OF_CLS(ImmortalException);
+public:
+    ImmortalException(const char* const name, PyObject* base=nullptr) :
+        ImmortalObject(name
+                       // Python 2.7 isn't const correct
+                       ? Require(PyErr_NewException((char*)name, base, nullptr))
+                       : nullptr)
+    {}
+
+    inline bool PyExceptionMatches() const
+    {
+        return PyErr_ExceptionMatches(this->p) > 0;
+    }
+
+};
+
+// This encapsulates what were previously module global "constants"
+// established at init time.
+// This is a step towards Python3 style module state that allows
+// reloading.
+// We play some tricks with placement new to be able to allocate this
+// object statically still, so that references to its members don't
+// incur an extra pointer indirection.
+class GreenletGlobals
+{
+public:
+    const ImmortalEventName event_switch;
+    const ImmortalEventName event_throw;
+    const ImmortalException PyExc_GreenletError;
+    const ImmortalException PyExc_GreenletExit;
+    const ImmortalObject empty_tuple;
+    const ImmortalObject empty_dict;
+    const ImmortalString str_run;
+    Mutex* const thread_states_to_destroy_lock;
+    greenlet::cleanup_queue_t thread_states_to_destroy;
+
+    GreenletGlobals(const int UNUSED(dummy)) :
+        event_switch(0),
+        event_throw(0),
+        PyExc_GreenletError(0),
+        PyExc_GreenletExit(0),
+        empty_tuple(0),
+        empty_dict(0),
+        str_run(0),
+        thread_states_to_destroy_lock(0)
+    {}
+
+    GreenletGlobals() :
+        event_switch("switch"),
+        event_throw("throw"),
+        PyExc_GreenletError("greenlet.error"),
+        PyExc_GreenletExit("greenlet.GreenletExit", PyExc_BaseException),
+        empty_tuple(Require(PyTuple_New(0))),
+        empty_dict(Require(PyDict_New())),
+        str_run("run"),
+        thread_states_to_destroy_lock(new Mutex())
+    {}
+
+    ~GreenletGlobals()
+    {
+        // This object is (currently) effectively immortal, and not
+        // just because of those placement new tricks; if we try to
+        // deallocate the static object we allocated, and overwrote,
+        // we would be doing so at C++ teardown time, which is after
+        // the final Python GIL is released, and we can't use the API
+        // then.
+        // (The members will still be destructed, but they also don't
+        // do any deallocation.)
+    }
+
+    void queue_to_destroy(ThreadState* ts) const
+    {
+        // we're currently accessed through a static const object,
+        // implicitly marking our members as const, so code can't just
+        // call push_back (or pop_back) without casting away the
+        // const.
+        //
+        // Do that for callers.
+        greenlet::cleanup_queue_t& q = const_cast<greenlet::cleanup_queue_t&>(this->thread_states_to_destroy);
+        q.push_back(ts);
+    }
+
+    ThreadState* take_next_to_destroy() const
+    {
+        greenlet::cleanup_queue_t& q = const_cast<greenlet::cleanup_queue_t&>(this->thread_states_to_destroy);
+        ThreadState* result = q.back();
+        q.pop_back();
+        return result;
+    }
+};
+
+static const GreenletGlobals mod_globs(0);
+
+// Protected by the GIL. Incremented when we create a main greenlet,
+// in a new thread, decremented when it is destroyed.
+static Py_ssize_t total_main_greenlets;
+
+struct ThreadState_DestroyWithGIL
+{
+    ThreadState_DestroyWithGIL(ThreadState* state)
+    {
+        if (state && state->has_main_greenlet()) {
+            DestroyWithGIL(state);
+        }
+    }
+
+    static int
+    DestroyWithGIL(ThreadState* state)
+    {
+        // Holding the GIL.
+        // Passed a non-shared pointer to the actual thread state.
+        // state -> main greenlet
+        assert(state->has_main_greenlet());
+        PyGreenlet* main(state->borrow_main_greenlet());
+        // When we need to do cross-thread operations, we check this.
+        // A NULL value means the thread died some time ago.
+        // We do this here, rather than in a Python dealloc function
+        // for the greenlet, in case there's still a reference out
+        // there.
+        static_cast<MainGreenlet*>(main->pimpl)->thread_state(nullptr);
+
+        delete state; // Deleting this runs the destructor, DECREFs the main greenlet.
+        return 0;
+    }
+};
+
+#if (PY_VERSION_HEX >= 0x30800A0 && PY_VERSION_HEX < 0x3090000) && !(defined(_WIN32) || defined(WIN32))
+// XXX: From Python 3.8a3 1 up until Python 3.9a6 23,
+// ``Py_AddPendingCall`` would try to produce a Python exception if
+// the interpreter was in the beginning of shutting down when this
+// function is called. However, ``Py_AddPendingCall`` doesn't require
+// the GIL, and we are absolutely not holding it when we make that
+// call. That means that trying to create the Python exception is
+// using the C API in an undefined state; here the C API detects this
+// and aborts the process with an error ("Fatal Python error: Python
+// memory allocator called without holding the GIL": Add ->
+// PyErr_SetString -> PyUnicode_New -> PyObject_Malloc). This arises
+// (obviously) in multi-threaded programs and happens if one thread is
+// exiting and cleaning up its thread-local data while the other
+// thread is trying to shut down the interpreter. A crash on shutdown
+// is still a crash and could result in data loss (e.g., daemon
+// threads are still running, pending signal handlers may be present,
+// buffers may not be flushed, there may be __del__ that need run,
+// etc), so we have to work around it.
+//
+// Of course, we can (and do) check for whether the interpreter is
+// shutting down before calling ``Py_AddPendingCall``, but that's a
+// race condition since we don't hold the GIL, and so we may not
+// actually get the right answer. Plus, ``Py_FinalizeEx`` actually
+// calls ``_Py_FinishPendingCalls`` (which sets the pending->finishing
+// flag, which is used to gate creating the exceptioen) *before*
+// publishing any other data that would let us detect the shutdown
+// (such as runtime->finalizing). So that point is moot.
+//
+// Our solution for those versions is to inline the same code, without
+// the problematic bit that sets the exception. Unfortunately, all of
+// the structure definitions are private/opaque, *and* we can't
+// actually count on being able to include their definitions from
+// ``internal/pycore_*``, because on some platforms those header files
+// are incomplete (i.e., on macOS with macports 3.8, the includes are
+// fine, but on Ubuntu jammy with 3.8 from ppa:deadsnakes or GitHub
+// Actions 3.8 (I think it's Ubuntu 18.04), they con't be used; at
+// least, I couldn't get them to work). So we need to define the
+// structures and _PyRuntime data member ourself. Yet more
+// unfortunately, _PyRuntime  won't link on Windows, so we can only do
+// this on other platforms.
+//
+// 1 https://github.com/python/cpython/commit/842a2f07f2f08a935ef470bfdaeef40f87490cfc
+// 2 https://github.com/python/cpython/commit/cfc3c2f8b34d3864717ab584c5b6c260014ba55a
+// 3 https://github.com/python/cpython/issues/81308
+# define GREENLET_BROKEN_PY_ADD_PENDING 1
+
+// When defining these structures, the important thing is to get
+// binary compatibility, i.e., structure layout. For that, we only
+// need to define fields up to the ones we use; after that they're
+// irrelevant UNLESS the structure is included in another structure
+// *before* the structure we're interested in --- in that case, it
+// must be complete. Ellipsis indicate elided trailing members.
+// Pointer types are changed to void* to keep from having to define
+// more structures.
+
+// From "internal/pycore_atomic.h"
+
+// There are several different definitions of this, including the
+// plain ``int`` version, a ``volatile int`` and an ``_Atomic int``
+// I don't think any of those change the size/layout.
+typedef struct _Py_atomic_int {
+    volatile int _value;
+} _Py_atomic_int;
+
+// This needs too much infrastructure, so we just do a regular store.
+#define _Py_atomic_store_relaxed(ATOMIC_VAL, NEW_VAL) \
+    (ATOMIC_VAL)->_value = NEW_VAL
+
+
+
+// From "internal/pycore_pymem.h"
+#define NUM_GENERATIONS 3
+
+
+struct gc_generation {
+    PyGC_Head head; // We already have this defined.
+    int threshold;
+    int count;
+};
+struct gc_generation_stats {
+    Py_ssize_t collections;
+    Py_ssize_t collected;
+    Py_ssize_t uncollectable;
+};
+
+struct _gc_runtime_state {
+    void *trash_delete_later;
+    int trash_delete_nesting;
+    int enabled;
+    int debug;
+    struct gc_generation generationsNUM_GENERATIONS;
+    void *generation0;
+    struct gc_generation permanent_generation;
+    struct gc_generation_stats generation_statsNUM_GENERATIONS;
+    int collecting;
+    void *garbage;
+    void *callbacks;
+    Py_ssize_t long_lived_total;
+    Py_ssize_t long_lived_pending;
+};
+
+// From "internal/pycore_pystate.h"
+struct _pending_calls {
+    int finishing;
+    PyThread_type_lock lock;
+    _Py_atomic_int calls_to_do;
+    int async_exc;
+#define NPENDINGCALLS 32
+    struct {
+        int (*func)(void *);
+        void *arg;
+    } callsNPENDINGCALLS;
+    int first;
+    int last;
+};
+
+struct _ceval_runtime_state {
+    int recursion_limit;
+    int tracing_possible;
+    _Py_atomic_int eval_breaker;
+    _Py_atomic_int gil_drop_request;
+    struct _pending_calls pending;
+    // ...
+};
+
+typedef struct pyruntimestate {
+    int preinitializing;
+    int preinitialized;
+    int core_initialized;
+    int initialized;
+    void *finalizing;
+
+    struct pyinterpreters {
+        PyThread_type_lock mutex;
+        void *head;
+        void *main;
+        int64_t next_id;
+    } interpreters;
+    // XXX Remove this field once we have a tp_* slot.
+    struct _xidregistry {
+        PyThread_type_lock mutex;
+        void *head;
+    } xidregistry;
+
+    unsigned long main_thread;
+
+#define NEXITFUNCS 32
+    void (*exitfuncsNEXITFUNCS)(void);
+    int nexitfuncs;
+
+    struct _gc_runtime_state gc;
+    struct _ceval_runtime_state ceval;
+    // ...
+} _PyRuntimeState;
+
+#define SIGNAL_PENDING_CALLS(ceval) \
+    do { \
+        _Py_atomic_store_relaxed(&(ceval)->pending.calls_to_do, 1); \
+        _Py_atomic_store_relaxed(&(ceval)->eval_breaker, 1); \
+    } while (0)
+
+extern _PyRuntimeState _PyRuntime;
+
+#else
+# define GREENLET_BROKEN_PY_ADD_PENDING 0
+#endif
+
+
+struct ThreadState_DestroyNoGIL
+{
+#if GREENLET_BROKEN_PY_ADD_PENDING
+    static int _push_pending_call(struct _pending_calls *pending,
+                                  int (*func)(void *), void *arg)
+    {
+        int i = pending->last;
+        int j = (i + 1) % NPENDINGCALLS;
+        if (j == pending->first) {
+            return -1; /* Queue full */
+        }
+        pending->callsi.func = func;
+        pending->callsi.arg = arg;
+        pending->last = j;
+        return 0;
+    }
+
+    static int AddPendingCall(int (*func)(void *), void *arg)
+    {
+        _PyRuntimeState *runtime = &_PyRuntime;
+        if (!runtime) {
+            // obviously impossible
+            return 0;
+        }
+        struct _pending_calls *pending = &runtime->ceval.pending;
+        if (!pending->lock) {
+            return 0;
+        }
+        int result = 0;
+        PyThread_acquire_lock(pending->lock, WAIT_LOCK);
+        if (!pending->finishing) {
+            result = _push_pending_call(pending, func, arg);
+        }
+        PyThread_release_lock(pending->lock);
+        SIGNAL_PENDING_CALLS(&runtime->ceval);
+        return result;
+    }
+#else
+    // Python < 3.8 or >= 3.9
+    static int AddPendingCall(int (*func)(void*), void* arg)
+    {
+        return Py_AddPendingCall(func, arg);
+    }
+#endif
+
+    ThreadState_DestroyNoGIL(ThreadState* state)
+    {
+        // We are *NOT* holding the GIL. Our thread is in the middle
+        // of its death throes and the Python thread state is already
+        // gone so we can't use most Python APIs. One that is safe is
+        // ``Py_AddPendingCall``, unless the interpreter itself has
+        // been torn down. There is a limited number of calls that can
+        // be queued: 32 (NPENDINGCALLS) in CPython 3.10, so we
+        // coalesce these calls using our own queue.
+        if (state && state->has_main_greenlet()) {
+            // mark the thread as dead ASAP.
+            // this is racy! If we try to throw or switch to a
+            // greenlet from this thread from some other thread before
+            // we clear the state pointer, it won't realize the state
+            // is dead which can crash the process.
+            PyGreenlet* p = state->borrow_main_greenlet();
+            assert(p->pimpl->thread_state() == state || p->pimpl->thread_state() == nullptr);
+            static_cast<MainGreenlet*>(p->pimpl)->thread_state(nullptr);
+        }
+
+        // NOTE: Because we're not holding the GIL here, some other
+        // Python thread could run and call ``os.fork()``, which would
+        // be bad if that happenend while we are holding the cleanup
+        // lock (it wouldn't function in the child process).
+        // Make a best effort to try to keep the duration we hold the
+        // lock short.
+        // TODO: On platforms that support it, use ``pthread_atfork`` to
+        // drop this lock.
+        LockGuard cleanup_lock(*mod_globs.thread_states_to_destroy_lock);
+
+        if (state && state->has_main_greenlet()) {
+            // Because we don't have the GIL, this is a race condition.
+            if (!PyInterpreterState_Head()) {
+                // We have to leak the thread state, if the
+                // interpreter has shut down when we're getting
+                // deallocated, we can't run the cleanup code that
+                // deleting it would imply.
+                return;
+            }
+
+            mod_globs.queue_to_destroy(state);
+            if (mod_globs.thread_states_to_destroy.size() == 1) {
+                // We added the first item to the queue. We need to schedule
+                // the cleanup.
+                int result = ThreadState_DestroyNoGIL::AddPendingCall(
+                    ThreadState_DestroyNoGIL::DestroyQueueWithGIL,
+                    NULL);
+                if (result < 0) {
+                    // Hmm, what can we do here?
+                    fprintf(stderr,
+                            "greenlet: WARNING: failed in call to Py_AddPendingCall; "
+                            "expect a memory leak.\n");
+                }
+            }
+        }
+    }
+
+    static int
+    DestroyQueueWithGIL(void* UNUSED(arg))
+    {
+        // We're holding the GIL here, so no Python code should be able to
+        // run to call ``os.fork()``.
+        while (1) {
+            ThreadState* to_destroy;
+            {
+                LockGuard cleanup_lock(*mod_globs.thread_states_to_destroy_lock);
+                if (mod_globs.thread_states_to_destroy.empty()) {
+                    break;
+                }
+                to_destroy = mod_globs.take_next_to_destroy();
+            }
+            // Drop the lock while we do the actual deletion.
+            ThreadState_DestroyWithGIL::DestroyWithGIL(to_destroy);
+        }
+        return 0;
+    }
+
+};
+
+// The intent when GET_THREAD_STATE() is used multiple times in a function is to
+// take a reference to it in a local variable, to avoid the
+// thread-local indirection. On some platforms (macOS),
+// accessing a thread-local involves a function call (plus an initial
+// function call in each function that uses a thread local); in
+// contrast, static volatile variables are at some pre-computed offset.
+
+#if G_USE_STANDARD_THREADING == 1
+typedef greenlet::ThreadStateCreator<ThreadState_DestroyNoGIL> ThreadStateCreator;
+static G_THREAD_LOCAL_VAR ThreadStateCreator g_thread_state_global;
+#define GET_THREAD_STATE() g_thread_state_global
+#else
+// if we're not using standard threading, we're using
+// the Python thread-local dictionary to perform our cleanup,
+// which means we're deallocated when holding the GIL. The
+// thread state is valid enough still for us to destroy
+// stuff.
+typedef greenlet::ThreadStateCreator<ThreadState_DestroyWithGIL> ThreadStateCreator;
+#define G_THREAD_STATE_DICT_CLEANUP_TYPE
+#include "greenlet_thread_state_dict_cleanup.hpp"
+typedef greenlet::refs::OwnedReference<PyGreenletCleanup> OwnedGreenletCleanup;
+// RECALL: legacy thread-local objects (__thread on GCC, __declspec(thread) on
+// MSVC) can't have constructors or destructors, they have to be
+// constant. So we indirect through a pointer and a function.
+static G_THREAD_LOCAL_VAR ThreadStateCreator* _g_thread_state_global_ptr = nullptr;
+static ThreadStateCreator& GET_THREAD_STATE()
+{
+    if (!_g_thread_state_global_ptr) {
+        // NOTE: If any of this fails, we'll probably go on to hard
+        // crash the process, because we're returning a reference to a
+        // null pointer. we've called Py_FatalError(), but have no way
+        // to communicate that to the caller. Since these should
+        // essentially never fail unless the entire process is borked,
+        // a hard crash with a decent C++ backtrace from the exception
+        // is much more useful.
+        _g_thread_state_global_ptr = new ThreadStateCreator();
+        if (!_g_thread_state_global_ptr) {
+            throw PyFatalError("greenlet: Failed to create greenlet thread state.");
+        }
+
+        OwnedGreenletCleanup cleanup(OwnedGreenletCleanup::consuming(PyType_GenericAlloc(&PyGreenletCleanup_Type, 0)));
+        if (!cleanup) {
+            throw PyFatalError("greenlet: Failed to create greenlet thread state cleanup.");
+        }
+
+        cleanup->thread_state_creator = _g_thread_state_global_ptr;
+        assert(PyObject_GC_IsTracked(cleanup.borrow_o()));
+
+        PyObject* ts_dict_w = PyThreadState_GetDict();
+        if (!ts_dict_w) {
+            throw PyFatalError("greenlet: Failed to get Python thread state.");
+        }
+        if (PyDict_SetItemString(ts_dict_w, "__greenlet_cleanup", cleanup.borrow_o()) < 0) {
+            throw PyFatalError("greenlet: Failed to save cleanup key in Python thread state.");
+        }
+    }
+    return *_g_thread_state_global_ptr;
+}
+#endif
+
+
+Greenlet::Greenlet(PyGreenlet* p)
+{
+    p ->pimpl = this;
+}
+
+Greenlet::Greenlet(PyGreenlet* p, const StackState& initial_stack)
+    : stack_state(initial_stack)
+{
+    // can't use a delegating constructor because of
+    // MSVC for Python 2.7
+    p->pimpl = this;
+}
+
+UserGreenlet::UserGreenlet(PyGreenlet* p,BorrowedGreenlet the_parent)
+    : Greenlet(p), _parent(the_parent)
+{
+    this->_self = p;
+}
+
+
+MainGreenlet::MainGreenlet(PyGreenlet* p, ThreadState* state)
+    : Greenlet(p, StackState::make_main()),
+      _self(p),
+      _thread_state(state)
+{
+    total_main_greenlets++;
+}
+
+ThreadState*
+MainGreenlet::thread_state() const G_NOEXCEPT
+{
+    return this->_thread_state;
+}
+
+void
+MainGreenlet::thread_state(ThreadState* t) G_NOEXCEPT
+{
+    assert(!t);
+    this->_thread_state = t;
+}
+
+BorrowedGreenlet
+UserGreenlet::self() const G_NOEXCEPT
+{
+    return this->_self;
+}
+
+BorrowedGreenlet
+MainGreenlet::self() const G_NOEXCEPT
+{
+    return BorrowedGreenlet(this->_self.borrow());
+}
+
+const BorrowedMainGreenlet
+UserGreenlet::main_greenlet() const
+{
+    return this->_main_greenlet;
+}
+
+const BorrowedMainGreenlet
+MainGreenlet::main_greenlet() const
+{
+    return this->_self;
+}
+
+static PyGreenlet*
+green_create_main(ThreadState* state)
+{
+    PyGreenlet* gmain;
+
+    /* create the main greenlet for this thread */
+    gmain = (PyGreenlet*)PyType_GenericAlloc(&PyGreenlet_Type, 0);
+    if (gmain == NULL) {
+        Py_FatalError("green_create_main failed to alloc");
+        return NULL;
+    }
+    new MainGreenlet(gmain, state);
+
+    assert(Py_REFCNT(gmain) == 1);
+    return gmain;
+}
+
+
+BorrowedMainGreenlet
+UserGreenlet::find_main_greenlet_in_lineage() const
+{
+    if (this->started()) {
+        assert(this->_main_greenlet);
+        return BorrowedMainGreenlet(this->_main_greenlet);
+    }
+
+    if (!this->_parent) {
+        /* garbage collected greenlet in chain */
+        // XXX: WHAT?
+        return BorrowedMainGreenlet(nullptr);
+    }
+
+    return this->_parent->find_main_greenlet_in_lineage();
+}
+
+
+BorrowedMainGreenlet
+MainGreenlet::find_main_greenlet_in_lineage() const
+{
+    return BorrowedMainGreenlet(this->_self);
+}
+
+/***********************************************************/
+
+/* Some functions must not be inlined:
+   * slp_restore_state, when inlined into slp_switch might cause
+     it to restore stack over its own local variables
+   * slp_save_state, when inlined would add its own local
+     variables to the saved stack, wasting space
+   * slp_switch, cannot be inlined for obvious reasons
+   * g_initialstub, when inlined would receive a pointer into its
+     own stack frame, leading to incomplete stack save/restore
+
+g_initialstub is a member function and declared virtual so that the
+compiler always calls it through a vtable.
+
+slp_save_state and slp_restore_state are also member functions. They
+are called from trampoline functions that themselves are declared as
+not eligible for inlining.
+*/
+
+
+
+/* add forward declarations */
+
+
+static void
+g_calltrace(const OwnedObject& tracefunc,
+            const ImmortalEventName& event,
+            const BorrowedGreenlet& origin,
+            const BorrowedGreenlet& target);
+
+static OwnedObject
+g_handle_exit(const OwnedObject& greenlet_result);
+
+
+
+
+
+/**
+ * CAUTION: May invoke arbitrary Python code.
+ *
+ * Figure out what the result of ``greenlet.switch(arg, kwargs)``
+ * should be and transfers ownership of it to the left-hand-side.
+ *
+ * If switch() was just passed an arg tuple, then we'll just return that.
+ * If only keyword arguments were passed, then we'll pass the keyword
+ * argument dict. Otherwise, we'll create a tuple of (args, kwargs) and
+ * return both.
+ */
+OwnedObject& operator<<=(OwnedObject& lhs, greenlet::SwitchingArgs& rhs) G_NOEXCEPT
+{
+    // Because this may invoke arbitrary Python code, which could
+    // result in switching back to us, we need to get the
+    // arguments locally on the stack.
+    assert(rhs);
+    OwnedObject args = rhs.args();
+    OwnedObject kwargs = rhs.kwargs();
+    rhs.CLEAR();
+    // We shouldn't be called twice for the same switch.
+    assert(args || kwargs);
+    assert(!rhs);
+
+    if (!kwargs) {
+        lhs = args;
+    }
+    else if (!PyDict_Size(kwargs.borrow())) {
+        lhs = args;
+    }
+    else if (!PySequence_Length(args.borrow())) {
+        lhs = kwargs;
+    }
+    else {
+        lhs = OwnedObject::consuming(PyTuple_Pack(2, args.borrow(), kwargs.borrow()));
+    }
+    return lhs;
+}
+
+
+
+void Greenlet::release_args()
+{
+    this->switch_args.CLEAR();
+}
+
+
+void* UserGreenlet::operator new(size_t UNUSED(count))
+{
+    return allocator.allocate(1);
+}
+
+
+void UserGreenlet::operator delete(void* ptr)
+{
+    return allocator.deallocate(static_cast<UserGreenlet*>(ptr),
+                                1);
+}
+
+void* MainGreenlet::operator new(size_t UNUSED(count))
+{
+    return allocator.allocate(1);
+}
+
+
+void MainGreenlet::operator delete(void* ptr)
+{
+    return allocator.deallocate(static_cast<MainGreenlet*>(ptr),
+                                1);
+}
+
+
+OwnedObject
+Greenlet::throw_GreenletExit_during_dealloc(const ThreadState& UNUSED(current_thread_state))
+{
+    // If we're killed because we lost all references in the
+    // middle of a switch, that's ok. Don't reset the args/kwargs,
+    // we still want to pass them to the parent.
+    PyErr_SetString(mod_globs.PyExc_GreenletExit,
+                    "Killing the greenlet because all references have vanished.");
+    // To get here it had to have run before
+    return this->g_switch();
+}
+
+OwnedObject
+UserGreenlet::throw_GreenletExit_during_dealloc(const ThreadState& current_thread_state)
+{
+    /* The dying greenlet cannot be a parent of ts_current
+       because the 'parent' field chain would hold a
+       reference */
+    UserGreenlet::ParentIsCurrentGuard with_current_parent(this, current_thread_state);
+
+    // We don't care about the return value, only whether an
+    // exception happened. Whether or not an exception happens,
+    // we need to restore the parent in case the greenlet gets
+    // resurrected.
+    return Greenlet::throw_GreenletExit_during_dealloc(current_thread_state);
+}
+
+ThreadState*
+UserGreenlet::thread_state() const G_NOEXCEPT
+{
+    // TODO: maybe make this throw, if the thread state isn't there?
+    // if (!this->main_greenlet) {
+    //     throw std::runtime_error("No thread state"); // TODO: Better exception
+    // }
+    if (!this->_main_greenlet) {
+        return nullptr;
+    }
+    return this->_main_greenlet->thread_state();
+}
+
+
+
+bool
+UserGreenlet::was_running_in_dead_thread() const G_NOEXCEPT
+{
+    return this->_main_greenlet && !this->thread_state();
+}
+
+bool
+MainGreenlet::was_running_in_dead_thread() const G_NOEXCEPT
+{
+    return !this->_thread_state;
+}
+
+inline void
+Greenlet::slp_restore_state() G_NOEXCEPT
+{
+#ifdef SLP_BEFORE_RESTORE_STATE
+    SLP_BEFORE_RESTORE_STATE();
+#endif
+    this->stack_state.copy_heap_to_stack(
+           this->thread_state()->borrow_current()->stack_state);
+}
+
+
+inline int
+Greenlet::slp_save_state(char *const stackref) G_NOEXCEPT
+{
+    // XXX: This used to happen in the middle, before saving, but
+    // after finding the next owner. Does that matter? This is
+    // only defined for Sparc/GCC where it flushes register
+    // windows to the stack (I think)
+#ifdef SLP_BEFORE_SAVE_STATE
+    SLP_BEFORE_SAVE_STATE();
+#endif
+    return this->stack_state.copy_stack_to_heap(stackref,
+                                                this->thread_state()->borrow_current()->stack_state);
+}
+
+
+OwnedObject
+UserGreenlet::g_switch()
+{
+    try {
+        this->check_switch_allowed();
+    }
+    catch(const PyErrOccurred&) {
+        this->release_args();
+        throw;
+    }
+
+    // Switching greenlets used to attempt to clean out ones that need
+    // deleted *if* we detected a thread switch. Should it still do
+    // that?
+    // An issue is that if we delete a greenlet from another thread,
+    // it gets queued to this thread, and ``kill_greenlet()`` switches
+    // back into the greenlet
+
+    /* find the real target by ignoring dead greenlets,
+       and if necessary starting a greenlet. */
+    switchstack_result_t err;
+    Greenlet* target = this;
+    // TODO: probably cleaner to handle the case where we do
+    // switch to ourself separately from the other cases.
+    // This can probably even further be simplified if we keep
+    // track of the switching_state we're going for and just call
+    // into g_switch() if it's not ourself. The main problem with that
+    // is that we would be using more stack space.
+    bool target_was_me = true;
+    while (target) {
+
+        if (target->active()) {
+            if (!target_was_me) {
+                target->args() <<= this->switch_args;
+                assert(!this->switch_args);
+            }
+            err = target->g_switchstack();
+            break;
+        }
+        if (!target->started()) {
+            // We never encounter a main greenlet that's not started.
+            assert(!target->main());
+            UserGreenlet* real_target = static_cast<UserGreenlet*>(target);
+            assert(real_target);
+            void* dummymarker;
+
+            if (!target_was_me) {
+                target->args() <<= this->switch_args;
+                assert(!this->switch_args);
+            }
+
+            try {
+                // This can only throw back to us while we're
+                // still in this greenlet. Once the new greenlet
+                // is bootstrapped, it has its own exception state.
+                err = real_target->g_initialstub(&dummymarker);
+            }
+            catch (const PyErrOccurred&) {
+                this->release_args();
+                throw;
+            }
+            catch (const GreenletStartedWhileInPython&) {
+                // The greenlet was started sometime before this
+                // greenlet actually switched to it, i.e.,
+                // "concurrent" calls to switch() or throw().
+                // We need to retry the switch.
+                // Note that the current greenlet has been reset
+                // to this one (or we wouldn't be running!)
+                continue;
+            }
+            break;
+        }
+
+        target = target->parent();
+        target_was_me = false;
+    }
+    // The this pointer and all other stack or register based
+    // variables are invalid now, at least where things succeed
+    // above.
+    // But this one, probably not so much? It's not clear if it's
+    // safe to throw an exception at this point.
+
+    if (err.status < 0) {
+        // XXX: This code path is untested.
+        assert(PyErr_Occurred());
+        assert(!err.the_state_that_switched);
+        assert(!err.origin_greenlet);
+        return OwnedObject();
+    }
+
+    return err.the_state_that_switched->g_switch_finish(err);
+}
+
+OwnedObject
+MainGreenlet::g_switch()
+{
+    try {
+        this->check_switch_allowed();
+    }
+    catch(const PyErrOccurred&) {
+        this->release_args();
+        throw;
+    }
+
+    switchstack_result_t err = this->g_switchstack();
+    if (err.status < 0) {
+        // XXX: This code path is untested.
+        assert(PyErr_Occurred());
+        assert(!err.the_state_that_switched);
+        assert(!err.origin_greenlet);
+        return OwnedObject();
+    }
+
+    return err.the_state_that_switched->g_switch_finish(err);
+}
+
+
+OwnedGreenlet
+Greenlet::g_switchstack_success() G_NOEXCEPT
+{
+    PyThreadState* tstate = PyThreadState_GET();
+    // restore the saved state
+    this->python_state >> tstate;
+    this->exception_state >> tstate;
+
+    // The thread state hasn't been changed yet.
+    ThreadState* thread_state = this->thread_state();
+    OwnedGreenlet result(thread_state->get_current());
+    thread_state->set_current(this->self());
+    //assert(thread_state->borrow_current().borrow() == this->_self);
+    return result;
+}
+
+
+Greenlet::switchstack_result_t
+UserGreenlet::g_initialstub(void* mark)
+{
+    OwnedObject run;
+
+    // We need to grab a reference to the current switch arguments
+    // in case we're entered concurrently during the call to
+    // GetAttr() and have to try again.
+    // We'll restore them when we return in that case.
+    // Scope them tightly to avoid ref leaks.
+    {
+        SwitchingArgs args(this->switch_args);
+
+        /* save exception in case getattr clears it */
+        PyErrPieces saved;
+
+        /*
+          self.run is the object to call in the new greenlet.
+          This could run arbitrary python code and switch greenlets!
+        */
+        run = this->_self.PyRequireAttr(mod_globs.str_run);
+
+        /* restore saved exception */
+        saved.PyErrRestore();
+
+
+        /* recheck that it's safe to switch in case greenlet reparented anywhere above */
+        this->check_switch_allowed();
+
+        /* by the time we got here another start could happen elsewhere,
+         * that means it should now be a regular switch.
+         * This can happen if the Python code is a subclass that implements
+         * __getattribute__ or __getattr__, or makes ``run`` a descriptor;
+         * all of those can run arbitrary code that switches back into
+         * this greenlet.
+         */
+        if (this->stack_state.started()) {
+            // the successful switch cleared these out, we need to
+            // restore our version.
+            assert(!this->switch_args);
+            this->switch_args <<= args;
+
+            throw GreenletStartedWhileInPython();
+        }
+    }
+
+    // Sweet, if we got here, we have the go-ahead and will switch
+    // greenlets.
+    // Nothing we do from here on out should allow for a thread or
+    // greenlet switch: No arbitrary calls to Python, including
+    // decref'ing
+
+#if GREENLET_USE_CFRAME
+    /* OK, we need it, we're about to switch greenlets, save the state. */
+    /*
+      See green_new(). This is a stack-allocated variable used
+      while *self* is in PyObject_Call().
+      We want to defer copying the state info until we're sure
+      we need it and are in a stable place to do so.
+    */
+    _PyCFrame trace_info;
+
+    this->python_state.set_new_cframe(trace_info);
+#endif
+    /* start the greenlet */
+    ThreadState& thread_state = GET_THREAD_STATE().state();
+    this->stack_state = StackState(mark,
+                                   thread_state.borrow_current()->stack_state);
+    this->python_state.set_initial_state(PyThreadState_GET());
+    this->exception_state.clear();
+    this->_main_greenlet = thread_state.get_main_greenlet();
+
+    /* perform the initial switch */
+    switchstack_result_t err = this->g_switchstack();
+    /* returns twice!
+       The 1st time with ``err == 1``: we are in the new greenlet.
+       This one owns a greenlet that used to be current.
+       The 2nd time with ``err <= 0``: back in the caller's
+       greenlet; this happens if the child finishes or switches
+       explicitly to us. Either way, the ``err`` variable is
+       created twice at the same memory location, but possibly
+       having different ``origin`` values. Note that it's not
+       constructed for the second time until the switch actually happens.
+    */
+    if (err.status == 1) {
+        // This never returns! Calling inner_bootstrap steals
+        // the contents of our run object within this stack frame, so
+        // it is not valid to do anything with it.
+        this->inner_bootstrap(err.origin_greenlet, run);
+        Py_FatalError("greenlet: inner_bootstrap returned\n");
+    }
+    // The child will take care of decrefing this.
+    run.relinquish_ownership();
+
+    // In contrast, notice that we're keeping the origin greenlet
+    // around as an owned reference; we need it to call the trace
+    // function for the switch back into the parent. It was only
+    // captured at the time the switch actually happened, though,
+    // so we haven't been keeping an extra reference around this
+    // whole time.
+
+    /* back in the parent */
+    if (err.status < 0) {
+        /* start failed badly, restore greenlet state */
+        // XXX: This code path is not tested.
+        this->stack_state = StackState();
+        this->_main_greenlet.CLEAR();
+        fprintf(stderr, "greenlet: g_initialstub: starting child failed.\n");
+    }
+    return err;
+}
+
+
+void
+UserGreenlet::inner_bootstrap(OwnedGreenlet& origin_greenlet, OwnedObject& _run) G_NOEXCEPT_WIN32
+{
+    // The arguments here would be another great place for move.
+    // As it is, we take them as a reference so that when we clear
+    // them we clear what's on the stack above us. Do that NOW, and
+    // without using a C++ RAII object,
+    // so there's no way that exiting the parent frame can clear it,
+    // or we clear it unexpectedly. This arises in the context of the
+    // interpreter shutting down. See https://github.com/python-greenlet/greenlet/issues/325
+    PyObject* run = _run.relinquish_ownership();
+
+    /* in the new greenlet */
+    assert(this->thread_state()->borrow_current() == this->_self);
+    // C++ exceptions cannot propagate to the parent greenlet from
+    // here. (TODO: Do we need a catch(...) clause, perhaps on the
+    // function itself? ALl we could do is terminate the program.)
+    // NOTE: On 32-bit Windows, the call chain is extremely
+    // important here in ways that are subtle, having to do with
+    // the depth of the SEH list. The call to restore it MUST NOT
+    // add a new SEH handler to the list, or we'll restore it to
+    // the wrong thing.
+    this->thread_state()->restore_exception_state();
+    /* stack variables from above are no good and also will not unwind! */
+    // EXCEPT: That can't be true, we access run, among others, here.
+
+    this->stack_state.set_active(); /* running */
+
+    // XXX: We could clear this much earlier, right?
+    // Or would that introduce the possibility of running Python
+    // code when we don't want to?
+    this->_run_callable.CLEAR();
+
+
+    // We're about to possibly run Python code again, which
+    // could switch back to us, so we need to grab the
+    // arguments locally.
+    SwitchingArgs args;
+    args <<= this->switch_args;
+    assert(!this->switch_args);
+
+    // The first switch we need to manually call the trace
+    // function here instead of in g_switch_finish, because we
+    // never return there.
+
+    if (OwnedObject tracefunc = this->thread_state()->get_tracefunc()) {
+        try {
+            g_calltrace(tracefunc,
+                        args ? mod_globs.event_switch : mod_globs.event_throw,
+                        origin_greenlet,
+                        this->_self);
+        }
+        catch (const PyErrOccurred&) {
+            /* Turn trace errors into switch throws */
+            args.CLEAR();
+        }
+    }
+
+    // We no longer need the origin, it was only here for
+    // tracing.
+    // We may never actually exit this stack frame so we need
+    // to explicitly clear it.
+    // This could run Python code and switch.
+    origin_greenlet.CLEAR();
+
+    OwnedObject result;
+    if (!args) {
+        /* pending exception */
+        result = NULL;
+    }
+    else {
+        /* call g.run(*args, **kwargs) */
+        // This could result in further switches
+        try {
+            //result = run.PyCall(args.args(), args.kwargs());
+            result = OwnedObject::consuming(PyObject_Call(run, args.args().borrow(), args.kwargs().borrow()));
+        }
+        catch(...) {
+            // Unhandled C++ exception!
+
+            // If we declare ourselves as noexcept, if we don't catch
+            // this here, most platforms will just abort() the
+            // process. But on 64-bit Windows with older versions of
+            // the C runtime, this can actually corrupt memory and
+            // just return. We see this when compiling with the
+            // Windows 7.0 SDK targeting Windows Server 2008, but not
+            // when using the Appveyor Visual Studio 2019 image. So
+            // this currently only affects Python 2.7 on Windows 64.
+            // That is, the tests pass and the runtime aborts
+            // everywhere else.
+            //
+            // However, if we catch it and try to continue with a
+            // Python error, then all Windows 64 bit platforms corrupt
+            // memory. So all we can do is manually abort, hopefully
+            // with a good error message. (Note that the above was
+            // tested WITHOUT the `/EHr` switch being used at compile
+            // time, so MSVC may have "optimized" out important
+            // checking. Using that switch, we may be in a better
+            // place in terms of memory corruption.) But sometimes it
+            // can't be caught here at all, which is confusing but not
+            // terribly surprising; so again, the G_NOEXCEPT_WIN32
+            // plus "/EHr".
+            //
+            // Hopefully the basic C stdlib is still functional enough
+            // for us to at least print an error.
+            //
+            // It gets more complicated than that, though, on some
+            // platforms, specifically at least Linux/gcc/libstdc++. They use
+            // an exception to unwind the stack when a background
+            // thread exits. (See comments about G_NOEXCEPT.) So this
+            // may not actually represent anything untoward. On those
+            // platforms we allow throws of this to propagate, or
+            // attempt to anyway.
+# if defined(WIN32) || defined(_WIN32)
+            Py_FatalError(
+                "greenlet: Unhandled C++ exception from a greenlet run function. "
+                "Because memory is likely corrupted, terminating process.");
+            std::abort();
+#else
+            throw;
+#endif
+        }
+    }
+    args.CLEAR();
+    Py_CLEAR(run);
+
+    if (!result
+        && mod_globs.PyExc_GreenletExit.PyExceptionMatches()
+        && (this->switch_args)) {
+        // This can happen, for example, if our only reference
+        // goes away after we switch back to the parent.
+        // See test_dealloc_switch_args_not_lost
+        PyErrPieces clear_error;
+        result <<= this->switch_args;
+        result = single_result(result);
+    }
+    this->release_args();
+    this->python_state.did_finish(PyThreadState_GET());
+
+    result = g_handle_exit(result);
+    assert(this->thread_state()->borrow_current() == this->_self);
+
+    /* jump back to parent */
+    this->stack_state.set_inactive(); /* dead */
+
+
+    // TODO: Can we decref some things here? Release our main greenlet
+    // and maybe parent?
+    for (Greenlet* parent = this->_parent;
+         parent;
+         parent = parent->parent()) {
+        // We need to somewhere consume a reference to
+        // the result; in most cases we'll never have control
+        // back in this stack frame again. Calling
+        // green_switch actually adds another reference!
+        // This would probably be clearer with a specific API
+        // to hand results to the parent.
+        parent->args() <<= result;
+        assert(!result);
+        // The parent greenlet now owns the result; in the
+        // typical case we'll never get back here to assign to
+        // result and thus release the reference.
+        try {
+            result = parent->g_switch();
+        }
+        catch (const PyErrOccurred&) {
+            // Ignore.
+        }
+
+        /* Return here means switch to parent failed,
+         * in which case we throw *current* exception
+         * to the next parent in chain.
+         */
+        assert(!result);
+    }
+    /* We ran out of parents, cannot continue */
+    PyErr_WriteUnraisable(this->self().borrow_o());
+    Py_FatalError("greenlet: ran out of parent greenlets while propagating exception; "
+                  "cannot continue");
+    std::abort();
+}
+
+
+Greenlet::switchstack_result_t
+Greenlet::g_switchstack(void)
+{
+    { /* save state */
+        if (this->thread_state()->is_current(this->self())) {
+            // Hmm, nothing to do.
+            // TODO: Does this bypass trace events that are
+            // important?
+            return switchstack_result_t(0,
+                                        this, this->thread_state()->borrow_current());
+        }
+        BorrowedGreenlet current = this->thread_state()->borrow_current();
+        PyThreadState* tstate = PyThreadState_GET();
+        current->python_state << tstate;
+        current->exception_state << tstate;
+        this->python_state.will_switch_from(tstate);
+        switching_thread_state = this;
+    }
+    // If this is the first switch into a greenlet, this will
+    // return twice, once with 1 in the new greenlet, once with 0
+    // in the origin.
+    int err = slp_switch();
+
+    if (err < 0) { /* error */
+        // XXX: This code path is not tested.
+        BorrowedGreenlet current(GET_THREAD_STATE().state().borrow_current());
+        //current->top_frame = NULL; // This probably leaks?
+        current->exception_state.clear();
+
+        switching_thread_state = nullptr;
+        //GET_THREAD_STATE().state().wref_target(NULL);
+        this->release_args();
+        // It's important to make sure not to actually return an
+        // owned greenlet here, no telling how long before it
+        // could be cleaned up.
+        // TODO: Can this be a throw? How stable is the stack in
+        // an error case like this?
+        return switchstack_result_t(err);
+    }
+
+    // No stack-based variables are valid anymore.
+
+    // But the global is volatile so we can reload it without the
+    // compiler caching it from earlier.
+    Greenlet* after_switch = switching_thread_state;
+    OwnedGreenlet origin = after_switch->g_switchstack_success();
+    switching_thread_state = nullptr;
+    return switchstack_result_t(err, after_switch, origin);
+}
+
+
+inline void
+Greenlet::check_switch_allowed() const
+{
+    // TODO: Make this take a parameter of the current greenlet,
+    // or current main greenlet, to make the check for
+    // cross-thread switching cheaper. Surely somewhere up the
+    // call stack we've already accessed the thread local variable.
+
+    // We expect to always have a main greenlet now; accessing the thread state
+    // created it. However, if we get here and cleanup has already
+    // begun because we're a greenlet that was running in a
+    // (now dead) thread, these invariants will not hold true. In
+    // fact, accessing `this->thread_state` may not even be possible.
+
+    // If the thread this greenlet was running in is dead,
+    // we'll still have a reference to a main greenlet, but the
+    // thread state pointer we have is bogus.
+    // TODO: Give the objects an API to determine if they belong
+    // to a dead thread.
+
+    const BorrowedMainGreenlet main_greenlet = this->find_main_greenlet_in_lineage();
+
+    if (!main_greenlet) {
+        throw PyErrOccurred(mod_globs.PyExc_GreenletError,
+                            "cannot switch to a garbage collected greenlet");
+    }
+
+    if (!main_greenlet->thread_state()) {
+        throw PyErrOccurred(mod_globs.PyExc_GreenletError,
+                            "cannot switch to a different thread (which happens to have exited)");
+    }
+
+    // The main greenlet we found was from the .parent lineage.
+    // That may or may not have any relationship to the main
+    // greenlet of the running thread. We can't actually access
+    // our this->thread_state members to try to check that,
+    // because it could be in the process of getting destroyed,
+    // but setting the main_greenlet->thread_state member to NULL
+    // may not be visible yet. So we need to check against the
+    // current thread state (once the cheaper checks are out of
+    // the way)
+    const BorrowedMainGreenlet current_main_greenlet = GET_THREAD_STATE().state().borrow_main_greenlet();
+    if (
+        // lineage main greenlet is not this thread's greenlet
+        current_main_greenlet != main_greenlet
+        || (
+            // atteched to some thread
+            this->main_greenlet()
+            // XXX: Same condition as above. Was this supposed to be
+            // this->main_greenlet()?
+            && current_main_greenlet != main_greenlet)
+        // switching into a known dead thread (XXX: which, if we get here,
+        // is bad, because we just accessed the thread state, which is
+        // gone!)
+        || (!current_main_greenlet->thread_state())) {
+        throw PyErrOccurred(mod_globs.PyExc_GreenletError,
+                            "cannot switch to a different thread");
+    }
+}
+
+
+OwnedObject
+Greenlet::g_switch_finish(const switchstack_result_t& err)
+{
+
+    ThreadState& state = *this->thread_state();
+    try {
+        // Our only caller handles the bad error case
+        assert(err.status >= 0);
+        assert(state.borrow_current() == this->self());
+
+        if (OwnedObject tracefunc = state.get_tracefunc()) {
+            g_calltrace(tracefunc,
+                        this->args() ? mod_globs.event_switch : mod_globs.event_throw,
+                        err.origin_greenlet,
+                        this->self());
+        }
+        // The above could have invoked arbitrary Python code, but
+        // it couldn't switch back to this object and *also*
+        // throw an exception, so the args won't have changed.
+
+        if (PyErr_Occurred()) {
+            // We get here if we fell of the end of the run() function
+            // raising an exception. The switch itself was
+            // successful, but the function raised.
+            // valgrind reports that memory allocated here can still
+            // be reached after a test run.
+            throw PyErrOccurred();
+        }
+
+        OwnedObject result;
+        result <<= this->switch_args;
+        assert(!this->switch_args);
+        return result;
+    }
+    catch (const PyErrOccurred&) {
+        /* Turn switch errors into switch throws */
+        /* Turn trace errors into switch throws */
+        this->release_args();
+        throw;
+    }
+}
+
+
+greenlet::PythonAllocator<UserGreenlet> UserGreenlet::allocator;
+greenlet::PythonAllocator<MainGreenlet> MainGreenlet::allocator;
+
+
+extern "C" {
+static int GREENLET_NOINLINE(slp_save_state_trampoline)(char* stackref)
+{
+    return switching_thread_state->slp_save_state(stackref);
+}
+static void GREENLET_NOINLINE(slp_restore_state_trampoline)()
+{
+    switching_thread_state->slp_restore_state();
+}
+}
+
+
+
+/***********************************************************/
+
+class TracingGuard
+{
+private:
+    PyThreadState* tstate;
+public:
+    TracingGuard()
+        : tstate(PyThreadState_GET())
+    {
+        PyThreadState_EnterTracing(this->tstate);
+    }
+
+    ~TracingGuard()
+    {
+        PyThreadState_LeaveTracing(this->tstate);
+        this->tstate = nullptr;
+    }
+
+    inline void CallTraceFunction(const OwnedObject& tracefunc,
+                                  const ImmortalEventName& event,
+                                  const BorrowedGreenlet& origin,
+                                  const BorrowedGreenlet& target)
+    {
+        // TODO: This calls tracefunc(event, (origin, target)). Add a shortcut
+        // function for that that's specialized to avoid the Py_BuildValue
+        // string parsing, or start with just using "ON" format with PyTuple_Pack(2,
+        // origin, target). That seems like what the N format is meant
+        // for.
+        // XXX: Why does event not automatically cast back to a PyObject?
+        // It tries to call the "deleted constructor ImmortalEventName
+        // const" instead.
+        assert(tracefunc);
+        assert(event);
+        assert(origin);
+        assert(target);
+        NewReference retval(PyObject_CallFunction(tracefunc.borrow(),
+                                             "O(OO)",
+                                             event.borrow(),
+                                             origin.borrow(),
+                                             target.borrow()));
+        if (!retval) {
+            throw PyErrOccurred();
+        }
+    }
+};
+
+static void
+g_calltrace(const OwnedObject& tracefunc,
+            const ImmortalEventName& event,
+            const BorrowedGreenlet& origin,
+            const BorrowedGreenlet& target)
+{
+    PyErrPieces saved_exc;
+    try {
+        TracingGuard tracing_guard;
+        tracing_guard.CallTraceFunction(tracefunc, event, origin, target);
+    }
+    catch (const PyErrOccurred&) {
+        // In case of exceptions trace function is removed,
+        // and any existing exception is replaced with the tracing
+        // exception.
+        GET_THREAD_STATE().state().set_tracefunc(Py_None);
+        throw;
+    }
+
+    saved_exc.PyErrRestore();
+}
+
+
+
+static OwnedObject
+g_handle_exit(const OwnedObject& greenlet_result)
+{
+    if (!greenlet_result && mod_globs.PyExc_GreenletExit.PyExceptionMatches()) {
+        /* catch and ignore GreenletExit */
+        PyErrFetchParam val;
+        PyErr_Fetch(PyErrFetchParam(), val, PyErrFetchParam());
+        if (!val) {
+            return OwnedObject::None();
+        }
+        return OwnedObject(val);
+    }
+
+    if (greenlet_result) {
+        // package the result into a 1-tuple
+        // PyTuple_Pack increments the reference of its arguments,
+        // so we always need to decref the greenlet result;
+        // the owner will do that.
+        return OwnedObject::consuming(PyTuple_Pack(1, greenlet_result.borrow()));
+    }
+
+    return OwnedObject();
+}
+
+
+
+/***********************************************************/
+
+static PyGreenlet*
+green_new(PyTypeObject* type, PyObject* UNUSED(args), PyObject* UNUSED(kwds))
+{
+    PyGreenlet* o =
+        (PyGreenlet*)PyBaseObject_Type.tp_new(type, mod_globs.empty_tuple, mod_globs.empty_dict);
+    if (o) {
+        new UserGreenlet(o, GET_THREAD_STATE().state().borrow_current());
+        assert(Py_REFCNT(o) == 1);
+    }
+    return o;
+}
+
+static int
+green_setrun(BorrowedGreenlet self, BorrowedObject nrun, void* c);
+static int
+green_setparent(BorrowedGreenlet self, BorrowedObject nparent, void* c);
+
+static int
+green_init(BorrowedGreenlet self, BorrowedObject args, BorrowedObject kwargs)
+{
+    PyArgParseParam run;
+    PyArgParseParam nparent;
+    static const char* const kwlist = {
+        "run",
+        "parent",
+        NULL
+    };
+
+    // recall: The O specifier does NOT increase the reference count.
+    if (!PyArg_ParseTupleAndKeywords(
+             args, kwargs, "|OO:green", (char**)kwlist, &run, &nparent)) {
+        return -1;
+    }
+
+    if (run) {
+        if (green_setrun(self, run, NULL)) {
+            return -1;
+        }
+    }
+    if (nparent && !nparent.is_None()) {
+        return green_setparent(self, nparent, NULL);
+    }
+    return 0;
+}
+
+
+UserGreenlet::ParentIsCurrentGuard::ParentIsCurrentGuard(UserGreenlet* p,
+                                                     const ThreadState& thread_state)
+    : oldparent(p->_parent),
+      greenlet(p)
+{
+    p->_parent = thread_state.get_current();
+}
+
+UserGreenlet::ParentIsCurrentGuard::~ParentIsCurrentGuard()
+{
+    this->greenlet->_parent = oldparent;
+    oldparent.CLEAR();
+}
+
+
+void
+Greenlet::murder_in_place()
+{
+    if (this->active()) {
+        assert(!this->is_currently_running_in_some_thread());
+        this->deactivate_and_free();
+    }
+}
+
+void
+UserGreenlet::murder_in_place()
+{
+    this->_main_greenlet.CLEAR();
+    Greenlet::murder_in_place();
+}
+
+inline void
+Greenlet::deactivate_and_free()
+{
+    if (!this->active()) {
+        return;
+    }
+    // Throw away any saved stack.
+    this->stack_state = StackState();
+    assert(!this->stack_state.active());
+    // Throw away any Python references.
+    // We're holding a borrowed reference to the last
+    // frame we executed. Since we borrowed it, the
+    // normal traversal, clear, and dealloc functions
+    // ignore it, meaning it leaks. (The thread state
+    // object can't find it to clear it when that's
+    // deallocated either, because by definition if we
+    // got an object on this list, it wasn't
+    // running and the thread state doesn't have
+    // this frame.)
+    // So here, we *do* clear it.
+    this->python_state.tp_clear(true);
+}
+
+bool
+Greenlet::belongs_to_thread(const ThreadState* thread_state) const
+{
+    if (!this->thread_state() // not running anywhere, or thread
+                              // exited
+        || !thread_state) { // same, or there is no thread state.
+        return false;
+    }
+    return true;
+}
+
+bool
+UserGreenlet::belongs_to_thread(const ThreadState* thread_state) const
+{
+    return Greenlet::belongs_to_thread(thread_state) && this->_main_greenlet == thread_state->borrow_main_greenlet();
+}
+
+void
+Greenlet::deallocing_greenlet_in_thread(const ThreadState* current_thread_state)
+{
+    /* Cannot raise an exception to kill the greenlet if
+       it is not running in the same thread! */
+    if (this->belongs_to_thread(current_thread_state)) {
+        assert(current_thread_state);
+        // To get here it had to have run before
+        /* Send the greenlet a GreenletExit exception. */
+
+        // We don't care about the return value, only whether an
+        // exception happened.
+        this->throw_GreenletExit_during_dealloc(*current_thread_state);
+        return;
+    }
+
+    // Not the same thread! Temporarily save the greenlet
+    // into its thread's deleteme list, *if* it exists.
+    // If that thread has already exited, and processed its pending
+    // cleanup, we'll never be able to clean everything up: we won't
+    // be able to raise an exception.
+    // That's mostly OK! Since we can't add it to a list, our refcount
+    // won't increase, and we'll go ahead with the DECREFs later.
+    ThreadState *const  thread_state = this->thread_state();
+    if (thread_state) {
+        thread_state->delete_when_thread_running(this->self());
+    }
+    else {
+        // The thread is dead, we can't raise an exception.
+        // We need to make it look non-active, though, so that dealloc
+        // finishes killing it.
+        this->deactivate_and_free();
+    }
+    return;
+}
+
+
+int
+Greenlet::tp_traverse(visitproc visit, void* arg)
+{
+
+    int result;
+    if ((result = this->exception_state.tp_traverse(visit, arg)) != 0) {
+        return result;
+    }
+    //XXX: This is ugly. But so is handling everything having to do
+    //with the top frame.
+    bool visit_top_frame = this->was_running_in_dead_thread();
+    // When true, the thread is dead. Our implicit weak reference to the
+    // frame is now all that's left; we consider ourselves to
+    // strongly own it now.
+    if ((result = this->python_state.tp_traverse(visit, arg, visit_top_frame)) != 0) {
+        return result;
+    }
+    return 0;
+}
+
+int
+UserGreenlet::tp_traverse(visitproc visit, void* arg)
+{
+    Py_VISIT(this->_parent.borrow_o());
+    Py_VISIT(this->_main_greenlet.borrow_o());
+    Py_VISIT(this->_run_callable.borrow_o());
+
+    return Greenlet::tp_traverse(visit, arg);
+}
+
+int
+MainGreenlet::tp_traverse(visitproc visit, void* arg)
+{
+    if (this->_thread_state) {
+        // we've already traversed main, (self), don't do it again.
+        int result = this->_thread_state->tp_traverse(visit, arg, false);
+        if (result) {
+            return result;
+        }
+    }
+    return Greenlet::tp_traverse(visit, arg);
+}
+
+static int
+green_traverse(PyGreenlet* self, visitproc visit, void* arg)
+{
+    // We must only visit referenced objects, i.e. only objects
+    // Py_INCREF'ed by this greenlet (directly or indirectly):
+    //
+    // - stack_prev is not visited: holds previous stack pointer, but it's not
+    //    referenced
+    // - frames are not visited as we don't strongly reference them;
+    //    alive greenlets are not garbage collected
+    //    anyway. This can be a problem, however, if this greenlet is
+    //    never allowed to finish, and is referenced from the frame: we
+    //    have an uncollectible cycle in that case. Note that the
+    //    frame object itself is also frequently not even tracked by the GC
+    //    starting with Python 3.7 (frames are allocated by the
+    //    interpreter untracked, and only become tracked when their
+    //    evaluation is finished if they have a refcount > 1). All of
+    //    this is to say that we should probably strongly reference
+    //    the frame object. Doing so, while always allowing GC on a
+    //    greenlet, solves several leaks for us.
+
+    Py_VISIT(self->dict);
+    if (!self->pimpl) {
+        // Hmm. I have seen this at interpreter shutdown time,
+        // I think. That's very odd because this doesn't go away until
+        // we're ``green_dealloc()``, at which point we shouldn't be
+        // traversed anymore.
+        return 0;
+    }
+
+    return self->pimpl->tp_traverse(visit, arg);
+}
+
+static int
+green_is_gc(BorrowedGreenlet self)
+{
+    int result = 0;
+    /* Main greenlet can be garbage collected since it can only
+       become unreachable if the underlying thread exited.
+       Active greenlets --- including those that are suspended ---
+       cannot be garbage collected, however.
+    */
+    if (self->main() || !self->active()) {
+        result = 1;
+    }
+    // The main greenlet pointer will eventually go away after the thread dies.
+    if (self->was_running_in_dead_thread()) {
+        // Our thread is dead! We can never run again. Might as well
+        // GC us. Note that if a tuple containing only us and other
+        // immutable objects had been scanned before this, when we
+        // would have returned 0, the tuple will take itself out of GC
+        // tracking and never be investigated again. So that could
+        // result in both us and the tuple leaking due to an
+        // unreachable/uncollectible reference. The same goes for
+        // dictionaries.
+        //
+        // It's not a great idea to be changing our GC state on the
+        // fly.
+        result = 1;
+    }
+    return result;
+}
+
+
+int
+Greenlet::tp_clear()
+{
+    bool own_top_frame = this->was_running_in_dead_thread();
+    this->exception_state.tp_clear();
+    this->python_state.tp_clear(own_top_frame);
+    return 0;
+}
+
+int
+UserGreenlet::tp_clear()
+{
+    Greenlet::tp_clear();
+    this->_parent.CLEAR();
+    this->_main_greenlet.CLEAR();
+    this->_run_callable.CLEAR();
+    return 0;
+}
+
+
+static int
+green_clear(PyGreenlet* self)
+{
+    /* Greenlet is only cleared if it is about to be collected.
+       Since active greenlets are not garbage collectable, we can
+       be sure that, even if they are deallocated during clear,
+       nothing they reference is in unreachable or finalizers,
+       so even if it switches we are relatively safe. */
+    // XXX: Are we responsible for clearing weakrefs here?
+    Py_CLEAR(self->dict);
+    return self->pimpl->tp_clear();
+}
+
+/**
+ * Returns 0 on failure (the object was resurrected) or 1 on success.
+ **/
+static int
+_green_dealloc_kill_started_non_main_greenlet(BorrowedGreenlet self)
+{
+    /* Hacks hacks hacks copied from instance_dealloc() */
+    /* Temporarily resurrect the greenlet. */
+    assert(self.REFCNT() == 0);
+    Py_SET_REFCNT(self.borrow(), 1);
+    /* Save the current exception, if any. */
+    PyErrPieces saved_err;
+    try {
+        // BY THE TIME WE GET HERE, the state may actually be going
+        // away
+        // if we're shutting down the interpreter and freeing thread
+        // entries,
+        // this could result in freeing greenlets that were leaked. So
+        // we can't try to read the state.
+        self->deallocing_greenlet_in_thread(
+              self->thread_state()
+              ? static_cast<ThreadState*>(GET_THREAD_STATE())
+              : nullptr);
+    }
+    catch (const PyErrOccurred&) {
+        PyErr_WriteUnraisable(self.borrow_o());
+        /* XXX what else should we do? */
+    }
+    /* Check for no resurrection must be done while we keep
+     * our internal reference, otherwise PyFile_WriteObject
+     * causes recursion if using Py_INCREF/Py_DECREF
+     */
+    if (self.REFCNT() == 1 && self->active()) {
+        /* Not resurrected, but still not dead!
+           XXX what else should we do? we complain. */
+        PyObject* f = PySys_GetObject("stderr");
+        Py_INCREF(self.borrow_o()); /* leak! */
+        if (f != NULL) {
+            PyFile_WriteString("GreenletExit did not kill ", f);
+            PyFile_WriteObject(self.borrow_o(), f, 0);
+            PyFile_WriteString("\n", f);
+        }
+    }
+    /* Restore the saved exception. */
+    saved_err.PyErrRestore();
+    /* Undo the temporary resurrection; can't use DECREF here,
+     * it would cause a recursive call.
+     */
+    assert(self.REFCNT() > 0);
+
+    Py_ssize_t refcnt = self.REFCNT() - 1;
+    Py_SET_REFCNT(self.borrow_o(), refcnt);
+    if (refcnt != 0) {
+        /* Resurrected! */
+        _Py_NewReference(self.borrow_o());
+        Py_SET_REFCNT(self.borrow_o(), refcnt);
+        /* Better to use tp_finalizer slot (PEP 442)
+         * and call ``PyObject_CallFinalizerFromDealloc``,
+         * but that's only supported in Python 3.4+; see
+         * Modules/_io/iobase.c for an example.
+         *
+         * The following approach is copied from iobase.c in CPython 2.7.
+         * (along with much of this function in general). Here's their
+         * comment:
+         *
+         * When called from a heap type's dealloc, the type will be
+         * decref'ed on return (see e.g. subtype_dealloc in typeobject.c). */
+        if (PyType_HasFeature(self.TYPE(), Py_TPFLAGS_HEAPTYPE)) {
+            Py_INCREF(self.TYPE());
+        }
+
+        PyObject_GC_Track((PyObject*)self);
+
+        _Py_DEC_REFTOTAL;
+#ifdef COUNT_ALLOCS
+        --Py_TYPE(self)->tp_frees;
+        --Py_TYPE(self)->tp_allocs;
+#endif /* COUNT_ALLOCS */
+        return 0;
+    }
+    return 1;
+}
+
+
+Greenlet::~Greenlet()
+{
+    // XXX: Can't do this. tp_clear is a virtual function, and by the
+    // time we're here, we've sliced off our child classes.
+    //this->tp_clear();
+}
+
+UserGreenlet::~UserGreenlet()
+{
+    // Python 3.11: If we don't clear out the raw frame datastack
+    // when deleting an unfinished greenlet,
+    // TestLeaks.test_untracked_memory_doesnt_increase_unfinished_thread_dealloc_in_main fails.
+    this->python_state.did_finish(nullptr);
+    this->tp_clear();
+}
+
+MainGreenlet::~MainGreenlet()
+{
+    total_main_greenlets--;
+    this->tp_clear();
+}
+
+static void
+green_dealloc(PyGreenlet* self)
+{
+    PyObject_GC_UnTrack(self);
+    BorrowedGreenlet me(self);
+    if (me->active()
+        && me->started()
+        && !me->main()) {
+        if (!_green_dealloc_kill_started_non_main_greenlet(me)) {
+            return;
+        }
+    }
+
+    if (self->weakreflist != NULL) {
+        PyObject_ClearWeakRefs((PyObject*)self);
+    }
+    Py_CLEAR(self->dict);
+
+    if (self->pimpl) {
+        // In case deleting this, which frees some memory,
+        // somehow winds up calling back into us. That's usually a
+        //bug in our code.
+        Greenlet* p = self->pimpl;
+        self->pimpl = nullptr;
+        delete p;
+    }
+    // and finally we're done. self is now invalid.
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+
+static OwnedObject
+throw_greenlet(BorrowedGreenlet self, PyErrPieces& err_pieces)
+{
+    PyObject* result = nullptr;
+    err_pieces.PyErrRestore();
+    assert(PyErr_Occurred());
+    if (self->started() && !self->active()) {
+        /* dead greenlet: turn GreenletExit into a regular return */
+        result = g_handle_exit(OwnedObject()).relinquish_ownership();
+    }
+
+    self->args() <<= result;
+
+    return single_result(self->g_switch());
+}
+
+
+
+PyDoc_STRVAR(
+    green_switch_doc,
+    "switch(*args, **kwargs)\n"
+    "\n"
+    "Switch execution to this greenlet.\n"
+    "\n"
+    "If this greenlet has never been run, then this greenlet\n"
+    "will be switched to using the body of ``self.run(*args, **kwargs)``.\n"
+    "\n"
+    "If the greenlet is active (has been run, but was switch()'ed\n"
+    "out before leaving its run function), then this greenlet will\n"
+    "be resumed and the return value to its switch call will be\n"
+    "None if no arguments are given, the given argument if one\n"
+    "argument is given, or the args tuple and keyword args dict if\n"
+    "multiple arguments are given.\n"
+    "\n"
+    "If the greenlet is dead, or is the current greenlet then this\n"
+    "function will simply return the arguments using the same rules as\n"
+    "above.\n");
+
+static PyObject*
+green_switch(PyGreenlet* self, PyObject* args, PyObject* kwargs)
+{
+    using greenlet::SwitchingArgs;
+    SwitchingArgs switch_args(OwnedObject::owning(args), OwnedObject::owning(kwargs));
+    self->pimpl->args() <<= switch_args;
+
+
+    // If we're switching out of a greenlet, and that switch is the
+    // last thing the greenlet does, the greenlet ought to be able to
+    // go ahead and die at that point. Currently, someone else must
+    // manually switch back to the greenlet so that we "fall off the
+    // end" and can perform cleanup. You'd think we'd be able to
+    // figure out that this is happening using the frame's ``f_lasti``
+    // member, which is supposed to be an index into
+    // ``frame->f_code->co_code``, the bytecode string. However, in
+    // recent interpreters, ``f_lasti`` tends not to be updated thanks
+    // to things like the PREDICT() macros in ceval.c. So it doesn't
+    // really work to do that in many cases. For example, the Python
+    // code:
+    //     def run():
+    //         greenlet.getcurrent().parent.switch()
+    // produces bytecode of len 16, with the actual call to switch()
+    // being at index 10 (in Python 3.10). However, the reported
+    // ``f_lasti`` we actually see is...5! (Which happens to be the
+    // second byte of the CALL_METHOD op for ``getcurrent()``).
+
+    try {
+        OwnedObject result = single_result(self->pimpl->g_switch());
+#ifndef NDEBUG
+        // Note that the current greenlet isn't necessarily self. If self
+        // finished, we went to one of its parents.
+        assert(!self->pimpl->args());
+
+        const BorrowedGreenlet& current = GET_THREAD_STATE().state().borrow_current();
+        // It's possible it's never been switched to.
+        assert(!current->args());
+#endif
+        return result.relinquish_ownership();
+    }
+    catch(const PyErrOccurred&) {
+        return nullptr;
+    }
+}
+
+PyDoc_STRVAR(
+    green_throw_doc,
+    "Switches execution to this greenlet, but immediately raises the\n"
+    "given exception in this greenlet.  If no argument is provided, the "
+    "exception\n"
+    "defaults to `greenlet.GreenletExit`.  The normal exception\n"
+    "propagation rules apply, as described for `switch`.  Note that calling "
+    "this\n"
+    "method is almost equivalent to the following::\n"
+    "\n"
+    "    def raiser():\n"
+    "        raise typ, val, tb\n"
+    "    g_raiser = greenlet(raiser, parent=g)\n"
+    "    g_raiser.switch()\n"
+    "\n"
+    "except that this trick does not work for the\n"
+    "`greenlet.GreenletExit` exception, which would not propagate\n"
+    "from ``g_raiser`` to ``g``.\n");
+
+static PyObject*
+green_throw(PyGreenlet* self, PyObject* args)
+{
+    PyArgParseParam typ(mod_globs.PyExc_GreenletExit);
+    PyArgParseParam val;
+    PyArgParseParam tb;
+
+    if (!PyArg_ParseTuple(args, "|OOO:throw", &typ, &val, &tb)) {
+        return NULL;
+    }
+
+    try {
+        // Both normalizing the error and the actual throw_greenlet
+        // could throw PyErrOccurred.
+        PyErrPieces err_pieces(typ.borrow(), val.borrow(), tb.borrow());
+
+        return throw_greenlet(self, err_pieces).relinquish_ownership();
+    }
+    catch (const PyErrOccurred&) {
+        return nullptr;
+    }
+}
+
+static int
+green_bool(PyGreenlet* self)
+{
+    return self->pimpl->active();
+}
+
+static PyObject*
+green_getdict(PyGreenlet* self, void* UNUSED(context))
+{
+    if (self->dict == NULL) {
+        self->dict = PyDict_New();
+        if (self->dict == NULL) {
+            return NULL;
+        }
+    }
+    Py_INCREF(self->dict);
+    return self->dict;
+}
+
+static int
+green_setdict(PyGreenlet* self, PyObject* val, void* UNUSED(context))
+{
+    PyObject* tmp;
+
+    if (val == NULL) {
+        PyErr_SetString(PyExc_TypeError, "__dict__ may not be deleted");
+        return -1;
+    }
+    if (!PyDict_Check(val)) {
+        PyErr_SetString(PyExc_TypeError, "__dict__ must be a dictionary");
+        return -1;
+    }
+    tmp = self->dict;
+    Py_INCREF(val);
+    self->dict = val;
+    Py_XDECREF(tmp);
+    return 0;
+}
+
+static bool
+_green_not_dead(BorrowedGreenlet self)
+{
+    // XXX: Where else should we do this?
+    // Probably on entry to most Python-facing functions?
+    if (self->was_running_in_dead_thread()) {
+        self->deactivate_and_free();
+        return false;
+    }
+    return self->active() || !self->started();
+}
+
+
+static PyObject*
+green_getdead(BorrowedGreenlet self, void* UNUSED(context))
+{
+    if (_green_not_dead(self)) {
+        Py_RETURN_FALSE;
+    }
+    else {
+        Py_RETURN_TRUE;
+    }
+}
+
+static PyObject*
+green_get_stack_saved(PyGreenlet* self, void* UNUSED(context))
+{
+    return PyLong_FromSsize_t(self->pimpl->stack_saved());
+}
+
+
+static PyObject*
+green_getrun(BorrowedGreenlet self, void* UNUSED(context))
+{
+    try {
+        OwnedObject result(self->run());
+        return result.relinquish_ownership();
+    }
+    catch(const PyErrOccurred&) {
+        return nullptr;
+    }
+}
+
+void
+UserGreenlet::run(const BorrowedObject nrun)
+{
+    if (this->started()) {
+        throw AttributeError(
+                        "run cannot be set "
+                        "after the start of the greenlet");
+    }
+    this->_run_callable = nrun;
+}
+
+const OwnedObject&
+MainGreenlet::run() const
+{
+    throw AttributeError("Main greenlets do not have a run attribute.");
+}
+
+void
+MainGreenlet::run(const BorrowedObject UNUSED(nrun))
+{
+   throw AttributeError("Main greenlets do not have a run attribute.");
+}
+
+static int
+green_setrun(BorrowedGreenlet self, BorrowedObject nrun, void* UNUSED(context))
+{
+    try {
+        self->run(nrun);
+        return 0;
+    }
+    catch(const PyErrOccurred&) {
+        return -1;
+    }
+}
+
+static PyObject*
+green_getparent(BorrowedGreenlet self, void* UNUSED(context))
+{
+    return self->parent().acquire_or_None();
+}
+
+using greenlet::AttributeError;
+
+const OwnedGreenlet
+UserGreenlet::parent() const
+{
+    return this->_parent;
+}
+
+void
+UserGreenlet::parent(const BorrowedObject raw_new_parent)
+{
+    if (!raw_new_parent) {
+        throw AttributeError("can't delete attribute");
+    }
+
+    BorrowedMainGreenlet main_greenlet_of_new_parent;
+    BorrowedGreenlet new_parent(raw_new_parent.borrow()); // could
+                                                          // throw
+                                                          // TypeError!
+    for (BorrowedGreenlet p = new_parent; p; p = p->parent()) {
+        if (p == this->_self) {
+            throw ValueError("cyclic parent chain");
+        }
+        main_greenlet_of_new_parent = p->main_greenlet();
+    }
+
+    if (!main_greenlet_of_new_parent) {
+        throw ValueError("parent must not be garbage collected");
+    }
+
+    if (this->started()
+        && this->_main_greenlet != main_greenlet_of_new_parent) {
+        throw ValueError("parent cannot be on a different thread");
+    }
+
+    this->_parent = new_parent;
+}
+
+void
+MainGreenlet::parent(const BorrowedObject raw_new_parent)
+{
+    if (!raw_new_parent) {
+        throw AttributeError("can't delete attribute");
+    }
+    throw AttributeError("cannot set the parent of a main greenlet");
+}
+
+const OwnedGreenlet
+MainGreenlet::parent() const
+{
+    return OwnedGreenlet(); // null becomes None
+}
+
+static int
+green_setparent(BorrowedGreenlet self, BorrowedObject nparent, void* UNUSED(context))
+{
+    try {
+        self->parent(nparent);
+    }
+    catch(const PyErrOccurred&) {
+        return -1;
+    }
+    return 0;
+}
+
+#ifdef Py_CONTEXT_H
+#    define GREENLET_NO_CONTEXTVARS_REASON "This build of greenlet"
+#else
+#    define GREENLET_NO_CONTEXTVARS_REASON "This Python interpreter"
+#endif
+
+namespace greenlet
+{
+
+template<>
+const OwnedObject
+Greenlet::context<GREENLET_WHEN_PY37>(GREENLET_WHEN_PY37::Yes) const
+{
+    using greenlet::PythonStateContext;
+    OwnedObject result;
+
+    if (this->is_currently_running_in_some_thread()) {
+        /* Currently running greenlet: context is stored in the thread state,
+           not the greenlet object. */
+        if (GET_THREAD_STATE().state().is_current(this->self())) {
+            result = PythonStateContext<G_IS_PY37>::context(PyThreadState_GET());
+        }
+        else {
+            throw ValueError(
+                            "cannot get context of a "
+                            "greenlet that is running in a different thread");
+        }
+    }
+    else {
+        /* Greenlet is not running: just return context. */
+        result = this->python_state.context();
+    }
+    if (!result) {
+        result = OwnedObject::None();
+    }
+    return result;
+}
+
+template<>
+const OwnedObject
+Greenlet::context<GREENLET_WHEN_NOT_PY37>(GREENLET_WHEN_NOT_PY37::No) const
+{
+    throw AttributeError(
+                         GREENLET_NO_CONTEXTVARS_REASON
+                         "does not support context variables"
+    );
+}
+
+template<>
+void Greenlet::context<GREENLET_WHEN_PY37>(BorrowedObject given, GREENLET_WHEN_PY37::Yes)
+{
+    using greenlet::PythonStateContext;
+    if (!given) {
+        throw AttributeError("can't delete context attribute");
+    }
+    if (given.is_None()) {
+        /* "Empty context" is stored as NULL, not None. */
+        given = nullptr;
+    }
+
+    //checks type, incrs refcnt
+    greenlet::refs::OwnedContext context(given);
+    PyThreadState* tstate = PyThreadState_GET();
+
+    if (this->is_currently_running_in_some_thread()) {
+        if (!GET_THREAD_STATE().state().is_current(this->self())) {
+            throw ValueError("cannot set context of a greenlet"
+                             " that is running in a different thread");
+        }
+
+        /* Currently running greenlet: context is stored in the thread state,
+           not the greenlet object. */
+        OwnedObject octx = OwnedObject::consuming(PythonStateContext<G_IS_PY37>::context(tstate));
+        PythonStateContext<G_IS_PY37>::context(tstate, context.relinquish_ownership());
+    }
+    else {
+        /* Greenlet is not running: just set context. Note that the
+           greenlet may be dead.*/
+        this->python_state.context() = context;
+    }
+}
+
+template<>
+void
+Greenlet::context<GREENLET_WHEN_NOT_PY37>(BorrowedObject UNUSED(given), GREENLET_WHEN_NOT_PY37::No)
+{
+    throw AttributeError(
+                         GREENLET_NO_CONTEXTVARS_REASON
+                         "does not support context variables"
+    );
+}
+
+};
+
+static PyObject*
+green_getcontext(const PyGreenlet* self, void* UNUSED(context))
+{
+    const Greenlet *const g = self->pimpl;
+    try {
+        OwnedObject result(g->context<G_IS_PY37>());
+        return result.relinquish_ownership();
+    }
+    catch(const PyErrOccurred&) {
+        return nullptr;
+    }
+}
+
+static int
+green_setcontext(BorrowedGreenlet self, PyObject* nctx, void* UNUSED(context))
+{
+    try {
+        self->context<G_IS_PY37>(nctx, G_IS_PY37::IsIt());
+        return 0;
+    }
+    catch(const PyErrOccurred&) {
+        return -1;
+    }
+}
+
+#undef GREENLET_NO_CONTEXTVARS_REASON
+
+static PyObject*
+green_getframe(BorrowedGreenlet self, void* UNUSED(context))
+{
+    const PythonState::OwnedFrame& top_frame = self->top_frame();
+    return top_frame.acquire_or_None();
+}
+
+static PyObject*
+green_getstate(PyGreenlet* self)
+{
+    PyErr_Format(PyExc_TypeError,
+                 "cannot serialize '%s' object",
+                 Py_TYPE(self)->tp_name);
+    return nullptr;
+}
+
+static PyObject*
+green_repr(BorrowedGreenlet self)
+{
+    /*
+      Return a string like
+      <greenlet.greenlet at 0xdeadbeef currentactive started|dead main>
+
+      The handling of greenlets across threads is not super good.
+      We mostly use the internal definitions of these terms, but they
+      generally should make sense to users as well.
+     */
+    PyObject* result;
+    int never_started = !self->started() && !self->active();
+
+    const char* const tp_name = Py_TYPE(self)->tp_name;
+
+    if (_green_not_dead(self)) {
+        /* XXX: The otid= is almost useless because you can't correlate it to
+         any thread identifier exposed to Python. We could use
+         PyThreadState_GET()->thread_id, but we'd need to save that in the
+         greenlet, or save the whole PyThreadState object itself.
+
+         As it stands, its only useful for identifying greenlets from the same thread.
+        */
+        const char* state_in_thread;
+        if (self->was_running_in_dead_thread()) {
+            // The thread it was running in is dead!
+            // This can happen, especially at interpreter shut down.
+            // It complicates debugging output because it may be
+            // impossible to access the current thread state at that
+            // time. Thus, don't access the current thread state.
+            state_in_thread = " (thread exited)";
+        }
+        else {
+            state_in_thread = GET_THREAD_STATE().state().is_current(self)
+                ? " current"
+                : (self->started() ? " suspended" : "");
+        }
+        result = GNative_FromFormat(
+            "<%s object at %p (otid=%p)%s%s%s%s>",
+            tp_name,
+            self.borrow_o(),
+            self->thread_state(),
+            state_in_thread,
+            self->active() ? " active" : "",
+            never_started ? " pending" : " started",
+            self->main() ? " main" : ""
+        );
+    }
+    else {
+        result = GNative_FromFormat(
+            "<%s object at %p (otid=%p) %sdead>",
+            tp_name,
+            self.borrow_o(),
+            self->thread_state(),
+            self->was_running_in_dead_thread()
+            ? "(thread exited) "
+            : ""
+            );
+    }
+
+    return result;
+}
+
+/*****************************************************************************
+ * C interface
+ *
+ * These are exported using the CObject API
+ */
+extern "C" {
+static PyGreenlet*
+PyGreenlet_GetCurrent(void)
+{
+    return GET_THREAD_STATE().state().get_current().relinquish_ownership();
+}
+
+static int
+PyGreenlet_SetParent(PyGreenlet* g, PyGreenlet* nparent)
+{
+    return green_setparent((PyGreenlet*)g, (PyObject*)nparent, NULL);
+}
+
+static PyGreenlet*
+PyGreenlet_New(PyObject* run, PyGreenlet* parent)
+{
+    using greenlet::refs::NewDictReference;
+    // In the past, we didn't use green_new and green_init, but that
+    // was a maintenance issue because we duplicated code. This way is
+    // much safer, but slightly slower. If that's a problem, we could
+    // refactor green_init to separate argument parsing from initialization.
+    OwnedGreenlet g = OwnedGreenlet::consuming(green_new(&PyGreenlet_Type, nullptr, nullptr));
+    if (!g) {
+        return NULL;
+    }
+
+    try {
+        NewDictReference kwargs;
+        if (run) {
+            kwargs.SetItem(mod_globs.str_run, run);
+        }
+        if (parent) {
+            kwargs.SetItem("parent", (PyObject*)parent);
+        }
+
+        Require(green_init(g, mod_globs.empty_tuple, kwargs));
+    }
+    catch (const PyErrOccurred&) {
+        return nullptr;
+    }
+
+    return g.relinquish_ownership();
+}
+
+static PyObject*
+PyGreenlet_Switch(PyGreenlet* g, PyObject* args, PyObject* kwargs)
+{
+    PyGreenlet* self = (PyGreenlet*)g;
+
+    if (!PyGreenlet_Check(self)) {
+        PyErr_BadArgument();
+        return NULL;
+    }
+
+    if (args == NULL) {
+        args = mod_globs.empty_tuple;
+    }
+
+    if (kwargs == NULL || !PyDict_Check(kwargs)) {
+        kwargs = NULL;
+    }
+
+    return green_switch(g, args, kwargs);
+}
+
+static PyObject*
+PyGreenlet_Throw(PyGreenlet* self, PyObject* typ, PyObject* val, PyObject* tb)
+{
+    if (!PyGreenlet_Check(self)) {
+        PyErr_BadArgument();
+        return nullptr;
+    }
+    try {
+        PyErrPieces err_pieces(typ, val, tb);
+        return throw_greenlet(self, err_pieces).relinquish_ownership();
+    }
+    catch (const PyErrOccurred&) {
+        return nullptr;
+    }
+}
+
+static int
+Extern_PyGreenlet_MAIN(PyGreenlet* self)
+{
+    if (!PyGreenlet_Check(self)) {
+        PyErr_BadArgument();
+        return -1;
+    }
+    return self->pimpl->main();
+}
+
+static int
+Extern_PyGreenlet_ACTIVE(PyGreenlet* self)
+{
+    if (!PyGreenlet_Check(self)) {
+        PyErr_BadArgument();
+        return -1;
+    }
+    return self->pimpl->active();
+}
+
+static int
+Extern_PyGreenlet_STARTED(PyGreenlet* self)
+{
+    if (!PyGreenlet_Check(self)) {
+        PyErr_BadArgument();
+        return -1;
+    }
+    return self->pimpl->started();
+}
+
+static PyGreenlet*
+Extern_PyGreenlet_GET_PARENT(PyGreenlet* self)
+{
+    if (!PyGreenlet_Check(self)) {
+        PyErr_BadArgument();
+        return NULL;
+    }
+    // This can return NULL even if there is no exception
+    return self->pimpl->parent().acquire();
+}
+} // extern C.
+/** End C API ****************************************************************/
+
+static PyMethodDef green_methods = {
+    {"switch",
+     reinterpret_cast<PyCFunction>(green_switch),
+     METH_VARARGS | METH_KEYWORDS,
+     green_switch_doc},
+    {"throw", (PyCFunction)green_throw, METH_VARARGS, green_throw_doc},
+    {"__getstate__", (PyCFunction)green_getstate, METH_NOARGS, NULL},
+    {NULL, NULL} /* sentinel */
+};
+
+static PyGetSetDef green_getsets = {
+    {"__dict__", (getter)green_getdict, (setter)green_setdict, /*XXX*/ NULL},
+    {"run", (getter)green_getrun, (setter)green_setrun, /*XXX*/ NULL},
+    {"parent", (getter)green_getparent, (setter)green_setparent, /*XXX*/ NULL},
+    {"gr_frame", (getter)green_getframe, NULL, /*XXX*/ NULL},
+    {"gr_context",
+     (getter)green_getcontext,
+     (setter)green_setcontext,
+     /*XXX*/ NULL},
+    {"dead", (getter)green_getdead, NULL, /*XXX*/ NULL},
+    {"_stack_saved", (getter)green_get_stack_saved, NULL, /*XXX*/ NULL},
+    {NULL}};
+
+static PyMemberDef green_members = {
+    {NULL}
+};
+
+static PyNumberMethods green_as_number = {
+    NULL, /* nb_add */
+    NULL, /* nb_subtract */
+    NULL, /* nb_multiply */
+#if PY_MAJOR_VERSION < 3
+    NULL, /* nb_divide */
+#endif
+    NULL,                /* nb_remainder */
+    NULL,                /* nb_divmod */
+    NULL,                /* nb_power */
+    NULL,                /* nb_negative */
+    NULL,                /* nb_positive */
+    NULL,                /* nb_absolute */
+    (inquiry)green_bool, /* nb_bool */
+};
+
+
+PyTypeObject PyGreenlet_Type = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    "greenlet.greenlet", /* tp_name */
+    sizeof(PyGreenlet),  /* tp_basicsize */
+    0,                   /* tp_itemsize */
+    /* methods */
+    (destructor)green_dealloc, /* tp_dealloc */
+    0,                         /* tp_print */
+    0,                         /* tp_getattr */
+    0,                         /* tp_setattr */
+    0,                         /* tp_compare */
+    (reprfunc)green_repr,      /* tp_repr */
+    &green_as_number,          /* tp_as _number*/
+    0,                         /* tp_as _sequence*/
+    0,                         /* tp_as _mapping*/
+    0,                         /* tp_hash */
+    0,                         /* tp_call */
+    0,                         /* tp_str */
+    0,                         /* tp_getattro */
+    0,                         /* tp_setattro */
+    0,                         /* tp_as_buffer*/
+    G_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
+    "greenlet(run=None, parent=None) -> greenlet\n\n"
+    "Creates a new greenlet object (without running it).\n\n"
+    " - *run* -- The callable to invoke.\n"
+    " - *parent* -- The parent greenlet. The default is the current "
+    "greenlet.",                        /* tp_doc */
+    (traverseproc)green_traverse, /* tp_traverse */
+    (inquiry)green_clear,         /* tp_clear */
+    0,                                  /* tp_richcompare */
+    offsetof(PyGreenlet, weakreflist),  /* tp_weaklistoffset */
+    0,                                  /* tp_iter */
+    0,                                  /* tp_iternext */
+    green_methods,                      /* tp_methods */
+    green_members,                      /* tp_members */
+    green_getsets,                      /* tp_getset */
+    0,                                  /* tp_base */
+    0,                                  /* tp_dict */
+    0,                                  /* tp_descr_get */
+    0,                                  /* tp_descr_set */
+    offsetof(PyGreenlet, dict),         /* tp_dictoffset */
+    (initproc)green_init,               /* tp_init */
+    PyType_GenericAlloc,                  /* tp_alloc */
+    (newfunc)green_new,                          /* tp_new */
+    PyObject_GC_Del,                   /* tp_free */
+    (inquiry)green_is_gc,         /* tp_is_gc */
+};
+
+
+
+PyDoc_STRVAR(mod_getcurrent_doc,
+             "getcurrent() -> greenlet\n"
+             "\n"
+             "Returns the current greenlet (i.e. the one which called this "
+             "function).\n");
+
+static PyObject*
+mod_getcurrent(PyObject* UNUSED(module))
+{
+    return GET_THREAD_STATE().state().get_current().relinquish_ownership_o();
+}
+
+PyDoc_STRVAR(mod_settrace_doc,
+             "settrace(callback) -> object\n"
+             "\n"
+             "Sets a new tracing function and returns the previous one.\n");
+static PyObject*
+mod_settrace(PyObject* UNUSED(module), PyObject* args)
+{
+    PyArgParseParam tracefunc;
+    if (!PyArg_ParseTuple(args, "O", &tracefunc)) {
+        return NULL;
+    }
+    ThreadState& state = GET_THREAD_STATE();
+    OwnedObject previous = state.get_tracefunc();
+    if (!previous) {
+        previous = Py_None;
+    }
+
+    state.set_tracefunc(tracefunc);
+
+    return previous.relinquish_ownership();
+}
+
+PyDoc_STRVAR(mod_gettrace_doc,
+             "gettrace() -> object\n"
+             "\n"
+             "Returns the currently set tracing function, or None.\n");
+
+static PyObject*
+mod_gettrace(PyObject* UNUSED(module))
+{
+    OwnedObject tracefunc = GET_THREAD_STATE().state().get_tracefunc();
+    if (!tracefunc) {
+        tracefunc = Py_None;
+    }
+    return tracefunc.relinquish_ownership();
+}
+
+PyDoc_STRVAR(mod_set_thread_local_doc,
+             "set_thread_local(key, value) -> None\n"
+             "\n"
+             "Set a value in the current thread-local dictionary. Debbuging only.\n");
+
+static PyObject*
+mod_set_thread_local(PyObject* UNUSED(module), PyObject* args)
+{
+    PyArgParseParam key;
+    PyArgParseParam value;
+    PyObject* result = NULL;
+
+    if (PyArg_UnpackTuple(args, "set_thread_local", 2, 2, &key, &value)) {
+        if(PyDict_SetItem(
+                          PyThreadState_GetDict(), // borrow
+                          key,
+                          value) == 0 ) {
+            // success
+            Py_INCREF(Py_None);
+            result = Py_None;
+        }
+    }
+    return result;
+}
+
+PyDoc_STRVAR(mod_get_pending_cleanup_count_doc,
+             "get_pending_cleanup_count() -> Integer\n"
+             "\n"
+             "Get the number of greenlet cleanup operations pending. Testing only.\n");
+
+
+static PyObject*
+mod_get_pending_cleanup_count(PyObject* UNUSED(module))
+{
+    LockGuard cleanup_lock(*mod_globs.thread_states_to_destroy_lock);
+    return PyLong_FromSize_t(mod_globs.thread_states_to_destroy.size());
+}
+
+PyDoc_STRVAR(mod_get_total_main_greenlets_doc,
+             "get_total_main_greenlets() -> Integer\n"
+             "\n"
+             "Quickly return the number of main greenlets that exist. Testing only.\n");
+
+static PyObject*
+mod_get_total_main_greenlets(PyObject* UNUSED(module))
+{
+    return PyLong_FromSize_t(total_main_greenlets);
+}
+
+PyDoc_STRVAR(mod_get_clocks_used_doing_optional_cleanup_doc,
+             "get_clocks_used_doing_optional_cleanup() -> Integer\n"
+             "\n"
+             "Get the number of clock ticks the program has used doing optional "
+             "greenlet cleanup.\n"
+             "Beginning in greenlet 2.0, greenlet tries to find and dispose of greenlets\n"
+             "that leaked after a thread exited. This requires invoking Python's garbage collector,\n"
+             "which may have a performance cost proportional to the number of live objects.\n"
+             "This function returns the amount of processor time\n"
+             "greenlet has used to do this. In programs that run with very large amounts of live\n"
+             "objects, this metric can be used to decide whether the cost of doing this cleanup\n"
+             "is worth the memory leak being corrected. If not, you can disable the cleanup\n"
+             "using ``enable_optional_cleanup(False)``.\n"
+             "The units are arbitrary and can only be compared to themselves (similarly to ``time.clock()``);\n"
+             "for example, to see how it scales with your heap. You can attempt to convert them into seconds\n"
+             "by dividing by the value of CLOCKS_PER_SEC."
+             "If cleanup has been disabled, returns None."
+             "\n"
+             "This is an implementation specific, provisional API. It may be changed or removed\n"
+             "in the future.\n"
+             ".. versionadded:: 2.0"
+             );
+static PyObject*
+mod_get_clocks_used_doing_optional_cleanup(PyObject* UNUSED(module))
+{
+    std::clock_t& clocks = ThreadState::clocks_used_doing_gc();
+
+    if (clocks == std::clock_t(-1)) {
+        Py_RETURN_NONE;
+    }
+    // This might not actually work on some implementations; clock_t
+    // is an opaque type.
+    return PyLong_FromSsize_t(clocks);
+}
+
+PyDoc_STRVAR(mod_enable_optional_cleanup_doc,
+             "mod_enable_optional_cleanup(bool) -> None\n"
+             "\n"
+             "Enable or disable optional cleanup operations.\n"
+             "See ``get_clocks_used_doing_optional_cleanup()`` for details.\n"
+             );
+static PyObject*
+mod_enable_optional_cleanup(PyObject* UNUSED(module), PyObject* flag)
+{
+    int is_true = PyObject_IsTrue(flag);
+    if (is_true == -1) {
+        return nullptr;
+    }
+
+    std::clock_t& clocks = ThreadState::clocks_used_doing_gc();
+    if (is_true) {
+        // If we already have a value, we don't want to lose it.
+        if (clocks == std::clock_t(-1)) {
+            clocks = 0;
+        }
+    }
+    else {
+        clocks = std::clock_t(-1);
+    }
+    Py_RETURN_NONE;
+}
+
+PyDoc_STRVAR(mod_get_tstate_trash_delete_nesting_doc,
+             "get_tstate_trash_delete_nesting() -> Integer\n"
+             "\n"
+             "Return the 'trash can' nesting level. Testing only.\n");
+static PyObject*
+mod_get_tstate_trash_delete_nesting(PyObject* UNUSED(module))
+{
+    PyThreadState* tstate = PyThreadState_GET();
+    return PyLong_FromLong(tstate->trash_delete_nesting);
+}
+
+static PyMethodDef GreenMethods = {
+    {"getcurrent",
+     (PyCFunction)mod_getcurrent,
+     METH_NOARGS,
+     mod_getcurrent_doc},
+    {"settrace", (PyCFunction)mod_settrace, METH_VARARGS, mod_settrace_doc},
+    {"gettrace", (PyCFunction)mod_gettrace, METH_NOARGS, mod_gettrace_doc},
+    {"set_thread_local", (PyCFunction)mod_set_thread_local, METH_VARARGS, mod_set_thread_local_doc},
+    {"get_pending_cleanup_count", (PyCFunction)mod_get_pending_cleanup_count, METH_NOARGS, mod_get_pending_cleanup_count_doc},
+    {"get_total_main_greenlets", (PyCFunction)mod_get_total_main_greenlets, METH_NOARGS, mod_get_total_main_greenlets_doc},
+    {"get_clocks_used_doing_optional_cleanup", (PyCFunction)mod_get_clocks_used_doing_optional_cleanup, METH_NOARGS, mod_get_clocks_used_doing_optional_cleanup_doc},
+    {"enable_optional_cleanup", (PyCFunction)mod_enable_optional_cleanup, METH_O, mod_enable_optional_cleanup_doc},
+    {"get_tstate_trash_delete_nesting", (PyCFunction)mod_get_tstate_trash_delete_nesting, METH_NOARGS, mod_get_tstate_trash_delete_nesting_doc},
+    {NULL, NULL} /* Sentinel */
+};
+
+static const char* const copy_on_greentype = {
+    "getcurrent",
+    "error",
+    "GreenletExit",
+    "settrace",
+    "gettrace",
+    NULL
+};
+
+static struct PyModuleDef greenlet_module_def = {
+    PyModuleDef_HEAD_INIT,
+    "greenlet._greenlet",
+    NULL,
+    -1,
+    GreenMethods,
+};
+
+
+
+static PyObject*
+greenlet_internal_mod_init() G_NOEXCEPT
+{
+    static void* _PyGreenlet_APIPyGreenlet_API_pointers;
+    GREENLET_NOINLINE_INIT();
+
+    try {
+        CreatedModule m(greenlet_module_def);
+
+        Require(PyType_Ready(&PyGreenlet_Type));
+
+#if G_USE_STANDARD_THREADING == 0
+        Require(PyType_Ready(&PyGreenletCleanup_Type));
+#endif
+
+        new((void*)&mod_globs) GreenletGlobals;
+        ThreadState::init();
+
+        m.PyAddObject("greenlet", PyGreenlet_Type);
+        m.PyAddObject("error", mod_globs.PyExc_GreenletError);
+        m.PyAddObject("GreenletExit", mod_globs.PyExc_GreenletExit);
+
+        m.PyAddObject("GREENLET_USE_GC", 1);
+        m.PyAddObject("GREENLET_USE_TRACING", 1);
+        // The macros are eithre 0 or 1; the 0 case can be interpreted
+        // the same as NULL, which is ambiguous with a pointer.
+        m.PyAddObject("GREENLET_USE_CONTEXT_VARS", (long)GREENLET_PY37);
+        m.PyAddObject("GREENLET_USE_STANDARD_THREADING", (long)G_USE_STANDARD_THREADING);
+
+        OwnedObject clocks_per_sec = OwnedObject::consuming(PyLong_FromSsize_t(CLOCKS_PER_SEC));
+        m.PyAddObject("CLOCKS_PER_SEC", clocks_per_sec);
+
+        /* also publish module-level data as attributes of the greentype. */
+        // XXX: This is weird, and enables a strange pattern of
+        // confusing the class greenlet with the module greenlet; with
+        // the exception of (possibly) ``getcurrent()``, this
+        // shouldn't be encouraged so don't add new items here.
+        for (const char* const* p = copy_on_greentype; *p; p++) {
+            OwnedObject o = m.PyRequireAttr(*p);
+            PyDict_SetItemString(PyGreenlet_Type.tp_dict, *p, o.borrow());
+        }
+
+        /*
+         * Expose C API
+         */
+
+        /* types */
+        _PyGreenlet_APIPyGreenlet_Type_NUM = (void*)&PyGreenlet_Type;
+
+        /* exceptions */
+        _PyGreenlet_APIPyExc_GreenletError_NUM = (void*)mod_globs.PyExc_GreenletError;
+        _PyGreenlet_APIPyExc_GreenletExit_NUM = (void*)mod_globs.PyExc_GreenletExit;
+
+        /* methods */
+        _PyGreenlet_APIPyGreenlet_New_NUM = (void*)PyGreenlet_New;
+        _PyGreenlet_APIPyGreenlet_GetCurrent_NUM = (void*)PyGreenlet_GetCurrent;
+        _PyGreenlet_APIPyGreenlet_Throw_NUM = (void*)PyGreenlet_Throw;
+        _PyGreenlet_APIPyGreenlet_Switch_NUM = (void*)PyGreenlet_Switch;
+        _PyGreenlet_APIPyGreenlet_SetParent_NUM = (void*)PyGreenlet_SetParent;
+
+        /* Previously macros, but now need to be functions externally. */
+        _PyGreenlet_APIPyGreenlet_MAIN_NUM = (void*)Extern_PyGreenlet_MAIN;
+        _PyGreenlet_APIPyGreenlet_STARTED_NUM = (void*)Extern_PyGreenlet_STARTED;
+        _PyGreenlet_APIPyGreenlet_ACTIVE_NUM = (void*)Extern_PyGreenlet_ACTIVE;
+        _PyGreenlet_APIPyGreenlet_GET_PARENT_NUM = (void*)Extern_PyGreenlet_GET_PARENT;
+
+        /* XXX: Note that our module name is ``greenlet._greenlet``, but for
+           backwards compatibility with existing C code, we need the _C_API to
+           be directly in greenlet.
+        */
+        const NewReference c_api_object(Require(
+                                           PyCapsule_New(
+                                               (void*)_PyGreenlet_API,
+                                               "greenlet._C_API",
+                                               NULL)));
+        m.PyAddObject("_C_API", c_api_object);
+        assert(c_api_object.REFCNT() == 2);
+
+        // cerr << "Sizes:"
+        //      << "\n\tGreenlet       : " << sizeof(Greenlet)
+        //      << "\n\tUserGreenlet   : " << sizeof(UserGreenlet)
+        //      << "\n\tMainGreenlet   : " << sizeof(MainGreenlet)
+        //      << "\n\tExceptionState : " << sizeof(greenlet::ExceptionState)
+        //      << "\n\tPythonState    : " << sizeof(greenlet::PythonState)
+        //      << "\n\tStackState     : " << sizeof(greenlet::StackState)
+        //      << "\n\tSwitchingArgs  : " << sizeof(greenlet::SwitchingArgs)
+        //      << "\n\tOwnedObject    : " << sizeof(greenlet::refs::OwnedObject)
+        //      << "\n\tBorrowedObject : " << sizeof(greenlet::refs::BorrowedObject)
+        //      << "\n\tPyGreenlet     : " << sizeof(PyGreenlet)
+        //      << endl;
+
+        return m.borrow(); // But really it's the main reference.
+    }
+    catch (const LockInitError& e) {
+        PyErr_SetString(PyExc_MemoryError, e.what());
+        return NULL;
+    }
+    catch (const PyErrOccurred&) {
+        return NULL;
+    }
+
+}
+
+extern "C" {
+#if PY_MAJOR_VERSION >= 3
+PyMODINIT_FUNC
+PyInit__greenlet(void)
+{
+    return greenlet_internal_mod_init();
+}
+#else
+PyMODINIT_FUNC
+init_greenlet(void)
+{
+    greenlet_internal_mod_init();
+}
+#endif
+};
+
+#ifdef __clang__
+#    pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#    pragma GCC diagnostic pop
+#endif

_service:tar_scm:greenlet-1.1.2.tar.gz/src/greenlet/greenlet.h -> _service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/greenlet.h Changed

@@ -5,6 +5,7 @@
 #ifndef Py_GREENLETOBJECT_H
 #define Py_GREENLETOBJECT_H
 
+
 #include <Python.h>
 
 #ifdef __cplusplus
@@ -14,45 +15,24 @@
 /* This is deprecated and undocumented. It does not change. */
 #define GREENLET_VERSION "1.0.0"
 
+#ifndef GREENLET_MODULE
+#define implementation_ptr_t void*
+#endif
+
 typedef struct _greenlet {
     PyObject_HEAD
-    char* stack_start;
-    char* stack_stop;
-    char* stack_copy;
-    intptr_t stack_saved;
-    struct _greenlet* stack_prev;
-    struct _greenlet* parent;
-    PyObject* run_info;
-    struct _frame* top_frame;
-    int recursion_depth;
     PyObject* weakreflist;
-#if PY_VERSION_HEX >= 0x030700A3
-    _PyErr_StackItem* exc_info;
-    _PyErr_StackItem exc_state;
-#else
-    PyObject* exc_type;
-    PyObject* exc_value;
-    PyObject* exc_traceback;
-#endif
     PyObject* dict;
-#if PY_VERSION_HEX >= 0x030700A3
-    PyObject* context;
-#endif
-#if PY_VERSION_HEX >= 0x30A00B1
-    CFrame* cframe;
-#endif
+    implementation_ptr_t pimpl;
 } PyGreenlet;
 
-#define PyGreenlet_Check(op) PyObject_TypeCheck(op, &PyGreenlet_Type)
-#define PyGreenlet_MAIN(op) (((PyGreenlet*)(op))->stack_stop == (char*)-1)
-#define PyGreenlet_STARTED(op) (((PyGreenlet*)(op))->stack_stop != NULL)
-#define PyGreenlet_ACTIVE(op) (((PyGreenlet*)(op))->stack_start != NULL)
-#define PyGreenlet_GET_PARENT(op) (((PyGreenlet*)(op))->parent)
+#define PyGreenlet_Check(op) (op && PyObject_TypeCheck(op, &PyGreenlet_Type))
+
 
 /* C API functions */
 
 /* Total number of symbols that are exported */
-#define PyGreenlet_API_pointers 8
+#define PyGreenlet_API_pointers 12
 
 #define PyGreenlet_Type_NUM 0
 #define PyExc_GreenletError_NUM 1
@@ -64,6 +44,11 @@
 #define PyGreenlet_Switch_NUM 6
 #define PyGreenlet_SetParent_NUM 7
 
+#define PyGreenlet_MAIN_NUM 8
+#define PyGreenlet_STARTED_NUM 9
+#define PyGreenlet_ACTIVE_NUM 10
+#define PyGreenlet_GET_PARENT_NUM 11
+
 #ifndef GREENLET_MODULE
 /* This section is used by modules that uses the greenlet C API */
 static void** _PyGreenlet_API = NULL;
@@ -129,6 +114,39 @@
         (*(int (*)(PyGreenlet * greenlet, PyGreenlet * nparent)) \
              _PyGreenlet_APIPyGreenlet_SetParent_NUM)
 
+/*
+ * PyGreenlet_GetParent(PyObject* greenlet)
+ *
+ * return greenlet.parent;
+ *
+ * This could return NULL even if there is no exception active.
+ * If it does not return NULL, you are responsible for decrementing the
+ * reference count.
+ */
+#     define PyGreenlet_GetParent                                    \
+    (*(PyGreenlet* (*)(PyGreenlet*))                                 \
+     _PyGreenlet_APIPyGreenlet_GET_PARENT_NUM)
+
+/*
+ * deprecated, undocumented alias.
+ */
+#     define PyGreenlet_GET_PARENT PyGreenlet_GetParent
+
+#     define PyGreenlet_MAIN                                         \
+    (*(int (*)(PyGreenlet*))                                         \
+     _PyGreenlet_APIPyGreenlet_MAIN_NUM)
+
+#     define PyGreenlet_STARTED                                      \
+    (*(int (*)(PyGreenlet*))                                         \
+     _PyGreenlet_APIPyGreenlet_STARTED_NUM)
+
+#     define PyGreenlet_ACTIVE                                       \
+    (*(int (*)(PyGreenlet*))                                         \
+     _PyGreenlet_APIPyGreenlet_ACTIVE_NUM)
+
+
+
+
 /* Macro that imports greenlet and initializes C API */
 /* NOTE: This has actually moved to ``greenlet._greenlet._C_API``, but we
    keep the older definition to be sure older code that might have a copy of

_service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/greenlet_allocator.hpp Added

@@ -0,0 +1,63 @@
+#ifndef GREENLET_ALLOCATOR_HPP
+#define GREENLET_ALLOCATOR_HPP
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include <memory>
+#include "greenlet_compiler_compat.hpp"
+
+
+namespace greenlet
+{
+    // This allocator is stateless; all instances are identical.
+    // It can *ONLY* be used when we're sure we're holding the GIL
+    // (Python's allocators require the GIL).
+    template <class T>
+    struct PythonAllocator : public std::allocator<T> {
+
+        PythonAllocator(const PythonAllocator& UNUSED(other))
+            : std::allocator<T>()
+        {
+        }
+
+        PythonAllocator(const std::allocator<T> other)
+            : std::allocator<T>(other)
+        {}
+
+        template <class U>
+        PythonAllocator(const std::allocator<U>& other)
+            : std::allocator<T>(other)
+        {
+        }
+
+        PythonAllocator() : std::allocator<T>() {}
+
+        T* allocate(size_t number_objects, const void* UNUSED(hint)=0)
+        {
+            void* p;
+            if (number_objects == 1)
+                p = PyObject_Malloc(sizeof(T));
+            else
+                p = PyMem_Malloc(sizeof(T) * number_objects);
+            return static_cast<T*>(p);
+        }
+
+        void deallocate(T* t, size_t n)
+        {
+            void* p = t;
+            if (n == 1) {
+                PyObject_Free(p);
+            }
+            else
+                PyMem_Free(p);
+        }
+        // This member is deprecated in C++17 and removed in C++20
+        template< class U >
+        struct rebind {
+            typedef PythonAllocator<U> other;
+        };
+
+    };
+}
+
+#endif

_service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/greenlet_compiler_compat.hpp Added

@@ -0,0 +1,132 @@
+/* -*- indent-tabs-mode: nil; tab-width: 4; -*- */
+#ifndef GREENLET_COMPILER_COMPAT_HPP
+#define GREENLET_COMPILER_COMPAT_HPP
+
+/**
+ * Definitions to aid with compatibility with different compilers.
+ *
+ * .. caution:: Use extreme care with G_NOEXCEPT.
+ * Some compilers and runtimes, specifically gcc/libgcc/libstdc++ on
+ * Linux, implement stack unwinding by throwing an uncatchable
+ * exception, one that specifically does not appear to be an active
+ * exception to the rest of the runtime. If this happens while we're in a G_NOEXCEPT function,
+ * we have violated our dynamic exception contract, and so the runtime
+ * will call std::terminate(), which kills the process with the
+ * unhelpful message "terminate called without an active exception".
+ *
+ * This has happened in this scenario: A background thread is running
+ * a greenlet that has made a native call and released the GIL.
+ * Meanwhile, the main thread finishes and starts shutting down the
+ * interpreter. When the background thread is scheduled again and
+ * attempts to obtain the  GIL, it notices that the interpreter is
+ * exiting and calls ``pthread_exit()``. This in turn starts to unwind
+ * the stack by throwing that exception. But we had the ``PyCall``
+ * functions annotated as G_NOEXCEPT, so the runtime terminated us.
+ *
+ * #2  0x00007fab26fec2b7 in std::terminate() () from /lib/x86_64-linux-gnu/libstdc++.so.6
+ * #3  0x00007fab26febb3c in __gxx_personality_v0 () from /lib/x86_64-linux-gnu/libstdc++.so.6
+ * #4  0x00007fab26f34de6 in ?? () from /lib/x86_64-linux-gnu/libgcc_s.so.1
+ * #6  0x00007fab276a34c6 in __GI___pthread_unwind  at ./nptl/unwind.c:130
+ * #7  0x00007fab2769bd3a in __do_cancel () at ../sysdeps/nptl/pthreadP.h:280
+ * #8  __GI___pthread_exit (value=value@entry=0x0) at ./nptl/pthread_exit.c:36
+ * #9  0x000000000052e567 in PyThread_exit_thread () at ../Python/thread_pthread.h:370
+ * #10 0x00000000004d60b5 in take_gil at ../Python/ceval_gil.h:224
+ * #11 0x00000000004d65f9 in PyEval_RestoreThread  at ../Python/ceval.c:467
+ * #12 0x000000000060cce3 in setipaddr  at ../Modules/socketmodule.c:1203
+ * #13 0x00000000006101cd in socket_gethostbyname
+ */
+
+
+/* The compiler used for Python 2.7 on Windows doesn't include
+   either stdint.h or cstdint.h. Nor does it understand nullptr or have
+   std::shared_ptr. = delete, etc Sigh. */
+#if defined(_MSC_VER) &&  _MSC_VER <= 1500
+typedef unsigned long long uint64_t;
+typedef signed long long int64_t;
+typedef unsigned int uint32_t;
+// C++ defines NULL to be 0, which is ambiguous
+// with an integer in certain cases, and won't autoconvert to a
+// pointer in other cases.
+#define nullptr NULL
+#define G_HAS_METHOD_DELETE 0
+// Use G_EXPLICIT_OP as the prefix for operator methods
+// that should be explicit. Old MSVC doesn't support explicit operator
+// methods.
+#define G_EXPLICIT_OP
+#define G_NOEXCEPT throw()
+// This version doesn't support "objects with internal linkage"
+// in non-type template arguments. Translation: function pointer
+// template arguments cannot be for static functions.
+#define G_FP_TMPL_STATIC
+#else
+// Newer, reasonable compilers implementing C++11 or so.
+#include <cstdint>
+#define G_HAS_METHOD_DELETE 1
+#define G_EXPLICIT_OP explicit
+#define G_NOEXCEPT noexcept
+# if defined(__clang__)
+#  define G_FP_TMPL_STATIC static
+# else
+// GCC has no problem allowing static function pointers, but emits
+// tons of warnings about "whose type uses the anonymous namespace -Wsubobject-linkage"
+#  define G_FP_TMPL_STATIC
+# endif
+
+#endif
+
+#if G_HAS_METHOD_DELETE == 1
+#    define G_NO_COPIES_OF_CLS(Cls) private:     \
+    Cls(const Cls& other) = delete; \
+    Cls& operator=(const Cls& other) = delete
+
+#    define G_NO_ASSIGNMENT_OF_CLS(Cls) private:  \
+    Cls& operator=(const Cls& other) = delete
+
+#    define G_NO_COPY_CONSTRUCTOR_OF_CLS(Cls) private: \
+    Cls(const Cls& other) = delete;
+#else
+#    define G_NO_COPIES_OF_CLS(Cls) private: \
+    Cls(const Cls& other); \
+    Cls& operator=(const Cls& other)
+
+#    define G_NO_ASSIGNMENT_OF_CLS(Cls) private: \
+        Cls& operator=(const Cls& other)
+
+#    define G_NO_COPY_CONSTRUCTOR_OF_CLS(Cls) private: \
+    Cls(const Cls& other);
+#endif
+
+// CAUTION: MSVC is stupidly picky:
+//
+// "The compiler ignores, without warning, any __declspec keywords
+// placed after * or & and in front of the variable identifier in a
+// declaration."
+// (https://docs.microsoft.com/en-us/cpp/cpp/declspec?view=msvc-160)
+//
+// So pointer return types must be handled differently (because of the
+// trailing *), or you get inscrutable compiler warnings like "error
+// C2059: syntax error: ''"
+
+#if defined(__GNUC__) || defined(__clang__)
+/* We used to check for GCC 4+ or 3.4+, but those compilers are
+   laughably out of date. Just assume they support it. */
+#    define GREENLET_NOINLINE_SUPPORTED
+#    define GREENLET_NOINLINE(name) __attribute__((noinline)) name
+#    define GREENLET_NOINLINE_P(rtype, name) rtype __attribute__((noinline)) name
+#    define UNUSED(x) UNUSED_ ## x __attribute__((__unused__))
+#elif defined(_MSC_VER)
+/* We used to check for  && (_MSC_VER >= 1300) but that's also out of date. */
+#    define GREENLET_NOINLINE_SUPPORTED
+#    define GREENLET_NOINLINE(name) __declspec(noinline) name
+#    define GREENLET_NOINLINE_P(rtype, name) __declspec(noinline) rtype name
+#    define UNUSED(x) UNUSED_ ## x
+#endif
+
+#if defined(_MSC_VER)
+#    define G_NOEXCEPT_WIN32 G_NOEXCEPT
+#else
+#    define G_NOEXCEPT_WIN32
+#endif
+
+
+#endif

_service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/greenlet_cpython_compat.hpp Added

@@ -0,0 +1,165 @@
+/* -*- indent-tabs-mode: nil; tab-width: 4; -*- */
+#ifndef GREENLET_CPYTHON_COMPAT_H
+#define GREENLET_CPYTHON_COMPAT_H
+
+/**
+ * Helpers for compatibility with multiple versions of CPython.
+ */
+
+#define PY_SSIZE_T_CLEAN
+#include "Python.h"
+
+// These enable writing template functions or classes specialized
+// based on the Python version. Write both versions of the function,
+// one with the WHEN version, one with the WHEN_NOT version.
+// Instantiate the template using the G_IS_PY37 macro.
+struct GREENLET_WHEN_PY37
+{
+    typedef GREENLET_WHEN_PY37* Yes;
+    // We really just want an alias, `using Yes = IsIt`,
+    // but old MSVC for Py27 doesn't support that.
+    typedef GREENLET_WHEN_PY37* IsIt;
+};
+
+struct GREENLET_WHEN_NOT_PY37
+{
+    typedef GREENLET_WHEN_NOT_PY37* No;
+    typedef GREENLET_WHEN_NOT_PY37* IsIt;
+};
+
+
+#if PY_VERSION_HEX >= 0x030700A3
+#    define GREENLET_PY37 1
+typedef GREENLET_WHEN_PY37 G_IS_PY37;
+#else
+#    define GREENLET_PY37 0
+typedef GREENLET_WHEN_NOT_PY37 G_IS_PY37;
+#endif
+
+
+#if PY_VERSION_HEX >= 0x30A00B1
+/*
+Python 3.10 beta 1 changed tstate->use_tracing to a nested cframe member.
+See https://github.com/python/cpython/pull/25276
+We have to save and restore this as well.
+*/
+#    define GREENLET_USE_CFRAME 1
+#else
+#    define GREENLET_USE_CFRAME 0
+#endif
+
+#if PY_VERSION_HEX >= 0x30B00A4
+/*
+Greenlet won't compile on anything older than Python 3.11 alpha 4 (see
+https://bugs.python.org/issue46090). Summary of breaking internal changes:
+- Python 3.11 alpha 1 changed how frame objects are represented internally.
+  - https://github.com/python/cpython/pull/30122
+- Python 3.11 alpha 3 changed how recursion limits are stored.
+  - https://github.com/python/cpython/pull/29524
+- Python 3.11 alpha 4 changed how exception state is stored. It also includes a
+  change to help greenlet save and restore the interpreter frame "data stack".
+  - https://github.com/python/cpython/pull/30122
+  - https://github.com/python/cpython/pull/30234
+*/
+#    define GREENLET_PY311 1
+#else
+#    define GREENLET_PY311 0
+#endif
+
+#ifndef Py_SET_REFCNT
+/* Py_REFCNT and Py_SIZE macros are converted to functions
+https://bugs.python.org/issue39573 */
+#    define Py_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt)
+#endif
+
+#ifndef _Py_DEC_REFTOTAL
+/* _Py_DEC_REFTOTAL macro has been removed from Python 3.9 by:
+  https://github.com/python/cpython/commit/49932fec62c616ec88da52642339d83ae719e924
+*/
+#    ifdef Py_REF_DEBUG
+#        define _Py_DEC_REFTOTAL _Py_RefTotal--
+#    else
+#        define _Py_DEC_REFTOTAL
+#    endif
+#endif
+// Define these flags like Cython does if we're on an old version.
+#ifndef Py_TPFLAGS_CHECKTYPES
+  #define Py_TPFLAGS_CHECKTYPES 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_INDEX
+  #define Py_TPFLAGS_HAVE_INDEX 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_NEWBUFFER
+  #define Py_TPFLAGS_HAVE_NEWBUFFER 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_FINALIZE
+  #define Py_TPFLAGS_HAVE_FINALIZE 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_VERSION_TAG
+   #define Py_TPFLAGS_HAVE_VERSION_TAG 0
+#endif
+
+#define G_TPFLAGS_DEFAULT Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_VERSION_TAG | Py_TPFLAGS_CHECKTYPES | Py_TPFLAGS_HAVE_NEWBUFFER | Py_TPFLAGS_HAVE_GC
+
+#if PY_MAJOR_VERSION >= 3
+#    define GNative_FromFormat PyUnicode_FromFormat
+#else
+#    define GNative_FromFormat PyString_FromFormat
+#endif
+
+#if PY_MAJOR_VERSION >= 3
+#    define Greenlet_Intern PyUnicode_InternFromString
+#else
+#    define Greenlet_Intern PyString_InternFromString
+#endif
+
+#if PY_VERSION_HEX < 0x03090000
+// The official version only became available in 3.9
+#    define PyObject_GC_IsTracked(o) _PyObject_GC_IS_TRACKED(o)
+#endif
+
+#if PY_MAJOR_VERSION < 3
+struct PyModuleDef {
+    int unused;
+    const char* const m_name;
+    const char* m_doc;
+    Py_ssize_t m_size;
+    PyMethodDef* m_methods;
+    // Then several more fields we're not currently using.
+};
+#define PyModuleDef_HEAD_INIT 1
+PyObject* PyModule_Create(PyModuleDef* m)
+{
+    return Py_InitModule(m->m_name, m->m_methods);
+}
+#endif
+
+// bpo-43760 added PyThreadState_EnterTracing() to Python 3.11.0a2
+#if PY_VERSION_HEX < 0x030B00A2 && !defined(PYPY_VERSION)
+static inline void PyThreadState_EnterTracing(PyThreadState *tstate)
+{
+    tstate->tracing++;
+#if PY_VERSION_HEX >= 0x030A00A1
+    tstate->cframe->use_tracing = 0;
+#else
+    tstate->use_tracing = 0;
+#endif
+}
+#endif
+
+// bpo-43760 added PyThreadState_LeaveTracing() to Python 3.11.0a2
+#if PY_VERSION_HEX < 0x030B00A2 && !defined(PYPY_VERSION)
+static inline void PyThreadState_LeaveTracing(PyThreadState *tstate)
+{
+    tstate->tracing--;
+    int use_tracing = (tstate->c_tracefunc != NULL
+                       || tstate->c_profilefunc != NULL);
+#if PY_VERSION_HEX >= 0x030A00A1
+    tstate->cframe->use_tracing = use_tracing;
+#else
+    tstate->use_tracing = use_tracing;
+#endif
+}
+#endif
+
+#endif /* GREENLET_CPYTHON_COMPAT_H */

_service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/greenlet_exceptions.hpp Added

@@ -0,0 +1,106 @@
+#ifndef GREENLET_EXCEPTIONS_HPP
+#define GREENLET_EXCEPTIONS_HPP
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include <stdexcept>
+#include <string>
+
+#ifdef __clang__
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wunused-function"
+#endif
+
+namespace greenlet {
+
+    class PyErrOccurred : public std::runtime_error
+    {
+    public:
+        PyErrOccurred() : std::runtime_error("")
+        {
+            assert(PyErr_Occurred());
+        }
+
+        PyErrOccurred(PyObject* exc_kind, const char* const msg)
+            : std::runtime_error(msg)
+        {
+            PyErr_SetString(exc_kind, msg);
+        }
+        PyErrOccurred(PyObject* exc_kind, const std::string msg)
+            : std::runtime_error(msg)
+        {
+            // This copies the c_str, so we don't have any lifetime
+            // issues to worry about.
+            PyErr_SetString(exc_kind, msg.c_str());
+        }
+    };
+
+    class TypeError : public PyErrOccurred
+    {
+    public:
+        TypeError(const char* const what)
+            : PyErrOccurred(PyExc_TypeError, what)
+        {
+        }
+        TypeError(const std::string what)
+            : PyErrOccurred(PyExc_TypeError, what)
+        {
+        }
+    };
+
+    class ValueError : public PyErrOccurred
+    {
+    public:
+        ValueError(const char* const what)
+            : PyErrOccurred(PyExc_ValueError, what)
+        {
+        }
+    };
+
+    class AttributeError : public PyErrOccurred
+    {
+    public:
+        AttributeError(const char* const what)
+            : PyErrOccurred(PyExc_AttributeError, what)
+        {
+        }
+    };
+
+    /**
+     * Calls `Py_FatalError` when constructed, so you can't actually
+     * throw this. It just makes static analysis easier.
+     */
+    class PyFatalError : public std::runtime_error
+    {
+    public:
+        PyFatalError(const char* const msg)
+            : std::runtime_error(msg)
+        {
+            Py_FatalError(msg);
+        }
+    };
+
+    static inline PyObject*
+    Require(PyObject* p)
+    {
+        if (!p) {
+            throw PyErrOccurred();
+        }
+        return p;
+    };
+
+    static inline void
+    Require(const int retval)
+    {
+        if (retval < 0) {
+            throw PyErrOccurred();
+        }
+    };
+
+
+};
+#ifdef __clang__
+#    pragma clang diagnostic pop
+#endif
+
+#endif

_service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/greenlet_greenlet.hpp Added

@@ -0,0 +1,1272 @@
+#ifndef GREENLET_GREENLET_HPP
+#define GREENLET_GREENLET_HPP
+/*
+ * Declarations of the core data structures.
+*/
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+#include "greenlet_compiler_compat.hpp"
+#include "greenlet_refs.hpp"
+#include "greenlet_cpython_compat.hpp"
+#include "greenlet_allocator.hpp"
+
+using greenlet::refs::OwnedObject;
+using greenlet::refs::OwnedGreenlet;
+using greenlet::refs::OwnedMainGreenlet;
+using greenlet::refs::BorrowedGreenlet;
+
+#if PY_VERSION_HEX < 0x30B00A6
+#  define _PyCFrame CFrame
+#  define _PyInterpreterFrame _interpreter_frame
+#endif
+
+// XXX: TODO: Work to remove all virtual functions
+// for speed of calling and size of objects (no vtable).
+// One pattern is the Curiously Recurring Template
+namespace greenlet
+{
+    class ExceptionState
+    {
+    private:
+        G_NO_COPIES_OF_CLS(ExceptionState);
+
+#if PY_VERSION_HEX >= 0x030700A3
+        // Even though these are borrowed objects, we actually own
+        // them, when they're not null.
+        // XXX: Express that in the API.
+    private:
+        _PyErr_StackItem* exc_info;
+        _PyErr_StackItem exc_state;
+#else
+        OwnedObject exc_value;
+#if !GREENLET_PY311
+        OwnedObject exc_type;
+        OwnedObject exc_traceback;
+#endif
+#endif
+    public:
+        ExceptionState();
+        void operator<<(const PyThreadState *const tstate) G_NOEXCEPT;
+        void operator>>(PyThreadState* tstate) G_NOEXCEPT;
+        void clear() G_NOEXCEPT;
+
+        int tp_traverse(visitproc visit, void* arg) G_NOEXCEPT;
+        void tp_clear() G_NOEXCEPT;
+    };
+
+    template<typename T>
+    void operator<<(const PyThreadState *const tstate, T& exc);
+
+    template<typename IsPy37>
+    class PythonStateContext
+    {};
+
+    template<>
+    class PythonStateContext<GREENLET_WHEN_PY37>
+    {
+    protected:
+        greenlet::refs::OwnedContext _context;
+    public:
+        inline const greenlet::refs::OwnedContext& context() const
+        {
+            return this->_context;
+        }
+        inline greenlet::refs::OwnedContext& context()
+        {
+            return this->_context;
+        }
+
+        inline void tp_clear()
+        {
+            this->_context.CLEAR();
+        }
+
+        template<typename T>
+        inline static PyObject* context(T* tstate)
+        {
+            return tstate->context;
+        }
+
+        template<typename T>
+        inline static void context(T* tstate, PyObject* new_context)
+        {
+            tstate->context = new_context;
+            tstate->context_ver++;
+        }
+    };
+
+
+    template<>
+    class PythonStateContext<GREENLET_WHEN_NOT_PY37>
+    {
+    public:
+        inline const greenlet::refs::OwnedContext& context() const
+        {
+            throw AttributeError("no context");
+        }
+
+        inline greenlet::refs::OwnedContext& context()
+        {
+            throw AttributeError("no context");
+        }
+
+        inline void tp_clear(){};
+
+        template<typename T>
+        inline static PyObject* context(T* UNUSED(tstate))
+        {
+            throw PyFatalError("This should never be called.");
+        }
+
+        template<typename T>
+        inline static void context(T* UNUSED(tstate), PyObject* UNUSED(new_context))
+        {
+            throw PyFatalError("This should never be called.");
+        }
+    };
+
+    class PythonState : public PythonStateContext<G_IS_PY37>
+    {
+    public:
+        typedef greenlet::refs::OwnedReference<struct _frame> OwnedFrame;
+    private:
+        G_NO_COPIES_OF_CLS(PythonState);
+        // We own this if we're suspended (although currently we don't
+        // tp_traverse into it; that's a TODO). If we're running, it's
+        // empty. If we get deallocated and *still* have a frame, it
+        // won't be reachable from the place that normally decref's
+        // it, so we need to do it (hence owning it).
+        OwnedFrame _top_frame;
+#if GREENLET_USE_CFRAME
+        _PyCFrame* cframe;
+        int use_tracing;
+#endif
+        int recursion_depth;
+        int trash_delete_nesting;
+#if GREENLET_PY311
+        _PyInterpreterFrame* current_frame;
+        _PyStackChunk* datastack_chunk;
+        PyObject** datastack_top;
+        PyObject** datastack_limit;
+#endif
+
+    public:
+        PythonState();
+        // You can use this for testing whether we have a frame
+        // or not. It returns const so they can't modify it.
+        const OwnedFrame& top_frame() const G_NOEXCEPT;
+
+
+        void operator<<(const PyThreadState *const tstate) G_NOEXCEPT;
+        void operator>>(PyThreadState* tstate) G_NOEXCEPT;
+        void clear() G_NOEXCEPT;
+
+        int tp_traverse(visitproc visit, void* arg, bool visit_top_frame) G_NOEXCEPT;
+        void tp_clear(bool own_top_frame) G_NOEXCEPT;
+        void set_initial_state(const PyThreadState* const tstate) G_NOEXCEPT;
+#if GREENLET_USE_CFRAME
+        void set_new_cframe(_PyCFrame& frame) G_NOEXCEPT;
+#endif
+        void will_switch_from(PyThreadState *const origin_tstate) G_NOEXCEPT;
+        void did_finish(PyThreadState* tstate) G_NOEXCEPT;
+    };
+
+    class StackState
+    {
+        // By having only plain C (POD) members, no virtual functions
+        // or bases, we get a trivial assignment operator generated
+        // for us. However, that's not safe since we do manage memory.
+        // So we declare an assignment operator that only works if we
+        // don't have any memory allocated. (We don't use
+        // std::shared_ptr for reference counting just to keep this
+        // object small)
+    private:
+        char* _stack_start;
+        char* stack_stop;
+        char* stack_copy;
+        intptr_t _stack_saved;
+        StackState* stack_prev;
+        inline int copy_stack_to_heap_up_to(const char* const stop) G_NOEXCEPT;
+        inline void free_stack_copy() G_NOEXCEPT;
+
+    public:
+        /**
+         * Creates a started, but inactive, state, using *current*
+         * as the previous.
+         */
+        StackState(void* mark, StackState& current);
+        /**
+         * Creates an inactive, unstarted, state.
+         */
+        StackState();
+        ~StackState();
+        StackState(const StackState& other);
+        StackState& operator=(const StackState& other);
+        inline void copy_heap_to_stack(const StackState& current) G_NOEXCEPT;
+        inline int copy_stack_to_heap(char* const stackref, const StackState& current) G_NOEXCEPT;
+        inline bool started() const G_NOEXCEPT;
+        inline bool main() const G_NOEXCEPT;
+        inline bool active() const G_NOEXCEPT;
+        inline void set_active() G_NOEXCEPT;
+        inline void set_inactive() G_NOEXCEPT;
+        inline intptr_t stack_saved() const G_NOEXCEPT;
+        inline char* stack_start() const G_NOEXCEPT;
+        static inline StackState make_main() G_NOEXCEPT;
+#ifdef GREENLET_USE_STDIO
+        friend std::ostream& operator<<(std::ostream& os, const StackState& s);
+#endif
+    };
+#ifdef GREENLET_USE_STDIO
+    std::ostream& operator<<(std::ostream& os, const StackState& s);
+#endif
+
+    class SwitchingArgs
+    {
+    private:
+        G_NO_ASSIGNMENT_OF_CLS(SwitchingArgs);
+        // If args and kwargs are both false (NULL), this is a *throw*, not a
+        // switch. PyErr_... must have been called already.
+        OwnedObject _args;
+        OwnedObject _kwargs;
+    public:
+
+        SwitchingArgs()
+        {}
+
+        SwitchingArgs(const OwnedObject& args, const OwnedObject& kwargs)
+            : _args(args),
+              _kwargs(kwargs)
+        {}
+
+        SwitchingArgs(const SwitchingArgs& other)
+            : _args(other._args),
+              _kwargs(other._kwargs)
+        {}
+
+        OwnedObject& args()
+        {
+            return this->_args;
+        }
+
+        OwnedObject& kwargs()
+        {
+            return this->_kwargs;
+        }
+
+        /**
+         * Moves ownership from the argument to this object.
+         */
+        SwitchingArgs& operator<<=(SwitchingArgs& other)
+        {
+            if (this != &other) {
+                this->_args = other._args;
+                this->_kwargs = other._kwargs;
+                other.CLEAR();
+            }
+            return *this;
+        }
+
+        /**
+         * Acquires ownership of the argument (consumes the reference).
+         */
+        SwitchingArgs& operator<<=(PyObject* args)
+        {
+            this->_args = OwnedObject::consuming(args);
+            this->_kwargs.CLEAR();
+            return *this;
+        }
+
+        /**
+         * Acquires ownership of the argument.
+         *
+         * Sets the args to be the given value; clears the kwargs.
+         */
+        SwitchingArgs& operator<<=(OwnedObject& args)
+        {
+            assert(&args != &this->_args);
+            this->_args = args;
+            this->_kwargs.CLEAR();
+            args.CLEAR();
+
+            return *this;
+        }
+
+        G_EXPLICIT_OP operator bool() const G_NOEXCEPT
+        {
+            return this->_args || this->_kwargs;
+        }
+
+        inline void CLEAR()
+        {
+            this->_args.CLEAR();
+            this->_kwargs.CLEAR();
+        }
+    };
+
+    class ThreadState;
+
+    class UserGreenlet;
+    class MainGreenlet;
+
+    class Greenlet
+    {
+    private:
+        G_NO_COPIES_OF_CLS(Greenlet);
+    private:
+        // XXX: Work to remove these.
+        friend class ThreadState;
+        friend class UserGreenlet;
+        friend class MainGreenlet;
+    protected:
+        ExceptionState exception_state;
+        SwitchingArgs switch_args;
+        StackState stack_state;
+        PythonState python_state;
+        Greenlet(PyGreenlet* p, const StackState& initial_state);
+    public:
+        Greenlet(PyGreenlet* p);
+        virtual ~Greenlet();
+
+        template <typename IsPy37> // maybe we can use a value here?
+        const OwnedObject context(const typename IsPy37::IsIt=nullptr) const;
+
+        template <typename IsPy37>
+        inline void context(refs::BorrowedObject new_context, typename IsPy37::IsIt=nullptr);
+
+        inline SwitchingArgs& args()
+        {
+            return this->switch_args;
+        }
+
+        virtual const refs::BorrowedMainGreenlet main_greenlet() const = 0;
+
+        inline intptr_t stack_saved() const G_NOEXCEPT
+        {
+            return this->stack_state.stack_saved();
+        }
+
+        // This is used by the macro SLP_SAVE_STATE to compute the
+        // difference in stack sizes. It might be nice to handle the
+        // computation ourself, but the type of the result
+        // varies by platform, so doing it in the macro is the
+        // simplest way.
+        inline const char* stack_start() const G_NOEXCEPT
+        {
+            return this->stack_state.stack_start();
+        }
+
+        virtual OwnedObject throw_GreenletExit_during_dealloc(const ThreadState& current_thread_state);
+        virtual OwnedObject g_switch() = 0;
+        /**
+         * Force the greenlet to appear dead. Used when it's not
+         * possible to throw an exception into a greenlet anymore.
+         *
+         * This losses access to the thread state and the main greenlet.
+         */
+        virtual void murder_in_place();
+
+        /**
+         * Called when somebody notices we were running in a dead
+         * thread to allow cleaning up resources (because we can't
+         * raise GreenletExit into it anymore).
+         * This is very similar to ``murder_in_place()``, except that
+         * it DOES NOT lose the main greenlet or thread state.
+         */
+        inline void deactivate_and_free();
+
+
+        // Called when some thread wants to deallocate a greenlet
+        // object.
+        // The thread may or may not be the same thread the greenlet
+        // was running in.
+        // The thread state will be null if the thread the greenlet
+        // was running in was known to have exited.
+        void deallocing_greenlet_in_thread(const ThreadState* current_state);
+
+        // TODO: Figure out how to make these non-public.
+        inline void slp_restore_state() G_NOEXCEPT;
+        inline int slp_save_state(char *const stackref) G_NOEXCEPT;
+
+        inline bool is_currently_running_in_some_thread() const;
+        virtual bool belongs_to_thread(const ThreadState* state) const;
+
+        inline bool started() const
+        {
+            return this->stack_state.started();
+        }
+        inline bool active() const
+        {
+            return this->stack_state.active();
+        }
+        inline bool main() const
+        {
+            return this->stack_state.main();
+        }
+        virtual refs::BorrowedMainGreenlet find_main_greenlet_in_lineage() const = 0;
+
+        virtual const OwnedGreenlet parent() const = 0;
+        virtual void parent(const refs::BorrowedObject new_parent) = 0;
+
+        inline const PythonState::OwnedFrame& top_frame()
+        {
+            return this->python_state.top_frame();
+        }
+
+        virtual const OwnedObject& run() const = 0;
+        virtual void run(const refs::BorrowedObject nrun) = 0;
+
+
+        virtual int tp_traverse(visitproc visit, void* arg);
+        virtual int tp_clear();
+
+
+        // Return the thread state that the greenlet is running in, or
+        // null if the greenlet is not running or the thread is known
+        // to have exited.
+        virtual ThreadState* thread_state() const G_NOEXCEPT = 0;
+
+        // Return true if the greenlet is known to have been running
+        // (active) in a thread that has now exited.
+        virtual bool was_running_in_dead_thread() const G_NOEXCEPT = 0;
+
+        // Return a borrowed greenlet that is the Python object
+        // this object represents.
+        virtual BorrowedGreenlet self() const G_NOEXCEPT = 0;
+
+    protected:
+        inline void release_args();
+
+        // The functions that must not be inlined are declared virtual.
+        // We also mark them as protected, not private, so that the
+        // compiler is forced to call them through a function pointer.
+        // (A sufficiently smart compiler could directly call a private
+        // virtual function since it can never be overridden in a
+        // subclass).
+
+        // Also TODO: Switch away from integer error codes and to enums,
+        // or throw exceptions when possible.
+        struct switchstack_result_t
+        {
+            int status;
+            Greenlet* the_state_that_switched;
+            OwnedGreenlet origin_greenlet;
+
+            switchstack_result_t()
+                : status(0),
+                  the_state_that_switched(nullptr)
+            {}
+
+            switchstack_result_t(int err)
+                : status(err),
+                  the_state_that_switched(nullptr)
+            {}
+
+            switchstack_result_t(int err, Greenlet* state, OwnedGreenlet& origin)
+                : status(err),
+                  the_state_that_switched(state),
+                  origin_greenlet(origin)
+            {
+            }
+
+            switchstack_result_t(int err, Greenlet* state, const BorrowedGreenlet& origin)
+                : status(err),
+                  the_state_that_switched(state),
+                  origin_greenlet(origin)
+            {
+            }
+
+            switchstack_result_t& operator=(const switchstack_result_t& other)
+            {
+                this->status = other.status;
+                this->the_state_that_switched = other.the_state_that_switched;
+                this->origin_greenlet = other.origin_greenlet;
+                return *this;
+            }
+        };
+
+        // Returns the previous greenlet we just switched away from.
+        virtual OwnedGreenlet g_switchstack_success() G_NOEXCEPT;
+
+
+        // Check the preconditions for switching to this greenlet; if they
+        // aren't met, throws PyErrOccurred. Most callers will want to
+        // catch this and clear the arguments
+        inline void check_switch_allowed() const;
+        class GreenletStartedWhileInPython : public std::runtime_error
+        {
+        public:
+            GreenletStartedWhileInPython() : std::runtime_error("")
+            {}
+        };
+
+    protected:
+
+
+        /**
+           Perform a stack switch into this greenlet.
+
+           This temporarily sets the global variable
+           ``switching_thread_state`` to this greenlet; as soon as the
+           call to ``slp_switch`` completes, this is reset to NULL.
+           Consequently, this depends on the GIL.
+
+           TODO: Adopt the stackman model and pass ``slp_switch`` a
+           callback function and context pointer; this eliminates the
+           need for global variables altogether.
+
+           Because the stack switch happens in this function, this
+           function can't use its own stack (local) variables, set
+           before the switch, and then accessed after the switch.
+
+           Further, you con't even access ``g_thread_state_global``
+           before and after the switch from the global variable.
+           Because it is thread local some compilers cache it in a
+           register/on the stack, notably new versions of MSVC; this
+           breaks with strange crashes sometime later, because writing
+           to anything in ``g_thread_state_global`` after the switch
+           is actually writing to random memory. For this reason, we
+           call a non-inlined function to finish the operation. (XXX:
+           The ``/GT`` MSVC compiler argument probably fixes that.)
+
+           It is very important that stack switch is 'atomic', i.e. no
+           calls into other Python code allowed (except very few that
+           are safe), because global variables are very fragile. (This
+           should no longer be the case with thread-local variables.)
+
+        */
+        switchstack_result_t g_switchstack(void);
+    private:
+        OwnedObject g_switch_finish(const switchstack_result_t& err);
+
+    };
+
+    class UserGreenlet : public Greenlet
+    {
+    private:
+        static greenlet::PythonAllocator<UserGreenlet> allocator;
+        BorrowedGreenlet _self;
+        OwnedMainGreenlet _main_greenlet;
+        OwnedObject _run_callable;
+        OwnedGreenlet _parent;
+    public:
+        static void* operator new(size_t UNUSED(count));
+        static void operator delete(void* ptr);
+
+        UserGreenlet(PyGreenlet* p, BorrowedGreenlet the_parent);
+        virtual ~UserGreenlet();
+
+        virtual refs::BorrowedMainGreenlet find_main_greenlet_in_lineage() const;
+        virtual bool was_running_in_dead_thread() const G_NOEXCEPT;
+        virtual ThreadState* thread_state() const G_NOEXCEPT;
+        virtual OwnedObject g_switch();
+        virtual const OwnedObject& run() const
+        {
+            if (this->started() || !this->_run_callable) {
+                throw AttributeError("run");
+            }
+            return this->_run_callable;
+        }
+        virtual void run(const refs::BorrowedObject nrun);
+
+        virtual const OwnedGreenlet parent() const;
+        virtual void parent(const refs::BorrowedObject new_parent);
+
+        virtual const refs::BorrowedMainGreenlet main_greenlet() const;
+
+        virtual BorrowedGreenlet self() const G_NOEXCEPT;
+        virtual void murder_in_place();
+        virtual bool belongs_to_thread(const ThreadState* state) const;
+        virtual int tp_traverse(visitproc visit, void* arg);
+        virtual int tp_clear();
+        class ParentIsCurrentGuard
+        {
+        private:
+            OwnedGreenlet oldparent;
+            UserGreenlet* greenlet;
+            G_NO_COPIES_OF_CLS(ParentIsCurrentGuard);
+        public:
+            ParentIsCurrentGuard(UserGreenlet* p, const ThreadState& thread_state);
+            ~ParentIsCurrentGuard();
+        };
+        virtual OwnedObject throw_GreenletExit_during_dealloc(const ThreadState& current_thread_state);
+    protected:
+        virtual switchstack_result_t g_initialstub(void* mark);
+    private:
+        void inner_bootstrap(OwnedGreenlet& origin_greenlet, OwnedObject& run) G_NOEXCEPT_WIN32;
+    };
+
+    class MainGreenlet : public Greenlet
+    {
+    private:
+        static greenlet::PythonAllocator<MainGreenlet> allocator;
+        refs::BorrowedMainGreenlet _self;
+        ThreadState* _thread_state;
+        G_NO_COPIES_OF_CLS(MainGreenlet);
+    public:
+        static void* operator new(size_t UNUSED(count));
+        static void operator delete(void* ptr);
+
+        MainGreenlet(refs::BorrowedMainGreenlet::PyType*, ThreadState*);
+        virtual ~MainGreenlet();
+
+
+        virtual const OwnedObject& run() const;
+        virtual void run(const refs::BorrowedObject nrun);
+
+        virtual const OwnedGreenlet parent() const;
+        virtual void parent(const refs::BorrowedObject new_parent);
+
+        virtual const refs::BorrowedMainGreenlet main_greenlet() const;
+
+        virtual refs::BorrowedMainGreenlet find_main_greenlet_in_lineage() const;
+        virtual bool was_running_in_dead_thread() const G_NOEXCEPT;
+        virtual ThreadState* thread_state() const G_NOEXCEPT;
+        void thread_state(ThreadState*) G_NOEXCEPT;
+        virtual OwnedObject g_switch();
+        virtual BorrowedGreenlet self() const G_NOEXCEPT;
+        virtual int tp_traverse(visitproc visit, void* arg);
+    };
+
+};
+
+template<typename T>
+void greenlet::operator<<(const PyThreadState *const lhs, T& rhs)
+{
+    rhs.operator<<(lhs);
+}
+
+using greenlet::ExceptionState;
+
+ExceptionState::ExceptionState()
+{
+    this->clear();
+}
+
+#if PY_VERSION_HEX >= 0x030700A3
+// ******** Python 3.7 and above *********
+void ExceptionState::operator<<(const PyThreadState *const tstate) G_NOEXCEPT
+{
+    this->exc_info = tstate->exc_info;
+    this->exc_state = tstate->exc_state;
+}
+
+void ExceptionState::operator>>(PyThreadState *const tstate) G_NOEXCEPT
+{
+    tstate->exc_state = this->exc_state;
+    tstate->exc_info =
+        this->exc_info ? this->exc_info : &tstate->exc_state;
+    this->clear();
+}
+
+void ExceptionState::clear() G_NOEXCEPT
+{
+    this->exc_info = nullptr;
+    this->exc_state.exc_value = nullptr;
+#if !GREENLET_PY311
+    this->exc_state.exc_type = nullptr;
+    this->exc_state.exc_traceback = nullptr;
+#endif
+    this->exc_state.previous_item = nullptr;
+}
+
+int ExceptionState::tp_traverse(visitproc visit, void* arg) G_NOEXCEPT
+{
+    Py_VISIT(this->exc_state.exc_value);
+#if !GREENLET_PY311
+    Py_VISIT(this->exc_state.exc_type);
+    Py_VISIT(this->exc_state.exc_traceback);
+#endif
+    return 0;
+}
+
+void ExceptionState::tp_clear() G_NOEXCEPT
+{
+    Py_CLEAR(this->exc_state.exc_value);
+#if !GREENLET_PY311
+    Py_CLEAR(this->exc_state.exc_type);
+    Py_CLEAR(this->exc_state.exc_traceback);
+#endif
+}
+#else
+// ********** Python 3.6 and below ********
+void ExceptionState::operator<<(const PyThreadState *const tstate) G_NOEXCEPT
+{
+    this->exc_value.steal(tstate->exc_value);
+#if !GREENLET_PY311
+    this->exc_type.steal(tstate->exc_type);
+    this->exc_traceback.steal(tstate->exc_traceback);
+#endif
+}
+
+void ExceptionState::operator>>(PyThreadState *const tstate) G_NOEXCEPT
+{
+    tstate->exc_value <<= this->exc_value;
+#if !GREENLET_PY311
+    tstate->exc_type <<= this->exc_type;
+    tstate->exc_traceback <<= this->exc_traceback;
+#endif
+    this->clear();
+}
+
+void ExceptionState::clear() G_NOEXCEPT
+{
+    this->exc_value = nullptr;
+#if !GREENLET_PY311
+    this->exc_type = nullptr;
+    this->exc_traceback = nullptr;
+#endif
+}
+
+int ExceptionState::tp_traverse(visitproc visit, void* arg) G_NOEXCEPT
+{
+    Py_VISIT(this->exc_value.borrow());
+#if !GREENLET_PY311
+    Py_VISIT(this->exc_type.borrow());
+    Py_VISIT(this->exc_traceback.borrow());
+#endif
+    return 0;
+}
+
+void ExceptionState::tp_clear() G_NOEXCEPT
+{
+    this->exc_value.CLEAR();
+#if !GREENLET_PY311
+    this->exc_type.CLEAR();
+    this->exc_traceback.CLEAR();
+#endif
+}
+#endif
+
+
+using greenlet::PythonState;
+
+PythonState::PythonState()
+    : _top_frame()
+#if GREENLET_USE_CFRAME
+    ,cframe(nullptr)
+    ,use_tracing(0)
+#endif
+    ,recursion_depth(0)
+    ,trash_delete_nesting(0)
+#if GREENLET_PY311
+    ,current_frame(nullptr)
+    ,datastack_chunk(nullptr)
+    ,datastack_top(nullptr)
+    ,datastack_limit(nullptr)
+#endif
+{
+#if GREENLET_USE_CFRAME
+    /*
+      The PyThreadState->cframe pointer usually points to memory on
+      the stack, alloceted in a call into PyEval_EvalFrameDefault.
+
+      Initially, before any evaluation begins, it points to the
+      initial PyThreadState object's ``root_cframe`` object, which is
+      statically allocated for the lifetime of the thread.
+
+      A greenlet can last for longer than a call to
+      PyEval_EvalFrameDefault, so we can't set its ``cframe`` pointer
+      to be the current ``PyThreadState->cframe``; nor could we use
+      one from the greenlet parent for the same reason. Yet a further
+      no: we can't allocate one scoped to the greenlet and then
+      destroy it when the greenlet is deallocated, because inside the
+      interpreter the _PyCFrame objects form a linked list, and that too
+      can result in accessing memory beyond its dynamic lifetime (if
+      the greenlet doesn't actually finish before it dies, its entry
+      could still be in the list).
+
+      Using the ``root_cframe`` is problematic, though, because its
+      members are never modified by the interpreter and are set to 0,
+      meaning that its ``use_tracing`` flag is never updated. We don't
+      want to modify that value in the ``root_cframe`` ourself: it
+      *shouldn't* matter much because we should probably never get
+      back to the point where that's the only cframe on the stack;
+      even if it did matter, the major consequence of an incorrect
+      value for ``use_tracing`` is that if its true the interpreter
+      does some extra work --- however, it's just good code hygiene.
+
+      Our solution: before a greenlet runs, after its initial
+      creation, it uses the ``root_cframe`` just to have something to
+      put there. However, once the greenlet is actually switched to
+      for the first time, ``g_initialstub`` (which doesn't actually
+      "return" while the greenlet is running) stores a new _PyCFrame on
+      its local stack, and copies the appropriate values from the
+      currently running _PyCFrame; this is then made the _PyCFrame for the
+      newly-minted greenlet. ``g_initialstub`` then proceeds to call
+      ``glet.run()``, which results in ``PyEval_...`` adding the
+      _PyCFrame to the list. Switches continue as normal. Finally, when
+      the greenlet finishes, the call to ``glet.run()`` returns and
+      the _PyCFrame is taken out of the linked list and the stack value
+      is now unused and free to expire.
+
+      XXX: I think we can do better. If we're deallocing in the same
+      thread, can't we traverse the list and unlink our frame?
+      Can we just keep a reference to the thread state in case we
+      dealloc in another thread? (Is that even possible if we're still
+      running and haven't returned from g_initialstub?)
+    */
+    this->cframe = &PyThreadState_GET()->root_cframe;
+#endif
+}
+
+void PythonState::operator<<(const PyThreadState *const tstate) G_NOEXCEPT
+{
+#if GREENLET_PY37
+    this->_context.steal(tstate->context);
+#endif
+#if GREENLET_USE_CFRAME
+    /*
+      IMPORTANT: ``cframe`` is a pointer into the STACK. Thus, because
+      the call to ``slp_switch()`` changes the contents of the stack,
+      you cannot read from ``ts_current->cframe`` after that call and
+      necessarily get the same values you get from reading it here.
+      Anything you need to restore from now to then must be saved in a
+      global/threadlocal variable (because we can't use stack
+      variables here either). For things that need to persist across
+      the switch, use `will_switch_from`.
+    */
+    this->cframe = tstate->cframe;
+    this->use_tracing = tstate->cframe->use_tracing;
+#endif
+#if GREENLET_PY311
+    this->recursion_depth = tstate->recursion_limit - tstate->recursion_remaining;
+    this->current_frame = tstate->cframe->current_frame;
+    this->datastack_chunk = tstate->datastack_chunk;
+    this->datastack_top = tstate->datastack_top;
+    this->datastack_limit = tstate->datastack_limit;
+    PyFrameObject *frame = PyThreadState_GetFrame((PyThreadState *)tstate);
+    Py_XDECREF(frame);  // PyThreadState_GetFrame gives us a new reference.
+    this->_top_frame.steal(frame);
+#else
+    this->recursion_depth = tstate->recursion_depth;
+    this->_top_frame.steal(tstate->frame);
+#endif
+
+    // All versions of Python.
+    this->trash_delete_nesting = tstate->trash_delete_nesting;
+}
+
+void PythonState::operator>>(PyThreadState *const tstate) G_NOEXCEPT
+{
+#if GREENLET_PY37
+    tstate->context = this->_context.relinquish_ownership();
+    /* Incrementing this value invalidates the contextvars cache,
+       which would otherwise remain valid across switches */
+    tstate->context_ver++;
+#endif
+#if GREENLET_USE_CFRAME
+    tstate->cframe = this->cframe;
+    /*
+      If we were tracing, we need to keep tracing.
+      There should never be the possibility of hitting the
+      root_cframe here. See note above about why we can't
+      just copy this from ``origin->cframe->use_tracing``.
+    */
+    tstate->cframe->use_tracing = this->use_tracing;
+#endif
+#if GREENLET_PY311
+    tstate->recursion_remaining = tstate->recursion_limit - this->recursion_depth;
+    tstate->cframe->current_frame = this->current_frame;
+    tstate->datastack_chunk = this->datastack_chunk;
+    tstate->datastack_top = this->datastack_top;
+    tstate->datastack_limit = this->datastack_limit;
+    this->_top_frame.relinquish_ownership();
+#else
+    tstate->frame = this->_top_frame.relinquish_ownership();
+    tstate->recursion_depth = this->recursion_depth;
+#endif
+    // All versions of Python.
+    tstate->trash_delete_nesting = this->trash_delete_nesting;
+}
+
+void PythonState::will_switch_from(PyThreadState *const origin_tstate) G_NOEXCEPT
+{
+#if GREENLET_USE_CFRAME
+    // The weird thing is, we don't actually save this for an
+    // effect on the current greenlet, it's saved for an
+    // effect on the target greenlet. That is, we want
+    // continuity of this setting across the greenlet switch.
+    this->use_tracing = origin_tstate->cframe->use_tracing;
+#endif
+}
+
+void PythonState::set_initial_state(const PyThreadState* const tstate) G_NOEXCEPT
+{
+    this->_top_frame = nullptr;
+#if GREENLET_PY311
+    this->recursion_depth = tstate->recursion_limit - tstate->recursion_remaining;
+#else
+    this->recursion_depth = tstate->recursion_depth;
+#endif
+}
+// TODO: Better state management about when we own the top frame.
+int PythonState::tp_traverse(visitproc visit, void* arg, bool own_top_frame) G_NOEXCEPT
+{
+#if GREENLET_PY37
+    Py_VISIT(this->_context.borrow());
+#endif
+    if (own_top_frame) {
+        Py_VISIT(this->_top_frame.borrow());
+    }
+    return 0;
+}
+
+void PythonState::tp_clear(bool own_top_frame) G_NOEXCEPT
+{
+    PythonStateContext::tp_clear();
+    // If we get here owning a frame,
+    // we got dealloc'd without being finished. We may or may not be
+    // in the same thread.
+    if (own_top_frame) {
+        this->_top_frame.CLEAR();
+    }
+}
+
+#if GREENLET_USE_CFRAME
+void PythonState::set_new_cframe(_PyCFrame& frame) G_NOEXCEPT
+{
+    frame = *PyThreadState_GET()->cframe;
+    /* Make the target greenlet refer to the stack value. */
+    this->cframe = &frame;
+    /*
+      And restore the link to the previous frame so this one gets
+      unliked appropriately.
+    */
+    this->cframe->previous = &PyThreadState_GET()->root_cframe;
+}
+#endif
+
+const PythonState::OwnedFrame& PythonState::top_frame() const G_NOEXCEPT
+{
+    return this->_top_frame;
+}
+
+void PythonState::did_finish(PyThreadState* tstate) G_NOEXCEPT
+{
+#if GREENLET_PY311
+    // See https://github.com/gevent/gevent/issues/1924 and
+    // https://github.com/python-greenlet/greenlet/issues/328. In
+    // short, Python 3.11 allocates memory for frames as a sort of
+    // linked list that's kept as part of PyThreadState in the
+    // ``datastack_chunk`` member and friends. These are saved and
+    // restored as part of switching greenlets.
+    //
+    // When we initially switch to a greenlet, we set those to NULL.
+    // That causes the frame management code to treat this like a
+    // brand new thread and start a fresh list of chunks, beginning
+    // with a new "root" chunk. As we make calls in this greenlet,
+    // those chunks get added, and as calls return, they get popped.
+    // But the frame code (pystate.c) is careful to make sure that the
+    // root chunk never gets popped.
+    //
+    // Thus, when a greenlet exits for the last time, there will be at
+    // least a single root chunk that we must be responsible for
+    // deallocating.
+    //
+    // The complex part is that these chunks are allocated and freed
+    // using ``_PyObject_VirtualAlloc``/``Free``. Those aren't public
+    // functions, and they aren't exported for linking. It so happens
+    // that we know they are just thin wrappers around the Arena
+    // allocator, so we can use that directly to deallocate in a
+    // compatible way.
+    //
+    // CAUTION: Check this implementation detail on every major version.
+    //
+    // It might be nice to be able to do this in our destructor, but
+    // can we be sure that no one else is using that memory? Plus, as
+    // described below, our pointers may not even be valid anymore. As
+    // a special case, there is one time that we know we can do this,
+    // and that's from the destructor of the associated UserGreenlet
+    // (NOT main greenlet)
+    PyObjectArenaAllocator alloc;
+    _PyStackChunk* chunk = nullptr;
+    if (tstate) {
+        // We really did finish, we can never be switched to again.
+        chunk = tstate->datastack_chunk;
+        // Unfortunately, we can't do much sanity checking. Our
+        // this->datastack_chunk pointer is out of date (evaluation may
+        // have popped down through it already) so we can't verify that
+        // we deallocate it. I don't think we can even check datastack_top
+        // for the same reason.
+
+        PyObject_GetArenaAllocator(&alloc);
+        tstate->datastack_chunk = nullptr;
+        tstate->datastack_limit = nullptr;
+        tstate->datastack_top = nullptr;
+
+    }
+    else if (this->datastack_chunk) {
+        // The UserGreenlet (NOT the main greenlet!) is being deallocated. If we're
+        // still holding a stack chunk, it's garbage because we know
+        // we can never switch back to let cPython clean it up.
+        // Because the last time we got switched away from, and we
+        // haven't run since then, we know our chain is valid and can
+        // be dealloced.
+        chunk = this->datastack_chunk;
+        PyObject_GetArenaAllocator(&alloc);
+    }
+
+    if (alloc.free && chunk) {
+        // In case the arena mechanism has been torn down already.
+        while (chunk) {
+            _PyStackChunk *prev = chunk->previous;
+            chunk->previous = nullptr;
+            alloc.free(alloc.ctx, chunk, chunk->size);
+            chunk = prev;
+        }
+    }
+
+    this->datastack_chunk = nullptr;
+    this->datastack_limit = nullptr;
+    this->datastack_top = nullptr;
+#endif
+}
+
+
+
+
+using greenlet::StackState;
+
+#ifdef GREENLET_USE_STDIO
+#include <iostream>
+using std::cerr;
+using std::endl;
+
+std::ostream& greenlet::operator<<(std::ostream& os, const StackState& s)
+{
+    os << "StackState(stack_start=" << (void*)s._stack_start
+       << ", stack_stop=" << (void*)s.stack_stop
+       << ", stack_copy=" << (void*)s.stack_copy
+       << ", stack_saved=" << s._stack_saved
+       << ", stack_prev=" << s.stack_prev
+       << ", addr=" << &s
+       << ")";
+    return os;
+}
+#endif
+
+StackState::StackState(void* mark, StackState& current)
+    : _stack_start(nullptr),
+      stack_stop((char*)mark),
+      stack_copy(nullptr),
+      _stack_saved(0),
+      /* Skip a dying greenlet */
+      stack_prev(current._stack_start
+                 ? &current
+                 : current.stack_prev)
+{
+}
+
+StackState::StackState()
+    : _stack_start(nullptr),
+      stack_stop(nullptr),
+      stack_copy(nullptr),
+      _stack_saved(0),
+      stack_prev(nullptr)
+{
+}
+
+StackState::StackState(const StackState& other)
+// can't use a delegating constructor because of
+// MSVC for Python 2.7
+    : _stack_start(nullptr),
+      stack_stop(nullptr),
+      stack_copy(nullptr),
+      _stack_saved(0),
+      stack_prev(nullptr)
+{
+    this->operator=(other);
+}
+
+StackState& StackState::operator=(const StackState& other)
+{
+    if (&other == this) {
+        return *this;
+    }
+    if (other._stack_saved) {
+        throw std::runtime_error("Refusing to steal memory.");
+    }
+
+    //If we have memory allocated, dispose of it
+    this->free_stack_copy();
+
+    this->_stack_start = other._stack_start;
+    this->stack_stop = other.stack_stop;
+    this->stack_copy = other.stack_copy;
+    this->_stack_saved = other._stack_saved;
+    this->stack_prev = other.stack_prev;
+    return *this;
+}
+
+inline void StackState::free_stack_copy() G_NOEXCEPT
+{
+    PyMem_Free(this->stack_copy);
+    this->stack_copy = nullptr;
+    this->_stack_saved = 0;
+}
+
+inline void StackState::copy_heap_to_stack(const StackState& current) G_NOEXCEPT
+{
+    // cerr << "copy_heap_to_stack" << endl
+    //      << "\tFrom    : " << *this << endl
+    //      << "\tCurrent:" << current
+    //      << endl;
+    /* Restore the heap copy back into the C stack */
+    if (this->_stack_saved != 0) {
+        memcpy(this->_stack_start, this->stack_copy, this->_stack_saved);
+        this->free_stack_copy();
+    }
+    StackState* owner = const_cast<StackState*>(&current);
+    if (!owner->_stack_start) {
+        owner = owner->stack_prev; /* greenlet is dying, skip it */
+    }
+    while (owner && owner->stack_stop <= this->stack_stop) {
+        // cerr << "\tOwner: " << owner << endl;
+        owner = owner->stack_prev; /* find greenlet with more stack */
+    }
+    this->stack_prev = owner;
+    // cerr << "\tFinished with: " << *this << endl;
+}
+
+inline int StackState::copy_stack_to_heap_up_to(const char* const stop) G_NOEXCEPT
+{
+    /* Save more of g's stack into the heap -- at least up to 'stop'
+       g->stack_stop |________|
+                     |        |
+                     |    __ stop       . . . . .
+                     |        |    ==>  .       .
+                     |________|          _______
+                     |        |         |       |
+                     |        |         |       |
+      g->stack_start |        |         |_______| g->stack_copy
+     */
+    intptr_t sz1 = this->_stack_saved;
+    intptr_t sz2 = stop - this->_stack_start;
+    assert(this->_stack_start);
+    if (sz2 > sz1) {
+        char* c = (char*)PyMem_Realloc(this->stack_copy, sz2);
+        if (!c) {
+            PyErr_NoMemory();
+            return -1;
+        }
+        memcpy(c + sz1, this->_stack_start + sz1, sz2 - sz1);
+        this->stack_copy = c;
+        this->_stack_saved = sz2;
+    }
+    return 0;
+}
+
+inline int StackState::copy_stack_to_heap(char* const stackref,
+                                          const StackState& current) G_NOEXCEPT
+{
+    // cerr << "copy_stack_to_heap: " << endl
+    //      << "\tstackref: " << (void*)stackref << endl
+    //      << "\tthis: " << *this << endl
+    //      << "\tcurrent: " << current
+    //      << endl;
+    /* must free all the C stack up to target_stop */
+    const char* const target_stop = this->stack_stop;
+
+    StackState* owner = const_cast<StackState*>(&current);
+    assert(owner->_stack_saved == 0); // everything is present on the stack
+    if (!owner->_stack_start) {
+        // cerr << "\tcurrent is dead; using: " << owner->stack_prev << endl;
+        owner = owner->stack_prev; /* not saved if dying */
+    }
+    else {
+        owner->_stack_start = stackref;
+    }
+
+    while (owner->stack_stop < target_stop) {
+        // cerr << "\tCopying from " << *owner << endl;
+        /* ts_current is entierely within the area to free */
+        if (owner->copy_stack_to_heap_up_to(owner->stack_stop)) {
+            return -1; /* XXX */
+        }
+        owner = owner->stack_prev;
+    }
+    if (owner != this) {
+        if (owner->copy_stack_to_heap_up_to(target_stop)) {
+            return -1; /* XXX */
+        }
+    }
+    return 0;
+}
+
+inline bool StackState::started() const G_NOEXCEPT
+{
+    return this->stack_stop != nullptr;
+}
+
+inline bool StackState::main() const G_NOEXCEPT
+{
+    return this->stack_stop == (char*)-1;
+}
+
+inline bool StackState::active() const G_NOEXCEPT
+{
+    return this->_stack_start != nullptr;
+}
+
+inline void StackState::set_active() G_NOEXCEPT
+{
+    assert(this->_stack_start == nullptr);
+    this->_stack_start = (char*)1;
+}
+
+inline void StackState::set_inactive() G_NOEXCEPT
+{
+    this->_stack_start = nullptr;
+    // XXX: What if we still have memory out there?
+    // That case is actually triggered by
+    // test_issue251_issue252_explicit_reference_not_collectable (greenlet.tests.test_leaks.TestLeaks)
+    // and
+    // test_issue251_issue252_need_to_collect_in_background
+    // (greenlet.tests.test_leaks.TestLeaks)
+    //
+    // Those objects never get deallocated, so the destructor never
+    // runs.
+    // It *seems* safe to clean up the memory here?
+    if (this->_stack_saved) {
+        this->free_stack_copy();
+    }
+}
+
+inline intptr_t StackState::stack_saved() const G_NOEXCEPT
+{
+    return this->_stack_saved;
+}
+
+inline char* StackState::stack_start() const G_NOEXCEPT
+{
+    return this->_stack_start;
+}
+
+
+inline StackState StackState::make_main() G_NOEXCEPT
+{
+    StackState s;
+    s._stack_start = (char*)1;
+    s.stack_stop = (char*)-1;
+    return s;
+}
+
+StackState::~StackState()
+{
+    if (this->_stack_saved != 0) {
+        this->free_stack_copy();
+    }
+}
+
+using greenlet::Greenlet;
+
+bool Greenlet::is_currently_running_in_some_thread() const
+{
+    return this->stack_state.active() && !this->python_state.top_frame();
+}
+
+
+
+#endif

_service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/greenlet_internal.hpp Added

@@ -0,0 +1,106 @@
+/* -*- indent-tabs-mode: nil; tab-width: 4; -*- */
+#ifndef GREENLET_INTERNAL_H
+#define GREENLET_INTERNAL_H
+#ifdef __clang__
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wunused-function"
+#    pragma clang diagnostic ignored "-Wmissing-field-initializers"
+#    pragma clang diagnostic ignored "-Wunused-variable"
+#endif
+
+/**
+ * Implementation helpers.
+ *
+ * C++ templates and inline functions should go here.
+ */
+#define PY_SSIZE_T_CLEAN
+#include "greenlet_compiler_compat.hpp"
+#include "greenlet_cpython_compat.hpp"
+#include "greenlet_exceptions.hpp"
+#include "greenlet_greenlet.hpp"
+#include "greenlet_allocator.hpp"
+
+#include <vector>
+#include <string>
+
+#define GREENLET_MODULE
+struct _greenlet;
+typedef struct _greenlet PyGreenlet;
+namespace greenlet {
+
+    class ThreadState;
+
+};
+
+
+#define implementation_ptr_t greenlet::Greenlet*
+
+
+#include "greenlet.h"
+
+G_FP_TMPL_STATIC inline void
+greenlet::refs::MainGreenletExactChecker(void *p)
+{
+    if (!p) {
+        return;
+    }
+    // We control the class of the main greenlet exactly.
+    if (Py_TYPE(p) != &PyGreenlet_Type) {
+        std::string err("MainGreenlet: Expected exactly a greenlet, not a ");
+        err += Py_TYPE(p)->tp_name;
+        throw greenlet::TypeError(err);
+    }
+
+    // Greenlets from dead threads no longer respond to main() with a
+    // true value; so in that case we need to perform an additional
+    // check.
+    Greenlet* g = ((PyGreenlet*)p)->pimpl;
+    if (g->main()) {
+        return;
+    }
+    if (!dynamic_cast<MainGreenlet*>(g)) {
+        std::string err("MainGreenlet: Expected exactly a main greenlet, not a ");
+        err += Py_TYPE(p)->tp_name;
+        throw greenlet::TypeError(err);
+    }
+}
+
+
+
+template <typename T, greenlet::refs::TypeChecker TC>
+inline greenlet::Greenlet* greenlet::refs::_OwnedGreenlet<T, TC>::operator->() const G_NOEXCEPT
+{
+    return reinterpret_cast<PyGreenlet*>(this->p)->pimpl;
+}
+
+template <typename T, greenlet::refs::TypeChecker TC>
+inline greenlet::Greenlet* greenlet::refs::_BorrowedGreenlet<T, TC>::operator->() const G_NOEXCEPT
+{
+    return reinterpret_cast<PyGreenlet*>(this->p)->pimpl;
+}
+
+#include <memory>
+#include <stdexcept>
+
+
+extern PyTypeObject PyGreenlet_Type;
+
+
+
+/**
+  * Forward declarations needed in multiple files.
+  */
+static PyGreenlet* green_create_main(greenlet::ThreadState*);
+static PyObject* green_switch(PyGreenlet* self, PyObject* args, PyObject* kwargs);
+static int green_is_gc(BorrowedGreenlet self);
+
+#ifdef __clang__
+#    pragma clang diagnostic pop
+#endif
+
+
+#endif
+
+// Local Variables:
+// flycheck-clang-include-path: ("../../include" "/opt/local/Library/Frameworks/Python.framework/Versions/3.10/include/python3.10")
+// End:

_service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/greenlet_refs.hpp Added

@@ -0,0 +1,1062 @@
+#ifndef GREENLET_REFS_HPP
+#define GREENLET_REFS_HPP
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+//#include "greenlet_internal.hpp"
+#include "greenlet_compiler_compat.hpp"
+#include "greenlet_cpython_compat.hpp"
+#include "greenlet_exceptions.hpp"
+
+struct _greenlet;
+struct _PyMainGreenlet;
+
+typedef struct _greenlet PyGreenlet;
+extern PyTypeObject PyGreenlet_Type;
+
+
+#ifdef  GREENLET_USE_STDIO
+#include <iostream>
+using std::cerr;
+using std::endl;
+#endif
+
+namespace greenlet
+{
+    class Greenlet;
+
+    namespace refs
+    {
+        // Type checkers throw a TypeError if the argument is not
+        // null, and isn't of the required Python type.
+        // (We can't use most of the defined type checkers
+        // like PyList_Check, etc, directly, because they are
+        // implemented as macros.)
+        typedef void (*TypeChecker)(void*);
+
+        G_FP_TMPL_STATIC inline void
+        NoOpChecker(void*)
+        {
+            return;
+        }
+
+        G_FP_TMPL_STATIC inline void
+        GreenletChecker(void *p)
+        {
+            if (!p) {
+                return;
+            }
+
+            PyTypeObject* typ = Py_TYPE(p);
+            // fast, common path. (PyObject_TypeCheck is a macro or
+            // static inline function, and it also does a
+            // direct comparison of the type pointers, but its fast
+            // path only handles one type)
+            if (typ == &PyGreenlet_Type) {
+                return;
+            }
+
+            if (!PyObject_TypeCheck(p, &PyGreenlet_Type)) {
+                std::string err("GreenletChecker: Expected any type of greenlet, not ");
+                err += Py_TYPE(p)->tp_name;
+                throw TypeError(err);
+            }
+        }
+
+        G_FP_TMPL_STATIC inline void
+        MainGreenletExactChecker(void *p);
+
+        template <typename T, TypeChecker>
+        class PyObjectPointer;
+
+        template<typename T, TypeChecker>
+        class OwnedReference;
+
+
+        template<typename T, TypeChecker>
+        class BorrowedReference;
+
+        typedef BorrowedReference<PyObject, NoOpChecker> BorrowedObject;
+        typedef OwnedReference<PyObject, NoOpChecker> OwnedObject;
+
+        class ImmortalObject;
+
+        template<typename T, TypeChecker TC>
+        class _OwnedGreenlet;
+
+        typedef _OwnedGreenlet<PyGreenlet, GreenletChecker> OwnedGreenlet;
+        typedef _OwnedGreenlet<PyGreenlet, MainGreenletExactChecker> OwnedMainGreenlet;
+
+        template<typename T, TypeChecker TC>
+        class _BorrowedGreenlet;
+
+        typedef _BorrowedGreenlet<PyGreenlet, GreenletChecker> BorrowedGreenlet;
+
+        G_FP_TMPL_STATIC inline void
+        ContextExactChecker(void *p)
+        {
+            if (!p) {
+                return;
+            }
+#if GREENLET_PY37
+            if (!PyContext_CheckExact(p)) {
+                throw TypeError(
+                    "greenlet context must be a contextvars.Context or None"
+                );
+            }
+#endif
+        }
+
+        typedef OwnedReference<PyObject, ContextExactChecker> OwnedContext;
+    }
+}
+
+namespace greenlet {
+
+
+    namespace refs {
+    // A set of classes to make reference counting rules in python
+    // code explicit.
+    //
+    // Rules of use:
+    // (1) Functions returning a new reference that the caller of the
+    // function is expected to dispose of should return a
+    // ``OwnedObject`` object. This object automatically releases its
+    // reference when it goes out of scope. It works like a ``std::shared_ptr``
+    // and can be copied or used as a function parameter (but don't do
+    // that). Note that constructing a ``OwnedObject`` from a
+    // PyObject* steals the reference.
+    // (2) Parameters to functions should be either a
+    // ``OwnedObject&``, or, more generally, a ``PyObjectPointer&``.
+    // If the function needs to create its own new reference, it can
+    // do so by copying to a local ``OwnedObject``.
+    // (3) Functions returning an existing pointer that is NOT
+    // incref'd, and which the caller MUST NOT decref,
+    // should return a ``BorrowedObject``.
+
+    //
+    // For a class with a single pointer member, whose constructor
+    // does nothing but copy a pointer parameter into the member, and
+    // which can then be converted back to the pointer type, compilers
+    // generate code that's the same as just passing the pointer.
+    // That is, func(BorrowedObject x) called like ``PyObject* p =
+    // ...; f(p)`` has 0 overhead. Similarly, they "unpack" to the
+    // pointer type with 0 overhead.
+    //
+    // If there are no virtual functions, no complex inheritance (maybe?) and
+    // no destructor, these can be directly used as parameters in
+    // Python callbacks like tp_init: the layout is the same as a
+    // single pointer. Only subclasses with trivial constructors that
+    // do nothing but set the single pointer member are safe to use
+    // that way.
+
+
+    // This is the base class for things that can be done with a
+    // PyObject pointer. It assumes nothing about memory management.
+    // NOTE: Nothing is virtual, so subclasses shouldn't add new
+    // storage fields or try to override these methods.
+    template <typename T=PyObject, TypeChecker TC=NoOpChecker>
+    class PyObjectPointer
+    {
+    public:
+        typedef T PyType;
+    protected:
+        T* p;
+    public:
+        explicit PyObjectPointer(T* it=nullptr) : p(it)
+        {
+            TC(p);
+        }
+
+        // We don't allow automatic casting to PyObject* at this
+        // level, because then we could be passed to Py_DECREF/INCREF,
+        // but we want nothing to do with memory management. If you
+        // know better, then you can use the get() method, like on a
+        // std::shared_ptr. Except we name it borrow() to clarify that
+        // if this is a reference-tracked object, the pointer you get
+        // back will go away when the object does.
+        // TODO: This should probably not exist here, but be moved
+        // down to relevant sub-types.
+
+        inline T* borrow() const G_NOEXCEPT
+        {
+            return this->p;
+        }
+
+        PyObject* borrow_o() const G_NOEXCEPT
+        {
+            return reinterpret_cast<PyObject*>(this->p);
+        }
+
+        inline T* operator->() const G_NOEXCEPT
+        {
+            return this->p;
+        }
+
+        bool is_None() const G_NOEXCEPT
+        {
+            return this->p == Py_None;
+        }
+
+        inline PyObject* acquire_or_None() const G_NOEXCEPT
+        {
+            PyObject* result = this->p ? reinterpret_cast<PyObject*>(this->p) : Py_None;
+            Py_INCREF(result);
+            return result;
+        }
+
+        G_EXPLICIT_OP operator bool() const G_NOEXCEPT
+        {
+            return p != nullptr;
+        }
+
+        inline Py_ssize_t REFCNT() const G_NOEXCEPT
+        {
+            return p ? Py_REFCNT(p) : -42;
+        }
+
+        inline PyTypeObject* TYPE() const G_NOEXCEPT
+        {
+            return p ? Py_TYPE(p) : nullptr;
+        }
+
+        inline OwnedObject PyStr() const G_NOEXCEPT;
+        inline const std::string as_str() const G_NOEXCEPT;
+        inline OwnedObject PyGetAttr(const ImmortalObject& name) const G_NOEXCEPT;
+        inline OwnedObject PyRequireAttr(const char* const name) const;
+        inline OwnedObject PyRequireAttr(const ImmortalObject& name) const;
+        inline OwnedObject PyCall(const BorrowedObject& arg) const;
+        inline OwnedObject PyCall(PyGreenlet* arg) const ;
+        inline OwnedObject PyCall(PyObject* arg) const ;
+        // PyObject_Call(this, args, kwargs);
+        inline OwnedObject PyCall(const BorrowedObject args,
+                                  const BorrowedObject kwargs) const;
+        inline OwnedObject PyCall(const OwnedObject& args,
+                                  const OwnedObject& kwargs) const;
+
+    protected:
+        void _set_raw_pointer(void* t)
+        {
+            TC(t);
+            p = reinterpret_cast<T*>(t);
+        }
+        void* _get_raw_pointer() const
+        {
+            return p;
+        }
+    };
+
+#ifdef GREENLET_USE_STDIO
+        template<typename T, TypeChecker TC>
+        std::ostream& operator<<(std::ostream& os, const PyObjectPointer<T, TC>& s)
+        {
+            const std::type_info& t = typeid(s);
+            os << t.name()
+               << "(addr=" << s.borrow()
+               << ", refcnt=" << s.REFCNT()
+               << ", value=" << s.as_str()
+               << ")";
+
+            return os;
+        }
+#endif
+
+    template<typename T, TypeChecker TC>
+    inline bool operator==(const PyObjectPointer<T, TC>& lhs, const void* const rhs) G_NOEXCEPT
+    {
+        return lhs.borrow_o() == rhs;
+    }
+
+    template<typename T, TypeChecker TC, typename X, TypeChecker XC>
+    inline bool operator==(const PyObjectPointer<T, TC>& lhs, const PyObjectPointer<X, XC>& rhs) G_NOEXCEPT
+    {
+        return lhs.borrow_o() == rhs.borrow_o();
+    }
+
+    template<typename T, TypeChecker TC, typename X, TypeChecker XC>
+    inline bool operator!=(const PyObjectPointer<T, TC>& lhs,
+                           const PyObjectPointer<X, XC>& rhs) G_NOEXCEPT
+    {
+        return lhs.borrow_o() != rhs.borrow_o();
+    }
+
+    template<typename T=PyObject, TypeChecker TC=NoOpChecker>
+    class OwnedReference : public PyObjectPointer<T, TC>
+    {
+    private:
+        friend class OwnedList;
+
+    protected:
+        explicit OwnedReference(T* it) : PyObjectPointer<T, TC>(it)
+        {
+        }
+
+    public:
+
+        // Constructors
+
+        static OwnedReference<T, TC> consuming(PyObject* p)
+        {
+            return OwnedReference<T, TC>(reinterpret_cast<T*>(p));
+        }
+
+        static OwnedReference<T, TC> owning(T* p)
+        {
+            OwnedReference<T, TC> result(p);
+            Py_XINCREF(result.p);
+            return result;
+        }
+
+        OwnedReference() : PyObjectPointer<T, TC>(nullptr)
+        {}
+
+        explicit OwnedReference(const PyObjectPointer<>& other)
+            : PyObjectPointer<T, TC>(nullptr)
+        {
+            T* op = other.borrow();
+            TC(op);
+            this->p = other.borrow();
+            Py_XINCREF(this->p);
+        }
+
+        // It would be good to make use of the C++11 distinction
+        // between move and copy operations, e.g., constructing from a
+        // pointer should be a move operation.
+        // In the common case of ``OwnedObject x = Py_SomeFunction()``,
+        // the call to the copy constructor will be elided completely.
+        OwnedReference(const OwnedReference<T, TC>& other)
+            : PyObjectPointer<T, TC>(other.p)
+        {
+            Py_XINCREF(this->p);
+        }
+
+        static OwnedReference<PyObject> None()
+        {
+            Py_INCREF(Py_None);
+            return OwnedReference<PyObject>(Py_None);
+        }
+
+        // We can assign from exactly our type without any extra checking
+        OwnedReference<T, TC>& operator=(const OwnedReference<T, TC>& other)
+        {
+            Py_XINCREF(other.p);
+            const T* tmp = this->p;
+            this->p = other.p;
+            Py_XDECREF(tmp);
+            return *this;
+        }
+
+        OwnedReference<T, TC>& operator=(const BorrowedReference<T, TC> other)
+        {
+            return this->operator=(other.borrow());
+        }
+
+        OwnedReference<T, TC>& operator=(T* const other)
+        {
+            TC(other);
+            Py_XINCREF(other);
+            T* tmp = this->p;
+            this->p = other;
+            Py_XDECREF(tmp);
+            return *this;
+        }
+
+        // We can assign from an arbitrary reference type
+        // if it passes our check.
+        template<typename X, TypeChecker XC>
+        OwnedReference<T, TC>& operator=(const OwnedReference<X, XC>& other)
+        {
+            X* op = other.borrow();
+            TC(op);
+            return this->operator=(reinterpret_cast<T*>(op));
+        }
+
+        inline void steal(T* other)
+        {
+            assert(this->p == nullptr);
+            TC(other);
+            this->p = other;
+        }
+
+        T* relinquish_ownership()
+        {
+            T* result = this->p;
+            this->p = nullptr;
+            return result;
+        }
+
+        T* acquire() const
+        {
+            // Return a new reference.
+            // TODO: This may go away when we have reference objects
+            // throughout the code.
+            Py_XINCREF(this->p);
+            return this->p;
+        }
+
+        // Nothing else declares a destructor, we're the leaf, so we
+        // should be able to get away without virtual.
+        ~OwnedReference()
+        {
+            Py_CLEAR(this->p);
+        }
+
+        void CLEAR()
+        {
+            Py_CLEAR(this->p);
+            assert(this->p == nullptr);
+        }
+    };
+
+    static inline
+    void operator<<=(PyObject*& target, OwnedObject& o)
+    {
+        target = o.relinquish_ownership();
+    }
+
+    class NewReference : public OwnedObject
+    {
+    private:
+        G_NO_COPIES_OF_CLS(NewReference);
+    public:
+        // Consumes the reference. Only use this
+        // for API return values.
+        NewReference(PyObject* it) : OwnedObject(it)
+        {
+        }
+    };
+
+    class NewDictReference : public NewReference
+    {
+    private:
+        G_NO_COPIES_OF_CLS(NewDictReference);
+    public:
+        NewDictReference() : NewReference(PyDict_New())
+        {
+            if (!this->p) {
+                throw PyErrOccurred();
+            }
+        }
+
+        void SetItem(const char* const key, PyObject* value)
+        {
+            Require(PyDict_SetItemString(this->p, key, value));
+        }
+
+        void SetItem(const PyObjectPointer<>& key, PyObject* value)
+        {
+            Require(PyDict_SetItem(this->p, key.borrow_o(), value));
+        }
+    };
+
+    template<typename T=PyGreenlet, TypeChecker TC=GreenletChecker>
+    class _OwnedGreenlet: public OwnedReference<T, TC>
+    {
+    private:
+    protected:
+        _OwnedGreenlet(T* it) : OwnedReference<T, TC>(it)
+        {}
+
+    public:
+        _OwnedGreenlet() : OwnedReference<T, TC>()
+        {}
+
+        _OwnedGreenlet(const _OwnedGreenlet<T, TC>& other) : OwnedReference<T, TC>(other)
+        {
+        }
+        _OwnedGreenlet(OwnedMainGreenlet& other) :
+            OwnedReference<T, TC>(reinterpret_cast<T*>(other.acquire()))
+        {
+        }
+        _OwnedGreenlet(const BorrowedGreenlet& other);
+        // Steals a reference.
+        static _OwnedGreenlet<T, TC> consuming(PyGreenlet* it)
+        {
+            return _OwnedGreenlet<T, TC>(reinterpret_cast<T*>(it));
+        }
+
+        inline _OwnedGreenlet<T, TC>& operator=(const OwnedGreenlet& other)
+        {
+            return this->operator=(other.borrow());
+        }
+
+        inline _OwnedGreenlet<T, TC>& operator=(const BorrowedGreenlet& other);
+
+        _OwnedGreenlet<T, TC>& operator=(const OwnedMainGreenlet& other)
+        {
+            PyGreenlet* owned = other.acquire();
+            Py_XDECREF(this->p);
+            this->p = reinterpret_cast<T*>(owned);
+            return *this;
+        }
+
+        _OwnedGreenlet<T, TC>& operator=(T* const other)
+        {
+            OwnedReference<T, TC>::operator=(other);
+            return *this;
+        }
+
+        T* relinquish_ownership()
+        {
+            T* result = this->p;
+            this->p = nullptr;
+            return result;
+        }
+
+        PyObject* relinquish_ownership_o()
+        {
+            return reinterpret_cast<PyObject*>(relinquish_ownership());
+        }
+
+        inline Greenlet* operator->() const G_NOEXCEPT;
+        inline operator Greenlet*() const G_NOEXCEPT;
+    };
+
+    template <typename T=PyObject, TypeChecker TC=NoOpChecker>
+    class BorrowedReference : public PyObjectPointer<T, TC>
+    {
+    public:
+        // Allow implicit creation from PyObject* pointers as we
+        // transition to using these classes. Also allow automatic
+        // conversion to PyObject* for passing to C API calls and even
+        // for Py_INCREF/DECREF, because we ourselves do no memory management.
+        BorrowedReference(T* it) : PyObjectPointer<T, TC>(it)
+        {}
+
+        BorrowedReference(const PyObjectPointer<T>& ref) : PyObjectPointer<T, TC>(ref.borrow())
+        {}
+
+        BorrowedReference() : PyObjectPointer<T, TC>(nullptr)
+        {}
+
+        operator T*() const
+        {
+            return this->p;
+        }
+    };
+
+    typedef BorrowedReference<PyObject> BorrowedObject;
+    //typedef BorrowedReference<PyGreenlet> BorrowedGreenlet;
+
+    template<typename T=PyGreenlet, TypeChecker TC=GreenletChecker>
+    class _BorrowedGreenlet : public BorrowedReference<T, TC>
+    {
+    public:
+        _BorrowedGreenlet() :
+            BorrowedReference<T, TC>(nullptr)
+        {}
+
+        _BorrowedGreenlet(T* it) :
+            BorrowedReference<T, TC>(it)
+        {}
+
+        _BorrowedGreenlet(const BorrowedObject& it);
+
+        _BorrowedGreenlet(const OwnedGreenlet& it) :
+            BorrowedReference<T, TC>(it.borrow())
+        {}
+
+        _BorrowedGreenlet<T, TC>& operator=(const BorrowedObject& other);
+
+        // We get one of these for PyGreenlet, but one for PyObject
+        // is handy as well
+        operator PyObject*() const
+        {
+            return reinterpret_cast<PyObject*>(this->p);
+        }
+        inline Greenlet* operator->() const G_NOEXCEPT;
+        inline operator Greenlet*() const G_NOEXCEPT;
+    };
+
+    typedef _BorrowedGreenlet<PyGreenlet> BorrowedGreenlet;
+
+    template<typename T, TypeChecker TC>
+    _OwnedGreenlet<T, TC>::_OwnedGreenlet(const BorrowedGreenlet& other)
+        : OwnedReference<T, TC>(reinterpret_cast<T*>(other.borrow()))
+    {
+        Py_XINCREF(this->p);
+    }
+
+
+     class BorrowedMainGreenlet
+            : public _BorrowedGreenlet<PyGreenlet, MainGreenletExactChecker>
+    {
+    public:
+        BorrowedMainGreenlet(const OwnedMainGreenlet& it) :
+            _BorrowedGreenlet<PyGreenlet, MainGreenletExactChecker>(it.borrow())
+        {}
+        BorrowedMainGreenlet(PyGreenlet* it=nullptr)
+            : _BorrowedGreenlet<PyGreenlet, MainGreenletExactChecker>(it)
+        {}
+    };
+
+    template<typename T, TypeChecker TC>
+    _OwnedGreenlet<T, TC>& _OwnedGreenlet<T, TC>::operator=(const BorrowedGreenlet& other)
+    {
+        return this->operator=(other.borrow());
+    }
+
+
+    class ImmortalObject : public PyObjectPointer<>
+    {
+    private:
+        G_NO_ASSIGNMENT_OF_CLS(ImmortalObject);
+    public:
+        explicit ImmortalObject(PyObject* it) : PyObjectPointer<>(it)
+        {
+        }
+
+        /**
+         * Become the new owner of the object. Does not change the
+         * reference count.
+         */
+        ImmortalObject& operator=(PyObject* it)
+        {
+            assert(this->p == nullptr);
+            this->p = it;
+            return *this;
+        }
+
+        static ImmortalObject consuming(PyObject* it)
+        {
+            return ImmortalObject(it);
+        }
+
+        inline operator PyObject*() const
+        {
+            return this->p;
+        }
+    };
+
+    class ImmortalString : public ImmortalObject
+    {
+    private:
+        G_NO_COPIES_OF_CLS(ImmortalString);
+        const char* str;
+    public:
+        ImmortalString(const char* const str) :
+            ImmortalObject(str ? Require(Greenlet_Intern(str)) : nullptr)
+        {
+            this->str = str;
+        }
+
+        inline ImmortalString& operator=(const char* const str)
+        {
+            if (!this->p) {
+                this->p = Require(Greenlet_Intern(str));
+                this->str = str;
+            }
+            else {
+                assert(this->str == str);
+            }
+            return *this;
+        }
+
+    };
+
+    template<typename T, TypeChecker TC>
+    inline OwnedObject PyObjectPointer<T, TC>::PyStr() const G_NOEXCEPT
+    {
+        if (!this->p) {
+            return OwnedObject();
+        }
+        return OwnedObject::consuming(PyObject_Str(reinterpret_cast<PyObject*>(this->p)));
+    }
+
+    template<typename T, TypeChecker TC>
+    inline const std::string PyObjectPointer<T, TC>::as_str() const G_NOEXCEPT
+    {
+        // NOTE: This is not Python exception safe.
+        if (this->p) {
+            // The Python APIs return a cached char* value that's only valid
+            // as long as the original object stays around, and we're
+            // about to (probably) toss it. Hence the copy to std::string.
+            OwnedObject py_str = this->PyStr();
+            if (!py_str) {
+                return "(nil)";
+            }
+#if PY_MAJOR_VERSION >= 3
+            return PyUnicode_AsUTF8(py_str.borrow());
+#else
+            return PyString_AsString(py_str.borrow());
+#endif
+        }
+        return "(nil)";
+    }
+
+    template<typename T, TypeChecker TC>
+    inline OwnedObject PyObjectPointer<T, TC>::PyGetAttr(const ImmortalObject& name) const G_NOEXCEPT
+    {
+        assert(this->p);
+        return OwnedObject::consuming(PyObject_GetAttr(reinterpret_cast<PyObject*>(this->p), name));
+    }
+
+    template<typename T, TypeChecker TC>
+    inline OwnedObject PyObjectPointer<T, TC>::PyRequireAttr(const char* const name) const
+    {
+        assert(this->p);
+        return OwnedObject::consuming(Require(PyObject_GetAttrString(this->p, name)));
+    }
+
+    template<typename T, TypeChecker TC>
+    inline OwnedObject PyObjectPointer<T, TC>::PyRequireAttr(const ImmortalObject& name) const
+    {
+        assert(this->p);
+        return OwnedObject::consuming(Require(
+                   PyObject_GetAttr(reinterpret_cast<PyObject*>(this->p),
+                                    name)));
+    }
+
+    template<typename T, TypeChecker TC>
+    inline OwnedObject PyObjectPointer<T, TC>::PyCall(const BorrowedObject& arg) const
+    {
+        return this->PyCall(arg.borrow());
+    }
+
+    template<typename T, TypeChecker TC>
+    inline OwnedObject PyObjectPointer<T, TC>::PyCall(PyGreenlet* arg) const
+    {
+        return this->PyCall(reinterpret_cast<PyObject*>(arg));
+    }
+
+    template<typename T, TypeChecker TC>
+    inline OwnedObject PyObjectPointer<T, TC>::PyCall(PyObject* arg) const
+    {
+        assert(this->p);
+        return OwnedObject::consuming(PyObject_CallFunctionObjArgs(this->p, arg, NULL));
+    }
+
+    template<typename T, TypeChecker TC>
+    inline OwnedObject PyObjectPointer<T, TC>::PyCall(const BorrowedObject args,
+                                                  const BorrowedObject kwargs) const
+    {
+        assert(this->p);
+        return OwnedObject::consuming(PyObject_Call(this->p, args, kwargs));
+    }
+
+    template<typename T, TypeChecker TC>
+    inline OwnedObject PyObjectPointer<T, TC>::PyCall(const OwnedObject& args,
+                                                  const OwnedObject& kwargs) const
+    {
+        assert(this->p);
+        return OwnedObject::consuming(PyObject_Call(this->p, args.borrow(), kwargs.borrow()));
+    }
+
+    G_FP_TMPL_STATIC inline void
+    ListChecker(void * p)
+    {
+        if (!p) {
+            return;
+        }
+        if (!PyList_Check(p)) {
+            throw TypeError("Expected a list");
+        }
+    }
+
+    class OwnedList : public OwnedReference<PyObject, ListChecker>
+    {
+    private:
+        G_NO_ASSIGNMENT_OF_CLS(OwnedList);
+    public:
+        // TODO: Would like to use move.
+        explicit OwnedList(const OwnedObject& other)
+            : OwnedReference<PyObject, ListChecker>(other)
+        {
+        }
+
+        OwnedList& operator=(const OwnedObject& other)
+        {
+            if (other && PyList_Check(other.p)) {
+                // Valid list. Own a new reference to it, discard the
+                // reference to what we did own.
+                PyObject* new_ptr = other.p;
+                Py_INCREF(new_ptr);
+                Py_XDECREF(this->p);
+                this->p = new_ptr;
+            }
+            else {
+                // Either the other object was NULL (an error) or it
+                // wasn't a list. Either way, we're now invalidated.
+                Py_XDECREF(this->p);
+                this->p = nullptr;
+            }
+            return *this;
+        }
+
+        inline bool empty() const
+        {
+            return PyList_GET_SIZE(p) == 0;
+        }
+
+        inline Py_ssize_t size() const
+        {
+            return PyList_GET_SIZE(p);
+        }
+
+        inline BorrowedObject at(const Py_ssize_t index) const
+        {
+            return PyList_GET_ITEM(p, index);
+        }
+
+        inline void clear()
+        {
+            PyList_SetSlice(p, 0, PyList_GET_SIZE(p), NULL);
+        }
+    };
+
+    // Use this to represent the module object used at module init
+    // time.
+    // This could either be a borrowed (Py2) or new (Py3) reference;
+    // either way, we don't want to do any memory management
+    // on it here, Python itself will handle that.
+    // XXX: Actually, that's not quite right. On Python 3, if an
+    // exception occurs before we return to the interpreter, this will
+    // leak; but all previous versions also had that problem.
+    class CreatedModule : public PyObjectPointer<>
+    {
+    private:
+        G_NO_COPIES_OF_CLS(CreatedModule);
+    public:
+        CreatedModule(PyModuleDef& mod_def) : PyObjectPointer<>(
+            Require(PyModule_Create(&mod_def)))
+        {
+        }
+
+        // PyAddObject(): Add a reference to the object to the module.
+        // On return, the reference count of the object is unchanged.
+        //
+        // The docs warn that PyModule_AddObject only steals the
+        // reference on success, so if it fails after we've incref'd
+        // or allocated, we're responsible for the decref.
+        void PyAddObject(const char* name, const long new_bool)
+        {
+            OwnedObject p = OwnedObject::consuming(Require(PyBool_FromLong(new_bool)));
+            this->PyAddObject(name, p);
+        }
+
+        void PyAddObject(const char* name, const OwnedObject& new_object)
+        {
+            // The caller already owns a reference they will decref
+            // when their variable goes out of scope, we still need to
+            // incref/decref.
+            this->PyAddObject(name, new_object.borrow());
+        }
+
+        void PyAddObject(const char* name, const ImmortalObject& new_object)
+        {
+            this->PyAddObject(name, new_object.borrow());
+        }
+
+        void PyAddObject(const char* name, PyTypeObject& type)
+        {
+            this->PyAddObject(name, reinterpret_cast<PyObject*>(&type));
+        }
+
+        void PyAddObject(const char* name, PyObject* new_object)
+        {
+            Py_INCREF(new_object);
+            try {
+                Require(PyModule_AddObject(this->p, name, new_object));
+            }
+            catch (const PyErrOccurred&) {
+                Py_DECREF(p);
+                throw;
+            }
+        }
+    };
+
+    class PyErrFetchParam : public PyObjectPointer<>
+    {
+        // Not an owned object, because we can't be initialized with
+        // one, and we only sometimes acquire ownership.
+    private:
+        G_NO_COPIES_OF_CLS(PyErrFetchParam);
+    public:
+        // To allow declaring these and passing them to
+        // PyErr_Fetch we implement the empty constructor,
+        // and the address operator.
+        PyErrFetchParam() : PyObjectPointer<>(nullptr)
+        {
+        }
+
+        PyObject** operator&()
+        {
+            return &this->p;
+        }
+
+        // This allows us to pass one directly without the &,
+        // BUT it has higher precedence than the bool operator
+        // if it's not explicit.
+        operator PyObject**()
+        {
+            return &this->p;
+        }
+
+        // We don't want to be able to pass these to Py_DECREF and
+        // such so we don't have the implicit PyObject* conversion.
+
+        inline PyObject* relinquish_ownership()
+        {
+            PyObject* result = this->p;
+            this->p = nullptr;
+            return result;
+        }
+
+        ~PyErrFetchParam()
+        {
+            Py_XDECREF(p);
+        }
+    };
+
+    class OwnedErrPiece : public OwnedObject
+    {
+    private:
+
+    public:
+        // Unlike OwnedObject, this increments the refcount.
+        OwnedErrPiece(PyObject* p=nullptr) : OwnedObject(p)
+        {
+            this->acquire();
+        }
+
+        PyObject** operator&()
+        {
+            return &this->p;
+        }
+
+        inline operator PyObject*() const
+        {
+            return this->p;
+        }
+
+        operator PyTypeObject*() const
+        {
+            return reinterpret_cast<PyTypeObject*>(this->p);
+        }
+    };
+
+    class PyErrPieces
+    {
+    private:
+        OwnedErrPiece type;
+        OwnedErrPiece instance;
+        OwnedErrPiece traceback;
+        bool restored;
+    public:
+        // Takes new references; if we're destroyed before
+        // restoring the error, we drop the references.
+        PyErrPieces(PyObject* t, PyObject* v, PyObject* tb) :
+            type(t),
+            instance(v),
+            traceback(tb),
+            restored(0)
+        {
+            this->normalize();
+        }
+
+        PyErrPieces() :
+            restored(0)
+        {
+            // PyErr_Fetch transfers ownership to us, so
+            // we don't actually need to INCREF; but we *do*
+            // need to DECREF if we're not restored.
+            PyErrFetchParam t, v, tb;
+            PyErr_Fetch(&t, &v, &tb);
+            type.steal(t.relinquish_ownership());
+            instance.steal(v.relinquish_ownership());
+            traceback.steal(tb.relinquish_ownership());
+        }
+
+        void PyErrRestore()
+        {
+            // can only do this once
+            assert(!this->restored);
+            this->restored = true;
+            PyErr_Restore(
+                this->type.relinquish_ownership(),
+                this->instance.relinquish_ownership(),
+                this->traceback.relinquish_ownership());
+            assert(!this->type && !this->instance && !this->traceback);
+        }
+
+    private:
+        void normalize()
+        {
+            // First, check the traceback argument, replacing None,
+            // with NULL
+            if (traceback.is_None()) {
+                traceback = nullptr;
+            }
+
+            if (traceback && !PyTraceBack_Check(traceback.borrow())) {
+                throw PyErrOccurred(PyExc_TypeError,
+                                    "throw() third argument must be a traceback object");
+            }
+
+            if (PyExceptionClass_Check(type)) {
+                // If we just had a type, we'll now have a type and
+                // instance.
+                // The type's refcount will have gone up by one
+                // because of the instance and the instance will have
+                // a refcount of one. Either way, we owned, and still
+                // do own, exactly one reference.
+                PyErr_NormalizeException(&type, &instance, &traceback);
+
+            }
+            else if (PyExceptionInstance_Check(type)) {
+                /* Raising an instance --- usually that means an
+                   object that is a subclass of BaseException, but on
+                   Python 2, that can also mean an arbitrary old-style
+                   object. The value should be a dummy. */
+                if (instance && !instance.is_None()) {
+                    throw PyErrOccurred(
+                                    PyExc_TypeError,
+                                    "instance exception may not have a separate value");
+                }
+                /* Normalize to raise <class>, <instance> */
+                this->instance = this->type;
+                this->type = PyExceptionInstance_Class(instance.borrow());
+
+                /*
+                  It would be tempting to do this:
+
+                Py_ssize_t type_count = Py_REFCNT(Py_TYPE(instance.borrow()));
+                this->type = PyExceptionInstance_Class(instance.borrow());
+                assert(this->type.REFCNT() == type_count + 1);
+
+                But that doesn't work on Python 2 in the case of
+                old-style instances: The result of Py_TYPE is going to
+                be the global shared <type instance> that all
+                old-style classes have, while the return of Instance_Class()
+                will be the Python-level class object. The two are unrelated.
+                */
+            }
+            else {
+                /* Not something you can raise. throw() fails. */
+                PyErr_Format(PyExc_TypeError,
+                     "exceptions must be classes, or instances, not %s",
+                             Py_TYPE(type.borrow())->tp_name);
+                throw PyErrOccurred();
+            }
+        }
+    };
+
+    // PyArg_Parse's O argument returns a borrowed reference.
+    class PyArgParseParam : public BorrowedObject
+    {
+    private:
+        G_NO_COPIES_OF_CLS(PyArgParseParam);
+    public:
+        explicit PyArgParseParam(PyObject* p=nullptr) : BorrowedObject(p)
+        {
+        }
+
+        inline PyObject** operator&()
+        {
+            return &this->p;
+        }
+    };
+
+};};
+
+#endif

_service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/greenlet_slp_switch.hpp Added

@@ -0,0 +1,117 @@
+#ifndef GREENLET_SLP_SWITCH_HPP
+#define GREENLET_SLP_SWITCH_HPP
+
+#include "greenlet_compiler_compat.hpp"
+#include "greenlet_refs.hpp"
+
+/*
+ * the following macros are spliced into the OS/compiler
+ * specific code, in order to simplify maintenance.
+ */
+// We can save about 10% of the time it takes to switch greenlets if
+// we thread the thread state through the slp_save_state() and the
+// following slp_restore_state() calls from
+// slp_switch()->g_switchstack() (which already needs to access it).
+//
+// However:
+//
+// that requires changing the prototypes and implementations of the
+// switching functions. If we just change the prototype of
+// slp_switch() to accept the argument and update the macros, without
+// changing the implementation of slp_switch(), we get crashes on
+// 64-bit Linux and 32-bit x86 (for reasons that aren't 100% clear);
+// on the other hand, 64-bit macOS seems to be fine. Also, 64-bit
+// windows is an issue because slp_switch is written fully in assembly
+// and currently ignores its argument so some code would have to be
+// adjusted there to pass the argument on to the
+// ``slp_save_state_asm()`` function (but interestingly, because of
+// the calling convention, the extra argument is just ignored and
+// things function fine, albeit slower, if we just modify
+// ``slp_save_state_asm`()` to fetch the pointer to pass to the
+// macro.)
+//
+// Our compromise is to use a *glabal*, untracked, weak, pointer
+// to the necessary thread state during the process of switching only.
+// This is safe because we're protected by the GIL, and if we're
+// running this code, the thread isn't exiting. This also nets us a
+// 10-12% speed improvement.
+
+static greenlet::Greenlet* volatile switching_thread_state = nullptr;
+
+
+#ifdef GREENLET_NOINLINE_SUPPORTED
+extern "C" {
+static int GREENLET_NOINLINE(slp_save_state_trampoline)(char* stackref);
+static void GREENLET_NOINLINE(slp_restore_state_trampoline)();
+}
+#define GREENLET_NOINLINE_INIT() \
+    do {                         \
+    } while (0)
+#else
+/* force compiler to call functions via pointers */
+/* XXX: Do we even want/need to support such compilers? This code path
+   is untested on CI. */
+extern "C" {
+static int (slp_save_state_trampoline)(char* stackref);
+static void (slp_restore_state_trampoline)();
+}
+#define GREENLET_NOINLINE(name) cannot_inline_##name
+#define GREENLET_NOINLINE_INIT()                                  \
+    do {                                                              \
+            slp_save_state_trampoline = GREENLET_NOINLINE(slp_save_state_trampoline); \
+            slp_restore_state_trampoline = GREENLET_NOINLINE(slp_restore_state_trampoline); \
+    } while (0)
+#endif
+
+#define SLP_SAVE_STATE(stackref, stsizediff) \
+do {                                                    \
+    assert(switching_thread_state);  \
+    stackref += STACK_MAGIC;                 \
+    if (slp_save_state_trampoline((char*)stackref))    \
+        return -1;                                     \
+    if (!switching_thread_state->active()) \
+        return 1;                                      \
+    stsizediff = switching_thread_state->stack_start() - (char*)stackref; \
+} while (0)
+
+#define SLP_RESTORE_STATE() slp_restore_state_trampoline()
+
+#define SLP_EVAL
+extern "C" {
+#define slp_switch GREENLET_NOINLINE(slp_switch)
+#include "slp_platformselect.h"
+}
+#undef slp_switch
+
+#ifndef STACK_MAGIC
+#    error \
+        "greenlet needs to be ported to this platform, or taught how to detect your compiler properly."
+#endif /* !STACK_MAGIC */
+
+
+
+#ifdef EXTERNAL_ASM
+/* CCP addition: Make these functions, to be called from assembler.
+ * The token include file for the given platform should enable the
+ * EXTERNAL_ASM define so that this is included.
+ */
+extern "C" {
+intptr_t
+slp_save_state_asm(intptr_t* ref)
+{
+    intptr_t diff;
+    SLP_SAVE_STATE(ref, diff);
+    return diff;
+}
+
+void
+slp_restore_state_asm(void)
+{
+    SLP_RESTORE_STATE();
+}
+
+extern int slp_switch(void);
+};
+#endif
+
+#endif

_service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/greenlet_thread_state.hpp Added

@@ -0,0 +1,561 @@
+#ifndef GREENLET_THREAD_STATE_HPP
+#define GREENLET_THREAD_STATE_HPP
+
+#include <ctime>
+#include <stdexcept>
+
+#include "greenlet_internal.hpp"
+#include "greenlet_refs.hpp"
+#include "greenlet_thread_support.hpp"
+
+using greenlet::refs::BorrowedObject;
+using greenlet::refs::BorrowedGreenlet;
+using greenlet::refs::BorrowedMainGreenlet;
+using greenlet::refs::OwnedMainGreenlet;
+using greenlet::refs::OwnedObject;
+using greenlet::refs::OwnedGreenlet;
+using greenlet::refs::OwnedList;
+using greenlet::refs::PyErrFetchParam;
+using greenlet::refs::PyArgParseParam;
+using greenlet::refs::ImmortalString;
+using greenlet::refs::CreatedModule;
+using greenlet::refs::PyErrPieces;
+using greenlet::refs::NewReference;
+
+namespace greenlet {
+/**
+ * Thread-local state of greenlets.
+ *
+ * Each native thread will get exactly one of these objects,
+ * automatically accessed through the best available thread-local
+ * mechanism the compiler supports (``thread_local`` for C++11
+ * compilers or ``__thread``/``declspec(thread)`` for older GCC/clang
+ * or MSVC, respectively.)
+ *
+ * Previously, we kept thread-local state mostly in a bunch of
+ * ``static volatile`` variables in the main greenlet file.. This had
+ * the problem of requiring extra checks, loops, and great care
+ * accessing these variables if we potentially invoked any Python code
+ * that could release the GIL, because the state could change out from
+ * under us. Making the variables thread-local solves this problem.
+ *
+ * When we detected that a greenlet API accessing the current greenlet
+ * was invoked from a different thread than the greenlet belonged to,
+ * we stored a reference to the greenlet in the Python thread
+ * dictionary for the thread the greenlet belonged to. This could lead
+ * to memory leaks if the thread then exited (because of a reference
+ * cycle, as greenlets referred to the thread dictionary, and deleting
+ * non-current greenlets leaked their frame plus perhaps arguments on
+ * the C stack). If a thread exited while still having running
+ * greenlet objects (perhaps that had just switched back to the main
+ * greenlet), and did not invoke one of the greenlet APIs *in that
+ * thread, immediately before it exited, without some other thread
+ * then being invoked*, such a leak was guaranteed.
+ *
+ * This can be partly solved by using compiler thread-local variables
+ * instead of the Python thread dictionary, thus avoiding a cycle.
+ *
+ * To fully solve this problem, we need a reliable way to know that a
+ * thread is done and we should clean up the main greenlet. On POSIX,
+ * we can use the destructor function of ``pthread_key_create``, but
+ * there's nothing similar on Windows; a C++11 thread local object
+ * reliably invokes its destructor when the thread it belongs to exits
+ * (non-C++11 compilers offer ``__thread`` or ``declspec(thread)`` to
+ * create thread-local variables, but they can't hold C++ objects that
+ * invoke destructors; the C++11 version is the most portable solution
+ * I found). When the thread exits, we can drop references and
+ * otherwise manipulate greenlets and frames that we know can no
+ * longer be switched to. For compilers that don't support C++11
+ * thread locals, we have a solution that uses the python thread
+ * dictionary, though it may not collect everything as promptly as
+ * other compilers do, if some other library is using the thread
+ * dictionary and has a cycle or extra reference.
+ *
+ * There are two small wrinkles. The first is that when the thread
+ * exits, it is too late to actually invoke Python APIs: the Python
+ * thread state is gone, and the GIL is released. To solve *this*
+ * problem, our destructor uses ``Py_AddPendingCall`` to transfer the
+ * destruction work to the main thread. (This is not an issue for the
+ * dictionary solution.)
+ *
+ * The second is that once the thread exits, the thread local object
+ * is invalid and we can't even access a pointer to it, so we can't
+ * pass it to ``Py_AddPendingCall``. This is handled by actually using
+ * a second object that's thread local (ThreadStateCreator) and having
+ * it dynamically allocate this object so it can live until the
+ * pending call runs.
+ */
+
+
+
+class ThreadState {
+private:
+    // As of commit 08ad1dd7012b101db953f492e0021fb08634afad
+    // this class needed 56 bytes in o Py_DEBUG build
+    // on 64-bit macOS 11.
+    // Adding the vector takes us up to 80 bytes ()
+
+    /* Strong reference to the main greenlet */
+    OwnedMainGreenlet main_greenlet;
+
+    /* Strong reference to the current greenlet. */
+    OwnedGreenlet current_greenlet;
+
+    /* Strong reference to the trace function, if any. */
+    OwnedObject tracefunc;
+
+    typedef std::vector<PyGreenlet*, PythonAllocator<PyGreenlet*> > deleteme_t;
+    /* A vector of raw PyGreenlet pointers representing things that need
+       deleted when this thread is running. The vector owns the
+       references, but you need to manually INCREF/DECREF as you use
+       them. We don't use a vector<refs::OwnedGreenlet> because we
+       make copy of this vector, and that would become O(n) as all the
+       refcounts are incremented in the copy.
+    */
+    deleteme_t deleteme;
+
+#ifdef GREENLET_NEEDS_EXCEPTION_STATE_SAVED
+    void* exception_state;
+#endif
+
+    static std::clock_t _clocks_used_doing_gc;
+    static ImmortalString get_referrers_name;
+    static PythonAllocator<ThreadState> allocator;
+
+    G_NO_COPIES_OF_CLS(ThreadState);
+
+public:
+    static void* operator new(size_t UNUSED(count))
+    {
+        return ThreadState::allocator.allocate(1);
+    }
+
+    static void operator delete(void* ptr)
+    {
+        return ThreadState::allocator.deallocate(static_cast<ThreadState*>(ptr),
+                                                 1);
+    }
+
+    static void init()
+    {
+        ThreadState::get_referrers_name = "get_referrers";
+        ThreadState::_clocks_used_doing_gc = 0;
+    }
+
+    ThreadState()
+        : main_greenlet(OwnedMainGreenlet::consuming(green_create_main(this))),
+          current_greenlet(main_greenlet)
+    {
+        if (!this->main_greenlet) {
+            // We failed to create the main greenlet. That's bad.
+            throw PyFatalError("Failed to create main greenlet");
+        }
+        // The main greenlet starts with 1 refs: The returned one. We
+        // then copied it to the current greenlet.
+        assert(this->main_greenlet.REFCNT() == 2);
+
+#ifdef GREENLET_NEEDS_EXCEPTION_STATE_SAVED
+        this->exception_state = slp_get_exception_state();
+#endif
+    }
+
+    inline void restore_exception_state()
+    {
+#ifdef GREENLET_NEEDS_EXCEPTION_STATE_SAVED
+        // It's probably important this be inlined and only call C
+        // functions to avoid adding an SEH frame.
+        slp_set_exception_state(this->exception_state);
+#endif
+    }
+
+    inline bool has_main_greenlet()
+    {
+        return !!this->main_greenlet;
+    }
+
+    // Called from the ThreadStateCreator when we're in non-standard
+    // threading mode. In that case, there is an object in the Python
+    // thread state dictionary that points to us. The main greenlet
+    // also traverses into us, in which case it's crucial not to
+    // traverse back into the main greenlet.
+    int tp_traverse(visitproc visit, void* arg, bool traverse_main=true)
+    {
+        if (traverse_main) {
+            Py_VISIT(main_greenlet.borrow_o());
+        }
+        if (traverse_main || current_greenlet != main_greenlet) {
+            Py_VISIT(current_greenlet.borrow_o());
+        }
+        Py_VISIT(tracefunc.borrow());
+        return 0;
+    }
+
+    inline BorrowedMainGreenlet borrow_main_greenlet() const
+    {
+        assert(this->main_greenlet);
+        assert(this->main_greenlet.REFCNT() >= 2);
+        return this->main_greenlet;
+    };
+
+    inline OwnedMainGreenlet get_main_greenlet()
+    {
+        return this->main_greenlet;
+    }
+
+    /**
+     * In addition to returning a new reference to the currunt
+     * greenlet, this performs any maintenance needed.
+     */
+    inline OwnedGreenlet get_current()
+    {
+        /* green_dealloc() cannot delete greenlets from other threads, so
+           it stores them in the thread dict; delete them now. */
+        this->clear_deleteme_list();
+        //assert(this->current_greenlet->main_greenlet == this->main_greenlet);
+        //assert(this->main_greenlet->main_greenlet == this->main_greenlet);
+        return this->current_greenlet;
+    }
+
+    /**
+     * As for non-const get_current();
+     */
+    inline BorrowedGreenlet borrow_current()
+    {
+        this->clear_deleteme_list();
+        return this->current_greenlet;
+    }
+
+    /**
+     * Does no maintenance.
+     */
+    inline OwnedGreenlet get_current() const
+    {
+        return this->current_greenlet;
+    }
+
+    template<typename T, refs::TypeChecker TC>
+    inline bool is_current(const refs::PyObjectPointer<T, TC>& obj) const
+    {
+        return this->current_greenlet.borrow_o() == obj.borrow_o();
+    }
+
+    inline void set_current(const OwnedGreenlet& target)
+    {
+        this->current_greenlet = target;
+    }
+
+private:
+    /**
+     * Deref and remove the greenlets from the deleteme list. Must be
+     * holding the GIL.
+     *
+     * If *murder* is true, then we must be called from a different
+     * thread than the one that these greenlets were running in.
+     * In that case, if the greenlet was actually running, we destroy
+     * the frame reference and otherwise make it appear dead before
+     * proceeding; otherwise, we would try (and fail) to raise an
+     * exception in it and wind up right back in this list.
+     */
+    inline void clear_deleteme_list(const bool murder=false)
+    {
+        if (!this->deleteme.empty()) {
+            // It's possible we could add items to this list while
+            // running Python code if there's a thread switch, so we
+            // need to defensively copy it before that can happen.
+            deleteme_t copy = this->deleteme;
+            this->deleteme.clear(); // in case things come back on the list
+            for(deleteme_t::iterator it = copy.begin(), end = copy.end();
+                it != end;
+                ++it ) {
+                PyGreenlet* to_del = *it;
+                if (murder) {
+                    // Force each greenlet to appear dead; we can't raise an
+                    // exception into it anymore anyway.
+                    to_del->pimpl->murder_in_place();
+                }
+
+                // The only reference to these greenlets should be in
+                // this list, decreffing them should let them be
+                // deleted again, triggering calls to green_dealloc()
+                // in the correct thread (if we're not murdering).
+                // This may run arbitrary Python code and switch
+                // threads or greenlets!
+                Py_DECREF(to_del);
+                if (PyErr_Occurred()) {
+                    PyErr_WriteUnraisable(nullptr);
+                    PyErr_Clear();
+                }
+            }
+        }
+    }
+
+public:
+
+    /**
+     * Returns a new reference, or a false object.
+     */
+    inline OwnedObject get_tracefunc() const
+    {
+        return tracefunc;
+    };
+
+
+    inline void set_tracefunc(BorrowedObject tracefunc)
+    {
+        assert(tracefunc);
+        if (tracefunc == BorrowedObject(Py_None)) {
+            this->tracefunc.CLEAR();
+        }
+        else {
+            this->tracefunc = tracefunc;
+        }
+    }
+
+    /**
+     * Given a reference to a greenlet that some other thread
+     * attempted to delete (has a refcount of 0) store it for later
+     * deletion when the thread this state belongs to is current.
+     */
+    inline void delete_when_thread_running(PyGreenlet* to_del)
+    {
+        Py_INCREF(to_del);
+        this->deleteme.push_back(to_del);
+    }
+
+    /**
+     * Set to std::clock_t(-1) to disable.
+     */
+    inline static std::clock_t& clocks_used_doing_gc()
+    {
+        return ThreadState::_clocks_used_doing_gc;
+    }
+
+    ~ThreadState()
+    {
+        if (!PyInterpreterState_Head()) {
+            // We shouldn't get here (our callers protect us)
+            // but if we do, all we can do is bail early.
+            return;
+        }
+
+        // We should not have an "origin" greenlet; that only exists
+        // for the temporary time during a switch, which should not
+        // be in progress as the thread dies.
+        //assert(!this->switching_state.origin);
+
+        this->tracefunc.CLEAR();
+
+        // Forcibly GC as much as we can.
+        this->clear_deleteme_list(true);
+
+        // The pending call did this.
+        assert(this->main_greenlet->thread_state() == nullptr);
+
+        // If the main greenlet is the current greenlet,
+        // then we "fell off the end" and the thread died.
+        // It's possible that there is some other greenlet that
+        // switched to us, leaving a reference to the main greenlet
+        // on the stack, somewhere uncollectible. Try to detect that.
+        if (this->current_greenlet == this->main_greenlet && this->current_greenlet) {
+            assert(this->current_greenlet->is_currently_running_in_some_thread());
+            // Drop one reference we hold.
+            this->current_greenlet.CLEAR();
+            assert(!this->current_greenlet);
+            // Only our reference to the main greenlet should be left,
+            // But hold onto the pointer in case we need to do extra cleanup.
+            PyGreenlet* old_main_greenlet = this->main_greenlet.borrow();
+            Py_ssize_t cnt = this->main_greenlet.REFCNT();
+            this->main_greenlet.CLEAR();
+            if (ThreadState::_clocks_used_doing_gc != std::clock_t(-1)
+                && cnt == 2 && Py_REFCNT(old_main_greenlet) == 1) {
+                // Highly likely that the reference is somewhere on
+                // the stack, not reachable by GC. Verify.
+                // XXX: This is O(n) in the total number of objects.
+                // TODO: Add a way to disable this at runtime, and
+                // another way to report on it.
+                std::clock_t begin = std::clock();
+                NewReference gc(PyImport_ImportModule("gc"));
+                if (gc) {
+                    OwnedObject get_referrers = gc.PyRequireAttr(ThreadState::get_referrers_name);
+                    OwnedList refs(get_referrers.PyCall(old_main_greenlet));
+                    if (refs && refs.empty()) {
+                        assert(refs.REFCNT() == 1);
+                        // We found nothing! So we left a dangling
+                        // reference: Probably the last thing some
+                        // other greenlet did was call
+                        // 'getcurrent().parent.switch()' to switch
+                        // back to us. Clean it up. This will be the
+                        // case on CPython 3.7 and newer, as they use
+                        // an internal calling conversion that avoids
+                        // creating method objects and storing them on
+                        // the stack.
+                        Py_DECREF(old_main_greenlet);
+                    }
+                    else if (refs
+                             && refs.size() == 1
+                             && PyCFunction_Check(refs.at(0))
+                             && Py_REFCNT(refs.at(0)) == 2) {
+                        assert(refs.REFCNT() == 1);
+                        // Ok, we found a C method that refers to the
+                        // main greenlet, and its only referenced
+                        // twice, once in the list we just created,
+                        // once from...somewhere else. If we can't
+                        // find where else, then this is a leak.
+                        // This happens in older versions of CPython
+                        // that create a bound method object somewhere
+                        // on the stack that we'll never get back to.
+                        if (PyCFunction_GetFunction(refs.at(0).borrow()) == (PyCFunction)green_switch) {
+                            BorrowedObject function_w = refs.at(0);
+                            refs.clear(); // destroy the reference
+                                          // from the list.
+                            // back to one reference. Can *it* be
+                            // found?
+                            assert(function_w.REFCNT() == 1);
+                            refs = get_referrers.PyCall(function_w);
+                            if (refs && refs.empty()) {
+                                // Nope, it can't be found so it won't
+                                // ever be GC'd. Drop it.
+                                Py_CLEAR(function_w);
+                            }
+                        }
+                    }
+                    std::clock_t end = std::clock();
+                    ThreadState::_clocks_used_doing_gc += (end - begin);
+                }
+            }
+        }
+
+        // We need to make sure this greenlet appears to be dead,
+        // because otherwise deallocing it would fail to raise an
+        // exception in it (the thread is dead) and put it back in our
+        // deleteme list.
+        if (this->current_greenlet) {
+            this->current_greenlet->murder_in_place();
+            this->current_greenlet.CLEAR();
+        }
+
+        if (this->main_greenlet) {
+            // Couldn't have been the main greenlet that was running
+            // when the thread exited (because we already cleared this
+            // pointer if it was). This shouldn't be possible?
+
+            // If the main greenlet was current when the thread died (it
+            // should be, right?) then we cleared its self pointer above
+            // when we cleared the current greenlet's main greenlet pointer.
+            // assert(this->main_greenlet->main_greenlet == this->main_greenlet
+            //        || !this->main_greenlet->main_greenlet);
+            // // self reference, probably gone
+            // this->main_greenlet->main_greenlet.CLEAR();
+
+            // This will actually go away when the ivar is destructed.
+            this->main_greenlet.CLEAR();
+        }
+
+        if (PyErr_Occurred()) {
+            PyErr_WriteUnraisable(NULL);
+            PyErr_Clear();
+        }
+
+    }
+
+};
+
+ImmortalString ThreadState::get_referrers_name(nullptr);
+PythonAllocator<ThreadState> ThreadState::allocator;
+std::clock_t ThreadState::_clocks_used_doing_gc(0);
+
+template<typename Destructor>
+class ThreadStateCreator
+{
+private:
+    // Initialized to 1, and, if still 1, created on access.
+    // Set to 0 on destruction.
+    ThreadState* _state;
+    G_NO_COPIES_OF_CLS(ThreadStateCreator);
+public:
+
+    // Only one of these, auto created per thread
+    ThreadStateCreator() :
+        _state((ThreadState*)1)
+    {
+    }
+
+    ~ThreadStateCreator()
+    {
+        ThreadState* tmp = this->_state;
+        this->_state = nullptr;
+        if (tmp && tmp != (ThreadState*)1) {
+            Destructor x(tmp);
+        }
+    }
+
+    inline ThreadState& state()
+    {
+        // The main greenlet will own this pointer when it is created,
+        // which will be right after this. The plan is to give every
+        // greenlet a pointer to the main greenlet for the thread it
+        // runs in; if we are doing something cross-thread, we need to
+        // access the pointer from the main greenlet. Deleting the
+        // thread, and hence the thread-local storage, will delete the
+        // state pointer in the main greenlet.
+        if (this->_state == (ThreadState*)1) {
+            // XXX: Assuming allocation never fails
+            this->_state = new ThreadState;
+            // For non-standard threading, we need to store an object
+            // in the Python thread state dictionary so that it can be
+            // DECREF'd when the thread ends (ideally; the dict could
+            // last longer) and clean this object up.
+        }
+        if (!this->_state) {
+            throw std::runtime_error("Accessing state after destruction.");
+        }
+        return *this->_state;
+    }
+
+    operator ThreadState&()
+    {
+        return this->state();
+    }
+
+    operator ThreadState*()
+    {
+        return &this->state();
+    }
+
+    inline int tp_traverse(visitproc visit, void* arg)
+    {
+        if (this->_state) {
+            return this->_state->tp_traverse(visit, arg);
+        }
+        return 0;
+    }
+
+};
+
+#if G_USE_STANDARD_THREADING == 1
+// We can't use the PythonAllocator for this, because we push to it
+// from the thread state destructor, which doesn't have the GIL,
+// and Python's allocators can only be called with the GIL.
+typedef std::vector<ThreadState*> cleanup_queue_t;
+#else
+class cleanup_queue_t {
+public:
+    inline ssize_t size() const { return 0; };
+    inline bool empty() const { return true; };
+    inline void pop_back()
+    {
+        throw std::out_of_range("empty queue.");
+    };
+    inline ThreadState* back()
+    {
+        throw std::out_of_range("empty queue.");
+    };
+    inline void push_back(ThreadState* g)
+    {
+        throw std::out_of_range("empty queue.");
+    };
+};
+#endif
+}; // namespace greenlet
+
+#endif

_service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/greenlet_thread_state_dict_cleanup.hpp Added

@@ -0,0 +1,118 @@
+#ifndef GREENLET_THREAD_STATE_DICT_CLEANUP_HPP
+#define GREENLET_THREAD_STATE_DICT_CLEANUP_HPP
+
+#include "greenlet_internal.hpp"
+#include "greenlet_thread_state.hpp"
+
+#ifdef __clang__
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wmissing-field-initializers"
+#endif
+
+#ifndef G_THREAD_STATE_DICT_CLEANUP_TYPE
+// shut the compiler up if it looks at this file in isolation
+#define ThreadStateCreator int
+#endif
+
+// Define a Python object that goes in the Python thread state dict
+// when the greenlet thread state is created, and which owns the
+// reference to the greenlet thread local state.
+// When the thread state dict is cleaned up, so too is the thread
+// state. This works best if we make sure there are no circular
+// references to the thread state.
+typedef struct _PyGreenletCleanup {
+    PyObject_HEAD
+    ThreadStateCreator* thread_state_creator;
+} PyGreenletCleanup;
+
+static void
+cleanup_do_dealloc(PyGreenletCleanup* self)
+{
+    ThreadStateCreator* tmp = self->thread_state_creator;
+    self->thread_state_creator = nullptr;
+    if (tmp) {
+        delete tmp;
+    }
+}
+
+static void
+cleanup_dealloc(PyGreenletCleanup* self)
+{
+    PyObject_GC_UnTrack(self);
+    cleanup_do_dealloc(self);
+}
+
+static int
+cleanup_clear(PyGreenletCleanup* self)
+{
+    // This method is never called by our test cases.
+    cleanup_do_dealloc(self);
+    return 0;
+}
+
+static int
+cleanup_traverse(PyGreenletCleanup* self, visitproc visit, void* arg)
+{
+    if (self->thread_state_creator) {
+        return self->thread_state_creator->tp_traverse(visit, arg);
+    }
+    return 0;
+}
+
+static int
+cleanup_is_gc(PyGreenlet* UNUSED(self))
+{
+    return 1;
+}
+
+static PyTypeObject PyGreenletCleanup_Type = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    "greenlet._greenlet.ThreadStateCleanup",
+    sizeof(struct _PyGreenletCleanup),
+    0,                   /* tp_itemsize */
+    /* methods */
+    (destructor)cleanup_dealloc, /* tp_dealloc */
+    0,                         /* tp_print */
+    0,                         /* tp_getattr */
+    0,                         /* tp_setattr */
+    0,                         /* tp_compare */
+    0,                         /* tp_repr */
+    0,                         /* tp_as _number*/
+    0,                         /* tp_as _sequence*/
+    0,                         /* tp_as _mapping*/
+    0,                         /* tp_hash */
+    0,                         /* tp_call */
+    0,                         /* tp_str */
+    0,                         /* tp_getattro */
+    0,                         /* tp_setattro */
+    0,                         /* tp_as_buffer*/
+    G_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
+    "Internal use only",                        /* tp_doc */
+    (traverseproc)cleanup_traverse, /* tp_traverse */
+    (inquiry)cleanup_clear,         /* tp_clear */
+    0,                                  /* tp_richcompare */
+    // XXX: Don't our flags promise a weakref?
+    0,                           /* tp_weaklistoffset */
+    0,                                  /* tp_iter */
+    0,                                  /* tp_iternext */
+    0,                      /* tp_methods */
+    0,                      /* tp_members */
+    0,                      /* tp_getset */
+    0,                                  /* tp_base */
+    0,                                  /* tp_dict */
+    0,                                  /* tp_descr_get */
+    0,                                  /* tp_descr_set */
+    0,         /* tp_dictoffset */
+    0,               /* tp_init */
+    PyType_GenericAlloc,                  /* tp_alloc */
+    PyType_GenericNew,                          /* tp_new */
+    PyObject_GC_Del,                   /* tp_free */
+    (inquiry)cleanup_is_gc,         /* tp_is_gc */
+};
+
+#ifdef __clang__
+#    pragma clang diagnostic pop
+#endif
+
+
+#endif

_service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/greenlet_thread_support.hpp Added

@@ -0,0 +1,144 @@
+#ifndef GREENLET_THREAD_SUPPORT_HPP
+#define GREENLET_THREAD_SUPPORT_HPP
+
+/**
+ * Defines various utility functions to help greenlet integrate well
+ * with threads. When possible, we use portable C++ 11 threading; when
+ * not possible, we will use platform specific APIs if needed and
+ * available. (Currently, this is only for Python 2.7 on Windows.)
+ */
+
+#include <stdexcept>
+#include "greenlet_compiler_compat.hpp"
+
+// Allow setting this to 0 on the command line so that we
+// can test these code paths on compilers that otherwise support
+// standard threads.
+#ifndef G_USE_STANDARD_THREADING
+#if __cplusplus >= 201103
+// Cool. We should have standard support
+#    define G_USE_STANDARD_THREADING 1
+#elif defined(_MSC_VER)
+// MSVC doesn't use a modern version of __cplusplus automatically, you
+// have to opt-in to update it with /Zc:__cplusplus, but that's not
+// available on our old version of visual studio for Python 2.7
+#    if _MSC_VER <= 1500
+// Python 2.7 on Windows. Use the Python thread state and native Win32 APIs.
+#        define G_USE_STANDARD_THREADING 0
+#    else
+// Assume we have a compiler that supports it. The Appveyor compilers
+// we use all do have standard support
+#        define G_USE_STANDARD_THREADING 1
+#    endif
+#elif defined(__GNUC__) || defined(__clang__)
+// All tested versions either do, or can with the right --std argument, support what we need
+#    define G_USE_STANDARD_THREADING 1
+#else
+#    define G_USE_STANDARD_THREADING 0
+#endif
+#endif /* G_USE_STANDARD_THREADING */
+
+namespace greenlet {
+    class LockInitError : public std::runtime_error
+    {
+    public:
+        LockInitError(const char* what) : std::runtime_error(what)
+        {};
+    };
+};
+
+
+#if G_USE_STANDARD_THREADING == 1
+#    define G_THREAD_LOCAL_SUPPORTS_DESTRUCTOR 1
+#    include <thread>
+#    include <mutex>
+#    define G_THREAD_LOCAL_VAR thread_local
+namespace greenlet {
+    typedef std::mutex Mutex;
+    typedef std::lock_guard<Mutex> LockGuard;
+};
+#else
+// NOTE: At this writing, the mutex isn't currently required;
+// we don't use a shared cleanup queue or Py_AddPendingCall in this
+// model, we rely on the thread state dictionary for cleanup.
+#    if defined(_MSC_VER)
+//       We should only hit this case for Python 2.7 on Windows.
+#        define G_THREAD_LOCAL_VAR __declspec(thread)
+#        include <windows.h>
+namespace greenlet {
+    class Mutex
+    {
+        CRITICAL_SECTION _mutex;
+        G_NO_COPIES_OF_CLS(Mutex);
+    public:
+        Mutex()
+        {
+            InitializeCriticalSection(&this->_mutex);
+        };
+
+        void Lock()
+        {
+            EnterCriticalSection(&this->_mutex);
+        };
+
+        void UnLock()
+        {
+            LeaveCriticalSection(&this->_mutex);
+        };
+    };
+};
+#    elif (defined(__GNUC__) || defined(__clang__)) || (defined(__SUNPRO_C))
+// GCC, clang, SunStudio all use __thread for thread-local variables.
+// For locks, we can use PyThread APIs, officially added in 3.2, but
+// present back to 2.7
+#        define G_THREAD_LOCAL_VAR __thread
+#        include "pythread.h"
+namespace greenlet {
+    class Mutex
+    {
+        PyThread_type_lock _mutex;
+        G_NO_COPIES_OF_CLS(Mutex);
+    public:
+        Mutex()
+        {
+            this->_mutex = PyThread_allocate_lock();
+            if (!this->_mutex) {
+                throw LockInitError("Failed to initialize mutex.");
+            }
+        };
+
+        void Lock()
+        {
+            PyThread_acquire_lock(this->_mutex, WAIT_LOCK);
+        };
+
+        void UnLock()
+        {
+            PyThread_release_lock(this->_mutex);
+        };
+    };
+};
+#    else
+#        error Unable to declare thread-local variables.
+#    endif
+// the RAII lock keeper for all non-standard threading platforms.
+namespace greenlet {
+    class LockGuard
+    {
+        Mutex& _mutex;
+        G_NO_COPIES_OF_CLS(LockGuard);
+    public:
+        LockGuard(Mutex& m) : _mutex(m)
+        {
+            this->_mutex.Lock();
+        };
+        ~LockGuard()
+        {
+            this->_mutex.UnLock();
+        };
+    };
+
+};
+#endif /* G_USE_STANDARD_THREADING == 1 */
+
+#endif /* GREENLET_THREAD_SUPPORT_HPP */

_service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/platform/__init__.py Added

_service:tar_scm:greenlet-1.1.2.tar.gz/src/greenlet/platform/switch_aarch64_gcc.h -> _service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/platform/switch_aarch64_gcc.h Changed

_service:tar_scm:greenlet-1.1.2.tar.gz/src/greenlet/platform/switch_amd64_unix.h -> _service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/platform/switch_amd64_unix.h Changed

_service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/platform/switch_arm64_masm.asm Added

@@ -0,0 +1,53 @@
+  AREA switch_arm64_masm, CODE, READONLY;
+  GLOBAL slp_switch FUNC
+  EXTERN slp_save_state_asm
+  EXTERN slp_restore_state_asm
+
+slp_switch    
+    ; push callee saved registers to stack
+    stp    x19, x20, sp, #-16!
+    stp    x21, x22, sp, #-16!
+    stp    x23, x24, sp, #-16!
+    stp    x25, x26, sp, #-16!
+    stp    x27, x28, sp, #-16!
+    stp    x29, x30, sp, #-16!
+    stp    d8, d9, sp, #-16!
+    stp    d10, d11, sp, #-16!
+    stp    d12, d13, sp, #-16!
+    stp    d14, d15, sp, #-16!
+
+    ; call slp_save_state_asm with stack pointer
+    mov x0, sp
+    bl    slp_save_state_asm
+
+    ; early return for return value of 1 and -1
+    cmp x0, #-1
+    b.eq RETURN
+    cmp x0, #1
+    b.eq RETURN
+
+    ; increment stack and frame pointer
+    add sp, sp, x0
+    add x29, x29, x0
+
+    bl slp_restore_state_asm
+
+    ; store return value for successful completion of routine
+    mov x0, #0
+
+RETURN
+    ; pop registers from stack
+    ldp d14, d15, sp, #16
+    ldp d12, d13, sp, #16
+    ldp d10, d11, sp, #16
+    ldp d8, d9, sp, #16
+    ldp x29, x30, sp, #16
+    ldp x27, x28, sp, #16
+    ldp x25, x26, sp, #16
+    ldp x23, x24, sp, #16
+    ldp x21, x22, sp, #16
+    ldp x19, x20, sp, #16
+
+    ret
+
+    END

_service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/platform/switch_arm64_masm.obj Added

_service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/platform/switch_arm64_msvc.h Added

_service:tar_scm:greenlet-1.1.2.tar.gz/src/greenlet/platform/switch_riscv_unix.h -> _service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/platform/switch_riscv_unix.h Changed

_service:tar_scm:greenlet-1.1.2.tar.gz/src/greenlet/platform/switch_x86_msvc.h -> _service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/platform/switch_x86_msvc.h Changed

@@ -32,17 +32,166 @@
 
 /* Some magic to quell warnings and keep slp_switch() from crashing when built
    with VC90. Disable global optimizations, and the warning: frame pointer
-   register 'ebp' modified by inline assembly code */
-#pragma optimize("g", off)
+   register 'ebp' modified by inline assembly code.
+
+   We used to just disable global optimizations ("g") but upstream stackless
+   Python, as well as stackman, turn off all optimizations.
+
+References:
+https://github.com/stackless-dev/stackman/blob/dbc72fe5207a2055e658c819fdeab9731dee78b9/stackman/platforms/switch_x86_msvc.h
+https://github.com/stackless-dev/stackless/blob/main-slp/Stackless/platf/switch_x86_msvc.h
+*/
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+#pragma optimize("", off) /* so that autos are stored on the stack */
 #pragma warning(disable:4731)
+#pragma warning(disable:4733) /* disable warning about modifying FS0 */
+
+/**
+ * Most modern compilers and environments handle C++ exceptions without any
+ * special help from us. MSVC on 32-bit windows is an exception. There, C++
+ * exceptions are dealt with using Windows' Structured Exception Handling
+ * (SEH).
+ *
+ * SEH is implemented as a singly linked list of <function*, prev*> nodes. The
+ * head of this list is stored in the Thread Information Block, which itself
+ * is pointed to from the FS register. It's the first field in the structure,
+ * or offset 0, so we can access it using assembly FS:0, or the compiler
+ * intrinsics and field offset information from the headers (as we do below).
+ * Somewhat unusually, the tail of the list doesn't have prev == NULL, it has
+ * prev == 0xFFFFFFFF.
+ *
+ * SEH was designed for C, and traditionally uses the MSVC compiler
+ * intrinsincs __try{}/__except{}. It is also utilized for C++ exceptions by
+ * MSVC; there, every throw of a C++ exception raises a SEH error with the
+ * ExceptionCode 0xE06D7363; the SEH handler list is then traversed to
+ * deal with the exception.
+ *
+ * If the SEH list is corrupt, then when a C++ exception is thrown the program
+ * will abruptly exit with exit code 1. This does not use std::terminate(), so
+ * std::set_terminate() is useless to debug this.
+ *
+ * The SEH list is closely tied to the call stack; entering a function that
+ * uses __try{} or most C++ functions will push a new handler onto the front
+ * of the list. Returning from the function will remove the handler. Saving
+ * and restoring the head node of the SEH list (FS:0) per-greenlet is NOT
+ * ENOUGH to make SEH or exceptions work.
+ *
+ * Stack switching breaks SEH because the call stack no longer necessarily
+ * matches the SEH list. For example, given greenlet A that switches to
+ * greenlet B, at the moment of entering greenlet B, we will have any SEH
+ * handlers from greenlet A on the SEH list; greenlet B can then add its own
+ * handlers to the SEH list. When greenlet B switches back to greenlet A,
+ * greenlet B's handlers would still be on the SEH stack, but when switch()
+ * returns control to greenlet A, we have replaced the contents of the stack
+ * in memory, so all the address that greenlet B added to the SEH list are now
+ * invalid: part of the call stack has been unwound, but the SEH list was out
+ * of sync with the call stack. The net effect is that exception handling
+ * stops working.
+ *
+ * Thus, when switching greenlets, we need to be sure that the SEH list
+ * matches the effective call stack, "cutting out" any handlers that were
+ * pushed by the greenlet that switched out and which are no longer valid.
+ *
+ * The easiest way to do this is to capture the SEH list at the time the main
+ * greenlet for a thread is created, and, when initially starting a greenlet,
+ * start a new SEH list for it, which contains nothing but the handler
+ * established for the new greenlet itself, with the tail being the handlers
+ * for the main greenlet. If we then save and restore the SEH per-greenlet,
+ * they won't interfere with each others SEH lists. (No greenlet can unwind
+ * the call stack past the handlers established by the main greenlet).
+ *
+ * By observation, a new thread starts with three SEH handlers on the list. By
+ * the time we get around to creating the main greenlet, though, there can be
+ * many more, established by transient calls that lead to the creation of the
+ * main greenlet. Therefore, 3 is a magic constant telling us when to perform
+ * the initial slice.
+ *
+ * All of this can be debugged using a vectored exception handler, which
+ * operates independently of the SEH handler list, and is called first.
+ * Walking the SEH list at key points can also be helpful.
+ *
+ * References:
+ * https://en.wikipedia.org/wiki/Win32_Thread_Information_Block
+ * https://devblogs.microsoft.com/oldnewthing/20100730-00/?p=13273
+ * https://docs.microsoft.com/en-us/cpp/cpp/try-except-statement?view=msvc-160
+ * https://docs.microsoft.com/en-us/cpp/cpp/structured-exception-handling-c-cpp?view=msvc-160
+ * https://docs.microsoft.com/en-us/windows/win32/debug/structured-exception-handling
+ * https://docs.microsoft.com/en-us/windows/win32/debug/using-a-vectored-exception-handler
+ * https://bytepointer.com/resources/pietrek_crash_course_depths_of_win32_seh.htm
+ */
+#define GREENLET_NEEDS_EXCEPTION_STATE_SAVED
+
+
+typedef struct _GExceptionRegistration {
+    struct _GExceptionRegistration* prev;
+    void* handler_f;
+} GExceptionRegistration;
+
+static void
+slp_set_exception_state(const void *const seh_state)
+{
+    // Because the stack from from which we do this is ALSO a handler, and
+    // that one we want to keep, we need to relink the current SEH handler
+    // frame to point to this one, cutting out the middle men, as it were.
+    //
+    // Entering a try block doesn't change the SEH frame, but entering a
+    // function containing a try block does.
+    GExceptionRegistration* current_seh_state = (GExceptionRegistration*)__readfsdword(FIELD_OFFSET(NT_TIB, ExceptionList));
+    current_seh_state->prev = (GExceptionRegistration*)seh_state;
+}
+
+
+static GExceptionRegistration*
+x86_slp_get_third_oldest_handler()
+{
+    GExceptionRegistration* a = NULL; /* Closest to the top */
+    GExceptionRegistration* b = NULL; /* second */
+    GExceptionRegistration* c = NULL;
+    GExceptionRegistration* seh_state = (GExceptionRegistration*)__readfsdword(FIELD_OFFSET(NT_TIB, ExceptionList));
+    a = b = c = seh_state;
+
+    while (seh_state && seh_state != (GExceptionRegistration*)0xFFFFFFFF) {
+        if ((void*)seh_state->prev < (void*)100) {
+            fprintf(stderr, "\tERROR: Broken SEH chain.\n");
+            return NULL;
+        }
+        a = b;
+        b = c;
+        c = seh_state;
+
+        seh_state = seh_state->prev;
+    }
+    return a ? a : (b ? b : c);
+}
+
+
+static void*
+slp_get_exception_state()
+{
+    // XXX: There appear to be three SEH handlers on the stack already at the
+    // start of the thread. Is that a guarantee? Almost certainly not. Yet in
+    // all observed cases it has been three. This is consistent with
+    // faulthandler off or on, and optimizations off or on. It may not be
+    // consistent with other operating system versions, though: we only have
+    // CI on one or two versions (don't ask what there are).
+    // In theory we could capture the number of handlers on the chain when
+    // PyInit__greenlet is called: there are probably only the default
+    // handlers at that point (unless we're embedded and people have used
+    // __try/__except or a C++ handler)?
+    return x86_slp_get_third_oldest_handler();
+}
 
 static int
 slp_switch(void)
 {
-    void* seh;
-    register int *stackref, stsizediff;
-    __asm mov eax, fs:0
-    __asm mov seh, eax
+    /* MASM syntax is typically reversed from other assemblers.
+       It is usually <instruction> <destination> <source>
+     */
+    int *stackref, stsizediff;
+    /* store the structured exception state for this stack */
+    DWORD seh_state = __readfsdword(FIELD_OFFSET(NT_TIB, ExceptionList));
     __asm mov stackref, esp;
     /* modify EBX, ESI and EDI in order to get them preserved */
     __asm mov ebx, ebx;
@@ -56,14 +205,15 @@
         }
         SLP_RESTORE_STATE();
     }
-    __asm mov eax, seh
-    __asm mov fs:0, eax
+    __writefsdword(FIELD_OFFSET(NT_TIB, ExceptionList), seh_state);
     return 0;
 }
 
 /* re-enable ebp warning and global optimizations. */
-#pragma optimize("g", on)
+#pragma optimize("", on)
 #pragma warning(default:4731)
+#pragma warning(default:4733) /* disable warning about modifying FS0 */
+
 
 #endif
 
@@ -74,8 +224,8 @@
 /* we have IsBadReadPtr available, so we can peek at objects */
 #define STACKLESS_SPY
 
-#ifdef IMPLEMENT_STACKLESSMODULE
-#include "Windows.h"
+#ifdef GREENLET_DEBUG
+
 #define CANNOT_READ_MEM(p, bytes) IsBadReadPtr(p, bytes)
 
 static int IS_ON_STACK(void*p)
@@ -83,6 +233,94 @@
     int stackref;
     int stackbase = ((int)&stackref) & 0xfffff000;
     return (int)p >= stackbase && (int)p < stackbase + 0x00100000;
-} 
+}
+
+static void
+x86_slp_show_seh_chain()
+{
+    GExceptionRegistration* seh_state = (GExceptionRegistration*)__readfsdword(FIELD_OFFSET(NT_TIB, ExceptionList));
+    fprintf(stderr, "====== SEH Chain ======\n");
+    while (seh_state && seh_state != (GExceptionRegistration*)0xFFFFFFFF) {
+        fprintf(stderr, "\tSEH_chain addr: %p handler: %p prev: %p\n",
+                seh_state,
+                seh_state->handler_f, seh_state->prev);
+        if ((void*)seh_state->prev < (void*)100) {
+            fprintf(stderr, "\tERROR: Broken chain.\n");
+            break;
+        }
+        seh_state = seh_state->prev;
+    }
+    fprintf(stderr, "====== End SEH Chain ======\n");
+    fflush(NULL);
+    return;
+}
+
+//addVectoredExceptionHandler constants:
+//CALL_FIRST means call this exception handler first;
+//CALL_LAST means call this exception handler last
+#define CALL_FIRST 1
+#define CALL_LAST 0
+
+LONG WINAPI
+GreenletVectorHandler(PEXCEPTION_POINTERS ExceptionInfo)
+{
+    // We get one of these for every C++ exception, with code
+    // E06D7363
+    // This is a special value that means "C++ exception from MSVC"
+    // https://devblogs.microsoft.com/oldnewthing/20100730-00/?p=13273
+    //
+    // Install in the module init function with:
+    // AddVectoredExceptionHandler(CALL_FIRST, GreenletVectorHandler);
+    PEXCEPTION_RECORD ExceptionRecord = ExceptionInfo->ExceptionRecord;
+
+    fprintf(stderr,
+            "GOT VECTORED EXCEPTION:\n"
+            "\tExceptionCode   : %p\n"
+            "\tExceptionFlags  : %p\n"
+            "\tExceptionAddr   : %p\n"
+            "\tNumberparams    : %ld\n",
+            ExceptionRecord->ExceptionCode,
+            ExceptionRecord->ExceptionFlags,
+            ExceptionRecord->ExceptionAddress,
+            ExceptionRecord->NumberParameters
+            );
+    if (ExceptionRecord->ExceptionFlags & 1) {
+        fprintf(stderr,  "\t\tEH_NONCONTINUABLE\n" );
+    }
+    if (ExceptionRecord->ExceptionFlags & 2) {
+        fprintf(stderr,  "\t\tEH_UNWINDING\n" );
+    }
+    if (ExceptionRecord->ExceptionFlags & 4) {
+        fprintf(stderr, "\t\tEH_EXIT_UNWIND\n" );
+    }
+    if (ExceptionRecord->ExceptionFlags & 8) {
+        fprintf(stderr,  "\t\tEH_STACK_INVALID\n" );
+    }
+    if (ExceptionRecord->ExceptionFlags & 0x10) {
+        fprintf(stderr,  "\t\tEH_NESTED_CALL\n" );
+    }
+    if (ExceptionRecord->ExceptionFlags & 0x20) {
+        fprintf(stderr,  "\t\tEH_TARGET_UNWIND\n" );
+    }
+    if (ExceptionRecord->ExceptionFlags & 0x40) {
+        fprintf(stderr,  "\t\tEH_COLLIDED_UNWIND\n" );
+    }
+    fprintf(stderr, "\n");
+    fflush(NULL);
+    for(DWORD i = 0; i < ExceptionRecord->NumberParameters; i++) {
+        fprintf(stderr, "\t\t\tParam %ld: %lX\n", i, ExceptionRecord->ExceptionInformationi);
+    }
+
+    if (ExceptionRecord->NumberParameters == 3) {
+        fprintf(stderr, "\tAbout to traverse SEH chain\n");
+        // C++ Exception records have 3 params.
+        x86_slp_show_seh_chain();
+    }
+
+    return EXCEPTION_CONTINUE_SEARCH;
+}
+
+
+
 
 #endif

_service:tar_scm:greenlet-1.1.2.tar.gz/src/greenlet/slp_platformselect.h -> _service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/slp_platformselect.h Changed

_service:tar_scm:greenlet-1.1.2.tar.gz/src/greenlet/tests/__init__.py -> _service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/tests/__init__.py Changed

@@ -0,0 +1,135 @@
+# -*- coding: utf-8 -*-
+"""
+Tests for greenlet.
+
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import unittest
+
+from gc import collect
+from gc import get_objects
+from threading import active_count as active_thread_count
+from time import sleep
+from time import time
+
+from greenlet import greenlet as RawGreenlet
+from greenlet import getcurrent
+
+from greenlet._greenlet import get_pending_cleanup_count
+from greenlet._greenlet import get_total_main_greenlets
+
+from . import leakcheck
+
+
+class TestCaseMetaClass(type):
+    # wrap each test method with
+    # a) leak checks
+    def __new__(cls, classname, bases, classDict):
+        # pylint and pep8 fight over what this should be called (mcs or cls).
+        # pylint gets it right, but we can't scope disable pep8, so we go with
+        # its convention.
+        # pylint: disable=bad-mcs-classmethod-argument
+        check_totalrefcount = True
+
+        # Python 3: must copy, we mutate the classDict. Interestingly enough,
+        # it doesn't actually error out, but under 3.6 we wind up wrapping
+        # and re-wrapping the same items over and over and over.
+        for key, value in list(classDict.items()):
+            if key.startswith('test') and callable(value):
+                classDict.pop(key)
+                if check_totalrefcount:
+                    value = leakcheck.wrap_refcount(value)
+                classDictkey = value
+        return type.__new__(cls, classname, bases, classDict)
+
+
+class TestCase(TestCaseMetaClass(
+        "NewBase",
+        (unittest.TestCase,),
+        {})):
+
+    cleanup_attempt_sleep_duration = 0.001
+    cleanup_max_sleep_seconds = 1
+
+    def wait_for_pending_cleanups(self,
+                                  initial_active_threads=None,
+                                  initial_main_greenlets=None):
+        initial_active_threads = initial_active_threads or self.threads_before_test
+        initial_main_greenlets = initial_main_greenlets or self.main_greenlets_before_test
+        sleep_time = self.cleanup_attempt_sleep_duration
+        # NOTE: This is racy! A Python-level thread object may be dead
+        # and gone, but the C thread may not yet have fired its
+        # destructors and added to the queue. There's no particular
+        # way to know that's about to happen. We try to watch the
+        # Python threads to make sure they, at least, have gone away.
+        # Counting the main greenlets, which we can easily do deterministically,
+        # also helps.
+
+        # Always sleep at least once to let other threads run
+        sleep(sleep_time)
+        quit_after = time() + self.cleanup_max_sleep_seconds
+        # TODO: We could add an API that calls us back when a particular main greenlet is deleted?
+        # It would have to drop the GIL
+        while (
+                get_pending_cleanup_count()
+                or active_thread_count() > initial_active_threads
+                or (not self.expect_greenlet_leak
+                    and get_total_main_greenlets() > initial_main_greenlets)):
+            sleep(sleep_time)
+            if time() > quit_after:
+                print("Time limit exceeded.")
+                print("Threads: Waiting for only", initial_active_threads,
+                      "-->", active_thread_count())
+                print("MGlets : Waiting for only", initial_main_greenlets,
+                      "-->", get_total_main_greenlets())
+                break
+        collect()
+
+    def count_objects(self, kind=list, exact_kind=True):
+        # pylint:disable=unidiomatic-typecheck
+        # Collect the garbage.
+        for _ in range(3):
+            collect()
+        if exact_kind:
+            return sum(
+                1
+                for x in get_objects()
+                if type(x) is kind
+            )
+        # instances
+        return sum(
+            1
+            for x in get_objects()
+            if isinstance(x, kind)
+        )
+
+    greenlets_before_test = 0
+    threads_before_test = 0
+    main_greenlets_before_test = 0
+    expect_greenlet_leak = False
+
+    def count_greenlets(self):
+        """
+        Find all the greenlets and subclasses tracked by the GC.
+        """
+        return self.count_objects(RawGreenlet, False)
+
+    def setUp(self):
+        # Ensure the main greenlet exists, otherwise the first test
+        # gets a false positive leak
+        super(TestCase, self).setUp()
+        getcurrent()
+        self.threads_before_test = active_thread_count()
+        self.main_greenlets_before_test = get_total_main_greenlets()
+        self.wait_for_pending_cleanups(self.threads_before_test, self.main_greenlets_before_test)
+        self.greenlets_before_test = self.count_greenlets()
+
+    def tearDown(self):
+        if getattr(self, 'skipTearDown', False):
+            return
+
+        self.wait_for_pending_cleanups(self.threads_before_test, self.main_greenlets_before_test)
+        super(TestCase, self).tearDown()

_service:tar_scm:greenlet-1.1.2.tar.gz/src/greenlet/tests/_test_extension.c -> _service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/tests/_test_extension.c Changed

@@ -107,6 +107,7 @@
     }
 
     result = PyGreenlet_Switch(greenlet, NULL, NULL);
+    Py_CLEAR(greenlet);
     if (result == NULL) {
         return NULL;
     }
@@ -136,6 +137,28 @@
     PyObject* msg_obj = Py_BuildValue("s", msg);
     PyGreenlet_Throw(g, PyExc_ValueError, msg_obj, NULL);
     Py_DECREF(msg_obj);
+    if (PyErr_Occurred()) {
+        return NULL;
+    }
+    Py_RETURN_NONE;
+}
+
+static PyObject*
+test_throw_exact(PyObject* self, PyObject* args)
+{
+    PyGreenlet* g = NULL;
+    PyObject* typ = NULL;
+    PyObject* val = NULL;
+    PyObject* tb = NULL;
+
+    if (!PyArg_ParseTuple(args, "OOOO:throw", &g, &typ, &val, &tb)) {
+        return NULL;
+    }
+
+    PyGreenlet_Throw(g, typ, val, tb);
+    if (PyErr_Occurred()) {
+        return NULL;
+    }
     Py_RETURN_NONE;
 }
 
@@ -173,7 +196,12 @@
      (PyCFunction)test_throw,
      METH_O,
      "Throw a ValueError at the provided greenlet"},
-    {NULL, NULL, 0, NULL}};
+    {"test_throw_exact",
+     (PyCFunction)test_throw_exact,
+     METH_VARARGS,
+     "Throw exactly the arguments given at the provided greenlet"},
+    {NULL, NULL, 0, NULL}
+};
 
 #if PY_MAJOR_VERSION >= 3
 #    define INITERROR return NULL

_service:tar_scm:greenlet-1.1.2.tar.gz/src/greenlet/tests/_test_extension_cpp.cpp -> _service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/tests/_test_extension_cpp.cpp Changed

@@ -3,6 +3,7 @@
  */
 
 #include "../greenlet.h"
+#include "../greenlet_compiler_compat.hpp"
 
 struct exception_t {
     int depth;
@@ -32,12 +33,15 @@
         return NULL;
 
     try {
-        PyGreenlet_Switch(self->parent, NULL, NULL);
+        if (PyGreenlet_Switch(PyGreenlet_GET_PARENT(self), NULL, NULL) == NULL) {
+            Py_DECREF(self);
+            return NULL;
+        }
         p_test_exception_throw(depth);
         PyErr_SetString(PyExc_RuntimeError,
                         "throwing C++ exception didn't work");
     }
-    catch (exception_t& e) {
+    catch (const exception_t& e) {
         if (e.depth != depth)
             PyErr_SetString(PyExc_AssertionError, "depth mismatch");
         else
@@ -58,7 +62,7 @@
  * - verifies depth matches (exceptions shouldn't be caught in other greenlets)
  */
 static PyObject*
-test_exception_switch(PyObject* self, PyObject* args)
+test_exception_switch(PyObject* UNUSED(self), PyObject* args)
 {
     int depth;
     if (!PyArg_ParseTuple(args, "i", &depth))
@@ -66,12 +70,83 @@
     return p_test_exception_switch_recurse(depth, depth);
 }
 
+
+static PyObject*
+py_test_exception_throw(PyObject* self, PyObject* args)
+{
+    if (!PyArg_ParseTuple(args, ""))
+        return NULL;
+    p_test_exception_throw(0);
+    PyErr_SetString(PyExc_AssertionError, "unreachable code running after throw");
+    return NULL;
+}
+
+
+/* test_exception_switch_and_do_in_g2(g2func)
+ * - creates new greenlet g2 to run g2func
+ * - switches to g2 inside try/catch block
+ * - verifies that no exception has been caught
+ *
+ * it is used together with test_exception_throw to verify that unhandled
+ * exceptions thrown in one greenlet do not propagate to other greenlet nor
+ * segfault the process.
+ */
+static PyObject*
+test_exception_switch_and_do_in_g2(PyObject* self, PyObject* args)
+{
+    PyObject* g2func = NULL;
+    PyObject* result = NULL;
+
+    if (!PyArg_ParseTuple(args, "O", &g2func))
+        return NULL;
+    PyGreenlet* g2 = PyGreenlet_New(g2func, NULL);
+    if (!g2) {
+        return NULL;
+    }
+
+    try {
+        result = PyGreenlet_Switch(g2, NULL, NULL);
+        if (!result) {
+            return NULL;
+        }
+    }
+    catch (const exception_t& e) {
+        /* if we are here the memory can be already corrupted and the program
+         * might crash before below py-level exception might become printed.
+         * -> print something to stderr to make it clear that we had entered
+         *    this catch block.
+         * See comments in inner_bootstrap()
+         */
+#if defined(WIN32) || defined(_WIN32)
+        fprintf(stderr, "C++ exception unexpectedly caught in g1\n");
+        PyErr_SetString(PyExc_AssertionError, "C++ exception unexpectedly caught in g1");
+        Py_XDECREF(result);
+        return NULL;
+#else
+        throw;
+#endif
+    }
+
+    Py_XDECREF(result);
+    Py_RETURN_NONE;
+}
+
 static PyMethodDef test_methods = {
     {"test_exception_switch",
      (PyCFunction)&test_exception_switch,
      METH_VARARGS,
      "Switches to parent twice, to test exception handling and greenlet "
      "switching."},
+    {"test_exception_switch_and_do_in_g2",
+     (PyCFunction)&test_exception_switch_and_do_in_g2,
+     METH_VARARGS,
+     "Creates new greenlet g2 to run g2func and switches to it inside try/catch "
+     "block. Used together with test_exception_throw to verify that unhandled "
+     "C++ exceptions thrown in a greenlet doe not corrupt memory."},
+    {"test_exception_throw",
+     (PyCFunction)&py_test_exception_throw,
+     METH_VARARGS,
+     "Throws C++ exception. Calling this function directly should abort the process."},
     {NULL, NULL, 0, NULL}};
 
 #if PY_MAJOR_VERSION >= 3

_service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/tests/leakcheck.py Added

@@ -0,0 +1,318 @@
+# Copyright (c) 2018 gevent community
+# Copyright (c) 2021 greenlet community
+#
+# This was originally part of gevent's test suite. The main author
+# (Jason Madden) vendored a copy of it into greenlet.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+from __future__ import print_function
+
+import os
+import sys
+import gc
+
+from functools import wraps
+import unittest
+
+
+import objgraph
+
+# graphviz 0.18 (Nov 7 2021), available only on Python 3.6 and newer,
+# has added type hints (sigh). It wants to use ``typing.Literal`` for
+# some stuff, but that's only available on Python 3.9+. If that's not
+# found, it creates a ``unittest.mock.MagicMock`` object and annotates
+# with that. These are GC'able objects, and doing almost *anything*
+# with them results in an explosion of objects. For example, trying to
+# compare them for equality creates new objects. This causes our
+# leakchecks to fail, with reports like:
+#
+# greenlet.tests.leakcheck.LeakCheckError: refcount increased by 337, 1333, 343, 430, 530, 643, 769
+# _Call          1820      +546
+# dict           4094       +76
+# MagicProxy      585       +73
+# tuple          2693       +66
+# _CallList        24        +3
+# weakref        1441        +1
+# function       5996        +1
+# type            736        +1
+# cell            592        +1
+# MagicMock         8        +1
+#
+# To avoid this, we *could* filter this type of object out early. In
+# principle it could leak, but we don't use mocks in greenlet, so it
+# doesn't leak from us. However, a further issue is that ``MagicMock``
+# objects have subobjects that are also GC'able, like ``_Call``, and
+# those create new mocks of their own too. So we'd have to filter them
+# as well, and they're not public. That's OK, we can workaround the
+# problem by being very careful to never compare by equality or other
+# user-defined operators, only using object identity or other builtin
+# functions.
+
+RUNNING_ON_GITHUB_ACTIONS = os.environ.get('GITHUB_ACTIONS')
+RUNNING_ON_TRAVIS = os.environ.get('TRAVIS') or RUNNING_ON_GITHUB_ACTIONS
+RUNNING_ON_APPVEYOR = os.environ.get('APPVEYOR')
+RUNNING_ON_CI = RUNNING_ON_TRAVIS or RUNNING_ON_APPVEYOR
+RUNNING_ON_MANYLINUX = os.environ.get('GREENLET_MANYLINUX')
+SKIP_LEAKCHECKS = RUNNING_ON_MANYLINUX or os.environ.get('GREENLET_SKIP_LEAKCHECKS')
+SKIP_FAILING_LEAKCHECKS = os.environ.get('GREENLET_SKIP_FAILING_LEAKCHECKS')
+ONLY_FAILING_LEAKCHECKS = os.environ.get('GREENLET_ONLY_FAILING_LEAKCHECKS')
+
+def ignores_leakcheck(func):
+    """
+    Ignore the given object during leakchecks.
+
+    Can be applied to a method, in which case the method will run, but
+    will not be subject to leak checks.
+
+    If applied to a class, the entire class will be skipped during leakchecks. This
+    is intended to be used for classes that are very slow and cause problems such as
+    test timeouts; typically it will be used for classes that are subclasses of a base
+    class and specify variants of behaviour (such as pool sizes).
+    """
+    func.ignore_leakcheck = True
+    return func
+
+def fails_leakcheck(func):
+    """
+    Mark that the function is known to leak.
+    """
+    func.fails_leakcheck = True
+    if SKIP_FAILING_LEAKCHECKS:
+        func = unittest.skip("Skipping known failures")(func)
+    return func
+
+class LeakCheckError(AssertionError):
+    pass
+
+if hasattr(sys, 'getobjects'):
+    # In a Python build with ``--with-trace-refs``, make objgraph
+    # trace *all* the objects, not just those that are tracked by the
+    # GC
+    class _MockGC(object):
+        def get_objects(self):
+            return sys.getobjects(0) # pylint:disable=no-member
+        def __getattr__(self, name):
+            return getattr(gc, name)
+    objgraph.gc = _MockGC()
+    fails_strict_leakcheck = fails_leakcheck
+else:
+    def fails_strict_leakcheck(func):
+        """
+        Decorator for a function that is known to fail when running
+        strict (``sys.getobjects()``) leakchecks.
+
+        This type of leakcheck finds all objects, even those, such as
+        strings, which are not tracked by the garbage collector.
+        """
+        return func
+
+class ignores_types_in_strict_leakcheck(object):
+    def __init__(self, types):
+        self.types = types
+    def __call__(self, func):
+        func.leakcheck_ignore_types = self.types
+        return func
+
+class _RefCountChecker(object):
+
+    # Some builtin things that we ignore
+    # XXX: Those things were ignored by gevent, but they're important here,
+    # presumably.
+    IGNORED_TYPES = () #(tuple, dict, types.FrameType, types.TracebackType)
+
+    def __init__(self, testcase, function):
+        self.testcase = testcase
+        self.function = function
+        self.deltas = 
+        self.peak_stats = {}
+        self.ignored_types = ()
+
+        # The very first time we are called, we have already been
+        # self.setUp() by the test runner, so we don't need to do it again.
+        self.needs_setUp = False
+
+    def _include_object_p(self, obj):
+        # pylint:disable=too-many-return-statements
+        #
+        # See the comment block at the top. We must be careful to
+        # avoid invoking user-defined operations.
+        if obj is self:
+            return False
+        kind = type(obj)
+        # ``self._include_object_p == obj`` returns NotImplemented
+        # for non-function objects, which causes the interpreter
+        # to try to reverse the order of arguments...which leads
+        # to the explosion of mock objects. We don't want that, so we implement
+        # the check manually.
+        if kind == type(self._include_object_p):
+            try:
+                # pylint:disable=not-callable
+                exact_method_equals = self._include_object_p.__eq__(obj)
+            except AttributeError:
+                # Python 2.7 methods may only have __cmp__, and that raises a
+                # TypeError for non-method arguments
+                # pylint:disable=no-member
+                exact_method_equals = self._include_object_p.__cmp__(obj) == 0
+
+            if exact_method_equals is not NotImplemented and exact_method_equals:
+                return False
+
+        # Similarly, we need to check identity in our __dict__ to avoid mock explosions.
+        for x in self.__dict__.values():
+            if obj is x:
+                return False
+
+
+        if kind in self.ignored_types or kind in self.IGNORED_TYPES:
+            return False
+
+        return True
+
+    def _growth(self):
+        return objgraph.growth(limit=None, peak_stats=self.peak_stats,
+                               filter=self._include_object_p)
+
+    def _report_diff(self, growth):
+        if not growth:
+            return "<Unable to calculate growth>"
+
+        lines = 
+        width = max(len(name) for name, _, _ in growth)
+        for name, count, delta in growth:
+            lines.append('%-*s%9d %+9d' % (width, name, count, delta))
+
+        diff = '\n'.join(lines)
+        return diff
+
+
+    def _run_test(self, args, kwargs):
+        gc_enabled = gc.isenabled()
+        gc.disable()
+
+        if self.needs_setUp:
+            self.testcase.setUp()
+            self.testcase.skipTearDown = False
+        try:
+            self.function(self.testcase, *args, **kwargs)
+        finally:
+            self.testcase.tearDown()
+            self.testcase.doCleanups()
+            self.testcase.skipTearDown = True
+            self.needs_setUp = True
+            if gc_enabled:
+                gc.enable()
+
+    def _growth_after(self):
+        # Grab post snapshot
+        if 'urlparse' in sys.modules:
+            sys.modules'urlparse'.clear_cache()
+        if 'urllib.parse' in sys.modules:
+            sys.modules'urllib.parse'.clear_cache()
+
+        return self._growth()
+
+    def _check_deltas(self, growth):
+        # Return false when we have decided there is no leak,
+        # true if we should keep looping, raises an assertion
+        # if we have decided there is a leak.
+
+        deltas = self.deltas
+        if not deltas:
+            # We haven't run yet, no data, keep looping
+            return True
+
+        if gc.garbage:
+            raise LeakCheckError("Generated uncollectable garbage %r" % (gc.garbage,))
+
+
+        # the following configurations are classified as "no leak"
+        # 0, 0
+        # x, 0, 0
+        # ... a, b, c, d  where a+b+c+d = 0
+        #
+        # the following configurations are classified as "leak"
+        # ... z, z, z  where z > 0
+
+        if deltas-2: == 0, 0 and len(deltas) in (2, 3):
+            return False
+
+        if deltas-3: == 0, 0, 0:
+            return False
+
+        if len(deltas) >= 4 and sum(deltas-4:) == 0:
+            return False
+
+        if len(deltas) >= 3 and deltas-1 > 0 and deltas-1 == deltas-2 and deltas-2 == deltas-3:
+            diff = self._report_diff(growth)
+            raise LeakCheckError('refcount increased by %r\n%s' % (deltas, diff))
+
+        # OK, we don't know for sure yet. Let's search for more
+        if sum(deltas-3:) <= 0 or sum(deltas-4:) <= 0 or deltas-4:.count(0) >= 2:
+            # this is suspicious, so give a few more runs
+            limit = 11
+        else:
+            limit = 7
+        if len(deltas) >= limit:
+            raise LeakCheckError('refcount increased by %r\n%s'
+                                 % (deltas,
+                                    self._report_diff(growth)))
+
+        # We couldn't decide yet, keep going
+        return True
+
+    def __call__(self, args, kwargs):
+        for _ in range(3):
+            gc.collect()
+
+        expect_failure = getattr(self.function, 'fails_leakcheck', False)
+        if expect_failure:
+            self.testcase.expect_greenlet_leak = True
+        self.ignored_types = getattr(self.function, "leakcheck_ignore_types", ())
+
+        # Capture state before; the incremental will be
+        # updated by each call to _growth_after
+        growth = self._growth()
+
+        try:
+            while self._check_deltas(growth):
+                self._run_test(args, kwargs)
+
+                growth = self._growth_after()
+
+                self.deltas.append(sum((stat2 for stat in growth)))
+        except LeakCheckError:
+            if not expect_failure:
+                raise
+        else:
+            if expect_failure:
+                raise LeakCheckError("Expected %s to leak but it did not." % (self.function,))
+
+def wrap_refcount(method):
+    if getattr(method, 'ignore_leakcheck', False) or SKIP_LEAKCHECKS:
+        return method
+
+    @wraps(method)
+    def wrapper(self, *args, **kwargs): # pylint:disable=too-many-branches
+        if getattr(self, 'ignore_leakcheck', False):
+            raise unittest.SkipTest("This class ignored during leakchecks")
+        if ONLY_FAILING_LEAKCHECKS and not getattr(method, 'fails_leakcheck', False):
+            raise unittest.SkipTest("Only running tests that fail leakchecks.")
+        return _RefCountChecker(self, method)(args, kwargs)
+
+    return wrapper

_service:tar_scm:greenlet-1.1.2.tar.gz/src/greenlet/tests/test_contextvars.py -> _service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/tests/test_contextvars.py Changed

@@ -1,27 +1,41 @@
-import unittest
+from __future__ import print_function
+
 import gc
 import sys
 
 from functools import partial
+from unittest import skipUnless
+from unittest import skipIf
 
 from greenlet import greenlet
 from greenlet import getcurrent
+from . import TestCase
 
 
 try:
     from contextvars import Context
     from contextvars import ContextVar
     from contextvars import copy_context
+    # From the documentation:
+    #
+    # Important: Context Variables should be created at the top module
+    # level and never in closures. Context objects hold strong
+    # references to context variables which prevents context variables
+    # from being properly garbage collected.
+    ID_VAR = ContextVar("id", default=None)
+    VAR_VAR = ContextVar("var", default=None)
+    ContextVar = None
 except ImportError:
     Context = ContextVar = copy_context = None
 
 # We don't support testing if greenlet's built-in context var support is disabled.
-@unittest.skipUnless(Context is not None, "ContextVar not supported")
-class ContextVarsTests(unittest.TestCase):
+@skipUnless(Context is not None, "ContextVar not supported")
+class ContextVarsTests(TestCase):
     def _new_ctx_run(self, *args, **kwargs):
         return copy_context().run(*args, **kwargs)
 
-    def _increment(self, greenlet_id, ctx_var, callback, counts, expect):
+    def _increment(self, greenlet_id, callback, counts, expect):
+        ctx_var = ID_VAR
         if expect is None:
             self.assertIsNone(ctx_var.get())
         else:
@@ -32,8 +46,7 @@
             callback()
 
     def _test_context(self, propagate_by):
-        id_var = ContextVar("id", default=None)
-        id_var.set(0)
+        ID_VAR.set(0)
 
         callback = getcurrent().switch
         counts = dict((i, 0) for i in range(5))
@@ -45,7 +58,6 @@
                     self._increment
                 ) if propagate_by == "run" else self._increment,
                 greenlet_id=i,
-                ctx_var=id_var,
                 callback=callback,
                 counts=counts,
                 expect=(
@@ -63,7 +75,7 @@
                 let.gr_context = getcurrent().gr_context
 
         for i in range(2):
-            countsid_var.get() += 1
+            countsID_VAR.get() += 1
             for let in lets:
                 let.switch()
 
@@ -82,7 +94,11 @@
             # and there's no context "underneath". When not using run(),
             # gr_context still reflects the context the greenlet was
             # running in.
-            self.assertEqual(let.gr_context is None, propagate_by == "run")
+            if propagate_by == 'run':
+                self.assertIsNone(let.gr_context)
+            else:
+                self.assertIsNotNone(let.gr_context)
+
 
         if propagate_by == "share":
             self.assertEqual(counts, {0: 1, 1: 1, 2: 1, 3: 1, 4: 6})
@@ -122,60 +138,61 @@
         let2.switch()
 
     def test_context_assignment_while_running(self):
-        id_var = ContextVar("id", default=None)
+        # pylint:disable=too-many-statements
+        ID_VAR.set(None)
 
         def target():
-            self.assertIsNone(id_var.get())
+            self.assertIsNone(ID_VAR.get())
             self.assertIsNone(gr.gr_context)
 
             # Context is created on first use
-            id_var.set(1)
+            ID_VAR.set(1)
             self.assertIsInstance(gr.gr_context, Context)
-            self.assertEqual(id_var.get(), 1)
-            self.assertEqual(gr.gr_contextid_var, 1)
+            self.assertEqual(ID_VAR.get(), 1)
+            self.assertEqual(gr.gr_contextID_VAR, 1)
 
             # Clearing the context makes it get re-created as another
             # empty context when next used
             old_context = gr.gr_context
             gr.gr_context = None  # assign None while running
-            self.assertIsNone(id_var.get())
+            self.assertIsNone(ID_VAR.get())
             self.assertIsNone(gr.gr_context)
-            id_var.set(2)
+            ID_VAR.set(2)
             self.assertIsInstance(gr.gr_context, Context)
-            self.assertEqual(id_var.get(), 2)
-            self.assertEqual(gr.gr_contextid_var, 2)
+            self.assertEqual(ID_VAR.get(), 2)
+            self.assertEqual(gr.gr_contextID_VAR, 2)
 
             new_context = gr.gr_context
             getcurrent().parent.switch((old_context, new_context))
             # parent switches us back to old_context
 
-            self.assertEqual(id_var.get(), 1)
+            self.assertEqual(ID_VAR.get(), 1)
             gr.gr_context = new_context  # assign non-None while running
-            self.assertEqual(id_var.get(), 2)
+            self.assertEqual(ID_VAR.get(), 2)
 
             getcurrent().parent.switch()
             # parent switches us back to no context
-            self.assertIsNone(id_var.get())
+            self.assertIsNone(ID_VAR.get())
             self.assertIsNone(gr.gr_context)
             gr.gr_context = old_context
-            self.assertEqual(id_var.get(), 1)
+            self.assertEqual(ID_VAR.get(), 1)
 
             getcurrent().parent.switch()
             # parent switches us back to no context
-            self.assertIsNone(id_var.get())
+            self.assertIsNone(ID_VAR.get())
             self.assertIsNone(gr.gr_context)
 
         gr = greenlet(target)
 
-        with self.assertRaisesRegex(AttributeError, "can't delete attr"):
+        with self.assertRaisesRegex(AttributeError, "can't delete context attribute"):
             del gr.gr_context
 
         self.assertIsNone(gr.gr_context)
         old_context, new_context = gr.switch()
         self.assertIs(new_context, gr.gr_context)
-        self.assertEqual(old_contextid_var, 1)
-        self.assertEqual(new_contextid_var, 2)
-        self.assertEqual(new_context.run(id_var.get), 2)
+        self.assertEqual(old_contextID_VAR, 1)
+        self.assertEqual(new_contextID_VAR, 2)
+        self.assertEqual(new_context.run(ID_VAR.get), 2)
         gr.gr_context = old_context  # assign non-None while suspended
         gr.switch()
         self.assertIs(gr.gr_context, new_context)
@@ -194,9 +211,9 @@
 
     def test_context_assignment_different_thread(self):
         import threading
-
+        VAR_VAR.set(None)
         ctx = Context()
-        var = ContextVar("var", default=None)
+
         is_running = threading.Event()
         should_suspend = threading.Event()
         did_suspend = threading.Event()
@@ -204,12 +221,12 @@
         holder = 
 
         def greenlet_in_thread_fn():
-            var.set(1)
+            VAR_VAR.set(1)
             is_running.set()
-            should_suspend.wait()
-            var.set(2)
+            should_suspend.wait(10)
+            VAR_VAR.set(2)
             getcurrent().parent.switch()
-            holder.append(var.get())
+            holder.append(VAR_VAR.get())
 
         def thread_fn():
             gr = greenlet(greenlet_in_thread_fn)
@@ -217,12 +234,14 @@
             holder.append(gr)
             gr.switch()
             did_suspend.set()
-            should_exit.wait()
+            should_exit.wait(10)
             gr.switch()
+            del gr
+            greenlet() # trigger cleanup
 
         thread = threading.Thread(target=thread_fn, daemon=True)
         thread.start()
-        is_running.wait()
+        is_running.wait(10)
         gr = holder0
 
         # Can't access or modify context if the greenlet is running
@@ -233,15 +252,15 @@
             gr.gr_context = None
 
         should_suspend.set()
-        did_suspend.wait()
+        did_suspend.wait(10)
 
         # OK to access and modify context if greenlet is suspended
         self.assertIs(gr.gr_context, ctx)
-        self.assertEqual(gr.gr_contextvar, 2)
+        self.assertEqual(gr.gr_contextVAR_VAR, 2)
         gr.gr_context = None
 
         should_exit.set()
-        thread.join()
+        thread.join(10)
 
         self.assertEqual(holder, gr, None)
 
@@ -250,17 +269,36 @@
         gr.gr_context = ctx
         self.assertIs(gr.gr_context, ctx)
 
-@unittest.skipIf(Context is not None, "ContextVar supported")
-class NoContextVarsTests(unittest.TestCase):
+        # Otherwise we leak greenlets on some platforms.
+        # XXX: Should be able to do this automatically
+        del holder:
+        gr = None
+        thread = None
+
+    def test_context_assignment_wrong_type(self):
+        g = greenlet()
+        with self.assertRaisesRegex(TypeError,
+                                    "greenlet context must be a contextvars.Context or None"):
+            g.gr_context = self
+
+
+@skipIf(Context is not None, "ContextVar supported")
+class NoContextVarsTests(TestCase):
     def test_contextvars_errors(self):
         let1 = greenlet(getcurrent().switch)
         self.assertFalse(hasattr(let1, 'gr_context'))
         with self.assertRaises(AttributeError):
             getattr(let1, 'gr_context')
+
         with self.assertRaises(AttributeError):
             let1.gr_context = None
+
         let1.switch()
+
         with self.assertRaises(AttributeError):
             getattr(let1, 'gr_context')
+
         with self.assertRaises(AttributeError):
             let1.gr_context = None
+
+        del let1

_service:tar_scm:greenlet-1.1.2.tar.gz/src/greenlet/tests/test_cpp.py -> _service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/tests/test_cpp.py Changed

@@ -1,13 +1,26 @@
 from __future__ import print_function
 from __future__ import absolute_import
 
-import unittest
+import signal
+from multiprocessing import Process
 
 import greenlet
 from . import _test_extension_cpp
+from . import TestCase
 
+def run_unhandled_exception_in_greenlet_aborts():
+    # This is used in multiprocessing.Process and must be picklable
+    # so it needs to be global.
 
-class CPPTests(unittest.TestCase):
+
+    def _():
+        _test_extension_cpp.test_exception_switch_and_do_in_g2(
+            _test_extension_cpp.test_exception_throw
+        )
+    g1 = greenlet.greenlet(_)
+    g1.switch()
+
+class CPPTests(TestCase):
     def test_exception_switch(self):
         greenlets = 
         for i in range(4):
@@ -16,3 +29,52 @@
             greenlets.append(g)
         for i, g in enumerate(greenlets):
             self.assertEqual(g.switch(), i)
+
+    def _do_test_unhandled_exception(self, target):
+        # TODO: On some versions of Python with some settings, this
+        # spews a lot of garbage to stderr. It would be nice to capture and ignore that.
+        import sys
+        WIN = sys.platform.startswith("win")
+
+        p = Process(target=target)
+        p.start()
+        p.join(10)
+        # The child should be aborted in an unusual way. On POSIX
+        # platforms, this is done with abort() and signal.SIGABRT,
+        # which is reflected in a negative return value; however, on
+        # Windows, even though we observe the child print "Fatal
+        # Python error: Aborted" and in older versions of the C
+        # runtime "This application has requested the Runtime to
+        # terminate it in an unusual way," it always has an exit code
+        # of 3. This is interesting because 3 is the error code for
+        # ERROR_PATH_NOT_FOUND; BUT: the C runtime abort() function
+        # also uses this code.
+        #
+        # See
+        # https://devblogs.microsoft.com/oldnewthing/20110519-00/?p=10623
+        # and
+        # https://docs.microsoft.com/en-us/previous-versions/k089yyh0(v=vs.140)?redirectedfrom=MSDN
+        expected_exit = (
+            -signal.SIGABRT,
+            # But beginning on Python 3.11, the faulthandler
+            # that prints the C backtraces sometimes segfaults after
+            # reporting the exception but before printing the stack.
+            # This has only been seen on linux/gcc.
+            -signal.SIGSEGV
+        ) if not WIN else (
+            3,
+        )
+        self.assertIn(p.exitcode, expected_exit)
+
+    def test_unhandled_exception_aborts(self):
+        # verify that plain unhandled throw aborts
+        self._do_test_unhandled_exception(_test_extension_cpp.test_exception_throw)
+
+
+    def test_unhandled_exception_in_greenlet_aborts(self):
+        # verify that unhandled throw called in greenlet aborts too
+        self._do_test_unhandled_exception(run_unhandled_exception_in_greenlet_aborts)
+
+
+if __name__ == '__main__':
+    __import__('unittest').main()

_service:tar_scm:greenlet-1.1.2.tar.gz/src/greenlet/tests/test_extension_interface.py -> _service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/tests/test_extension_interface.py Changed

@@ -2,24 +2,26 @@
 from __future__ import absolute_import
 
 import sys
-import unittest
 
 import greenlet
 from . import _test_extension
+from . import TestCase
 
+# pylint:disable=c-extension-no-member
 
-class CAPITests(unittest.TestCase):
+class CAPITests(TestCase):
     def test_switch(self):
         self.assertEqual(
             50, _test_extension.test_switch(greenlet.greenlet(lambda: 50)))
 
     def test_switch_kwargs(self):
-        def foo(x, y):
+        def adder(x, y):
             return x * y
-        g = greenlet.greenlet(foo)
+        g = greenlet.greenlet(adder)
         self.assertEqual(6, _test_extension.test_switch_kwargs(g, x=3, y=2))
 
     def test_setparent(self):
+        # pylint:disable=disallowed-name
         def foo():
             def bar():
                 greenlet.getcurrent().parent.switch()
@@ -54,7 +56,7 @@
     def test_throw(self):
         seen = 
 
-        def foo():
+        def foo():         # pylint:disable=disallowed-name
             try:
                 greenlet.getcurrent().parent.switch()
             except ValueError:
@@ -73,5 +75,41 @@
             'take that sucka!',
             "message doesn't match")
 
+    def test_non_traceback_param(self):
+        with self.assertRaises(TypeError) as exc:
+            _test_extension.test_throw_exact(
+                greenlet.getcurrent(),
+                Exception,
+                Exception(),
+                self
+            )
+        self.assertEqual(str(exc.exception),
+                         "throw() third argument must be a traceback object")
+
+    def test_instance_of_wrong_type(self):
+        with self.assertRaises(TypeError) as exc:
+            _test_extension.test_throw_exact(
+                greenlet.getcurrent(),
+                Exception(),
+                BaseException(),
+                None,
+            )
+
+        self.assertEqual(str(exc.exception),
+                         "instance exception may not have a separate value")
+
+    def test_not_throwable(self):
+        with self.assertRaises(TypeError) as exc:
+            _test_extension.test_throw_exact(
+                greenlet.getcurrent(),
+                "abc",
+                None,
+                None,
+            )
+        self.assertEqual(str(exc.exception),
+                         "exceptions must be classes, or instances, not str")
+
+
 if __name__ == '__main__':
+    import unittest
     unittest.main()

_service:tar_scm:greenlet-1.1.2.tar.gz/src/greenlet/tests/test_gc.py -> _service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/tests/test_gc.py Changed

@@ -1,77 +1,86 @@
 import gc
-import sys
-import unittest
+
 import weakref
 
 import greenlet
 
 
-class GCTests(unittest.TestCase):
+from . import TestCase
+from .leakcheck import fails_leakcheck
+# These only work with greenlet gc support
+# which is no longer optional.
+assert greenlet.GREENLET_USE_GC
+
+class GCTests(TestCase):
     def test_dead_circular_ref(self):
         o = weakref.ref(greenlet.greenlet(greenlet.getcurrent).switch())
         gc.collect()
-        self.assertTrue(o() is None)
+        if o() is not None:
+            import sys
+            print("O IS NOT NONE.", sys.getrefcount(o()))
+        self.assertIsNone(o())
         self.assertFalse(gc.garbage, gc.garbage)
 
-    if greenlet.GREENLET_USE_GC:
-        # These only work with greenlet gc support
+    def test_circular_greenlet(self):
+        class circular_greenlet(greenlet.greenlet):
+            pass
+        o = circular_greenlet()
+        o.self = o
+        o = weakref.ref(o)
+        gc.collect()
+        self.assertIsNone(o())
+        self.assertFalse(gc.garbage, gc.garbage)
 
-        def test_circular_greenlet(self):
-            class circular_greenlet(greenlet.greenlet):
-                pass
-            o = circular_greenlet()
-            o.self = o
-            o = weakref.ref(o)
-            gc.collect()
-            self.assertTrue(o() is None)
-            self.assertFalse(gc.garbage, gc.garbage)
+    def test_inactive_ref(self):
+        class inactive_greenlet(greenlet.greenlet):
+            def __init__(self):
+                greenlet.greenlet.__init__(self, run=self.run)
 
-        def test_inactive_ref(self):
-            class inactive_greenlet(greenlet.greenlet):
-                def __init__(self):
-                    greenlet.greenlet.__init__(self, run=self.run)
+            def run(self):
+                pass
+        o = inactive_greenlet()
+        o = weakref.ref(o)
+        gc.collect()
+        self.assertIsNone(o())
+        self.assertFalse(gc.garbage, gc.garbage)
 
-                def run(self):
-                    pass
-            o = inactive_greenlet()
-            o = weakref.ref(o)
-            gc.collect()
-            self.assertTrue(o() is None)
-            self.assertFalse(gc.garbage, gc.garbage)
+    @fails_leakcheck
+    def test_finalizer_crash(self):
+        # This test is designed to crash when active greenlets
+        # are made garbage collectable, until the underlying
+        # problem is resolved. How does it work:
+        # - order of object creation is important
+        # - array is created first, so it is moved to unreachable first
+        # - we create a cycle between a greenlet and this array
+        # - we create an object that participates in gc, is only
+        #   referenced by a greenlet, and would corrupt gc lists
+        #   on destruction, the easiest is to use an object with
+        #   a finalizer
+        # - because array is the first object in unreachable it is
+        #   cleared first, which causes all references to greenlet
+        #   to disappear and causes greenlet to be destroyed, but since
+        #   it is still live it causes a switch during gc, which causes
+        #   an object with finalizer to be destroyed, which causes stack
+        #   corruption and then a crash
 
-        def test_finalizer_crash(self):
-            # This test is designed to crash when active greenlets
-            # are made garbage collectable, until the underlying
-            # problem is resolved. How does it work:
-            # - order of object creation is important
-            # - array is created first, so it is moved to unreachable first
-            # - we create a cycle between a greenlet and this array
-            # - we create an object that participates in gc, is only
-            #   referenced by a greenlet, and would corrupt gc lists
-            #   on destruction, the easiest is to use an object with
-            #   a finalizer
-            # - because array is the first object in unreachable it is
-            #   cleared first, which causes all references to greenlet
-            #   to disappear and causes greenlet to be destroyed, but since
-            #   it is still live it causes a switch during gc, which causes
-            #   an object with finalizer to be destroyed, which causes stack
-            #   corruption and then a crash
-            class object_with_finalizer(object):
-                def __del__(self):
-                    pass
-            array = 
-            parent = greenlet.getcurrent()
-            def greenlet_body():
-                greenlet.getcurrent().object = object_with_finalizer()
-                try:
-                    parent.switch()
-                finally:
-                    del greenlet.getcurrent().object
-            g = greenlet.greenlet(greenlet_body)
-            g.array = array
-            array.append(g)
-            g.switch()
-            del array
-            del g
-            greenlet.getcurrent()
-            gc.collect()
+        class object_with_finalizer(object):
+            def __del__(self):
+                pass
+        array = 
+        parent = greenlet.getcurrent()
+        def greenlet_body():
+            greenlet.getcurrent().object = object_with_finalizer()
+            try:
+                parent.switch()
+            except greenlet.GreenletExit:
+                print("Got greenlet exit!")
+            finally:
+                del greenlet.getcurrent().object
+        g = greenlet.greenlet(greenlet_body)
+        g.array = array
+        array.append(g)
+        g.switch()
+        del array
+        del g
+        greenlet.getcurrent()
+        gc.collect()

_service:tar_scm:greenlet-1.1.2.tar.gz/src/greenlet/tests/test_generator.py -> _service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/tests/test_generator.py Changed

@@ -1,9 +1,10 @@
-import unittest
+
 from greenlet import greenlet
 
+from . import TestCase
 
 class genlet(greenlet):
-
+    parent = None
     def __init__(self, *args, **kwds):
         self.args = args
         self.kwds = kwds
@@ -20,10 +21,9 @@
         result = self.switch()
         if self:
             return result
-        else:
-            raise StopIteration
 
-    # Hack: Python < 2.6 compatibility
+        raise StopIteration
+
     next = __next__
 
 
@@ -37,14 +37,14 @@
 
 
 def generator(func):
-    class generator(genlet):
+    class Generator(genlet):
         fn = (func,)
-    return generator
+    return Generator
 
 # ____________________________________________________________
 
 
-class GeneratorTests(unittest.TestCase):
+class GeneratorTests(TestCase):
     def test_generator(self):
         seen = 
 
@@ -53,7 +53,7 @@
                 seen.append(i)
                 Yield(i)
         g = generator(g)
-        for k in range(3):
+        for _ in range(3):
             for j in g(5):
                 seen.append(j)
         self.assertEqual(seen, 3 * 0, 0, 1, 1, 2, 2, 3, 3, 4, 4)

_service:tar_scm:greenlet-1.1.2.tar.gz/src/greenlet/tests/test_generator_nested.py -> _service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/tests/test_generator_nested.py Changed

@@ -1,15 +1,18 @@
-import unittest
-from greenlet import greenlet
 
+from greenlet import greenlet
+from . import TestCase
+from .leakcheck import fails_leakcheck
 
 class genlet(greenlet):
-
+    parent = None
     def __init__(self, *args, **kwds):
         self.args = args
         self.kwds = kwds
         self.child = None
 
     def run(self):
+        # Note the function is packed in a tuple
+        # to avoid creating a bound method for it.
         fn, = self.fn
         fn(*self.args, **self.kwds)
 
@@ -34,12 +37,10 @@
 
         if self:
             return result
-        else:
-            raise StopIteration
 
-    # Hack: Python < 2.6 compatibility
-    next = __next__
+        raise StopIteration
 
+    next = __next__
 
 def Yield(value, level=1):
     g = greenlet.getcurrent()
@@ -56,9 +57,9 @@
 
 
 def Genlet(func):
-    class Genlet(genlet):
+    class TheGenlet(genlet):
         fn = (func,)
-    return Genlet
+    return TheGenlet
 
 # ____________________________________________________________
 
@@ -101,7 +102,8 @@
     if len(l) > 1:
         for e in l:
             # No syntactical sugar for generator expressions
-            Yield(e + p) for p in perms(x for x in l if x != e)
+            x = Yield(e + p) for p in perms(x for x in l if x != e)
+            assert x
     else:
         Yield(l)
 perms = Genlet(perms)
@@ -122,19 +124,20 @@
 gr2 = Genlet(gr2)
 
 
-class NestedGeneratorTests(unittest.TestCase):
+class NestedGeneratorTests(TestCase):
     def test_layered_genlets(self):
         seen = 
         for ii in gr2(5, seen):
             seen.append(ii)
         self.assertEqual(seen, 1, 1, 2, 4, 3, 9, 4, 16)
 
+    @fails_leakcheck
     def test_permutations(self):
         gen_perms = perms(list(range(4)))
         permutations = list(gen_perms)
         self.assertEqual(len(permutations), 4 * 3 * 2 * 1)
-        self.assertTrue(0, 1, 2, 3 in permutations)
-        self.assertTrue(3, 2, 1, 0 in permutations)
+        self.assertIn(0, 1, 2, 3, permutations)
+        self.assertIn(3, 2, 1, 0, permutations)
         res = 
         for ii in zip(perms(list(range(4))), perms(list(range(3)))):
             res.append(ii)
@@ -148,7 +151,7 @@
     def test_genlet_simple(self):
         for g in g1, g2, g3:
             seen = 
-            for k in range(3):
+            for _ in range(3):
                 for j in g(5, seen):
                     seen.append(j)
             self.assertEqual(seen, 3 * 1, 0, 2, 1, 3, 2, 4, 3, 5, 4)

_service:tar_scm:greenlet-1.1.2.tar.gz/src/greenlet/tests/test_greenlet.py -> _service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/tests/test_greenlet.py Changed

@@ -1,14 +1,22 @@
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
 import gc
 import sys
 import time
 import threading
-import unittest
+
 from abc import ABCMeta, abstractmethod
 
 from greenlet import greenlet
+from . import TestCase
+from .leakcheck import fails_leakcheck
+
 
 # We manually manage locks in many tests
 # pylint:disable=consider-using-with
+# pylint:disable=too-many-public-methods
 
 class SomeError(Exception):
     pass
@@ -25,15 +33,16 @@
 
 def send_exception(g, exc):
     # note: send_exception(g, exc)  can be now done with  g.throw(exc).
-    # the purpose of this test is to explicitely check the propagation rules.
+    # the purpose of this test is to explicitly check the propagation rules.
     def crasher(exc):
         raise exc
     g1 = greenlet(crasher, parent=g)
     g1.switch(exc)
 
 
-class TestGreenlet(unittest.TestCase):
-    def test_simple(self):
+class TestGreenlet(TestCase):
+
+    def _do_simple_test(self):
         lst = 
 
         def f():
@@ -48,6 +57,23 @@
         lst.append(4)
         self.assertEqual(lst, list(range(5)))
 
+    def test_simple(self):
+        self._do_simple_test()
+
+    def test_switch_no_run_raises_AttributeError(self):
+        g = greenlet()
+        with self.assertRaises(AttributeError) as exc:
+            g.switch()
+
+        self.assertIn("run", str(exc.exception))
+
+    def test_throw_no_run_raises_AttributeError(self):
+        g = greenlet()
+        with self.assertRaises(AttributeError) as exc:
+            g.throw(SomeError)
+
+        self.assertIn("run", str(exc.exception))
+
     def test_parent_equals_None(self):
         g = greenlet(parent=None)
         self.assertIsNotNone(g)
@@ -82,30 +108,33 @@
         lst = 
 
         def f():
-            lst.append(1)
+            lst.append('b')
             greenlet.getcurrent().parent.switch()
 
         def g():
-            lst.append(1)
+            lst.append('a')
             g = greenlet(f)
             g.switch()
-            lst.append(1)
+            lst.append('c')
+
         g = greenlet(g)
+        self.assertEqual(sys.getrefcount(g), 2)
         g.switch()
-        self.assertEqual(len(lst), 3)
+        self.assertEqual(lst, 'a', 'b', 'c')
+        # Just the one in this frame, plus the one on the stack we pass to the function
         self.assertEqual(sys.getrefcount(g), 2)
 
     def test_threads(self):
         success = 
 
         def f():
-            self.test_simple()
+            self._do_simple_test()
             success.append(True)
         ths = threading.Thread(target=f) for i in range(10)
         for th in ths:
             th.start()
         for th in ths:
-            th.join()
+            th.join(10)
         self.assertEqual(len(success), len(ths))
 
     def test_exception(self):
@@ -115,12 +144,27 @@
         g1.switch(seen)
         g2.switch(seen)
         g2.parent = g1
+
         self.assertEqual(seen, )
+        #with self.assertRaises(SomeError):
+        #    p("***Switching back")
+        #    g2.switch()
+        # Creating this as a bound method can reveal bugs that
+        # are hidden on newer versions of Python that avoid creating
+        # bound methods for direct expressions; IOW, don't use the `with`
+        # form!
         self.assertRaises(SomeError, g2.switch)
         self.assertEqual(seen, SomeError)
-        g2.switch()
+
+        value = g2.switch()
+        self.assertEqual(value, ())
+        self.assertEqual(seen, SomeError)
+
+        value = g2.switch(25)
+        self.assertEqual(value, 25)
         self.assertEqual(seen, SomeError)
 
+
     def test_send_exception(self):
         seen = 
         g1 = greenlet(fmain)
@@ -142,13 +186,44 @@
         gc.collect()
         self.assertEqual(seen, greenlet.GreenletExit, greenlet.GreenletExit)
 
+    def test_dealloc_catches_GreenletExit_throws_other(self):
+        def run():
+            try:
+                greenlet.getcurrent().parent.switch()
+            except greenlet.GreenletExit:
+                raise SomeError
+
+        g = greenlet(run)
+        g.switch()
+        # Destroying the only reference to the greenlet causes it
+        # to get GreenletExit; when it in turn raises, even though we're the parent
+        # we don't get the exception, it just gets printed.
+        # When we run on 3.8 only, we can use sys.unraisablehook
+        oldstderr = sys.stderr
+        try:
+            from cStringIO import StringIO
+        except ImportError:
+            from io import StringIO
+        stderr = sys.stderr = StringIO()
+        try:
+            del g
+        finally:
+            sys.stderr = oldstderr
+
+        v = stderr.getvalue()
+        self.assertIn("Exception", v)
+        self.assertIn('ignored', v)
+        self.assertIn("SomeError", v)
+
+
     def test_dealloc_other_thread(self):
         seen = 
         someref = 
-        lock = threading.Lock()
-        lock.acquire()
-        lock2 = threading.Lock()
-        lock2.acquire()
+
+        bg_glet_created_running_and_no_longer_ref_in_bg = threading.Event()
+        fg_ref_released = threading.Event()
+        bg_should_be_clear = threading.Event()
+        ok_to_exit_bg_thread = threading.Event()
 
         def f():
             g1 = greenlet(fmain)
@@ -156,25 +231,34 @@
             someref.append(g1)
             del g1
             gc.collect()
-            lock.release()
-            lock2.acquire()
+
+            bg_glet_created_running_and_no_longer_ref_in_bg.set()
+            fg_ref_released.wait(3)
+
             greenlet()   # trigger release
-            lock.release()
-            lock2.acquire()
+            bg_should_be_clear.set()
+            ok_to_exit_bg_thread.wait(3)
+            greenlet() # One more time
+
         t = threading.Thread(target=f)
         t.start()
-        lock.acquire()
+        bg_glet_created_running_and_no_longer_ref_in_bg.wait(10)
+
         self.assertEqual(seen, )
         self.assertEqual(len(someref), 1)
         del someref:
         gc.collect()
         # g1 is not released immediately because it's from another thread
         self.assertEqual(seen, )
-        lock2.release()
-        lock.acquire()
-        self.assertEqual(seen, greenlet.GreenletExit)
-        lock2.release()
-        t.join()
+        fg_ref_released.set()
+        bg_should_be_clear.wait(3)
+        try:
+            self.assertEqual(seen, greenlet.GreenletExit)
+        finally:
+            ok_to_exit_bg_thread.set()
+            t.join(10)
+            del seen:
+            del someref:
 
     def test_frame(self):
         def f1():
@@ -200,8 +284,8 @@
         t2 = threading.Thread(target=runner, args=(0.3,))
         t1.start()
         t2.start()
-        t1.join()
-        t2.join()
+        t1.join(10)
+        t2.join(10)
 
     def test_switch_kwargs(self):
         def run(a, b):
@@ -223,24 +307,22 @@
 
     def test_switch_to_another_thread(self):
         data = {}
-        error = None
         created_event = threading.Event()
         done_event = threading.Event()
 
         def run():
             data'g' = greenlet(lambda: None)
             created_event.set()
-            done_event.wait()
+            done_event.wait(10)
         thread = threading.Thread(target=run)
         thread.start()
-        created_event.wait()
-        try:
+        created_event.wait(10)
+        with self.assertRaises(greenlet.error):
             data'g'.switch()
-        except greenlet.error:
-            error = sys.exc_info()1
-        self.assertIsNotNone(error, "greenlet.error was not raised!")
         done_event.set()
-        thread.join()
+        thread.join(10)
+        # XXX: Should handle this automatically
+        data.clear()
 
     def test_exc_state(self):
         def f():
@@ -273,30 +355,16 @@
         self.assertRaises(TypeError, deldict, g)
         self.assertRaises(TypeError, setdict, g, 42)
 
-    def test_threaded_reparent(self):
-        data = {}
-        created_event = threading.Event()
-        done_event = threading.Event()
-
-        def run():
-            data'g' = greenlet(lambda: None)
-            created_event.set()
-            done_event.wait()
-
-        def blank():
-            greenlet.getcurrent().parent.switch()
-
-        def setparent(g, value):
-            g.parent = value
+    def test_running_greenlet_has_no_run(self):
+        has_run = 
+        def func():
+            has_run.append(
+                hasattr(greenlet.getcurrent(), 'run')
+            )
 
-        thread = threading.Thread(target=run)
-        thread.start()
-        created_event.wait()
-        g = greenlet(blank)
+        g = greenlet(func)
         g.switch()
-        self.assertRaises(ValueError, setparent, g, data'g')
-        done_event.set()
-        thread.join()
+        self.assertEqual(has_run, False)
 
     def test_deepcopy(self):
         import copy
@@ -309,7 +377,7 @@
         result = 
         def worker():
             try:
-                # Wait to be killed
+                # Wait to be killed by going back to the test.
                 main.switch()
             except greenlet.GreenletExit:
                 # Resurrect and switch to parent
@@ -318,10 +386,17 @@
                 hub.switch()
         g = greenlet(worker, parent=hub)
         g.switch()
+        # delete the only reference, thereby raising GreenletExit
         del g
         self.assertTrue(result)
-        self.assertEqual(result0, main)
-        self.assertEqual(result1.parent, hub)
+        self.assertIs(result0, main)
+        self.assertIs(result1.parent, hub)
+        # Delete them, thereby breaking the cycle between the greenlet
+        # and the frame, which otherwise would never be collectable
+        # XXX: We should be able to automatically fix this.
+        del result:
+        hub = None
+        main = None
 
     def test_parent_return_failure(self):
         # No run causes AttributeError on switch
@@ -329,7 +404,8 @@
         # Greenlet that implicitly switches to parent
         g2 = greenlet(lambda: None, parent=g1)
         # AttributeError should propagate to us, no fatal errors
-        self.assertRaises(AttributeError, g2.switch)
+        with self.assertRaises(AttributeError):
+            g2.switch()
 
     def test_throw_exception_not_lost(self):
         class mygreenlet(greenlet):
@@ -342,19 +418,71 @@
         g = mygreenlet(lambda: None)
         self.assertRaises(SomeError, g.throw, SomeError())
 
-    def test_throw_doesnt_crash(self):
+    @fails_leakcheck
+    def _do_test_throw_to_dead_thread_doesnt_crash(self, wait_for_cleanup=False):
         result = 
         def worker():
             greenlet.getcurrent().parent.switch()
+
         def creator():
             g = greenlet(worker)
             g.switch()
             result.append(g)
+            if wait_for_cleanup:
+                # Let this greenlet eventually be cleaned up.
+                g.switch()
+                greenlet.getcurrent()
         t = threading.Thread(target=creator)
         t.start()
-        t.join()
-        self.assertRaises(greenlet.error, result0.throw, SomeError())
+        t.join(10)
+        del t
+        # But, depending on the operating system, the thread
+        # deallocator may not actually have run yet! So we can't be
+        # sure about the error message unless we wait.
+        if wait_for_cleanup:
+            self.wait_for_pending_cleanups()
+        with self.assertRaises(greenlet.error) as exc:
+            result0.throw(SomeError)
+
+        if not wait_for_cleanup:
+            self.assertIn(
+                str(exc.exception), 
+                    "cannot switch to a different thread (which happens to have exited)",
+                    "cannot switch to a different thread"
+                
+            )
+        else:
+            self.assertEqual(
+                str(exc.exception),
+                "cannot switch to a different thread (which happens to have exited)",
+            )
 
+        if hasattr(result0.gr_frame, 'clear'):
+            # The frame is actually executing (it thinks), we can't clear it.
+            with self.assertRaises(RuntimeError):
+                result0.gr_frame.clear()
+        # Unfortunately, this doesn't actually clear the references, they're in the
+        # fast local array.
+        if not wait_for_cleanup:
+            result0.gr_frame.f_locals.clear()
+        else:
+            self.assertIsNone(result0.gr_frame)
+
+        del creator
+        worker = None
+        del result:
+        # XXX: we ought to be able to automatically fix this.
+        # See issue 252
+        self.expect_greenlet_leak = True # direct us not to wait for it to go away
+
+    @fails_leakcheck
+    def test_throw_to_dead_thread_doesnt_crash(self):
+        self._do_test_throw_to_dead_thread_doesnt_crash()
+
+    def test_throw_to_dead_thread_doesnt_crash_wait(self):
+        self._do_test_throw_to_dead_thread_doesnt_crash(True)
+
+    @fails_leakcheck
     def test_recursive_startup(self):
         class convoluted(greenlet):
             def __init__(self):
@@ -370,23 +498,11 @@
                     self.parent.switch(value)
         g = convoluted()
         self.assertEqual(g.switch(42), 43)
-
-    def test_unexpected_reparenting(self):
-        another = 
-        def worker():
-            g = greenlet(lambda: None)
-            another.append(g)
-            g.switch()
-        t = threading.Thread(target=worker)
-        t.start()
-        t.join()
-        class convoluted(greenlet):
-            def __getattribute__(self, name):
-                if name == 'run':
-                    self.parent = another0 # pylint:disable=attribute-defined-outside-init
-                return greenlet.__getattribute__(self, name)
-        g = convoluted(lambda: None)
-        self.assertRaises(greenlet.error, g.switch)
+        # Exits the running greenlet, otherwise it leaks
+        # XXX: We should be able to automatically fix this
+        #g.throw(greenlet.GreenletExit)
+        #del g
+        self.expect_greenlet_leak = True
 
     def test_threaded_updatecurrent(self):
         # released when main thread should execute
@@ -433,7 +549,7 @@
         # to randomly crash if it's not anyway.
         self.assertEqual(greenlet.getcurrent(), main)
         # wait for another thread to complete, just in case
-        t.join()
+        t.join(10)
 
     def test_dealloc_switch_args_not_lost(self):
         seen = 
@@ -445,23 +561,37 @@
             initiator.parent = greenlet.getcurrent().parent
             # switch to main with the value, but because
             # ts_current is the last reference to us we
-            # return immediately
+            # return here immediately, where we resurrect ourself.
             try:
                 greenlet.getcurrent().parent.switch(value)
             finally:
                 seen.append(greenlet.getcurrent())
         def initiator():
             return 42 # implicitly falls thru to parent
+
         worker = greenlet(worker)
+
         worker0.switch() # prime worker
         initiator = greenlet(initiator, worker0)
         value = initiator.switch()
         self.assertTrue(seen)
         self.assertEqual(value, 42)
 
-
-
     def test_tuple_subclass(self):
+        # XXX: This is failing on Python 2 with a SystemError: error return without exception set
+
+        # The point of this test is to see what happens when a custom
+        # tuple subclass is used as an object passed directly to the C
+        # function ``green_switch``; part of ``green_switch`` checks
+        # the ``len()`` of the ``args`` tuple, and that can call back
+        # into Python. Here, when it calls back into Python, we
+        # recursively enter ``green_switch`` again.
+
+        # This test is really only relevant on Python 2. The builtin
+        # `apply` function directly passes the given args tuple object
+        # to the underlying function, whereas the Python 3 version
+        # unpacks and repacks into an actual tuple. This could still
+        # happen using the C API on Python 3 though.
         if sys.version_info0 > 2:
             # There's no apply in Python 3.x
             def _apply(func, a, k):
@@ -531,7 +661,7 @@
                 g = None # lose reference to garbage
                 if recycled0:
                     # gc callback called prematurely
-                    t.join()
+                    t.join(10)
                     return False
                 last = greenlet()
                 if recycled0:
@@ -541,7 +671,7 @@
                 # gc callback not called when expected
                 gc.collect()
                 if recycled0:
-                    t.join()
+                    t.join(10)
                 return False
             self.assertEqual(last.parent, current)
             for g in l:
@@ -609,7 +739,7 @@
             greenlet_running_event.set()
             # Wait for main to let us know the references are
             # gone and the greenlet objects no longer reachable
-            ref_cleared.wait()
+            ref_cleared.wait(10)
             # The creating thread must call getcurrent() (or a few other
             # greenlet APIs) because that's when the thread-local list of dead
             # greenlets gets cleared.
@@ -638,7 +768,7 @@
 
 
         for done_event in thread_ready_events:
-            done_event.wait()
+            done_event.wait(10)
 
 
         del glets:
@@ -646,11 +776,246 @@
         # Let any other thread run; it will crash the interpreter
         # if not fixed (or silently corrupt memory and we possibly crash
         # later).
-        time.sleep(1)
+        self.wait_for_pending_cleanups()
         self.assertEqual(sys.getrefcount(MyGreenlet), initial_refs)
 
+    def test_falling_off_end_switches_to_unstarted_parent_raises_error(self):
+        def no_args():
+            return 13
+
+        parent_never_started = greenlet(no_args)
+
+        def leaf():
+            return 42
+
+        child = greenlet(leaf, parent_never_started)
+
+        # Because the run function takes to arguments
+        with self.assertRaises(TypeError):
+            child.switch()
 
-class TestRepr(unittest.TestCase):
+    def test_falling_off_end_switches_to_unstarted_parent_works(self):
+        def one_arg(x):
+            return (x, 24)
+
+        parent_never_started = greenlet(one_arg)
+
+        def leaf():
+            return 42
+
+        child = greenlet(leaf, parent_never_started)
+
+        result = child.switch()
+        self.assertEqual(result, (42, 24))
+
+    def test_switch_to_dead_greenlet_with_unstarted_perverse_parent(self):
+        class Parent(greenlet):
+            def __getattribute__(self, name):
+                if name == 'run':
+                    raise SomeError
+
+
+        parent_never_started = Parent()
+        seen = 
+        child = greenlet(lambda: seen.append(42), parent_never_started)
+        # Because we automatically start the parent when the child is
+        # finished
+        with self.assertRaises(SomeError):
+            child.switch()
+
+        self.assertEqual(seen, 42)
+
+        with self.assertRaises(SomeError):
+            child.switch()
+        self.assertEqual(seen, 42)
+
+    def test_switch_to_dead_greenlet_reparent(self):
+        seen = 
+        parent_never_started = greenlet(lambda: seen.append(24))
+        child = greenlet(lambda: seen.append(42))
+
+        child.switch()
+        self.assertEqual(seen, 42)
+
+        child.parent = parent_never_started
+        # This actually is the same as switching to the parent.
+        result = child.switch()
+        self.assertIsNone(result)
+        self.assertEqual(seen, 42, 24)
+
+
+class TestGreenletSetParentErrors(TestCase):
+    def test_threaded_reparent(self):
+        data = {}
+        created_event = threading.Event()
+        done_event = threading.Event()
+
+        def run():
+            data'g' = greenlet(lambda: None)
+            created_event.set()
+            done_event.wait(10)
+
+        def blank():
+            greenlet.getcurrent().parent.switch()
+
+        thread = threading.Thread(target=run)
+        thread.start()
+        created_event.wait(10)
+        g = greenlet(blank)
+        g.switch()
+        with self.assertRaises(ValueError) as exc:
+            g.parent = data'g'
+        done_event.set()
+        thread.join(10)
+
+        self.assertEqual(str(exc.exception), "parent cannot be on a different thread")
+
+    def test_unexpected_reparenting(self):
+        another = 
+        def worker():
+            g = greenlet(lambda: None)
+            another.append(g)
+            g.switch()
+        t = threading.Thread(target=worker)
+        t.start()
+        t.join(10)
+        # The first time we switch (running g_initialstub(), which is
+        # when we look up the run attribute) we attempt to change the
+        # parent to one from another thread (which also happens to be
+        # dead). ``g_initialstub()`` should detect this and raise a
+        # greenlet error.
+        #
+        # EXCEPT: With the fix for #252, this is actually detected
+        # sooner, when setting the parent itself. Prior to that fix,
+        # the main greenlet from the background thread kept a valid
+        # value for ``run_info``, and appeared to be a valid parent
+        # until we actually started the greenlet. But now that it's
+        # cleared, this test is catching whether ``green_setparent``
+        # can detect the dead thread.
+        #
+        # Further refactoring once again changes this back to a greenlet.error
+        #
+        # We need to wait for the cleanup to happen, but we're
+        # deliberately leaking a main greenlet here.
+        self.wait_for_pending_cleanups(initial_main_greenlets=self.main_greenlets_before_test + 1)
+
+        class convoluted(greenlet):
+            def __getattribute__(self, name):
+                if name == 'run':
+                    self.parent = another0 # pylint:disable=attribute-defined-outside-init
+                return greenlet.__getattribute__(self, name)
+        g = convoluted(lambda: None)
+        with self.assertRaises(greenlet.error) as exc:
+            g.switch()
+        self.assertEqual(str(exc.exception),
+                         "cannot switch to a different thread (which happens to have exited)")
+        del another:
+
+    def test_unexpected_reparenting_thread_running(self):
+        # Like ``test_unexpected_reparenting``, except the background thread is
+        # actually still alive.
+        another = 
+        switched_to_greenlet = threading.Event()
+        keep_main_alive = threading.Event()
+        def worker():
+            g = greenlet(lambda: None)
+            another.append(g)
+            g.switch()
+            switched_to_greenlet.set()
+            keep_main_alive.wait(10)
+        class convoluted(greenlet):
+            def __getattribute__(self, name):
+                if name == 'run':
+                    self.parent = another0 # pylint:disable=attribute-defined-outside-init
+                return greenlet.__getattribute__(self, name)
+
+        t = threading.Thread(target=worker)
+        t.start()
+
+        switched_to_greenlet.wait(10)
+        try:
+            g = convoluted(lambda: None)
+
+            with self.assertRaises(greenlet.error) as exc:
+                g.switch()
+            self.assertEqual(str(exc.exception), "cannot switch to a different thread")
+        finally:
+            keep_main_alive.set()
+            t.join(10)
+            # XXX: Should handle this automatically.
+            del another:
+
+    def test_cannot_delete_parent(self):
+        worker = greenlet(lambda: None)
+        self.assertIs(worker.parent, greenlet.getcurrent())
+
+        with self.assertRaises(AttributeError) as exc:
+            del worker.parent
+        self.assertEqual(str(exc.exception), "can't delete attribute")
+
+    def test_cannot_delete_parent_of_main(self):
+        with self.assertRaises(AttributeError) as exc:
+            del greenlet.getcurrent().parent
+        self.assertEqual(str(exc.exception), "can't delete attribute")
+
+
+    def test_main_greenlet_parent_is_none(self):
+        # assuming we're in a main greenlet here.
+        self.assertIsNone(greenlet.getcurrent().parent)
+
+    def test_set_parent_wrong_types(self):
+        def bg():
+            # Go back to main.
+            greenlet.getcurrent().parent.switch()
+
+        def check(glet):
+            for p in None, 1, self, "42":
+                with self.assertRaises(TypeError) as exc:
+                    glet.parent = p
+
+                self.assertEqual(
+                    str(exc.exception),
+                    "GreenletChecker: Expected any type of greenlet, not " + type(p).__name__)
+
+        # First, not running
+        g = greenlet(bg)
+        self.assertFalse(g)
+        check(g)
+
+        # Then when running.
+        g.switch()
+        self.assertTrue(g)
+        check(g)
+
+        # Let it finish
+        g.switch()
+
+
+    def test_trivial_cycle(self):
+        glet = greenlet(lambda: None)
+        with self.assertRaises(ValueError) as exc:
+            glet.parent = glet
+        self.assertEqual(str(exc.exception), "cyclic parent chain")
+
+    def test_trivial_cycle_main(self):
+        # This used to produce a ValueError, but we catch it earlier than that now.
+        with self.assertRaises(AttributeError) as exc:
+            greenlet.getcurrent().parent = greenlet.getcurrent()
+        self.assertEqual(str(exc.exception), "cannot set the parent of a main greenlet")
+
+    def test_deeper_cycle(self):
+        g1 = greenlet(lambda: None)
+        g2 = greenlet(lambda: None)
+        g3 = greenlet(lambda: None)
+
+        g1.parent = g2
+        g2.parent = g3
+        with self.assertRaises(ValueError) as exc:
+            g3.parent = g1
+        self.assertEqual(str(exc.exception), "cyclic parent chain")
+
+
+class TestRepr(TestCase):
 
     def assertEndsWith(self, got, suffix):
         self.assertTrue(got.endswith(suffix), (got, suffix))
@@ -689,12 +1054,23 @@
 
         self.assertEndsWith(t.original_main, ' suspended active started main>')
         self.assertEndsWith(t.thread_main, ' current active started main>')
-
-        r = repr(t.main_glet)
-        # main greenlets, even from dead threads, never really appear dead
-        # TODO: Can we find a better way to differentiate that?
-        assert not t.main_glet.dead
-        self.assertEndsWith(r, ' suspended active started main>')
+        # give the machinery time to notice the death of the thread,
+        # and clean it up. Note that we don't use
+        # ``expect_greenlet_leak`` or wait_for_pending_cleanups,
+        # because at this point we know we have an extra greenlet
+        # still reachable.
+        for _ in range(3):
+            time.sleep(0.001)
+
+        # In the past, main greenlets, even from dead threads, never
+        # really appear dead. We have fixed that, and we also report
+        # that the thread is dead in the repr. (Do this multiple times
+        # to make sure that we don't self-modify and forget our state
+        # in the C++ code).
+        for _ in range(3):
+            self.assertTrue(t.main_glet.dead)
+            r = repr(t.main_glet)
+            self.assertEndsWith(r, ' (thread exited) dead>')
 
     def test_dead(self):
         g = greenlet(lambda: None)
@@ -724,5 +1100,27 @@
             )
 
 
+class TestMainGreenlet(TestCase):
+    # Tests some implementation details, and relies on some
+    # implementation details.
+
+    def _check_current_is_main(self):
+        # implementation detail
+        assert 'main' in repr(greenlet.getcurrent())
+
+        t = type(greenlet.getcurrent())
+        assert 'main' not in repr(t)
+        return t
+
+    def test_main_greenlet_type_can_be_subclassed(self):
+        main_type = self._check_current_is_main()
+        subclass = type('subclass', (main_type,), {})
+        self.assertIsNotNone(subclass)
+
+    def test_main_greenlet_is_greenlet(self):
+        self._check_current_is_main()
+        self.assertIsInstance(greenlet.getcurrent(), greenlet)
+
 if __name__ == '__main__':
+    import unittest
     unittest.main()

_service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/tests/test_greenlet_trash.py Added

@@ -0,0 +1,185 @@
+# -*- coding: utf-8 -*-
+"""
+Tests for greenlets interacting with the CPython trash can API.
+
+The CPython trash can API is not designed to be re-entered from a
+single thread. But this can happen using greenlets, if something
+during the object deallocation process switches greenlets, and this second
+greenlet then causes the trash can to get entered again. Here, we do this
+very explicitly, but in other cases (like gevent) it could be arbitrarily more
+complicated: for example, a weakref callback might try to acquire a lock that's
+already held by another greenlet; that would allow a greenlet switch to occur.
+
+See https://github.com/gevent/gevent/issues/1909
+
+This test is fragile and relies on details of the CPython
+implementation (like most of the rest of this package):
+
+    - We enter the trashcan and deferred deallocation after
+      ``_PyTrash_UNWIND_LEVEL`` calls. This constant, defined in
+      CPython's object.c, is generally 50. That's basically how many objects are required to
+      get us into the deferred deallocation situation.
+
+    - The test fails by hitting an ``assert()`` in object.c; if the
+      build didn't enable assert, then we don't catch this.
+
+    - If the test fails in that way, the interpreter crashes.
+"""
+from __future__ import print_function, absolute_import, division
+
+import sys
+import unittest
+
+
+
+class TestTrashCanReEnter(unittest.TestCase):
+
+    @unittest.skipUnless(
+        sys.version_info0 > 2,
+        "Python 2 tracks this slightly differently, so our test doesn't catch a problem there. "
+    )
+    def test_it(self):
+        # Try several times to trigger it, because it isn't 100%
+        # reliable.
+        for _ in range(10):
+            self.check_it()
+
+    def check_it(self): # pylint:disable=too-many-statements
+        import greenlet
+        from greenlet._greenlet import get_tstate_trash_delete_nesting # pylint:disable=no-name-in-module
+
+        main = greenlet.getcurrent()
+
+        assert get_tstate_trash_delete_nesting() == 0
+
+        # We expect to be in deferred deallocation after this many
+        # deallocations have occurred. TODO: I wish we had a better way to do
+        # this --- that was before get_tstate_trash_delete_nesting; perhaps
+        # we can use that API to do better?
+        TRASH_UNWIND_LEVEL = 50
+        # How many objects to put in a container; it's the container that
+        # queues objects for deferred deallocation.
+        OBJECTS_PER_CONTAINER = 500
+
+        class Dealloc: # define the class here because we alter class variables each time we run.
+            """
+            An object with a ``__del__`` method. When it starts getting deallocated
+            from a deferred trash can run, it switches greenlets, allocates more objects
+            which then also go in the trash can. If we don't save state appropriately,
+            nesting gets out of order and we can crash the interpreter.
+            """
+
+            #: Has our deallocation actually run and switched greenlets?
+            #: When it does, this will be set to the current greenlet. This should
+            #: be happening in the main greenlet, so we check that down below.
+            SPAWNED = False
+
+            #: Has the background greenlet run?
+            BG_RAN = False
+
+            BG_GLET = None
+
+            #: How many of these things have ever been allocated.
+            CREATED = 0
+
+            #: How many of these things have ever been deallocated.
+            DESTROYED = 0
+
+            #: How many were destroyed not in the main greenlet. There should always
+            #: be some.
+            #: If the test is broken or things change in the trashcan implementation,
+            #: this may not be correct.
+            DESTROYED_BG = 0
+
+            def __init__(self, sequence_number):
+                """
+                :param sequence_number: The ordinal of this object during
+                   one particular creation run. This is used to detect (guess, really)
+                   when we have entered the trash can's deferred deallocation.
+                """
+                self.i = sequence_number
+                Dealloc.CREATED += 1
+
+            def __del__(self):
+                if self.i == TRASH_UNWIND_LEVEL and not self.SPAWNED:
+                    Dealloc.SPAWNED = greenlet.getcurrent()
+                    other = Dealloc.BG_GLET = greenlet.greenlet(background_greenlet)
+                    x = other.switch()
+                    assert x == 42
+                    # It's important that we don't switch back to the greenlet,
+                    # we leave it hanging there in an incomplete state. But we don't let it
+                    # get collected, either. If we complete it now, while we're still
+                    # in the scope of the initial trash can, things work out and we
+                    # don't see the problem. We need this greenlet to complete
+                    # at some point in the future, after we've exited this trash can invocation.
+                    del other
+                elif self.i == 40 and greenlet.getcurrent() is not main:
+                    Dealloc.BG_RAN = True
+                    try:
+                        main.switch(42)
+                    except greenlet.GreenletExit as ex:
+                        # We expect this; all references to us go away
+                        # while we're still running, and we need to finish deleting
+                        # ourself.
+                        Dealloc.BG_RAN = type(ex)
+                        del ex
+
+                # Record the fact that we're dead last of all. This ensures that
+                # we actually get returned too.
+                Dealloc.DESTROYED += 1
+                if greenlet.getcurrent() is not main:
+                    Dealloc.DESTROYED_BG += 1
+
+
+        def background_greenlet():
+            # We direct through a second function, instead of
+            # directly calling ``make_some()``, so that we have complete
+            # control over when these objects are destroyed: we need them
+            # to be destroyed in the context of the background greenlet
+            t = make_some()
+            del t # Triggere deletion.
+
+        def make_some():
+            t = ()
+            i = OBJECTS_PER_CONTAINER
+            while i:
+                # Nest the tuples; it's the recursion that gets us
+                # into trash.
+                t = (Dealloc(i), t)
+                i -= 1
+            return t
+
+
+        some = make_some()
+        self.assertEqual(Dealloc.CREATED, OBJECTS_PER_CONTAINER)
+        self.assertEqual(Dealloc.DESTROYED, 0)
+
+        # If we're going to crash, it should be on the following line.
+        # We only crash if ``assert()`` is enabled, of course.
+        del some
+
+        # For non-debug builds of CPython, we won't crash. The best we can do is check
+        # the nesting level explicitly.
+        self.assertEqual(0, get_tstate_trash_delete_nesting())
+
+        # Discard this, raising GreenletExit into where it is waiting.
+        Dealloc.BG_GLET = None
+        # The same nesting level maintains.
+        self.assertEqual(0, get_tstate_trash_delete_nesting())
+
+        # We definitely cleaned some up in the background
+        self.assertGreater(Dealloc.DESTROYED_BG, 0)
+
+        # Make sure all the cleanups happened.
+        self.assertIs(Dealloc.SPAWNED, main)
+        self.assertTrue(Dealloc.BG_RAN)
+        self.assertEqual(Dealloc.BG_RAN, greenlet.GreenletExit)
+        self.assertEqual(Dealloc.CREATED, Dealloc.DESTROYED )
+        self.assertEqual(Dealloc.CREATED, OBJECTS_PER_CONTAINER * 2)
+
+        import gc
+        gc.collect()
+
+
+if __name__ == '__main__':
+    unittest.main()

_service:tar_scm:greenlet-1.1.2.tar.gz/src/greenlet/tests/test_leaks.py -> _service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/tests/test_leaks.py Changed

@@ -1,4 +1,9 @@
-import unittest
+# -*- coding: utf-8 -*-
+"""
+Testing scenarios that may have leaked.
+"""
+from __future__ import print_function, absolute_import, division
+
 import sys
 import gc
 
@@ -6,9 +11,40 @@
 import weakref
 import threading
 
+import psutil
+
 import greenlet
+from . import TestCase
+from .leakcheck import fails_leakcheck
+from .leakcheck import ignores_leakcheck
+from .leakcheck import RUNNING_ON_GITHUB_ACTIONS
+from .leakcheck import RUNNING_ON_MANYLINUX
+
+try:
+    from sys import intern
+except ImportError:
+    # Python 2
+    pass
+
+assert greenlet.GREENLET_USE_GC # Option to disable this was removed in 1.0
 
-class TestLeaks(unittest.TestCase):
+class HasFinalizerTracksInstances(object):
+    EXTANT_INSTANCES = set()
+    def __init__(self, msg):
+        self.msg = intern(msg)
+        self.EXTANT_INSTANCES.add(id(self))
+    def __del__(self):
+        self.EXTANT_INSTANCES.remove(id(self))
+    def __repr__(self):
+        return "<HasFinalizerTracksInstances at 0x%x %r>" % (
+            id(self), self.msg
+        )
+    @classmethod
+    def reset(cls):
+        cls.EXTANT_INSTANCES.clear()
+
+
+class TestLeaks(TestCase):
 
     def test_arg_refs(self):
         args = ('a', 'b', 'c')
@@ -29,9 +65,9 @@
             g.switch(**kwargs)
         self.assertEqual(sys.getrefcount(kwargs), 2)
 
-    assert greenlet.GREENLET_USE_GC # Option to disable this was removed in 1.0
 
-    def recycle_threads(self):
+    @staticmethod
+    def __recycle_threads():
         # By introducing a thread that does sleep we allow other threads,
         # that have triggered their __block condition, but did not have a
         # chance to deallocate their thread state yet, to finally do so.
@@ -43,7 +79,7 @@
         t = threading.Thread(target=worker)
         t.start()
         time.sleep(0.001)
-        t.join()
+        t.join(10)
 
     def test_threaded_leak(self):
         gg = 
@@ -53,10 +89,10 @@
         for _ in range(2):
             t = threading.Thread(target=worker)
             t.start()
-            t.join()
+            t.join(10)
             del t
         greenlet.getcurrent() # update ts_current
-        self.recycle_threads()
+        self.__recycle_threads()
         greenlet.getcurrent() # update ts_current
         gc.collect()
         greenlet.getcurrent() # update ts_current
@@ -76,59 +112,83 @@
         for _ in range(2):
             t = threading.Thread(target=worker)
             t.start()
-            t.join()
+            t.join(10)
             del t
         greenlet.getcurrent() # update ts_current
-        self.recycle_threads()
+        self.__recycle_threads()
         greenlet.getcurrent() # update ts_current
         gc.collect()
         greenlet.getcurrent() # update ts_current
         for g in gg:
             self.assertIsNone(g())
 
-    def test_issue251_killing_cross_thread_leaks_list(self, manually_collect_background=True):
+    def assertClocksUsed(self):
+        used = greenlet._greenlet.get_clocks_used_doing_optional_cleanup()
+        self.assertGreaterEqual(used, 0)
+        # we don't lose the value
+        greenlet._greenlet.enable_optional_cleanup(True)
+        used2 = greenlet._greenlet.get_clocks_used_doing_optional_cleanup()
+        self.assertEqual(used, used2)
+        self.assertGreater(greenlet._greenlet.CLOCKS_PER_SEC, 1)
+
+    def _check_issue251(self,
+                        manually_collect_background=True,
+                        explicit_reference_to_switch=False):
         # See https://github.com/python-greenlet/greenlet/issues/251
         # Killing a greenlet (probably not the main one)
         # in one thread from another thread would
         # result in leaking a list (the ts_delkey list).
+        # We no longer use lists to hold that stuff, though.
 
         # For the test to be valid, even empty lists have to be tracked by the
         # GC
-        assert gc.is_tracked()
 
-        def count_objects(kind=list):
-            # pylint:disable=unidiomatic-typecheck
-            # Collect the garbage.
-            for _ in range(3):
-                gc.collect()
-            gc.collect()
-            return sum(
-                1
-                for x in gc.get_objects()
-                if type(x) is kind
-            )
-
-        # XXX: The main greenlet of a dead thread is only released
-        # when one of the proper greenlet APIs is used from a different
-        # running thread. See #252 (https://github.com/python-greenlet/greenlet/issues/252)
+        assert gc.is_tracked()
+        HasFinalizerTracksInstances.reset()
         greenlet.getcurrent()
-        greenlets_before = count_objects(greenlet.greenlet)
+        greenlets_before = self.count_objects(greenlet.greenlet, exact_kind=False)
 
         background_glet_running = threading.Event()
         background_glet_killed = threading.Event()
         background_greenlets = 
+
+        # XXX: Switching this to a greenlet subclass that overrides
+        # run results in all callers failing the leaktest; that
+        # greenlet instance is leaked. There's a bound method for
+        # run() living on the stack of the greenlet in g_initialstub,
+        # and since we don't manually switch back to the background
+        # greenlet to let it "fall off the end" and exit the
+        # g_initialstub function, it never gets cleaned up. Making the
+        # garbage collector aware of this bound method (making it an
+        # attribute of the greenlet structure and traversing into it)
+        # doesn't help, for some reason.
         def background_greenlet():
             # Throw control back to the main greenlet.
-            greenlet.getcurrent().parent.switch()
+            jd = HasFinalizerTracksInstances("DELETING STACK OBJECT")
+            greenlet._greenlet.set_thread_local(
+                'test_leaks_key',
+                HasFinalizerTracksInstances("DELETING THREAD STATE"))
+            # Explicitly keeping 'switch' in a local variable
+            # breaks this test in all versions
+            if explicit_reference_to_switch:
+                s = greenlet.getcurrent().parent.switch
+                s(jd)
+            else:
+                greenlet.getcurrent().parent.switch(jd)
+
+        bg_main_wrefs = 
 
         def background_thread():
             glet = greenlet.greenlet(background_greenlet)
+            bg_main_wrefs.append(weakref.ref(glet.parent))
+
             background_greenlets.append(glet)
             glet.switch() # Be sure it's active.
             # Control is ours again.
             del glet # Delete one reference from the thread it runs in.
             background_glet_running.set()
-            background_glet_killed.wait()
+            background_glet_killed.wait(10)
+
             # To trigger the background collection of the dead
             # greenlet, thus clearing out the contents of the list, we
             # need to run some APIs. See issue 252.
@@ -138,9 +198,9 @@
 
         t = threading.Thread(target=background_thread)
         t.start()
-        background_glet_running.wait()
-
-        lists_before = count_objects()
+        background_glet_running.wait(10)
+        greenlet.getcurrent()
+        lists_before = self.count_objects(list, exact_kind=True)
 
         assert len(background_greenlets) == 1
         self.assertFalse(background_greenlets0.dead)
@@ -153,26 +213,236 @@
         # Now wait for the background thread to die.
         t.join(10)
         del t
+        # As part of the fix for 252, we need to cycle the ceval.c
+        # interpreter loop to be sure it has had a chance to process
+        # the pending call.
+        self.wait_for_pending_cleanups()
 
-        # Free the background main greenlet by forcing greenlet to notice a difference.
-        greenlet.getcurrent()
-        greenlets_after = count_objects(greenlet.greenlet)
+        lists_after = self.count_objects(list, exact_kind=True)
+        greenlets_after = self.count_objects(greenlet.greenlet, exact_kind=False)
 
-        lists_after = count_objects()
         # On 2.7, we observe that lists_after is smaller than
         # lists_before. No idea what lists got cleaned up. All the
         # Python 3 versions match exactly.
         self.assertLessEqual(lists_after, lists_before)
+        # On versions after 3.6, we've successfully cleaned up the
+        # greenlet references thanks to the internal "vectorcall"
+        # protocol; prior to that, there is a reference path through
+        # the ``greenlet.switch`` method still on the stack that we
+        # can't reach to clean up. The C code goes through terrific
+        # lengths to clean that up.
+        if not explicit_reference_to_switch and greenlet._greenlet.get_clocks_used_doing_optional_cleanup() is not None:
+            # If cleanup was disabled, though, we may not find it.
+            self.assertEqual(greenlets_after, greenlets_before)
+            if manually_collect_background:
+                # TODO: Figure out how to make this work!
+                # The one on the stack is still leaking somehow
+                # in the non-manually-collect state.
+                self.assertEqual(HasFinalizerTracksInstances.EXTANT_INSTANCES, set())
+        else:
+            # The explicit reference prevents us from collecting it
+            # and it isn't always found by the GC either for some
+            # reason. The entire frame is leaked somehow, on some
+            # platforms (e.g., MacPorts builds of Python (all
+            # versions!)), but not on other platforms (the linux and
+            # windows builds on GitHub actions and Appveyor). So we'd
+            # like to write a test that proves that the main greenlet
+            # sticks around, and we can on my machine (macOS 11.6,
+            # MacPorts builds of everything) but we can't write that
+            # same test on other platforms. However, hopefully iteration
+            # done by leakcheck will find it.
+            pass
+
+        if greenlet._greenlet.get_clocks_used_doing_optional_cleanup() is not None:
+            self.assertClocksUsed()
 
-        self.assertEqual(greenlets_before, greenlets_after)
+    def test_issue251_killing_cross_thread_leaks_list(self):
+        self._check_issue251()
 
-    @unittest.expectedFailure
+    def test_issue251_with_cleanup_disabled(self):
+        greenlet._greenlet.enable_optional_cleanup(False)
+        try:
+            self._check_issue251()
+        finally:
+            greenlet._greenlet.enable_optional_cleanup(True)
+
+    @fails_leakcheck
     def test_issue251_issue252_need_to_collect_in_background(self):
-        # This still fails because the leak of the list
-        # still exists when we don't call a greenlet API before exiting the
-        # thread. The proximate cause is that neither of the two greenlets
-        # from the background thread are actually being destroyed, even though
-        # the GC is in fact visiting both objects.
-        # It's not clear where that leak is? For some reason the thread-local dict
-        # holding it isn't being cleaned up.
-        self.test_issue251_killing_cross_thread_leaks_list(manually_collect_background=False)
+        # Between greenlet 1.1.2 and the next version, this was still
+        # failing because the leak of the list still exists when we
+        # don't call a greenlet API before exiting the thread. The
+        # proximate cause is that neither of the two greenlets from
+        # the background thread are actually being destroyed, even
+        # though the GC is in fact visiting both objects. It's not
+        # clear where that leak is? For some reason the thread-local
+        # dict holding it isn't being cleaned up.
+        #
+        # The leak, I think, is in the CPYthon internal function that
+        # calls into green_switch(). The argument tuple is still on
+        # the C stack somewhere and can't be reached? That doesn't
+        # make sense, because the tuple should be collectable when
+        # this object goes away.
+        #
+        # Note that this test sometimes spuriously passes on Linux,
+        # for some reason, but I've never seen it pass on macOS.
+        self._check_issue251(manually_collect_background=False)
+
+    @fails_leakcheck
+    def test_issue251_issue252_need_to_collect_in_background_cleanup_disabled(self):
+        self.expect_greenlet_leak = True
+        greenlet._greenlet.enable_optional_cleanup(False)
+        try:
+            self._check_issue251(manually_collect_background=False)
+        finally:
+            greenlet._greenlet.enable_optional_cleanup(True)
+
+    @fails_leakcheck
+    def test_issue251_issue252_explicit_reference_not_collectable(self):
+        self._check_issue251(
+            manually_collect_background=False,
+            explicit_reference_to_switch=True)
+
+    UNTRACK_ATTEMPTS = 100
+
+    def _only_test_some_versions(self):
+        # We're only looking for this problem specifically on 3.11,
+        # and this set of tests is relatively fragile, depending on
+        # OS and memory management details. So we want to run it on 3.11+
+        # (obviously) but not every older 3.x version in order to reduce
+        # false negatives.
+        if sys.version_info0 >= 3 and sys.version_info:2 < (3, 8):
+            self.skipTest('Only observed on 3.11')
+        if sys.version_info0 == 2 and RUNNING_ON_GITHUB_ACTIONS:
+            self.skipTest('Hard to get a stable pattern here')
+        if RUNNING_ON_MANYLINUX:
+            self.skipTest("Slow and not worth repeating here")
+
+    @ignores_leakcheck
+    # Because we're just trying to track raw memory, not objects, and running
+    # the leakcheck makes an already slow test slower.
+    def test_untracked_memory_doesnt_increase(self):
+        # See https://github.com/gevent/gevent/issues/1924
+        # and https://github.com/python-greenlet/greenlet/issues/328
+        self._only_test_some_versions()
+        def f():
+            return 1
+
+        ITER = 10000
+        def run_it():
+            for _ in range(ITER):
+                greenlet.greenlet(f).switch()
+
+        # Establish baseline
+        for _ in range(3):
+            run_it()
+
+        # uss: (Linux, macOS, Windows): aka "Unique Set Size", this is
+        # the memory which is unique to a process and which would be
+        # freed if the process was terminated right now.
+        uss_before = psutil.Process().memory_full_info().uss
+
+        for count in range(self.UNTRACK_ATTEMPTS):
+            uss_before = max(uss_before, psutil.Process().memory_full_info().uss)
+            run_it()
+
+            uss_after = psutil.Process().memory_full_info().uss
+            if uss_after <= uss_before and count > 1:
+                break
+
+        self.assertLessEqual(uss_after, uss_before)
+
+    def _check_untracked_memory_thread(self, deallocate_in_thread=True):
+        self._only_test_some_versions()
+        # Like the above test, but what if there are a bunch of
+        # unfinished greenlets in a thread that dies?
+        # Does it matter if we deallocate in the thread or not?
+        EXIT_COUNT = 0
+
+        def f():
+            try:
+                greenlet.getcurrent().parent.switch()
+            except greenlet.GreenletExit:
+                EXIT_COUNT0 += 1
+                raise
+            return 1
+
+        ITER = 10000
+        def run_it():
+            glets = 
+            for _ in range(ITER):
+                # Greenlet starts, switches back to us.
+                # We keep a strong reference to the greenlet though so it doesn't
+                # get a GreenletExit exception.
+                g = greenlet.greenlet(f)
+                glets.append(g)
+                g.switch()
+
+            return glets
+
+        test = self
+
+        class ThreadFunc:
+            uss_before = uss_after = 0
+            glets = ()
+            ITER = 2
+            def __call__(self):
+                self.uss_before = psutil.Process().memory_full_info().uss
+
+                for _ in range(self.ITER):
+                    self.glets += tuple(run_it())
+
+                for g in self.glets:
+                    test.assertIn('suspended active', str(g))
+                # Drop them.
+                if deallocate_in_thread:
+                    self.glets = ()
+                self.uss_after = psutil.Process().memory_full_info().uss
+
+        # Establish baseline
+        uss_before = uss_after = None
+        for count in range(self.UNTRACK_ATTEMPTS):
+            EXIT_COUNT0 = 0
+            thread_func = ThreadFunc()
+            t = threading.Thread(target=thread_func)
+            t.start()
+            t.join(30)
+            self.assertFalse(t.is_alive())
+
+            if uss_before is None:
+                uss_before = thread_func.uss_before
+
+            uss_before = max(uss_before, thread_func.uss_before)
+            if deallocate_in_thread:
+                self.assertEqual(thread_func.glets, ())
+                self.assertEqual(EXIT_COUNT0, ITER * thread_func.ITER)
+
+            del thread_func # Deallocate the greenlets; but this won't raise into them
+            del t
+            if not deallocate_in_thread:
+                self.assertEqual(EXIT_COUNT0, 0)
+            if deallocate_in_thread:
+                self.wait_for_pending_cleanups()
+
+            uss_after = psutil.Process().memory_full_info().uss
+            # See if we achieve a non-growth state at some point. Break when we do.
+            if uss_after <= uss_before and count > 1:
+                break
+
+        self.wait_for_pending_cleanups()
+        uss_after = psutil.Process().memory_full_info().uss
+        self.assertLessEqual(uss_after, uss_before, "after attempts %d" % (count,))
+
+    @ignores_leakcheck
+    # Because we're just trying to track raw memory, not objects, and running
+    # the leakcheck makes an already slow test slower.
+    def test_untracked_memory_doesnt_increase_unfinished_thread_dealloc_in_thread(self):
+        self._check_untracked_memory_thread(deallocate_in_thread=True)
+
+    @ignores_leakcheck
+    # Because the main greenlets from the background threads do not exit in a timely fashion,
+    # we fail the object-based leakchecks.
+    def test_untracked_memory_doesnt_increase_unfinished_thread_dealloc_in_main(self):
+        self._check_untracked_memory_thread(deallocate_in_thread=False)
+
+if __name__ == '__main__':
+    __import__('unittest').main()

_service:tar_scm:greenlet-1.1.2.tar.gz/src/greenlet/tests/test_stack_saved.py -> _service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/tests/test_stack_saved.py Changed

_service:tar_scm:greenlet-1.1.2.tar.gz/src/greenlet/tests/test_throw.py -> _service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/tests/test_throw.py Changed

@@ -1,14 +1,14 @@
 import sys
-import unittest
 
-from greenlet import greenlet
 
+from greenlet import greenlet
+from . import TestCase
 
 def switch(*args):
     return greenlet.getcurrent().parent.switch(*args)
 
 
-class ThrowTests(unittest.TestCase):
+class ThrowTests(TestCase):
     def test_class(self):
         def f():
             try:
@@ -75,7 +75,8 @@
 
         g1 = greenlet(f1)
         g2 = greenlet(f2, parent=g1)
-        self.assertRaises(IndexError, g2.throw, IndexError)
+        with self.assertRaises(IndexError):
+            g2.throw(IndexError)
         self.assertTrue(g2.dead)
         self.assertTrue(g1.dead)
 
@@ -98,3 +99,31 @@
         self.assertEqual(res, "caught")
         self.assertTrue(g2.dead)
         self.assertTrue(g1.dead)
+
+    def test_non_traceback_param(self):
+        with self.assertRaises(TypeError) as exc:
+            greenlet.getcurrent().throw(
+                Exception,
+                Exception(),
+                self
+            )
+        self.assertEqual(str(exc.exception),
+                         "throw() third argument must be a traceback object")
+
+    def test_instance_of_wrong_type(self):
+        with self.assertRaises(TypeError) as exc:
+            greenlet.getcurrent().throw(
+                Exception(),
+                BaseException()
+            )
+
+        self.assertEqual(str(exc.exception),
+                         "instance exception may not have a separate value")
+
+    def test_not_throwable(self):
+        with self.assertRaises(TypeError) as exc:
+            greenlet.getcurrent().throw(
+                "abc"
+            )
+        self.assertEqual(str(exc.exception),
+                         "exceptions must be classes, or instances, not str")

_service:tar_scm:greenlet-1.1.2.tar.gz/src/greenlet/tests/test_tracing.py -> _service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/tests/test_tracing.py Changed

@@ -1,7 +1,9 @@
+from __future__ import print_function
 import sys
-import unittest
 import greenlet
 
+from . import TestCase
+
 class SomeError(Exception):
     pass
 
@@ -25,12 +27,12 @@
         greenlet.settrace(self.oldtrace)
 
 
-class TestGreenletTracing(unittest.TestCase):
+class TestGreenletTracing(TestCase):
     """
     Tests of ``greenlet.settrace()``
     """
 
-    def test_greenlet_tracing(self):
+    def test_a_greenlet_tracing(self):
         main = greenlet.getcurrent()
         def dummy():
             pass
@@ -50,7 +52,7 @@
             ('throw', (g2, main)),
         )
 
-    def test_exception_disables_tracing(self):
+    def test_b_exception_disables_tracing(self):
         main = greenlet.getcurrent()
         def dummy():
             main.switch()
@@ -64,6 +66,15 @@
             ('switch', (main, g)),
         )
 
+    def test_set_same_tracer_twice(self):
+        # https://github.com/python-greenlet/greenlet/issues/332
+        # Our logic in asserting that the tracefunction should
+        # gain a reference was incorrect if the same tracefunction was set
+        # twice.
+        tracer = GreenletTracer()
+        with tracer:
+            greenlet.settrace(tracer)
+
 
 class PythonTracer(object):
     oldtrace = None
@@ -85,7 +96,7 @@
 def tpt_callback():
     return 42
 
-class TestPythonTracing(unittest.TestCase):
+class TestPythonTracing(TestCase):
     """
     Tests of the interaction of ``sys.settrace()``
     with greenlet facilities.

_service:tar_scm:greenlet-1.1.2.tar.gz/src/greenlet/tests/test_version.py -> _service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/tests/test_version.py Changed

_service:tar_scm:greenlet-1.1.2.tar.gz/src/greenlet/tests/test_weakref.py -> _service:tar_scm:greenlet-2.0.2.tar.gz/src/greenlet/tests/test_weakref.py Changed

_service:tar_scm:greenlet-1.1.2.tar.gz/tox.ini -> _service:tar_scm:greenlet-2.0.2.tar.gz/tox.ini Changed

@@ -1,28 +1,25 @@
 tox
 envlist =
-    py27,py35,py36,py37,py38,py39,py310,docs
+    py27,py35,py36,py37,py38,py39,py310,py27-ns,py310-ns,py311,py311-ns,docs
 
 testenv
+setenv =
+    ns: CPPFLAGS=-DG_USE_STANDARD_THREADING=0
 commands =
+    ns: python -c 'import greenlet._greenlet as G; assert not G.GREENLET_USE_STANDARD_THREADING'
+    !ns: python -c 'import greenlet._greenlet as G; assert G.GREENLET_USE_STANDARD_THREADING'
     python -m unittest discover -v greenlet.tests
-    sphinx-build -b doctest -d docs/_build/doctrees-{envname} docs docs/_build/doctest-{envname}
+    !ns: sphinx-build -b doctest -d docs/_build/doctrees-{envname} docs docs/_build/doctest-{envname}
 sitepackages = False
 extras =
     test
     docs
 
-testenv:py310
-# See tests.yml
-commands =
-    python -m unittest discover -v greenlet.tests
 
 
 testenv:docs
 # usedevelop to save rebuilding the extension
 usedevelop = true
-# We can't use Python 3.10 yet, so specify fully what we need.
-basepython =
-    python3.9
 commands =
     sphinx-build -b html -d docs/_build/doctrees docs docs/_build/html
     sphinx-build -b doctest -d docs/_build/doctrees docs docs/_build/doctest