cre = re.compile(r'def\s+%s\s*[(]' % re.escape(funcname))

try:

fp = open(filename)

except IOError:

return None

# consumer of this info expects the first line to be 1

lineno = 1

answer = None

while 1:

line = fp.readline()

if line == '':

break

if cre.match(line):

answer = funcname, filename, lineno

break

lineno = lineno + 1

fp.close()

def __init__(self, completekey='tab', stdin=None, stdout=None, skip=None):

bdb.Bdb.__init__(self, skip=skip)

cmd.Cmd.__init__(self, completekey, stdin, stdout)

if stdout:

self.use_rawinput = 0

self.prompt = '(Pdb) '

self.aliases = {}

self.mainpyfile = ''

self._wait_for_mainpyfile = 0

# Try to load readline if it exists

try:

import readline

except ImportError:

pass

# Read $HOME/.pdbrc and ./.pdbrc

self.rcLines = []

if 'HOME' in os.environ:

envHome = os.environ['HOME']

try:

rcFile = open(os.path.join(envHome, ".pdbrc"))

except IOError:

pass

else:

for line in rcFile.readlines():

self.rcLines.append(line)

rcFile.close()

try:

rcFile = open(".pdbrc")

except IOError:

pass

else:

for line in rcFile.readlines():

self.rcLines.append(line)

rcFile.close()

self.commands = {} # associates a command list to breakpoint numbers

self.commands_doprompt = {} # for each bp num, tells if the prompt

# must be disp. after execing the cmd list

self.commands_silent = {} # for each bp num, tells if the stack trace

# must be disp. after execing the cmd list

self.commands_defining = False # True while in the process of defining

# a command list

self.commands_bnum = None # The breakpoint number for which we are

# defining a list

def reset(self):

bdb.Bdb.reset(self)

self.forget()

def forget(self):

self.lineno = None

self.stack = []

self.curindex = 0

self.curframe = None

def setup(self, f, t):

self.forget()

self.stack, self.curindex = self.get_stack(f, t)

self.curframe = self.stack[self.curindex][0]

# The f_locals dictionary is updated from the actual frame

# locals whenever the .f_locals accessor is called, so we

# cache it here to ensure that modifications are not overwritten.

self.curframe_locals = self.curframe.f_locals

self.execRcLines()

# Can be executed earlier than 'setup' if desired

def execRcLines(self):

if self.rcLines:

# Make local copy because of recursion

rcLines = self.rcLines

# executed only once

self.rcLines = []

for line in rcLines:

line = line[:-1]

if len(line) > 0 and line[0] != '#':

self.onecmd(line)

# Override Bdb methods

def user_call(self, frame, argument_list):

"""This method is called when there is the remote possibility

if self._wait_for_mainpyfile:

return

if self.stop_here(frame):

print >>self.stdout, '--Call--'

self.interaction(frame, None)

def user_line(self, frame):

"""This function is called when we stop or break at this line."""

if self._wait_for_mainpyfile:

if (self.mainpyfile != self.canonic(frame.f_code.co_filename)

or frame.f_lineno<= 0):

return

self._wait_for_mainpyfile = 0

if self.bp_commands(frame):

self.interaction(frame, None)

def bp_commands(self,frame):

"""Call every command that was set for the current active breakpoint

# self.currentbp is set in bdb in Bdb.break_here if a breakpoint was hit

if getattr(self, "currentbp", False) and \

self.currentbp in self.commands:

currentbp = self.currentbp

self.currentbp = 0

lastcmd_back = self.lastcmd

self.setup(frame, None)

for line in self.commands[currentbp]:

self.onecmd(line)

self.lastcmd = lastcmd_back

if not self.commands_silent[currentbp]:

self.print_stack_entry(self.stack[self.curindex])

if self.commands_doprompt[currentbp]:

self.cmdloop()

self.forget()

return

return 1

def user_return(self, frame, return_value):

"""This function is called when a return trap is set here."""

if self._wait_for_mainpyfile:

return

frame.f_locals['__return__'] = return_value

print >>self.stdout, '--Return--'

