pdb
index
/usr/local/lib/python2.3/pdb.py

A Python debugger.

 
Modules
       
bdb
cmd
linecache
os
pprint
re
sys

 
Classes
       
bdb.Bdb
Pdb(bdb.Bdb, cmd.Cmd)
cmd.Cmd
Pdb(bdb.Bdb, cmd.Cmd)

 
class Pdb(bdb.Bdb, cmd.Cmd)
    
Method resolution order:
Pdb
bdb.Bdb
cmd.Cmd

Methods defined here:
__init__(self)
checkline(self, filename, lineno)
Return line number of first line at or after input
argument such that if the input points to a 'def', the
returned line number is the first
non-blank/non-comment line to follow.  If the input
points to a blank or comment line, return 0.  At end
of file, also return 0.
default(self, line)
defaultFile(self)
Produce a reasonable default.
do_EOF(self, arg)
do_a = do_args(self, arg)
do_alias(self, arg)
do_args(self, arg)
do_b = do_break(self, arg, temporary=0)
do_break(self, arg, temporary=0)
do_bt = do_where(self, arg)
do_c = do_continue(self, arg)
do_cl = do_clear(self, arg)
do_clear(self, arg)
Three possibilities, tried in this order:
clear -> clear all breaks, ask for confirmation
clear /get.cgi/lineno -> clear all breaks at file:lineno
clear bpno bpno ... -> clear breakpoints by number
do_condition(self, arg)
do_cont = do_continue(self, arg)
do_continue(self, arg)
do_d = do_down(self, arg)
do_debug(self, arg)
do_disable(self, arg)
do_down(self, arg)
do_enable(self, arg)
do_exit = do_quit(self, arg)
do_h = do_help(self, arg)
do_ignore(self, arg)
arg is bp number followed by ignore count.
do_j = do_jump(self, arg)
do_jump(self, arg)
do_l = do_list(self, arg)
do_list(self, arg)
do_n = do_next(self, arg)
do_next(self, arg)
do_p(self, arg)
do_pp(self, arg)
do_q = do_quit(self, arg)
do_quit(self, arg)
do_r = do_return(self, arg)
do_return(self, arg)
do_retval(self, arg)
do_rv = do_retval(self, arg)
do_s = do_step(self, arg)
do_step(self, arg)
do_tbreak(self, arg)
do_u = do_up(self, arg)
do_unalias(self, arg)
do_up(self, arg)
do_w = do_where(self, arg)
do_whatis(self, arg)
do_where(self, arg)
execRcLines(self)
# Can be executed earlier than 'setup' if desired
forget(self)
help_EOF(self)
help_a(self)
help_alias(self)
help_args(self)
help_b(self)
help_break(self)
help_bt = help_w(self)
help_c(self)
help_cl(self)
help_clear(self)
help_condition(self)
help_cont(self)
help_continue(self)
help_d(self)
help_debug(self)
help_disable(self)
help_down(self)
help_enable(self)
help_exec(self)
help_exit = help_q(self)
help_h(self)
help_help(self)
help_ignore(self)
help_j(self)
help_jump(self)
help_l(self)
help_list(self)
help_n(self)
help_next(self)
help_p(self)
help_pdb(self)
help_pp(self)
help_q(self)
help_quit(self)
help_r(self)
help_return(self)
help_s(self)
help_step(self)
help_tbreak(self)
help_u(self)
help_unalias(self)
help_up(self)
help_w(self)
help_whatis(self)
help_where(self)
interaction(self, frame, traceback)
lineinfo(self, identifier)
lookupmodule(self, filename)
Helper function for break/clear parsing -- may be overridden.
precmd(self, line)
Handle alias expansion and ';;' separator.
print_stack_entry(self, frame_lineno, prompt_prefix='\n-> ')
print_stack_trace(self)
reset(self)
setup(self, f, t)
user_call(self, frame, argument_list)
This method is called when there is the remote possibility
that we ever need to stop in this function.
user_exception(self, frame, (exc_type, exc_value, exc_traceback))
This function is called if an exception occurs,
but only if we are to stop at or just below this level.
user_line(self, frame)
This function is called when we stop or break at this line.
user_return(self, frame, return_value)
This function is called when a return trap is set here.

