Coverage for /pythoncovmergedfiles/medio/medio/usr/lib/python3.9/pdb.py: 16%

995 statements  

« prev     ^ index     » next       coverage.py v7.3.1, created at 2023-09-25 06:05 +0000

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 if not run_as_module: 

1690 mainpyfile = os.path.realpath(mainpyfile) 

1691 # Replace pdb's dir with script's dir in front of module search path. 

1692 sys.path[0] = os.path.dirname(mainpyfile) 

1693 

1694 # Note on saving/restoring sys.argv: it's a good idea when sys.argv was 

1695 # modified by the script being debugged. It's a bad idea when it was 

1696 # changed by the user from the command line. There is a "restart" command 

1697 # which allows explicit specification of command line arguments. 

1698 pdb = Pdb() 

1699 pdb.rcLines.extend(commands) 

1700 while True: 

1701 try: 

1702 if run_as_module: 

1703 pdb._runmodule(mainpyfile) 

1704 else: 

1705 pdb._runscript(mainpyfile) 

1706 if pdb._user_requested_quit: 

1707 break 

1708 print("The program finished and will be restarted") 

1709 except Restart: 

1710 print("Restarting", mainpyfile, "with arguments:") 

1711 print("\t" + " ".join(sys.argv[1:])) 

1712 except SystemExit: 

1713 # In most cases SystemExit does not warrant a post-mortem session. 

1714 print("The program exited via sys.exit(). Exit status:", end=' ') 

1715 print(sys.exc_info()[1]) 

1716 except SyntaxError: 

1717 traceback.print_exc() 

1718 sys.exit(1) 

1719 except: 

1720 traceback.print_exc() 

1721 print("Uncaught exception. Entering post mortem debugging") 

1722 print("Running 'cont' or 'step' will restart the program") 

1723 t = sys.exc_info()[2] 

1724 pdb.interaction(None, t) 

1725 print("Post mortem debugger finished. The " + mainpyfile + 

1726 " will be restarted") 

1727 

1728 

1729# When invoked as main program, invoke the debugger on a script 

1730if __name__ == '__main__': 

1731 import pdb 

1732 pdb.main()