self.interaction(frame, None)

def user_exception(self, frame, exc_info):

"""This function is called if an exception occurs,

if self._wait_for_mainpyfile:

return

exc_type, exc_value, exc_traceback = exc_info

frame.f_locals['__exception__'] = exc_type, exc_value

if type(exc_type) == type(''):

exc_type_name = exc_type

else: exc_type_name = exc_type.__name__

print >>self.stdout, exc_type_name + ':', _saferepr(exc_value)

self.interaction(frame, exc_traceback)

# General interaction function

def interaction(self, frame, traceback):

self.setup(frame, traceback)

self.print_stack_entry(self.stack[self.curindex])

self.cmdloop()

self.forget()

def displayhook(self, obj):

"""Custom displayhook for the exec in default(), which prevents

# reproduce the behavior of the standard displayhook, not printing None

if obj is not None:

print repr(obj)

def default(self, line):

if line[:1] == '!': line = line[1:]

locals = self.curframe_locals

globals = self.curframe.f_globals

try:

code = compile(line + '\n', '<stdin>', 'single')

save_stdout = sys.stdout

save_stdin = sys.stdin

save_displayhook = sys.displayhook

try:

sys.stdin = self.stdin

sys.stdout = self.stdout

sys.displayhook = self.displayhook

exec code in globals, locals

finally:

sys.stdout = save_stdout

sys.stdin = save_stdin

sys.displayhook = save_displayhook

except:

t, v = sys.exc_info()[:2]

if type(t) == type(''):

exc_type_name = t

else: exc_type_name = t.__name__

print >>self.stdout, '***', exc_type_name + ':', v

def precmd(self, line):

"""Handle alias expansion and ';;' separator."""

if not line.strip():

return line

args = line.split()

while args[0] in self.aliases:

line = self.aliases[args[0]]

ii = 1

for tmpArg in args[1:]:

line = line.replace("%" + str(ii),

tmpArg)

ii = ii + 1

line = line.replace("%*", ' '.join(args[1:]))

args = line.split()

# split into ';;' separated commands

# unless it's an alias command

if args[0] != 'alias':

marker = line.find(';;')

if marker >= 0:

# queue up everything after marker

next = line[marker+2:].lstrip()

self.cmdqueue.append(next)

line = line[:marker].rstrip()

return line

def onecmd(self, line):

"""Interpret the argument as though it had been typed in response

if not self.commands_defining:

return cmd.Cmd.onecmd(self, line)

else:

return self.handle_command_def(line)

def handle_command_def(self,line):

"""Handles one command line during command list definition."""

cmd, arg, line = self.parseline(line)

if not cmd:

return

if cmd == 'silent':

self.commands_silent[self.commands_bnum] = True

return # continue to handle other cmd def in the cmd list

elif cmd == 'end':

self.cmdqueue = []

return 1 # end of cmd list

cmdlist = self.commands[self.commands_bnum]

if arg:

cmdlist.append(cmd+' '+arg)

else:

cmdlist.append(cmd)

# Determine if we must stop

try:

func = getattr(self, 'do_' + cmd)

except AttributeError:

func = self.default

# one of the resuming commands

if func.func_name in self.commands_resuming:

self.commands_doprompt[self.commands_bnum] = False

self.cmdqueue = []

return 1

return

# Command definitions, called by cmdloop()

# The argument is the remaining string on the command line

# Return true to exit from the command loop

do_h = cmd.Cmd.do_help

def do_commands(self, arg):

"""Defines a list of commands associated to a breakpoint.

if not arg:

bnum = len(bdb.Breakpoint.bpbynumber)-1

else:

try:

bnum = int(arg)

except:

print >>self.stdout, "Usage : commands [bnum]\n ..." \

"\n end"

return

self.commands_bnum = bnum

self.commands[bnum] = []

self.commands_doprompt[bnum] = True

self.commands_silent[bnum] = False

prompt_back = self.prompt

self.prompt = '(com) '

self.commands_defining = True

try:

self.cmdloop()

finally:

self.commands_defining = False

self.prompt = prompt_back

