Use an object for Gen.next but skip it in tp_clear

Author: jdemeyer

cypari2/gen.pxd

@@ -29,14 +29,12 @@ cdef class Gen(Gen_base):
 
     # The Gen objects on the PARI stack form a linked list, from the
     # bottom to the top of the stack. This makes sense since we can only
-    # deallocate a Gen which is on the bottom of the PARI stack.
+    # deallocate a Gen which is on the bottom of the PARI stack. If this
+    # is the last object on the stack, then next = top_of_stack
+    # (a singleton object).
     #
-    # Link to the next (up the PARI stack) Gen object. This is manually
-    # refcounted (not by Cython) because we need complete control over
-    # it. If this is the last object on the stack, then
-    # next = top_of_stack (a singleton object). In the clone and constant
-    # cases, this is NULL.
-    cdef PyObject* next
+    # In the clone and constant cases, this is None.
+    cdef Gen next
 
     # A cache for __getitem__. Initially, this is None but it will be
     # turned into a dict when needed.

cypari2/gen.pyx

@@ -57,16 +57,10 @@ AUTHORS:
 
 from __future__ import absolute_import, division, print_function
 
-import types
 cimport cython
 
-from cpython.int cimport PyInt_Check
-from cpython.long cimport PyLong_Check
-from cpython.bytes cimport PyBytes_Check
-from cpython.unicode cimport PyUnicode_Check
-from cpython.float cimport PyFloat_AS_DOUBLE
-from cpython.complex cimport PyComplex_RealAsDouble, PyComplex_ImagAsDouble
-from cpython.object cimport Py_EQ, Py_NE, Py_LE, Py_GE, Py_LT, Py_GT
+from cpython.object cimport (Py_EQ, Py_NE, Py_LE, Py_GE, Py_LT, Py_GT,
+        PyTypeObject)
 
 from cysignals.memory cimport sig_free, check_malloc
 from cysignals.signals cimport sig_check, sig_on, sig_off, sig_block, sig_unblock
@@ -158,7 +152,7 @@ cdef class Gen(Gen_base):
         raise RuntimeError("PARI objects cannot be instantiated directly; use pari(x) to convert x to PARI")
 
     def __dealloc__(self):
-        if self.next is not NULL:
+        if self.next is not None:
             # stack
             remove_from_pari_stack(self)
         elif self.address is not NULL:
@@ -194,7 +188,7 @@ cdef class Gen(Gen_base):
         >>> pari("[[1, 2], 3]")[0][1]  # indirect doctest
         2
         """
-        if self.next is not NULL:
+        if self.next is not None:
             raise TypeError("cannot create reference to PARI stack (call fixGEN() first)")
         if is_on_stack(g):
             raise ValueError("new_ref() called with GEN which does not belong to parent")
@@ -208,7 +202,7 @@ cdef class Gen(Gen_base):
         Return the PARI ``GEN`` corresponding to ``self`` which is
         guaranteed not to change.
         """
-        if self.next is not NULL:
+        if self.next is not None:
             move_gens_to_heap(self.sp())
         return self.g
 
@@ -4554,6 +4548,20 @@ cdef class Gen(Gen_base):
         raise NotImplementedError("the method allocatemem() should not be used; use pari.allocatemem() instead")
 
 
+cdef int Gen_clear(self) except -1:
+    """
+    Implementation of tp_clear() for Gen. We need to override Cython's
+    default since we do not want self.next to be cleared: it is crucial
+    that the next Gen stays alive until remove_from_pari_stack(self) is
+    called by __dealloc__.
+    """
+    # Only itemcache needs to be cleared
+    (<Gen>self).itemcache = None
+
+
+(<PyTypeObject*>Gen).tp_clear = Gen_clear
+
+
 @cython.boundscheck(False)
 @cython.wraparound(False)
 cdef Gen list_of_Gens_to_Gen(list s):

cypari2/stack.pyx

@@ -59,30 +59,30 @@ cdef void remove_from_pari_stack(Gen self):
         else:
             warn(f"cypari2 leaked {self.sp() - avma} bytes on the PARI stack",
                  RuntimeWarning, stacklevel=2)
-    stackbottom = n = self.next
-    self.next = NULL
+    n = self.next
+    stackbottom = <PyObject*>n
+    self.next = None
     reset_avma()
-    Py_XDECREF(n)
 
 
 cdef inline Gen Gen_stack_new(GEN x):
     """
     Allocate and initialize a new instance of ``Gen`` wrapping
     a GEN on the PARI stack.
     """
-    # INCREF(stackbottom) must be done BEFORE calling Gen_new
+    global stackbottom
+    # n = <Gen>stackbottom must be done BEFORE calling Gen_new()
     # since Gen_new may invoke gc.collect() which would mess up
     # the PARI stack.
-    global stackbottom
-    Py_XINCREF(stackbottom)
+    n = <Gen>stackbottom
     z = Gen_new(x, <GEN>avma)
-    z.next = stackbottom
+    z.next = n
     stackbottom = <PyObject*>z
-    if z.next is not <PyObject*>top_of_stack:
-        s0 = z.sp()
-        s1 = (<Gen>z.next).sp()
-        if s0 > s1:
-            raise SystemError(f"objects on PARI stack in invalid order (first: 0x{s0:x}; next: 0x{s1:x})")
+    if n is not top_of_stack:
+        sz = z.sp()
+        sn = n.sp()
+        if sz > sn:
+            raise SystemError(f"objects on PARI stack in invalid order (first: 0x{sz:x}; next: 0x{sn:x})")
     return z