diff options
Diffstat (limited to 'Lib/pdb.py')
| -rwxr-xr-x | Lib/pdb.py | 1319 |
1 files changed, 783 insertions, 536 deletions
@@ -1,30 +1,89 @@ -#! /usr/bin/env python +#! /usr/bin/env python3 -"""A Python debugger.""" +""" +The Python Debugger Pdb +======================= -# (See pdb.doc for documentation.) +To use the debugger in its simplest form: + >>> import pdb + >>> pdb.run('<a statement>') + +The debugger's prompt is '(Pdb) '. This will stop in the first +function call in <a statement>. + +Alternatively, if a statement terminated with an unhandled exception, +you can use pdb's post-mortem facility to inspect the contents of the +traceback: + + >>> <a statement> + <exception traceback> + >>> import pdb + >>> pdb.pm() + +The commands recognized by the debugger are listed in the next +section. Most can be abbreviated as indicated; e.g., h(elp) means +that 'help' can be typed as 'h' or 'help' (but not as 'he' or 'hel', +nor as 'H' or 'Help' or 'HELP'). Optional arguments are enclosed in +square brackets. Alternatives in the command syntax are separated +by a vertical bar (|). + +A blank line repeats the previous command literally, except for +'list', where it lists the next 11 lines. + +Commands that the debugger doesn't recognize are assumed to be Python +statements and are executed in the context of the program being +debugged. Python statements can also be prefixed with an exclamation +point ('!'). This is a powerful way to inspect the program being +debugged; it is even possible to change variables or call functions. +When an exception occurs in such a statement, the exception name is +printed but the debugger's state is not changed. + +The debugger supports aliases, which can save typing. And aliases can +have parameters (see the alias help entry) which allows one a certain +level of adaptability to the context under examination. + +Multiple commands may be entered on a single line, separated by the +pair ';;'. No intelligence is applied to separating the commands; the +input is split at the first ';;', even if it is in the middle of a +quoted string. + +If a file ".pdbrc" exists in your home directory or in the current +directory, it is read in and executed as if it had been typed at the +debugger prompt. This is particularly useful for aliases. If both +files exist, the one in the home directory is read first and aliases +defined there can be overriden by the local file. + +Aside from aliases, the debugger is not directly programmable; but it +is implemented as a class from which you can derive your own debugger +class, which you can make as fancy as you like. + + +Debugger commands +================= + +""" +# NOTE: the actual command documentation is collected from docstrings of the +# commands and is appended to __doc__ after the class has been defined. + +import os +import re import sys -import linecache import cmd import bdb -from reprlib import Repr -import os -import re +import dis +import code import pprint +import signal +import inspect import traceback +import linecache class Restart(Exception): """Causes a debugger to be restarted for the debugged python program.""" pass -# Create a custom safe Repr instance and increase its maxstring. -# The default of 30 truncates error messages too easily. -_repr = Repr() -_repr.maxstring = 200 -_saferepr = _repr.repr - __all__ = ["run", "pm", "Pdb", "runeval", "runctx", "runcall", "set_trace", "post_mortem", "help"] @@ -37,17 +96,40 @@ def find_function(funcname, filename): # consumer of this info expects the first line to be 1 lineno = 1 answer = None - while 1: + while True: line = fp.readline() if line == '': break if cre.match(line): answer = funcname, filename, lineno break - lineno = lineno + 1 + lineno += 1 fp.close() return answer +def getsourcelines(obj): + lines, lineno = inspect.findsource(obj) + if inspect.isframe(obj) and obj.f_globals is obj.f_locals: + # 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 lasti2lineno(code, lasti): + linestarts = list(dis.findlinestarts(code)) + linestarts.reverse() + for i, lineno in linestarts: + if lasti >= i: + return lineno + return 0 + + +class _rstr(str): + """String that doesn't quote its repr.""" + def __repr__(self): + return self + # Interaction prompt line will separate file and call info from code # text using value of line_prefix string. A newline and arrow may @@ -58,41 +140,40 @@ line_prefix = '\n-> ' # Probably a better default class Pdb(bdb.Bdb, cmd.Cmd): - def __init__(self, completekey='tab', stdin=None, stdout=None, skip=None): + def __init__(self, completekey='tab', stdin=None, stdout=None, skip=None, + nosigint=False): bdb.Bdb.__init__(self, skip=skip) cmd.Cmd.__init__(self, completekey, stdin, stdout) if stdout: self.use_rawinput = 0 self.prompt = '(Pdb) ' self.aliases = {} + self.displaying = {} self.mainpyfile = '' - self._wait_for_mainpyfile = 0 + self._wait_for_mainpyfile = False + self.tb_lineno = {} # Try to load readline if it exists try: import readline except ImportError: pass + self.allow_kbdint = False + self.nosigint = nosigint # Read $HOME/.pdbrc and ./.pdbrc self.rcLines = [] if 'HOME' in os.environ: envHome = os.environ['HOME'] try: - rcFile = open(os.path.join(envHome, ".pdbrc")) + with open(os.path.join(envHome, ".pdbrc")) as rcFile: + self.rcLines.extend(rcFile) except IOError: pass - else: - for line in rcFile.readlines(): - self.rcLines.append(line) - rcFile.close() try: - rcFile = open(".pdbrc") + with open(".pdbrc") as rcFile: + self.rcLines.extend(rcFile) except IOError: pass - else: - for line in rcFile.readlines(): - self.rcLines.append(line) - rcFile.close() self.commands = {} # associates a command list to breakpoint numbers self.commands_doprompt = {} # for each bp num, tells if the prompt @@ -104,6 +185,15 @@ class Pdb(bdb.Bdb, cmd.Cmd): self.commands_bnum = None # The breakpoint number for which we are # defining a list + def sigint_handler(self, signum, frame): + if self.allow_kbdint: + raise KeyboardInterrupt + self.message("\nProgram interrupted. (Use 'cont' to resume).") + self.set_step() + self.set_trace(frame) + # restore previous signal handler + signal.signal(signal.SIGINT, self._previous_sigint_handler) + def reset(self): bdb.Bdb.reset(self) self.forget() @@ -113,28 +203,43 @@ class Pdb(bdb.Bdb, cmd.Cmd): self.stack = [] self.curindex = 0 self.curframe = None + self.tb_lineno.clear() - def setup(self, f, t): + def setup(self, f, tb): self.forget() - self.stack, self.curindex = self.get_stack(f, t) + self.stack, self.curindex = self.get_stack(f, tb) + while tb: + # when setting up post-mortem debugging with a traceback, save all + # the original line numbers to be displayed along the current line + # numbers (which can be different, e.g. due to finally clauses) + lineno = lasti2lineno(tb.tb_frame.f_code, tb.tb_lasti) + self.tb_lineno[tb.tb_frame] = lineno + tb = tb.tb_next self.curframe = self.stack[self.curindex][0] # The f_locals dictionary is updated from the actual frame # locals whenever the .f_locals accessor is called, so we # cache it here to ensure that modifications are not overwritten. self.curframe_locals = self.curframe.f_locals - self.execRcLines() + return self.execRcLines() # Can be executed earlier than 'setup' if desired def execRcLines(self): - if self.rcLines: - # Make local copy because of recursion - rcLines = self.rcLines - # executed only once - self.rcLines = [] - for line in rcLines: - line = line[:-1] - if len(line) > 0 and line[0] != '#': - self.onecmd(line) + if not self.rcLines: + return + # local copy because of recursion + rcLines = self.rcLines + rcLines.reverse() + # execute every line only once + self.rcLines = [] + while rcLines: + line = rcLines.pop().strip() + if line and line[0] != '#': + if self.onecmd(line): + # if onecmd returns True, the command wants to exit + # from the interaction, save leftover rc lines + # to execute before next interaction + self.rcLines += reversed(rcLines) + return True # Override Bdb methods @@ -144,20 +249,20 @@ class Pdb(bdb.Bdb, cmd.Cmd): if self._wait_for_mainpyfile: return if self.stop_here(frame): - print('--Call--', file=self.stdout) + self.message('--Call--') self.interaction(frame, None) def user_line(self, frame): """This function is called when we stop or break at this line.""" if self._wait_for_mainpyfile: if (self.mainpyfile != self.canonic(frame.f_code.co_filename) - or frame.f_lineno<= 0): + or frame.f_lineno <= 0): return - self._wait_for_mainpyfile = 0 + self._wait_for_mainpyfile = False if self.bp_commands(frame): self.interaction(frame, None) - def bp_commands(self,frame): + def bp_commands(self, frame): """Call every command that was set for the current active breakpoint (if there is one). @@ -176,7 +281,7 @@ class Pdb(bdb.Bdb, cmd.Cmd): if not self.commands_silent[currentbp]: self.print_stack_entry(self.stack[self.curindex]) if self.commands_doprompt[currentbp]: - self.cmdloop() + self._cmdloop() self.forget() return return 1 @@ -186,7 +291,7 @@ class Pdb(bdb.Bdb, cmd.Cmd): if self._wait_for_mainpyfile: return frame.f_locals['__return__'] = return_value - print('--Return--', file=self.stdout) + self.message('--Return--') self.interaction(frame, None) def user_exception(self, frame, exc_info): @@ -196,16 +301,45 @@ class Pdb(bdb.Bdb, cmd.Cmd): return exc_type, exc_value, exc_traceback = exc_info frame.f_locals['__exception__'] = exc_type, exc_value - exc_type_name = exc_type.__name__ - print(exc_type_name + ':', _saferepr(exc_value), file=self.stdout) + self.message(traceback.format_exception_only(exc_type, + exc_value)[-1].strip()) self.interaction(frame, exc_traceback) # General interaction function + 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: + self.message('--KeyboardInterrupt--') + + # Called before loop, handles display expressions + def preloop(self): + displaying = self.displaying.get(self.curframe) + if displaying: + for expr, oldvalue in displaying.items(): + newvalue = self._getval_except(expr) + # check for identity first; this prevents custom __eq__ to + # be called at every loop, and also prevents instances whose + # fields are changed to be displayed + if newvalue is not oldvalue and newvalue != oldvalue: + displaying[expr] = newvalue + self.message('display %s: %r [old: %r]' % + (expr, newvalue, oldvalue)) def interaction(self, frame, traceback): - self.setup(frame, traceback) + if self.setup(frame, traceback): + # no interaction desired at this time (happens if .pdbrc contains + # a command like "continue") + self.forget() + return self.print_stack_entry(self.stack[self.curindex]) - self.cmdloop() + self._cmdloop() self.forget() def displayhook(self, obj): @@ -214,7 +348,7 @@ class Pdb(bdb.Bdb, cmd.Cmd): """ # reproduce the behavior of the standard displayhook, not printing None if obj is not None: - print(repr(obj)) + self.message(repr(obj)) def default(self, line): if line[:1] == '!': line = line[1:] @@ -235,11 +369,8 @@ class Pdb(bdb.Bdb, cmd.Cmd): sys.stdin = save_stdin sys.displayhook = save_displayhook except: - t, v = sys.exc_info()[:2] - if type(t) == type(''): - exc_type_name = t - else: exc_type_name = t.__name__ - print('***', exc_type_name + ':', v, file=self.stdout) + exc_info = sys.exc_info()[:2] + self.error(traceback.format_exception_only(*exc_info)[-1].strip()) def precmd(self, line): """Handle alias expansion and ';;' separator.""" @@ -252,7 +383,7 @@ class Pdb(bdb.Bdb, cmd.Cmd): for tmpArg in args[1:]: line = line.replace("%" + str(ii), tmpArg) - ii = ii + 1 + ii += 1 line = line.replace("%*", ' '.join(args[1:])) args = line.split() # split into ';;' separated commands @@ -278,7 +409,7 @@ class Pdb(bdb.Bdb, cmd.Cmd): else: return self.handle_command_def(line) - def handle_command_def(self,line): + def handle_command_def(self, line): """Handles one command line during command list definition.""" cmd, arg, line = self.parseline(line) if not cmd: @@ -306,47 +437,116 @@ class Pdb(bdb.Bdb, cmd.Cmd): return 1 return + # interface abstraction functions + + def message(self, msg): + print(msg, file=self.stdout) + + def error(self, msg): + print('***', msg, file=self.stdout) + # Command definitions, called by cmdloop() # The argument is the remaining string on the command line # Return true to exit from the command loop - do_h = cmd.Cmd.do_help - def do_commands(self, arg): - """Defines a list of commands associated to a breakpoint. - - Those commands will be executed whenever the breakpoint causes - the program to stop execution.""" + """commands [bpnumber] + (com) ... + (com) end + (Pdb) + + Specify a list of commands for breakpoint number bpnumber. + The commands themselves are entered on the following lines. + Type a line containing just 'end' to terminate the commands. + The commands are executed when the breakpoint is hit. + + To remove all commands from a breakpoint, type commands and + follow it immediately with end; that is, give no commands. + + With no bpnumber argument, commands refers to the last + breakpoint set. + + You can use breakpoint commands to start your program up + again. Simply use the continue command, or step, or any other + command that resumes execution. + + Specifying any command resuming execution (currently continue, + step, next, return, jump, quit and their abbreviations) + terminates the command list (as if that command was + immediately followed by end). This is because any time you + resume execution (even with a simple next or step), you may + encounter another breakpoint -- which could have its own + command list, leading to ambiguities about which list to + execute. + + If you use the 'silent' command in the command list, the usual + message about stopping at a breakpoint is not printed. This + may be desirable for breakpoints that are to print a specific + message and then continue. If none of the other commands + print anything, you will see no sign that the breakpoint was + reached. + """ if not arg: - bnum = len(bdb.Breakpoint.bpbynumber)-1 + bnum = len(bdb.Breakpoint.bpbynumber) - 1 else: try: bnum = int(arg) except: - print("Usage : commands [bnum]\n ...\n end", - file=self.stdout) + self.error("Usage: commands [bnum]\n ...\n end") return self.commands_bnum = bnum + # Save old definitions for the case of a keyboard interrupt. + if bnum in self.commands: + old_command_defs = (self.commands[bnum], + self.commands_doprompt[bnum], + self.commands_silent[bnum]) + else: + old_command_defs = None self.commands[bnum] = [] self.commands_doprompt[bnum] = True self.commands_silent[bnum] = False + prompt_back = self.prompt self.prompt = '(com) ' self.commands_defining = True try: self.cmdloop() + except KeyboardInterrupt: + # Restore old definitions. + if old_command_defs: + self.commands[bnum] = old_command_defs[0] + self.commands_doprompt[bnum] = old_command_defs[1] + self.commands_silent[bnum] = old_command_defs[2] + else: + del self.commands[bnum] + del self.commands_doprompt[bnum] + del self.commands_silent[bnum] + self.error('command definition aborted, old commands restored') finally: self.commands_defining = False self.prompt = prompt_back def do_break(self, arg, temporary = 0): - # break [ ([filename:]lineno | function) [, "condition"] ] + """b(reak) [ ([filename:]lineno | function) [, condition] ] + Without argument, list all breaks. + + With a line number argument, set a break at this line in the + current file. With a function name, set a break at the first + executable line of that function. If a second argument is + present, it is a string specifying an expression which must + evaluate to true before the breakpoint is honored. + + The line number may be prefixed with a filename and a colon, + to specify a breakpoint in another file (probably one that + hasn't been loaded yet). The file is searched for on + sys.path; the .py suffix may be omitted. + """ if not arg: if self.breaks: # There's at least one - print("Num Type Disp Enb Where", file=self.stdout) + self.message("Num Type Disp Enb Where") for bp in bdb.Breakpoint.bpbynumber: if bp: - bp.bpprint(self.stdout) + self.message(bp.bpformat()) return # parse arguments; comma has lowest precedence # and cannot occur in filename @@ -365,16 +565,15 @@ class Pdb(bdb.Bdb, cmd.Cmd): filename = arg[:colon].rstrip() f = self.lookupmodule(filename) if not f: - print('*** ', repr(filename), end=' ', file=self.stdout) - print('not found from sys.path', file=self.stdout) + self.error('%r not found from sys.path' % filename) return else: filename = f arg = arg[colon+1:].lstrip() try: lineno = int(arg) - except ValueError as msg: - print('*** Bad lineno:', arg, file=self.stdout) + except ValueError: + self.error('Bad lineno: %s' % arg) return else: # no colon; can be lineno or function @@ -400,10 +599,8 @@ class Pdb(bdb.Bdb, cmd.Cmd): # last thing to try (ok, filename, ln) = self.lineinfo(arg) if not ok: - print('*** The specified object', end=' ', file=self.stdout) - print(repr(arg), end=' ', file=self.stdout) - print('is not a function', file=self.stdout) - print('or was not found along sys.path.', file=self.stdout) + self.error('The specified object %r is not a function ' + 'or was not found along sys.path.' % arg) return funcname = ok # ok contains a function name lineno = int(ln) @@ -414,12 +611,12 @@ class Pdb(bdb.Bdb, cmd.Cmd): if line: # now set the break point err = self.set_break(filename, line, temporary, cond, funcname) - if err: print('***', err, file=self.stdout) + if err: + self.error(err, file=self.stdout) else: bp = self.get_breaks(filename, line)[-1] - print("Breakpoint %d at %s:%d" % (bp.number, - bp.file, - bp.line), file=self.stdout) + self.message("Breakpoint %d at %s:%d" % + (bp.number, bp.file, bp.line)) # To be overridden in derived debuggers def defaultFile(self): @@ -432,6 +629,10 @@ class Pdb(bdb.Bdb, cmd.Cmd): do_b = do_break def do_tbreak(self, arg): + """tbreak [ ([filename:]lineno | function) [, condition] ] + Same arguments as break, but sets a temporary breakpoint: it + is automatically deleted when first hit. + """ self.do_break(arg, 1) def lineinfo(self, identifier): @@ -478,112 +679,110 @@ class Pdb(bdb.Bdb, cmd.Cmd): globs = self.curframe.f_globals if hasattr(self, 'curframe') else None line = linecache.getline(filename, lineno, globs) if not line: - print('End of file', file=self.stdout) + self.message('End of file') return 0 line = line.strip() # Don't allow setting breakpoint at a blank line if (not line or (line[0] == '#') or (line[:3] == '"""') or line[:3] == "'''"): - print('*** Blank or comment', file=self.stdout) + self.error('Blank or comment') return 0 return lineno def do_enable(self, arg): + """enable bpnumber [bpnumber ...] + Enables the breakpoints given as a space separated list of + breakpoint numbers. + """ args = arg.split() for i in args: try: - i = int(i) - except ValueError: - print('Breakpoint index %r is not a number' % i, file=self.stdout) - continue - - if not (0 <= i < len(bdb.Breakpoint.bpbynumber)): - print('No breakpoint numbered', i, file=self.stdout) - continue - - bp = bdb.Breakpoint.bpbynumber[i] - if bp: + bp = self.get_bpbynumber(i) + except ValueError as err: + self.error(err) + else: bp.enable() + self.message('Enabled %s' % bp) def do_disable(self, arg): + """disable bpnumber [bpnumber ...] + Disables the breakpoints given as a space separated list of + breakpoint numbers. Disabling a breakpoint means it cannot + cause the program to stop execution, but unlike clearing a + breakpoint, it remains in the list of breakpoints and can be + (re-)enabled. + """ args = arg.split() for i in args: try: - i = int(i) - except ValueError: - print('Breakpoint index %r is not a number' % i, file=self.stdout) - continue - - if not (0 <= i < len(bdb.Breakpoint.bpbynumber)): - print('No breakpoint numbered', i, file=self.stdout) - continue - - bp = bdb.Breakpoint.bpbynumber[i] - if bp: + bp = self.get_bpbynumber(i) + except ValueError as err: + self.error(err) + else: bp.disable() + self.message('Disabled %s' % bp) def do_condition(self, arg): - # arg is breakpoint number and condition + """condition bpnumber [condition] + Set a new condition for the breakpoint, an expression which + must evaluate to true before the breakpoint is honored. If + condition is absent, any existing condition is removed; i.e., + the breakpoint is made unconditional. + """ args = arg.split(' ', 1) try: - bpnum = int(args[0].strip()) - except ValueError: - # something went wrong - print('Breakpoint index %r is not a number' % args[0], file=self.stdout) - return - try: cond = args[1] - except: + except IndexError: cond = None try: - bp = bdb.Breakpoint.bpbynumber[bpnum] - except IndexError: - print('Breakpoint index %r is not valid' % args[0], - file=self.stdout) - return - if bp: + bp = self.get_bpbynumber(args[0].strip()) + except ValueError as err: + self.error(err) + else: bp.cond = cond if not cond: - print('Breakpoint', bpnum, end=' ', file=self.stdout) - print('is now unconditional.', file=self.stdout) - - def do_ignore(self,arg): - """arg is bp number followed by ignore count.""" + self.message('Breakpoint %d is now unconditional.' % bp.number) + else: + self.message('New condition set for breakpoint %d.' % bp.number) + + def do_ignore(self, arg): + """ignore bpnumber [count] + Set the ignore count for the given breakpoint number. If + count is omitted, the ignore count is set to 0. A breakpoint + becomes active when the ignore count is zero. When non-zero, + the count is decremented each time the breakpoint is reached + and the breakpoint is not disabled and any associated + condition evaluates to true. + """ args = arg.split() try: - bpnum = int(args[0].strip()) - except ValueError: - # something went wrong - print('Breakpoint index %r is not a number' % args[0], file=self.stdout) - return - try: count = int(args[1].strip()) except: count = 0 try: - bp = bdb.Breakpoint.bpbynumber[bpnum] - except IndexError: - print('Breakpoint index %r is not valid' % args[0], - file=self.stdout) - return - if bp: + bp = self.get_bpbynumber(args[0].strip()) + except ValueError as err: + self.error(err) + else: bp.ignore = count if count > 0: - reply = 'Will ignore next ' if count > 1: - reply = reply + '%d crossings' % count + countstr = '%d crossings' % count else: - reply = reply + '1 crossing' - print(reply + ' of breakpoint %d.' % bpnum, file=self.stdout) + countstr = '1 crossing' + self.message('Will ignore next %s of breakpoint %d.' % + (countstr, bp.number)) else: - print('Will stop next time breakpoint', end=' ', file=self.stdout) - print(bpnum, 'is reached.', file=self.stdout) + self.message('Will stop next time breakpoint %d is reached.' + % bp.number) def do_clear(self, arg): - """Three possibilities, tried in this order: - clear -> clear all breaks, ask for confirmation - clear file:lineno -> clear all breaks at file:lineno - clear bpno bpno ... -> clear breakpoints by number""" + """cl(ear) filename:lineno\ncl(ear) [bpnumber [bpnumber...]] + With a space separated list of breakpoint numbers, clear + those breakpoints. Without argument, clear all breaks (but + first ask confirmation). With a filename:lineno argument, + clear all breaks at that line in that file. + """ if not arg: try: reply = input('Clear all breaks? ') @@ -591,7 +790,10 @@ class Pdb(bdb.Bdb, cmd.Cmd): reply = 'no' reply = reply.strip().lower() if reply in ('y', 'yes'): + bplist = [bp for bp in bdb.Breakpoint.bpbynumber if bp] self.clear_all_breaks() + for bp in bplist: + self.message('Deleted %s' % bp) return if ':' in arg: # Make sure it works for "clear C:\foo\bar.py:12" @@ -603,99 +805,180 @@ class Pdb(bdb.Bdb, cmd.Cmd): except ValueError: err = "Invalid line number (%s)" % arg else: + bplist = self.get_breaks(filename, lineno) err = self.clear_break(filename, lineno) - if err: print('***', err, file=self.stdout) + if err: + self.error(err) + else: + for bp in bplist: + self.message('Deleted %s' % bp) return numberlist = arg.split() for i in numberlist: try: - i = int(i) - except ValueError: - print('Breakpoint index %r is not a number' % i, file=self.stdout) - continue - - if not (0 <= i < len(bdb.Breakpoint.bpbynumber)): - print('No breakpoint numbered', i, file=self.stdout) - continue - err = self.clear_bpbynumber(i) - if err: - print('***', err, file=self.stdout) + bp = self.get_bpbynumber(i) + except ValueError as err: + self.error(err) else: - print('Deleted breakpoint', i, file=self.stdout) + self.clear_bpbynumber(i) + self.message('Deleted %s' % bp) do_cl = do_clear # 'c' is already an abbreviation for 'continue' 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. + """ self.print_stack_trace() do_w = do_where do_bt = do_where + def _select_frame(self, number): + assert 0 <= number < len(self.stack) + self.curindex = number + self.curframe = self.stack[self.curindex][0] + self.curframe_locals = self.curframe.f_locals + self.print_stack_entry(self.stack[self.curindex]) + self.lineno = None + 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). + """ if self.curindex == 0: - print('*** Oldest frame', file=self.stdout) + self.error('Oldest frame') + return + try: + count = int(arg or 1) + except ValueError: + self.error('Invalid frame count (%s)' % arg) + return + if count < 0: + newframe = 0 else: - self.curindex = self.curindex - 1 - self.curframe = self.stack[self.curindex][0] - self.curframe_locals = self.curframe.f_locals - self.print_stack_entry(self.stack[self.curindex]) - self.lineno = None + newframe = max(0, self.curindex - count) + self._select_frame(newframe) do_u = do_up 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). + """ if self.curindex + 1 == len(self.stack): - print('*** Newest frame', file=self.stdout) + 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: - self.curindex = self.curindex + 1 - self.curframe = self.stack[self.curindex][0] - self.curframe_locals = self.curframe.f_locals - self.print_stack_entry(self.stack[self.curindex]) - self.lineno = None + newframe = min(len(self.stack) - 1, self.curindex + count) + self._select_frame(newframe) do_d = do_down def do_until(self, arg): - self.set_until(self.curframe) + """unt(il) [lineno] + Without argument, continue execution until the line with a + number greater than the current one is reached. With a line + number, continue execution until a line with a number greater + or equal to that is reached. In both cases, also stop when + the current frame returns. + """ + if arg: + try: + lineno = int(arg) + except ValueError: + self.error('Error in argument: %r' % arg) + return + if lineno <= self.curframe.f_lineno: + self.error('"until" line number is smaller than current ' + 'line number') + return + else: + lineno = None + self.set_until(self.curframe, lineno) return 1 do_unt = do_until def do_step(self, arg): + """s(tep) + Execute the current line, stop at the first possible occasion + (either in a function that is called or in the current + function). + """ self.set_step() return 1 do_s = do_step def do_next(self, arg): + """n(ext) + Continue execution until the next line in the current function + is reached or it returns. + """ self.set_next(self.curframe) return 1 do_n = do_next def do_run(self, arg): - """Restart program by raising an exception to be caught in the main - debugger loop. If arguments were given, set them in sys.argv.""" + """run [args...] + Restart the debugged python program. If a string is supplied + it is splitted with "shlex", and the result is used as the new + sys.argv. History, breakpoints, actions and debugger options + are preserved. "restart" is an alias for "run". + """ if arg: import shlex argv0 = sys.argv[0:1] sys.argv = shlex.split(arg) sys.argv[:0] = argv0 + # this is caught in the main debugger loop raise Restart do_restart = do_run def do_return(self, arg): + """r(eturn) + Continue execution until the current function returns. + """ self.set_return(self.curframe) return 1 do_r = do_return def do_continue(self, arg): + """c(ont(inue)) + Continue execution, only stop when a breakpoint is encountered. + """ + if not self.nosigint: + self._previous_sigint_handler = \ + signal.signal(signal.SIGINT, self.sigint_handler) self.set_continue() return 1 do_c = do_cont = do_continue def do_jump(self, arg): + """j(ump) lineno + Set the next line that will be executed. Only available in + the bottom-most frame. This lets you jump back and execute + code again, or jump forward to skip code that you don't want + to run. + + It should be noted that not all jumps are allowed -- for + instance it is not possible to jump into the middle of a + for loop or out of a finally clause. + """ if self.curindex + 1 != len(self.stack): - print("*** You can only jump within the bottom frame", file=self.stdout) + self.error('You can only jump within the bottom frame') return try: arg = int(arg) except ValueError: - print("*** The 'jump' command requires a line number.", file=self.stdout) + self.error("The 'jump' command requires a line number") else: try: # Do the jump, fix up our copy of the stack, and display the @@ -704,23 +987,31 @@ class Pdb(bdb.Bdb, cmd.Cmd): self.stack[self.curindex] = self.stack[self.curindex][0], arg self.print_stack_entry(self.stack[self.curindex]) except ValueError as e: - print('*** Jump failed:', e, file=self.stdout) + self.error('Jump failed: %s' % e) do_j = do_jump 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). + """ sys.settrace(None) globals = self.curframe.f_globals locals = self.curframe_locals p = Pdb(self.completekey, self.stdin, self.stdout) p.prompt = "(%s) " % self.prompt.strip() - print("ENTERING RECURSIVE DEBUGGER", file=self.stdout) + self.message("ENTERING RECURSIVE DEBUGGER") sys.call_tracing(p.run, (arg, globals, locals)) - print("LEAVING RECURSIVE DEBUGGER", file=self.stdout) + self.message("LEAVING RECURSIVE DEBUGGER") sys.settrace(self.trace_dispatch) self.lastcmd = p.lastcmd def do_quit(self, arg): - self._user_requested_quit = 1 + """q(uit)\nexit + Quit from the debugger. The program being executed is aborted. + """ + self._user_requested_quit = True self.set_quit() return 1 @@ -728,12 +1019,18 @@ class Pdb(bdb.Bdb, cmd.Cmd): do_exit = do_quit def do_EOF(self, arg): - print(file=self.stdout) - self._user_requested_quit = 1 + """EOF + Handles the receipt of EOF as a command. + """ + self.message('') + self._user_requested_quit = True self.set_quit() return 1 def do_args(self, arg): + """a(rgs) + Print the argument list of the current function. + """ co = self.curframe.f_code dict = self.curframe_locals n = co.co_argcount @@ -741,62 +1038,94 @@ class Pdb(bdb.Bdb, cmd.Cmd): if co.co_flags & 8: n = n+1 for i in range(n): name = co.co_varnames[i] - print(name, '=', end=' ', file=self.stdout) - if name in dict: print(dict[name], file=self.stdout) - else: print("*** undefined ***", file=self.stdout) + if name in dict: + self.message('%s = %r' % (name, dict[name])) + else: + self.message('%s = *** undefined ***' % (name,)) do_a = do_args def do_retval(self, arg): + """retval + Print the return value for the last return of a function. + """ if '__return__' in self.curframe_locals: - print(self.curframe_locals['__return__'], file=self.stdout) + self.message(repr(self.curframe_locals['__return__'])) else: - print('*** Not yet returned!', file=self.stdout) + self.error('Not yet returned!') do_rv = do_retval def _getval(self, arg): try: return eval(arg, self.curframe.f_globals, self.curframe_locals) except: - t, v = sys.exc_info()[:2] - if isinstance(t, str): - exc_type_name = t - else: exc_type_name = t.__name__ - print('***', exc_type_name + ':', repr(v), file=self.stdout) + exc_info = sys.exc_info()[:2] + self.error(traceback.format_exception_only(*exc_info)[-1].strip()) raise + def _getval_except(self, arg, frame=None): + try: + if frame is None: + return eval(arg, self.curframe.f_globals, self.curframe_locals) + else: + return eval(arg, frame.f_globals, frame.f_locals) + except: + exc_info = sys.exc_info()[:2] + err = traceback.format_exception_only(*exc_info)[-1].strip() + return _rstr('** raised %s **' % err) + def do_p(self, arg): + """p(rint) expression + Print the value of the expression. + """ try: - print(repr(self._getval(arg)), file=self.stdout) + self.message(repr(self._getval(arg))) except: pass # make "print" an alias of "p" since print isn't a Python statement anymore do_print = do_p def do_pp(self, arg): + """pp expression + Pretty-print the value of the expression. + """ try: - pprint.pprint(self._getval(arg), self.stdout) + self.message(pprint.pformat(self._getval(arg))) except: pass def do_list(self, arg): + """l(ist) [first [,last] | .] + + List source code for the current file. Without arguments, + list 11 lines around the current line or continue the previous + listing. With . as argument, list 11 lines around the current + line. With one argument, list 11 lines starting at that line. + With two arguments, list the given range; if the second + argument is less than the first, it is a count. + + The current line in the current frame is indicated by "->". + If an exception is being debugged, the line where the + exception was originally raised or propagated is indicated by + ">>", if it differs from the current line. + """ self.lastcmd = 'list' last = None - if arg: + if arg and arg != '.': try: - x = eval(arg, {}, {}) - if type(x) == type(()): - first, last = x - first = int(first) - last = int(last) + if ',' in arg: + first, last = arg.split(',') + first = int(first.strip()) + last = int(last.strip()) if last < first: - # Assume it's a count + # assume it's a count last = first + last else: - first = max(1, int(x) - 5) - except: - print('*** Error in argument:', repr(arg), file=self.stdout) + first = int(arg.strip()) + first = max(1, first - 5) + except ValueError: + self.error('Error in argument: %r' % arg) return - elif self.lineno is None: + elif self.lineno is None or arg == '.': first = max(1, self.curframe.f_lineno - 5) else: first = self.lineno + 1 @@ -805,71 +1134,186 @@ class Pdb(bdb.Bdb, cmd.Cmd): filename = self.curframe.f_code.co_filename breaklist = self.get_file_breaks(filename) try: - for lineno in range(first, last+1): - line = linecache.getline(filename, lineno, - self.curframe.f_globals) - if not line: - print('[EOF]', file=self.stdout) - break - else: - s = repr(lineno).rjust(3) - if len(s) < 4: s = s + ' ' - if lineno in breaklist: s = s + 'B' - else: s = s + ' ' - if lineno == self.curframe.f_lineno: - s = s + '->' - print(s + '\t' + line, end='', file=self.stdout) - self.lineno = lineno + lines = linecache.getlines(filename, self.curframe.f_globals) + self._print_lines(lines[first-1:last], first, breaklist, + self.curframe) + self.lineno = min(last, len(lines)) + if len(lines) < last: + self.message('[EOF]') except KeyboardInterrupt: pass do_l = do_list + def do_longlist(self, arg): + """longlist | ll + List the whole source code for the current function or frame. + """ + filename = self.curframe.f_code.co_filename + breaklist = self.get_file_breaks(filename) + try: + lines, lineno = getsourcelines(self.curframe) + except IOError as err: + self.error(err) + return + self._print_lines(lines, lineno, breaklist, self.curframe) + do_ll = do_longlist + + def do_source(self, arg): + """source expression + Try to get source code for the given object and display it. + """ + try: + obj = self._getval(arg) + except: + return + try: + lines, lineno = getsourcelines(obj) + except (IOError, TypeError) as err: + self.error(err) + return + self._print_lines(lines, lineno) + + def _print_lines(self, lines, start, breaks=(), frame=None): + """Print a range of lines.""" + if frame: + current_lineno = frame.f_lineno + exc_lineno = self.tb_lineno.get(frame, -1) + else: + current_lineno = exc_lineno = -1 + for lineno, line in enumerate(lines, start): + s = str(lineno).rjust(3) + if len(s) < 4: + s += ' ' + if lineno in breaks: + s += 'B' + else: + s += ' ' + if lineno == current_lineno: + s += '->' + elif lineno == exc_lineno: + s += '>>' + self.message(s + '\t' + line.rstrip()) + def do_whatis(self, arg): + """whatis arg + Print the type of the argument. + """ try: - value = eval(arg, self.curframe.f_globals, - self.curframe_locals) + value = self._getval(arg) except: - t, v = sys.exc_info()[:2] - if type(t) == type(''): - exc_type_name = t - else: exc_type_name = t.__name__ - print('***', exc_type_name + ':', repr(v), file=self.stdout) + # _getval() already printed the error return code = None # Is it a function? - try: code = value.__code__ - except: pass + try: + code = value.__code__ + except Exception: + pass if code: - print('Function', code.co_name, file=self.stdout) + self.message('Function %s' % code.co_name) return # Is it an instance method? - try: code = value.__func__.__code__ - except: pass + try: + code = value.__func__.__code__ + except Exception: + pass if code: - print('Method', code.co_name, file=self.stdout) + self.message('Method %s' % code.co_name) + return + # Is it a class? + if value.__class__ is type: + self.message('Class %s.%s' % (value.__module__, value.__name__)) return # None of the above... - print(type(value), file=self.stdout) + self.message(type(value)) + + def do_display(self, arg): + """display [expression] + + Display the value of the expression if it changed, each time execution + stops in the current frame. + + Without expression, list all display expressions for the current frame. + """ + if not arg: + self.message('Currently displaying:') + for item in self.displaying.get(self.curframe, {}).items(): + self.message('%s: %r' % item) + else: + val = self._getval_except(arg) + self.displaying.setdefault(self.curframe, {})[arg] = val + self.message('display %s: %r' % (arg, val)) + + def do_undisplay(self, arg): + """undisplay [expression] + + Do not display the expression any more in the current frame. + + Without expression, clear all display expressions for the current frame. + """ + if arg: + try: + del self.displaying.get(self.curframe, {})[arg] + except KeyError: + self.error('not displaying %s' % arg) + else: + self.displaying.pop(self.curframe, None) + + def do_interact(self, arg): + """interact + + Start an interative interpreter whose global namespace + contains all the (global and local) names found in the current scope. + """ + ns = self.curframe.f_globals.copy() + ns.update(self.curframe_locals) + code.interact("*interactive*", local=ns) def do_alias(self, arg): + """alias [name [command [parameter parameter ...] ]] + Create an alias called 'name' that executes 'command'. The + command must *not* be enclosed in quotes. Replaceable + parameters can be indicated by %1, %2, and so on, while %* is + replaced by all the parameters. If no command is given, the + current alias for name is shown. If no name is given, all + aliases are listed. + + Aliases may be nested and can contain anything that can be + legally typed at the pdb prompt. Note! You *can* override + internal pdb commands with aliases! Those internal commands + are then hidden until the alias is removed. Aliasing is + recursively applied to the first word of the command line; all + other words in the line are left alone. + + As an example, here are two useful aliases (especially when + placed in the .pdbrc file): + + # Print instance variables (usage "pi classInst") + alias pi for k in %1.__dict__.keys(): print "%1.",k,"=",%1.__dict__[k] + # Print instance variables in self + alias ps pi self + """ args = arg.split() if len(args) == 0: keys = sorted(self.aliases.keys()) for alias in keys: - print("%s = %s" % (alias, self.aliases[alias]), file=self.stdout) + self.message("%s = %s" % (alias, self.aliases[alias])) return if args[0] in self.aliases and len(args) == 1: - print("%s = %s" % (args[0], self.aliases[args[0]]), file=self.stdout) + self.message("%s = %s" % (args[0], self.aliases[args[0]])) else: self.aliases[args[0]] = ' '.join(args[1:]) def do_unalias(self, arg): + """unalias name + Delete the specified alias. + """ args = arg.split() if len(args) == 0: return if args[0] in self.aliases: del self.aliases[args[0]] - #list of all the commands making the program resume execution. + # List of all the commands making the program resume execution. commands_resuming = ['do_continue', 'do_step', 'do_next', 'do_return', 'do_quit', 'do_jump'] @@ -891,292 +1335,57 @@ class Pdb(bdb.Bdb, cmd.Cmd): def print_stack_entry(self, frame_lineno, prompt_prefix=line_prefix): frame, lineno = frame_lineno if frame is self.curframe: - print('>', end=' ', file=self.stdout) + prefix = '> ' else: - print(' ', end=' ', file=self.stdout) - print(self.format_stack_entry(frame_lineno, - prompt_prefix), file=self.stdout) - - - # Help methods (derived from pdb.doc) - - def help_help(self): - self.help_h() - - def help_h(self): - print("""h(elp) -Without argument, print the list of available commands. -With a command name as argument, print help about that command -"help pdb" pipes the full documentation file to the $PAGER -"help exec" gives help on the ! command""", file=self.stdout) - - def help_where(self): - self.help_w() - - def help_w(self): - print("""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.""", file=self.stdout) - - help_bt = help_w - - def help_down(self): - self.help_d() - - def help_d(self): - print("""d(own) -Move the current frame one level down in the stack trace -(to a newer frame).""", file=self.stdout) - - def help_up(self): - self.help_u() - - def help_u(self): - print("""u(p) -Move the current frame one level up in the stack trace -(to an older frame).""", file=self.stdout) - - def help_break(self): - self.help_b() - - def help_b(self): - print("""b(reak) ([file:]lineno | function) [, condition] -With a line number argument, set a break there in the current -file. With a function name, set a break at first executable line -of that function. Without argument, list all breaks. If a second -argument is present, it is a string specifying an expression -which must evaluate to true before the breakpoint is honored. - -The line number may be prefixed with a filename and a colon, -to specify a breakpoint in another file (probably one that -hasn't been loaded yet). The file is searched for on sys.path; -the .py suffix may be omitted.""", file=self.stdout) - - def help_clear(self): - self.help_cl() - - def help_cl(self): - print("cl(ear) filename:lineno", file=self.stdout) - print("""cl(ear) [bpnumber [bpnumber...]] -With a space separated list of breakpoint numbers, clear -those breakpoints. Without argument, clear all breaks (but -first ask confirmation). With a filename:lineno argument, -clear all breaks at that line in that file.""", file=self.stdout) - - def help_tbreak(self): - print("""tbreak same arguments as break, but breakpoint is -removed when first hit.""", file=self.stdout) - - def help_enable(self): - print("""enable bpnumber [bpnumber ...] -Enables the breakpoints given as a space separated list of -bp numbers.""", file=self.stdout) - - def help_disable(self): - print("""disable bpnumber [bpnumber ...] -Disables the breakpoints given as a space separated list of -bp numbers.""", file=self.stdout) - - def help_ignore(self): - print("""ignore bpnumber count -Sets the ignore count for the given breakpoint number. A breakpoint -becomes active when the ignore count is zero. When non-zero, the -count is decremented each time the breakpoint is reached and the -breakpoint is not disabled and any associated condition evaluates -to true.""", file=self.stdout) - - def help_condition(self): - print("""condition bpnumber str_condition -str_condition is a string specifying an expression which -must evaluate to true before the breakpoint is honored. -If str_condition is absent, any existing condition is removed; -i.e., the breakpoint is made unconditional.""", file=self.stdout) - - def help_step(self): - self.help_s() - - def help_s(self): - print("""s(tep) -Execute the current line, stop at the first possible occasion -(either in a function that is called or in the current function).""", file=self.stdout) - - def help_until(self): - self.help_unt() - - def help_unt(self): - print("""unt(il) -Continue execution until the line with a number greater than the current -one is reached or until the current frame returns""") - - def help_next(self): - self.help_n() - - def help_n(self): - print("""n(ext) -Continue execution until the next line in the current function -is reached or it returns.""", file=self.stdout) - - def help_return(self): - self.help_r() - - def help_r(self): - print("""r(eturn) -Continue execution until the current function returns.""", file=self.stdout) - - def help_continue(self): - self.help_c() - - def help_cont(self): - self.help_c() - - def help_c(self): - print("""c(ont(inue)) -Continue execution, only stop when a breakpoint is encountered.""", file=self.stdout) - - def help_jump(self): - self.help_j() - - def help_j(self): - print("""j(ump) lineno -Set the next line that will be executed.""", file=self.stdout) - - def help_debug(self): - print("""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).""", file=self.stdout) - - def help_list(self): - self.help_l() - - def help_l(self): - print("""l(ist) [first [,last]] -List source code for the current file. -Without arguments, list 11 lines around the current line -or continue the previous listing. -With one argument, list 11 lines starting at that line. -With two arguments, list the given range; -if the second argument is less than the first, it is a count.""", file=self.stdout) - - def help_args(self): - self.help_a() - - def help_a(self): - print("""a(rgs) -Print the arguments of the current function.""", file=self.stdout) - - def help_p(self): - print("""p(rint) expression -Print the value of the expression.""", file=self.stdout) - - def help_pp(self): - print("""pp expression -Pretty-print the value of the expression.""", file=self.stdout) + prefix = ' ' + self.message(prefix + + self.format_stack_entry(frame_lineno, prompt_prefix)) + + # Provide help + + def do_help(self, arg): + """h(elp) + Without argument, print the list of available commands. + With a command name as argument, print help about that command. + "help pdb" shows the full pdb documentation. + "help exec" gives help on the ! command. + """ + if not arg: + return cmd.Cmd.do_help(self, arg) + try: + try: + topic = getattr(self, 'help_' + arg) + return topic() + except AttributeError: + command = getattr(self, 'do_' + arg) + except AttributeError: + self.error('No help for %r' % arg) + else: + if sys.flags.optimize >= 2: + self.error('No help for %r; please do not run Python with -OO ' + 'if you need command help' % arg) + return + self.message(command.__doc__.rstrip()) + + do_h = do_help def help_exec(self): - print("""(!) statement -Execute the (one-line) statement in the context of -the current stack frame. -The exclamation point can be omitted unless the first word -of the statement resembles a debugger command. -To assign to a global variable you must always prefix the -command with a 'global' command, e.g.: -(Pdb) global list_options; list_options = ['-l'] -(Pdb)""", file=self.stdout) - - def help_run(self): - print("""run [args...] -Restart the debugged python program. If a string is supplied, it is -splitted with "shlex" and the result is used as the new sys.argv. -History, breakpoints, actions and debugger options are preserved. -"restart" is an alias for "run".""") - - help_restart = help_run - - def help_quit(self): - self.help_q() - - def help_q(self): - print("""q(uit) or exit - Quit from the debugger. -The program being executed is aborted.""", file=self.stdout) - - help_exit = help_q - - def help_whatis(self): - print("""whatis arg -Prints the type of the argument.""", file=self.stdout) - - def help_EOF(self): - print("""EOF -Handles the receipt of EOF as a command.""", file=self.stdout) - - def help_alias(self): - print("""alias [name [command [parameter parameter ...] ]] -Creates an alias called 'name' the executes 'command'. The command -must *not* be enclosed in quotes. Replaceable parameters are -indicated by %1, %2, and so on, while %* is replaced by all the -parameters. If no command is given, the current alias for name -is shown. If no name is given, all aliases are listed. - -Aliases may be nested and can contain anything that can be -legally typed at the pdb prompt. Note! You *can* override -internal pdb commands with aliases! Those internal commands -are then hidden until the alias is removed. Aliasing is recursively -applied to the first word of the command line; all other words -in the line are left alone. - -Some useful aliases (especially when placed in the .pdbrc file) are: - -#Print instance variables (usage "pi classInst") -alias pi for k in %1.__dict__.keys(): print "%1.",k,"=",%1.__dict__[k] - -#Print instance variables in self -alias ps pi self -""", file=self.stdout) - - def help_unalias(self): - print("""unalias name -Deletes the specified alias.""", file=self.stdout) - - def help_commands(self): - print("""commands [bpnumber] -(com) ... -(com) end -(Pdb) - -Specify a list of commands for breakpoint number bpnumber. The -commands themselves appear on the following lines. Type a line -containing just 'end' to terminate the commands. - -To remove all commands from a breakpoint, type commands and -follow it immediately with end; that is, give no commands. - -With no bpnumber argument, commands refers to the last -breakpoint set. - -You can use breakpoint commands to start your program up again. -Simply use the continue command, or step, or any other -command that resumes execution. - -Specifying any command resuming execution (currently continue, -step, next, return, jump, quit and their abbreviations) terminates -the command list (as if that command was immediately followed by end). -This is because any time you resume execution -(even with a simple next or step), you may encounter -another breakpoint--which could have its own command list, leading to -ambiguities about which list to execute. - - If you use the 'silent' command in the command list, the -usual message about stopping at a breakpoint is not printed. This may -be desirable for breakpoints that are to print a specific message and -then continue. If none of the other commands print anything, you -see no sign that the breakpoint was reached. -""", file=self.stdout) + """(!) statement + Execute the (one-line) statement in the context of the current + stack frame. The exclamation point can be omitted unless the + first word of the statement resembles a debugger command. To + assign to a global variable you must always prefix the command + with a 'global' command, e.g.: + (Pdb) global list_options; list_options = ['-l'] + (Pdb) + """ + self.message((self.help_exec.__doc__ or '').strip()) def help_pdb(self): help() + # other helper functions + def lookupmodule(self, filename): """Helper function for break/clear parsing -- may be overridden. @@ -1219,14 +1428,33 @@ see no sign that the breakpoint was reached. # events depends on python version). So we take special measures to # avoid stopping before we reach the main script (see user_line and # user_call for details). - self._wait_for_mainpyfile = 1 + self._wait_for_mainpyfile = True self.mainpyfile = self.canonic(filename) - self._user_requested_quit = 0 + self._user_requested_quit = False with open(filename, "rb") as fp: statement = "exec(compile(%r, %r, 'exec'))" % \ (fp.read(), self.mainpyfile) self.run(statement) +# Collect all command help into docstring, if not run with -OO + +if __doc__ is not None: + # unfortunately we can't guess this order from the class definition + _help_order = [ + 'help', 'where', 'down', 'up', 'break', 'tbreak', 'clear', 'disable', + 'enable', 'ignore', 'condition', 'commands', 'step', 'next', 'until', + 'jump', 'return', 'retval', 'run', 'continue', 'list', 'longlist', + 'args', 'print', 'pp', 'whatis', 'source', 'display', 'undisplay', + 'interact', 'alias', 'unalias', 'debug', 'quit', + ] + + for _command in _help_order: + __doc__ += getattr(Pdb, 'do_' + _command).__doc__.strip() + '\n\n' + __doc__ += Pdb.help_exec.__doc__ + + del _help_order, _command + + # Simplified interface def run(statement, globals=None, locals=None): @@ -1253,9 +1481,9 @@ def post_mortem(t=None): # sys.exc_info() returns (type, value, traceback) if an exception is # being handled, otherwise it returns None t = sys.exc_info()[2] - if t is None: - raise ValueError("A valid traceback must be passed if no " - "exception is being handled") + if t is None: + raise ValueError("A valid traceback must be passed if no " + "exception is being handled") p = Pdb() p.reset() @@ -1274,27 +1502,45 @@ def test(): # print help def help(): - for dirname in sys.path: - fullname = os.path.join(dirname, 'pdb.doc') - if os.path.exists(fullname): - sts = os.system('${PAGER-more} '+fullname) - if sts: print('*** Pager exit status:', sts) - break - else: - print('Sorry, can\'t find the help file "pdb.doc"', end=' ') - print('along the Python search path') + import pydoc + pydoc.pager(__doc__) + +_usage = """\ +usage: pdb.py [-c command] ... pyfile [arg] ... + +Debug the Python program given by pyfile. + +Initial commands are read from .pdbrc files in your home directory +and in the current directory, if they exist. Commands supplied with +-c are executed after commands from .pdbrc files. + +To let the script run until an exception occurs, use "-c continue". +To let the script run up to a given line X in the debugged file, use +"-c 'until X'".""" def main(): - if not sys.argv[1:] or sys.argv[1] in ("--help", "-h"): - print("usage: pdb.py scriptfile [arg] ...") + import getopt + + opts, args = getopt.getopt(sys.argv[1:], 'hc:', ['--help', '--command=']) + + if not args: + print(_usage) sys.exit(2) - mainpyfile = sys.argv[1] # Get script filename + commands = [] + for opt, optarg in opts: + if opt in ['-h', '--help']: + print(_usage) + sys.exit() + elif opt in ['-c', '--command']: + commands.append(optarg) + + mainpyfile = args[0] # Get script filename if not os.path.exists(mainpyfile): print('Error:', mainpyfile, 'does not exist') sys.exit(1) - del sys.argv[0] # Hide "pdb.py" from argument list + sys.argv[:] = args # Hide "pdb.py" and pdb options from argument list # Replace pdb's dir with script's dir in front of module search path. sys.path[0] = os.path.dirname(mainpyfile) @@ -1304,6 +1550,7 @@ def main(): # changed by the user from the command line. There is a "restart" command # which allows explicit specification of command line arguments. pdb = Pdb() + pdb.rcLines.extend(commands) while True: try: pdb._runscript(mainpyfile) @@ -1312,10 +1559,10 @@ def main(): print("The program finished and will be restarted") except Restart: print("Restarting", mainpyfile, "with arguments:") - print("\t" + " ".join(sys.argv[1:])) + print("\t" + " ".join(args)) except SystemExit: # In most cases SystemExit does not warrant a post-mortem session. - print("The program exited via sys.exit(). Exit status: ", end=' ') + print("The program exited via sys.exit(). Exit status:", end=' ') print(sys.exc_info()[1]) except: traceback.print_exc() |