def do_break(self, arg, temporary = 0):

# break [ ([filename:]lineno | function) [, "condition"] ]

if not arg:

if self.breaks: # There's at least one

print >>self.stdout, "Num Type Disp Enb Where"

for bp in bdb.Breakpoint.bpbynumber:

if bp:

bp.bpprint(self.stdout)

return

# parse arguments; comma has lowest precedence

# and cannot occur in filename

filename = None

lineno = None

cond = None

comma = arg.find(',')

if comma > 0:

# parse stuff after comma: "condition"

cond = arg[comma+1:].lstrip()

arg = arg[:comma].rstrip()

# parse stuff before comma: [filename:]lineno | function

colon = arg.rfind(':')

funcname = None

if colon >= 0:

filename = arg[:colon].rstrip()

f = self.lookupmodule(filename)

if not f:

print >>self.stdout, '*** ', repr(filename),

print >>self.stdout, 'not found from sys.path'

return

else:

filename = f

arg = arg[colon+1:].lstrip()

try:

lineno = int(arg)

except ValueError, msg:

print >>self.stdout, '*** Bad lineno:', arg

return

else:

# no colon; can be lineno or function

try:

lineno = int(arg)

except ValueError:

try:

func = eval(arg,

self.curframe.f_globals,

self.curframe_locals)

except:

func = arg

try:

if hasattr(func, 'im_func'):

func = func.im_func

code = func.func_code

#use co_name to identify the bkpt (function names

#could be aliased, but co_name is invariant)

funcname = code.co_name

lineno = code.co_firstlineno

filename = code.co_filename

except:

# last thing to try

(ok, filename, ln) = self.lineinfo(arg)

if not ok:

print >>self.stdout, '*** The specified object',

print >>self.stdout, repr(arg),

print >>self.stdout, 'is not a function'

print >>self.stdout, 'or was not found along sys.path.'

return

funcname = ok # ok contains a function name

lineno = int(ln)

if not filename:

filename = self.defaultFile()

# Check for reasonable breakpoint

line = self.checkline(filename, lineno)

if line:

# now set the break point

err = self.set_break(filename, line, temporary, cond, funcname)

if err: print >>self.stdout, '***', err

else:

bp = self.get_breaks(filename, line)[-1]

print >>self.stdout, "Breakpoint %d at %s:%d" % (bp.number,

bp.file,

bp.line)

# To be overridden in derived debuggers

def defaultFile(self):

"""Produce a reasonable default."""

filename = self.curframe.f_code.co_filename

if filename == '<string>' and self.mainpyfile:

filename = self.mainpyfile

return filename

do_b = do_break

def do_tbreak(self, arg):

self.do_break(arg, 1)

def lineinfo(self, identifier):

failed = (None, None, None)

# Input is identifier, may be in single quotes

idstring = identifier.split("'")

if len(idstring) == 1:

# not in single quotes

id = idstring[0].strip()

elif len(idstring) == 3:

# quoted

id = idstring[1].strip()

else:

return failed

if id == '': return failed

parts = id.split('.')

# Protection for derived debuggers

if parts[0] == 'self':

del parts[0]

if len(parts) == 0:

return failed

# Best first guess at file to look at

fname = self.defaultFile()

if len(parts) == 1:

item = parts[0]

else:

# More than one part.

# First is module, second is method/class

f = self.lookupmodule(parts[0])

if f:

fname = f

item = parts[1]

answer = find_function(item, fname)

return answer or failed

def checkline(self, filename, lineno):

"""Check whether specified line seems to be executable.

# this method should be callable before starting debugging, so default

# to "no globals" if there is no current frame

globs = self.curframe.f_globals if hasattr(self, 'curframe') else None

line = linecache.getline(filename, lineno, globs)

if not line:

print >>self.stdout, 'End of file'

return 0

line = line.strip()

# Don't allow setting breakpoint at a blank line

if (not line or (line[0] == '#') or

(line[:3] == '"""') or line[:3] == "'''"):

print >>self.stdout, '*** Blank or comment'

return 0

return lineno

def do_enable(self, arg):

