dispatch based on frame

python code stepping (for libpython and libcython)
generic stepper class
fix step-into functions
have cygdb accept a '--' command line argument to disable automatic importing
replace gdb.execute() with something that actually captures all output
have 'cy break' break properly on line numbers

Cython/Compiler/Main.py

@@ -185,7 +185,7 @@ class Context(object):
             from ParseTreeTransforms import DebugTransform
             self.debug_outputwriter = DebugWriter.CythonDebugWriter(
                 options.output_dir)
-            debug_transform = [DebugTransform(self)]
+            debug_transform = [DebugTransform(self, options)]
         else:
             debug_transform = []
             

Cython/Compiler/ParseTreeTransforms.py

@@ -1441,18 +1441,23 @@ class DebugTransform(CythonTransform):
     to enable debugging.
     """
     
-    def __init__(self, context):
+    def __init__(self, context, options):
         super(DebugTransform, self).__init__(context)
         self.visited = set()
         # our treebuilder and debug output writer 
         # (see Cython.Debugger.debug_output.CythonDebugWriter)
         self.tb = self.context.debug_outputwriter
+        self.c_output_file = options.output_file
+        
+        # tells visit_NameNode whether it should register step-into functions
+        self.register_stepinto = False
         
     def visit_ModuleNode(self, node):
         self.tb.module_name = node.full_module_name
         attrs = dict(
             module_name=node.full_module_name,
-            filename=node.pos[0].filename)
+            filename=node.pos[0].filename,
+            c_filename=self.c_output_file)
         
         self.tb.start('Module', attrs)
         
@@ -1503,16 +1508,21 @@ class DebugTransform(CythonTransform):
         self.tb.end('Arguments')
 
         self.tb.start('StepIntoFunctions')
+        self.register_stepinto = True
         self.visitchildren(node)
+        self.register_stepinto = False
         self.tb.end('StepIntoFunctions')
         self.tb.end('Function')
 
         return node
 
     def visit_NameNode(self, node):
-        if (node.type.is_cfunction and 
-            node.is_called and 
-            node.entry.in_cinclude):
+        if (self.register_stepinto and node.type.is_cfunction and node.is_called):
+            # don't check node.entry.in_cinclude, as 'cdef extern: ...' 
+            # declared functions are not 'in_cinclude'. 
+            # This means we will list called 'cdef' functions as 
+            # "step into functions", but this is not an issue as they will be 
+            # recognized as Cython functions anyway.
             attrs = dict(name=node.entry.func_cname)
             self.tb.start('StepIntoFunction', attrs=attrs)
             self.tb.end('StepIntoFunction')

Cython/Debugger/Cygdb.py

@@ -20,9 +20,11 @@ import subprocess
 def usage():
     print("Usage: cygdb [PATH GDB_ARGUMENTS]")
 
-def make_command_file(path_to_debug_info):
-    debug_files = glob.glob(
-        os.path.join(path_to_debug_info, 'cython_debug/cython_debug_info_*'))
+def make_command_file(path_to_debug_info, prefix_code='', no_import=False):
+    if not no_import:
+        pattern = os.path.join(path_to_debug_info, 
+                               'cython_debug/cython_debug_info_*')
+        debug_files = glob.glob(pattern)
 
         if not debug_files:
             usage()
@@ -31,14 +33,16 @@ def make_command_file(path_to_debug_info):
         
     fd, tempfilename = tempfile.mkstemp()
     f = os.fdopen(fd, 'w')
+    f.write(prefix_code)
     f.write('set breakpoint pending on\n')
     f.write('python from Cython.Debugger import libcython\n')
+    if not no_import:
         f.write('\n'.join('cy import %s\n' % fn for fn in debug_files))
     f.close()
     
     return tempfilename
 
-def main(gdb_argv=[], path_to_debug_info=os.curdir):
+def main(path_to_debug_info=os.curdir, gdb_argv=[], no_import=False):
     """
     Start the Cython debugger. This tells gdb to import the Cython and Python
     extensions (libpython.py and libcython.py) and it enables gdb's pending 
