开源软件构建与测试

We truncated the diff of some files because they were too big. If you want to see the full diff for every file, click here.

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;

_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

_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

_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',

_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.
+

_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);

_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;
+        }

_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;
+    };
+

_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
+

_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))
+

_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()

_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()

_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()

_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