Methods inherited from bdb.Bdb:
break_anywhere(self, frame)
break_here(self, frame)
canonic(self, filename)
clear_all_breaks(self)
clear_all_file_breaks(self, filename)
clear_bpbynumber(self, arg)
clear_break(self, filename, lineno)
dispatch_call(self, frame, arg)
dispatch_exception(self, frame, arg)
dispatch_line(self, frame)
dispatch_return(self, frame, arg)
format_stack_entry(self, frame_lineno, lprefix=': ')
get_all_breaks(self)
get_break(self, filename, lineno)
get_breaks(self, filename, lineno)
get_file_breaks(self, filename)
get_stack(self, f, t)
run(self, cmd, globals=None, locals=None)
runcall(self, func, *args)
runctx(self, cmd, globals, locals)
runeval(self, expr, globals=None, locals=None)
set_break(self, filename, lineno, temporary=0, cond=None)
set_continue(self)
set_next(self, frame)
Stop on the next line in or below the given frame.
set_quit(self)
set_return(self, frame)
Stop when returning from the given frame.
set_step(self)
Stop after one line of code.
set_trace(self)
Start debugging from here.
stop_here(self, frame)
trace_dispatch(self, frame, event, arg)

Methods inherited from cmd.Cmd:
cmdloop(self, intro=None)
Repeatedly issue a prompt, accept input, parse an initial prefix
off the received input, and dispatch to action methods, passing them
the remainder of the line as argument.
columnize(self, list, displaywidth=80)
Display a list of strings as a compact set of columns.
 
Each column is only as wide as necessary.
Columns are separated by two spaces (one was not legible enough).
complete(self, text, state)
Return the next possible completion for 'text'.
 
If a command has not been entered, then complete against command list.
Otherwise try to call complete_<command> to get list of completions.
complete_help(self, *args)
completedefault(self, *ignored)
Method called to complete an input line when no command-specific
complete_*() method is available.
 
By default, it returns an empty list.
completenames(self, text, *ignored)
do_help(self, arg)
emptyline(self)
Called when an empty line is entered in response to the prompt.
 
If this method is not overridden, it repeats the last nonempty
command entered.
get_names(self)
onecmd(self, line)
Interpret the argument as though it had been typed in response
to the prompt.
 
This may be overridden, but should not normally need to be;
see the precmd() and postcmd() methods for useful execution hooks.
The return value is a flag indicating whether interpretation of
commands by the interpreter should stop.
parseline(self, line)
postcmd(self, stop, line)
Hook method executed just after a command dispatch is finished.
postloop(self)
Hook method executed once when the cmdloop() method is about to
return.
preloop(self)
Hook method executed once when the cmdloop() method is called.
print_topics(self, header, cmds, cmdlen, maxcol)

Data and other attributes inherited from cmd.Cmd:
doc_header = 'Documented commands (type help <topic>):'
doc_leader = ''
identchars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_'
intro = None
lastcmd = ''
misc_header = 'Miscellaneous help topics:'
nohelp = '*** No help on %s'
prompt = '(Cmd) '
ruler = '='
undoc_header = 'Undocumented commands:'
use_rawinput = 1

 
Functions
       
find_function(funcname, filename)
help()
# print help
pm()
post_mortem(t)
run(statement, globals=None, locals=None)
runcall(*args)
runctx(statement, globals, locals)
runeval(expression, globals=None, locals=None)
set_trace()
test()

 
Data
        TESTCMD = 'import x; x.main()'
__all__ = ['run', 'pm', 'Pdb', 'runeval', 'runctx', 'runcall', 'set_trace', 'post_mortem', 'help']
line_prefix = '\n-> '
mainmodule = ''
mainpyfile = ''