1#! /usr/bin/env python3 2 3""" 4The Python Debugger Pdb 5======================= 6 7To use the debugger in its simplest form: 8 9 >>> import pdb 10 >>> pdb.run('<a statement>') 11 12The debugger's prompt is '(Pdb) '. This will stop in the first 13function call in <a statement>. 14 15Alternatively, if a statement terminated with an unhandled exception, 16you can use pdb's post-mortem facility to inspect the contents of the 17traceback: 18 19 >>> <a statement> 20 <exception traceback> 21 >>> import pdb 22 >>> pdb.pm() 23 24The commands recognized by the debugger are listed in the next 25section. Most can be abbreviated as indicated; e.g., h(elp) means 26that 'help' can be typed as 'h' or 'help' (but not as 'he' or 'hel', 27nor as 'H' or 'Help' or 'HELP'). Optional arguments are enclosed in 28square brackets. Alternatives in the command syntax are separated 29by a vertical bar (|). 30 31A blank line repeats the previous command literally, except for 32'list', where it lists the next 11 lines. 33 34Commands that the debugger doesn't recognize are assumed to be Python 35statements and are executed in the context of the program being 36debugged. Python statements can also be prefixed with an exclamation 37point ('!'). This is a powerful way to inspect the program being 38debugged; it is even possible to change variables or call functions. 39When an exception occurs in such a statement, the exception name is 40printed but the debugger's state is not changed. 41 42The debugger supports aliases, which can save typing. And aliases can 43have parameters (see the alias help entry) which allows one a certain 44level of adaptability to the context under examination. 45 46Multiple commands may be entered on a single line, separated by the 47pair ';;'. No intelligence is applied to separating the commands; the 48input is split at the first ';;', even if it is in the middle of a 49quoted string. 50 51If a file ".pdbrc" exists in your home directory or in the current 52directory, it is read in and executed as if it had been typed at the 53debugger prompt. This is particularly useful for aliases. If both 54files exist, the one in the home directory is read first and aliases 55defined there can be overridden by the local file. This behavior can be 56disabled by passing the "readrc=False" argument to the Pdb constructor. 57 58Aside from aliases, the debugger is not directly programmable; but it 59is implemented as a class from which you can derive your own debugger 60class, which you can make as fancy as you like. 61 62 63Debugger commands 64================= 65 66""" 67# NOTE: the actual command documentation is collected from docstrings of the 68# commands and is appended to __doc__ after the class has been defined. 69 70import os 71import io 72import re 73import sys 74import cmd 75import bdb 76import dis 77import code 78import glob 79import pprint 80import signal 81import inspect 82import tokenize 83import traceback 84import linecache 85 86 87class Restart(Exception): 88 """Causes a debugger to be restarted for the debugged python program.""" 89 pass 90 91__all__ = ["run", "pm", "Pdb", "runeval", "runctx", "runcall", "set_trace", 92 "post_mortem", "help"] 93 94def find_function(funcname, filename): 95 cre = re.compile(r'def\s+%s\s*[(]' % re.escape(funcname)) 96 try: 97 fp = tokenize.open(filename) 98 except OSError: 99 return None 100 # consumer of this info expects the first line to be 1 101 with fp: 102 for lineno, line in enumerate(fp, start=1): 103 if cre.match(line): 104 return funcname, filename, lineno 105 return None 106 107def getsourcelines(obj): 108 lines, lineno = inspect.findsource(obj) 109 if inspect.isframe(obj) and obj.f_globals is obj.f_locals: 110 # must be a module frame: do not try to cut a block out of it 111 return lines, 1 112 elif inspect.ismodule(obj): 113 return lines, 1 114 return inspect.getblock(lines[lineno:]), lineno+1 115 116def lasti2lineno(code, lasti): 117 linestarts = list(dis.findlinestarts(code)) 118 linestarts.reverse() 119 for i, lineno in linestarts: 120 if lasti >= i: 121 return lineno 122 return 0 123 124 125class _rstr(str): 126 """String that doesn't quote its repr.""" 127 def __repr__(self): 128 return self 129 130 131# Interaction prompt line will separate file and call info from code 132# text using value of line_prefix string. A newline and arrow may 133# be to your liking. You can set it once pdb is imported using the 134# command "pdb.line_prefix = '\n% '". 135# line_prefix = ': ' # Use this to get the old situation back 136line_prefix = '\n-> ' # Probably a better default 137 138class Pdb(bdb.Bdb, cmd.Cmd): 139 140 _previous_sigint_handler = None 141 142 def __init__(self, completekey='tab', stdin=None, stdout=None, skip=None, 143 nosigint=False, readrc=True): 144 bdb.Bdb.__init__(self, skip=skip) 145 cmd.Cmd.__init__(self, completekey, stdin, stdout) 146 sys.audit("pdb.Pdb") 147 if stdout: 148 self.use_rawinput = 0 149 self.prompt = '(Pdb) ' 150 self.aliases = {} 151 self.displaying = {} 152 self.mainpyfile = '' 153 self._wait_for_mainpyfile = False 154 self.tb_lineno = {} 155 # Try to load readline if it exists 156 try: 157 import readline 158 # remove some common file name delimiters 159 readline.set_completer_delims(' \t\n`@#$%^&*()=+[{]}\\|;:\'",<>?') 160 except ImportError: 161 pass 162 self.allow_kbdint = False 163 self.nosigint = nosigint 164 165 # Read ~/.pdbrc and ./.pdbrc 166 self.rcLines = [] 167 if readrc: 168 try: 169 with open(os.path.expanduser('~/.pdbrc')) as rcFile: 170 self.rcLines.extend(rcFile) 171 except OSError: 172 pass 173 try: 174 with open(".pdbrc") as rcFile: 175 self.rcLines.extend(rcFile) 176 except OSError: 177 pass 178 179 self.commands = {} # associates a command list to breakpoint numbers 180 self.commands_doprompt = {} # for each bp num, tells if the prompt 181 # must be disp. after execing the cmd list 182 self.commands_silent = {} # for each bp num, tells if the stack trace 183 # must be disp. after execing the cmd list 184 self.commands_defining = False # True while in the process of defining 185 # a command list 186 self.commands_bnum = None # The breakpoint number for which we are 187 # defining a list 188 189 def sigint_handler(self, signum, frame): 190 if self.allow_kbdint: 191 raise KeyboardInterrupt 192 self.message("\nProgram interrupted. (Use 'cont' to resume).") 193 self.set_step() 194 self.set_trace(frame) 195 196 def reset(self): 197 bdb.Bdb.reset(self) 198 self.forget() 199 200 def forget(self): 201 self.lineno = None 202 self.stack = [] 203 self.curindex = 0 204 self.curframe = None 205 self.tb_lineno.clear() 206 207 def setup(self, f, tb): 208 self.forget() 209 self.stack, self.curindex = self.get_stack(f, tb) 210 while tb: 211 # when setting up post-mortem debugging with a traceback, save all 212 # the original line numbers to be displayed along the current line 213 # numbers (which can be different, e.g. due to finally clauses) 214 lineno = lasti2lineno(tb.tb_frame.f_code, tb.tb_lasti) 215 self.tb_lineno[tb.tb_frame] = lineno 216 tb = tb.tb_next 217 self.curframe = self.stack[self.curindex][0] 218 # The f_locals dictionary is updated from the actual frame 219 # locals whenever the .f_locals accessor is called, so we 220 # cache it here to ensure that modifications are not overwritten. 221 self.curframe_locals = self.curframe.f_locals 222 return self.execRcLines() 223 224 # Can be executed earlier than 'setup' if desired 225 def execRcLines(self): 226 if not self.rcLines: 227 return 228 # local copy because of recursion 229 rcLines = self.rcLines 230 rcLines.reverse() 231 # execute every line only once 232 self.rcLines = [] 233 while rcLines: 234 line = rcLines.pop().strip() 235 if line and line[0] != '#': 236 if self.onecmd(line): 237 # if onecmd returns True, the command wants to exit 238 # from the interaction, save leftover rc lines 239 # to execute before next interaction 240 self.rcLines += reversed(rcLines) 241 return True 242 243 # Override Bdb methods 244 245 def user_call(self, frame, argument_list): 246 """This method is called when there is the remote possibility 247 that we ever need to stop in this function.""" 248 if self._wait_for_mainpyfile: 249 return 250 if self.stop_here(frame): 251 self.message('--Call--') 252 self.interaction(frame, None) 253 254 def user_line(self, frame): 255 """This function is called when we stop or break at this line.""" 256 if self._wait_for_mainpyfile: 257 if (self.mainpyfile != self.canonic(frame.f_code.co_filename) 258 or frame.f_lineno <= 0): 259 return 260 self._wait_for_mainpyfile = False 261 if self.bp_commands(frame): 262 self.interaction(frame, None) 263 264 def bp_commands(self, frame): 265 """Call every command that was set for the current active breakpoint 266 (if there is one). 267 268 Returns True if the normal interaction function must be called, 269 False otherwise.""" 270 # self.currentbp is set in bdb in Bdb.break_here if a breakpoint was hit 271 if getattr(self, "currentbp", False) and \ 272 self.currentbp in self.commands: 273 currentbp = self.currentbp 274 self.currentbp = 0 275 lastcmd_back = self.lastcmd 276 self.setup(frame, None) 277 for line in self.commands[currentbp]: 278 self.onecmd(line) 279 self.lastcmd = lastcmd_back 280 if not self.commands_silent[currentbp]: 281 self.print_stack_entry(self.stack[self.curindex]) 282 if self.commands_doprompt[currentbp]: 283 self._cmdloop() 284 self.forget() 285 return 286 return 1 287 288 def user_return(self, frame, return_value): 289 """This function is called when a return trap is set here.""" 290 if self._wait_for_mainpyfile: 291 return 292 frame.f_locals['__return__'] = return_value 293 self.message('--Return--') 294 self.interaction(frame, None) 295 296 def user_exception(self, frame, exc_info): 297 """This function is called if an exception occurs, 298 but only if we are to stop at or just below this level.""" 299 if self._wait_for_mainpyfile: 300 return 301 exc_type, exc_value, exc_traceback = exc_info 302 frame.f_locals['__exception__'] = exc_type, exc_value 303 304 # An 'Internal StopIteration' exception is an exception debug event 305 # issued by the interpreter when handling a subgenerator run with 306 # 'yield from' or a generator controlled by a for loop. No exception has 307 # actually occurred in this case. The debugger uses this debug event to 308 # stop when the debuggee is returning from such generators. 309 prefix = 'Internal ' if (not exc_traceback 310 and exc_type is StopIteration) else '' 311 self.message('%s%s' % (prefix, 312 traceback.format_exception_only(exc_type, exc_value)[-1].strip())) 313 self.interaction(frame, exc_traceback) 314 315 # General interaction function 316 def _cmdloop(self): 317 while True: 318 try: 319 # keyboard interrupts allow for an easy way to cancel 320 # the current command, so allow them during interactive input 321 self.allow_kbdint = True 322 self.cmdloop() 323 self.allow_kbdint = False 324 break 325 except KeyboardInterrupt: 326 self.message('--KeyboardInterrupt--') 327 328 # Called before loop, handles display expressions 329 def preloop(self): 330 displaying = self.displaying.get(self.curframe) 331 if displaying: 332 for expr, oldvalue in displaying.items(): 333 newvalue = self._getval_except(expr) 334 # check for identity first; this prevents custom __eq__ to 335 # be called at every loop, and also prevents instances whose 336 # fields are changed to be displayed 337 if newvalue is not oldvalue and newvalue != oldvalue: 338 displaying[expr] = newvalue 339 self.message('display %s: %r [old: %r]' % 340 (expr, newvalue, oldvalue)) 341 342 def interaction(self, frame, traceback): 343 # Restore the previous signal handler at the Pdb prompt. 344 if Pdb._previous_sigint_handler: 345 try: 346 signal.signal(signal.SIGINT, Pdb._previous_sigint_handler) 347 except ValueError: # ValueError: signal only works in main thread 348 pass 349 else: 350 Pdb._previous_sigint_handler = None 351 if self.setup(frame, traceback): 352 # no interaction desired at this time (happens if .pdbrc contains 353 # a command like "continue") 354 self.forget() 355 return 356 self.print_stack_entry(self.stack[self.curindex]) 357 self._cmdloop() 358 self.forget() 359 360 def displayhook(self, obj): 361 """Custom displayhook for the exec in default(), which prevents 362 assignment of the _ variable in the builtins. 363 """ 364 # reproduce the behavior of the standard displayhook, not printing None 365 if obj is not None: 366 self.message(repr(obj)) 367 368 def default(self, line): 369 if line[:1] == '!': line = line[1:] 370 locals = self.curframe_locals 371 globals = self.curframe.f_globals 372 try: 373 code = compile(line + '\n', '<stdin>', 'single') 374 save_stdout = sys.stdout 375 save_stdin = sys.stdin 376 save_displayhook = sys.displayhook 377 try: 378 sys.stdin = self.stdin 379 sys.stdout = self.stdout 380 sys.displayhook = self.displayhook 381 exec(code, globals, locals) 382 finally: 383 sys.stdout = save_stdout 384 sys.stdin = save_stdin 385 sys.displayhook = save_displayhook 386 except: 387 exc_info = sys.exc_info()[:2] 388 self.error(traceback.format_exception_only(*exc_info)[-1].strip()) 389 390 def precmd(self, line): 391 """Handle alias expansion and ';;' separator.""" 392 if not line.strip(): 393 return line 394 args = line.split() 395 while args[0] in self.aliases: 396 line = self.aliases[args[0]] 397 ii = 1 398 for tmpArg in args[1:]: 399 line = line.replace("%" + str(ii), 400 tmpArg) 401 ii += 1 402 line = line.replace("%*", ' '.join(args[1:])) 403 args = line.split() 404 # split into ';;' separated commands 405 # unless it's an alias command 406 if args[0] != 'alias': 407 marker = line.find(';;') 408 if marker >= 0: 409 # queue up everything after marker 410 next = line[marker+2:].lstrip() 411 self.cmdqueue.append(next) 412 line = line[:marker].rstrip() 413 return line 414 415 def onecmd(self, line): 416 """Interpret the argument as though it had been typed in response 417 to the prompt. 418 419 Checks whether this line is typed at the normal prompt or in 420 a breakpoint command list definition. 421 """ 422 if not self.commands_defining: 423 return cmd.Cmd.onecmd(self, line) 424 else: 425 return self.handle_command_def(line) 426 427 def handle_command_def(self, line): 428 """Handles one command line during command list definition.""" 429 cmd, arg, line = self.parseline(line) 430 if not cmd: 431 return 432 if cmd == 'silent': 433 self.commands_silent[self.commands_bnum] = True 434 return # continue to handle other cmd def in the cmd list 435 elif cmd == 'end': 436 self.cmdqueue = [] 437 return 1 # end of cmd list 438 cmdlist = self.commands[self.commands_bnum] 439 if arg: 440 cmdlist.append(cmd+' '+arg) 441 else: 442 cmdlist.append(cmd) 443 # Determine if we must stop 444 try: 445 func = getattr(self, 'do_' + cmd) 446 except AttributeError: 447 func = self.default 448 # one of the resuming commands 449 if func.__name__ in self.commands_resuming: 450 self.commands_doprompt[self.commands_bnum] = False 451 self.cmdqueue = [] 452 return 1 453 return 454 455 # interface abstraction functions 456 457 def message(self, msg): 458 print(msg, file=self.stdout) 459 460 def error(self, msg): 461 print('***', msg, file=self.stdout) 462 463 # Generic completion functions. Individual complete_foo methods can be 464 # assigned below to one of these functions. 465 466 def _complete_location(self, text, line, begidx, endidx): 467 # Complete a file/module/function location for break/tbreak/clear. 468 if line.strip().endswith((':', ',')): 469 # Here comes a line number or a condition which we can't complete. 470 return [] 471 # First, try to find matching functions (i.e. expressions). 472 try: 473 ret = self._complete_expression(text, line, begidx, endidx) 474 except Exception: 475 ret = [] 476 # Then, try to complete file names as well. 477 globs = glob.glob(glob.escape(text) + '*') 478 for fn in globs: 479 if os.path.isdir(fn): 480 ret.append(fn + '/') 481 elif os.path.isfile(fn) and fn.lower().endswith(('.py', '.pyw')): 482 ret.append(fn + ':') 483 return ret 484 485 def _complete_bpnumber(self, text, line, begidx, endidx): 486 # Complete a breakpoint number. (This would be more helpful if we could 487 # display additional info along with the completions, such as file/line 488 # of the breakpoint.) 489 return [str(i) for i, bp in enumerate(bdb.Breakpoint.bpbynumber) 490 if bp is not None and str(i).startswith(text)] 491 492 def _complete_expression(self, text, line, begidx, endidx): 493 # Complete an arbitrary expression. 494 if not self.curframe: 495 return [] 496 # Collect globals and locals. It is usually not really sensible to also 497 # complete builtins, and they clutter the namespace quite heavily, so we 498 # leave them out. 499 ns = {**self.curframe.f_globals, **self.curframe_locals} 500 if '.' in text: 501 # Walk an attribute chain up to the last part, similar to what 502 # rlcompleter does. This will bail if any of the parts are not 503 # simple attribute access, which is what we want. 504 dotted = text.split('.') 505 try: 506 obj = ns[dotted[0]] 507 for part in dotted[1:-1]: 508 obj = getattr(obj, part) 509 except (KeyError, AttributeError): 510 return [] 511 prefix = '.'.join(dotted[:-1]) + '.' 512 return [prefix + n for n in dir(obj) if n.startswith(dotted[-1])] 513 else: 514 # Complete a simple name. 515 return [n for n in ns.keys() if n.startswith(text)] 516 517 # Command definitions, called by cmdloop() 518 # The argument is the remaining string on the command line 519 # Return true to exit from the command loop 520 521 def do_commands(self, arg): 522 """commands [bpnumber] 523 (com) ... 524 (com) end 525 (Pdb) 526 527 Specify a list of commands for breakpoint number bpnumber. 528 The commands themselves are entered on the following lines. 529 Type a line containing just 'end' to terminate the commands. 530 The commands are executed when the breakpoint is hit. 531 532 To remove all commands from a breakpoint, type commands and 533 follow it immediately with end; that is, give no commands. 534 535 With no bpnumber argument, commands refers to the last 536 breakpoint set. 537 538 You can use breakpoint commands to start your program up 539 again. Simply use the continue command, or step, or any other 540 command that resumes execution. 541 542 Specifying any command resuming execution (currently continue, 543 step, next, return, jump, quit and their abbreviations) 544 terminates the command list (as if that command was 545 immediately followed by end). This is because any time you 546 resume execution (even with a simple next or step), you may 547 encounter another breakpoint -- which could have its own 548 command list, leading to ambiguities about which list to 549 execute. 550 551 If you use the 'silent' command in the command list, the usual 552 message about stopping at a breakpoint is not printed. This 553 may be desirable for breakpoints that are to print a specific 554 message and then continue. If none of the other commands 555 print anything, you will see no sign that the breakpoint was 556 reached. 557 """ 558 if not arg: 559 bnum = len(bdb.Breakpoint.bpbynumber) - 1 560 else: 561 try: 562 bnum = int(arg) 563 except: 564 self.error("Usage: commands [bnum]\n ...\n end") 565 return 566 self.commands_bnum = bnum 567 # Save old definitions for the case of a keyboard interrupt. 568 if bnum in self.commands: 569 old_command_defs = (self.commands[bnum], 570 self.commands_doprompt[bnum], 571 self.commands_silent[bnum]) 572 else: 573 old_command_defs = None 574 self.commands[bnum] = [] 575 self.commands_doprompt[bnum] = True 576 self.commands_silent[bnum] = False 577 578 prompt_back = self.prompt 579 self.prompt = '(com) ' 580 self.commands_defining = True 581 try: 582 self.cmdloop() 583 except KeyboardInterrupt: 584 # Restore old definitions. 585 if old_command_defs: 586 self.commands[bnum] = old_command_defs[0] 587 self.commands_doprompt[bnum] = old_command_defs[1] 588 self.commands_silent[bnum] = old_command_defs[2] 589 else: 590 del self.commands[bnum] 591 del self.commands_doprompt[bnum] 592 del self.commands_silent[bnum] 593 self.error('command definition aborted, old commands restored') 594 finally: 595 self.commands_defining = False 596 self.prompt = prompt_back 597 598 complete_commands = _complete_bpnumber 599 600 def do_break(self, arg, temporary = 0): 601 """b(reak) [ ([filename:]lineno | function) [, condition] ] 602 Without argument, list all breaks. 603 604 With a line number argument, set a break at this line in the 605 current file. With a function name, set a break at the first 606 executable line of that function. If a second argument is 607 present, it is a string specifying an expression which must 608 evaluate to true before the breakpoint is honored. 609 610 The line number may be prefixed with a filename and a colon, 611 to specify a breakpoint in another file (probably one that 612 hasn't been loaded yet). The file is searched for on 613 sys.path; the .py suffix may be omitted. 614 """ 615 if not arg: 616 if self.breaks: # There's at least one 617 self.message("Num Type Disp Enb Where") 618 for bp in bdb.Breakpoint.bpbynumber: 619 if bp: 620 self.message(bp.bpformat()) 621 return 622 # parse arguments; comma has lowest precedence 623 # and cannot occur in filename 624 filename = None 625 lineno = None 626 cond = None 627 comma = arg.find(',') 628 if comma > 0: 629 # parse stuff after comma: "condition" 630 cond = arg[comma+1:].lstrip() 631 arg = arg[:comma].rstrip() 632 # parse stuff before comma: [filename:]lineno | function 633 colon = arg.rfind(':') 634 funcname = None 635 if colon >= 0: 636 filename = arg[:colon].rstrip() 637 f = self.lookupmodule(filename) 638 if not f: 639 self.error('%r not found from sys.path' % filename) 640 return 641 else: 642 filename = f 643 arg = arg[colon+1:].lstrip() 644 try: 645 lineno = int(arg) 646 except ValueError: 647 self.error('Bad lineno: %s' % arg) 648 return 649 else: 650 # no colon; can be lineno or function 651 try: 652 lineno = int(arg) 653 except ValueError: 654 try: 655 func = eval(arg, 656 self.curframe.f_globals, 657 self.curframe_locals) 658 except: 659 func = arg 660 try: 661 if hasattr(func, '__func__'): 662 func = func.__func__ 663 code = func.__code__ 664 #use co_name to identify the bkpt (function names 665 #could be aliased, but co_name is invariant) 666 funcname = code.co_name 667 lineno = code.co_firstlineno 668 filename = code.co_filename 669 except: 670 # last thing to try 671 (ok, filename, ln) = self.lineinfo(arg) 672 if not ok: 673 self.error('The specified object %r is not a function ' 674 'or was not found along sys.path.' % arg) 675 return 676 funcname = ok # ok contains a function name 677 lineno = int(ln) 678 if not filename: 679 filename = self.defaultFile() 680 # Check for reasonable breakpoint 681 line = self.checkline(filename, lineno) 682 if line: 683 # now set the break point 684 err = self.set_break(filename, line, temporary, cond, funcname) 685 if err: 686 self.error(err) 687 else: 688 bp = self.get_breaks(filename, line)[-1] 689 self.message("Breakpoint %d at %s:%d" % 690 (bp.number, bp.file, bp.line)) 691 692 # To be overridden in derived debuggers 693 def defaultFile(self): 694 """Produce a reasonable default.""" 695 filename = self.curframe.f_code.co_filename 696 if filename == '<string>' and self.mainpyfile: 697 filename = self.mainpyfile 698 return filename 699 700 do_b = do_break 701 702 complete_break = _complete_location 703 complete_b = _complete_location 704 705 def do_tbreak(self, arg): 706 """tbreak [ ([filename:]lineno | function) [, condition] ] 707 Same arguments as break, but sets a temporary breakpoint: it 708 is automatically deleted when first hit. 709 """ 710 self.do_break(arg, 1) 711 712 complete_tbreak = _complete_location 713 714 def lineinfo(self, identifier): 715 failed = (None, None, None) 716 # Input is identifier, may be in single quotes 717 idstring = identifier.split("'") 718 if len(idstring) == 1: 719 # not in single quotes 720 id = idstring[0].strip() 721 elif len(idstring) == 3: 722 # quoted 723 id = idstring[1].strip() 724 else: 725 return failed 726 if id == '': return failed 727 parts = id.split('.') 728 # Protection for derived debuggers 729 if parts[0] == 'self': 730 del parts[0] 731 if len(parts) == 0: 732 return failed 733 # Best first guess at file to look at 734 fname = self.defaultFile() 735 if len(parts) == 1: 736 item = parts[0] 737 else: 738 # More than one part. 739 # First is module, second is method/class 740 f = self.lookupmodule(parts[0]) 741 if f: 742 fname = f 743 item = parts[1] 744 answer = find_function(item, fname) 745 return answer or failed 746 747 def checkline(self, filename, lineno): 748 """Check whether specified line seems to be executable. 749 750 Return `lineno` if it is, 0 if not (e.g. a docstring, comment, blank 751 line or EOF). Warning: testing is not comprehensive. 752 """ 753 # this method should be callable before starting debugging, so default 754 # to "no globals" if there is no current frame 755 globs = self.curframe.f_globals if hasattr(self, 'curframe') else None 756 line = linecache.getline(filename, lineno, globs) 757 if not line: 758 self.message('End of file') 759 return 0 760 line = line.strip() 761 # Don't allow setting breakpoint at a blank line 762 if (not line or (line[0] == '#') or 763 (line[:3] == '"""') or line[:3] == "'''"): 764 self.error('Blank or comment') 765 return 0 766 return lineno 767 768 def do_enable(self, arg): 769 """enable bpnumber [bpnumber ...] 770 Enables the breakpoints given as a space separated list of 771 breakpoint numbers. 772 """ 773 args = arg.split() 774 for i in args: 775 try: 776 bp = self.get_bpbynumber(i) 777 except ValueError as err: 778 self.error(err) 779 else: 780 bp.enable() 781 self.message('Enabled %s' % bp) 782 783 complete_enable = _complete_bpnumber 784 785 def do_disable(self, arg): 786 """disable bpnumber [bpnumber ...] 787 Disables the breakpoints given as a space separated list of 788 breakpoint numbers. Disabling a breakpoint means it cannot 789 cause the program to stop execution, but unlike clearing a 790 breakpoint, it remains in the list of breakpoints and can be 791 (re-)enabled. 792 """ 793 args = arg.split() 794 for i in args: 795 try: 796 bp = self.get_bpbynumber(i) 797 except ValueError as err: 798 self.error(err) 799 else: 800 bp.disable() 801 self.message('Disabled %s' % bp) 802 803 complete_disable = _complete_bpnumber 804 805 def do_condition(self, arg): 806 """condition bpnumber [condition] 807 Set a new condition for the breakpoint, an expression which 808 must evaluate to true before the breakpoint is honored. If 809 condition is absent, any existing condition is removed; i.e., 810 the breakpoint is made unconditional. 811 """ 812 args = arg.split(' ', 1) 813 try: 814 cond = args[1] 815 except IndexError: 816 cond = None 817 try: 818 bp = self.get_bpbynumber(args[0].strip()) 819 except IndexError: 820 self.error('Breakpoint number expected') 821 except ValueError as err: 822 self.error(err) 823 else: 824 bp.cond = cond 825 if not cond: 826 self.message('Breakpoint %d is now unconditional.' % bp.number) 827 else: 828 self.message('New condition set for breakpoint %d.' % bp.number) 829 830 complete_condition = _complete_bpnumber 831 832 def do_ignore(self, arg): 833 """ignore bpnumber [count] 834 Set the ignore count for the given breakpoint number. If 835 count is omitted, the ignore count is set to 0. A breakpoint 836 becomes active when the ignore count is zero. When non-zero, 837 the count is decremented each time the breakpoint is reached 838 and the breakpoint is not disabled and any associated 839 condition evaluates to true. 840 """ 841 args = arg.split() 842 try: 843 count = int(args[1].strip()) 844 except: 845 count = 0 846 try: 847 bp = self.get_bpbynumber(args[0].strip()) 848 except IndexError: 849 self.error('Breakpoint number expected') 850 except ValueError as err: 851 self.error(err) 852 else: 853 bp.ignore = count 854 if count > 0: 855 if count > 1: 856 countstr = '%d crossings' % count 857 else: 858 countstr = '1 crossing' 859 self.message('Will ignore next %s of breakpoint %d.' % 860 (countstr, bp.number)) 861 else: 862 self.message('Will stop next time breakpoint %d is reached.' 863 % bp.number) 864 865 complete_ignore = _complete_bpnumber 866 867 def do_clear(self, arg): 868 """cl(ear) filename:lineno\ncl(ear) [bpnumber [bpnumber...]] 869 With a space separated list of breakpoint numbers, clear 870 those breakpoints. Without argument, clear all breaks (but 871 first ask confirmation). With a filename:lineno argument, 872 clear all breaks at that line in that file. 873 """ 874 if not arg: 875 try: 876 reply = input('Clear all breaks? ') 877 except EOFError: 878 reply = 'no' 879 reply = reply.strip().lower() 880 if reply in ('y', 'yes'): 881 bplist = [bp for bp in bdb.Breakpoint.bpbynumber if bp] 882 self.clear_all_breaks() 883 for bp in bplist: 884 self.message('Deleted %s' % bp) 885 return 886 if ':' in arg: 887 # Make sure it works for "clear C:\foo\bar.py:12" 888 i = arg.rfind(':') 889 filename = arg[:i] 890 arg = arg[i+1:] 891 try: 892 lineno = int(arg) 893 except ValueError: 894 err = "Invalid line number (%s)" % arg 895 else: 896 bplist = self.get_breaks(filename, lineno) 897 err = self.clear_break(filename, lineno) 898 if err: 899 self.error(err) 900 else: 901 for bp in bplist: 902 self.message('Deleted %s' % bp) 903 return 904 numberlist = arg.split() 905 for i in numberlist: 906 try: 907 bp = self.get_bpbynumber(i) 908 except ValueError as err: 909 self.error(err) 910 else: 911 self.clear_bpbynumber(i) 912 self.message('Deleted %s' % bp) 913 do_cl = do_clear # 'c' is already an abbreviation for 'continue' 914 915 complete_clear = _complete_location 916 complete_cl = _complete_location 917 918 def do_where(self, arg): 919 """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 self.print_stack_trace() 925 do_w = do_where 926 do_bt = do_where 927 928 def _select_frame(self, number): 929 assert 0 <= number < len(self.stack) 930 self.curindex = number 931 self.curframe = self.stack[self.curindex][0] 932 self.curframe_locals = self.curframe.f_locals 933 self.print_stack_entry(self.stack[self.curindex]) 934 self.lineno = None 935 936 def do_up(self, arg): 937 """u(p) [count] 938 Move the current frame count (default one) levels up in the 939 stack trace (to an older frame). 940 """ 941 if self.curindex == 0: 942 self.error('Oldest frame') 943 return 944 try: 945 count = int(arg or 1) 946 except ValueError: 947 self.error('Invalid frame count (%s)' % arg) 948 return 949 if count < 0: 950 newframe = 0 951 else: 952 newframe = max(0, self.curindex - count) 953 self._select_frame(newframe) 954 do_u = do_up 955 956 def do_down(self, arg): 957 """d(own) [count] 958 Move the current frame count (default one) levels down in the 959 stack trace (to a newer frame). 960 """ 961 if self.curindex + 1 == len(self.stack): 962 self.error('Newest frame') 963 return 964 try: 965 count = int(arg or 1) 966 except ValueError: 967 self.error('Invalid frame count (%s)' % arg) 968 return 969 if count < 0: 970 newframe = len(self.stack) - 1 971 else: 972 newframe = min(len(self.stack) - 1, self.curindex + count) 973 self._select_frame(newframe) 974 do_d = do_down 975 976 def do_until(self, arg): 977 """unt(il) [lineno] 978 Without argument, continue execution until the line with a 979 number greater than the current one is reached. With a line 980 number, continue execution until a line with a number greater 981 or equal to that is reached. In both cases, also stop when 982 the current frame returns. 983 """ 984 if arg: 985 try: 986 lineno = int(arg) 987 except ValueError: 988 self.error('Error in argument: %r' % arg) 989 return 990 if lineno <= self.curframe.f_lineno: 991 self.error('"until" line number is smaller than current ' 992 'line number') 993 return 994 else: 995 lineno = None 996 self.set_until(self.curframe, lineno) 997 return 1 998 do_unt = do_until 999 1000 def do_step(self, arg): 1001 """s(tep) 1002 Execute the current line, stop at the first possible occasion 1003 (either in a function that is called or in the current 1004 function). 1005 """ 1006 self.set_step() 1007 return 1 1008 do_s = do_step 1009 1010 def do_next(self, arg): 1011 """n(ext) 1012 Continue execution until the next line in the current function 1013 is reached or it returns. 1014 """ 1015 self.set_next(self.curframe) 1016 return 1 1017 do_n = do_next 1018 1019 def do_run(self, arg): 1020 """run [args...] 1021 Restart the debugged python program. If a string is supplied 1022 it is split with "shlex", and the result is used as the new 1023 sys.argv. History, breakpoints, actions and debugger options 1024 are preserved. "restart" is an alias for "run". 1025 """ 1026 if arg: 1027 import shlex 1028 argv0 = sys.argv[0:1] 1029 sys.argv = shlex.split(arg) 1030 sys.argv[:0] = argv0 1031 # this is caught in the main debugger loop 1032 raise Restart 1033 1034 do_restart = do_run 1035 1036 def do_return(self, arg): 1037 """r(eturn) 1038 Continue execution until the current function returns. 1039 """ 1040 self.set_return(self.curframe) 1041 return 1 1042 do_r = do_return 1043 1044 def do_continue(self, arg): 1045 """c(ont(inue)) 1046 Continue execution, only stop when a breakpoint is encountered. 1047 """ 1048 if not self.nosigint: 1049 try: 1050 Pdb._previous_sigint_handler = \ 1051 signal.signal(signal.SIGINT, self.sigint_handler) 1052 except ValueError: 1053 # ValueError happens when do_continue() is invoked from 1054 # a non-main thread in which case we just continue without 1055 # SIGINT set. Would printing a message here (once) make 1056 # sense? 1057 pass 1058 self.set_continue() 1059 return 1 1060 do_c = do_cont = do_continue 1061 1062 def do_jump(self, arg): 1063 """j(ump) lineno 1064 Set the next line that will be executed. Only available in 1065 the bottom-most frame. This lets you jump back and execute 1066 code again, or jump forward to skip code that you don't want 1067 to run. 1068 1069 It should be noted that not all jumps are allowed -- for 1070 instance it is not possible to jump into the middle of a 1071 for loop or out of a finally clause. 1072 """ 1073 if self.curindex + 1 != len(self.stack): 1074 self.error('You can only jump within the bottom frame') 1075 return 1076 try: 1077 arg = int(arg) 1078 except ValueError: 1079 self.error("The 'jump' command requires a line number") 1080 else: 1081 try: 1082 # Do the jump, fix up our copy of the stack, and display the 1083 # new position 1084 self.curframe.f_lineno = arg 1085 self.stack[self.curindex] = self.stack[self.curindex][0], arg 1086 self.print_stack_entry(self.stack[self.curindex]) 1087 except ValueError as e: 1088 self.error('Jump failed: %s' % e) 1089 do_j = do_jump 1090 1091 def do_debug(self, arg): 1092 """debug code 1093 Enter a recursive debugger that steps through the code 1094 argument (which is an arbitrary expression or statement to be 1095 executed in the current environment). 1096 """ 1097 sys.settrace(None) 1098 globals = self.curframe.f_globals 1099 locals = self.curframe_locals 1100 p = Pdb(self.completekey, self.stdin, self.stdout) 1101 p.prompt = "(%s) " % self.prompt.strip() 1102 self.message("ENTERING RECURSIVE DEBUGGER") 1103 try: 1104 sys.call_tracing(p.run, (arg, globals, locals)) 1105 except Exception: 1106 exc_info = sys.exc_info()[:2] 1107 self.error(traceback.format_exception_only(*exc_info)[-1].strip()) 1108 self.message("LEAVING RECURSIVE DEBUGGER") 1109 sys.settrace(self.trace_dispatch) 1110 self.lastcmd = p.lastcmd 1111 1112 complete_debug = _complete_expression 1113 1114 def do_quit(self, arg): 1115 """q(uit)\nexit 1116 Quit from the debugger. The program being executed is aborted. 1117 """ 1118 self._user_requested_quit = True 1119 self.set_quit() 1120 return 1 1121 1122 do_q = do_quit 1123 do_exit = do_quit 1124 1125 def do_EOF(self, arg): 1126 """EOF 1127 Handles the receipt of EOF as a command. 1128 """ 1129 self.message('') 1130 self._user_requested_quit = True 1131 self.set_quit() 1132 return 1 1133 1134 def do_args(self, arg): 1135 """a(rgs) 1136 Print the argument list of the current function. 1137 """ 1138 co = self.curframe.f_code 1139 dict = self.curframe_locals 1140 n = co.co_argcount + co.co_kwonlyargcount 1141 if co.co_flags & inspect.CO_VARARGS: n = n+1 1142 if co.co_flags & inspect.CO_VARKEYWORDS: n = n+1 1143 for i in range(n): 1144 name = co.co_varnames[i] 1145 if name in dict: 1146 self.message('%s = %r' % (name, dict[name])) 1147 else: 1148 self.message('%s = *** undefined ***' % (name,)) 1149 do_a = do_args 1150 1151 def do_retval(self, arg): 1152 """retval 1153 Print the return value for the last return of a function. 1154 """ 1155 if '__return__' in self.curframe_locals: 1156 self.message(repr(self.curframe_locals['__return__'])) 1157 else: 1158 self.error('Not yet returned!') 1159 do_rv = do_retval 1160 1161 def _getval(self, arg): 1162 try: 1163 return eval(arg, self.curframe.f_globals, self.curframe_locals) 1164 except: 1165 exc_info = sys.exc_info()[:2] 1166 self.error(traceback.format_exception_only(*exc_info)[-1].strip()) 1167 raise 1168 1169 def _getval_except(self, arg, frame=None): 1170 try: 1171 if frame is None: 1172 return eval(arg, self.curframe.f_globals, self.curframe_locals) 1173 else: 1174 return eval(arg, frame.f_globals, frame.f_locals) 1175 except: 1176 exc_info = sys.exc_info()[:2] 1177 err = traceback.format_exception_only(*exc_info)[-1].strip() 1178 return _rstr('** raised %s **' % err) 1179 1180 def do_p(self, arg): 1181 """p expression 1182 Print the value of the expression. 1183 """ 1184 try: 1185 self.message(repr(self._getval(arg))) 1186 except: 1187 pass 1188 1189 def do_pp(self, arg): 1190 """pp expression 1191 Pretty-print the value of the expression. 1192 """ 1193 try: 1194 self.message(pprint.pformat(self._getval(arg))) 1195 except: 1196 pass 1197 1198 complete_print = _complete_expression 1199 complete_p = _complete_expression 1200 complete_pp = _complete_expression 1201 1202 def do_list(self, arg): 1203 """l(ist) [first [,last] | .] 1204 1205 List source code for the current file. Without arguments, 1206 list 11 lines around the current line or continue the previous 1207 listing. With . as argument, list 11 lines around the current 1208 line. With one argument, list 11 lines starting at that line. 1209 With two arguments, list the given range; if the second 1210 argument is less than the first, it is a count. 1211 1212 The current line in the current frame is indicated by "->". 1213 If an exception is being debugged, the line where the 1214 exception was originally raised or propagated is indicated by 1215 ">>", if it differs from the current line. 1216 """ 1217 self.lastcmd = 'list' 1218 last = None 1219 if arg and arg != '.': 1220 try: 1221 if ',' in arg: 1222 first, last = arg.split(',') 1223 first = int(first.strip()) 1224 last = int(last.strip()) 1225 if last < first: 1226 # assume it's a count 1227 last = first + last 1228 else: 1229 first = int(arg.strip()) 1230 first = max(1, first - 5) 1231 except ValueError: 1232 self.error('Error in argument: %r' % arg) 1233 return 1234 elif self.lineno is None or arg == '.': 1235 first = max(1, self.curframe.f_lineno - 5) 1236 else: 1237 first = self.lineno + 1 1238 if last is None: 1239 last = first + 10 1240 filename = self.curframe.f_code.co_filename 1241 breaklist = self.get_file_breaks(filename) 1242 try: 1243 lines = linecache.getlines(filename, self.curframe.f_globals) 1244 self._print_lines(lines[first-1:last], first, breaklist, 1245 self.curframe) 1246 self.lineno = min(last, len(lines)) 1247 if len(lines) < last: 1248 self.message('[EOF]') 1249 except KeyboardInterrupt: 1250 pass 1251 do_l = do_list 1252 1253 def do_longlist(self, arg): 1254 """longlist | ll 1255 List the whole source code for the current function or frame. 1256 """ 1257 filename = self.curframe.f_code.co_filename 1258 breaklist = self.get_file_breaks(filename) 1259 try: 1260 lines, lineno = getsourcelines(self.curframe) 1261 except OSError as err: 1262 self.error(err) 1263 return 1264 self._print_lines(lines, lineno, breaklist, self.curframe) 1265 do_ll = do_longlist 1266 1267 def do_source(self, arg): 1268 """source expression 1269 Try to get source code for the given object and display it. 1270 """ 1271 try: 1272 obj = self._getval(arg) 1273 except: 1274 return 1275 try: 1276 lines, lineno = getsourcelines(obj) 1277 except (OSError, TypeError) as err: 1278 self.error(err) 1279 return 1280 self._print_lines(lines, lineno) 1281 1282 complete_source = _complete_expression 1283 1284 def _print_lines(self, lines, start, breaks=(), frame=None): 1285 """Print a range of lines.""" 1286 if frame: 1287 current_lineno = frame.f_lineno 1288 exc_lineno = self.tb_lineno.get(frame, -1) 1289 else: 1290 current_lineno = exc_lineno = -1 1291 for lineno, line in enumerate(lines, start): 1292 s = str(lineno).rjust(3) 1293 if len(s) < 4: 1294 s += ' ' 1295 if lineno in breaks: 1296 s += 'B' 1297 else: 1298 s += ' ' 1299 if lineno == current_lineno: 1300 s += '->' 1301 elif lineno == exc_lineno: 1302 s += '>>' 1303 self.message(s + '\t' + line.rstrip()) 1304 1305 def do_whatis(self, arg): 1306 """whatis arg 1307 Print the type of the argument. 1308 """ 1309 try: 1310 value = self._getval(arg) 1311 except: 1312 # _getval() already printed the error 1313 return 1314 code = None 1315 # Is it an instance method? 1316 try: 1317 code = value.__func__.__code__ 1318 except Exception: 1319 pass 1320 if code: 1321 self.message('Method %s' % code.co_name) 1322 return 1323 # Is it a function? 1324 try: 1325 code = value.__code__ 1326 except Exception: 1327 pass 1328 if code: 1329 self.message('Function %s' % code.co_name) 1330 return 1331 # Is it a class? 1332 if value.__class__ is type: 1333 self.message('Class %s.%s' % (value.__module__, value.__qualname__)) 1334 return 1335 # None of the above... 1336 self.message(type(value)) 1337 1338 complete_whatis = _complete_expression 1339 1340 def do_display(self, arg): 1341 """display [expression] 1342 1343 Display the value of the expression if it changed, each time execution 1344 stops in the current frame. 1345 1346 Without expression, list all display expressions for the current frame. 1347 """ 1348 if not arg: 1349 self.message('Currently displaying:') 1350 for item in self.displaying.get(self.curframe, {}).items(): 1351 self.message('%s: %r' % item) 1352 else: 1353 val = self._getval_except(arg) 1354 self.displaying.setdefault(self.curframe, {})[arg] = val 1355 self.message('display %s: %r' % (arg, val)) 1356 1357 complete_display = _complete_expression 1358 1359 def do_undisplay(self, arg): 1360 """undisplay [expression] 1361 1362 Do not display the expression any more in the current frame. 1363 1364 Without expression, clear all display expressions for the current frame. 1365 """ 1366 if arg: 1367 try: 1368 del self.displaying.get(self.curframe, {})[arg] 1369 except KeyError: 1370 self.error('not displaying %s' % arg) 1371 else: 1372 self.displaying.pop(self.curframe, None) 1373 1374 def complete_undisplay(self, text, line, begidx, endidx): 1375 return [e for e in self.displaying.get(self.curframe, {}) 1376 if e.startswith(text)] 1377 1378 def do_interact(self, arg): 1379 """interact 1380 1381 Start an interactive interpreter whose global namespace 1382 contains all the (global and local) names found in the current scope. 1383 """ 1384 ns = {**self.curframe.f_globals, **self.curframe_locals} 1385 code.interact("*interactive*", local=ns) 1386 1387 def do_alias(self, arg): 1388 """alias [name [command [parameter parameter ...] ]] 1389 Create an alias called 'name' that executes 'command'. The 1390 command must *not* be enclosed in quotes. Replaceable 1391 parameters can be indicated by %1, %2, and so on, while %* is 1392 replaced by all the parameters. If no command is given, the 1393 current alias for name is shown. If no name is given, all 1394 aliases are listed. 1395 1396 Aliases may be nested and can contain anything that can be 1397 legally typed at the pdb prompt. Note! You *can* override 1398 internal pdb commands with aliases! Those internal commands 1399 are then hidden until the alias is removed. Aliasing is 1400 recursively applied to the first word of the command line; all 1401 other words in the line are left alone. 1402 1403 As an example, here are two useful aliases (especially when 1404 placed in the .pdbrc file): 1405 1406 # Print instance variables (usage "pi classInst") 1407 alias pi for k in %1.__dict__.keys(): print("%1.",k,"=",%1.__dict__[k]) 1408 # Print instance variables in self 1409 alias ps pi self 1410 """ 1411 args = arg.split() 1412 if len(args) == 0: 1413 keys = sorted(self.aliases.keys()) 1414 for alias in keys: 1415 self.message("%s = %s" % (alias, self.aliases[alias])) 1416 return 1417 if args[0] in self.aliases and len(args) == 1: 1418 self.message("%s = %s" % (args[0], self.aliases[args[0]])) 1419 else: 1420 self.aliases[args[0]] = ' '.join(args[1:]) 1421 1422 def do_unalias(self, arg): 1423 """unalias name 1424 Delete the specified alias. 1425 """ 1426 args = arg.split() 1427 if len(args) == 0: return 1428 if args[0] in self.aliases: 1429 del self.aliases[args[0]] 1430 1431 def complete_unalias(self, text, line, begidx, endidx): 1432 return [a for a in self.aliases if a.startswith(text)] 1433 1434 # List of all the commands making the program resume execution. 1435 commands_resuming = ['do_continue', 'do_step', 'do_next', 'do_return', 1436 'do_quit', 'do_jump'] 1437 1438 # Print a traceback starting at the top stack frame. 1439 # The most recently entered frame is printed last; 1440 # this is different from dbx and gdb, but consistent with 1441 # the Python interpreter's stack trace. 1442 # It is also consistent with the up/down commands (which are 1443 # compatible with dbx and gdb: up moves towards 'main()' 1444 # and down moves towards the most recent stack frame). 1445 1446 def print_stack_trace(self): 1447 try: 1448 for frame_lineno in self.stack: 1449 self.print_stack_entry(frame_lineno) 1450 except KeyboardInterrupt: 1451 pass 1452 1453 def print_stack_entry(self, frame_lineno, prompt_prefix=line_prefix): 1454 frame, lineno = frame_lineno 1455 if frame is self.curframe: 1456 prefix = '> ' 1457 else: 1458 prefix = ' ' 1459 self.message(prefix + 1460 self.format_stack_entry(frame_lineno, prompt_prefix)) 1461 1462 # Provide help 1463 1464 def do_help(self, arg): 1465 """h(elp) 1466 Without argument, print the list of available commands. 1467 With a command name as argument, print help about that command. 1468 "help pdb" shows the full pdb documentation. 1469 "help exec" gives help on the ! command. 1470 """ 1471 if not arg: 1472 return cmd.Cmd.do_help(self, arg) 1473 try: 1474 try: 1475 topic = getattr(self, 'help_' + arg) 1476 return topic() 1477 except AttributeError: 1478 command = getattr(self, 'do_' + arg) 1479 except AttributeError: 1480 self.error('No help for %r' % arg) 1481 else: 1482 if sys.flags.optimize >= 2: 1483 self.error('No help for %r; please do not run Python with -OO ' 1484 'if you need command help' % arg) 1485 return 1486 self.message(command.__doc__.rstrip()) 1487 1488 do_h = do_help 1489 1490 def help_exec(self): 1491 """(!) statement 1492 Execute the (one-line) statement in the context of the current 1493 stack frame. The exclamation point can be omitted unless the 1494 first word of the statement resembles a debugger command. To 1495 assign to a global variable you must always prefix the command 1496 with a 'global' command, e.g.: 1497 (Pdb) global list_options; list_options = ['-l'] 1498 (Pdb) 1499 """ 1500 self.message((self.help_exec.__doc__ or '').strip()) 1501 1502 def help_pdb(self): 1503 help() 1504 1505 # other helper functions 1506 1507 def lookupmodule(self, filename): 1508 """Helper function for break/clear parsing -- may be overridden. 1509 1510 lookupmodule() translates (possibly incomplete) file or module name 1511 into an absolute file name. 1512 """ 1513 if os.path.isabs(filename) and os.path.exists(filename): 1514 return filename 1515 f = os.path.join(sys.path[0], filename) 1516 if os.path.exists(f) and self.canonic(f) == self.mainpyfile: 1517 return f 1518 root, ext = os.path.splitext(filename) 1519 if ext == '': 1520 filename = filename + '.py' 1521 if os.path.isabs(filename): 1522 return filename 1523 for dirname in sys.path: 1524 while os.path.islink(dirname): 1525 dirname = os.readlink(dirname) 1526 fullname = os.path.join(dirname, filename) 1527 if os.path.exists(fullname): 1528 return fullname 1529 return None 1530 1531 def _runmodule(self, module_name): 1532 self._wait_for_mainpyfile = True 1533 self._user_requested_quit = False 1534 import runpy 1535 mod_name, mod_spec, code = runpy._get_module_details(module_name) 1536 self.mainpyfile = self.canonic(code.co_filename) 1537 import __main__ 1538 __main__.__dict__.clear() 1539 __main__.__dict__.update({ 1540 "__name__": "__main__", 1541 "__file__": self.mainpyfile, 1542 "__package__": mod_spec.parent, 1543 "__loader__": mod_spec.loader, 1544 "__spec__": mod_spec, 1545 "__builtins__": __builtins__, 1546 }) 1547 self.run(code) 1548 1549 def _runscript(self, filename): 1550 # The script has to run in __main__ namespace (or imports from 1551 # __main__ will break). 1552 # 1553 # So we clear up the __main__ and set several special variables 1554 # (this gets rid of pdb's globals and cleans old variables on restarts). 1555 import __main__ 1556 __main__.__dict__.clear() 1557 __main__.__dict__.update({"__name__" : "__main__", 1558 "__file__" : filename, 1559 "__builtins__": __builtins__, 1560 }) 1561 1562 # When bdb sets tracing, a number of call and line events happens 1563 # BEFORE debugger even reaches user's code (and the exact sequence of 1564 # events depends on python version). So we take special measures to 1565 # avoid stopping before we reach the main script (see user_line and 1566 # user_call for details). 1567 self._wait_for_mainpyfile = True 1568 self.mainpyfile = self.canonic(filename) 1569 self._user_requested_quit = False 1570 with io.open_code(filename) as fp: 1571 statement = "exec(compile(%r, %r, 'exec'))" % \ 1572 (fp.read(), self.mainpyfile) 1573 self.run(statement) 1574 1575# Collect all command help into docstring, if not run with -OO 1576 1577if __doc__ is not None: 1578 # unfortunately we can't guess this order from the class definition 1579 _help_order = [ 1580 'help', 'where', 'down', 'up', 'break', 'tbreak', 'clear', 'disable', 1581 'enable', 'ignore', 'condition', 'commands', 'step', 'next', 'until', 1582 'jump', 'return', 'retval', 'run', 'continue', 'list', 'longlist', 1583 'args', 'p', 'pp', 'whatis', 'source', 'display', 'undisplay', 1584 'interact', 'alias', 'unalias', 'debug', 'quit', 1585 ] 1586 1587 for _command in _help_order: 1588 __doc__ += getattr(Pdb, 'do_' + _command).__doc__.strip() + '\n\n' 1589 __doc__ += Pdb.help_exec.__doc__ 1590 1591 del _help_order, _command 1592 1593 1594# Simplified interface 1595 1596def run(statement, globals=None, locals=None): 1597 Pdb().run(statement, globals, locals) 1598 1599def runeval(expression, globals=None, locals=None): 1600 return Pdb().runeval(expression, globals, locals) 1601 1602def runctx(statement, globals, locals): 1603 # B/W compatibility 1604 run(statement, globals, locals) 1605 1606def runcall(*args, **kwds): 1607 return Pdb().runcall(*args, **kwds) 1608 1609def set_trace(*, header=None): 1610 pdb = Pdb() 1611 if header is not None: 1612 pdb.message(header) 1613 pdb.set_trace(sys._getframe().f_back) 1614 1615# Post-Mortem interface 1616 1617def post_mortem(t=None): 1618 # handling the default 1619 if t is None: 1620 # sys.exc_info() returns (type, value, traceback) if an exception is 1621 # being handled, otherwise it returns None 1622 t = sys.exc_info()[2] 1623 if t is None: 1624 raise ValueError("A valid traceback must be passed if no " 1625 "exception is being handled") 1626 1627 p = Pdb() 1628 p.reset() 1629 p.interaction(None, t) 1630 1631def pm(): 1632 post_mortem(sys.last_traceback) 1633 1634 1635# Main program for testing 1636 1637TESTCMD = 'import x; x.main()' 1638 1639def test(): 1640 run(TESTCMD) 1641 1642# print help 1643def help(): 1644 import pydoc 1645 pydoc.pager(__doc__) 1646 1647_usage = """\ 1648usage: pdb.py [-c command] ... [-m module | pyfile] [arg] ... 1649 1650Debug the Python program given by pyfile. Alternatively, 1651an executable module or package to debug can be specified using 1652the -m switch. 1653 1654Initial commands are read from .pdbrc files in your home directory 1655and in the current directory, if they exist. Commands supplied with 1656-c are executed after commands from .pdbrc files. 1657 1658To let the script run until an exception occurs, use "-c continue". 1659To let the script run up to a given line X in the debugged file, use 1660"-c 'until X'".""" 1661 1662def main(): 1663 import getopt 1664 1665 opts, args = getopt.getopt(sys.argv[1:], 'mhc:', ['help', 'command=']) 1666 1667 if not args: 1668 print(_usage) 1669 sys.exit(2) 1670 1671 commands = [] 1672 run_as_module = False 1673 for opt, optarg in opts: 1674 if opt in ['-h', '--help']: 1675 print(_usage) 1676 sys.exit() 1677 elif opt in ['-c', '--command']: 1678 commands.append(optarg) 1679 elif opt in ['-m']: 1680 run_as_module = True 1681 1682 mainpyfile = args[0] # Get script filename 1683 if not run_as_module and not os.path.exists(mainpyfile): 1684 print('Error:', mainpyfile, 'does not exist') 1685 sys.exit(1) 1686 1687 sys.argv[:] = args # Hide "pdb.py" and pdb options from argument list 1688 1689 # Replace pdb's dir with script's dir in front of module search path. 1690 if not run_as_module: 1691 sys.path[0] = os.path.dirname(mainpyfile) 1692 1693 # Note on saving/restoring sys.argv: it's a good idea when sys.argv was 1694 # modified by the script being debugged. It's a bad idea when it was 1695 # changed by the user from the command line. There is a "restart" command 1696 # which allows explicit specification of command line arguments. 1697 pdb = Pdb() 1698 pdb.rcLines.extend(commands) 1699 while True: 1700 try: 1701 if run_as_module: 1702 pdb._runmodule(mainpyfile) 1703 else: 1704 pdb._runscript(mainpyfile) 1705 if pdb._user_requested_quit: 1706 break 1707 print("The program finished and will be restarted") 1708 except Restart: 1709 print("Restarting", mainpyfile, "with arguments:") 1710 print("\t" + " ".join(args)) 1711 except SystemExit: 1712 # In most cases SystemExit does not warrant a post-mortem session. 1713 print("The program exited via sys.exit(). Exit status:", end=' ') 1714 print(sys.exc_info()[1]) 1715 except SyntaxError: 1716 traceback.print_exc() 1717 sys.exit(1) 1718 except: 1719 traceback.print_exc() 1720 print("Uncaught exception. Entering post mortem debugging") 1721 print("Running 'cont' or 'step' will restart the program") 1722 t = sys.exc_info()[2] 1723 pdb.interaction(None, t) 1724 print("Post mortem debugger finished. The " + mainpyfile + 1725 " will be restarted") 1726 1727 1728# When invoked as main program, invoke the debugger on a script 1729if __name__ == '__main__': 1730 import pdb 1731 pdb.main() 1732