Cython 3.2.0__cp39-abi3-win32.whl

Cython/Debugger/DebugWriter.py

@@ -0,0 +1,82 @@
+import os
+import sys
+import errno
+
+try:
+    from lxml import etree
+    have_lxml = True
+except ImportError:
+    have_lxml = False
+    from xml.etree import ElementTree as etree
+
+from ..Compiler import Errors
+from ..Compiler.StringEncoding import EncodedString
+
+
+def is_valid_tag(name):
+    """
+    Names like '.0' are used internally for arguments
+    to functions creating generator expressions,
+    however they are not identifiers.
+
+    See https://github.com/cython/cython/issues/5552
+    """
+    if isinstance(name, EncodedString):
+        if name.startswith(".") and name[1:].isdecimal():
+            return False
+    return True
+
+
+class CythonDebugWriter:
+    """
+    Class to output debugging information for cygdb
+
+    It writes debug information to cython_debug/cython_debug_info_<modulename>
+    in the build directory.
+    """
+
+    def __init__(self, output_dir):
+        if etree is None:
+            raise Errors.NoElementTreeInstalledException()
+
+        self.output_dir = os.path.join(output_dir or os.curdir, 'cython_debug')
+        self.tb = etree.TreeBuilder()
+        # set by Cython.Compiler.ParseTreeTransforms.DebugTransform
+        self.module_name = None
+        self.start('cython_debug', attrs=dict(version='1.0'))
+
+    def start(self, name, attrs=None):
+        if is_valid_tag(name):
+            self.tb.start(name, attrs or {})
+
+    def end(self, name):
+        if is_valid_tag(name):
+            self.tb.end(name)
+
+    def add_entry(self, name, **attrs):
+        if is_valid_tag(name):
+            self.tb.start(name, attrs)
+            self.tb.end(name)
+
+    def serialize(self):
+        self.tb.end('Module')
+        self.tb.end('cython_debug')
+        xml_root_element = self.tb.close()
+
+        try:
+            os.makedirs(self.output_dir)
+        except OSError as e:
+            if e.errno != errno.EEXIST:
+                raise
+
+        et = etree.ElementTree(xml_root_element)
+        kw = {}
+        if have_lxml:
+            kw['pretty_print'] = True
+
+        fn = "cython_debug_info_" + self.module_name
+        et.write(os.path.join(self.output_dir, fn), encoding="UTF-8", **kw)
+
+        interpreter_path = os.path.join(self.output_dir, 'interpreter')
+        with open(interpreter_path, 'w') as f:
+            f.write(sys.executable)

Cython/Debugger/Tests/TestLibCython.py