args = arg.split()

for i in args:

try:

i = int(i)

except ValueError:

print >>self.stdout, 'Breakpoint index %r is not a number' % i

continue

if not (0 <= i < len(bdb.Breakpoint.bpbynumber)):

print >>self.stdout, 'No breakpoint numbered', i

continue

bp = bdb.Breakpoint.bpbynumber[i]

if bp:

bp.enable()

def do_disable(self, arg):

args = arg.split()

for i in args:

try:

i = int(i)

except ValueError:

print >>self.stdout, 'Breakpoint index %r is not a number' % i

continue

if not (0 <= i < len(bdb.Breakpoint.bpbynumber)):

print >>self.stdout, 'No breakpoint numbered', i

continue

bp = bdb.Breakpoint.bpbynumber[i]

if bp:

bp.disable()

def do_condition(self, arg):

# arg is breakpoint number and condition

args = arg.split(' ', 1)

try:

bpnum = int(args[0].strip())

except ValueError:

# something went wrong

print >>self.stdout, \

'Breakpoint index %r is not a number' % args[0]

return

try:

cond = args[1]

except:

cond = None

try:

bp = bdb.Breakpoint.bpbynumber[bpnum]

except IndexError:

print >>self.stdout, 'Breakpoint index %r is not valid' % args[0]

return

if bp:

bp.cond = cond

if not cond:

print >>self.stdout, 'Breakpoint', bpnum,

print >>self.stdout, 'is now unconditional.'

def do_ignore(self,arg):

"""arg is bp number followed by ignore count."""

args = arg.split()

try:

bpnum = int(args[0].strip())

except ValueError:

# something went wrong

print >>self.stdout, \

'Breakpoint index %r is not a number' % args[0]

return

try:

count = int(args[1].strip())

except:

count = 0

try:

bp = bdb.Breakpoint.bpbynumber[bpnum]

except IndexError:

print >>self.stdout, 'Breakpoint index %r is not valid' % args[0]

return

if bp:

bp.ignore = count

if count > 0:

reply = 'Will ignore next '

if count > 1:

reply = reply + '%d crossings' % count

else:

reply = reply + '1 crossing'

print >>self.stdout, reply + ' of breakpoint %d.' % bpnum

else:

print >>self.stdout, 'Will stop next time breakpoint',

print >>self.stdout, bpnum, 'is reached.'

def do_clear(self, arg):

"""Three possibilities, tried in this order:

if not arg:

try:

reply = raw_input('Clear all breaks? ')

except EOFError:

reply = 'no'

reply = reply.strip().lower()

if reply in ('y', 'yes'):

self.clear_all_breaks()

return

if ':' in arg:

# Make sure it works for "clear C:\foo\bar.py:12"

i = arg.rfind(':')

filename = arg[:i]

arg = arg[i+1:]

try:

lineno = int(arg)

except ValueError:

err = "Invalid line number (%s)" % arg

else:

err = self.clear_break(filename, lineno)

if err: print >>self.stdout, '***', err

return

numberlist = arg.split()

for i in numberlist:

try:

i = int(i)

except ValueError:

print >>self.stdout, 'Breakpoint index %r is not a number' % i

continue

if not (0 <= i < len(bdb.Breakpoint.bpbynumber)):

print >>self.stdout, 'No breakpoint numbered', i

continue

err = self.clear_bpbynumber(i)

if err:

print >>self.stdout, '***', err

else:

print >>self.stdout, 'Deleted breakpoint', i

do_cl = do_clear # 'c' is already an abbreviation for 'continue'

def do_where(self, arg):

self.print_stack_trace()

do_w = do_where

do_bt = do_where

def do_up(self, arg):

if self.curindex == 0:

print >>self.stdout, '*** Oldest frame'

else:

self.curindex = self.curindex - 1

self.curframe = self.stack[self.curindex][0]

self.curframe_locals = self.curframe.f_locals

self.print_stack_entry(self.stack[self.curindex])

self.lineno = None

do_u = do_up

def do_down(self, arg):

if self.curindex + 1 == len(self.stack):

print >>self.stdout, '*** Newest frame'

else:

self.curindex = self.curindex + 1

self.curframe = self.stack[self.curindex][0]

self.curframe_locals = self.curframe.f_locals

self.print_stack_entry(self.stack[self.curindex])

self.lineno = None

do_d = do_down

def do_until(self, arg):

self.set_until(self.curframe)

return 1

do_unt = do_until

def do_step(self, arg):

self.set_step()

return 1

do_s = do_step

def do_next(self, arg):

self.set_next(self.curframe)

return 1

do_n = do_next

def do_run(self, arg):

"""Restart program by raising an exception to be caught in the main

