| [2] | 1 | #! /usr/bin/env python
|
|---|
| 2 |
|
|---|
| 3 | """A Python debugger."""
|
|---|
| 4 |
|
|---|
| 5 | # (See pdb.doc for documentation.)
|
|---|
| 6 |
|
|---|
| 7 | import sys
|
|---|
| 8 | import linecache
|
|---|
| 9 | import cmd
|
|---|
| 10 | import bdb
|
|---|
| 11 | from repr import Repr
|
|---|
| 12 | import os
|
|---|
| 13 | import re
|
|---|
| 14 | import pprint
|
|---|
| 15 | import traceback
|
|---|
| 16 |
|
|---|
| 17 |
|
|---|
| 18 | class Restart(Exception):
|
|---|
| 19 | """Causes a debugger to be restarted for the debugged python program."""
|
|---|
| 20 | pass
|
|---|
| 21 |
|
|---|
| 22 | # Create a custom safe Repr instance and increase its maxstring.
|
|---|
| 23 | # The default of 30 truncates error messages too easily.
|
|---|
| 24 | _repr = Repr()
|
|---|
| 25 | _repr.maxstring = 200
|
|---|
| 26 | _saferepr = _repr.repr
|
|---|
| 27 |
|
|---|
| 28 | __all__ = ["run", "pm", "Pdb", "runeval", "runctx", "runcall", "set_trace",
|
|---|
| 29 | "post_mortem", "help"]
|
|---|
| 30 |
|
|---|
| 31 | def find_function(funcname, filename):
|
|---|
| 32 | cre = re.compile(r'def\s+%s\s*[(]' % re.escape(funcname))
|
|---|
| 33 | try:
|
|---|
| 34 | fp = open(filename)
|
|---|
| 35 | except IOError:
|
|---|
| 36 | return None
|
|---|
| 37 | # consumer of this info expects the first line to be 1
|
|---|
| 38 | lineno = 1
|
|---|
| 39 | answer = None
|
|---|
| 40 | while 1:
|
|---|
| 41 | line = fp.readline()
|
|---|
| 42 | if line == '':
|
|---|
| 43 | break
|
|---|
| 44 | if cre.match(line):
|
|---|
| 45 | answer = funcname, filename, lineno
|
|---|
| 46 | break
|
|---|
| 47 | lineno = lineno + 1
|
|---|
| 48 | fp.close()
|
|---|
| 49 | return answer
|
|---|
| 50 |
|
|---|
| 51 |
|
|---|
| 52 | # Interaction prompt line will separate file and call info from code
|
|---|
| 53 | # text using value of line_prefix string. A newline and arrow may
|
|---|
| 54 | # be to your liking. You can set it once pdb is imported using the
|
|---|
| 55 | # command "pdb.line_prefix = '\n% '".
|
|---|
| 56 | # line_prefix = ': ' # Use this to get the old situation back
|
|---|
| 57 | line_prefix = '\n-> ' # Probably a better default
|
|---|
| 58 |
|
|---|
| 59 | class Pdb(bdb.Bdb, cmd.Cmd):
|
|---|
| 60 |
|
|---|
| [391] | 61 | def __init__(self, completekey='tab', stdin=None, stdout=None, skip=None):
|
|---|
| 62 | bdb.Bdb.__init__(self, skip=skip)
|
|---|
| [2] | 63 | cmd.Cmd.__init__(self, completekey, stdin, stdout)
|
|---|
| 64 | if stdout:
|
|---|
| 65 | self.use_rawinput = 0
|
|---|
| 66 | self.prompt = '(Pdb) '
|
|---|
| 67 | self.aliases = {}
|
|---|
| 68 | self.mainpyfile = ''
|
|---|
| 69 | self._wait_for_mainpyfile = 0
|
|---|
| 70 | # Try to load readline if it exists
|
|---|
| 71 | try:
|
|---|
| 72 | import readline
|
|---|
| 73 | except ImportError:
|
|---|
| 74 | pass
|
|---|
| 75 |
|
|---|
| 76 | # Read $HOME/.pdbrc and ./.pdbrc
|
|---|
| 77 | self.rcLines = []
|
|---|
| 78 | if 'HOME' in os.environ:
|
|---|
| 79 | envHome = os.environ['HOME']
|
|---|
| 80 | try:
|
|---|
| 81 | rcFile = open(os.path.join(envHome, ".pdbrc"))
|
|---|
| 82 | except IOError:
|
|---|
| 83 | pass
|
|---|
| 84 | else:
|
|---|
| 85 | for line in rcFile.readlines():
|
|---|
| 86 | self.rcLines.append(line)
|
|---|
| 87 | rcFile.close()
|
|---|
| 88 | try:
|
|---|
| 89 | rcFile = open(".pdbrc")
|
|---|
| 90 | except IOError:
|
|---|
| 91 | pass
|
|---|
| 92 | else:
|
|---|
| 93 | for line in rcFile.readlines():
|
|---|
| 94 | self.rcLines.append(line)
|
|---|
| 95 | rcFile.close()
|
|---|
| 96 |
|
|---|
| 97 | self.commands = {} # associates a command list to breakpoint numbers
|
|---|
| [391] | 98 | self.commands_doprompt = {} # for each bp num, tells if the prompt
|
|---|
| 99 | # must be disp. after execing the cmd list
|
|---|
| 100 | self.commands_silent = {} # for each bp num, tells if the stack trace
|
|---|
| 101 | # must be disp. after execing the cmd list
|
|---|
| 102 | self.commands_defining = False # True while in the process of defining
|
|---|
| 103 | # a command list
|
|---|
| 104 | self.commands_bnum = None # The breakpoint number for which we are
|
|---|
| 105 | # defining a list
|
|---|
| [2] | 106 |
|
|---|
| 107 | def reset(self):
|
|---|
| 108 | bdb.Bdb.reset(self)
|
|---|
| 109 | self.forget()
|
|---|
| 110 |
|
|---|
| 111 | def forget(self):
|
|---|
| 112 | self.lineno = None
|
|---|
| 113 | self.stack = []
|
|---|
| 114 | self.curindex = 0
|
|---|
| 115 | self.curframe = None
|
|---|
| 116 |
|
|---|
| 117 | def setup(self, f, t):
|
|---|
| 118 | self.forget()
|
|---|
| 119 | self.stack, self.curindex = self.get_stack(f, t)
|
|---|
| 120 | self.curframe = self.stack[self.curindex][0]
|
|---|
| [391] | 121 | # The f_locals dictionary is updated from the actual frame
|
|---|
| 122 | # locals whenever the .f_locals accessor is called, so we
|
|---|
| 123 | # cache it here to ensure that modifications are not overwritten.
|
|---|
| 124 | self.curframe_locals = self.curframe.f_locals
|
|---|
| [2] | 125 | self.execRcLines()
|
|---|
| 126 |
|
|---|
| 127 | # Can be executed earlier than 'setup' if desired
|
|---|
| 128 | def execRcLines(self):
|
|---|
| 129 | if self.rcLines:
|
|---|
| 130 | # Make local copy because of recursion
|
|---|
| 131 | rcLines = self.rcLines
|
|---|
| 132 | # executed only once
|
|---|
| 133 | self.rcLines = []
|
|---|
| 134 | for line in rcLines:
|
|---|
| 135 | line = line[:-1]
|
|---|
| 136 | if len(line) > 0 and line[0] != '#':
|
|---|
| 137 | self.onecmd(line)
|
|---|
| 138 |
|
|---|
| 139 | # Override Bdb methods
|
|---|
| 140 |
|
|---|
| 141 | def user_call(self, frame, argument_list):
|
|---|
| 142 | """This method is called when there is the remote possibility
|
|---|
| 143 | that we ever need to stop in this function."""
|
|---|
| 144 | if self._wait_for_mainpyfile:
|
|---|
| 145 | return
|
|---|
| 146 | if self.stop_here(frame):
|
|---|
| 147 | print >>self.stdout, '--Call--'
|
|---|
| 148 | self.interaction(frame, None)
|
|---|
| 149 |
|
|---|
| 150 | def user_line(self, frame):
|
|---|
| 151 | """This function is called when we stop or break at this line."""
|
|---|
| 152 | if self._wait_for_mainpyfile:
|
|---|
| 153 | if (self.mainpyfile != self.canonic(frame.f_code.co_filename)
|
|---|
| 154 | or frame.f_lineno<= 0):
|
|---|
| 155 | return
|
|---|
| 156 | self._wait_for_mainpyfile = 0
|
|---|
| 157 | if self.bp_commands(frame):
|
|---|
| 158 | self.interaction(frame, None)
|
|---|
| 159 |
|
|---|
| 160 | def bp_commands(self,frame):
|
|---|
| [391] | 161 | """Call every command that was set for the current active breakpoint
|
|---|
| 162 | (if there is one).
|
|---|
| 163 |
|
|---|
| 164 | Returns True if the normal interaction function must be called,
|
|---|
| 165 | False otherwise."""
|
|---|
| 166 | # self.currentbp is set in bdb in Bdb.break_here if a breakpoint was hit
|
|---|
| 167 | if getattr(self, "currentbp", False) and \
|
|---|
| 168 | self.currentbp in self.commands:
|
|---|
| [2] | 169 | currentbp = self.currentbp
|
|---|
| 170 | self.currentbp = 0
|
|---|
| 171 | lastcmd_back = self.lastcmd
|
|---|
| 172 | self.setup(frame, None)
|
|---|
| 173 | for line in self.commands[currentbp]:
|
|---|
| 174 | self.onecmd(line)
|
|---|
| 175 | self.lastcmd = lastcmd_back
|
|---|
| 176 | if not self.commands_silent[currentbp]:
|
|---|
| 177 | self.print_stack_entry(self.stack[self.curindex])
|
|---|
| 178 | if self.commands_doprompt[currentbp]:
|
|---|
| 179 | self.cmdloop()
|
|---|
| 180 | self.forget()
|
|---|
| 181 | return
|
|---|
| 182 | return 1
|
|---|
| 183 |
|
|---|
| 184 | def user_return(self, frame, return_value):
|
|---|
| 185 | """This function is called when a return trap is set here."""
|
|---|
| [391] | 186 | if self._wait_for_mainpyfile:
|
|---|
| 187 | return
|
|---|
| [2] | 188 | frame.f_locals['__return__'] = return_value
|
|---|
| 189 | print >>self.stdout, '--Return--'
|
|---|
| 190 | self.interaction(frame, None)
|
|---|
| 191 |
|
|---|
| 192 | def user_exception(self, frame, exc_info):
|
|---|
| 193 | """This function is called if an exception occurs,
|
|---|
| 194 | but only if we are to stop at or just below this level."""
|
|---|
| [391] | 195 | if self._wait_for_mainpyfile:
|
|---|
| 196 | return
|
|---|
| 197 | exc_type, exc_value, exc_traceback = exc_info
|
|---|
| [2] | 198 | frame.f_locals['__exception__'] = exc_type, exc_value
|
|---|
| 199 | if type(exc_type) == type(''):
|
|---|
| 200 | exc_type_name = exc_type
|
|---|
| 201 | else: exc_type_name = exc_type.__name__
|
|---|
| 202 | print >>self.stdout, exc_type_name + ':', _saferepr(exc_value)
|
|---|
| 203 | self.interaction(frame, exc_traceback)
|
|---|
| 204 |
|
|---|
| 205 | # General interaction function
|
|---|
| 206 |
|
|---|
| 207 | def interaction(self, frame, traceback):
|
|---|
| 208 | self.setup(frame, traceback)
|
|---|
| 209 | self.print_stack_entry(self.stack[self.curindex])
|
|---|
| 210 | self.cmdloop()
|
|---|
| 211 | self.forget()
|
|---|
| 212 |
|
|---|
| 213 | def displayhook(self, obj):
|
|---|
| 214 | """Custom displayhook for the exec in default(), which prevents
|
|---|
| 215 | assignment of the _ variable in the builtins.
|
|---|
| 216 | """
|
|---|
| 217 | # reproduce the behavior of the standard displayhook, not printing None
|
|---|
| 218 | if obj is not None:
|
|---|
| 219 | print repr(obj)
|
|---|
| 220 |
|
|---|
| 221 | def default(self, line):
|
|---|
| 222 | if line[:1] == '!': line = line[1:]
|
|---|
| [391] | 223 | locals = self.curframe_locals
|
|---|
| [2] | 224 | globals = self.curframe.f_globals
|
|---|
| 225 | try:
|
|---|
| 226 | code = compile(line + '\n', '<stdin>', 'single')
|
|---|
| 227 | save_stdout = sys.stdout
|
|---|
| 228 | save_stdin = sys.stdin
|
|---|
| 229 | save_displayhook = sys.displayhook
|
|---|
| 230 | try:
|
|---|
| 231 | sys.stdin = self.stdin
|
|---|
| 232 | sys.stdout = self.stdout
|
|---|
| 233 | sys.displayhook = self.displayhook
|
|---|
| 234 | exec code in globals, locals
|
|---|
| 235 | finally:
|
|---|
| 236 | sys.stdout = save_stdout
|
|---|
| 237 | sys.stdin = save_stdin
|
|---|
| 238 | sys.displayhook = save_displayhook
|
|---|
| 239 | except:
|
|---|
| 240 | t, v = sys.exc_info()[:2]
|
|---|
| 241 | if type(t) == type(''):
|
|---|
| 242 | exc_type_name = t
|
|---|
| 243 | else: exc_type_name = t.__name__
|
|---|
| 244 | print >>self.stdout, '***', exc_type_name + ':', v
|
|---|
| 245 |
|
|---|
| 246 | def precmd(self, line):
|
|---|
| 247 | """Handle alias expansion and ';;' separator."""
|
|---|
| 248 | if not line.strip():
|
|---|
| 249 | return line
|
|---|
| 250 | args = line.split()
|
|---|
| 251 | while args[0] in self.aliases:
|
|---|
| 252 | line = self.aliases[args[0]]
|
|---|
| 253 | ii = 1
|
|---|
| 254 | for tmpArg in args[1:]:
|
|---|
| 255 | line = line.replace("%" + str(ii),
|
|---|
| 256 | tmpArg)
|
|---|
| 257 | ii = ii + 1
|
|---|
| 258 | line = line.replace("%*", ' '.join(args[1:]))
|
|---|
| 259 | args = line.split()
|
|---|
| 260 | # split into ';;' separated commands
|
|---|
| 261 | # unless it's an alias command
|
|---|
| 262 | if args[0] != 'alias':
|
|---|
| 263 | marker = line.find(';;')
|
|---|
| 264 | if marker >= 0:
|
|---|
| 265 | # queue up everything after marker
|
|---|
| 266 | next = line[marker+2:].lstrip()
|
|---|
| 267 | self.cmdqueue.append(next)
|
|---|
| 268 | line = line[:marker].rstrip()
|
|---|
| 269 | return line
|
|---|
| 270 |
|
|---|
| 271 | def onecmd(self, line):
|
|---|
| 272 | """Interpret the argument as though it had been typed in response
|
|---|
| 273 | to the prompt.
|
|---|
| 274 |
|
|---|
| 275 | Checks whether this line is typed at the normal prompt or in
|
|---|
| 276 | a breakpoint command list definition.
|
|---|
| 277 | """
|
|---|
| 278 | if not self.commands_defining:
|
|---|
| 279 | return cmd.Cmd.onecmd(self, line)
|
|---|
| 280 | else:
|
|---|
| 281 | return self.handle_command_def(line)
|
|---|
| 282 |
|
|---|
| 283 | def handle_command_def(self,line):
|
|---|
| [391] | 284 | """Handles one command line during command list definition."""
|
|---|
| [2] | 285 | cmd, arg, line = self.parseline(line)
|
|---|
| [391] | 286 | if not cmd:
|
|---|
| 287 | return
|
|---|
| [2] | 288 | if cmd == 'silent':
|
|---|
| 289 | self.commands_silent[self.commands_bnum] = True
|
|---|
| 290 | return # continue to handle other cmd def in the cmd list
|
|---|
| 291 | elif cmd == 'end':
|
|---|
| 292 | self.cmdqueue = []
|
|---|
| 293 | return 1 # end of cmd list
|
|---|
| 294 | cmdlist = self.commands[self.commands_bnum]
|
|---|
| [391] | 295 | if arg:
|
|---|
| [2] | 296 | cmdlist.append(cmd+' '+arg)
|
|---|
| 297 | else:
|
|---|
| 298 | cmdlist.append(cmd)
|
|---|
| 299 | # Determine if we must stop
|
|---|
| 300 | try:
|
|---|
| 301 | func = getattr(self, 'do_' + cmd)
|
|---|
| 302 | except AttributeError:
|
|---|
| 303 | func = self.default
|
|---|
| [391] | 304 | # one of the resuming commands
|
|---|
| 305 | if func.func_name in self.commands_resuming:
|
|---|
| [2] | 306 | self.commands_doprompt[self.commands_bnum] = False
|
|---|
| 307 | self.cmdqueue = []
|
|---|
| 308 | return 1
|
|---|
| 309 | return
|
|---|
| 310 |
|
|---|
| 311 | # Command definitions, called by cmdloop()
|
|---|
| 312 | # The argument is the remaining string on the command line
|
|---|
| 313 | # Return true to exit from the command loop
|
|---|
| 314 |
|
|---|
| 315 | do_h = cmd.Cmd.do_help
|
|---|
| 316 |
|
|---|
| 317 | def do_commands(self, arg):
|
|---|
| [391] | 318 | """Defines a list of commands associated to a breakpoint.
|
|---|
| 319 |
|
|---|
| 320 | Those commands will be executed whenever the breakpoint causes
|
|---|
| 321 | the program to stop execution."""
|
|---|
| [2] | 322 | if not arg:
|
|---|
| 323 | bnum = len(bdb.Breakpoint.bpbynumber)-1
|
|---|
| 324 | else:
|
|---|
| 325 | try:
|
|---|
| 326 | bnum = int(arg)
|
|---|
| 327 | except:
|
|---|
| [391] | 328 | print >>self.stdout, "Usage : commands [bnum]\n ..." \
|
|---|
| 329 | "\n end"
|
|---|
| [2] | 330 | return
|
|---|
| 331 | self.commands_bnum = bnum
|
|---|
| 332 | self.commands[bnum] = []
|
|---|
| 333 | self.commands_doprompt[bnum] = True
|
|---|
| 334 | self.commands_silent[bnum] = False
|
|---|
| 335 | prompt_back = self.prompt
|
|---|
| 336 | self.prompt = '(com) '
|
|---|
| 337 | self.commands_defining = True
|
|---|
| [391] | 338 | try:
|
|---|
| 339 | self.cmdloop()
|
|---|
| 340 | finally:
|
|---|
| 341 | self.commands_defining = False
|
|---|
| 342 | self.prompt = prompt_back
|
|---|
| [2] | 343 |
|
|---|
| 344 | def do_break(self, arg, temporary = 0):
|
|---|
| 345 | # break [ ([filename:]lineno | function) [, "condition"] ]
|
|---|
| 346 | if not arg:
|
|---|
| 347 | if self.breaks: # There's at least one
|
|---|
| 348 | print >>self.stdout, "Num Type Disp Enb Where"
|
|---|
| 349 | for bp in bdb.Breakpoint.bpbynumber:
|
|---|
| 350 | if bp:
|
|---|
| 351 | bp.bpprint(self.stdout)
|
|---|
| 352 | return
|
|---|
| 353 | # parse arguments; comma has lowest precedence
|
|---|
| 354 | # and cannot occur in filename
|
|---|
| 355 | filename = None
|
|---|
| 356 | lineno = None
|
|---|
| 357 | cond = None
|
|---|
| 358 | comma = arg.find(',')
|
|---|
| 359 | if comma > 0:
|
|---|
| 360 | # parse stuff after comma: "condition"
|
|---|
| 361 | cond = arg[comma+1:].lstrip()
|
|---|
| 362 | arg = arg[:comma].rstrip()
|
|---|
| 363 | # parse stuff before comma: [filename:]lineno | function
|
|---|
| 364 | colon = arg.rfind(':')
|
|---|
| 365 | funcname = None
|
|---|
| 366 | if colon >= 0:
|
|---|
| 367 | filename = arg[:colon].rstrip()
|
|---|
| 368 | f = self.lookupmodule(filename)
|
|---|
| 369 | if not f:
|
|---|
| 370 | print >>self.stdout, '*** ', repr(filename),
|
|---|
| 371 | print >>self.stdout, 'not found from sys.path'
|
|---|
| 372 | return
|
|---|
| 373 | else:
|
|---|
| 374 | filename = f
|
|---|
| 375 | arg = arg[colon+1:].lstrip()
|
|---|
| 376 | try:
|
|---|
| 377 | lineno = int(arg)
|
|---|
| 378 | except ValueError, msg:
|
|---|
| 379 | print >>self.stdout, '*** Bad lineno:', arg
|
|---|
| 380 | return
|
|---|
| 381 | else:
|
|---|
| 382 | # no colon; can be lineno or function
|
|---|
| 383 | try:
|
|---|
| 384 | lineno = int(arg)
|
|---|
| 385 | except ValueError:
|
|---|
| 386 | try:
|
|---|
| 387 | func = eval(arg,
|
|---|
| 388 | self.curframe.f_globals,
|
|---|
| [391] | 389 | self.curframe_locals)
|
|---|
| [2] | 390 | except:
|
|---|
| 391 | func = arg
|
|---|
| 392 | try:
|
|---|
| 393 | if hasattr(func, 'im_func'):
|
|---|
| 394 | func = func.im_func
|
|---|
| 395 | code = func.func_code
|
|---|
| 396 | #use co_name to identify the bkpt (function names
|
|---|
| 397 | #could be aliased, but co_name is invariant)
|
|---|
| 398 | funcname = code.co_name
|
|---|
| 399 | lineno = code.co_firstlineno
|
|---|
| 400 | filename = code.co_filename
|
|---|
| 401 | except:
|
|---|
| 402 | # last thing to try
|
|---|
| 403 | (ok, filename, ln) = self.lineinfo(arg)
|
|---|
| 404 | if not ok:
|
|---|
| 405 | print >>self.stdout, '*** The specified object',
|
|---|
| 406 | print >>self.stdout, repr(arg),
|
|---|
| 407 | print >>self.stdout, 'is not a function'
|
|---|
| 408 | print >>self.stdout, 'or was not found along sys.path.'
|
|---|
| 409 | return
|
|---|
| 410 | funcname = ok # ok contains a function name
|
|---|
| 411 | lineno = int(ln)
|
|---|
| 412 | if not filename:
|
|---|
| 413 | filename = self.defaultFile()
|
|---|
| 414 | # Check for reasonable breakpoint
|
|---|
| 415 | line = self.checkline(filename, lineno)
|
|---|
| 416 | if line:
|
|---|
| 417 | # now set the break point
|
|---|
| 418 | err = self.set_break(filename, line, temporary, cond, funcname)
|
|---|
| 419 | if err: print >>self.stdout, '***', err
|
|---|
| 420 | else:
|
|---|
| 421 | bp = self.get_breaks(filename, line)[-1]
|
|---|
| 422 | print >>self.stdout, "Breakpoint %d at %s:%d" % (bp.number,
|
|---|
| 423 | bp.file,
|
|---|
| 424 | bp.line)
|
|---|
| 425 |
|
|---|
| 426 | # To be overridden in derived debuggers
|
|---|
| 427 | def defaultFile(self):
|
|---|
| 428 | """Produce a reasonable default."""
|
|---|
| 429 | filename = self.curframe.f_code.co_filename
|
|---|
| 430 | if filename == '<string>' and self.mainpyfile:
|
|---|
| 431 | filename = self.mainpyfile
|
|---|
| 432 | return filename
|
|---|
| 433 |
|
|---|
| 434 | do_b = do_break
|
|---|
| 435 |
|
|---|
| 436 | def do_tbreak(self, arg):
|
|---|
| 437 | self.do_break(arg, 1)
|
|---|
| 438 |
|
|---|
| 439 | def lineinfo(self, identifier):
|
|---|
| 440 | failed = (None, None, None)
|
|---|
| 441 | # Input is identifier, may be in single quotes
|
|---|
| 442 | idstring = identifier.split("'")
|
|---|
| 443 | if len(idstring) == 1:
|
|---|
| 444 | # not in single quotes
|
|---|
| 445 | id = idstring[0].strip()
|
|---|
| 446 | elif len(idstring) == 3:
|
|---|
| 447 | # quoted
|
|---|
| 448 | id = idstring[1].strip()
|
|---|
| 449 | else:
|
|---|
| 450 | return failed
|
|---|
| 451 | if id == '': return failed
|
|---|
| 452 | parts = id.split('.')
|
|---|
| 453 | # Protection for derived debuggers
|
|---|
| 454 | if parts[0] == 'self':
|
|---|
| 455 | del parts[0]
|
|---|
| 456 | if len(parts) == 0:
|
|---|
| 457 | return failed
|
|---|
| 458 | # Best first guess at file to look at
|
|---|
| 459 | fname = self.defaultFile()
|
|---|
| 460 | if len(parts) == 1:
|
|---|
| 461 | item = parts[0]
|
|---|
| 462 | else:
|
|---|
| 463 | # More than one part.
|
|---|
| 464 | # First is module, second is method/class
|
|---|
| 465 | f = self.lookupmodule(parts[0])
|
|---|
| 466 | if f:
|
|---|
| 467 | fname = f
|
|---|
| 468 | item = parts[1]
|
|---|
| 469 | answer = find_function(item, fname)
|
|---|
| 470 | return answer or failed
|
|---|
| 471 |
|
|---|
| 472 | def checkline(self, filename, lineno):
|
|---|
| 473 | """Check whether specified line seems to be executable.
|
|---|
| 474 |
|
|---|
| 475 | Return `lineno` if it is, 0 if not (e.g. a docstring, comment, blank
|
|---|
| 476 | line or EOF). Warning: testing is not comprehensive.
|
|---|
| 477 | """
|
|---|
| [391] | 478 | # this method should be callable before starting debugging, so default
|
|---|
| 479 | # to "no globals" if there is no current frame
|
|---|
| 480 | globs = self.curframe.f_globals if hasattr(self, 'curframe') else None
|
|---|
| 481 | line = linecache.getline(filename, lineno, globs)
|
|---|
| [2] | 482 | if not line:
|
|---|
| 483 | print >>self.stdout, 'End of file'
|
|---|
| 484 | return 0
|
|---|
| 485 | line = line.strip()
|
|---|
| 486 | # Don't allow setting breakpoint at a blank line
|
|---|
| 487 | if (not line or (line[0] == '#') or
|
|---|
| 488 | (line[:3] == '"""') or line[:3] == "'''"):
|
|---|
| 489 | print >>self.stdout, '*** Blank or comment'
|
|---|
| 490 | return 0
|
|---|
| 491 | return lineno
|
|---|
| 492 |
|
|---|
| 493 | def do_enable(self, arg):
|
|---|
| 494 | args = arg.split()
|
|---|
| 495 | for i in args:
|
|---|
| 496 | try:
|
|---|
| 497 | i = int(i)
|
|---|
| 498 | except ValueError:
|
|---|
| 499 | print >>self.stdout, 'Breakpoint index %r is not a number' % i
|
|---|
| 500 | continue
|
|---|
| 501 |
|
|---|
| 502 | if not (0 <= i < len(bdb.Breakpoint.bpbynumber)):
|
|---|
| 503 | print >>self.stdout, 'No breakpoint numbered', i
|
|---|
| 504 | continue
|
|---|
| 505 |
|
|---|
| 506 | bp = bdb.Breakpoint.bpbynumber[i]
|
|---|
| 507 | if bp:
|
|---|
| 508 | bp.enable()
|
|---|
| 509 |
|
|---|
| 510 | def do_disable(self, arg):
|
|---|
| 511 | args = arg.split()
|
|---|
| 512 | for i in args:
|
|---|
| 513 | try:
|
|---|
| 514 | i = int(i)
|
|---|
| 515 | except ValueError:
|
|---|
| 516 | print >>self.stdout, 'Breakpoint index %r is not a number' % i
|
|---|
| 517 | continue
|
|---|
| 518 |
|
|---|
| 519 | if not (0 <= i < len(bdb.Breakpoint.bpbynumber)):
|
|---|
| 520 | print >>self.stdout, 'No breakpoint numbered', i
|
|---|
| 521 | continue
|
|---|
| 522 |
|
|---|
| 523 | bp = bdb.Breakpoint.bpbynumber[i]
|
|---|
| 524 | if bp:
|
|---|
| 525 | bp.disable()
|
|---|
| 526 |
|
|---|
| 527 | def do_condition(self, arg):
|
|---|
| 528 | # arg is breakpoint number and condition
|
|---|
| 529 | args = arg.split(' ', 1)
|
|---|
| 530 | try:
|
|---|
| 531 | bpnum = int(args[0].strip())
|
|---|
| 532 | except ValueError:
|
|---|
| 533 | # something went wrong
|
|---|
| 534 | print >>self.stdout, \
|
|---|
| 535 | 'Breakpoint index %r is not a number' % args[0]
|
|---|
| 536 | return
|
|---|
| 537 | try:
|
|---|
| 538 | cond = args[1]
|
|---|
| 539 | except:
|
|---|
| 540 | cond = None
|
|---|
| 541 | try:
|
|---|
| 542 | bp = bdb.Breakpoint.bpbynumber[bpnum]
|
|---|
| 543 | except IndexError:
|
|---|
| 544 | print >>self.stdout, 'Breakpoint index %r is not valid' % args[0]
|
|---|
| 545 | return
|
|---|
| 546 | if bp:
|
|---|
| 547 | bp.cond = cond
|
|---|
| 548 | if not cond:
|
|---|
| 549 | print >>self.stdout, 'Breakpoint', bpnum,
|
|---|
| 550 | print >>self.stdout, 'is now unconditional.'
|
|---|
| 551 |
|
|---|
| 552 | def do_ignore(self,arg):
|
|---|
| 553 | """arg is bp number followed by ignore count."""
|
|---|
| 554 | args = arg.split()
|
|---|
| 555 | try:
|
|---|
| 556 | bpnum = int(args[0].strip())
|
|---|
| 557 | except ValueError:
|
|---|
| 558 | # something went wrong
|
|---|
| 559 | print >>self.stdout, \
|
|---|
| 560 | 'Breakpoint index %r is not a number' % args[0]
|
|---|
| 561 | return
|
|---|
| 562 | try:
|
|---|
| 563 | count = int(args[1].strip())
|
|---|
| 564 | except:
|
|---|
| 565 | count = 0
|
|---|
| 566 | try:
|
|---|
| 567 | bp = bdb.Breakpoint.bpbynumber[bpnum]
|
|---|
| 568 | except IndexError:
|
|---|
| 569 | print >>self.stdout, 'Breakpoint index %r is not valid' % args[0]
|
|---|
| 570 | return
|
|---|
| 571 | if bp:
|
|---|
| 572 | bp.ignore = count
|
|---|
| 573 | if count > 0:
|
|---|
| 574 | reply = 'Will ignore next '
|
|---|
| 575 | if count > 1:
|
|---|
| 576 | reply = reply + '%d crossings' % count
|
|---|
| 577 | else:
|
|---|
| 578 | reply = reply + '1 crossing'
|
|---|
| 579 | print >>self.stdout, reply + ' of breakpoint %d.' % bpnum
|
|---|
| 580 | else:
|
|---|
| 581 | print >>self.stdout, 'Will stop next time breakpoint',
|
|---|
| 582 | print >>self.stdout, bpnum, 'is reached.'
|
|---|
| 583 |
|
|---|
| 584 | def do_clear(self, arg):
|
|---|
| 585 | """Three possibilities, tried in this order:
|
|---|
| 586 | clear -> clear all breaks, ask for confirmation
|
|---|
| 587 | clear file:lineno -> clear all breaks at file:lineno
|
|---|
| 588 | clear bpno bpno ... -> clear breakpoints by number"""
|
|---|
| 589 | if not arg:
|
|---|
| 590 | try:
|
|---|
| 591 | reply = raw_input('Clear all breaks? ')
|
|---|
| 592 | except EOFError:
|
|---|
| 593 | reply = 'no'
|
|---|
| 594 | reply = reply.strip().lower()
|
|---|
| 595 | if reply in ('y', 'yes'):
|
|---|
| 596 | self.clear_all_breaks()
|
|---|
| 597 | return
|
|---|
| 598 | if ':' in arg:
|
|---|
| 599 | # Make sure it works for "clear C:\foo\bar.py:12"
|
|---|
| 600 | i = arg.rfind(':')
|
|---|
| 601 | filename = arg[:i]
|
|---|
| 602 | arg = arg[i+1:]
|
|---|
| 603 | try:
|
|---|
| 604 | lineno = int(arg)
|
|---|
| 605 | except ValueError:
|
|---|
| 606 | err = "Invalid line number (%s)" % arg
|
|---|
| 607 | else:
|
|---|
| 608 | err = self.clear_break(filename, lineno)
|
|---|
| 609 | if err: print >>self.stdout, '***', err
|
|---|
| 610 | return
|
|---|
| 611 | numberlist = arg.split()
|
|---|
| 612 | for i in numberlist:
|
|---|
| 613 | try:
|
|---|
| 614 | i = int(i)
|
|---|
| 615 | except ValueError:
|
|---|
| 616 | print >>self.stdout, 'Breakpoint index %r is not a number' % i
|
|---|
| 617 | continue
|
|---|
| 618 |
|
|---|
| 619 | if not (0 <= i < len(bdb.Breakpoint.bpbynumber)):
|
|---|
| 620 | print >>self.stdout, 'No breakpoint numbered', i
|
|---|
| 621 | continue
|
|---|
| 622 | err = self.clear_bpbynumber(i)
|
|---|
| 623 | if err:
|
|---|
| 624 | print >>self.stdout, '***', err
|
|---|
| 625 | else:
|
|---|
| 626 | print >>self.stdout, 'Deleted breakpoint', i
|
|---|
| 627 | do_cl = do_clear # 'c' is already an abbreviation for 'continue'
|
|---|
| 628 |
|
|---|
| 629 | def do_where(self, arg):
|
|---|
| 630 | self.print_stack_trace()
|
|---|
| 631 | do_w = do_where
|
|---|
| 632 | do_bt = do_where
|
|---|
| 633 |
|
|---|
| 634 | def do_up(self, arg):
|
|---|
| 635 | if self.curindex == 0:
|
|---|
| 636 | print >>self.stdout, '*** Oldest frame'
|
|---|
| 637 | else:
|
|---|
| 638 | self.curindex = self.curindex - 1
|
|---|
| 639 | self.curframe = self.stack[self.curindex][0]
|
|---|
| [391] | 640 | self.curframe_locals = self.curframe.f_locals
|
|---|
| [2] | 641 | self.print_stack_entry(self.stack[self.curindex])
|
|---|
| 642 | self.lineno = None
|
|---|
| 643 | do_u = do_up
|
|---|
| 644 |
|
|---|
| 645 | def do_down(self, arg):
|
|---|
| 646 | if self.curindex + 1 == len(self.stack):
|
|---|
| 647 | print >>self.stdout, '*** Newest frame'
|
|---|
| 648 | else:
|
|---|
| 649 | self.curindex = self.curindex + 1
|
|---|
| 650 | self.curframe = self.stack[self.curindex][0]
|
|---|
| [391] | 651 | self.curframe_locals = self.curframe.f_locals
|
|---|
| [2] | 652 | self.print_stack_entry(self.stack[self.curindex])
|
|---|
| 653 | self.lineno = None
|
|---|
| 654 | do_d = do_down
|
|---|
| 655 |
|
|---|
| 656 | def do_until(self, arg):
|
|---|
| 657 | self.set_until(self.curframe)
|
|---|
| 658 | return 1
|
|---|
| 659 | do_unt = do_until
|
|---|
| 660 |
|
|---|
| 661 | def do_step(self, arg):
|
|---|
| 662 | self.set_step()
|
|---|
| 663 | return 1
|
|---|
| 664 | do_s = do_step
|
|---|
| 665 |
|
|---|
| 666 | def do_next(self, arg):
|
|---|
| 667 | self.set_next(self.curframe)
|
|---|
| 668 | return 1
|
|---|
| 669 | do_n = do_next
|
|---|
| 670 |
|
|---|
| 671 | def do_run(self, arg):
|
|---|
| [391] | 672 | """Restart program by raising an exception to be caught in the main
|
|---|
| 673 | debugger loop. If arguments were given, set them in sys.argv."""
|
|---|
| [2] | 674 | if arg:
|
|---|
| 675 | import shlex
|
|---|
| 676 | argv0 = sys.argv[0:1]
|
|---|
| 677 | sys.argv = shlex.split(arg)
|
|---|
| 678 | sys.argv[:0] = argv0
|
|---|
| 679 | raise Restart
|
|---|
| 680 |
|
|---|
| 681 | do_restart = do_run
|
|---|
| 682 |
|
|---|
| 683 | def do_return(self, arg):
|
|---|
| 684 | self.set_return(self.curframe)
|
|---|
| 685 | return 1
|
|---|
| 686 | do_r = do_return
|
|---|
| 687 |
|
|---|
| 688 | def do_continue(self, arg):
|
|---|
| 689 | self.set_continue()
|
|---|
| 690 | return 1
|
|---|
| 691 | do_c = do_cont = do_continue
|
|---|
| 692 |
|
|---|
| 693 | def do_jump(self, arg):
|
|---|
| 694 | if self.curindex + 1 != len(self.stack):
|
|---|
| 695 | print >>self.stdout, "*** You can only jump within the bottom frame"
|
|---|
| 696 | return
|
|---|
| 697 | try:
|
|---|
| 698 | arg = int(arg)
|
|---|
| 699 | except ValueError:
|
|---|
| 700 | print >>self.stdout, "*** The 'jump' command requires a line number."
|
|---|
| 701 | else:
|
|---|
| 702 | try:
|
|---|
| 703 | # Do the jump, fix up our copy of the stack, and display the
|
|---|
| 704 | # new position
|
|---|
| 705 | self.curframe.f_lineno = arg
|
|---|
| 706 | self.stack[self.curindex] = self.stack[self.curindex][0], arg
|
|---|
| 707 | self.print_stack_entry(self.stack[self.curindex])
|
|---|
| 708 | except ValueError, e:
|
|---|
| 709 | print >>self.stdout, '*** Jump failed:', e
|
|---|
| 710 | do_j = do_jump
|
|---|
| 711 |
|
|---|
| 712 | def do_debug(self, arg):
|
|---|
| 713 | sys.settrace(None)
|
|---|
| 714 | globals = self.curframe.f_globals
|
|---|
| [391] | 715 | locals = self.curframe_locals
|
|---|
| [2] | 716 | p = Pdb(self.completekey, self.stdin, self.stdout)
|
|---|
| 717 | p.prompt = "(%s) " % self.prompt.strip()
|
|---|
| 718 | print >>self.stdout, "ENTERING RECURSIVE DEBUGGER"
|
|---|
| 719 | sys.call_tracing(p.run, (arg, globals, locals))
|
|---|
| 720 | print >>self.stdout, "LEAVING RECURSIVE DEBUGGER"
|
|---|
| 721 | sys.settrace(self.trace_dispatch)
|
|---|
| 722 | self.lastcmd = p.lastcmd
|
|---|
| 723 |
|
|---|
| 724 | def do_quit(self, arg):
|
|---|
| 725 | self._user_requested_quit = 1
|
|---|
| 726 | self.set_quit()
|
|---|
| 727 | return 1
|
|---|
| 728 |
|
|---|
| 729 | do_q = do_quit
|
|---|
| 730 | do_exit = do_quit
|
|---|
| 731 |
|
|---|
| 732 | def do_EOF(self, arg):
|
|---|
| 733 | print >>self.stdout
|
|---|
| 734 | self._user_requested_quit = 1
|
|---|
| 735 | self.set_quit()
|
|---|
| 736 | return 1
|
|---|
| 737 |
|
|---|
| 738 | def do_args(self, arg):
|
|---|
| [391] | 739 | co = self.curframe.f_code
|
|---|
| 740 | dict = self.curframe_locals
|
|---|
| [2] | 741 | n = co.co_argcount
|
|---|
| 742 | if co.co_flags & 4: n = n+1
|
|---|
| 743 | if co.co_flags & 8: n = n+1
|
|---|
| 744 | for i in range(n):
|
|---|
| 745 | name = co.co_varnames[i]
|
|---|
| 746 | print >>self.stdout, name, '=',
|
|---|
| 747 | if name in dict: print >>self.stdout, dict[name]
|
|---|
| 748 | else: print >>self.stdout, "*** undefined ***"
|
|---|
| 749 | do_a = do_args
|
|---|
| 750 |
|
|---|
| 751 | def do_retval(self, arg):
|
|---|
| [391] | 752 | if '__return__' in self.curframe_locals:
|
|---|
| 753 | print >>self.stdout, self.curframe_locals['__return__']
|
|---|
| [2] | 754 | else:
|
|---|
| 755 | print >>self.stdout, '*** Not yet returned!'
|
|---|
| 756 | do_rv = do_retval
|
|---|
| 757 |
|
|---|
| 758 | def _getval(self, arg):
|
|---|
| 759 | try:
|
|---|
| 760 | return eval(arg, self.curframe.f_globals,
|
|---|
| [391] | 761 | self.curframe_locals)
|
|---|
| [2] | 762 | except:
|
|---|
| 763 | t, v = sys.exc_info()[:2]
|
|---|
| 764 | if isinstance(t, str):
|
|---|
| 765 | exc_type_name = t
|
|---|
| 766 | else: exc_type_name = t.__name__
|
|---|
| 767 | print >>self.stdout, '***', exc_type_name + ':', repr(v)
|
|---|
| 768 | raise
|
|---|
| 769 |
|
|---|
| 770 | def do_p(self, arg):
|
|---|
| 771 | try:
|
|---|
| 772 | print >>self.stdout, repr(self._getval(arg))
|
|---|
| 773 | except:
|
|---|
| 774 | pass
|
|---|
| 775 |
|
|---|
| 776 | def do_pp(self, arg):
|
|---|
| 777 | try:
|
|---|
| 778 | pprint.pprint(self._getval(arg), self.stdout)
|
|---|
| 779 | except:
|
|---|
| 780 | pass
|
|---|
| 781 |
|
|---|
| 782 | def do_list(self, arg):
|
|---|
| 783 | self.lastcmd = 'list'
|
|---|
| 784 | last = None
|
|---|
| 785 | if arg:
|
|---|
| 786 | try:
|
|---|
| 787 | x = eval(arg, {}, {})
|
|---|
| 788 | if type(x) == type(()):
|
|---|
| 789 | first, last = x
|
|---|
| 790 | first = int(first)
|
|---|
| 791 | last = int(last)
|
|---|
| 792 | if last < first:
|
|---|
| 793 | # Assume it's a count
|
|---|
| 794 | last = first + last
|
|---|
| 795 | else:
|
|---|
| 796 | first = max(1, int(x) - 5)
|
|---|
| 797 | except:
|
|---|
| 798 | print >>self.stdout, '*** Error in argument:', repr(arg)
|
|---|
| 799 | return
|
|---|
| 800 | elif self.lineno is None:
|
|---|
| 801 | first = max(1, self.curframe.f_lineno - 5)
|
|---|
| 802 | else:
|
|---|
| 803 | first = self.lineno + 1
|
|---|
| 804 | if last is None:
|
|---|
| 805 | last = first + 10
|
|---|
| 806 | filename = self.curframe.f_code.co_filename
|
|---|
| 807 | breaklist = self.get_file_breaks(filename)
|
|---|
| 808 | try:
|
|---|
| 809 | for lineno in range(first, last+1):
|
|---|
| [391] | 810 | line = linecache.getline(filename, lineno,
|
|---|
| 811 | self.curframe.f_globals)
|
|---|
| [2] | 812 | if not line:
|
|---|
| 813 | print >>self.stdout, '[EOF]'
|
|---|
| 814 | break
|
|---|
| 815 | else:
|
|---|
| 816 | s = repr(lineno).rjust(3)
|
|---|
| 817 | if len(s) < 4: s = s + ' '
|
|---|
| 818 | if lineno in breaklist: s = s + 'B'
|
|---|
| 819 | else: s = s + ' '
|
|---|
| 820 | if lineno == self.curframe.f_lineno:
|
|---|
| 821 | s = s + '->'
|
|---|
| 822 | print >>self.stdout, s + '\t' + line,
|
|---|
| 823 | self.lineno = lineno
|
|---|
| 824 | except KeyboardInterrupt:
|
|---|
| 825 | pass
|
|---|
| 826 | do_l = do_list
|
|---|
| 827 |
|
|---|
| 828 | def do_whatis(self, arg):
|
|---|
| 829 | try:
|
|---|
| 830 | value = eval(arg, self.curframe.f_globals,
|
|---|
| [391] | 831 | self.curframe_locals)
|
|---|
| [2] | 832 | except:
|
|---|
| 833 | t, v = sys.exc_info()[:2]
|
|---|
| 834 | if type(t) == type(''):
|
|---|
| 835 | exc_type_name = t
|
|---|
| 836 | else: exc_type_name = t.__name__
|
|---|
| 837 | print >>self.stdout, '***', exc_type_name + ':', repr(v)
|
|---|
| 838 | return
|
|---|
| 839 | code = None
|
|---|
| 840 | # Is it a function?
|
|---|
| 841 | try: code = value.func_code
|
|---|
| 842 | except: pass
|
|---|
| 843 | if code:
|
|---|
| 844 | print >>self.stdout, 'Function', code.co_name
|
|---|
| 845 | return
|
|---|
| 846 | # Is it an instance method?
|
|---|
| 847 | try: code = value.im_func.func_code
|
|---|
| 848 | except: pass
|
|---|
| 849 | if code:
|
|---|
| 850 | print >>self.stdout, 'Method', code.co_name
|
|---|
| 851 | return
|
|---|
| 852 | # None of the above...
|
|---|
| 853 | print >>self.stdout, type(value)
|
|---|
| 854 |
|
|---|
| 855 | def do_alias(self, arg):
|
|---|
| 856 | args = arg.split()
|
|---|
| 857 | if len(args) == 0:
|
|---|
| 858 | keys = self.aliases.keys()
|
|---|
| 859 | keys.sort()
|
|---|
| 860 | for alias in keys:
|
|---|
| 861 | print >>self.stdout, "%s = %s" % (alias, self.aliases[alias])
|
|---|
| 862 | return
|
|---|
| 863 | if args[0] in self.aliases and len(args) == 1:
|
|---|
| 864 | print >>self.stdout, "%s = %s" % (args[0], self.aliases[args[0]])
|
|---|
| 865 | else:
|
|---|
| 866 | self.aliases[args[0]] = ' '.join(args[1:])
|
|---|
| 867 |
|
|---|
| 868 | def do_unalias(self, arg):
|
|---|
| 869 | args = arg.split()
|
|---|
| 870 | if len(args) == 0: return
|
|---|
| 871 | if args[0] in self.aliases:
|
|---|
| 872 | del self.aliases[args[0]]
|
|---|
| 873 |
|
|---|
| 874 | #list of all the commands making the program resume execution.
|
|---|
| 875 | commands_resuming = ['do_continue', 'do_step', 'do_next', 'do_return',
|
|---|
| 876 | 'do_quit', 'do_jump']
|
|---|
| 877 |
|
|---|
| 878 | # Print a traceback starting at the top stack frame.
|
|---|
| 879 | # The most recently entered frame is printed last;
|
|---|
| 880 | # this is different from dbx and gdb, but consistent with
|
|---|
| 881 | # the Python interpreter's stack trace.
|
|---|
| 882 | # It is also consistent with the up/down commands (which are
|
|---|
| 883 | # compatible with dbx and gdb: up moves towards 'main()'
|
|---|
| 884 | # and down moves towards the most recent stack frame).
|
|---|
| 885 |
|
|---|
| 886 | def print_stack_trace(self):
|
|---|
| 887 | try:
|
|---|
| 888 | for frame_lineno in self.stack:
|
|---|
| 889 | self.print_stack_entry(frame_lineno)
|
|---|
| 890 | except KeyboardInterrupt:
|
|---|
| 891 | pass
|
|---|
| 892 |
|
|---|
| 893 | def print_stack_entry(self, frame_lineno, prompt_prefix=line_prefix):
|
|---|
| 894 | frame, lineno = frame_lineno
|
|---|
| 895 | if frame is self.curframe:
|
|---|
| 896 | print >>self.stdout, '>',
|
|---|
| 897 | else:
|
|---|
| 898 | print >>self.stdout, ' ',
|
|---|
| 899 | print >>self.stdout, self.format_stack_entry(frame_lineno,
|
|---|
| 900 | prompt_prefix)
|
|---|
| 901 |
|
|---|
| 902 |
|
|---|
| 903 | # Help methods (derived from pdb.doc)
|
|---|
| 904 |
|
|---|
| 905 | def help_help(self):
|
|---|
| 906 | self.help_h()
|
|---|
| 907 |
|
|---|
| 908 | def help_h(self):
|
|---|
| 909 | print >>self.stdout, """h(elp)
|
|---|
| 910 | Without argument, print the list of available commands.
|
|---|
| 911 | With a command name as argument, print help about that command
|
|---|
| 912 | "help pdb" pipes the full documentation file to the $PAGER
|
|---|
| 913 | "help exec" gives help on the ! command"""
|
|---|
| 914 |
|
|---|
| 915 | def help_where(self):
|
|---|
| 916 | self.help_w()
|
|---|
| 917 |
|
|---|
| 918 | def help_w(self):
|
|---|
| 919 | print >>self.stdout, """w(here)
|
|---|
| 920 | Print a stack trace, with the most recent frame at the bottom.
|
|---|
| 921 | An arrow indicates the "current frame", which determines the
|
|---|
| 922 | context of most commands. 'bt' is an alias for this command."""
|
|---|
| 923 |
|
|---|
| 924 | help_bt = help_w
|
|---|
| 925 |
|
|---|
| 926 | def help_down(self):
|
|---|
| 927 | self.help_d()
|
|---|
| 928 |
|
|---|
| 929 | def help_d(self):
|
|---|
| 930 | print >>self.stdout, """d(own)
|
|---|
| 931 | Move the current frame one level down in the stack trace
|
|---|
| 932 | (to a newer frame)."""
|
|---|
| 933 |
|
|---|
| 934 | def help_up(self):
|
|---|
| 935 | self.help_u()
|
|---|
| 936 |
|
|---|
| 937 | def help_u(self):
|
|---|
| 938 | print >>self.stdout, """u(p)
|
|---|
| 939 | Move the current frame one level up in the stack trace
|
|---|
| 940 | (to an older frame)."""
|
|---|
| 941 |
|
|---|
| 942 | def help_break(self):
|
|---|
| 943 | self.help_b()
|
|---|
| 944 |
|
|---|
| 945 | def help_b(self):
|
|---|
| 946 | print >>self.stdout, """b(reak) ([file:]lineno | function) [, condition]
|
|---|
| 947 | With a line number argument, set a break there in the current
|
|---|
| 948 | file. With a function name, set a break at first executable line
|
|---|
| 949 | of that function. Without argument, list all breaks. If a second
|
|---|
| 950 | argument is present, it is a string specifying an expression
|
|---|
| 951 | which must evaluate to true before the breakpoint is honored.
|
|---|
| 952 |
|
|---|
| 953 | The line number may be prefixed with a filename and a colon,
|
|---|
| 954 | to specify a breakpoint in another file (probably one that
|
|---|
| 955 | hasn't been loaded yet). The file is searched for on sys.path;
|
|---|
| 956 | the .py suffix may be omitted."""
|
|---|
| 957 |
|
|---|
| 958 | def help_clear(self):
|
|---|
| 959 | self.help_cl()
|
|---|
| 960 |
|
|---|
| 961 | def help_cl(self):
|
|---|
| 962 | print >>self.stdout, "cl(ear) filename:lineno"
|
|---|
| 963 | print >>self.stdout, """cl(ear) [bpnumber [bpnumber...]]
|
|---|
| 964 | With a space separated list of breakpoint numbers, clear
|
|---|
| 965 | those breakpoints. Without argument, clear all breaks (but
|
|---|
| 966 | first ask confirmation). With a filename:lineno argument,
|
|---|
| 967 | clear all breaks at that line in that file.
|
|---|
| 968 |
|
|---|
| 969 | Note that the argument is different from previous versions of
|
|---|
| 970 | the debugger (in python distributions 1.5.1 and before) where
|
|---|
| 971 | a linenumber was used instead of either filename:lineno or
|
|---|
| 972 | breakpoint numbers."""
|
|---|
| 973 |
|
|---|
| 974 | def help_tbreak(self):
|
|---|
| [391] | 975 | print >>self.stdout, """tbreak same arguments as break, but breakpoint
|
|---|
| 976 | is removed when first hit."""
|
|---|
| [2] | 977 |
|
|---|
| 978 | def help_enable(self):
|
|---|
| 979 | print >>self.stdout, """enable bpnumber [bpnumber ...]
|
|---|
| 980 | Enables the breakpoints given as a space separated list of
|
|---|
| 981 | bp numbers."""
|
|---|
| 982 |
|
|---|
| 983 | def help_disable(self):
|
|---|
| 984 | print >>self.stdout, """disable bpnumber [bpnumber ...]
|
|---|
| 985 | Disables the breakpoints given as a space separated list of
|
|---|
| 986 | bp numbers."""
|
|---|
| 987 |
|
|---|
| 988 | def help_ignore(self):
|
|---|
| 989 | print >>self.stdout, """ignore bpnumber count
|
|---|
| 990 | Sets the ignore count for the given breakpoint number. A breakpoint
|
|---|
| 991 | becomes active when the ignore count is zero. When non-zero, the
|
|---|
| 992 | count is decremented each time the breakpoint is reached and the
|
|---|
| 993 | breakpoint is not disabled and any associated condition evaluates
|
|---|
| 994 | to true."""
|
|---|
| 995 |
|
|---|
| 996 | def help_condition(self):
|
|---|
| 997 | print >>self.stdout, """condition bpnumber str_condition
|
|---|
| 998 | str_condition is a string specifying an expression which
|
|---|
| 999 | must evaluate to true before the breakpoint is honored.
|
|---|
| 1000 | If str_condition is absent, any existing condition is removed;
|
|---|
| 1001 | i.e., the breakpoint is made unconditional."""
|
|---|
| 1002 |
|
|---|
| 1003 | def help_step(self):
|
|---|
| 1004 | self.help_s()
|
|---|
| 1005 |
|
|---|
| 1006 | def help_s(self):
|
|---|
| 1007 | print >>self.stdout, """s(tep)
|
|---|
| 1008 | Execute the current line, stop at the first possible occasion
|
|---|
| 1009 | (either in a function that is called or in the current function)."""
|
|---|
| 1010 |
|
|---|
| 1011 | def help_until(self):
|
|---|
| 1012 | self.help_unt()
|
|---|
| 1013 |
|
|---|
| 1014 | def help_unt(self):
|
|---|
| 1015 | print """unt(il)
|
|---|
| 1016 | Continue execution until the line with a number greater than the current
|
|---|
| 1017 | one is reached or until the current frame returns"""
|
|---|
| 1018 |
|
|---|
| 1019 | def help_next(self):
|
|---|
| 1020 | self.help_n()
|
|---|
| 1021 |
|
|---|
| 1022 | def help_n(self):
|
|---|
| 1023 | print >>self.stdout, """n(ext)
|
|---|
| 1024 | Continue execution until the next line in the current function
|
|---|
| 1025 | is reached or it returns."""
|
|---|
| 1026 |
|
|---|
| 1027 | def help_return(self):
|
|---|
| 1028 | self.help_r()
|
|---|
| 1029 |
|
|---|
| 1030 | def help_r(self):
|
|---|
| 1031 | print >>self.stdout, """r(eturn)
|
|---|
| 1032 | Continue execution until the current function returns."""
|
|---|
| 1033 |
|
|---|
| 1034 | def help_continue(self):
|
|---|
| 1035 | self.help_c()
|
|---|
| 1036 |
|
|---|
| 1037 | def help_cont(self):
|
|---|
| 1038 | self.help_c()
|
|---|
| 1039 |
|
|---|
| 1040 | def help_c(self):
|
|---|
| 1041 | print >>self.stdout, """c(ont(inue))
|
|---|
| 1042 | Continue execution, only stop when a breakpoint is encountered."""
|
|---|
| 1043 |
|
|---|
| 1044 | def help_jump(self):
|
|---|
| 1045 | self.help_j()
|
|---|
| 1046 |
|
|---|
| 1047 | def help_j(self):
|
|---|
| 1048 | print >>self.stdout, """j(ump) lineno
|
|---|
| 1049 | Set the next line that will be executed."""
|
|---|
| 1050 |
|
|---|
| 1051 | def help_debug(self):
|
|---|
| 1052 | print >>self.stdout, """debug code
|
|---|
| 1053 | Enter a recursive debugger that steps through the code argument
|
|---|
| 1054 | (which is an arbitrary expression or statement to be executed
|
|---|
| 1055 | in the current environment)."""
|
|---|
| 1056 |
|
|---|
| 1057 | def help_list(self):
|
|---|
| 1058 | self.help_l()
|
|---|
| 1059 |
|
|---|
| 1060 | def help_l(self):
|
|---|
| 1061 | print >>self.stdout, """l(ist) [first [,last]]
|
|---|
| 1062 | List source code for the current file.
|
|---|
| 1063 | Without arguments, list 11 lines around the current line
|
|---|
| 1064 | or continue the previous listing.
|
|---|
| 1065 | With one argument, list 11 lines starting at that line.
|
|---|
| 1066 | With two arguments, list the given range;
|
|---|
| 1067 | if the second argument is less than the first, it is a count."""
|
|---|
| 1068 |
|
|---|
| 1069 | def help_args(self):
|
|---|
| 1070 | self.help_a()
|
|---|
| 1071 |
|
|---|
| 1072 | def help_a(self):
|
|---|
| 1073 | print >>self.stdout, """a(rgs)
|
|---|
| 1074 | Print the arguments of the current function."""
|
|---|
| 1075 |
|
|---|
| 1076 | def help_p(self):
|
|---|
| 1077 | print >>self.stdout, """p expression
|
|---|
| 1078 | Print the value of the expression."""
|
|---|
| 1079 |
|
|---|
| 1080 | def help_pp(self):
|
|---|
| 1081 | print >>self.stdout, """pp expression
|
|---|
| 1082 | Pretty-print the value of the expression."""
|
|---|
| 1083 |
|
|---|
| 1084 | def help_exec(self):
|
|---|
| 1085 | print >>self.stdout, """(!) statement
|
|---|
| 1086 | Execute the (one-line) statement in the context of
|
|---|
| 1087 | the current stack frame.
|
|---|
| 1088 | The exclamation point can be omitted unless the first word
|
|---|
| 1089 | of the statement resembles a debugger command.
|
|---|
| 1090 | To assign to a global variable you must always prefix the
|
|---|
| 1091 | command with a 'global' command, e.g.:
|
|---|
| 1092 | (Pdb) global list_options; list_options = ['-l']
|
|---|
| 1093 | (Pdb)"""
|
|---|
| 1094 |
|
|---|
| 1095 | def help_run(self):
|
|---|
| 1096 | print """run [args...]
|
|---|
| 1097 | Restart the debugged python program. If a string is supplied, it is
|
|---|
| [391] | 1098 | split with "shlex" and the result is used as the new sys.argv.
|
|---|
| [2] | 1099 | History, breakpoints, actions and debugger options are preserved.
|
|---|
| 1100 | "restart" is an alias for "run"."""
|
|---|
| 1101 |
|
|---|
| 1102 | help_restart = help_run
|
|---|
| 1103 |
|
|---|
| 1104 | def help_quit(self):
|
|---|
| 1105 | self.help_q()
|
|---|
| 1106 |
|
|---|
| 1107 | def help_q(self):
|
|---|
| 1108 | print >>self.stdout, """q(uit) or exit - Quit from the debugger.
|
|---|
| 1109 | The program being executed is aborted."""
|
|---|
| 1110 |
|
|---|
| 1111 | help_exit = help_q
|
|---|
| 1112 |
|
|---|
| 1113 | def help_whatis(self):
|
|---|
| 1114 | print >>self.stdout, """whatis arg
|
|---|
| 1115 | Prints the type of the argument."""
|
|---|
| 1116 |
|
|---|
| 1117 | def help_EOF(self):
|
|---|
| 1118 | print >>self.stdout, """EOF
|
|---|
| 1119 | Handles the receipt of EOF as a command."""
|
|---|
| 1120 |
|
|---|
| 1121 | def help_alias(self):
|
|---|
| [391] | 1122 | print >>self.stdout, """alias [name [command [parameter parameter ...]]]
|
|---|
| [2] | 1123 | Creates an alias called 'name' the executes 'command'. The command
|
|---|
| 1124 | must *not* be enclosed in quotes. Replaceable parameters are
|
|---|
| 1125 | indicated by %1, %2, and so on, while %* is replaced by all the
|
|---|
| 1126 | parameters. If no command is given, the current alias for name
|
|---|
| 1127 | is shown. If no name is given, all aliases are listed.
|
|---|
| 1128 |
|
|---|
| 1129 | Aliases may be nested and can contain anything that can be
|
|---|
| 1130 | legally typed at the pdb prompt. Note! You *can* override
|
|---|
| 1131 | internal pdb commands with aliases! Those internal commands
|
|---|
| 1132 | are then hidden until the alias is removed. Aliasing is recursively
|
|---|
| 1133 | applied to the first word of the command line; all other words
|
|---|
| 1134 | in the line are left alone.
|
|---|
| 1135 |
|
|---|
| 1136 | Some useful aliases (especially when placed in the .pdbrc file) are:
|
|---|
| 1137 |
|
|---|
| 1138 | #Print instance variables (usage "pi classInst")
|
|---|
| 1139 | alias pi for k in %1.__dict__.keys(): print "%1.",k,"=",%1.__dict__[k]
|
|---|
| 1140 |
|
|---|
| 1141 | #Print instance variables in self
|
|---|
| 1142 | alias ps pi self
|
|---|
| 1143 | """
|
|---|
| 1144 |
|
|---|
| 1145 | def help_unalias(self):
|
|---|
| 1146 | print >>self.stdout, """unalias name
|
|---|
| 1147 | Deletes the specified alias."""
|
|---|
| 1148 |
|
|---|
| 1149 | def help_commands(self):
|
|---|
| 1150 | print >>self.stdout, """commands [bpnumber]
|
|---|
| 1151 | (com) ...
|
|---|
| 1152 | (com) end
|
|---|
| 1153 | (Pdb)
|
|---|
| 1154 |
|
|---|
| 1155 | Specify a list of commands for breakpoint number bpnumber. The
|
|---|
| 1156 | commands themselves appear on the following lines. Type a line
|
|---|
| 1157 | containing just 'end' to terminate the commands.
|
|---|
| 1158 |
|
|---|
| 1159 | To remove all commands from a breakpoint, type commands and
|
|---|
| 1160 | follow it immediately with end; that is, give no commands.
|
|---|
| 1161 |
|
|---|
| 1162 | With no bpnumber argument, commands refers to the last
|
|---|
| 1163 | breakpoint set.
|
|---|
| 1164 |
|
|---|
| 1165 | You can use breakpoint commands to start your program up again.
|
|---|
| 1166 | Simply use the continue command, or step, or any other
|
|---|
| 1167 | command that resumes execution.
|
|---|
| 1168 |
|
|---|
| 1169 | Specifying any command resuming execution (currently continue,
|
|---|
| 1170 | step, next, return, jump, quit and their abbreviations) terminates
|
|---|
| 1171 | the command list (as if that command was immediately followed by end).
|
|---|
| 1172 | This is because any time you resume execution
|
|---|
| 1173 | (even with a simple next or step), you may encounter
|
|---|
| 1174 | another breakpoint--which could have its own command list, leading to
|
|---|
| 1175 | ambiguities about which list to execute.
|
|---|
| 1176 |
|
|---|
| 1177 | If you use the 'silent' command in the command list, the
|
|---|
| 1178 | usual message about stopping at a breakpoint is not printed. This may
|
|---|
| 1179 | be desirable for breakpoints that are to print a specific message and
|
|---|
| 1180 | then continue. If none of the other commands print anything, you
|
|---|
| 1181 | see no sign that the breakpoint was reached.
|
|---|
| 1182 | """
|
|---|
| 1183 |
|
|---|
| 1184 | def help_pdb(self):
|
|---|
| 1185 | help()
|
|---|
| 1186 |
|
|---|
| 1187 | def lookupmodule(self, filename):
|
|---|
| 1188 | """Helper function for break/clear parsing -- may be overridden.
|
|---|
| 1189 |
|
|---|
| 1190 | lookupmodule() translates (possibly incomplete) file or module name
|
|---|
| 1191 | into an absolute file name.
|
|---|
| 1192 | """
|
|---|
| 1193 | if os.path.isabs(filename) and os.path.exists(filename):
|
|---|
| 1194 | return filename
|
|---|
| 1195 | f = os.path.join(sys.path[0], filename)
|
|---|
| 1196 | if os.path.exists(f) and self.canonic(f) == self.mainpyfile:
|
|---|
| 1197 | return f
|
|---|
| 1198 | root, ext = os.path.splitext(filename)
|
|---|
| 1199 | if ext == '':
|
|---|
| 1200 | filename = filename + '.py'
|
|---|
| 1201 | if os.path.isabs(filename):
|
|---|
| 1202 | return filename
|
|---|
| 1203 | for dirname in sys.path:
|
|---|
| 1204 | while os.path.islink(dirname):
|
|---|
| 1205 | dirname = os.readlink(dirname)
|
|---|
| 1206 | fullname = os.path.join(dirname, filename)
|
|---|
| 1207 | if os.path.exists(fullname):
|
|---|
| 1208 | return fullname
|
|---|
| 1209 | return None
|
|---|
| 1210 |
|
|---|
| 1211 | def _runscript(self, filename):
|
|---|
| 1212 | # The script has to run in __main__ namespace (or imports from
|
|---|
| 1213 | # __main__ will break).
|
|---|
| 1214 | #
|
|---|
| 1215 | # So we clear up the __main__ and set several special variables
|
|---|
| 1216 | # (this gets rid of pdb's globals and cleans old variables on restarts).
|
|---|
| 1217 | import __main__
|
|---|
| 1218 | __main__.__dict__.clear()
|
|---|
| 1219 | __main__.__dict__.update({"__name__" : "__main__",
|
|---|
| 1220 | "__file__" : filename,
|
|---|
| 1221 | "__builtins__": __builtins__,
|
|---|
| 1222 | })
|
|---|
| 1223 |
|
|---|
| 1224 | # When bdb sets tracing, a number of call and line events happens
|
|---|
| 1225 | # BEFORE debugger even reaches user's code (and the exact sequence of
|
|---|
| 1226 | # events depends on python version). So we take special measures to
|
|---|
| 1227 | # avoid stopping before we reach the main script (see user_line and
|
|---|
| 1228 | # user_call for details).
|
|---|
| 1229 | self._wait_for_mainpyfile = 1
|
|---|
| 1230 | self.mainpyfile = self.canonic(filename)
|
|---|
| 1231 | self._user_requested_quit = 0
|
|---|
| [391] | 1232 | statement = 'execfile(%r)' % filename
|
|---|
| [2] | 1233 | self.run(statement)
|
|---|
| 1234 |
|
|---|
| 1235 | # Simplified interface
|
|---|
| 1236 |
|
|---|
| 1237 | def run(statement, globals=None, locals=None):
|
|---|
| 1238 | Pdb().run(statement, globals, locals)
|
|---|
| 1239 |
|
|---|
| 1240 | def runeval(expression, globals=None, locals=None):
|
|---|
| 1241 | return Pdb().runeval(expression, globals, locals)
|
|---|
| 1242 |
|
|---|
| 1243 | def runctx(statement, globals, locals):
|
|---|
| 1244 | # B/W compatibility
|
|---|
| 1245 | run(statement, globals, locals)
|
|---|
| 1246 |
|
|---|
| 1247 | def runcall(*args, **kwds):
|
|---|
| 1248 | return Pdb().runcall(*args, **kwds)
|
|---|
| 1249 |
|
|---|
| 1250 | def set_trace():
|
|---|
| 1251 | Pdb().set_trace(sys._getframe().f_back)
|
|---|
| 1252 |
|
|---|
| 1253 | # Post-Mortem interface
|
|---|
| 1254 |
|
|---|
| 1255 | def post_mortem(t=None):
|
|---|
| 1256 | # handling the default
|
|---|
| 1257 | if t is None:
|
|---|
| 1258 | # sys.exc_info() returns (type, value, traceback) if an exception is
|
|---|
| 1259 | # being handled, otherwise it returns None
|
|---|
| 1260 | t = sys.exc_info()[2]
|
|---|
| 1261 | if t is None:
|
|---|
| 1262 | raise ValueError("A valid traceback must be passed if no "
|
|---|
| 1263 | "exception is being handled")
|
|---|
| 1264 |
|
|---|
| 1265 | p = Pdb()
|
|---|
| 1266 | p.reset()
|
|---|
| 1267 | p.interaction(None, t)
|
|---|
| 1268 |
|
|---|
| 1269 | def pm():
|
|---|
| 1270 | post_mortem(sys.last_traceback)
|
|---|
| 1271 |
|
|---|
| 1272 |
|
|---|
| 1273 | # Main program for testing
|
|---|
| 1274 |
|
|---|
| 1275 | TESTCMD = 'import x; x.main()'
|
|---|
| 1276 |
|
|---|
| 1277 | def test():
|
|---|
| 1278 | run(TESTCMD)
|
|---|
| 1279 |
|
|---|
| 1280 | # print help
|
|---|
| 1281 | def help():
|
|---|
| 1282 | for dirname in sys.path:
|
|---|
| 1283 | fullname = os.path.join(dirname, 'pdb.doc')
|
|---|
| 1284 | if os.path.exists(fullname):
|
|---|
| 1285 | sts = os.system('${PAGER-more} '+fullname)
|
|---|
| 1286 | if sts: print '*** Pager exit status:', sts
|
|---|
| 1287 | break
|
|---|
| 1288 | else:
|
|---|
| 1289 | print 'Sorry, can\'t find the help file "pdb.doc"',
|
|---|
| 1290 | print 'along the Python search path'
|
|---|
| 1291 |
|
|---|
| 1292 | def main():
|
|---|
| 1293 | if not sys.argv[1:] or sys.argv[1] in ("--help", "-h"):
|
|---|
| 1294 | print "usage: pdb.py scriptfile [arg] ..."
|
|---|
| 1295 | sys.exit(2)
|
|---|
| 1296 |
|
|---|
| 1297 | mainpyfile = sys.argv[1] # Get script filename
|
|---|
| 1298 | if not os.path.exists(mainpyfile):
|
|---|
| 1299 | print 'Error:', mainpyfile, 'does not exist'
|
|---|
| 1300 | sys.exit(1)
|
|---|
| 1301 |
|
|---|
| 1302 | del sys.argv[0] # Hide "pdb.py" from argument list
|
|---|
| 1303 |
|
|---|
| 1304 | # Replace pdb's dir with script's dir in front of module search path.
|
|---|
| 1305 | sys.path[0] = os.path.dirname(mainpyfile)
|
|---|
| 1306 |
|
|---|
| 1307 | # Note on saving/restoring sys.argv: it's a good idea when sys.argv was
|
|---|
| 1308 | # modified by the script being debugged. It's a bad idea when it was
|
|---|
| [391] | 1309 | # changed by the user from the command line. There is a "restart" command
|
|---|
| 1310 | # which allows explicit specification of command line arguments.
|
|---|
| [2] | 1311 | pdb = Pdb()
|
|---|
| [391] | 1312 | while True:
|
|---|
| [2] | 1313 | try:
|
|---|
| 1314 | pdb._runscript(mainpyfile)
|
|---|
| 1315 | if pdb._user_requested_quit:
|
|---|
| 1316 | break
|
|---|
| 1317 | print "The program finished and will be restarted"
|
|---|
| 1318 | except Restart:
|
|---|
| 1319 | print "Restarting", mainpyfile, "with arguments:"
|
|---|
| 1320 | print "\t" + " ".join(sys.argv[1:])
|
|---|
| 1321 | except SystemExit:
|
|---|
| 1322 | # In most cases SystemExit does not warrant a post-mortem session.
|
|---|
| 1323 | print "The program exited via sys.exit(). Exit status: ",
|
|---|
| 1324 | print sys.exc_info()[1]
|
|---|
| 1325 | except:
|
|---|
| 1326 | traceback.print_exc()
|
|---|
| 1327 | print "Uncaught exception. Entering post mortem debugging"
|
|---|
| 1328 | print "Running 'cont' or 'step' will restart the program"
|
|---|
| 1329 | t = sys.exc_info()[2]
|
|---|
| 1330 | pdb.interaction(None, t)
|
|---|
| [391] | 1331 | print "Post mortem debugger finished. The " + mainpyfile + \
|
|---|
| 1332 | " will be restarted"
|
|---|
| [2] | 1333 |
|
|---|
| 1334 |
|
|---|
| 1335 | # When invoked as main program, invoke the debugger on a script
|
|---|
| 1336 | if __name__ == '__main__':
|
|---|
| 1337 | import pdb
|
|---|
| 1338 | pdb.main()
|
|---|