@@ -0,0 +1,275 @@
+import os
+import re
+import sys
+import shutil
+import warnings
+import textwrap
+import unittest
+import tempfile
+import subprocess
+#import distutils.core
+#from distutils import sysconfig
+from distutils import ccompiler
+
+import runtests
+import Cython.Distutils.extension
+import Cython.Distutils.old_build_ext as build_ext
+from Cython.Debugger import Cygdb as cygdb
+
+root = os.path.dirname(os.path.abspath(__file__))
+codefile = os.path.join(root, 'codefile')
+cfuncs_file = os.path.join(root, 'cfuncs.c')
+
+with open(codefile) as f:
+    source_to_lineno = {line.strip(): i for i, line in enumerate(f, 1)}
+
+
+have_gdb = None
+def test_gdb():
+    global have_gdb
+    if have_gdb is not None:
+        return have_gdb
+
+    have_gdb = False
+    try:
+        p = subprocess.Popen(['gdb', '-nx', '--version'], stdout=subprocess.PIPE)
+    except OSError:
+        # gdb not found
+        gdb_version = None
+    else:
+        stdout, _ = p.communicate()
+        # Based on Lib/test/test_gdb.py
+        regex = r"GNU gdb [^\d]*(\d+)\.(\d+)"
+        gdb_version = re.match(regex, stdout.decode('ascii', 'ignore'))
+
+    if gdb_version:
+        gdb_version_number = list(map(int, gdb_version.groups()))
+        if gdb_version_number >= [7, 2]:
+            have_gdb = True
+            with tempfile.NamedTemporaryFile(mode='w+') as python_version_script:
+                python_version_script.write(
+                    'python import sys; print("%s %s" % sys.version_info[:2])')
+                python_version_script.flush()
+                p = subprocess.Popen(['gdb', '-batch', '-x', python_version_script.name],
+                                     stdout=subprocess.PIPE)
+                stdout, _ = p.communicate()
+                try:
+                    internal_python_version = list(map(int, stdout.decode('ascii', 'ignore').split()))
+                    if internal_python_version < [2, 7]:
+                        have_gdb = False
+                except ValueError:
+                    have_gdb = False
+
+    if not have_gdb:
+        warnings.warn('Skipping gdb tests, need gdb >= 7.2 with Python >= 2.7')
+
+    return have_gdb
+
+
+class DebuggerTestCase(unittest.TestCase):
+
+    def setUp(self):
+        """
+        Run gdb and have cygdb import the debug information from the code
+        defined in TestParseTreeTransforms's setUp method
+        """
+        if not test_gdb():
+            return
+
+        self.tempdir = tempfile.mkdtemp()
+        self.destfile = os.path.join(self.tempdir, 'codefile.pyx')
+        self.debug_dest = os.path.join(self.tempdir,
+                                      'cython_debug',
+                                      'cython_debug_info_codefile')
+        self.cfuncs_destfile = os.path.join(self.tempdir, 'cfuncs')
+
+        self.cwd = os.getcwd()
+        try:
+            os.chdir(self.tempdir)
+
+            shutil.copy(codefile, self.destfile)
+            shutil.copy(cfuncs_file, self.cfuncs_destfile + '.c')
+            shutil.copy(cfuncs_file.replace('.c', '.h'),
+                        self.cfuncs_destfile + '.h')
+
+            compiler = ccompiler.new_compiler()
+            compiler.compile(['cfuncs.c'], debug=True, extra_postargs=['-fPIC'])
+
+            opts = dict(
+                test_directory=self.tempdir,
+                module='codefile',
+                module_path=self.destfile,
+            )
+
+            optimization_disabler = build_ext.Optimization()
+
+            cython_compile_testcase = runtests.CythonCompileTestCase(
+                workdir=self.tempdir,
+                # we clean up everything (not only compiled files)
+                cleanup_workdir=False,
+                tags=runtests.parse_tags(codefile),
+                **opts
+            )
+
+
+            new_stderr = open(os.devnull, 'w')
+
+            stderr = sys.stderr
+            sys.stderr = new_stderr
+
+            optimization_disabler.disable_optimization()
+            try:
+                cython_compile_testcase.run_cython(
+                    targetdir=self.tempdir,
+                    incdir=None,
+                    annotate=False,
+                    extra_compile_options={
+                        'gdb_debug':True,
+                        'output_dir':self.tempdir,
+                    },
+                    **opts
+                )
+
+                cython_compile_testcase.run_distutils(
+                    test_directory=opts['test_directory'],
+                    module=opts['module'],
+                    workdir=opts['test_directory'],
+                    incdir=None,
+                    extra_extension_args={'extra_objects':['cfuncs.o']},
+                )
+            finally:
+                optimization_disabler.restore_state()
+                sys.stderr = stderr
+                new_stderr.close()
+
+            # ext = Cython.Distutils.extension.Extension(
+                # 'codefile',
+                # ['codefile.pyx'],
+                # cython_gdb=True,
+                # extra_objects=['cfuncs.o'])
+            #
+            # distutils.core.setup(
+                # script_args=['build_ext', '--inplace'],
+                # ext_modules=[ext],
+                # cmdclass=dict(build_ext=Cython.Distutils.build_ext)
+            # )
+
+        except:
+            os.chdir(self.cwd)
+            raise
+
+    def tearDown(self):
+        if not test_gdb():
+            return
+        os.chdir(self.cwd)
+        shutil.rmtree(self.tempdir)
+
+
+class GdbDebuggerTestCase(DebuggerTestCase):
+
+    def setUp(self):
+        if not test_gdb():
+            return
+
+        super().setUp()
+
+        prefix_code = textwrap.dedent('''\
+            python
+
+            import os
+            import sys
+            import traceback
+
+            def excepthook(type, value, tb):
+                traceback.print_exception(type, value, tb)
+                sys.stderr.flush()
+                sys.stdout.flush()
+                os._exit(1)
+
+            sys.excepthook = excepthook
+
+            # Have tracebacks end up on sys.stderr (gdb replaces sys.stderr
+            # with an object that calls gdb.write())
+            sys.stderr = sys.__stderr__
+
+            end
+            ''')
+
+        code = textwrap.dedent('''\
+            python
+
+            from Cython.Debugger.Tests import test_libcython_in_gdb
+            test_libcython_in_gdb.main(version=%r)
+
+            end
+            ''' % (sys.version_info[:2],))
+
+        self.gdb_command_file = cygdb.make_command_file(self.tempdir,
+                                                        prefix_code)
+
+        with open(self.gdb_command_file, 'a') as f:
+            f.write(code)
+
+        args = ['gdb', '-batch', '-x', self.gdb_command_file, '-n', '--args',
+                sys.executable, '-c', 'import codefile']
+
+        paths = []
+        path = os.environ.get('PYTHONPATH')
+        if path:
+            paths.append(path)
+        paths.append(os.path.dirname(os.path.dirname(
+            os.path.abspath(Cython.__file__))))
+        env = dict(os.environ, PYTHONPATH=os.pathsep.join(paths))
+
+        self.p = subprocess.Popen(
+            args,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            env=env)
+
+    def tearDown(self):
+        if not test_gdb():
+            return
+
+        try:
+            super().tearDown()
+            if self.p:
+                try: self.p.stdout.close()
+                except: pass
+                try: self.p.stderr.close()
+                except: pass
+                self.p.wait()
+        finally:
+            os.remove(self.gdb_command_file)
+
+
+class TestAll(GdbDebuggerTestCase):
+
+    def test_all(self):
+        if not test_gdb():
+            return
+
+        out, err = self.p.communicate()
+        out = out.decode('UTF-8')
+        err = err.decode('UTF-8')
+
+        exit_status = self.p.returncode
+
+        if exit_status == 1:
+            sys.stderr.write(out)
+            sys.stderr.write(err)
+        elif exit_status >= 2:
+            border = '*' * 30
+            start  = '%s   v INSIDE GDB v   %s' % (border, border)
+            stderr = '%s   v STDERR v   %s' % (border, border)
+            end    = '%s   ^ INSIDE GDB ^   %s' % (border, border)
+            errmsg = '\n%s\n%s%s\n%s%s' % (start, out, stderr, err, end)
+
+            sys.stderr.write(errmsg)
+
+        # FIXME: re-enable this to make the test fail on internal failures
+        #self.assertEqual(exit_status, 0)
+
+
+if __name__ == '__main__':
+    unittest.main()

Cython/Debugger/Tests/__init__.py

@@ -0,0 +1 @@
+# empty file

Cython/Debugger/Tests/cfuncs.c

@@ -0,0 +1,8 @@
+void
+some_c_function(void)
+{
+    int a, b, c;
+
+    a = 1;
+    b = 2;
+}

Cython/Debugger/Tests/codefile

@@ -0,0 +1,49 @@
+cdef extern from "stdio.h":
+    int puts(char *s)
+
+cdef extern from "cfuncs.h":
+    void some_c_function()
+
+import os
+
+cdef int c_var = 12
+python_var = 13
+
+def spam(a=0):
+    cdef:
+        int b, c
+
+    b = c = d = 0
+
+    b = 1
+    c = 2
+    int(10)
+    puts("spam")
+    os.path.join("foo", "bar")
+    some_c_function()
+
+cpdef eggs():
+    pass
+
+cdef ham():
+    pass
+
+cdef class SomeClass(object):
+    def spam(self):
+        pass
+
+def outer():
+    cdef object a = "an object"
+    def inner():
+        b = 2
+        # access closed over variables
+        print(a, b)
+    return inner
+
+outer()()
+
+spam()
+print("bye!")
+
+def use_ham():
+    ham()