@@ -46,7 +50,7 @@ def main(gdb_argv=[], path_to_debug_info=os.curdir):
     
     path_to_debug_info is the path to the cython_debug directory
     """
-    tempfilename = make_command_file(path_to_debug_info)
+    tempfilename = make_command_file(path_to_debug_info, no_import=no_import)
     p = subprocess.Popen(['gdb', '-command', tempfilename] + gdb_argv)
     while True:
         try:

Cython/Debugger/DebugWriter.py

+import os
+import errno
+
+try:
+  from lxml import etree
+  have_lxml = True
+except ImportError:
+    have_lxml = False
+    try:
+        # Python 2.5
+        from xml.etree import cElementTree as etree
+    except ImportError:
+        try:
+            # Python 2.5
+            from xml.etree import ElementTree as etree
+        except ImportError:
+            try:
+                # normal cElementTree install
+                import cElementTree as etree
+            except ImportError:
+                try:
+                    # normal ElementTree install
+                    import elementtree.ElementTree as etree
+                except ImportError:
+                    etree = None
+
+from Cython.Compiler import Errors
+
+
+class CythonDebugWriter(object):
+    """
+    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, '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):
+        self.tb.start(name, attrs or {})
+    
+    def end(self, name):
+        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, 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)
\ No newline at end of file

Cython/Debugger/libcython.py

@@ -91,18 +91,41 @@ def require_cython_frame(function):
         return function(self, *args, **kwargs)
     return wrapper 
 
+def dispatch_on_frame(c_command, python_command=None):
+    def decorator(function):
+        @functools.wraps(function)
+        def wrapper(self, *args, **kwargs):
+            is_cy = self.is_cython_function()
+            is_py = self.is_python_function()
+            
+            if is_cy or (is_py and not python_command):
+                function(self, *args, **kwargs)
+            elif is_py:
+                gdb.execute(python_command)
+            elif self.is_relevant_function():
+                gdb.execute(c_command)
+            else:
+                raise gdb.GdbError("Not a function cygdb knows about. "
+                                   "Use the normal GDB commands instead.")
+        
+        return wrapper
+    return decorator
+
+
 # Classes that represent the debug information
 # Don't rename the parameters of these classes, they come directly from the XML
 
 class CythonModule(object):
-    def __init__(self, module_name, filename):
+    def __init__(self, module_name, filename, c_filename):
         self.name = module_name
         self.filename = filename
+        self.c_filename = c_filename
         self.globals = {}
         # {cython_lineno: min(c_linenos)}
         self.lineno_cy2c = {}
         # {c_lineno: cython_lineno}
         self.lineno_c2cy = {}
+        self.functions = {}
         
     def qualified_name(self, varname):
         return '.'.join(self.name, varname)
@@ -146,11 +169,14 @@ class CythonBase(object):
 
     @default_selected_gdb_frame(err=False)
     def is_python_function(self, frame):
-        return frame.name() == 'PyEval_EvalFrameEx'
-
-    @default_selected_gdb_frame()
-    def is_python_function(self, frame):
-        return libpython.Frame(frame).is_evalframeex()
+        """
+        Tells if a frame is associated with a Python function.
+        If we can't read the Python frame information, don't regard it as such.
+        """
+        if frame.name() == 'PyEval_EvalFrameEx':
+            pyframe = libpython.Frame(frame).get_pyop()
+            return pyframe and not pyframe.is_optimized_out()
+        return False
         
     @default_selected_gdb_frame()
     def get_c_function_name(self, frame):
@@ -170,8 +196,12 @@ class CythonBase(object):
     
     @default_selected_gdb_frame()
     def get_cython_lineno(self, frame):
+        """
+        Get the current Cython line number. Returns 0 if there is no 
+        correspondence between the C and Cython code.
+        """
         cyfunc = self.get_cython_function(frame)
