Cython 3.0.6__tar.gz → 3.0.8__tar.gz

Cython-3.0.8/.gitrev

@@ -0,0 +1 @@
+a1b79a6bc5326406ad73af73f5b41e3bb5f8da6e

{Cython-3.0.6 → Cython-3.0.8}/CHANGES.rst

@@ -2,6 +2,51 @@
 Cython Changelog
 ================
 
+3.0.8 (2024-01-10)
+==================
+
+Bugs fixed
+----------
+
+* Using ``const`` together with defined fused types could fail to compile.
+  (Github issue :issue:`5230`)
+
+* A "use after free" bug was fixed in parallel sections.
+  (Github issue :issue:`5922`)
+
+* Several types were not available as ``cython.*`` types in pure Python code.
+
+* The generated code is now correct C89 again, removing some C++ style ``//`` comments
+  and C99-style declaration-after-code code ordering.  This is still relevant for some
+  ols C compilers, specifically ones that match old Python 2.7 installations.
+
+
+3.0.7 (2023-12-19)
+==================
+
+Bugs fixed
+----------
+
+* In the iterator of generator expressions, ``await`` and ``yield`` were not correctly analysed.
+  (Github issue :issue:`5851`)
+
+* ``cpdef`` enums with the same name cimported from different modules could lead to
+  invalid C code.
+  (Github issue :issue:`5887`)
+
+* Some declarations in ``cpython.unicode`` were fixed and extended.
+  (Github issue :issue:`5902`)
+
+* Compiling fused types used in pxd files could crash Cython in Python 3.11+.
+  (Github issues :issue:`5894`,  :issue:`5588`)
+
+* Source files with non-ASCII file names could crash Cython.
+  (Github issue :issue:`5873`)
+
+* Includes all bug-fixes and features from the 0.29 maintenance branch
+  up to the :ref:`0.29.37` release.
+
+
 3.0.6 (2023-11-26)
 ==================
 
@@ -14,7 +59,7 @@ Features added
   (Github issue :issue:`5836`)
 
 * The Python "nogil" fork is now also detected with the new ``Py_GIL_DISABLED`` macro.
-  Patch by Hugo van Kemenade   (Github issue :issue:`583652`)
+  Patch by Hugo van Kemenade.  (Github issue :issue:`5852`)
 
 Bugs fixed
 ----------
@@ -3319,6 +3364,27 @@ Other changes
 .. _`PEP-479`: https://www.python.org/dev/peps/pep-0479
 
 
+.. _0.29.37:
+
+0.29.37 (2023-12-18)
+====================
+
+Bugs fixed
+----------
+
+* Fix a potential crash while cleaning up subtypes of externally imported extension
+  types when terminating Python.  This was introduced in Cython 0.29.35.
+
+* Fix a ``complex`` related compile error on Windows.
+  (Github issue :issue:`5512`)
+
+* Compiling fused types used in pxd files could crash Cython in Python 3.11+.
+  (Github issues :issue:`5894`, :issue:`5588`)
+
+* ``cythonize`` failed to consider the ``CYTHON_FORCE_REGEN`` env variable.
+  Patch by Harmen Stoppels.  (Github issue :issue:`5712`)
+
+
 .. _0.29.36:
 
 0.29.36 (2023-07-04)

{Cython-3.0.6 → Cython-3.0.8}/Cython/Compiler/Errors.py

@@ -249,7 +249,7 @@ def warn_once(position, message, level=0):
     echo_file = threadlocal.cython_errors_echo_file
     if echo_file:
         _write_file_encode(echo_file, line)
-    warn_once_seen[message] = True
+    warn_once_seen.add(message)
     return warn
 
 

{Cython-3.0.6 → Cython-3.0.8}/Cython/Compiler/ExprNodes.py

@@ -6482,9 +6482,11 @@ class SimpleCallNode(CallNode):
                 if exc_check:
                     if nogil:
                         if not exc_checks:
+                            perf_hint_entry = getattr(self.function, "entry", None)
                             PyrexTypes.write_noexcept_performance_hint(
                                 self.pos, code.funcstate.scope,
-                                function_name=None, void_return=self.type.is_void)
+                                function_name=perf_hint_entry.name if perf_hint_entry else None,
+                                void_return=self.type.is_void, is_call=True)
                         code.globalstate.use_utility_code(
                             UtilityCode.load_cached("ErrOccurredWithGIL", "Exceptions.c"))
                         exc_checks.append("__Pyx_ErrOccurredWithGIL()")

