1435 lines
44 KiB
Python
1435 lines
44 KiB
Python
"""
|
|
GDB extension that adds Cython support.
|
|
"""
|
|
|
|
from __future__ import print_function
|
|
|
|
try:
|
|
input = raw_input
|
|
except NameError:
|
|
pass
|
|
|
|
import sys
|
|
import textwrap
|
|
import traceback
|
|
import functools
|
|
import itertools
|
|
import collections
|
|
|
|
import gdb
|
|
|
|
try: # python 2
|
|
UNICODE = unicode
|
|
BYTES = str
|
|
except NameError: # python 3
|
|
UNICODE = str
|
|
BYTES = bytes
|
|
|
|
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:
|
|
# normal ElementTree install
|
|
import elementtree.ElementTree as etree
|
|
|
|
try:
|
|
import pygments.lexers
|
|
import pygments.formatters
|
|
except ImportError:
|
|
pygments = None
|
|
sys.stderr.write("Install pygments for colorized source code.\n")
|
|
|
|
if hasattr(gdb, 'string_to_argv'):
|
|
from gdb import string_to_argv
|
|
else:
|
|
from shlex import split as string_to_argv
|
|
|
|
from Cython.Debugger import libpython
|
|
|
|
# C or Python type
|
|
CObject = 'CObject'
|
|
PythonObject = 'PythonObject'
|
|
|
|
_data_types = dict(CObject=CObject, PythonObject=PythonObject)
|
|
_filesystemencoding = sys.getfilesystemencoding() or 'UTF-8'
|
|
|
|
|
|
# decorators
|
|
|
|
def dont_suppress_errors(function):
|
|
"*sigh*, readline"
|
|
@functools.wraps(function)
|
|
def wrapper(*args, **kwargs):
|
|
try:
|
|
return function(*args, **kwargs)
|
|
except Exception:
|
|
traceback.print_exc()
|
|
raise
|
|
|
|
return wrapper
|
|
|
|
|
|
def default_selected_gdb_frame(err=True):
|
|
def decorator(function):
|
|
@functools.wraps(function)
|
|
def wrapper(self, frame=None, *args, **kwargs):
|
|
try:
|
|
frame = frame or gdb.selected_frame()
|
|
except RuntimeError:
|
|
raise gdb.GdbError("No frame is currently selected.")
|
|
|
|
if err and frame.name() is None:
|
|
raise NoFunctionNameInFrameError()
|
|
|
|
return function(self, frame, *args, **kwargs)
|
|
return wrapper
|
|
return decorator
|
|
|
|
|
|
def require_cython_frame(function):
|
|
@functools.wraps(function)
|
|
@require_running_program
|
|
def wrapper(self, *args, **kwargs):
|
|
frame = kwargs.get('frame') or gdb.selected_frame()
|
|
if not self.is_cython_function(frame):
|
|
raise gdb.GdbError('Selected frame does not correspond with a '
|
|
'Cython function we know about.')
|
|
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
|
|
|
|
|
|
def require_running_program(function):
|
|
@functools.wraps(function)
|
|
def wrapper(*args, **kwargs):
|
|
try:
|
|
gdb.selected_frame()
|
|
except RuntimeError:
|
|
raise gdb.GdbError("No frame is currently selected.")
|
|
|
|
return function(*args, **kwargs)
|
|
return wrapper
|
|
|
|
|
|
def gdb_function_value_to_unicode(function):
|
|
@functools.wraps(function)
|
|
def wrapper(self, string, *args, **kwargs):
|
|
if isinstance(string, gdb.Value):
|
|
string = string.string()
|
|
|
|
return function(self, string, *args, **kwargs)
|
|
return wrapper
|
|
|
|
|
|
# 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, 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 = {}
|
|
|
|
|
|
class CythonVariable(object):
|
|
|
|
def __init__(self, name, cname, qualified_name, type, lineno):
|
|
self.name = name
|
|
self.cname = cname
|
|
self.qualified_name = qualified_name
|
|
self.type = type
|
|
self.lineno = int(lineno)
|
|
|
|
|
|
class CythonFunction(CythonVariable):
|
|
def __init__(self,
|
|
module,
|
|
name,
|
|
cname,
|
|
pf_cname,
|
|
qualified_name,
|
|
lineno,
|
|
type=CObject,
|
|
is_initmodule_function="False"):
|
|
super(CythonFunction, self).__init__(name,
|
|
cname,
|
|
qualified_name,
|
|
type,
|
|
lineno)
|
|
self.module = module
|
|
self.pf_cname = pf_cname
|
|
self.is_initmodule_function = is_initmodule_function == "True"
|
|
self.locals = {}
|
|
self.arguments = []
|
|
self.step_into_functions = set()
|
|
|
|
|
|
# General purpose classes
|
|
|
|
class CythonBase(object):
|
|
|
|
@default_selected_gdb_frame(err=False)
|
|
def is_cython_function(self, frame):
|
|
return frame.name() in self.cy.functions_by_cname
|
|
|
|
@default_selected_gdb_frame(err=False)
|
|
def is_python_function(self, frame):
|
|
"""
|
|
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):
|
|
return frame.name()
|
|
|
|
@default_selected_gdb_frame()
|
|
def get_c_lineno(self, frame):
|
|
return frame.find_sal().line
|
|
|
|
@default_selected_gdb_frame()
|
|
def get_cython_function(self, frame):
|
|
result = self.cy.functions_by_cname.get(frame.name())
|
|
if result is None:
|
|
raise NoCythonFunctionInFrameError()
|
|
|
|
return result
|
|
|
|
@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), 0)
|
|
|
|
@default_selected_gdb_frame()
|
|
def get_source_desc(self, frame):
|
|
filename = lineno = lexer = None
|
|
if self.is_cython_function(frame):
|
|
filename = self.get_cython_function(frame).module.filename
|
|
lineno = self.get_cython_lineno(frame)
|
|
if pygments:
|
|
lexer = pygments.lexers.CythonLexer(stripall=False)
|
|
elif self.is_python_function(frame):
|
|
pyframeobject = libpython.Frame(frame).get_pyop()
|
|
|
|
if not pyframeobject:
|
|
raise gdb.GdbError(
|
|
'Unable to read information on python frame')
|
|
|
|
filename = pyframeobject.filename()
|
|
lineno = pyframeobject.current_line_num()
|
|
|
|
if pygments:
|
|
lexer = pygments.lexers.PythonLexer(stripall=False)
|
|
else:
|
|
symbol_and_line_obj = frame.find_sal()
|
|
if not symbol_and_line_obj or not symbol_and_line_obj.symtab:
|
|
filename = None
|
|
lineno = 0
|
|
else:
|
|
filename = symbol_and_line_obj.symtab.fullname()
|
|
lineno = symbol_and_line_obj.line
|
|
if pygments:
|
|
lexer = pygments.lexers.CLexer(stripall=False)
|
|
|
|
return SourceFileDescriptor(filename, lexer), lineno
|
|
|
|
@default_selected_gdb_frame()
|
|
def get_source_line(self, frame):
|
|
source_desc, lineno = self.get_source_desc()
|
|
return source_desc.get_source(lineno)
|
|
|
|
@default_selected_gdb_frame()
|
|
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 older_frame and self.is_cython_function(older_frame):
|
|
# check for 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
|
|
|
|
@default_selected_gdb_frame(err=False)
|
|
def print_stackframe(self, frame, index, is_c=False):
|
|
"""
|
|
Print a C, Cython or Python stack frame and the line of source code
|
|
if available.
|
|
"""
|
|
# do this to prevent the require_cython_frame decorator from
|
|
# raising GdbError when calling self.cy.cy_cvalue.invoke()
|
|
selected_frame = gdb.selected_frame()
|
|
frame.select()
|
|
|
|
try:
|
|
source_desc, lineno = self.get_source_desc(frame)
|
|
except NoFunctionNameInFrameError:
|
|
print('#%-2d Unknown Frame (compile with -g)' % index)
|
|
return
|
|
|
|
if not is_c and self.is_python_function(frame):
|
|
pyframe = libpython.Frame(frame).get_pyop()
|
|
if pyframe is None or pyframe.is_optimized_out():
|
|
# print this python function as a C function
|
|
return self.print_stackframe(frame, index, is_c=True)
|
|
|
|
func_name = pyframe.co_name
|
|
func_cname = 'PyEval_EvalFrameEx'
|
|
func_args = []
|
|
elif self.is_cython_function(frame):
|
|
cyfunc = self.get_cython_function(frame)
|
|
f = lambda arg: self.cy.cy_cvalue.invoke(arg, frame=frame)
|
|
|
|
func_name = cyfunc.name
|
|
func_cname = cyfunc.cname
|
|
func_args = [] # [(arg, f(arg)) for arg in cyfunc.arguments]
|
|
else:
|
|
source_desc, lineno = self.get_source_desc(frame)
|
|
func_name = frame.name()
|
|
func_cname = func_name
|
|
func_args = []
|
|
|
|
try:
|
|
gdb_value = gdb.parse_and_eval(func_cname)
|
|
except RuntimeError:
|
|
func_address = 0
|
|
else:
|
|
func_address = gdb_value.address
|
|
if not isinstance(func_address, int):
|
|
# Seriously? Why is the address not an int?
|
|
if not isinstance(func_address, (str, bytes)):
|
|
func_address = str(func_address)
|
|
func_address = int(func_address.split()[0], 0)
|
|
|
|
a = ', '.join('%s=%s' % (name, val) for name, val in func_args)
|
|
sys.stdout.write('#%-2d 0x%016x in %s(%s)' % (index, func_address, func_name, a))
|
|
|
|
if source_desc.filename is not None:
|
|
sys.stdout.write(' at %s:%s' % (source_desc.filename, lineno))
|
|
|
|
sys.stdout.write('\n')
|
|
|
|
try:
|
|
sys.stdout.write(' ' + source_desc.get_source(lineno))
|
|
except gdb.GdbError:
|
|
pass
|
|
|
|
selected_frame.select()
|
|
|
|
def get_remote_cython_globals_dict(self):
|
|
m = gdb.parse_and_eval('__pyx_m')
|
|
|
|
try:
|
|
PyModuleObject = gdb.lookup_type('PyModuleObject')
|
|
except RuntimeError:
|
|
raise gdb.GdbError(textwrap.dedent("""\
|
|
Unable to lookup type PyModuleObject, did you compile python
|
|
with debugging support (-g)?"""))
|
|
|
|
m = m.cast(PyModuleObject.pointer())
|
|
return m['md_dict']
|
|
|
|
|
|
def get_cython_globals_dict(self):
|
|
"""
|
|
Get the Cython globals dict where the remote names are turned into
|
|
local strings.
|
|
"""
|
|
remote_dict = self.get_remote_cython_globals_dict()
|
|
pyobject_dict = libpython.PyObjectPtr.from_pyobject_ptr(remote_dict)
|
|
|
|
result = {}
|
|
seen = set()
|
|
for k, v in pyobject_dict.items():
|
|
result[k.proxyval(seen)] = v
|
|
|
|
return result
|
|
|
|
def print_gdb_value(self, name, value, max_name_length=None, prefix=''):
|
|
if libpython.pretty_printer_lookup(value):
|
|
typename = ''
|
|
else:
|
|
typename = '(%s) ' % (value.type,)
|
|
|
|
if max_name_length is None:
|
|
print('%s%s = %s%s' % (prefix, name, typename, value))
|
|
else:
|
|
print('%s%-*s = %s%s' % (prefix, max_name_length, name, typename, value))
|
|
|
|
def is_initialized(self, cython_func, local_name):
|
|
cyvar = cython_func.locals[local_name]
|
|
cur_lineno = self.get_cython_lineno()
|
|
|
|
if '->' in cyvar.cname:
|
|
# Closed over free variable
|
|
if cur_lineno > cython_func.lineno:
|
|
if cyvar.type == PythonObject:
|
|
return int(gdb.parse_and_eval(cyvar.cname))
|
|
return True
|
|
return False
|
|
|
|
return cur_lineno > cyvar.lineno
|
|
|
|
|
|
class SourceFileDescriptor(object):
|
|
def __init__(self, filename, lexer, formatter=None):
|
|
self.filename = filename
|
|
self.lexer = lexer
|
|
self.formatter = formatter
|
|
|
|
def valid(self):
|
|
return self.filename is not None
|
|
|
|
def lex(self, code):
|
|
if pygments and self.lexer and parameters.colorize_code:
|
|
bg = parameters.terminal_background.value
|
|
if self.formatter is None:
|
|
formatter = pygments.formatters.TerminalFormatter(bg=bg)
|
|
else:
|
|
formatter = self.formatter
|
|
|
|
return pygments.highlight(code, self.lexer, formatter)
|
|
|
|
return code
|
|
|
|
def _get_source(self, start, stop, lex_source, mark_line, lex_entire):
|
|
with open(self.filename) as f:
|
|
# to provide "correct" colouring, the entire code needs to be
|
|
# lexed. However, this makes a lot of things terribly slow, so
|
|
# we decide not to. Besides, it's unlikely to matter.
|
|
|
|
if lex_source and lex_entire:
|
|
f = self.lex(f.read()).splitlines()
|
|
|
|
slice = itertools.islice(f, start - 1, stop - 1)
|
|
|
|
for idx, line in enumerate(slice):
|
|
if start + idx == mark_line:
|
|
prefix = '>'
|
|
else:
|
|
prefix = ' '
|
|
|
|
if lex_source and not lex_entire:
|
|
line = self.lex(line)
|
|
|
|
yield '%s %4d %s' % (prefix, start + idx, line.rstrip())
|
|
|
|
def get_source(self, start, stop=None, lex_source=True, mark_line=0,
|
|
lex_entire=False):
|
|
exc = gdb.GdbError('Unable to retrieve source code')
|
|
|
|
if not self.filename:
|
|
raise exc
|
|
|
|
start = max(start, 1)
|
|
if stop is None:
|
|
stop = start + 1
|
|
|
|
try:
|
|
return '\n'.join(
|
|
self._get_source(start, stop, lex_source, mark_line, lex_entire))
|
|
except IOError:
|
|
raise exc
|
|
|
|
|
|
# Errors
|
|
|
|
class CyGDBError(gdb.GdbError):
|
|
"""
|
|
Base class for Cython-command related errors
|
|
"""
|
|
|
|
def __init__(self, *args):
|
|
args = args or (self.msg,)
|
|
super(CyGDBError, self).__init__(*args)
|
|
|
|
|
|
class NoCythonFunctionInFrameError(CyGDBError):
|
|
"""
|
|
raised when the user requests the current cython function, which is
|
|
unavailable
|
|
"""
|
|
msg = "Current function is a function cygdb doesn't know about"
|
|
|
|
|
|
class NoFunctionNameInFrameError(NoCythonFunctionInFrameError):
|
|
"""
|
|
raised when the name of the C function could not be determined
|
|
in the current C stack frame
|
|
"""
|
|
msg = ('C function name could not be determined in the current C stack '
|
|
'frame')
|
|
|
|
|
|
# Parameters
|
|
|
|
class CythonParameter(gdb.Parameter):
|
|
"""
|
|
Base class for cython parameters
|
|
"""
|
|
|
|
def __init__(self, name, command_class, parameter_class, default=None):
|
|
self.show_doc = self.set_doc = self.__class__.__doc__
|
|
super(CythonParameter, self).__init__(name, command_class,
|
|
parameter_class)
|
|
if default is not None:
|
|
self.value = default
|
|
|
|
def __bool__(self):
|
|
return bool(self.value)
|
|
|
|
__nonzero__ = __bool__ # Python 2
|
|
|
|
|
|
|
|
class CompleteUnqualifiedFunctionNames(CythonParameter):
|
|
"""
|
|
Have 'cy break' complete unqualified function or method names.
|
|
"""
|
|
|
|
|
|
class ColorizeSourceCode(CythonParameter):
|
|
"""
|
|
Tell cygdb whether to colorize source code.
|
|
"""
|
|
|
|
|
|
class TerminalBackground(CythonParameter):
|
|
"""
|
|
Tell cygdb about the user's terminal background (light or dark).
|
|
"""
|
|
|
|
|
|
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).
|
|
"""
|
|
|
|
def __init__(self):
|
|
self.complete_unqualified = CompleteUnqualifiedFunctionNames(
|
|
'cy_complete_unqualified',
|
|
gdb.COMMAND_BREAKPOINTS,
|
|
gdb.PARAM_BOOLEAN,
|
|
True)
|
|
self.colorize_code = ColorizeSourceCode(
|
|
'cy_colorize_code',
|
|
gdb.COMMAND_FILES,
|
|
gdb.PARAM_BOOLEAN,
|
|
True)
|
|
self.terminal_background = TerminalBackground(
|
|
'cy_terminal_background_color',
|
|
gdb.COMMAND_FILES,
|
|
gdb.PARAM_STRING,
|
|
"dark")
|
|
|
|
parameters = CythonParameters()
|
|
|
|
|
|
# Commands
|
|
|
|
class CythonCommand(gdb.Command, CythonBase):
|
|
"""
|
|
Base class for Cython commands
|
|
"""
|
|
|
|
command_class = gdb.COMMAND_NONE
|
|
|
|
@classmethod
|
|
def _register(cls, clsname, args, kwargs):
|
|
if not hasattr(cls, 'completer_class'):
|
|
return cls(clsname, cls.command_class, *args, **kwargs)
|
|
else:
|
|
return cls(clsname, cls.command_class, cls.completer_class,
|
|
*args, **kwargs)
|
|
|
|
@classmethod
|
|
def register(cls, *args, **kwargs):
|
|
alias = getattr(cls, 'alias', None)
|
|
if alias:
|
|
cls._register(cls.alias, args, kwargs)
|
|
|
|
return cls._register(cls.name, args, kwargs)
|
|
|
|
|
|
class CyCy(CythonCommand):
|
|
"""
|
|
Invoke a Cython command. Available commands are:
|
|
|
|
cy import
|
|
cy break
|
|
cy step
|
|
cy next
|
|
cy run
|
|
cy cont
|
|
cy finish
|
|
cy up
|
|
cy down
|
|
cy select
|
|
cy bt / cy backtrace
|
|
cy list
|
|
cy print
|
|
cy set
|
|
cy locals
|
|
cy globals
|
|
cy exec
|
|
"""
|
|
|
|
name = 'cy'
|
|
command_class = gdb.COMMAND_NONE
|
|
completer_class = gdb.COMPLETE_COMMAND
|
|
|
|
def __init__(self, name, command_class, completer_class):
|
|
# keep the signature 2.5 compatible (i.e. do not use f(*a, k=v)
|
|
super(CythonCommand, self).__init__(name, command_class,
|
|
completer_class, prefix=True)
|
|
|
|
commands = dict(
|
|
# GDB commands
|
|
import_ = CyImport.register(),
|
|
break_ = CyBreak.register(),
|
|
step = CyStep.register(),
|
|
next = CyNext.register(),
|
|
run = CyRun.register(),
|
|
cont = CyCont.register(),
|
|
finish = CyFinish.register(),
|
|
up = CyUp.register(),
|
|
down = CyDown.register(),
|
|
select = CySelect.register(),
|
|
bt = CyBacktrace.register(),
|
|
list = CyList.register(),
|
|
print_ = CyPrint.register(),
|
|
locals = CyLocals.register(),
|
|
globals = CyGlobals.register(),
|
|
exec_ = libpython.FixGdbCommand('cy exec', '-cy-exec'),
|
|
_exec = CyExec.register(),
|
|
set = CySet.register(),
|
|
|
|
# GDB functions
|
|
cy_cname = CyCName('cy_cname'),
|
|
cy_cvalue = CyCValue('cy_cvalue'),
|
|
cy_lineno = CyLine('cy_lineno'),
|
|
cy_eval = CyEval('cy_eval'),
|
|
)
|
|
|
|
for command_name, command in commands.items():
|
|
command.cy = self
|
|
setattr(self, command_name, command)
|
|
|
|
self.cy = self
|
|
|
|
# Cython module namespace
|
|
self.cython_namespace = {}
|
|
|
|
# maps (unique) qualified function names (e.g.
|
|
# cythonmodule.ClassName.method_name) to the CythonFunction object
|
|
self.functions_by_qualified_name = {}
|
|
|
|
# unique cnames of Cython functions
|
|
self.functions_by_cname = {}
|
|
|
|
# map function names like method_name to a list of all such
|
|
# CythonFunction objects
|
|
self.functions_by_name = collections.defaultdict(list)
|
|
|
|
|
|
class CyImport(CythonCommand):
|
|
"""
|
|
Import debug information outputted by the Cython compiler
|
|
Example: cy import FILE...
|
|
"""
|
|
|
|
name = 'cy import'
|
|
command_class = gdb.COMMAND_STATUS
|
|
completer_class = gdb.COMPLETE_FILENAME
|
|
|
|
def invoke(self, args, from_tty):
|
|
if isinstance(args, BYTES):
|
|
args = args.decode(_filesystemencoding)
|
|
for arg in string_to_argv(args):
|
|
try:
|
|
f = open(arg)
|
|
except OSError as e:
|
|
raise gdb.GdbError('Unable to open file %r: %s' % (args, e.args[1]))
|
|
|
|
t = etree.parse(f)
|
|
|
|
for module in t.getroot():
|
|
cython_module = CythonModule(**module.attrib)
|
|
self.cy.cython_namespace[cython_module.name] = cython_module
|
|
|
|
for variable in module.find('Globals'):
|
|
d = variable.attrib
|
|
cython_module.globals[d['name']] = CythonVariable(**d)
|
|
|
|
for function in module.find('Functions'):
|
|
cython_function = CythonFunction(module=cython_module,
|
|
**function.attrib)
|
|
|
|
# update the global function mappings
|
|
name = cython_function.name
|
|
qname = cython_function.qualified_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[qname] = cython_function
|
|
|
|
for local in function.find('Locals'):
|
|
d = local.attrib
|
|
cython_function.locals[d['name']] = CythonVariable(**d)
|
|
|
|
for step_into_func in function.find('StepIntoFunctions'):
|
|
d = step_into_func.attrib
|
|
cython_function.step_into_functions.add(d['name'])
|
|
|
|
cython_function.arguments.extend(
|
|
funcarg.tag for funcarg in function.find('Arguments'))
|
|
|
|
for marker in module.find('LineNumberMapping'):
|
|
cython_lineno = int(marker.attrib['cython_lineno'])
|
|
c_linenos = list(map(int, marker.attrib['c_linenos'].split()))
|
|
cython_module.lineno_cy2c[cython_lineno] = min(c_linenos)
|
|
for c_lineno in c_linenos:
|
|
cython_module.lineno_c2cy[c_lineno] = cython_lineno
|
|
|
|
|
|
class CyBreak(CythonCommand):
|
|
"""
|
|
Set a breakpoint for Cython code using Cython qualified name notation, e.g.:
|
|
|
|
cy break cython_modulename.ClassName.method_name...
|
|
|
|
or normal notation:
|
|
|
|
cy break function_or_method_name...
|
|
|
|
or for a line number:
|
|
|
|
cy break cython_module:lineno...
|
|
|
|
Set a Python breakpoint:
|
|
Break on any function or method named 'func' in module 'modname'
|
|
|
|
cy break -p modname.func...
|
|
|
|
Break on any function or method named 'func'
|
|
|
|
cy break -p func...
|
|
"""
|
|
|
|
name = 'cy break'
|
|
command_class = gdb.COMMAND_BREAKPOINTS
|
|
|
|
def _break_pyx(self, name):
|
|
modulename, _, lineno = name.partition(':')
|
|
lineno = int(lineno)
|
|
if modulename:
|
|
cython_module = self.cy.cython_namespace[modulename]
|
|
else:
|
|
cython_module = self.get_cython_function().module
|
|
|
|
if lineno in cython_module.lineno_cy2c:
|
|
c_lineno = cython_module.lineno_cy2c[lineno]
|
|
breakpoint = '%s:%s' % (cython_module.c_filename, c_lineno)
|
|
gdb.execute('break ' + breakpoint)
|
|
else:
|
|
raise gdb.GdbError("Not a valid line number. "
|
|
"Does it contain actual code?")
|
|
|
|
def _break_funcname(self, funcname):
|
|
func = self.cy.functions_by_qualified_name.get(funcname)
|
|
|
|
if func and func.is_initmodule_function:
|
|
func = None
|
|
|
|
break_funcs = [func]
|
|
|
|
if not func:
|
|
funcs = self.cy.functions_by_name.get(funcname) or []
|
|
funcs = [f for f in funcs if not f.is_initmodule_function]
|
|
|
|
if not funcs:
|
|
gdb.execute('break ' + funcname)
|
|
return
|
|
|
|
if len(funcs) > 1:
|
|
# multiple functions, let the user pick one
|
|
print('There are multiple such functions:')
|
|
for idx, func in enumerate(funcs):
|
|
print('%3d) %s' % (idx, func.qualified_name))
|
|
|
|
while True:
|
|
try:
|
|
result = input(
|
|
"Select a function, press 'a' for all "
|
|
"functions or press 'q' or '^D' to quit: ")
|
|
except EOFError:
|
|
return
|
|
else:
|
|
if result.lower() == 'q':
|
|
return
|
|
elif result.lower() == 'a':
|
|
break_funcs = funcs
|
|
break
|
|
elif (result.isdigit() and
|
|
0 <= int(result) < len(funcs)):
|
|
break_funcs = [funcs[int(result)]]
|
|
break
|
|
else:
|
|
print('Not understood...')
|
|
else:
|
|
break_funcs = [funcs[0]]
|
|
|
|
for func in break_funcs:
|
|
gdb.execute('break %s' % func.cname)
|
|
if func.pf_cname:
|
|
gdb.execute('break %s' % func.pf_cname)
|
|
|
|
def invoke(self, function_names, from_tty):
|
|
if isinstance(function_names, BYTES):
|
|
function_names = function_names.decode(_filesystemencoding)
|
|
argv = string_to_argv(function_names)
|
|
if function_names.startswith('-p'):
|
|
argv = argv[1:]
|
|
python_breakpoints = True
|
|
else:
|
|
python_breakpoints = False
|
|
|
|
for funcname in argv:
|
|
if python_breakpoints:
|
|
gdb.execute('py-break %s' % funcname)
|
|
elif ':' in funcname:
|
|
self._break_pyx(funcname)
|
|
else:
|
|
self._break_funcname(funcname)
|
|
|
|
@dont_suppress_errors
|
|
def complete(self, text, word):
|
|
# Filter init-module functions (breakpoints can be set using
|
|
# modulename:linenumber).
|
|
names = [n for n, L in self.cy.functions_by_name.items()
|
|
if any(not f.is_initmodule_function for f in L)]
|
|
qnames = [n for n, f in self.cy.functions_by_qualified_name.items()
|
|
if not f.is_initmodule_function]
|
|
|
|
if parameters.complete_unqualified:
|
|
all_names = itertools.chain(qnames, names)
|
|
else:
|
|
all_names = qnames
|
|
|
|
words = text.strip().split()
|
|
if not words or '.' not in words[-1]:
|
|
# complete unqualified
|
|
seen = set(text[:-len(word)].split())
|
|
return [n for n in all_names
|
|
if n.startswith(word) and n not in seen]
|
|
|
|
# complete qualified name
|
|
lastword = words[-1]
|
|
compl = [n for n in qnames if n.startswith(lastword)]
|
|
|
|
if len(lastword) > len(word):
|
|
# readline sees something (e.g. a '.') as a word boundary, so don't
|
|
# "recomplete" this prefix
|
|
strip_prefix_length = len(lastword) - len(word)
|
|
compl = [n[strip_prefix_length:] for n in compl]
|
|
|
|
return compl
|
|
|
|
|
|
class CythonInfo(CythonBase, libpython.PythonInfo):
|
|
"""
|
|
Implementation of the interface dictated by libpython.LanguageInfo.
|
|
"""
|
|
|
|
def lineno(self, frame):
|
|
# Take care of the Python and Cython levels. We need to care for both
|
|
# as we can't simply dispatch 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)
|
|
return super(CythonInfo, self).lineno(frame)
|
|
|
|
def get_source_line(self, frame):
|
|
try:
|
|
line = super(CythonInfo, self).get_source_line(frame)
|
|
except gdb.GdbError:
|
|
return None
|
|
else:
|
|
return line.strip() or None
|
|
|
|
def exc_info(self, frame):
|
|
if self.is_python_function:
|
|
return super(CythonInfo, self).exc_info(frame)
|
|
|
|
def runtime_break_functions(self):
|
|
if self.is_cython_function():
|
|
return self.get_cython_function().step_into_functions
|
|
return ()
|
|
|
|
def static_break_functions(self):
|
|
result = ['PyEval_EvalFrameEx']
|
|
result.extend(self.cy.functions_by_cname)
|
|
return result
|
|
|
|
|
|
class CythonExecutionControlCommand(CythonCommand,
|
|
libpython.ExecutionControlCommandBase):
|
|
|
|
@classmethod
|
|
def register(cls):
|
|
return cls(cls.name, cython_info)
|
|
|
|
|
|
class CyStep(CythonExecutionControlCommand, libpython.PythonStepperMixin):
|
|
"Step through Cython, Python or C code."
|
|
|
|
name = 'cy -step'
|
|
stepinto = True
|
|
|
|
def invoke(self, args, from_tty):
|
|
if self.is_python_function():
|
|
self.python_step(self.stepinto)
|
|
elif not self.is_cython_function():
|
|
if self.stepinto:
|
|
command = 'step'
|
|
else:
|
|
command = 'next'
|
|
|
|
self.finish_executing(gdb.execute(command, to_string=True))
|
|
else:
|
|
self.step(stepinto=self.stepinto)
|
|
|
|
|
|
class CyNext(CyStep):
|
|
"Step-over Cython, Python or C code."
|
|
|
|
name = 'cy -next'
|
|
stepinto = False
|
|
|
|
|
|
class CyRun(CythonExecutionControlCommand):
|
|
"""
|
|
Run a Cython program. This is like the 'run' command, except that it
|
|
displays Cython or Python source lines as well
|
|
"""
|
|
|
|
name = 'cy run'
|
|
|
|
invoke = CythonExecutionControlCommand.run
|
|
|
|
|
|
class CyCont(CythonExecutionControlCommand):
|
|
"""
|
|
Continue a Cython program. This is like the 'run' command, except that it
|
|
displays Cython or Python source lines as well.
|
|
"""
|
|
|
|
name = 'cy cont'
|
|
invoke = CythonExecutionControlCommand.cont
|
|
|
|
|
|
class CyFinish(CythonExecutionControlCommand):
|
|
"""
|
|
Execute until the function returns.
|
|
"""
|
|
name = 'cy finish'
|
|
|
|
invoke = CythonExecutionControlCommand.finish
|
|
|
|
|
|
class CyUp(CythonCommand):
|
|
"""
|
|
Go up a Cython, Python or relevant C frame.
|
|
"""
|
|
name = 'cy up'
|
|
_command = 'up'
|
|
|
|
def invoke(self, *args):
|
|
try:
|
|
gdb.execute(self._command, to_string=True)
|
|
while not self.is_relevant_function(gdb.selected_frame()):
|
|
gdb.execute(self._command, to_string=True)
|
|
except RuntimeError as e:
|
|
raise gdb.GdbError(*e.args)
|
|
|
|
frame = gdb.selected_frame()
|
|
index = 0
|
|
while frame:
|
|
frame = frame.older()
|
|
index += 1
|
|
|
|
self.print_stackframe(index=index - 1)
|
|
|
|
|
|
class CyDown(CyUp):
|
|
"""
|
|
Go down a Cython, Python or relevant C frame.
|
|
"""
|
|
|
|
name = 'cy down'
|
|
_command = 'down'
|
|
|
|
|
|
class CySelect(CythonCommand):
|
|
"""
|
|
Select a frame. Use frame numbers as listed in `cy backtrace`.
|
|
This command is useful because `cy backtrace` prints a reversed backtrace.
|
|
"""
|
|
|
|
name = 'cy select'
|
|
|
|
def invoke(self, stackno, from_tty):
|
|
try:
|
|
stackno = int(stackno)
|
|
except ValueError:
|
|
raise gdb.GdbError("Not a valid number: %r" % (stackno,))
|
|
|
|
frame = gdb.selected_frame()
|
|
while frame.newer():
|
|
frame = frame.newer()
|
|
|
|
stackdepth = libpython.stackdepth(frame)
|
|
|
|
try:
|
|
gdb.execute('select %d' % (stackdepth - stackno - 1,))
|
|
except RuntimeError as e:
|
|
raise gdb.GdbError(*e.args)
|
|
|
|
|
|
class CyBacktrace(CythonCommand):
|
|
'Print the Cython stack'
|
|
|
|
name = 'cy bt'
|
|
alias = 'cy backtrace'
|
|
command_class = gdb.COMMAND_STACK
|
|
completer_class = gdb.COMPLETE_NONE
|
|
|
|
@require_running_program
|
|
def invoke(self, args, from_tty):
|
|
# get the first frame
|
|
frame = gdb.selected_frame()
|
|
while frame.older():
|
|
frame = frame.older()
|
|
|
|
print_all = args == '-a'
|
|
|
|
index = 0
|
|
while frame:
|
|
try:
|
|
is_relevant = self.is_relevant_function(frame)
|
|
except CyGDBError:
|
|
is_relevant = False
|
|
|
|
if print_all or is_relevant:
|
|
self.print_stackframe(frame, index)
|
|
|
|
index += 1
|
|
frame = frame.newer()
|
|
|
|
|
|
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,
|
|
lex_entire=True)
|
|
print(source)
|
|
|
|
|
|
class CyPrint(CythonCommand):
|
|
"""
|
|
Print a Cython variable using 'cy-print x' or 'cy-print module.function.x'
|
|
"""
|
|
|
|
name = 'cy print'
|
|
command_class = gdb.COMMAND_DATA
|
|
|
|
def invoke(self, name, from_tty, max_name_length=None):
|
|
if self.is_python_function():
|
|
return gdb.execute('py-print ' + name)
|
|
elif self.is_cython_function():
|
|
value = self.cy.cy_cvalue.invoke(name.lstrip('*'))
|
|
for c in name:
|
|
if c == '*':
|
|
value = value.dereference()
|
|
else:
|
|
break
|
|
|
|
self.print_gdb_value(name, value, max_name_length)
|
|
else:
|
|
gdb.execute('print ' + name)
|
|
|
|
def complete(self):
|
|
if self.is_cython_function():
|
|
f = self.get_cython_function()
|
|
return list(itertools.chain(f.locals, f.globals))
|
|
else:
|
|
return []
|
|
|
|
|
|
sortkey = lambda item: item[0].lower()
|
|
|
|
|
|
class CyLocals(CythonCommand):
|
|
"""
|
|
List the locals from the current Cython frame.
|
|
"""
|
|
|
|
name = 'cy locals'
|
|
command_class = gdb.COMMAND_STACK
|
|
completer_class = gdb.COMPLETE_NONE
|
|
|
|
@dispatch_on_frame(c_command='info locals', python_command='py-locals')
|
|
def invoke(self, args, from_tty):
|
|
cython_function = self.get_cython_function()
|
|
|
|
if cython_function.is_initmodule_function:
|
|
self.cy.globals.invoke(args, from_tty)
|
|
return
|
|
|
|
local_cython_vars = cython_function.locals
|
|
max_name_length = len(max(local_cython_vars, key=len))
|
|
for name, cyvar in sorted(local_cython_vars.items(), key=sortkey):
|
|
if self.is_initialized(self.get_cython_function(), cyvar.name):
|
|
value = gdb.parse_and_eval(cyvar.cname)
|
|
if not value.is_optimized_out:
|
|
self.print_gdb_value(cyvar.name, value,
|
|
max_name_length, '')
|
|
|
|
|
|
class CyGlobals(CyLocals):
|
|
"""
|
|
List the globals from the current Cython module.
|
|
"""
|
|
|
|
name = 'cy globals'
|
|
command_class = gdb.COMMAND_STACK
|
|
completer_class = gdb.COMPLETE_NONE
|
|
|
|
@dispatch_on_frame(c_command='info variables', python_command='py-globals')
|
|
def invoke(self, args, from_tty):
|
|
global_python_dict = self.get_cython_globals_dict()
|
|
module_globals = self.get_cython_function().module.globals
|
|
|
|
max_globals_len = 0
|
|
max_globals_dict_len = 0
|
|
if module_globals:
|
|
max_globals_len = len(max(module_globals, key=len))
|
|
if global_python_dict:
|
|
max_globals_dict_len = len(max(global_python_dict))
|
|
|
|
max_name_length = max(max_globals_len, max_globals_dict_len)
|
|
|
|
seen = set()
|
|
print('Python globals:')
|
|
for k, v in sorted(global_python_dict.items(), key=sortkey):
|
|
v = v.get_truncated_repr(libpython.MAX_OUTPUT_LEN)
|
|
seen.add(k)
|
|
print(' %-*s = %s' % (max_name_length, k, v))
|
|
|
|
print('C globals:')
|
|
for name, cyvar in sorted(module_globals.items(), key=sortkey):
|
|
if name not in seen:
|
|
try:
|
|
value = gdb.parse_and_eval(cyvar.cname)
|
|
except RuntimeError:
|
|
pass
|
|
else:
|
|
if not value.is_optimized_out:
|
|
self.print_gdb_value(cyvar.name, value,
|
|
max_name_length, ' ')
|
|
|
|
|
|
class EvaluateOrExecuteCodeMixin(object):
|
|
"""
|
|
Evaluate or execute Python code in a Cython or Python frame. The 'evalcode'
|
|
method evaluations Python code, prints a traceback if an exception went
|
|
uncaught, and returns any return value as a gdb.Value (NULL on exception).
|
|
"""
|
|
|
|
def _fill_locals_dict(self, executor, local_dict_pointer):
|
|
"Fill a remotely allocated dict with values from the Cython C stack"
|
|
cython_func = self.get_cython_function()
|
|
|
|
for name, cyvar in cython_func.locals.items():
|
|
if cyvar.type == PythonObject and self.is_initialized(cython_func, name):
|
|
try:
|
|
val = gdb.parse_and_eval(cyvar.cname)
|
|
except RuntimeError:
|
|
continue
|
|
else:
|
|
if val.is_optimized_out:
|
|
continue
|
|
|
|
pystringp = executor.alloc_pystring(name)
|
|
code = '''
|
|
(PyObject *) PyDict_SetItem(
|
|
(PyObject *) %d,
|
|
(PyObject *) %d,
|
|
(PyObject *) %s)
|
|
''' % (local_dict_pointer, pystringp, cyvar.cname)
|
|
|
|
try:
|
|
if gdb.parse_and_eval(code) < 0:
|
|
gdb.parse_and_eval('PyErr_Print()')
|
|
raise gdb.GdbError("Unable to execute Python code.")
|
|
finally:
|
|
# PyDict_SetItem doesn't steal our reference
|
|
executor.xdecref(pystringp)
|
|
|
|
def _find_first_cython_or_python_frame(self):
|
|
frame = gdb.selected_frame()
|
|
while frame:
|
|
if (self.is_cython_function(frame) or
|
|
self.is_python_function(frame)):
|
|
frame.select()
|
|
return frame
|
|
|
|
frame = frame.older()
|
|
|
|
raise gdb.GdbError("There is no Cython or Python frame on the stack.")
|
|
|
|
def _evalcode_cython(self, executor, code, input_type):
|
|
with libpython.FetchAndRestoreError():
|
|
# get the dict of Cython globals and construct a dict in the
|
|
# inferior with Cython locals
|
|
global_dict = gdb.parse_and_eval(
|
|
'(PyObject *) PyModule_GetDict(__pyx_m)')
|
|
local_dict = gdb.parse_and_eval('(PyObject *) PyDict_New()')
|
|
|
|
try:
|
|
self._fill_locals_dict(executor,
|
|
libpython.pointervalue(local_dict))
|
|
result = executor.evalcode(code, input_type, global_dict,
|
|
local_dict)
|
|
finally:
|
|
executor.xdecref(libpython.pointervalue(local_dict))
|
|
|
|
return result
|
|
|
|
def evalcode(self, code, input_type):
|
|
"""
|
|
Evaluate `code` in a Python or Cython stack frame using the given
|
|
`input_type`.
|
|
"""
|
|
frame = self._find_first_cython_or_python_frame()
|
|
executor = libpython.PythonCodeExecutor()
|
|
if self.is_python_function(frame):
|
|
return libpython._evalcode_python(executor, code, input_type)
|
|
return self._evalcode_cython(executor, code, input_type)
|
|
|
|
|
|
class CyExec(CythonCommand, libpython.PyExec, EvaluateOrExecuteCodeMixin):
|
|
"""
|
|
Execute Python code in the nearest Python or Cython frame.
|
|
"""
|
|
|
|
name = '-cy-exec'
|
|
command_class = gdb.COMMAND_STACK
|
|
completer_class = gdb.COMPLETE_NONE
|
|
|
|
def invoke(self, expr, from_tty):
|
|
expr, input_type = self.readcode(expr)
|
|
executor = libpython.PythonCodeExecutor()
|
|
executor.xdecref(self.evalcode(expr, executor.Py_single_input))
|
|
|
|
|
|
class CySet(CythonCommand):
|
|
"""
|
|
Set a Cython variable to a certain value
|
|
|
|
cy set my_cython_c_variable = 10
|
|
cy set my_cython_py_variable = $cy_eval("{'doner': 'kebab'}")
|
|
|
|
This is equivalent to
|
|
|
|
set $cy_value("my_cython_variable") = 10
|
|
"""
|
|
|
|
name = 'cy set'
|
|
command_class = gdb.COMMAND_DATA
|
|
completer_class = gdb.COMPLETE_NONE
|
|
|
|
@require_cython_frame
|
|
def invoke(self, expr, from_tty):
|
|
name_and_expr = expr.split('=', 1)
|
|
if len(name_and_expr) != 2:
|
|
raise gdb.GdbError("Invalid expression. Use 'cy set var = expr'.")
|
|
|
|
varname, expr = name_and_expr
|
|
cname = self.cy.cy_cname.invoke(varname.strip())
|
|
gdb.execute("set %s = %s" % (cname, expr))
|
|
|
|
|
|
# Functions
|
|
|
|
class CyCName(gdb.Function, CythonBase):
|
|
"""
|
|
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
|
|
@gdb_function_value_to_unicode
|
|
def invoke(self, cyname, frame=None):
|
|
frame = frame or gdb.selected_frame()
|
|
cname = None
|
|
|
|
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)
|
|
|
|
return cname
|
|
|
|
|
|
class CyCValue(CyCName):
|
|
"""
|
|
Get the value of a Cython variable.
|
|
"""
|
|
|
|
@require_cython_frame
|
|
@gdb_function_value_to_unicode
|
|
def invoke(self, cyname, frame=None):
|
|
globals_dict = self.get_cython_globals_dict()
|
|
cython_function = self.get_cython_function(frame)
|
|
|
|
if self.is_initialized(cython_function, cyname):
|
|
cname = super(CyCValue, self).invoke(cyname, frame=frame)
|
|
return gdb.parse_and_eval(cname)
|
|
elif cyname in globals_dict:
|
|
return globals_dict[cyname]._gdbval
|
|
else:
|
|
raise gdb.GdbError("Variable %s is not initialized." % cyname)
|
|
|
|
|
|
class CyLine(gdb.Function, CythonBase):
|
|
"""
|
|
Get the current Cython line.
|
|
"""
|
|
|
|
@require_cython_frame
|
|
def invoke(self):
|
|
return self.get_cython_lineno()
|
|
|
|
|
|
class CyEval(gdb.Function, CythonBase, EvaluateOrExecuteCodeMixin):
|
|
"""
|
|
Evaluate Python code in the nearest Python or Cython frame and return
|
|
"""
|
|
|
|
@gdb_function_value_to_unicode
|
|
def invoke(self, python_expression):
|
|
input_type = libpython.PythonCodeExecutor.Py_eval_input
|
|
return self.evalcode(python_expression, input_type)
|
|
|
|
|
|
cython_info = CythonInfo()
|
|
cy = CyCy.register()
|
|
cython_info.cy = cy
|
|
|
|
|
|
def register_defines():
|
|
libpython.source_gdb_script(textwrap.dedent("""\
|
|
define cy step
|
|
cy -step
|
|
end
|
|
|
|
define cy next
|
|
cy -next
|
|
end
|
|
|
|
document cy step
|
|
%s
|
|
end
|
|
|
|
document cy next
|
|
%s
|
|
end
|
|
""") % (CyStep.__doc__, CyNext.__doc__))
|
|
|
|
register_defines()
|