-        return cyfunc.module.lineno_c2cy.get(self.get_c_lineno(frame))
+        return cyfunc.module.lineno_c2cy.get(self.get_c_lineno(frame), 0)
     
     @default_selected_gdb_frame()
     def get_source_desc(self, frame):
@@ -185,7 +215,7 @@ class CythonBase(object):
             pyframeobject = libpython.Frame(frame).get_pyop()
 
             if not pyframeobject:
-                raise GdbError('Unable to read information on python frame')
+                raise gdb.GdbError('Unable to read information on python frame')
 
             filename = pyframeobject.filename()
             lineno = pyframeobject.current_line_num()
@@ -199,6 +229,25 @@ class CythonBase(object):
         source_desc, lineno = self.get_source_desc()
         return source_desc.get_source(lineno)
     
+    def is_relevant_function(self, frame):
+        """
+        returns whether we care about a frame on the user-level when debugging
+        Cython code
+        """
+        name = frame.name()
+        older_frame = frame.older()
+        
+        if self.is_cython_function(frame) or self.is_python_function(frame):
+            return True
+        elif (parameters.step_into_c_code and 
+              older_frame and self.is_cython_function(older_frame)):
+            # direct C function call from a Cython function
+            cython_func = self.get_cython_function(older_frame)
+            return name in cython_func.step_into_functions
+
+        return False
+
+
 class SourceFileDescriptor(object):
     def __init__(self, filename, lexer, formatter=None):
         self.filename = filename
@@ -238,12 +287,19 @@ class SourceFileDescriptor(object):
                 yield '%s %4d    %s' % (prefix, start + idx, line)
 
     def get_source(self, start, stop=None, lex_source=True, mark_line=0):
+        exc = gdb.GdbError('Unable to retrieve source code')
+        
         if not self.filename:
-            raise GdbError('Unable to retrieve source code')
+            raise exc
             
         if stop is None:
             stop = start + 1
-        return '\n'.join(self._get_source(start, stop, lex_source, mark_line))
+
+        try:
+            return '\n'.join(
+                self._get_source(start, stop, lex_source, mark_line))
+        except IOError:
+            raise exc
 
 
 # Errors
@@ -299,18 +355,24 @@ class CompleteUnqualifiedFunctionNames(CythonParameter):
 
 class ColorizeSourceCode(CythonParameter):
     """
-    Tell cygdb whether to colorize source code
+    Tell cygdb whether to colorize source code.
     """
 
 class TerminalBackground(CythonParameter):
     """
-    Tell cygdb about the user's terminal background (light or dark)
+    Tell cygdb about the user's terminal background (light or dark).
+    """
+
+class StepIntoCCode(CythonParameter):
+    """
+    Tells cygdb whether to step into C functions called directly from Cython
+    code.
     """
 
 class CythonParameters(object):
     """
     Simple container class that might get more functionality in the distant
-    future (mostly to remind us that we're dealing with parameters)
+    future (mostly to remind us that we're dealing with parameters).
     """
     
     def __init__(self):
@@ -329,6 +391,11 @@ class CythonParameters(object):
             gdb.COMMAND_FILES,
             gdb.PARAM_STRING,
             "dark")
+        self.step_into_c_code = StepIntoCCode(
+            'cy_step_into_c_code',
+            gdb.COMMAND_RUNNING,
+            gdb.PARAM_BOOLEAN,
+            True)
         
 parameters = CythonParameters()
 
@@ -340,6 +407,14 @@ class CythonCommand(gdb.Command, CythonBase):
     Base class for Cython commands
     """
 
+    @classmethod
+    def register(cls, *args, **kwargs):
+        if not hasattr(cls, 'completer_class'):
+            return cls(cls.name, cls.command_class, *args, **kwargs)
+        else:
+            return cls(cls.name, cls.command_class, cls.completer_class, 
+                       *args, **kwargs)
+
 
 class CyCy(CythonCommand):
     """