{Cython-3.0.6 → Cython-3.0.8}/Cython/Compiler/FusedNode.py

@@ -3,7 +3,8 @@ from __future__ import absolute_import
 import copy
 
 from . import (ExprNodes, PyrexTypes, MemoryView,
-               ParseTreeTransforms, StringEncoding, Errors)
+               ParseTreeTransforms, StringEncoding, Errors,
+               Naming)
 from .ExprNodes import CloneNode, ProxyNode, TupleNode
 from .Nodes import FuncDefNode, CFuncDefNode, StatListNode, DefNode
 from ..Utils import OrderedSet
@@ -198,12 +199,11 @@ class FusedCFuncDefNode(StatListNode):
                 break
 
         # replace old entry with new entries
-        try:
+        if self.node.entry in env.cfunc_entries:
             cindex = env.cfunc_entries.index(self.node.entry)
-        except ValueError:
-            env.cfunc_entries.extend(new_cfunc_entries)
-        else:
             env.cfunc_entries[cindex:cindex+1] = new_cfunc_entries
+        else:
+            env.cfunc_entries.extend(new_cfunc_entries)
 
         if orig_py_func:
             self.py_func = self.make_fused_cpdef(orig_py_func, env,
@@ -308,9 +308,10 @@ class FusedCFuncDefNode(StatListNode):
                 """)
 
     def _dtype_name(self, dtype):
+        name = str(dtype).replace('_', '__').replace(' ', '_')
         if dtype.is_typedef:
-            return '___pyx_%s' % dtype
-        return str(dtype).replace(' ', '_')
+            name = Naming.fused_dtype_prefix + name
+        return name
 
     def _dtype_type(self, dtype):
         if dtype.is_typedef:

{Cython-3.0.6 → Cython-3.0.8}/Cython/Compiler/ModuleNode.py

@@ -3592,7 +3592,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
         code.putln("int add_module_result = PyState_AddModule(%s, &%s);" % (
             module_temp, Naming.pymoduledef_cname))
         code.putln("%s = 0; /* transfer ownership from %s to %s pseudovariable */" % (
-            module_temp, module_temp, env.module_name
+            module_temp, module_temp, env.module_name.as_c_string_literal()
         ))
         # At this stage the module likely has a refcount of 2 - one owned by the list
         # inside PyState_AddModule and one owned by "__pyx_m" (and returned from this

{Cython-3.0.6 → Cython-3.0.8}/Cython/Compiler/Naming.py

@@ -132,6 +132,7 @@ frame_code_cname = pyrex_prefix + "frame_code"
 error_without_exception_cname = pyrex_prefix + "error_without_exception"
 binding_cfunc    = pyrex_prefix + "binding_PyCFunctionType"
 fused_func_prefix = pyrex_prefix + 'fuse_'
+fused_dtype_prefix = pyrex_prefix + 'fused_dtype_'
 quick_temp_cname = pyrex_prefix + "temp"  # temp variable for quick'n'dirty temping
 tp_dict_version_temp = pyrex_prefix + "tp_dict_version"
 obj_dict_version_temp = pyrex_prefix + "obj_dict_version"

{Cython-3.0.6 → Cython-3.0.8}/Cython/Compiler/Nodes.py

@@ -8610,6 +8610,8 @@ class TryFinallyStatNode(StatNode):
 
         if self.is_try_finally_in_nogil:
             code.put_ensure_gil(declare_gilstate=False)
+            # although the thread state is already assigned, that can't be trusted after releasing the GIL
+            code.putln("__Pyx_PyThreadState_assign")
 
         # not using preprocessor here to avoid warnings about
         # unused utility functions and/or temps
@@ -8636,6 +8638,8 @@ class TryFinallyStatNode(StatNode):
         code.globalstate.use_utility_code(reset_exception_utility_code)
         if self.is_try_finally_in_nogil:
             code.put_ensure_gil(declare_gilstate=False)
+            # although the thread state is already assigned, that can't be trusted after releasing the GIL
+            code.putln("__Pyx_PyThreadState_assign")
 
         # not using preprocessor here to avoid warnings about
         # unused utility functions and/or temps

{Cython-3.0.6 → Cython-3.0.8}/Cython/Compiler/ParseTreeTransforms.pxd

@@ -54,10 +54,12 @@ cdef class YieldNodeCollector(TreeVisitor):
     cdef public bint has_return_value
     cdef public bint has_yield
     cdef public bint has_await
+    cdef list excludes
 
 @cython.final
 cdef class MarkClosureVisitor(CythonTransform):
     cdef bint needs_closure
+    cdef list excludes
 
 @cython.final
 cdef class CreateClosureClasses(CythonTransform):

{Cython-3.0.6 → Cython-3.0.8}/Cython/Compiler/ParseTreeTransforms.py

@@ -215,7 +215,7 @@ class PostParse(ScopeTrackingTransform):
     def visit_GeneratorExpressionNode(self, node):
         # unpack a generator expression into the corresponding DefNode
         collector = YieldNodeCollector()
-        collector.visitchildren(node.loop)
+        collector.visitchildren(node.loop, attrs=None, exclude=["iterator"])
         node.def_node = Nodes.DefNode(
             node.pos, name=node.name, doc=None,
             args=[], star_arg=None, starstar_arg=None,
@@ -3155,7 +3155,7 @@ class RemoveUnreachableCode(CythonTransform):
 
 class YieldNodeCollector(TreeVisitor):
 
-    def __init__(self):
+    def __init__(self, excludes=[]):
         super(YieldNodeCollector, self).__init__()
         self.yields = []
         self.returns = []
@@ -3164,9 +3164,11 @@ class YieldNodeCollector(TreeVisitor):
         self.has_return_value = False
         self.has_yield = False
         self.has_await = False
+        self.excludes = excludes
 
     def visit_Node(self, node):
-        self.visitchildren(node)
+        if node not in self.excludes:
+            self.visitchildren(node)
 
     def visit_YieldExprNode(self, node):
         self.yields.append(node)
@@ -3202,7 +3204,11 @@ class YieldNodeCollector(TreeVisitor):
         pass
 
     def visit_GeneratorExpressionNode(self, node):
-        pass
+        # node.loop iterator is evaluated outside the generator expression
+        if isinstance(node.loop, Nodes._ForInStatNode):
+            # Possibly should handle ForFromStatNode
+            # but for now do nothing
+            self.visit(node.loop.iterator)
 
     def visit_CArgDeclNode(self, node):
         # do not look into annotations
@@ -3216,6 +3222,7 @@ class MarkClosureVisitor(CythonTransform):
 
     def visit_ModuleNode(self, node):
         self.needs_closure = False
+        self.excludes = []
         self.visitchildren(node)
         return node
 
@@ -3225,7 +3232,7 @@ class MarkClosureVisitor(CythonTransform):
         node.needs_closure = self.needs_closure
         self.needs_closure = True
 
-        collector = YieldNodeCollector()
+        collector = YieldNodeCollector(self.excludes)
         collector.visitchildren(node)
 
         if node.is_async_def:
@@ -3284,7 +3291,11 @@ class MarkClosureVisitor(CythonTransform):
         return node
 
     def visit_GeneratorExpressionNode(self, node):
+        excludes = self.excludes
+        if isinstance(node.loop, Nodes._ForInStatNode):
+            self.excludes = [node.loop.iterator]
         node = self.visit_LambdaNode(node)
+        self.excludes = excludes
         if not isinstance(node.loop, Nodes._ForInStatNode):
             # Possibly should handle ForFromStatNode
             # but for now do nothing

{Cython-3.0.6 → Cython-3.0.8}/Cython/Compiler/PyrexTypes.py

@@ -3301,7 +3301,12 @@ class CFuncType(CType):
         if self.is_overridable:
             arg_decl_list.append("int %s" % Naming.skip_dispatch_cname)
         if self.optional_arg_count:
-            arg_decl_list.append(self.op_arg_struct.declaration_code(Naming.optional_args_cname))
+            if self.op_arg_struct:
+                arg_decl_list.append(self.op_arg_struct.declaration_code(Naming.optional_args_cname))
+            else:
+                # op_arg_struct may not be initialized at this point if this class is being used
+                # to prepare a Python error message or similar.  In this case, just omit the args.
+                assert for_display
         if self.has_varargs:
             arg_decl_list.append("...")
         arg_decl_code = ", ".join(arg_decl_list)
@@ -4305,7 +4310,7 @@ class EnumMixin(object):
 
     def create_enum_to_py_utility_code(self, env):
         from .UtilityCode import CythonUtilityCode
-        self.to_py_function = "__Pyx_Enum_%s_to_py" % self.name
+        self.to_py_function = "__Pyx_Enum_%s_to_py" % type_identifier(self)
         if self.entry.scope != env.global_scope():
             module_name = self.entry.scope.qualified_name
         else:
@@ -5316,6 +5321,8 @@ def parse_basic_type(name):
         signed = 2
     elif name == 'size_t':
         signed = 0
+    elif name == 'ptrdiff_t':
+        signed = 2
     else:
         if name.startswith('u'):
             name = name[1:]
@@ -5438,16 +5445,29 @@ def cap_length(s, max_prefix=63, max_len=1024):
     hash_prefix = hashlib.sha256(s.encode('ascii')).hexdigest()[:6]
     return '%s__%s__etc' % (hash_prefix, s[:max_len-17])
 
-def write_noexcept_performance_hint(pos, env, function_name=None, void_return=False):
-    on_what = "on '%s' " % function_name if function_name else ""
+def write_noexcept_performance_hint(pos, env, function_name=None, void_return=False, is_call=False):
+    if function_name:
+        # we need it escaped everywhere we use it
+        function_name = "'%s'" % function_name
+    if is_call:
+        on_what = "after calling %s " % (function_name or 'function')
+    elif function_name:
+        on_what = "on %s " % function_name
+    else:
+        on_what =''
     msg = (
         "Exception check %swill always require the GIL to be acquired."
     ) % on_what
-    solutions = ["Declare the function as 'noexcept' if you control the definition and "
-                                "you're sure you don't want the function to raise exceptions."]
+    the_function = function_name if function_name else "the function"
+    if is_call and not function_name:
+        the_function = the_function + " you are calling"
+    solutions = ["Declare %s as 'noexcept' if you control the definition and "
+                 "you're sure you don't want the function to raise exceptions."
+                                % the_function]
     if void_return:
         solutions.append(
-            "Use an 'int' return type on the function to allow an error code to be returned.")
+            "Use an 'int' return type on %s to allow an error code to be returned." %
+            the_function)
     if len(solutions) == 1:
         msg = "%s %s" % (msg, solutions[0])
     else:

{Cython-3.0.6 → Cython-3.0.8}/Cython/Includes/cpython/unicode.pxd

@@ -194,7 +194,7 @@ cdef extern from *:
     # string is null-terminated in case this is required by the application.
     # Also, note that the wchar_t* string might contain null characters,
     # which would cause the string to be truncated when used with most C functions.
-    Py_ssize_t PyUnicode_AsWideChar(object o, wchar_t *w, Py_ssize_t size)
+    Py_ssize_t PyUnicode_AsWideChar(object o, wchar_t *w, Py_ssize_t size) except -1
 
     # Convert the Unicode object to a wide character string. The output
     # string always ends with a null character. If size is not NULL,
@@ -207,7 +207,7 @@ cdef extern from *:
     # Returns a buffer allocated by PyMem_New (use PyMem_Free() to free it)
     # on success. On error, returns NULL and *size is undefined. Raises a
     # MemoryError if memory allocation is failed.
-    wchar_t *PyUnicode_AsWideCharString(object o, Py_ssize_t *size)
+    wchar_t *PyUnicode_AsWideCharString(object o, Py_ssize_t *size) except NULL
 
 # Unicode Methods
 
@@ -394,7 +394,11 @@ cdef extern from *:
     # This caches the UTF-8 representation of the string in the Unicode
     # object, and subsequent calls will return a pointer to the same buffer.
     # The caller is not responsible for deallocating the buffer
-    const char* PyUnicode_AsUTF8AndSize(object unicode, Py_ssize_t *size)
+    const char* PyUnicode_AsUTF8AndSize(object unicode, Py_ssize_t *size) except NULL
+
+
+    # As PyUnicode_AsUTF8AndSize(), but does not store the size.
+    const char *PyUnicode_AsUTF8(object unicode) except NULL
 
 # These are the UTF-16 codec APIs:
 

{Cython-3.0.6 → Cython-3.0.8}/Cython/Shadow.py

@@ -2,7 +2,7 @@
 from __future__ import absolute_import
 
 # Possible version formats: "3.1.0", "3.1.0a1", "3.1.0a1.dev0"
-__version__ = "3.0.6"
+__version__ = "3.0.8"
 
 try:
     from __builtin__ import basestring
@@ -451,6 +451,8 @@ int_types = [
     'Py_hash_t',
     'Py_ssize_t',
     'size_t',
+    'ssize_t',
+    'ptrdiff_t',
 ]
 float_types = [
     'longdouble',
@@ -491,7 +493,7 @@ del builtins
 for name in int_types:
     reprname = to_repr(name, name)
     gs[name] = typedef(py_int, reprname)
-    if name not in ('Py_UNICODE', 'Py_UCS4') and not name.endswith('size_t'):
+    if name not in ('Py_UNICODE', 'Py_UCS4', 'Py_hash_t', 'ptrdiff_t') and not name.endswith('size_t'):
         gs['u'+name] = typedef(py_int, "unsigned " + reprname)
         gs['s'+name] = typedef(py_int, "signed " + reprname)
 
@@ -505,9 +507,18 @@ bint = typedef(bool, "bint")
 void = typedef(None, "void")
 Py_tss_t = typedef(None, "Py_tss_t")
 
-for t in int_types + float_types + complex_types + other_types:
+for t in int_types:
     for i in range(1, 4):
         gs["%s_%s" % ('p'*i, t)] = gs[t]._pointer(i)
+        if 'u'+t in gs:
+            gs["%s_u%s" % ('p'*i, t)] = gs['u'+t]._pointer(i)
+            gs["%s_s%s" % ('p'*i, t)] = gs['s'+t]._pointer(i)
+
+for t in float_types + complex_types + other_types:
+    for i in range(1, 4):
+        gs["%s_%s" % ('p'*i, t)] = gs[t]._pointer(i)
+
+del t, i
 
 NULL = gs['p_void'](0)
 

Cython-3.0.8/Cython/Tests/TestShadow.py

@@ -0,0 +1,79 @@
+import unittest
+
+from Cython import Shadow
+from Cython.Compiler import Options, CythonScope, PyrexTypes, Errors
+
+class TestShadow(unittest.TestCase):
+    def test_all_types_in_shadow(self):
+        cython_scope = CythonScope.create_cython_scope(None)
+        # Not doing load_cythonscope at this stage because it requires a proper context and
+        # Errors.py to be set up
+
+        missing_types = []
+        for key in cython_scope.entries.keys():
+            if key.startswith('__') and key.endswith('__'):
+                continue
+            if key in ('PyTypeObject', 'PyObject_TypeCheck'):
+                # These are declared in Shadow.py for reasons that look to
+                # be an implementation detail, but it isn't our intention for
+                # users to access them from Pure Python mode.
+                continue
+            if not hasattr(Shadow, key):
+                missing_types.append(key)
+        self.assertEqual(missing_types, [])
+
+    def test_int_types_in_shadow(self):
+        missing_types = []
+        for int_name in Shadow.int_types:
+            for sign in ['', 'u', 's']:
+                name = sign + int_name
+
+                if sign and (
+                        int_name in ['Py_UNICODE', 'Py_UCS4', 'Py_ssize_t',
+                                     'ssize_t', 'ptrdiff_t', 'Py_hash_t'] or
+                        name == "usize_t"):
+                    # size_t is special-cased here a little since ssize_t legitimate
+                    # but usize_t isn't
+                    self.assertNotIn(name, dir(Shadow))
+                    self.assertNotIn('p_' + name, dir(Shadow))
+                    continue
+
+                if not hasattr(Shadow, name):
+                    missing_types.append(name)
+
+                for ptr in range(1, 4):
+                    ptr_name = 'p' * ptr + '_' + name
+                    if not hasattr(Shadow, ptr_name):
+                        missing_types.append(ptr_name)
+        self.assertEqual(missing_types, [])
+
+    def test_most_types(self):
+        # TODO it's unfortunately hard to get a definite list of types to confirm that they're
+        # present (because they're obtained by on-the-fly string parsing in `cython_scope.lookup_type`)
+
+        cython_scope = CythonScope.create_cython_scope(None)
+        # Set up just enough of "Context" and "Errors" that CythonScope.lookup_type can fail
+        class Context:
+            cpp = False
+            language_level = 3
+            future_directives = []
+        cython_scope.context = Context
+        Errors.init_thread()
+
+        missing_types = []
+        missing_lookups = []
+        for (signed, longness, name), type_ in PyrexTypes.modifiers_and_name_to_type.items():
+            if name == 'object':
+                continue  # This probably shouldn't be in Shadow
+            if not hasattr(Shadow, name):
+                missing_types.append(name)
+            if not cython_scope.lookup_type(name):
+                missing_lookups.append(name)
+            for ptr in range(1, 4):
+                ptr_name = 'p' * ptr + '_' + name
+                if not hasattr(Shadow, ptr_name):
+                    missing_types.append(ptr_name)
+                if not cython_scope.lookup_type(ptr_name):
+                    missing_lookups.append(ptr_name)
+        self.assertEqual(missing_types, [])
+        self.assertEqual(missing_lookups, [])

{Cython-3.0.6 → Cython-3.0.8}/Cython/Utility/CythonFunction.c

@@ -58,7 +58,7 @@ typedef struct {
     // Dynamic default args and annotations
     void *defaults;
     int defaults_pyobjects;
-    size_t defaults_size;  // used by FusedFunction for copying defaults
+    size_t defaults_size;  /* used by FusedFunction for copying defaults */
     int flags;
 
     // Defaults info

{Cython-3.0.6 → Cython-3.0.8}/Cython/Utility/Dataclasses.c

@@ -39,7 +39,7 @@ static PyObject* __Pyx_LoadInternalModule(const char* name, const char* fallback
     if (!module) {
         PyObject *localDict, *runValue, *builtins, *modulename;
         if (!PyErr_ExceptionMatches(PyExc_ImportError)) goto bad;
-        PyErr_Clear();  // this is reasonably likely (especially on older versions of Python)
+        PyErr_Clear();  /* this is reasonably likely (especially on older versions of Python) */
 #if PY_MAJOR_VERSION < 3
         modulename = PyBytes_FromFormat("_cython_" CYTHON_ABI ".%s", name);
 #else
@@ -47,17 +47,17 @@ static PyObject* __Pyx_LoadInternalModule(const char* name, const char* fallback
 #endif
         if (!modulename) goto bad;
 #if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_CPYTHON
-        module = PyImport_AddModuleObject(modulename); // borrowed
+        module = PyImport_AddModuleObject(modulename);  /* borrowed */
 #else
-        module = PyImport_AddModule(PyBytes_AsString(modulename)); // borrowed
+        module = PyImport_AddModule(PyBytes_AsString(modulename));  /* borrowed */
 #endif
         Py_DECREF(modulename);
         if (!module) goto bad;
         Py_INCREF(module);
         if (PyObject_SetAttrString(shared_abi_module, name, module) < 0) goto bad;
-        localDict = PyModule_GetDict(module); // borrowed
+        localDict = PyModule_GetDict(module);  /* borrowed */
         if (!localDict) goto bad;
-        builtins = PyEval_GetBuiltins(); // borrowed
+        builtins = PyEval_GetBuiltins();  /* borrowed */
         if (!builtins) goto bad;
         if (PyDict_SetItemString(localDict, "__builtins__", builtins) <0) goto bad;
 

{Cython-3.0.6 → Cython-3.0.8}/Cython/Utility/Exceptions.c

@@ -1083,7 +1083,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
     #else
     py_code = PyCode_NewEmpty(filename, funcname, py_line);
     #endif
-    Py_XDECREF(py_funcname);  // XDECREF since it's only set on Py3 if cline
+    Py_XDECREF(py_funcname);  /* XDECREF since it's only set on Py3 if cline */
     return py_code;
 bad:
     Py_XDECREF(py_funcname);

{Cython-3.0.6 → Cython-3.0.8}/Cython/Utility/FunctionArguments.c

@@ -301,7 +301,7 @@ static int __Pyx_ParseOptionalKeywords(
         if (*name) {
             values[name-argnames] = value;
 #if CYTHON_AVOID_BORROWED_REFS
-            Py_INCREF(value); // transfer ownership of value to values
+            Py_INCREF(value);  /* transfer ownership of value to values */
             Py_DECREF(key);
 #endif
             key = NULL;
@@ -323,7 +323,7 @@ static int __Pyx_ParseOptionalKeywords(
                         && _PyString_Eq(**name, key)) {
                     values[name-argnames] = value;
 #if CYTHON_AVOID_BORROWED_REFS
-                    value = NULL;  // ownership transferred to values
+                    value = NULL;  /* ownership transferred to values */
 #endif
                     break;
                 }
@@ -357,7 +357,7 @@ static int __Pyx_ParseOptionalKeywords(
                 if (cmp == 0) {
                     values[name-argnames] = value;
 #if CYTHON_AVOID_BORROWED_REFS
-                    value = NULL; // ownership transferred to values
+                    value = NULL;  /* ownership transferred to values */
 #endif
                     break;
                 }
@@ -492,8 +492,8 @@ bad:
     #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg)
     #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg)
 #else
-    #define __Pyx_Arg_NewRef_VARARGS(arg) arg // no-op
-    #define __Pyx_Arg_XDECREF_VARARGS(arg) // no-op - arg is borrowed
+    #define __Pyx_Arg_NewRef_VARARGS(arg) arg  /* no-op */
+    #define __Pyx_Arg_XDECREF_VARARGS(arg)     /* no-op - arg is borrowed */
 #endif
 #define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds)
 #define __Pyx_KwValues_VARARGS(args, nargs) NULL
@@ -509,9 +509,9 @@ bad:
   #else
     #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw)
   #endif
-    #define __Pyx_Arg_NewRef_FASTCALL(arg) arg // no-op, __Pyx_Arg_FASTCALL is direct and this needs
-                                               // to have the same reference counting
-    #define __Pyx_Arg_XDECREF_FASTCALL(arg)  // no-op - arg was returned from array
+    #define __Pyx_Arg_NewRef_FASTCALL(arg) arg  /* no-op, __Pyx_Arg_FASTCALL is direct and this needs
+                                                   to have the same reference counting */
+    #define __Pyx_Arg_XDECREF_FASTCALL(arg)     /* no-op - arg was returned from array */
 #else
     #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS
     #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS
@@ -555,11 +555,11 @@ static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyO
     {
         int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ);
         if (unlikely(eq != 0)) {
-            if (unlikely(eq < 0)) return NULL;  // error
+            if (unlikely(eq < 0)) return NULL;  /* error */
             return kwvalues[i];
         }
     }
-    return NULL;  // not found (no exception set)
+    return NULL;  /* not found (no exception set) */
 }
 
 #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000

{Cython-3.0.6 → Cython-3.0.8}/Cython/Utility/ModuleSetupCode.c

@@ -680,7 +680,7 @@ class __Pyx_FakeReference {
         PyObject *exception_table = NULL;
         PyObject *types_module=NULL, *code_type=NULL, *result=NULL;
         #if __PYX_LIMITED_VERSION_HEX < 0x030B0000
-        PyObject *version_info; // borrowed
+        PyObject *version_info;  /* borrowed */
         PyObject *py_minor_version = NULL;
         #endif
         long minor_version = 0;
@@ -690,8 +690,9 @@ class __Pyx_FakeReference {
         PyErr_Fetch(&type, &value, &traceback);
 
         #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000
-        minor_version = 11; // we don't yet need to distinguish between versions > 11
-        // Note that from 3.13, when we do we can use Py_Version
+        minor_version = 11;
+        // we don't yet need to distinguish between versions > 11
+        // Note that from 3.13, when we do, we can use Py_Version
         #else
         if (!(version_info = PySys_GetObject("version_info"))) goto end;
         if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end;
@@ -772,7 +773,7 @@ class __Pyx_FakeReference {
     //  1. pass an empty bytes string as exception_table
     //  2. pass name as qualname (TODO this might implementing properly in future)
     PyCodeObject *result;
-    PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0);  // we don't have access to __pyx_empty_bytes here
+    PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0);  /* we don't have access to __pyx_empty_bytes here */
     if (!empty_bytes) return NULL;
     result =
       #if PY_VERSION_HEX >= 0x030C0000