if arg:

import shlex

argv0 = sys.argv[0:1]

sys.argv = shlex.split(arg)

sys.argv[:0] = argv0

raise Restart

do_restart = do_run

def do_return(self, arg):

self.set_return(self.curframe)

return 1

do_r = do_return

def do_continue(self, arg):

self.set_continue()

return 1

do_c = do_cont = do_continue

def do_jump(self, arg):

if self.curindex + 1 != len(self.stack):

print >>self.stdout, "*** You can only jump within the bottom frame"

return

try:

arg = int(arg)

except ValueError:

print >>self.stdout, "*** The 'jump' command requires a line number."

else:

try:

# Do the jump, fix up our copy of the stack, and display the

# new position

self.curframe.f_lineno = arg

self.stack[self.curindex] = self.stack[self.curindex][0], arg

self.print_stack_entry(self.stack[self.curindex])

except ValueError, e:

print >>self.stdout, '*** Jump failed:', e

do_j = do_jump

def do_debug(self, arg):

sys.settrace(None)

globals = self.curframe.f_globals

locals = self.curframe_locals

p = Pdb(self.completekey, self.stdin, self.stdout)

p.prompt = "(%s) " % self.prompt.strip()

print >>self.stdout, "ENTERING RECURSIVE DEBUGGER"

sys.call_tracing(p.run, (arg, globals, locals))

print >>self.stdout, "LEAVING RECURSIVE DEBUGGER"

sys.settrace(self.trace_dispatch)

self.lastcmd = p.lastcmd

def do_quit(self, arg):

self._user_requested_quit = 1

self.set_quit()

return 1

do_q = do_quit

do_exit = do_quit

def do_EOF(self, arg):

print >>self.stdout

self._user_requested_quit = 1

self.set_quit()

return 1

def do_args(self, arg):

co = self.curframe.f_code

dict = self.curframe_locals

n = co.co_argcount

if co.co_flags & 4: n = n+1

if co.co_flags & 8: n = n+1

for i in range(n):

name = co.co_varnames[i]

print >>self.stdout, name, '=',

if name in dict: print >>self.stdout, dict[name]

else: print >>self.stdout, "*** undefined ***"

do_a = do_args

def do_retval(self, arg):

if '__return__' in self.curframe_locals:

print >>self.stdout, self.curframe_locals['__return__']

else:

print >>self.stdout, '*** Not yet returned!'

do_rv = do_retval

def _getval(self, arg):

try:

return eval(arg, self.curframe.f_globals,

self.curframe_locals)

except:

t, v = sys.exc_info()[:2]

if isinstance(t, str):

exc_type_name = t

else: exc_type_name = t.__name__

print >>self.stdout, '***', exc_type_name + ':', repr(v)

raise

def do_p(self, arg):

try:

print >>self.stdout, repr(self._getval(arg))

except:

pass

def do_pp(self, arg):

try:

pprint.pprint(self._getval(arg), self.stdout)

except:

pass

def do_list(self, arg):

self.lastcmd = 'list'

last = None

if arg:

try:

x = eval(arg, {}, {})

if type(x) == type(()):

first, last = x

first = int(first)

last = int(last)

if last < first:

# Assume it's a count

last = first + last

else:

first = max(1, int(x) - 5)

except:

print >>self.stdout, '*** Error in argument:', repr(arg)

return

elif self.lineno is None:

first = max(1, self.curframe.f_lineno - 5)

else:

first = self.lineno + 1

if last is None:

last = first + 10

filename = self.curframe.f_code.co_filename

breaklist = self.get_file_breaks(filename)

try:

for lineno in range(first, last+1):

line = linecache.getline(filename, lineno,

self.curframe.f_globals)

if not line:

print >>self.stdout, '[EOF]'

break

else:

s = repr(lineno).rjust(3)

if len(s) < 4: s = s + ' '

if lineno in breaklist: s = s + 'B'

else: s = s + ' '

if lineno == self.curframe.f_lineno:

s = s + '->'

print >>self.stdout, s + '\t' + line,

self.lineno = lineno

except KeyboardInterrupt:

pass

do_l = do_list

def do_whatis(self, arg):

try:

value = eval(arg, self.curframe.f_globals,

self.curframe_locals)

except:

t, v = sys.exc_info()[:2]

if type(t) == type(''):

exc_type_name = t

else: exc_type_name = t.__name__

print >>self.stdout, '***', exc_type_name + ':', repr(v)

return

code = None

# Is it a function?

try: code = value.func_code

except: pass

if code:

print >>self.stdout, 'Function', code.co_name

return

# Is it an instance method?

try: code = value.im_func.func_code

except: pass

if code:

print >>self.stdout, 'Method', code.co_name

return

# None of the above...

print >>self.stdout, type(value)

def do_alias(self, arg):

args = arg.split()

if len(args) == 0:

keys = self.aliases.keys()

keys.sort()

for alias in keys:

print >>self.stdout, "%s = %s" % (alias, self.aliases[alias])

return

if args[0] in self.aliases and len(args) == 1:

print >>self.stdout, "%s = %s" % (args[0], self.aliases[args[0]])

else:

self.aliases[args[0]] = ' '.join(args[1:])

def do_unalias(self, arg):

args = arg.split()

if len(args) == 0: return

if args[0] in self.aliases:

del self.aliases[args[0]]

#list of all the commands making the program resume execution.

commands_resuming = ['do_continue', 'do_step', 'do_next', 'do_return',

'do_quit', 'do_jump']

# Print a traceback starting at the top stack frame.

# The most recently entered frame is printed last;

# this is different from dbx and gdb, but consistent with

# the Python interpreter's stack trace.

# It is also consistent with the up/down commands (which are

# compatible with dbx and gdb: up moves towards 'main()'

# and down moves towards the most recent stack frame).

def print_stack_trace(self):

try:

for frame_lineno in self.stack:

self.print_stack_entry(frame_lineno)

except KeyboardInterrupt:

pass

def print_stack_entry(self, frame_lineno, prompt_prefix=line_prefix):

frame, lineno = frame_lineno

if frame is self.curframe:

print >>self.stdout, '>',

else:

print >>self.stdout, ' ',

print >>self.stdout, self.format_stack_entry(frame_lineno,

prompt_prefix)

# Help methods (derived from pdb.doc)

def help_help(self):

self.help_h()

def help_h(self):

print >>self.stdout, """h(elp)

def help_where(self):

self.help_w()

def help_w(self):

print >>self.stdout, """w(here)

help_bt = help_w

def help_down(self):

self.help_d()

def help_d(self):

print >>self.stdout, """d(own)

def help_up(self):

self.help_u()

def help_u(self):

print >>self.stdout, """u(p)

def help_break(self):

self.help_b()

def help_b(self):

print >>self.stdout, """b(reak) ([file:]lineno | function) [, condition]

def help_clear(self):

self.help_cl()

def help_cl(self):

print >>self.stdout, "cl(ear) filename:lineno"

print >>self.stdout, """cl(ear) [bpnumber [bpnumber...]]

def help_tbreak(self):

print >>self.stdout, """tbreak same arguments as break, but breakpoint

def help_enable(self):

print >>self.stdout, """enable bpnumber [bpnumber ...]

def help_disable(self):

print >>self.stdout, """disable bpnumber [bpnumber ...]

def help_ignore(self):

print >>self.stdout, """ignore bpnumber count

def help_condition(self):

print >>self.stdout, """condition bpnumber str_condition