@@ -348,6 +423,7 @@ class CyCy(CythonCommand):
         cy import
         cy break
         cy step
+        cy next
         cy print
         cy list
         cy locals
@@ -357,31 +433,29 @@ class CyCy(CythonCommand):
         cy down
     """
     
-    def __init__(self):
-        super(CythonCommand, self).__init__(
-            'cy', gdb.COMMAND_NONE, gdb.COMPLETE_COMMAND, prefix=True)
-        
-        self.import_ = CyImport(
-            'cy import', gdb.COMMAND_STATUS, gdb.COMPLETE_FILENAME)
-            
-        self.break_ = CyBreak('cy break', gdb.COMMAND_BREAKPOINTS)
-        self.step = CyStep('cy step', gdb.COMMAND_RUNNING, gdb.COMPLETE_NONE)
-        self.next = CyNext('cy next', gdb.COMMAND_RUNNING, gdb.COMPLETE_NONE)
-        self.list = CyList('cy list', gdb.COMMAND_FILES, gdb.COMPLETE_NONE)
-        self.print_ = CyPrint('cy print', gdb.COMMAND_DATA)
+    name = 'cy'
+    command_class = gdb.COMMAND_NONE
+    completer_class = gdb.COMPLETE_COMMAND
     
-        self.locals = CyLocals(
-            'cy locals', gdb.COMMAND_STACK, gdb.COMPLETE_NONE)
-        self.globals = CyGlobals(
-            'cy globals', gdb.COMMAND_STACK, gdb.COMPLETE_NONE)
-            
-        self.cy_cname = CyCName('cy_cname')
-        
-        objs = (self.import_, self.break_, self.step, self.list, self.print_,
-                self.locals, self.globals, self.cy_cname)
-
-        for obj in objs:
-            obj.cy = self
+    def __init__(self, *args):
+        super(CythonCommand, self).__init__(*args, prefix=True)
+        
+        commands = dict(
+            import_ = CyImport.register(),
+            break_ = CyBreak.register(),
+            step = CyStep.register(),
+            next = CyNext.register(),
+            list = CyList.register(),
+            print_ = CyPrint.register(),
+            locals = CyLocals.register(),
+            globals = CyGlobals.register(),
+            cy_cname = CyCName('cy_cname'),
+            cy_line = CyLine('cy_line'),
+        )
+            
+        for command_name, command in commands.iteritems():
+            command.cy = self
+            setattr(self, command_name, command)
             
         # Cython module namespace
         self.cython_namespace = {}
@@ -404,14 +478,18 @@ class CyImport(CythonCommand):
     Example: cy import FILE...
     """
     
+    name = 'cy import'
+    command_class = gdb.COMMAND_STATUS
+    completer_class = gdb.COMPLETE_FILENAME
+    
     def invoke(self, args, from_tty):
         args = args.encode(_filesystemencoding)
         for arg in string_to_argv(args):
             try:
                 f = open(arg)
             except OSError, e:
-                print('Unable to open file %r: %s' % (args, e.args[1]))
-                return
+                raise gdb.GdbError('Unable to open file %r: %s' % 
+                                                (args, e.args[1]))
             
             t = etree.parse(f)
             
@@ -428,13 +506,18 @@ class CyImport(CythonCommand):
                                                      **function.attrib)
 
                     # update the global function mappings
-                    self.cy.functions_by_name[cython_function.name].append(
-                        cython_function)
+                    name = cython_function.name
+                    
+                    self.cy.functions_by_name[name].append(cython_function)
                     self.cy.functions_by_qualified_name[
                         cython_function.qualified_name] = cython_function
                     self.cy.functions_by_cname[
                         cython_function.cname] = cython_function
                     
+                    d = cython_module.functions
+                    L = d.setdefault(cython_function.qualified_name, [])
+                    L.append(cython_function)
+                    
                     for local in function.find('Locals'):
                         d = local.attrib
                         cython_function.locals[d['name']] = CythonVariable(**d)
