1 #! /usr/bin/env python

     2 

     3 """A Python debugger."""

     4 

     5 # (See pdb.doc for documentation.)

     6 

     7 import sys

     8 import linecache

     9 import cmd

    10 import bdb

    11 from repr import Repr

    12 import os

    13 import re

    14 import pprint

    15 import traceback

    16 

    17 

    18 class Restart(Exception):

    19     """Causes a debugger to be restarted for the debugged python program."""

    20     pass

    21 

    22 # Create a custom safe Repr instance and increase its maxstring.

    23 # The default of 30 truncates error messages too easily.

    24 _repr = Repr()

    25 _repr.maxstring = 200

    26 _saferepr = _repr.repr

    27 

    28 __all__ = ["run", "pm", "Pdb", "runeval", "runctx", "runcall", "set_trace",

    29            "post_mortem", "help"]

    30 

    31 def find_function(funcname, filename):

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

    33     try:

    34         fp = open(filename)

    35     except IOError:

    36         return None

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

    38     lineno = 1

    39     answer = None

    40     while 1:

    41         line = fp.readline()

    42         if line == '':

    43             break

    44         if cre.match(line):

    45             answer = funcname, filename, lineno

    46             break

    47         lineno = lineno + 1

    48     fp.close()

    49     return answer

    50 

    51 

    52 # Interaction prompt line will separate file and call info from code

    53 # text using value of line_prefix string.  A newline and arrow may

    54 # be to your liking.  You can set it once pdb is imported using the

    55 # command "pdb.line_prefix = '\n% '".

    56 # line_prefix = ': '    # Use this to get the old situation back

    57 line_prefix = '\n-> '   # Probably a better default

    58 

    59 class Pdb(bdb.Bdb, cmd.Cmd):

    60 

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

    62         bdb.Bdb.__init__(self)

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

    64         if stdout:

    65             self.use_rawinput = 0

    66         self.prompt = '(Pdb) '

    67         self.aliases = {}

    68         self.mainpyfile = ''

    69         self._wait_for_mainpyfile = 0

    70         # Try to load readline if it exists

    71         try:

    72             import readline

    73         except ImportError:

    74             pass

    75 

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

    77         self.rcLines = []

    78         if 'HOME' in os.environ:

    79             envHome = os.environ['HOME']

    80             try:

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

    82             except IOError:

    83                 pass

    84             else:

    85                 for line in rcFile.readlines():

    86                     self.rcLines.append(line)

    87                 rcFile.close()

    88         try:

    89             rcFile = open(".pdbrc")

    90         except IOError:

    91             pass

    92         else:

    93             for line in rcFile.readlines():

    94                 self.rcLines.append(line)

    95             rcFile.close()

    96 

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

    98         self.commands_doprompt = {} # for each bp num, tells if the prompt must be disp. after execing the cmd list

    99         self.commands_silent = {} # for each bp num, tells if the stack trace must be disp. after execing the cmd list

   100         self.commands_defining = False # True while in the process of defining a command list

   101         self.commands_bnum = None # The breakpoint number for which we are defining a list

   102 

   103     def reset(self):

   104         bdb.Bdb.reset(self)

   105         self.forget()

   106 

   107     def forget(self):

   108         self.lineno = None

   109         self.stack = []

   110         self.curindex = 0

   111         self.curframe = None

   112 

   113     def setup(self, f, t):

   114         self.forget()

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

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

   117         self.execRcLines()

   118 

   119     # Can be executed earlier than 'setup' if desired

   120     def execRcLines(self):

   121         if self.rcLines:

   122             # Make local copy because of recursion

   123             rcLines = self.rcLines

   124             # executed only once

   125             self.rcLines = []

   126             for line in rcLines:

   127                 line = line[:-1]

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

   129                     self.onecmd(line)

   130 

   131     # Override Bdb methods

   132 

   133     def user_call(self, frame, argument_list):

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

   135         that we ever need to stop in this function."""

   136         if self._wait_for_mainpyfile:

   137             return

   138         if self.stop_here(frame):

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

   140             self.interaction(frame, None)

   141 

   142     def user_line(self, frame):

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

   144         if self._wait_for_mainpyfile:

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

   146                 or frame.f_lineno<= 0):

   147                 return

   148             self._wait_for_mainpyfile = 0

   149         if self.bp_commands(frame):

   150             self.interaction(frame, None)

   151 

   152     def bp_commands(self,frame):

   153         """ Call every command that was set for the current active breakpoint (if there is one)

   154         Returns True if the normal interaction function must be called, False otherwise """

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

   156         if getattr(self,"currentbp",False) and self.currentbp in self.commands:

   157             currentbp = self.currentbp

   158             self.currentbp = 0

   159             lastcmd_back = self.lastcmd

   160             self.setup(frame, None)

   161             for line in self.commands[currentbp]:

   162                 self.onecmd(line)

   163             self.lastcmd = lastcmd_back

   164             if not self.commands_silent[currentbp]:

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

   166             if self.commands_doprompt[currentbp]:

   167                 self.cmdloop()

   168             self.forget()

   169             return

   170         return 1

   171 

   172     def user_return(self, frame, return_value):

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

   174         frame.f_locals['__return__'] = return_value

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

   176         self.interaction(frame, None)

   177 

   178     def user_exception(self, frame, exc_info):

   179         exc_type, exc_value, exc_traceback = exc_info

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

   181         but only if we are to stop at or just below this level."""

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

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

   184             exc_type_name = exc_type

   185         else: exc_type_name = exc_type.__name__

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

   187         self.interaction(frame, exc_traceback)

   188 

   189     # General interaction function

   190 

   191     def interaction(self, frame, traceback):

   192         self.setup(frame, traceback)

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

   194         self.cmdloop()

   195         self.forget()

   196 

   197     def default(self, line):

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

   199         locals = self.curframe.f_locals

   200         globals = self.curframe.f_globals

   201         try:

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

   203             save_stdout = sys.stdout

   204             save_stdin = sys.stdin

   205             try:

   206                 sys.stdin = self.stdin

   207                 sys.stdout = self.stdout

   208                 exec code in globals, locals

   209             finally:

   210                 sys.stdout = save_stdout

   211                 sys.stdin = save_stdin

   212         except:

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

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

   215                 exc_type_name = t

   216             else: exc_type_name = t.__name__

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

   218 

   219     def precmd(self, line):

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

   221         if not line.strip():

   222             return line

   223         args = line.split()

   224         while args[0] in self.aliases:

   225             line = self.aliases[args[0]]

   226             ii = 1

   227             for tmpArg in args[1:]:

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

   229                                       tmpArg)

   230                 ii = ii + 1

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

   232             args = line.split()

   233         # split into ';;' separated commands

   234         # unless it's an alias command

   235         if args[0] != 'alias':

   236             marker = line.find(';;')

   237             if marker >= 0:

   238                 # queue up everything after marker

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

   240                 self.cmdqueue.append(next)

   241                 line = line[:marker].rstrip()

   242         return line

   243 

   244     def onecmd(self, line):

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

   246         to the prompt.

   247 

   248         Checks whether this line is typed at the normal prompt or in

   249         a breakpoint command list definition.

   250         """

   251         if not self.commands_defining:

   252             return cmd.Cmd.onecmd(self, line)

   253         else:

   254             return self.handle_command_def(line)

   255 

   256     def handle_command_def(self,line):

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

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

   259         if cmd == 'silent':

   260             self.commands_silent[self.commands_bnum] = True

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

   262         elif cmd == 'end':

   263             self.cmdqueue = []

   264             return 1 # end of cmd list

   265         cmdlist = self.commands[self.commands_bnum]

   266         if (arg):

   267             cmdlist.append(cmd+' '+arg)

   268         else:

   269             cmdlist.append(cmd)

   270         # Determine if we must stop

   271         try:

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

   273         except AttributeError:

   274             func = self.default

   275         if func.func_name in self.commands_resuming : # one of the resuming commands.

   276             self.commands_doprompt[self.commands_bnum] = False

   277             self.cmdqueue = []

   278             return 1

   279         return

   280 

   281     # Command definitions, called by cmdloop()

   282     # The argument is the remaining string on the command line

   283     # Return true to exit from the command loop

   284 

   285     do_h = cmd.Cmd.do_help

   286 

   287     def do_commands(self, arg):

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

   289         Those commands will be executed whenever the breakpoint causes the program to stop execution."""

   290         if not arg:

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

   292         else:

   293             try:

   294                 bnum = int(arg)

   295             except:

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

   297                 return

   298         self.commands_bnum = bnum

   299         self.commands[bnum] = []

   300         self.commands_doprompt[bnum] = True

   301         self.commands_silent[bnum] = False

   302         prompt_back = self.prompt

   303         self.prompt = '(com) '

   304         self.commands_defining = True

   305         self.cmdloop()

   306         self.commands_defining = False

   307         self.prompt = prompt_back

   308 

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

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

   311         if not arg:

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

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

   314                 for bp in bdb.Breakpoint.bpbynumber:

   315                     if bp:

   316                         bp.bpprint(self.stdout)

   317             return

   318         # parse arguments; comma has lowest precedence

   319         # and cannot occur in filename

   320         filename = None

   321         lineno = None

   322         cond = None

   323         comma = arg.find(',')

   324         if comma > 0:

   325             # parse stuff after comma: "condition"

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

   327             arg = arg[:comma].rstrip()

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

   329         colon = arg.rfind(':')

   330         funcname = None

   331         if colon >= 0:

   332             filename = arg[:colon].rstrip()

   333             f = self.lookupmodule(filename)

   334             if not f:

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

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

   337                 return

   338             else:

   339                 filename = f

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

   341             try:

   342                 lineno = int(arg)

   343             except ValueError, msg:

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

   345                 return

   346         else:

   347             # no colon; can be lineno or function

   348             try:

   349                 lineno = int(arg)

   350             except ValueError:

   351                 try:

   352                     func = eval(arg,

   353                                 self.curframe.f_globals,

   354                                 self.curframe.f_locals)

   355                 except:

   356                     func = arg

   357                 try:

   358                     if hasattr(func, 'im_func'):

   359                         func = func.im_func

   360                     code = func.func_code

   361                     #use co_name to identify the bkpt (function names

   362                     #could be aliased, but co_name is invariant)

   363                     funcname = code.co_name

   364                     lineno = code.co_firstlineno

   365                     filename = code.co_filename

   366                 except:

   367                     # last thing to try

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

   369                     if not ok:

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

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

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

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

   374                         return

   375                     funcname = ok # ok contains a function name

   376                     lineno = int(ln)

   377         if not filename:

   378             filename = self.defaultFile()

   379         # Check for reasonable breakpoint

   380         line = self.checkline(filename, lineno)

   381         if line:

   382             # now set the break point

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

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

   385             else:

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

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

   388                                                                  bp.file,

   389                                                                  bp.line)

   390 

   391     # To be overridden in derived debuggers

   392     def defaultFile(self):

   393         """Produce a reasonable default."""

   394         filename = self.curframe.f_code.co_filename

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

   396             filename = self.mainpyfile

   397         return filename

   398 

   399     do_b = do_break

   400 

   401     def do_tbreak(self, arg):

   402         self.do_break(arg, 1)

   403 

   404     def lineinfo(self, identifier):

   405         failed = (None, None, None)

   406         # Input is identifier, may be in single quotes

   407         idstring = identifier.split("'")

   408         if len(idstring) == 1:

   409             # not in single quotes

   410             id = idstring[0].strip()

   411         elif len(idstring) == 3:

   412             # quoted

   413             id = idstring[1].strip()

   414         else:

   415             return failed

   416         if id == '': return failed

   417         parts = id.split('.')

   418         # Protection for derived debuggers

   419         if parts[0] == 'self':

   420             del parts[0]

   421             if len(parts) == 0:

   422                 return failed

   423         # Best first guess at file to look at

   424         fname = self.defaultFile()

   425         if len(parts) == 1:

   426             item = parts[0]

   427         else:

   428             # More than one part.

   429             # First is module, second is method/class

   430             f = self.lookupmodule(parts[0])

   431             if f:

   432                 fname = f

   433             item = parts[1]

   434         answer = find_function(item, fname)

   435         return answer or failed

   436 

   437     def checkline(self, filename, lineno):

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

   439 

   440         Return `lineno` if it is, 0 if not (e.g. a docstring, comment, blank

   441         line or EOF). Warning: testing is not comprehensive.

   442         """

   443         line = linecache.getline(filename, lineno)

   444         if not line:

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

   446             return 0

   447         line = line.strip()

   448         # Don't allow setting breakpoint at a blank line

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

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

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

   452             return 0

   453         return lineno

   454 

   455     def do_enable(self, arg):

   456         args = arg.split()

   457         for i in args:

   458             try:

   459                 i = int(i)

   460             except ValueError:

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

   462                 continue

   463 

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

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

   466                 continue

   467 

   468             bp = bdb.Breakpoint.bpbynumber[i]

   469             if bp:

   470                 bp.enable()

   471 

   472     def do_disable(self, arg):

   473         args = arg.split()

   474         for i in args:

   475             try:

   476                 i = int(i)

   477             except ValueError:

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

   479                 continue

   480 

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

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

   483                 continue

   484 

   485             bp = bdb.Breakpoint.bpbynumber[i]

   486             if bp:

   487                 bp.disable()

   488 

   489     def do_condition(self, arg):

   490         # arg is breakpoint number and condition

   491         args = arg.split(' ', 1)

   492         try:

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

   494         except ValueError:

   495             # something went wrong

   496             print >>self.stdout, \

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

   498             return

   499         try:

   500             cond = args[1]

   501         except:

   502             cond = None

   503         try:

   504             bp = bdb.Breakpoint.bpbynumber[bpnum]

   505         except IndexError:

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

   507             return

   508         if bp:

   509             bp.cond = cond

   510             if not cond:

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

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

   513 

   514     def do_ignore(self,arg):

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

   516         args = arg.split()

   517         try:

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

   519         except ValueError:

   520             # something went wrong

   521             print >>self.stdout, \

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

   523             return

   524         try:

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

   526         except:

   527             count = 0

   528         try:

   529             bp = bdb.Breakpoint.bpbynumber[bpnum]

   530         except IndexError:

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

   532             return

   533         if bp:

   534             bp.ignore = count

   535             if count > 0:

   536                 reply = 'Will ignore next '

   537                 if count > 1:

   538                     reply = reply + '%d crossings' % count

   539                 else:

   540                     reply = reply + '1 crossing'

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

   542             else:

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

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

   545 

   546     def do_clear(self, arg):

   547         """Three possibilities, tried in this order:

   548         clear -> clear all breaks, ask for confirmation

   549         clear file:lineno -> clear all breaks at file:lineno

   550         clear bpno bpno ... -> clear breakpoints by number"""

   551         if not arg:

   552             try:

   553                 reply = raw_input('Clear all breaks? ')

   554             except EOFError:

   555                 reply = 'no'

   556             reply = reply.strip().lower()

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

   558                 self.clear_all_breaks()

   559             return

   560         if ':' in arg:

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

   562             i = arg.rfind(':')

   563             filename = arg[:i]

   564             arg = arg[i+1:]

   565             try:

   566                 lineno = int(arg)

   567             except ValueError:

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

   569             else:

   570                 err = self.clear_break(filename, lineno)

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

   572             return

   573         numberlist = arg.split()

   574         for i in numberlist:

   575             try:

   576                 i = int(i)

   577             except ValueError:

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

   579                 continue

   580 

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

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

   583                 continue

   584             err = self.clear_bpbynumber(i)

   585             if err:

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

   587             else:

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

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

   590 

   591     def do_where(self, arg):

   592         self.print_stack_trace()

   593     do_w = do_where

   594     do_bt = do_where

   595 

   596     def do_up(self, arg):

   597         if self.curindex == 0:

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

   599         else:

   600             self.curindex = self.curindex - 1

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

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

   603             self.lineno = None

   604     do_u = do_up

   605 

   606     def do_down(self, arg):

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

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

   609         else:

   610             self.curindex = self.curindex + 1

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

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

   613             self.lineno = None

   614     do_d = do_down

   615 

   616     def do_until(self, arg):

   617         self.set_until(self.curframe)

   618         return 1

   619     do_unt = do_until

   620 

   621     def do_step(self, arg):

   622         self.set_step()

   623         return 1

   624     do_s = do_step

   625 

   626     def do_next(self, arg):

   627         self.set_next(self.curframe)

   628         return 1

   629     do_n = do_next

   630 

   631     def do_run(self, arg):

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

   633         loop. If arguments were given, set them in sys.argv."""

   634         if arg:

   635             import shlex

   636             argv0 = sys.argv[0:1]

   637             sys.argv = shlex.split(arg)

   638             sys.argv[:0] = argv0

   639         raise Restart

   640 

   641     do_restart = do_run

   642 

   643     def do_return(self, arg):

   644         self.set_return(self.curframe)

   645         return 1

   646     do_r = do_return

   647 

   648     def do_continue(self, arg):

   649         self.set_continue()

   650         return 1

   651     do_c = do_cont = do_continue

   652 

   653     def do_jump(self, arg):

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

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

   656             return

   657         try:

   658             arg = int(arg)

   659         except ValueError:

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

   661         else:

   662             try:

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

   664                 # new position

   665                 self.curframe.f_lineno = arg

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

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

   668             except ValueError, e:

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

   670     do_j = do_jump

   671 

   672     def do_debug(self, arg):

   673         sys.settrace(None)

   674         globals = self.curframe.f_globals

   675         locals = self.curframe.f_locals

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

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

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

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

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

   681         sys.settrace(self.trace_dispatch)

   682         self.lastcmd = p.lastcmd

   683 

   684     def do_quit(self, arg):

   685         self._user_requested_quit = 1

   686         self.set_quit()

   687         return 1

   688 

   689     do_q = do_quit

   690     do_exit = do_quit

   691 

   692     def do_EOF(self, arg):

   693         print >>self.stdout

   694         self._user_requested_quit = 1

   695         self.set_quit()

   696         return 1

   697 

   698     def do_args(self, arg):

   699         f = self.curframe

   700         co = f.f_code

   701         dict = f.f_locals

   702         n = co.co_argcount

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

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

   705         for i in range(n):

   706             name = co.co_varnames[i]

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

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

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

   710     do_a = do_args

   711 

   712     def do_retval(self, arg):

   713         if '__return__' in self.curframe.f_locals:

   714             print >>self.stdout, self.curframe.f_locals['__return__']

   715         else:

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

   717     do_rv = do_retval

   718 

   719     def _getval(self, arg):

   720         try:

   721             return eval(arg, self.curframe.f_globals,

   722                         self.curframe.f_locals)

   723         except:

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

   725             if isinstance(t, str):

   726                 exc_type_name = t

   727             else: exc_type_name = t.__name__

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

   729             raise

   730 

   731     def do_p(self, arg):

   732         try:

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

   734         except:

   735             pass

   736 

   737     def do_pp(self, arg):

   738         try:

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

   740         except:

   741             pass

   742 

   743     def do_list(self, arg):

   744         self.lastcmd = 'list'

   745         last = None

   746         if arg:

   747             try:

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

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

   750                     first, last = x

   751                     first = int(first)

   752                     last = int(last)

   753                     if last < first:

   754                         # Assume it's a count

   755                         last = first + last

   756                 else:

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

   758             except:

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

   760                 return

   761         elif self.lineno is None:

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

   763         else:

   764             first = self.lineno + 1

   765         if last is None:

   766             last = first + 10

   767         filename = self.curframe.f_code.co_filename

   768         breaklist = self.get_file_breaks(filename)

   769         try:

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

   771                 line = linecache.getline(filename, lineno)

   772                 if not line:

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

   774                     break

   775                 else:

   776                     s = repr(lineno).rjust(3)

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

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

   779                     else: s = s + ' '

   780                     if lineno == self.curframe.f_lineno:

   781                         s = s + '->'

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

   783                     self.lineno = lineno

   784         except KeyboardInterrupt:

   785             pass

   786     do_l = do_list

   787 

   788     def do_whatis(self, arg):

   789         try:

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

   791                             self.curframe.f_locals)

   792         except:

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

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

   795                 exc_type_name = t

   796             else: exc_type_name = t.__name__

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

   798             return

   799         code = None

   800         # Is it a function?

   801         try: code = value.func_code

   802         except: pass

   803         if code:

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

   805             return

   806         # Is it an instance method?

   807         try: code = value.im_func.func_code

   808         except: pass

   809         if code:

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

   811             return

   812         # None of the above...

   813         print >>self.stdout, type(value)

   814 

   815     def do_alias(self, arg):

   816         args = arg.split()

   817         if len(args) == 0:

   818             keys = self.aliases.keys()

   819             keys.sort()

   820             for alias in keys:

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

   822             return

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

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

   825         else:

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

   827 

   828     def do_unalias(self, arg):

   829         args = arg.split()

   830         if len(args) == 0: return

   831         if args[0] in self.aliases:

   832             del self.aliases[args[0]]

   833 

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

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

   836                          'do_quit', 'do_jump']

   837 

   838     # Print a traceback starting at the top stack frame.

   839     # The most recently entered frame is printed last;

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

   841     # the Python interpreter's stack trace.

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

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

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

   845 

   846     def print_stack_trace(self):

   847         try:

   848             for frame_lineno in self.stack:

   849                 self.print_stack_entry(frame_lineno)

   850         except KeyboardInterrupt:

   851             pass

   852 

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

   854         frame, lineno = frame_lineno

   855         if frame is self.curframe:

   856             print >>self.stdout, '>',

   857         else:

   858             print >>self.stdout, ' ',

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

   860                                                      prompt_prefix)

   861 

   862 

   863     # Help methods (derived from pdb.doc)

   864 

   865     def help_help(self):

   866         self.help_h()

   867 

   868     def help_h(self):

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

   870 Without argument, print the list of available commands.

   871 With a command name as argument, print help about that command

   872 "help pdb" pipes the full documentation file to the $PAGER

   873 "help exec" gives help on the ! command"""

   874 

   875     def help_where(self):

   876         self.help_w()

   877 

   878     def help_w(self):

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

   880 Print a stack trace, with the most recent frame at the bottom.

   881 An arrow indicates the "current frame", which determines the

   882 context of most commands.  'bt' is an alias for this command."""

   883 

   884     help_bt = help_w

   885 

   886     def help_down(self):

   887         self.help_d()

   888 

   889     def help_d(self):

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

   891 Move the current frame one level down in the stack trace

   892 (to a newer frame)."""

   893 

   894     def help_up(self):

   895         self.help_u()

   896 

   897     def help_u(self):

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

   899 Move the current frame one level up in the stack trace

   900 (to an older frame)."""

   901 

   902     def help_break(self):

   903         self.help_b()

   904 

   905     def help_b(self):

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

   907 With a line number argument, set a break there in the current

   908 file.  With a function name, set a break at first executable line

   909 of that function.  Without argument, list all breaks.  If a second

   910 argument is present, it is a string specifying an expression

   911 which must evaluate to true before the breakpoint is honored.

   912 

   913 The line number may be prefixed with a filename and a colon,

   914 to specify a breakpoint in another file (probably one that

   915 hasn't been loaded yet).  The file is searched for on sys.path;

   916 the .py suffix may be omitted."""

   917 

   918     def help_clear(self):

   919         self.help_cl()

   920 

   921     def help_cl(self):

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

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

   924 With a space separated list of breakpoint numbers, clear

   925 those breakpoints.  Without argument, clear all breaks (but

   926 first ask confirmation).  With a filename:lineno argument,

   927 clear all breaks at that line in that file.

   928 

   929 Note that the argument is different from previous versions of

   930 the debugger (in python distributions 1.5.1 and before) where

   931 a linenumber was used instead of either filename:lineno or

   932 breakpoint numbers."""

   933 

   934     def help_tbreak(self):

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

   936 removed when first hit."""

   937 

   938     def help_enable(self):

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

   940 Enables the breakpoints given as a space separated list of

   941 bp numbers."""

   942 

   943     def help_disable(self):

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

   945 Disables the breakpoints given as a space separated list of

   946 bp numbers."""

   947 

   948     def help_ignore(self):

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

   950 Sets the ignore count for the given breakpoint number.  A breakpoint

   951 becomes active when the ignore count is zero.  When non-zero, the

   952 count is decremented each time the breakpoint is reached and the

   953 breakpoint is not disabled and any associated condition evaluates

   954 to true."""

   955 

   956     def help_condition(self):

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

   958 str_condition is a string specifying an expression which

   959 must evaluate to true before the breakpoint is honored.

   960 If str_condition is absent, any existing condition is removed;

   961 i.e., the breakpoint is made unconditional."""

   962 

   963     def help_step(self):

   964         self.help_s()

   965 

   966     def help_s(self):

   967         print >>self.stdout, """s(tep)

   968 Execute the current line, stop at the first possible occasion

   969 (either in a function that is called or in the current function)."""

   970 

   971     def help_until(self):

   972         self.help_unt()

   973 

   974     def help_unt(self):

   975         print """unt(il)

   976 Continue execution until the line with a number greater than the current

   977 one is reached or until the current frame returns"""

   978 

   979     def help_next(self):

   980         self.help_n()

   981 

   982     def help_n(self):

   983         print >>self.stdout, """n(ext)

   984 Continue execution until the next line in the current function

   985 is reached or it returns."""

   986 

   987     def help_return(self):

   988         self.help_r()

   989 

   990     def help_r(self):

   991         print >>self.stdout, """r(eturn)

   992 Continue execution until the current function returns."""

   993 

   994     def help_continue(self):

   995         self.help_c()

   996 

   997     def help_cont(self):

   998         self.help_c()

   999 

  1000     def help_c(self):

  1001         print >>self.stdout, """c(ont(inue))

  1002 Continue execution, only stop when a breakpoint is encountered."""

  1003 

  1004     def help_jump(self):

  1005         self.help_j()

  1006 

  1007     def help_j(self):

  1008         print >>self.stdout, """j(ump) lineno

  1009 Set the next line that will be executed."""

  1010 

  1011     def help_debug(self):

  1012         print >>self.stdout, """debug code

  1013 Enter a recursive debugger that steps through the code argument

  1014 (which is an arbitrary expression or statement to be executed

  1015 in the current environment)."""

  1016 

  1017     def help_list(self):

  1018         self.help_l()

  1019 

  1020     def help_l(self):

  1021         print >>self.stdout, """l(ist) [first [,last]]

  1022 List source code for the current file.

  1023 Without arguments, list 11 lines around the current line

  1024 or continue the previous listing.

  1025 With one argument, list 11 lines starting at that line.

  1026 With two arguments, list the given range;

  1027 if the second argument is less than the first, it is a count."""

  1028 

  1029     def help_args(self):

  1030         self.help_a()

  1031 

  1032     def help_a(self):

  1033         print >>self.stdout, """a(rgs)

  1034 Print the arguments of the current function."""

  1035 

  1036     def help_p(self):

  1037         print >>self.stdout, """p expression

  1038 Print the value of the expression."""

  1039 

  1040     def help_pp(self):

  1041         print >>self.stdout, """pp expression

  1042 Pretty-print the value of the expression."""

  1043 

  1044     def help_exec(self):

  1045         print >>self.stdout, """(!) statement

  1046 Execute the (one-line) statement in the context of

  1047 the current stack frame.

  1048 The exclamation point can be omitted unless the first word

  1049 of the statement resembles a debugger command.

  1050 To assign to a global variable you must always prefix the

  1051 command with a 'global' command, e.g.:

  1052 (Pdb) global list_options; list_options = ['-l']

  1053 (Pdb)"""

  1054 

  1055     def help_run(self):

  1056         print """run [args...]

  1057 Restart the debugged python program. If a string is supplied, it is

  1058 splitted with "shlex" and the result is used as the new sys.argv.

  1059 History, breakpoints, actions and debugger options are preserved.

  1060 "restart" is an alias for "run"."""

  1061 

  1062     help_restart = help_run

  1063 

  1064     def help_quit(self):

  1065         self.help_q()

  1066 

  1067     def help_q(self):

  1068         print >>self.stdout, """q(uit) or exit - Quit from the debugger.

  1069 The program being executed is aborted."""

  1070 

  1071     help_exit = help_q

  1072 

  1073     def help_whatis(self):

  1074         print >>self.stdout, """whatis arg

  1075 Prints the type of the argument."""

  1076 

  1077     def help_EOF(self):

  1078         print >>self.stdout, """EOF

  1079 Handles the receipt of EOF as a command."""

  1080 

  1081     def help_alias(self):

  1082         print >>self.stdout, """alias [name [command [parameter parameter ...] ]]

  1083 Creates an alias called 'name' the executes 'command'.  The command

  1084 must *not* be enclosed in quotes.  Replaceable parameters are

  1085 indicated by %1, %2, and so on, while %* is replaced by all the

  1086 parameters.  If no command is given, the current alias for name

  1087 is shown. If no name is given, all aliases are listed.

  1088 

  1089 Aliases may be nested and can contain anything that can be

  1090 legally typed at the pdb prompt.  Note!  You *can* override

  1091 internal pdb commands with aliases!  Those internal commands

  1092 are then hidden until the alias is removed.  Aliasing is recursively

  1093 applied to the first word of the command line; all other words

  1094 in the line are left alone.

  1095 

  1096 Some useful aliases (especially when placed in the .pdbrc file) are:

  1097 

  1098 #Print instance variables (usage "pi classInst")

  1099 alias pi for k in %1.__dict__.keys(): print "%1.",k,"=",%1.__dict__[k]

  1100 

  1101 #Print instance variables in self

  1102 alias ps pi self

  1103 """

  1104 

  1105     def help_unalias(self):

  1106         print >>self.stdout, """unalias name

  1107 Deletes the specified alias."""

  1108 

  1109     def help_commands(self):

  1110         print >>self.stdout, """commands [bpnumber]

  1111 (com) ...

  1112 (com) end

  1113 (Pdb)

  1114 

  1115 Specify a list of commands for breakpoint number bpnumber.  The

  1116 commands themselves appear on the following lines.  Type a line

  1117 containing just 'end' to terminate the commands.

  1118 

  1119 To remove all commands from a breakpoint, type commands and

  1120 follow it immediately with  end; that is, give no commands.

  1121 

  1122 With no bpnumber argument, commands refers to the last

  1123 breakpoint set.

  1124 

  1125 You can use breakpoint commands to start your program up again.

  1126 Simply use the continue command, or step, or any other

  1127 command that resumes execution.

  1128 

  1129 Specifying any command resuming execution (currently continue,

  1130 step, next, return, jump, quit and their abbreviations) terminates

  1131 the command list (as if that command was immediately followed by end).

  1132 This is because any time you resume execution

  1133 (even with a simple next or step), you may encounter

  1134 another breakpoint--which could have its own command list, leading to

  1135 ambiguities about which list to execute.