debugger.py
972 lines
| 32.9 KiB
| text/x-python
|
PythonLexer
|
r0 | # -*- coding: utf-8 -*- | ||
""" | ||||
Pdb debugger class. | ||||
Modified from the standard pdb.Pdb class to avoid including readline, so that | ||||
the command line completion of other programs which include this isn't | ||||
damaged. | ||||
In the future, this class will be expanded with improvements over the standard | ||||
pdb. | ||||
The code in this file is mainly lifted out of cmd.py in Python 2.2, with minor | ||||
changes. Licensing should therefore be under the standard Python terms. For | ||||
details on the PSF (Python Software Foundation) standard license, see: | ||||
|
r23220 | https://docs.python.org/2/license.html | ||
""" | ||||
|
r88 | |||
#***************************************************************************** | ||||
# | ||||
|
r911 | # This file is licensed under the PSF license. | ||
|
r88 | # | ||
# Copyright (C) 2001 Python Software Foundation, www.python.org | ||||
# Copyright (C) 2005-2006 Fernando Perez. <fperez@colorado.edu> | ||||
# | ||||
# | ||||
#***************************************************************************** | ||||
|
r52 | import bdb | ||
|
r8679 | import functools | ||
|
r21395 | import inspect | ||
|
r23116 | import linecache | ||
|
r52 | import sys | ||
|
r22687 | import warnings | ||
|
r24092 | import re | ||
|
r26540 | import os | ||
|
r52 | |||
|
r10580 | from IPython import get_ipython | ||
|
r23116 | from IPython.utils import PyColorize | ||
|
r22192 | from IPython.utils import coloransi, py3compat | ||
|
r2021 | from IPython.core.excolors import exception_colors | ||
|
r12286 | from IPython.testing.skipdoctest import skip_doctest | ||
|
r22390 | |||
|
r22383 | |||
|
r552 | prompt = 'ipdb> ' | ||
|
r22359 | |||
|
r26325 | # We have to check this directly from sys.argv, config struct not yet available | ||
|
r22359 | from pdb import Pdb as OldPdb | ||
|
r393 | |||
|
r506 | # Allow the set_trace code to operate outside of an ipython instance, even if | ||
# it does so with some limitations. The rest of this support is implemented in | ||||
# the Tracer constructor. | ||||
|
r22083 | |||
|
r26325 | |||
|
r22083 | def make_arrow(pad): | ||
"""generate the leading arrow in front of traceback or debugger""" | ||||
if pad >= 2: | ||||
return '-'*(pad-2) + '> ' | ||||
elif pad == 1: | ||||
return '>' | ||||
return '' | ||||
|
r8679 | def BdbQuit_excepthook(et, ev, tb, excepthook=None): | ||
"""Exception hook which handles `BdbQuit` exceptions. | ||||
All other exceptions are processed using the `excepthook` | ||||
parameter. | ||||
""" | ||||
|
r22687 | warnings.warn("`BdbQuit_excepthook` is deprecated since version 5.1", | ||
|
r22994 | DeprecationWarning, stacklevel=2) | ||
|
r26325 | if et == bdb.BdbQuit: | ||
|
r7817 | print('Exiting Debugger.') | ||
|
r8679 | elif excepthook is not None: | ||
excepthook(et, ev, tb) | ||||
|
r506 | else: | ||
|
r8679 | # Backwards compatibility. Raise deprecation warning? | ||
|
r26325 | BdbQuit_excepthook.excepthook_ori(et, ev, tb) | ||
|
r506 | |||
|
r22687 | |||
|
r26325 | def BdbQuit_IPython_excepthook(self, et, ev, tb, tb_offset=None): | ||
|
r22687 | warnings.warn( | ||
"`BdbQuit_IPython_excepthook` is deprecated since version 5.1", | ||||
|
r22994 | DeprecationWarning, stacklevel=2) | ||
|
r7817 | print('Exiting Debugger.') | ||
|
r506 | |||
|
r2290 | |||
|
r506 | class Tracer(object): | ||
|
r22724 | """ | ||
DEPRECATED | ||||
Class for local debugging, similar to pdb.set_trace. | ||||
|
r506 | |||
Instances of this class, when called, behave like pdb.set_trace, but | ||||
providing IPython's enhanced capabilities. | ||||
This is implemented as a class which must be initialized in your own code | ||||
and not as a standalone function because we need to detect at runtime | ||||
whether IPython is already active or not. That detection is done in the | ||||
constructor, ensuring that this code plays nicely with a running IPython, | ||||
while functioning acceptably (though with limitations) if outside of it. | ||||
""" | ||||
|
r12286 | @skip_doctest | ||
|
r21876 | def __init__(self, colors=None): | ||
|
r22724 | """ | ||
DEPRECATED | ||||
Create a local debugger instance. | ||||
|
r506 | |||
|
r12553 | Parameters | ||
---------- | ||||
colors : str, optional | ||||
The name of the color scheme to use, it must be one of IPython's | ||||
valid color schemes. If not given, the function will default to | ||||
the current IPython scheme when running inside IPython, and to | ||||
'NoColor' otherwise. | ||||
|
r506 | |||
|
r12553 | Examples | ||
-------- | ||||
:: | ||||
|
r506 | |||
|
r12553 | from IPython.core.debugger import Tracer; debug_here = Tracer() | ||
|
r506 | |||
|
r12553 | Later in your code:: | ||
|
r21692 | |||
|
r12553 | debug_here() # -> will open up the debugger at that point. | ||
|
r506 | |||
Once the debugger activates, you can use all of its regular commands to | ||||
step through code, set breakpoints, etc. See the pdb documentation | ||||
from the Python standard library for usage details. | ||||
""" | ||||
|
r22687 | warnings.warn("`Tracer` is deprecated since version 5.1, directly use " | ||
"`IPython.core.debugger.Pdb.set_trace()`", | ||||
|
r22994 | DeprecationWarning, stacklevel=2) | ||
|
r506 | |||
|
r10580 | ip = get_ipython() | ||
if ip is None: | ||||
|
r506 | # Outside of ipython, we set our own exception hook manually | ||
|
r8679 | sys.excepthook = functools.partial(BdbQuit_excepthook, | ||
excepthook=sys.excepthook) | ||||
|
r506 | def_colors = 'NoColor' | ||
else: | ||||
# In ipython, we use its custom exception handler mechanism | ||||
|
r2205 | def_colors = ip.colors | ||
|
r2290 | ip.set_custom_exc((bdb.BdbQuit,), BdbQuit_IPython_excepthook) | ||
|
r506 | |||
if colors is None: | ||||
colors = def_colors | ||||
|
r7083 | |||
# The stdlib debugger internally uses a modified repr from the `repr` | ||||
# module, that limits the length of printed strings to a hardcoded | ||||
# limit of 30 characters. That much trimming is too aggressive, let's | ||||
# at least raise that limit to 80 chars, which should be enough for | ||||
# most interactive uses. | ||||
try: | ||||
|
r25369 | from reprlib import aRepr | ||
|
r7083 | aRepr.maxstring = 80 | ||
except: | ||||
# This is only a user-facing convenience, so any error we encounter | ||||
# here can be warned about but can be otherwise ignored. These | ||||
|
r8678 | # printouts will tell us about problems if this API changes | ||
|
r7083 | import traceback | ||
traceback.print_exc() | ||||
|
r506 | self.debugger = Pdb(colors) | ||
def __call__(self): | ||||
"""Starts an interactive debugger at the point where called. | ||||
This is similar to the pdb.set_trace() function from the std lib, but | ||||
using IPython's enhanced debugger.""" | ||||
|
r4872 | |||
|
r506 | self.debugger.set_trace(sys._getframe().f_back) | ||
|
r2290 | |||
|
r24451 | RGX_EXTRA_INDENT = re.compile(r'(?<=\n)\s+') | ||
|
r24093 | |||
|
r24092 | def strip_indentation(multiline_string): | ||
return RGX_EXTRA_INDENT.sub('', multiline_string) | ||||
|
r393 | def decorate_fn_with_doc(new_fn, old_fn, additional_text=""): | ||
"""Make new_fn have old_fn's doc string. This is particularly useful | ||||
|
r9244 | for the ``do_...`` commands that hook into the help system. | ||
|
r393 | Adapted from from a comp.lang.python posting | ||
by Duncan Booth.""" | ||||
def wrapper(*args, **kw): | ||||
return new_fn(*args, **kw) | ||||
if old_fn.__doc__: | ||||
|
r24092 | wrapper.__doc__ = strip_indentation(old_fn.__doc__) + additional_text | ||
|
r393 | return wrapper | ||
|
r2290 | |||
|
r23003 | class Pdb(OldPdb): | ||
|
r22724 | """Modified Pdb class, does not load readline. | ||
|
r22731 | for a standalone version that uses prompt_toolkit, see | ||
|
r22724 | `IPython.terminal.debugger.TerminalPdb` and | ||
`IPython.terminal.debugger.set_trace()` | ||||
|
r26566 | |||
This debugger can hide and skip frames that are tagged according to some predicates. | ||||
See the `skip_predicates` commands. | ||||
|
r22724 | """ | ||
|
r122 | |||
|
r26566 | default_predicates = {"tbhide": True, "readonly": False, "ipython_internal": True} | ||
|
r22687 | def __init__(self, color_scheme=None, completekey=None, | ||
|
r25172 | stdin=None, stdout=None, context=5, **kwargs): | ||
|
r25173 | """Create a new IPython debugger. | ||
|
r26325 | |||
|
r26566 | Parameters | ||
---------- | ||||
color_scheme : default None | ||||
Deprecated, do not use. | ||||
completekey : default None | ||||
Passed to pdb.Pdb. | ||||
stdin : default None | ||||
Passed to pdb.Pdb. | ||||
stdout : default None | ||||
Passed to pdb.Pdb. | ||||
context : int | ||||
Number of lines of source code context to show when | ||||
|
r25173 | displaying stacktrace information. | ||
|
r26566 | **kwargs | ||
Passed to pdb.Pdb. | ||||
Notes | ||||
----- | ||||
The possibilities are python version dependent, see the python | ||||
docs for more info. | ||||
|
r25173 | """ | ||
|
r367 | |||
|
r2290 | # Parent constructor: | ||
|
r21876 | try: | ||
|
r22687 | self.context = int(context) | ||
|
r21876 | if self.context <= 0: | ||
raise ValueError("Context must be a positive integer") | ||||
|
r25824 | except (TypeError, ValueError) as e: | ||
raise ValueError("Context must be a positive integer") from e | ||||
|
r25176 | |||
|
r25172 | # `kwargs` ensures full compatibility with stdlib's `pdb.Pdb`. | ||
OldPdb.__init__(self, completekey, stdin, stdout, **kwargs) | ||||
|
r4872 | |||
|
r2290 | # IPython changes... | ||
|
r10581 | self.shell = get_ipython() | ||
|
r367 | |||
|
r11114 | if self.shell is None: | ||
|
r22907 | save_main = sys.modules['__main__'] | ||
|
r11114 | # No IPython instance running, we must create one | ||
from IPython.terminal.interactiveshell import \ | ||||
TerminalInteractiveShell | ||||
self.shell = TerminalInteractiveShell.instance() | ||||
|
r22907 | # needed by any code which calls __import__("__main__") after | ||
# the debugger was entered. See also #9941. | ||||
|
r26328 | sys.modules["__main__"] = save_main | ||
|
r11114 | |||
|
r22687 | if color_scheme is not None: | ||
warnings.warn( | ||||
"The `color_scheme` argument is deprecated since version 5.1", | ||||
|
r22911 | DeprecationWarning, stacklevel=2) | ||
|
r22687 | else: | ||
color_scheme = self.shell.colors | ||||
|
r2290 | self.aliases = {} | ||
|
r553 | |||
|
r2290 | # Create color table: we copy the default one from the traceback | ||
# module and add a few attributes needed for debugging | ||||
self.color_scheme_table = exception_colors() | ||||
|
r367 | |||
|
r4872 | # shorthands | ||
|
r2290 | C = coloransi.TermColors | ||
cst = self.color_scheme_table | ||||
|
r367 | |||
|
r21692 | cst['NoColor'].colors.prompt = C.NoColor | ||
|
r2290 | cst['NoColor'].colors.breakpoint_enabled = C.NoColor | ||
cst['NoColor'].colors.breakpoint_disabled = C.NoColor | ||||
|
r367 | |||
|
r21692 | cst['Linux'].colors.prompt = C.Green | ||
|
r2290 | cst['Linux'].colors.breakpoint_enabled = C.LightRed | ||
cst['Linux'].colors.breakpoint_disabled = C.Red | ||||
|
r367 | |||
|
r21692 | cst['LightBG'].colors.prompt = C.Blue | ||
|
r2290 | cst['LightBG'].colors.breakpoint_enabled = C.LightRed | ||
cst['LightBG'].colors.breakpoint_disabled = C.Red | ||||
|
r367 | |||
|
r22609 | cst['Neutral'].colors.prompt = C.Blue | ||
cst['Neutral'].colors.breakpoint_enabled = C.LightRed | ||||
cst['Neutral'].colors.breakpoint_disabled = C.Red | ||||
|
r2290 | # Add a python parser so we can syntax highlight source while | ||
# debugging. | ||||
|
r22911 | self.parser = PyColorize.Parser(style=color_scheme) | ||
self.set_colors(color_scheme) | ||||
|
r553 | |||
|
r22094 | # Set the prompt - the default prompt is '(Pdb)' | ||
|
r22383 | self.prompt = prompt | ||
|
r25839 | self.skip_hidden = True | ||
|
r26573 | self.report_skipped = True | ||
|
r21692 | |||
|
r26540 | # list of predicates we use to skip frames | ||
|
r26566 | self._predicates = self.default_predicates | ||
|
r26540 | |||
|
r46 | def set_colors(self, scheme): | ||
"""Shorthand access to the color table scheme selector method.""" | ||||
self.color_scheme_table.set_active_scheme(scheme) | ||||
|
r22911 | self.parser.style = scheme | ||
|
r46 | |||
|
r26135 | def set_trace(self, frame=None): | ||
if frame is None: | ||||
frame = sys._getframe().f_back | ||||
self.initial_frame = frame | ||||
return super().set_trace(frame) | ||||
|
r25839 | |||
|
r26540 | def _hidden_predicate(self, frame): | ||
""" | ||||
Given a frame return whether it it should be hidden or not by IPython. | ||||
""" | ||||
if self._predicates["readonly"]: | ||||
fname = frame.f_code.co_filename | ||||
# we need to check for file existence and interactively define | ||||
# function would otherwise appear as RO. | ||||
if os.path.isfile(fname) and not os.access(fname, os.W_OK): | ||||
return True | ||||
if self._predicates["tbhide"]: | ||||
if frame in (self.curframe, getattr(self, "initial_frame", None)): | ||||
return False | ||||
else: | ||||
|
r26584 | return self._get_frame_locals(frame).get("__tracebackhide__", False) | ||
|
r26540 | |||
return False | ||||
|
r25839 | def hidden_frames(self, stack): | ||
""" | ||||
|
r26053 | Given an index in the stack return whether it should be skipped. | ||
|
r25839 | |||
This is used in up/down and where to skip frames. | ||||
""" | ||||
|
r25895 | # The f_locals dictionary is updated from the actual frame | ||
# locals whenever the .f_locals accessor is called, so we | ||||
# avoid calling it here to preserve self.curframe_locals. | ||||
# Futhermore, there is no good reason to hide the current frame. | ||||
|
r26540 | ip_hide = [self._hidden_predicate(s[0]) for s in stack] | ||
|
r25839 | ip_start = [i for i, s in enumerate(ip_hide) if s == "__ipython_bottom__"] | ||
|
r26540 | if ip_start and self._predicates["ipython_internal"]: | ||
|
r25839 | ip_hide = [h if i > ip_start[0] else True for (i, h) in enumerate(ip_hide)] | ||
return ip_hide | ||||
|
r46 | def interaction(self, frame, traceback): | ||
|
r22385 | try: | ||
OldPdb.interaction(self, frame, traceback) | ||||
except KeyboardInterrupt: | ||||
|
r25839 | self.stdout.write("\n" + self.shell.get_exception_only()) | ||
|
r393 | |||
|
r26327 | def precmd(self, line): | ||
"""Perform useful escapes on the command before it is executed.""" | ||||
|
r26328 | if line.endswith("??"): | ||
line = "pinfo2 " + line[:-2] | ||||
elif line.endswith("?"): | ||||
line = "pinfo " + line[:-1] | ||||
|
r26327 | |||
line = super().precmd(line) | ||||
return line | ||||
|
r393 | def new_do_frame(self, arg): | ||
OldPdb.do_frame(self, arg) | ||||
def new_do_quit(self, arg): | ||||
|
r4872 | |||
|
r465 | if hasattr(self, 'old_all_completions'): | ||
|
r26325 | self.shell.Completer.all_completions = self.old_all_completions | ||
|
r4872 | |||
|
r393 | return OldPdb.do_quit(self, arg) | ||
do_q = do_quit = decorate_fn_with_doc(new_do_quit, OldPdb.do_quit) | ||||
def new_do_restart(self, arg): | ||||
"""Restart command. In the context of ipython this is exactly the same | ||||
thing as 'quit'.""" | ||||
self.msg("Restart doesn't make sense here. Using 'quit' instead.") | ||||
return self.do_quit(arg) | ||||
|
r46 | |||
|
r21876 | def print_stack_trace(self, context=None): | ||
|
r25839 | Colors = self.color_scheme_table.active_colors | ||
ColorsNormal = Colors.Normal | ||||
|
r21876 | if context is None: | ||
context = self.context | ||||
try: | ||||
|
r26325 | context = int(context) | ||
|
r21876 | if context <= 0: | ||
raise ValueError("Context must be a positive integer") | ||||
|
r25824 | except (TypeError, ValueError) as e: | ||
raise ValueError("Context must be a positive integer") from e | ||||
|
r46 | try: | ||
|
r25839 | skipped = 0 | ||
for hidden, frame_lineno in zip(self.hidden_frames(self.stack), self.stack): | ||||
if hidden and self.skip_hidden: | ||||
skipped += 1 | ||||
continue | ||||
if skipped: | ||||
print( | ||||
f"{Colors.excName} [... skipping {skipped} hidden frame(s)]{ColorsNormal}\n" | ||||
) | ||||
skipped = 0 | ||||
|
r21876 | self.print_stack_entry(frame_lineno, context=context) | ||
|
r25839 | if skipped: | ||
print( | ||||
f"{Colors.excName} [... skipping {skipped} hidden frame(s)]{ColorsNormal}\n" | ||||
) | ||||
|
r46 | except KeyboardInterrupt: | ||
|
r0 | pass | ||
|
r46 | |||
|
r25083 | def print_stack_entry(self, frame_lineno, prompt_prefix='\n-> ', | ||
|
r21876 | context=None): | ||
if context is None: | ||||
context = self.context | ||||
try: | ||||
|
r26325 | context = int(context) | ||
|
r21876 | if context <= 0: | ||
raise ValueError("Context must be a positive integer") | ||||
|
r25824 | except (TypeError, ValueError) as e: | ||
raise ValueError("Context must be a positive integer") from e | ||||
|
r25083 | print(self.format_stack_entry(frame_lineno, '', context), file=self.stdout) | ||
|
r46 | |||
|
r1241 | # vds: >> | ||
frame, lineno = frame_lineno | ||||
filename = frame.f_code.co_filename | ||||
|
r2290 | self.shell.hooks.synchronize_with_editor(filename, lineno, 0) | ||
|
r1241 | # vds: << | ||
|
r26584 | def _get_frame_locals(self, frame): | ||
""" " | ||||
Acessing f_local of current frame reset the namespace, so we want to avoid | ||||
that or the following can happend | ||||
ipdb> foo | ||||
"old" | ||||
ipdb> foo = "new" | ||||
ipdb> foo | ||||
"new" | ||||
ipdb> where | ||||
ipdb> foo | ||||
"old" | ||||
So if frame is self.current_frame we instead return self.curframe_locals | ||||
""" | ||||
if frame is self.curframe: | ||||
return self.curframe_locals | ||||
else: | ||||
return frame.f_locals | ||||
|
r21876 | def format_stack_entry(self, frame_lineno, lprefix=': ', context=None): | ||
if context is None: | ||||
context = self.context | ||||
try: | ||||
|
r26325 | context = int(context) | ||
|
r21876 | if context <= 0: | ||
|
r25083 | print("Context must be a positive integer", file=self.stdout) | ||
|
r21876 | except (TypeError, ValueError): | ||
|
r25083 | print("Context must be a positive integer", file=self.stdout) | ||
|
r25516 | |||
import reprlib | ||||
|
r4872 | |||
|
r294 | ret = [] | ||
|
r4872 | |||
|
r46 | Colors = self.color_scheme_table.active_colors | ||
ColorsNormal = Colors.Normal | ||||
|
r26328 | tpl_link = "%s%%s%s" % (Colors.filenameEm, ColorsNormal) | ||
tpl_call = "%s%%s%s%%s%s" % (Colors.vName, Colors.valEm, ColorsNormal) | ||||
tpl_line = "%%s%s%%s %s%%s" % (Colors.lineno, ColorsNormal) | ||||
tpl_line_em = "%%s%s%%s %s%%s%s" % (Colors.linenoEm, Colors.line, ColorsNormal) | ||||
|
r4872 | |||
|
r46 | frame, lineno = frame_lineno | ||
|
r4872 | |||
|
r46 | return_value = '' | ||
|
r26584 | loc_frame = self._get_frame_locals(frame) | ||
if "__return__" in loc_frame: | ||||
rv = loc_frame["__return__"] | ||||
# return_value += '->' | ||||
return_value += reprlib.repr(rv) + "\n" | ||||
|
r294 | ret.append(return_value) | ||
|
r46 | |||
#s = filename + '(' + `lineno` + ')' | ||||
filename = self.canonic(frame.f_code.co_filename) | ||||
|
r8327 | link = tpl_link % py3compat.cast_unicode(filename) | ||
|
r4872 | |||
|
r46 | if frame.f_code.co_name: | ||
func = frame.f_code.co_name | ||||
else: | ||||
func = "<lambda>" | ||||
|
r4872 | |||
|
r26584 | call = "" | ||
if func != "?": | ||||
if "__args__" in loc_frame: | ||||
args = reprlib.repr(loc_frame["__args__"]) | ||||
|
r46 | else: | ||
args = '()' | ||||
call = tpl_call % (func, args) | ||||
|
r294 | |||
# The level info should be generated in the same format pdb uses, to | ||||
# avoid breaking the pdbtrack functionality of python-mode in *emacs. | ||||
|
r552 | if frame is self.curframe: | ||
ret.append('> ') | ||||
else: | ||||
|
r26328 | ret.append(" ") | ||
ret.append("%s(%s)%s\n" % (link, lineno, call)) | ||||
|
r4872 | |||
|
r46 | start = lineno - 1 - context//2 | ||
|
r23116 | lines = linecache.getlines(filename) | ||
|
r46 | start = min(start, len(lines) - context) | ||
|
r8895 | start = max(start, 0) | ||
|
r46 | lines = lines[start : start + context] | ||
|
r4872 | |||
|
r26325 | for i, line in enumerate(lines): | ||
|
r26328 | show_arrow = start + 1 + i == lineno | ||
linetpl = (frame is self.curframe or show_arrow) and tpl_line_em or tpl_line | ||||
ret.append( | ||||
self.__format_line( | ||||
linetpl, filename, start + 1 + i, line, arrow=show_arrow | ||||
) | ||||
) | ||||
return "".join(ret) | ||||
|
r46 | |||
|
r26325 | def __format_line(self, tpl_line, filename, lineno, line, arrow=False): | ||
|
r46 | bp_mark = "" | ||
bp_mark_color = "" | ||||
|
r22911 | new_line, err = self.parser.format2(line, 'str') | ||
if not err: | ||||
line = new_line | ||||
|
r553 | |||
|
r46 | bp = None | ||
if lineno in self.get_file_breaks(filename): | ||||
bps = self.get_breaks(filename, lineno) | ||||
bp = bps[-1] | ||||
|
r4872 | |||
|
r46 | if bp: | ||
Colors = self.color_scheme_table.active_colors | ||||
bp_mark = str(bp.number) | ||||
bp_mark_color = Colors.breakpoint_enabled | ||||
if not bp.enabled: | ||||
bp_mark_color = Colors.breakpoint_disabled | ||||
numbers_width = 7 | ||||
if arrow: | ||||
# This is the line with the error | ||||
pad = numbers_width - len(str(lineno)) - len(bp_mark) | ||||
|
r22083 | num = '%s%s' % (make_arrow(pad), str(lineno)) | ||
|
r46 | else: | ||
num = '%*s' % (numbers_width - len(bp_mark), str(lineno)) | ||||
|
r4872 | |||
|
r22083 | return tpl_line % (bp_mark_color + bp_mark, num, line) | ||
|
r393 | def print_list_lines(self, filename, first, last): | ||
"""The printing (as opposed to the parsing part of a 'list' | ||||
command.""" | ||||
try: | ||||
Colors = self.color_scheme_table.active_colors | ||||
ColorsNormal = Colors.Normal | ||||
tpl_line = '%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal) | ||||
tpl_line_em = '%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line, ColorsNormal) | ||||
src = [] | ||||
|
r8317 | if filename == "<string>" and hasattr(self, "_exec_filename"): | ||
|
r8324 | filename = self._exec_filename | ||
|
r8678 | |||
|
r393 | for lineno in range(first, last+1): | ||
|
r23116 | line = linecache.getline(filename, lineno) | ||
|
r393 | if not line: | ||
break | ||||
if lineno == self.curframe.f_lineno: | ||||
|
r26328 | line = self.__format_line( | ||
tpl_line_em, filename, lineno, line, arrow=True | ||||
) | ||||
|
r393 | else: | ||
|
r26328 | line = self.__format_line( | ||
tpl_line, filename, lineno, line, arrow=False | ||||
) | ||||
|
r393 | |||
src.append(line) | ||||
self.lineno = lineno | ||||
|
r25083 | print(''.join(src), file=self.stdout) | ||
|
r393 | |||
except KeyboardInterrupt: | ||||
pass | ||||
|
r26540 | def do_skip_predicates(self, args): | ||
""" | ||||
Turn on/off individual predicates as to whether a frame should be hidden/skip. | ||||
The global option to skip (or not) hidden frames is set with skip_hidden | ||||
To change the value of a predicate | ||||
skip_predicates key [true|false] | ||||
Call without arguments to see the current values. | ||||
|
r26566 | To permanently change the value of an option add the corresponding | ||
command to your ``~/.pdbrc`` file. If you are programmatically using the | ||||
Pdb instance you can also change the ``default_predicates`` class | ||||
attribute. | ||||
|
r26540 | """ | ||
if not args.strip(): | ||||
print("current predicates:") | ||||
for (p, v) in self._predicates.items(): | ||||
print(" ", p, ":", v) | ||||
return | ||||
type_value = args.strip().split(" ") | ||||
if len(type_value) != 2: | ||||
|
r26542 | print( | ||
f"Usage: skip_predicates <type> <value>, with <type> one of {set(self._predicates.keys())}" | ||||
) | ||||
|
r26540 | return | ||
type_, value = type_value | ||||
if type_ not in self._predicates: | ||||
print(f"{type_!r} not in {set(self._predicates.keys())}") | ||||
return | ||||
if value.lower() not in ("true", "yes", "1", "no", "false", "0"): | ||||
print( | ||||
|
r26542 | f"{value!r} is invalid - use one of ('true', 'yes', '1', 'no', 'false', '0')" | ||
|
r26540 | ) | ||
return | ||||
self._predicates[type_] = value.lower() in ("true", "yes", "1") | ||||
if not any(self._predicates.values()): | ||||
print( | ||||
"Warning, all predicates set to False, skip_hidden may not have any effects." | ||||
) | ||||
|
r25839 | def do_skip_hidden(self, arg): | ||
""" | ||||
Change whether or not we should skip frames with the | ||||
__tracebackhide__ attribute. | ||||
""" | ||||
|
r26540 | if not arg.strip(): | ||
print( | ||||
f"skip_hidden = {self.skip_hidden}, use 'yes','no', 'true', or 'false' to change." | ||||
) | ||||
elif arg.strip().lower() in ("true", "yes"): | ||||
|
r25839 | self.skip_hidden = True | ||
elif arg.strip().lower() in ("false", "no"): | ||||
self.skip_hidden = False | ||||
|
r26540 | if not any(self._predicates.values()): | ||
print( | ||||
"Warning, all predicates set to False, skip_hidden may not have any effects." | ||||
) | ||||
|
r25839 | |||
|
r46 | def do_list(self, arg): | ||
|
r23488 | """Print lines of code from the current stack frame | ||
""" | ||||
|
r46 | self.lastcmd = 'list' | ||
last = None | ||||
if arg: | ||||
try: | ||||
x = eval(arg, {}, {}) | ||||
if type(x) == type(()): | ||||
first, last = x | ||||
first = int(first) | ||||
last = int(last) | ||||
if last < first: | ||||
# Assume it's a count | ||||
last = first + last | ||||
else: | ||||
first = max(1, int(x) - 5) | ||||
except: | ||||
|
r25083 | print('*** Error in argument:', repr(arg), file=self.stdout) | ||
|
r46 | return | ||
elif self.lineno is None: | ||||
first = max(1, self.curframe.f_lineno - 5) | ||||
|
r0 | else: | ||
|
r46 | first = self.lineno + 1 | ||
if last is None: | ||||
last = first + 10 | ||||
|
r393 | self.print_list_lines(self.curframe.f_code.co_filename, first, last) | ||
|
r46 | |||
|
r1241 | # vds: >> | ||
lineno = first | ||||
filename = self.curframe.f_code.co_filename | ||||
|
r2290 | self.shell.hooks.synchronize_with_editor(filename, lineno, 0) | ||
|
r1241 | # vds: << | ||
|
r46 | do_l = do_list | ||
|
r393 | |||
|
r21395 | def getsourcelines(self, obj): | ||
lines, lineno = inspect.findsource(obj) | ||||
|
r26584 | if inspect.isframe(obj) and obj.f_globals is self._get_frame_locals(obj): | ||
|
r21395 | # must be a module frame: do not try to cut a block out of it | ||
return lines, 1 | ||||
elif inspect.ismodule(obj): | ||||
return lines, 1 | ||||
return inspect.getblock(lines[lineno:]), lineno+1 | ||||
def do_longlist(self, arg): | ||||
|
r23488 | """Print lines of code from the current stack frame. | ||
Shows more lines than 'list' does. | ||||
""" | ||||
|
r21395 | self.lastcmd = 'longlist' | ||
try: | ||||
lines, lineno = self.getsourcelines(self.curframe) | ||||
except OSError as err: | ||||
self.error(err) | ||||
return | ||||
last = lineno + len(lines) | ||||
self.print_list_lines(self.curframe.f_code.co_filename, lineno, last) | ||||
do_ll = do_longlist | ||||
|
r23823 | def do_debug(self, arg): | ||
"""debug code | ||||
Enter a recursive debugger that steps through the code | ||||
argument (which is an arbitrary expression or statement to be | ||||
executed in the current environment). | ||||
""" | ||||
|
r26149 | trace_function = sys.gettrace() | ||
|
r23823 | sys.settrace(None) | ||
globals = self.curframe.f_globals | ||||
locals = self.curframe_locals | ||||
p = self.__class__(completekey=self.completekey, | ||||
stdin=self.stdin, stdout=self.stdout) | ||||
p.use_rawinput = self.use_rawinput | ||||
p.prompt = "(%s) " % self.prompt.strip() | ||||
self.message("ENTERING RECURSIVE DEBUGGER") | ||||
sys.call_tracing(p.run, (arg, globals, locals)) | ||||
self.message("LEAVING RECURSIVE DEBUGGER") | ||||
|
r26149 | sys.settrace(trace_function) | ||
|
r23823 | self.lastcmd = p.lastcmd | ||
|
r393 | def do_pdef(self, arg): | ||
|
r8707 | """Print the call signature for any callable object. | ||
|
r8698 | |||
The debugger interface to %pdef""" | ||||
|
r26170 | namespaces = [ | ||
("Locals", self.curframe_locals), | ||||
("Globals", self.curframe.f_globals), | ||||
] | ||||
self.shell.find_line_magic("pdef")(arg, namespaces=namespaces) | ||||
|
r393 | |||
def do_pdoc(self, arg): | ||||
|
r8698 | """Print the docstring for an object. | ||
The debugger interface to %pdoc.""" | ||||
|
r26170 | namespaces = [ | ||
("Locals", self.curframe_locals), | ||||
("Globals", self.curframe.f_globals), | ||||
] | ||||
self.shell.find_line_magic("pdoc")(arg, namespaces=namespaces) | ||||
|
r393 | |||
|
r8699 | def do_pfile(self, arg): | ||
"""Print (or run through pager) the file where an object is defined. | ||||
The debugger interface to %pfile. | ||||
""" | ||||
|
r26170 | namespaces = [ | ||
("Locals", self.curframe_locals), | ||||
("Globals", self.curframe.f_globals), | ||||
] | ||||
self.shell.find_line_magic("pfile")(arg, namespaces=namespaces) | ||||
|
r8699 | |||
|
r393 | def do_pinfo(self, arg): | ||
|
r8698 | """Provide detailed information about an object. | ||
The debugger interface to %pinfo, i.e., obj?.""" | ||||
|
r26170 | namespaces = [ | ||
("Locals", self.curframe_locals), | ||||
("Globals", self.curframe.f_globals), | ||||
] | ||||
self.shell.find_line_magic("pinfo")(arg, namespaces=namespaces) | ||||
|
r8701 | |||
def do_pinfo2(self, arg): | ||||
"""Provide extra detailed information about an object. | ||||
The debugger interface to %pinfo2, i.e., obj??.""" | ||||
|
r26170 | namespaces = [ | ||
("Locals", self.curframe_locals), | ||||
("Globals", self.curframe.f_globals), | ||||
] | ||||
self.shell.find_line_magic("pinfo2")(arg, namespaces=namespaces) | ||||
|
r2372 | |||
|
r8700 | def do_psource(self, arg): | ||
"""Print (or run through pager) the source code for an object.""" | ||||
|
r26170 | namespaces = [ | ||
("Locals", self.curframe_locals), | ||||
("Globals", self.curframe.f_globals), | ||||
] | ||||
self.shell.find_line_magic("psource")(arg, namespaces=namespaces) | ||||
|
r21876 | |||
|
r22959 | def do_where(self, arg): | ||
"""w(here) | ||||
Print a stack trace, with the most recent frame at the bottom. | ||||
An arrow indicates the "current frame", which determines the | ||||
context of most commands. 'bt' is an alias for this command. | ||||
Take a number as argument as an (optional) number of context line to | ||||
print""" | ||||
if arg: | ||||
|
r25620 | try: | ||
context = int(arg) | ||||
|
r25622 | except ValueError as err: | ||
self.error(err) | ||||
|
r25620 | return | ||
|
r22959 | self.print_stack_trace(context) | ||
else: | ||||
self.print_stack_trace() | ||||
|
r21876 | |||
|
r22959 | do_w = do_where | ||
|
r22871 | |||
|
r25839 | def stop_here(self, frame): | ||
hidden = False | ||||
if self.skip_hidden: | ||||
|
r26540 | hidden = self._hidden_predicate(frame) | ||
|
r25839 | if hidden: | ||
|
r26573 | if self.report_skipped: | ||
Colors = self.color_scheme_table.active_colors | ||||
ColorsNormal = Colors.Normal | ||||
print( | ||||
f"{Colors.excName} [... skipped 1 hidden frame]{ColorsNormal}\n" | ||||
) | ||||
|
r25839 | return super().stop_here(frame) | ||
def do_up(self, arg): | ||||
"""u(p) [count] | ||||
Move the current frame count (default one) levels up in the | ||||
stack trace (to an older frame). | ||||
Will skip hidden frames. | ||||
""" | ||||
|
r26325 | # modified version of upstream that skips | ||
|
r26540 | # frames with __tracebackhide__ | ||
|
r25839 | if self.curindex == 0: | ||
self.error("Oldest frame") | ||||
return | ||||
try: | ||||
count = int(arg or 1) | ||||
except ValueError: | ||||
self.error("Invalid frame count (%s)" % arg) | ||||
return | ||||
skipped = 0 | ||||
if count < 0: | ||||
_newframe = 0 | ||||
else: | ||||
counter = 0 | ||||
hidden_frames = self.hidden_frames(self.stack) | ||||
for i in range(self.curindex - 1, -1, -1): | ||||
if hidden_frames[i] and self.skip_hidden: | ||||
skipped += 1 | ||||
continue | ||||
counter += 1 | ||||
if counter >= count: | ||||
break | ||||
else: | ||||
# if no break occured. | ||||
|
r26053 | self.error( | ||
"all frames above hidden, use `skip_hidden False` to get get into those." | ||||
) | ||||
|
r25839 | return | ||
Colors = self.color_scheme_table.active_colors | ||||
ColorsNormal = Colors.Normal | ||||
_newframe = i | ||||
self._select_frame(_newframe) | ||||
if skipped: | ||||
print( | ||||
f"{Colors.excName} [... skipped {skipped} hidden frame(s)]{ColorsNormal}\n" | ||||
) | ||||
def do_down(self, arg): | ||||
"""d(own) [count] | ||||
Move the current frame count (default one) levels down in the | ||||
stack trace (to a newer frame). | ||||
Will skip hidden frames. | ||||
""" | ||||
if self.curindex + 1 == len(self.stack): | ||||
self.error("Newest frame") | ||||
return | ||||
try: | ||||
count = int(arg or 1) | ||||
except ValueError: | ||||
self.error("Invalid frame count (%s)" % arg) | ||||
return | ||||
if count < 0: | ||||
_newframe = len(self.stack) - 1 | ||||
else: | ||||
counter = 0 | ||||
skipped = 0 | ||||
hidden_frames = self.hidden_frames(self.stack) | ||||
for i in range(self.curindex + 1, len(self.stack)): | ||||
if hidden_frames[i] and self.skip_hidden: | ||||
skipped += 1 | ||||
continue | ||||
counter += 1 | ||||
if counter >= count: | ||||
break | ||||
else: | ||||
|
r26053 | self.error( | ||
"all frames bellow hidden, use `skip_hidden False` to get get into those." | ||||
) | ||||
|
r25839 | return | ||
Colors = self.color_scheme_table.active_colors | ||||
ColorsNormal = Colors.Normal | ||||
if skipped: | ||||
print( | ||||
f"{Colors.excName} [... skipped {skipped} hidden frame(s)]{ColorsNormal}\n" | ||||
) | ||||
_newframe = i | ||||
self._select_frame(_newframe) | ||||
do_d = do_down | ||||
do_u = do_up | ||||
|
r22871 | |||
|
r26339 | def do_context(self, context): | ||
"""context number_of_lines | ||||
Set the number of lines of source code to show when displaying | ||||
stacktrace information. | ||||
""" | ||||
try: | ||||
new_context = int(context) | ||||
if new_context <= 0: | ||||
raise ValueError() | ||||
|
r26357 | self.context = new_context | ||
|
r26339 | except ValueError: | ||
self.error("The 'context' command requires a positive integer argument.") | ||||
|
r25649 | class InterruptiblePdb(Pdb): | ||
"""Version of debugger where KeyboardInterrupt exits the debugger altogether.""" | ||||
def cmdloop(self): | ||||
"""Wrap cmdloop() such that KeyboardInterrupt stops the debugger.""" | ||||
try: | ||||
return OldPdb.cmdloop(self) | ||||
except KeyboardInterrupt: | ||||
self.stop_here = lambda frame: False | ||||
self.do_quit("") | ||||
sys.settrace(None) | ||||
self.quitting = False | ||||
raise | ||||
|
r25568 | def _cmdloop(self): | ||
while True: | ||||
try: | ||||
# keyboard interrupts allow for an easy way to cancel | ||||
# the current command, so allow them during interactive input | ||||
self.allow_kbdint = True | ||||
self.cmdloop() | ||||
self.allow_kbdint = False | ||||
break | ||||
except KeyboardInterrupt: | ||||
|
r25649 | self.message('--KeyboardInterrupt--') | ||
|
r25568 | raise | ||
|
r22871 | |||
|
r22872 | def set_trace(frame=None): | ||
""" | ||||
Start debugging from `frame`. | ||||
If frame is not specified, debugging starts from caller's frame. | ||||
""" | ||||
|
r22873 | Pdb().set_trace(frame or sys._getframe().f_back) | ||