@@ -469,13 +552,16 @@ class CyBreak(CythonCommand):
         cy break cython_module:lineno...
     """
     
+    name = 'cy break'
+    command_class = gdb.COMMAND_BREAKPOINTS
+    
     def _break_pyx(self, name):
         modulename, _, lineno = name.partition(':')
         lineno = int(lineno)
         cython_module = self.cy.cython_namespace[modulename]
         if lineno in cython_module.lineno_cy2c:
             c_lineno = cython_module.lineno_cy2c[lineno]
-            breakpoint = '%s:%s' % (cython_module.name, c_lineno)
+            breakpoint = '%s:%s' % (cython_module.c_filename, c_lineno)
             gdb.execute('break ' + breakpoint)
         else:
             raise GdbError("Not a valid line number. "
@@ -554,78 +640,74 @@ class CyBreak(CythonCommand):
         return compl
 
 
-class CodeStepperMixin(object):
-    
-    def init_stepping(self):
-        self.cython_func = self.get_cython_function()
-        self.beginline = self.get_cython_lineno()
-        self.curframe = gdb.selected_frame() 
-
-    def next_step(self, command):
-        "returns whether to continue stepping"
-        result = gdb.execute(command, to_string=True)
-        newframe = gdb.selected_frame()
+class CythonCodeStepper(CythonCommand, libpython.GenericCodeStepper):
+    """
+    Base class for CyStep and CyNext. It implements the interface dictated by
+    libpython.GenericCodeStepper.
+    """
     
-        c1 = result.startswith('Breakpoint')
-        c2 = (newframe == self.curframe and 
-              self.get_cython_lineno() > self.beginline)
-        return not c1 and not c2
+    def lineno(self, frame):
+        # Take care of the Python and Cython levels. We need to care for both
+        # as we can't simply dispath to 'py-step', since that would work for
+        # stepping through Python code, but it would not step back into Cython-
+        # related code. The C level should be dispatched to the 'step' command.
+        if self.is_cython_function(frame):
+            return self.get_cython_lineno(frame)
+        else:
+            return libpython.py_step.lineno(frame)
     
-    def end_stepping(self):
-        sys.stdout.write(self.get_source_line())
+    def get_source_line(self, frame):
+        # We may have ended up in a Python, Cython, or C function
+        # In case of C, don't display any additional data (gdb already 
+        # does this)
+        result = ''
         
+        if self.is_cython_function(frame) or self.is_python_function(frame):
+            try:
+                result = super(CythonCodeStepper, self).get_source_line(frame)
+            except gdb.GdbError:
+                result = ''
         
-class CyStep(CythonCommand, CodeStepperMixin):
+        return result.lstrip()
         
-    def step(self, nsteps=1):
-        for nthstep in xrange(nsteps):
-            self.init_stepping()
+    @classmethod
+    def register(cls):
+        return cls(cls.name, stepper=cls.stepper)
     
-            while self.next_step('step'):
-                newframe = gdb.selected_frame()
-                if newframe != self.curframe:
-                    # we entered a function
-                    funcname = self.get_c_function_name(newframe)
-                    if (self.is_cython_function() or 
-                        self.is_python_function() or
-                        funcname in cython_function.step_into_functions):
-                        break
 
-        self.end_stepping()
+class CyStep(CythonCodeStepper):
+    "Step through Python code."
     
-    def invoke(self, steps, from_tty):
-        if self.is_cython_function():
-            if steps:
-                self.step(int(steps))
-            else:
-                self.step()
-        else:
-            gdb.execute('step ' + steps, from_tty)
+    name = 'cy step'
+    stepper = True
     
+    @dispatch_on_frame(c_command='step')
+    def invoke(self, *args, **kwargs):
+        super(CythonCodeStepper, self).invoke(*args, **kwargs)
 
-class CyNext(CythonCommand, CodeStepperMixin):
 
-    def next(self, nsteps=1):
-        for nthstep in xrange(nsteps):
-            self.init_stepping()
+class CyNext(CythonCodeStepper):
+    "Step-over Python code."
 
-            while self.next_step('next'):
-                pass
+    name = 'cy next'
+    stepper = False
 
-            self.end_stepping()
-    
-    def invoke(self, steps, from_tty):
-        if self.is_cython_function():
-            if steps:
-                self.next(int(steps))
-            else:
-                self.next()
-        else:
-            gdb.execute('next ' + steps, from_tty)
+    @dispatch_on_frame(c_command='next')
+    def invoke(self, *args, **kwargs):
+        super(CythonCodeStepper, self).invoke(*args, **kwargs)
 
 
 class CyList(CythonCommand):
+    """
+    List Cython source code. To disable to customize colouring see the cy_*
+    parameters.
+    """
+    
+    name = 'cy list'
+    command_class = gdb.COMMAND_FILES
+    completer_class = gdb.COMPLETE_NONE
     
+    @dispatch_on_frame(c_command='list')
     def invoke(self, _, from_tty):
         sd, lineno = self.get_source_desc()
         source = sd.get_source(lineno - 5, lineno + 5, mark_line=lineno)
@@ -637,27 +719,34 @@ class CyPrint(CythonCommand):
     Print a Cython variable using 'cy-print x' or 'cy-print module.function.x'
     """
     
