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
3"""
4The Python Debugger Pdb
5=======================
7To use the debugger in its simplest form:
9 >>> import pdb
10 >>> pdb.run('<a statement>')
12The debugger's prompt is '(Pdb) '. This will stop in the first
13function call in <a statement>.
15Alternatively, if a statement terminated with an unhandled exception,
16you can use pdb's post-mortem facility to inspect the contents of the
17traceback:
19 >>> <a statement>
20 <exception traceback>
21 >>> import pdb
22 >>> pdb.pm()
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 (|).
31A blank line repeats the previous command literally, except for
32'list', where it lists the next 11 lines.
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.
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.
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.
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.
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.
63Debugger commands
64=================
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.
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
87class Restart(Exception):
88 """Causes a debugger to be restarted for the debugged python program."""
89 pass
91__all__ = ["run", "pm", "Pdb", "runeval", "runctx", "runcall", "set_trace",
92 "post_mortem", "help"]
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
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
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
125class _rstr(str):
126 """String that doesn't quote its repr."""
127 def __repr__(self):
128 return self
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
138class Pdb(bdb.Bdb, cmd.Cmd):
140 _previous_sigint_handler = None
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
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
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
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)
196 def reset(self):
197 bdb.Bdb.reset(self)
198 self.forget()
200 def forget(self):
201 self.lineno = None
202 self.stack = []
203 self.curindex = 0
204 self.curframe = None
205 self.tb_lineno.clear()
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()
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
243 # Override Bdb methods
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)
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)
264 def bp_commands(self, frame):
265 """Call every command that was set for the current active breakpoint
266 (if there is one).
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
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)
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
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)
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--')
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))
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()
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))
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())
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
415 def onecmd(self, line):
416 """Interpret the argument as though it had been typed in response
417 to the prompt.
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)
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
455 # interface abstraction functions
457 def message(self, msg):
458 print(msg, file=self.stdout)
460 def error(self, msg):
461 print('***', msg, file=self.stdout)
463 # Generic completion functions. Individual complete_foo methods can be
464 # assigned below to one of these functions.
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
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)]
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)]
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
521 def do_commands(self, arg):
522 """commands [bpnumber]
523 (com) ...
524 (com) end
525 (Pdb)
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.
532 To remove all commands from a breakpoint, type commands and
533 follow it immediately with end; that is, give no commands.
535 With no bpnumber argument, commands refers to the last
536 breakpoint set.
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.
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.
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
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
598 complete_commands = _complete_bpnumber
600 def do_break(self, arg, temporary = 0):
601 """b(reak) [ ([filename:]lineno | function) [, condition] ]
602 Without argument, list all breaks.
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.
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))
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
700 do_b = do_break
702 complete_break = _complete_location
703 complete_b = _complete_location
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)
712 complete_tbreak = _complete_location
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
747 def checkline(self, filename, lineno):
748 """Check whether specified line seems to be executable.
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
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)
783 complete_enable = _complete_bpnumber
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)
803 complete_disable = _complete_bpnumber
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)
830 complete_condition = _complete_bpnumber
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)
865 complete_ignore = _complete_bpnumber
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'
915 complete_clear = _complete_location
916 complete_cl = _complete_location
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
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
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
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
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
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
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
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
1034 do_restart = do_run
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
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
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.
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
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
1112 complete_debug = _complete_expression
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
1122 do_q = do_quit
1123 do_exit = do_quit
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
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
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
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
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)
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
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
1198 complete_print = _complete_expression
1199 complete_p = _complete_expression
1200 complete_pp = _complete_expression
1202 def do_list(self, arg):
1203 """l(ist) [first [,last] | .]
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.
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
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
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)
1282 complete_source = _complete_expression
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())
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))
1338 complete_whatis = _complete_expression
1340 def do_display(self, arg):
1341 """display [expression]
1343 Display the value of the expression if it changed, each time execution
1344 stops in the current frame.
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))
1357 complete_display = _complete_expression
1359 def do_undisplay(self, arg):
1360 """undisplay [expression]
1362 Do not display the expression any more in the current frame.
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)
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)]
1378 def do_interact(self, arg):
1379 """interact
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)
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.
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.
1403 As an example, here are two useful aliases (especially when
1404 placed in the .pdbrc file):
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:])
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]]
1431 def complete_unalias(self, text, line, begidx, endidx):
1432 return [a for a in self.aliases if a.startswith(text)]
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']
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).
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
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))
1462 # Provide help
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())
1488 do_h = do_help
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())
1502 def help_pdb(self):
1503 help()
1505 # other helper functions
1507 def lookupmodule(self, filename):
1508 """Helper function for break/clear parsing -- may be overridden.
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
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)
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 })
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)
1575# Collect all command help into docstring, if not run with -OO
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 ]
1587 for _command in _help_order:
1588 __doc__ += getattr(Pdb, 'do_' + _command).__doc__.strip() + '\n\n'
1589 __doc__ += Pdb.help_exec.__doc__
1591 del _help_order, _command
1594# Simplified interface
1596def run(statement, globals=None, locals=None):
1597 Pdb().run(statement, globals, locals)
1599def runeval(expression, globals=None, locals=None):
1600 return Pdb().runeval(expression, globals, locals)
1602def runctx(statement, globals, locals):
1603 # B/W compatibility
1604 run(statement, globals, locals)
1606def runcall(*args, **kwds):
1607 return Pdb().runcall(*args, **kwds)
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)
1615# Post-Mortem interface
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")
1627 p = Pdb()
1628 p.reset()
1629 p.interaction(None, t)
1631def pm():
1632 post_mortem(sys.last_traceback)
1635# Main program for testing
1637TESTCMD = 'import x; x.main()'
1639def test():
1640 run(TESTCMD)
1642# print help
1643def help():
1644 import pydoc
1645 pydoc.pager(__doc__)
1647_usage = """\
1648usage: pdb.py [-c command] ... [-m module | pyfile] [arg] ...
1650Debug the Python program given by pyfile. Alternatively,
1651an executable module or package to debug can be specified using
1652the -m switch.
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.
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'"."""
1662def main():
1663 import getopt
1665 opts, args = getopt.getopt(sys.argv[1:], 'mhc:', ['help', 'command='])
1667 if not args:
1668 print(_usage)
1669 sys.exit(2)
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
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)
1687 sys.argv[:] = args # Hide "pdb.py" and pdb options from argument list
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)
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")
1729# When invoked as main program, invoke the debugger on a script
1730if __name__ == '__main__':
1731 import pdb
1732 pdb.main()