pdb
index
/usr/lib/python2.2/pdb.py

A Python debugger.

 
Modules
            
bdb
cmd
linecache
os
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_disable(self, arg)
do_down(self, arg)
do_enable(self, arg)
do_h = do_help(self, arg)
do_ignore(self, arg)
arg is bp number followed by ignore count.
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_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_disable(self)
help_down(self)
help_enable(self)
help_exec(self)
help_h(self)
help_help(self)
help_ignore(self)
help_l(self)
help_list(self)
help_n(self)
help_next(self)
help_p(self)
help_pdb(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_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.

Data and non-method functions defined here:
__doc__ = None
__module__ = 'pdb'

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)
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.

Methods inherited from cmd.Cmd:
cmdloop(self, intro=None)
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)
completenames(self, text, *ignored)
do_help(self, arg)
emptyline(self)
get_names(self)
onecmd(self, line)
parseline(self, line)
postcmd(self, stop, line)
postloop(self)
preloop(self)
print_topics(self, header, cmds, cmdlen, maxcol)

Data and non-method functions inherited from cmd.Cmd:
cmdqueue = []
doc_header = 'Documented commands (type help ):'
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']
__file__ = '/usr/lib/python2.2/pdb.pyc'
__name__ = 'pdb'
line_prefix = '\n-> '
mainmodule = ''
mainpyfile = ''