-    def invoke(self, name, from_tty):
-        try:
-            cname = cy.cy_cname.invoke(name)
-        except gdb.GdbError:
-            cname = name
-       
-        gdb.execute('print ' + cname)
+    name = 'cy print'
+    command_class = gdb.COMMAND_DATA
     
+    @dispatch_on_frame(c_command='print', python_command='py-print')
+    def invoke(self, name, from_tty):
+        gdb.execute('print ' + self.cy.cy_cname.invoke(name, string=True))
     
     def complete(self):
         if self.is_cython_function():
             f = self.get_cython_function()
             return list(itertools.chain(f.locals, f.globals))
+        else:
             return []
 
 
 class CyLocals(CythonCommand):
+    """
+    List the locals from the current Cython frame.
+    """
+    
+    name = 'cy locals'
+    command_class = gdb.COMMAND_STACK
+    completer_class = gdb.COMPLETE_NONE
+    
     def ns(self):
         return self.get_cython_function().locals
     
-    @require_cython_frame
+    @dispatch_on_frame(c_command='info locals', python_command='py-locals')
     def invoke(self, name, from_tty):
         try:
             ns = self.ns()
@@ -682,10 +771,18 @@ class CyLocals(CythonCommand):
 
 
 class CyGlobals(CythonCommand):
+    """
+    List the globals from the current Cython module.
+    """
+    
+    name = 'cy globals'
+    command_class = gdb.COMMAND_STACK
+    completer_class = gdb.COMPLETE_NONE
+    
     def ns(self):
         return self.get_cython_function().globals
     
-    @require_cython_frame
+    @dispatch_on_frame(c_command='info variables', python_command='py-globals')
     def invoke(self, name, from_tty):
         # include globals from the debug info XML file!
         m = gdb.parse_and_eval('__pyx_m')
@@ -709,26 +806,54 @@ class CyGlobals(CythonCommand):
 
 class CyCName(gdb.Function, CythonBase):
     """
-    Get the C name of a Cython variable.
+    Get the C name of a Cython variable in the current context.
+    Examples:
+        
+        print $cy_cname("function")
+        print $cy_cname("Class.method")
+        print $cy_cname("module.function")
     """
     
     @require_cython_frame
-    def invoke(self, cyname, frame=None):
+    def invoke(self, cyname, string=False, frame=None):
         frame = frame or gdb.selected_frame()
         cname = None
         
+        if isinstance(cyname, gdb.Value):
+            # convert to a python string so it supports proper hashing
             cyname = cyname.string()
+        
         if self.is_cython_function(frame):
             cython_function = self.get_cython_function(frame)
             if cyname in cython_function.locals:
                 cname = cython_function.locals[cyname].cname
             elif cyname in cython_function.module.globals:
                 cname = cython_function.module.globals[cyname].cname
+            else:
+                qname = '%s.%s' % (cython_function.module.name, cyname)
+                if qname in cython_function.module.functions:
+                    cname = cython_function.module.functions[qname].cname
+            
+        if not cname:
+            cname = self.cy.functions_by_qualified_name.get(cyname)
             
         if not cname:
             raise gdb.GdbError('No such Cython variable: %s' % cyname)
         
+        if string:
             return cname
+        else:
+            return gdb.parse_and_eval(cname)
+
+
+class CyLine(gdb.Function, CythonBase):
+    """
+    Get the current Cython line.
+    """
+    
+    @require_cython_frame
+    def invoke(self):
+        return self.get_cython_lineno()
 
 
-cy = CyCy()
\ No newline at end of file
+cy = CyCy.register()
\ No newline at end of file

Cython/Debugger/libpython.py

@@ -44,8 +44,12 @@ the type names are known to the debugger
 The module also extends gdb with some python-specific commands.
 '''
 from __future__ import with_statement
-import gdb
+
+import os
 import sys
+import tempfile
+
+import gdb
 
 # Look up the gdb.Type for some standard types:
 _type_char_ptr = gdb.lookup_type('char').pointer() # char*
@@ -1448,3 +1452,165 @@ class PyLocals(gdb.Command):
                       pyop_value.get_truncated_repr(MAX_OUTPUT_LEN)))
 
 PyLocals()
+
+
+def execute(command, from_tty=False, to_string=False):
+    """
+    Replace gdb.execute() with this function and have it accept a 'to_string'
+    argument (new in 7.2). Have it properly capture stderr also.
+    
+    Unfortuntaly, this function is not reentrant.
+    """
+    if not to_string:
+        return _execute(command, from_tty)
+            
+    fd, filename = tempfile.mkstemp()
+    
+    try:
+        _execute("set logging file %s" % filename)
+        _execute("set logging redirect on")
+        _execute("set logging on")
+        _execute("set pagination off")
+        
+        _execute(command, from_tty)
+    finally:
+        data = os.fdopen(fd).read()
+        os.remove(filename)
+        _execute("set logging off")
+        _execute("set pagination on")
+        return data
+        
+_execute = gdb.execute
+gdb.execute = execute
+
+
+class GenericCodeStepper(gdb.Command):
+    """
+    Superclass for code stepping. Subclasses must implement the following 
+    methods:
+        
+        lineno(frame)               - tells the current line number (only
+                                      called for a relevant frame)
+        is_relevant_function(frame) - tells whether we care about frame 'frame'
+        get_source_line(frame)      - get the line of source code for the 
+                                      current line (only called for a relevant
+                                      frame)
+        
+    This class provides an 'invoke' method that invokes a 'step' or 'step-over'
+    depending on the 'stepper' argument.
+    """
+    
+    def __init__(self, name, stepper=False):
+        super(GenericCodeStepper, self).__init__(name, 
+                                                 gdb.COMMAND_RUNNING,
+                                                 gdb.COMPLETE_NONE)
+        self.stepper = stepper
+    
+    def _init_stepping(self):
+        self.beginframe = gdb.selected_frame()
+        self.beginline = self.lineno(self.beginframe)
+        if not self.stepper:
+            self.depth = self._stackdepth(self.beginframe)
+
+    def _next_step(self, gdb_command):
+        """
+        Teturns whether to continue stepping. This method sets the instance 
+        attributes 'result' and 'stopped_running'. 'result' hold the output
+        of the executed gdb command ('step' or 'next')
+        """
+        self.result = gdb.execute(gdb_command, to_string=True)
+        self.stopped_running = gdb.inferiors()[0].pid == 0
+        
+        if self.stopped_running:
+            # We stopped running
+            return False
+            
+        newframe = gdb.selected_frame()
+        
+        hit_breakpoint = self.result.startswith('Breakpoint')
+        is_relevant_function = self.is_relevant_function(newframe)
+        
+        if newframe != self.beginframe:
+            # new function
+            if not self.stepper:
+                is_relevant_function = (
+                    self._stackdepth(newframe) < self.depth and
+                    is_relevant_function)
+
+            new_lineno = False
+        else:
+            is_relevant_function = False
+            new_lineno = self.lineno(newframe) > self.beginline
+        
+        return not (hit_breakpoint or new_lineno or is_relevant_function)
+        
+    def _end_stepping(self):
+        # sys.stdout.write(self.result)
+        
+        if not self.stopped_running:
+            frame = gdb.selected_frame()
+            if self.is_relevant_function(frame):
+                print self.get_source_line(frame)
+    
+    def _stackdepth(self, frame):
+        depth = 0
+        while frame:
+            frame = frame.older()
+            depth += 1
+            
+        return depth
+    
+    def invoke(self, args, from_tty):
+        if args:
+            nsteps = int(args)
+        else:
+            nsteps = 1
+        
+        if self.stepper:
+            gdb_command = 'step'
+        else:
+            gdb_command= 'next'
+        
+        for nthstep in xrange(nsteps):
+            self._init_stepping()
+            while self._next_step(gdb_command):
+                pass
+            
+            self._end_stepping()
+
+
+class PythonCodeStepper(GenericCodeStepper):
+    
+    def pyframe(self, frame):
+        pyframe = Frame(frame).get_pyop()
+        if pyframe:
+            return pyframe
+        else:
+            raise gdb.GdbError(
+                "Unable to find the Python frame, run your code with a debug "
+                "build (configure with --with-pydebug or compile with -g).")
+        
+    def lineno(self, frame):
+        return self.pyframe(frame).current_line_num()
+    
+    def is_relevant_function(self, frame):
+        return Frame(frame).is_evalframeex()
+
+    def get_source_line(self, frame):
+        try:
+            return self.pyframe(frame).current_line().rstrip()
+        except IOError, e:
+            gdb.GdbError('Unable to retrieve source code: %s' % (e,))
+
+
+class PyStep(PythonCodeStepper):
+    "Step through Python code."
+
+class PyNext(PythonCodeStepper):
+    "Step-over Python code."
+
+py_step = PyStep('py-step', stepper=True)
+py_next = PyNext('py-next', stepper=False)
+
+class PyShowCCode(gdb.Parameter):
+    pass
\ No newline at end of file

bin/cygdb

@@ -6,7 +6,14 @@ from Cython.Debugger import Cygdb as cygdb
 
 if __name__ == '__main__':
     if len(sys.argv) > 1:
-        cygdb.main(path_to_debug_info=sys.argv[1], 
-                   gdb_argv=sys.argv[2:])
+        path_to_debug_info = sys.argv[1]
+        
+        no_import = False
+        if path_to_debug_info == '--':
+            no_import = True
+        
+        cygdb.main(path_to_debug_info, 
+                   gdb_argv=sys.argv[2:],
+                   no_import=no_import)
     else:
         cygdb.main()

cygdb.py

@@ -6,7 +6,14 @@ from Cython.Debugger import Cygdb as cygdb
 
 if __name__ == '__main__':
     if len(sys.argv) > 1:
-        cygdb.main(path_to_debug_info=sys.argv[1], 
-                   gdb_argv=sys.argv[2:])
+        path_to_debug_info = sys.argv[1]
+        
+        no_import = False
+        if path_to_debug_info == '--':
+            no_import = True
+        
+        cygdb.main(path_to_debug_info, 
+                   gdb_argv=sys.argv[2:],
+                   no_import=no_import)
     else:
         cygdb.main()