Home | History | Annotate | Download | only in python2.7
      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, skip=None):
     62         bdb.Bdb.__init__(self, skip=skip)
     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
     99                                     # must be disp. after execing the cmd list
    100         self.commands_silent = {} # for each bp num, tells if the stack trace
    101                                   # must be disp. after execing the cmd list
    102         self.commands_defining = False # True while in the process of defining
    103                                        # a command list
    104         self.commands_bnum = None # The breakpoint number for which we are
    105                                   # defining a list
    106 
    107     def reset(self):
    108         bdb.Bdb.reset(self)
    109         self.forget()
    110 
    111     def forget(self):
    112         self.lineno = None
    113         self.stack = []
    114         self.curindex = 0
    115         self.curframe = None
    116 
    117     def setup(self, f, t):
    118         self.forget()
    119         self.stack, self.curindex = self.get_stack(f, t)
    120         self.curframe = self.stack[self.curindex][0]
    121         # The f_locals dictionary is updated from the actual frame
    122         # locals whenever the .f_locals accessor is called, so we
    123         # cache it here to ensure that modifications are not overwritten.
    124         self.curframe_locals = self.curframe.f_locals
    125         self.execRcLines()
    126 
    127     # Can be executed earlier than 'setup' if desired
    128     def execRcLines(self):
    129         if self.rcLines:
    130             # Make local copy because of recursion
    131             rcLines = self.rcLines
    132             # executed only once
    133             self.rcLines = []
    134             for line in rcLines:
    135                 line = line[:-1]
    136                 if len(line) > 0 and line[0] != '#':
    137                     self.onecmd(line)
    138 
    139     # Override Bdb methods
    140 
    141     def user_call(self, frame, argument_list):
    142         """This method is called when there is the remote possibility
    143         that we ever need to stop in this function."""
    144         if self._wait_for_mainpyfile:
    145             return
    146         if self.stop_here(frame):
    147             print >>self.stdout, '--Call--'
    148             self.interaction(frame, None)
    149 
    150     def user_line(self, frame):
    151         """This function is called when we stop or break at this line."""
    152         if self._wait_for_mainpyfile:
    153             if (self.mainpyfile != self.canonic(frame.f_code.co_filename)
    154                 or frame.f_lineno<= 0):
    155                 return
    156             self._wait_for_mainpyfile = 0
    157         if self.bp_commands(frame):
    158             self.interaction(frame, None)
    159 
    160     def bp_commands(self,frame):
    161         """Call every command that was set for the current active breakpoint
    162         (if there is one).
    163 
    164         Returns True if the normal interaction function must be called,
    165         False otherwise."""
    166         # self.currentbp is set in bdb in Bdb.break_here if a breakpoint was hit
    167         if getattr(self, "currentbp", False) and \
    168                self.currentbp in self.commands:
    169             currentbp = self.currentbp
    170             self.currentbp = 0
    171             lastcmd_back = self.lastcmd
    172             self.setup(frame, None)
    173             for line in self.commands[currentbp]:
    174                 self.onecmd(line)
    175             self.lastcmd = lastcmd_back
    176             if not self.commands_silent[currentbp]:
    177                 self.print_stack_entry(self.stack[self.curindex])
    178             if self.commands_doprompt[currentbp]:
    179                 self.cmdloop()
    180             self.forget()
    181             return
    182         return 1
    183 
    184     def user_return(self, frame, return_value):
    185         """This function is called when a return trap is set here."""
    186         if self._wait_for_mainpyfile:
    187             return
    188         frame.f_locals['__return__'] = return_value
    189         print >>self.stdout, '--Return--'
    190         self.interaction(frame, None)
    191 
    192     def user_exception(self, frame, exc_info):
    193         """This function is called if an exception occurs,
    194         but only if we are to stop at or just below this level."""
    195         if self._wait_for_mainpyfile:
    196             return
    197         exc_type, exc_value, exc_traceback = exc_info
    198         frame.f_locals['__exception__'] = exc_type, exc_value
    199         if type(exc_type) == type(''):
    200             exc_type_name = exc_type
    201         else: exc_type_name = exc_type.__name__
    202         print >>self.stdout, exc_type_name + ':', _saferepr(exc_value)
    203         self.interaction(frame, exc_traceback)
    204 
    205     # General interaction function
    206 
    207     def interaction(self, frame, traceback):
    208         self.setup(frame, traceback)
    209         self.print_stack_entry(self.stack[self.curindex])
    210         self.cmdloop()
    211         self.forget()
    212 
    213     def displayhook(self, obj):
    214         """Custom displayhook for the exec in default(), which prevents
    215         assignment of the _ variable in the builtins.
    216         """
    217         # reproduce the behavior of the standard displayhook, not printing None
    218         if obj is not None:
    219             print repr(obj)
    220 
    221     def default(self, line):
    222         if line[:1] == '!': line = line[1:]
    223         locals = self.curframe_locals
    224         globals = self.curframe.f_globals
    225         try:
    226             code = compile(line + '\n', '<stdin>', 'single')
    227             save_stdout = sys.stdout
    228             save_stdin = sys.stdin
    229             save_displayhook = sys.displayhook
    230             try:
    231                 sys.stdin = self.stdin
    232                 sys.stdout = self.stdout
    233                 sys.displayhook = self.displayhook
    234                 exec code in globals, locals
    235             finally:
    236                 sys.stdout = save_stdout
    237                 sys.stdin = save_stdin
    238                 sys.displayhook = save_displayhook
    239         except:
    240             t, v = sys.exc_info()[:2]
    241             if type(t) == type(''):
    242                 exc_type_name = t
    243             else: exc_type_name = t.__name__
    244             print >>self.stdout, '***', exc_type_name + ':', v
    245 
    246     def precmd(self, line):
    247         """Handle alias expansion and ';;' separator."""
    248         if not line.strip():
    249             return line
    250         args = line.split()
    251         while args[0] in self.aliases:
    252             line = self.aliases[args[0]]
    253             ii = 1
    254             for tmpArg in args[1:]:
    255                 line = line.replace("%" + str(ii),
    256                                       tmpArg)
    257                 ii = ii + 1
    258             line = line.replace("%*", ' '.join(args[1:]))
    259             args = line.split()
    260         # split into ';;' separated commands
    261         # unless it's an alias command
    262         if args[0] != 'alias':
    263             marker = line.find(';;')
    264             if marker >= 0:
    265                 # queue up everything after marker
    266                 next = line[marker+2:].lstrip()
    267                 self.cmdqueue.append(next)
    268                 line = line[:marker].rstrip()
    269         return line
    270 
    271     def onecmd(self, line):
    272         """Interpret the argument as though it had been typed in response
    273         to the prompt.
    274 
    275         Checks whether this line is typed at the normal prompt or in
    276         a breakpoint command list definition.
    277         """
    278         if not self.commands_defining:
    279             return cmd.Cmd.onecmd(self, line)
    280         else:
    281             return self.handle_command_def(line)
    282 
    283     def handle_command_def(self,line):
    284         """Handles one command line during command list definition."""
    285         cmd, arg, line = self.parseline(line)
    286         if not cmd:
    287             return
    288         if cmd == 'silent':
    289             self.commands_silent[self.commands_bnum] = True
    290             return # continue to handle other cmd def in the cmd list
    291         elif cmd == 'end':
    292             self.cmdqueue = []
    293             return 1 # end of cmd list
    294         cmdlist = self.commands[self.commands_bnum]
    295         if arg:
    296             cmdlist.append(cmd+' '+arg)
    297         else:
    298             cmdlist.append(cmd)
    299         # Determine if we must stop
    300         try:
    301             func = getattr(self, 'do_' + cmd)
    302         except AttributeError:
    303             func = self.default
    304         # one of the resuming commands
    305         if func.func_name in self.commands_resuming:
    306             self.commands_doprompt[self.commands_bnum] = False
    307             self.cmdqueue = []
    308             return 1
    309         return
    310 
    311     # Command definitions, called by cmdloop()
    312     # The argument is the remaining string on the command line
    313     # Return true to exit from the command loop
    314 
    315     do_h = cmd.Cmd.do_help
    316 
    317     def do_commands(self, arg):
    318         """Defines a list of commands associated to a breakpoint.
    319 
    320         Those commands will be executed whenever the breakpoint causes
    321         the program to stop execution."""
    322         if not arg:
    323             bnum = len(bdb.Breakpoint.bpbynumber)-1
    324         else:
    325             try:
    326                 bnum = int(arg)
    327             except:
    328                 print >>self.stdout, "Usage : commands [bnum]\n        ..." \
    329                                      "\n        end"
    330                 return
    331         self.commands_bnum = bnum
    332         self.commands[bnum] = []
    333         self.commands_doprompt[bnum] = True
    334         self.commands_silent[bnum] = False
    335         prompt_back = self.prompt
    336         self.prompt = '(com) '
    337         self.commands_defining = True
    338         try:
    339             self.cmdloop()
    340         finally:
    341             self.commands_defining = False
    342             self.prompt = prompt_back
    343 
    344     def do_break(self, arg, temporary = 0):
    345         # break [ ([filename:]lineno | function) [, "condition"] ]
    346         if not arg:
    347             if self.breaks:  # There's at least one
    348                 print >>self.stdout, "Num Type         Disp Enb   Where"
    349                 for bp in bdb.Breakpoint.bpbynumber:
    350                     if bp:
    351                         bp.bpprint(self.stdout)
    352             return
    353         # parse arguments; comma has lowest precedence
    354         # and cannot occur in filename
    355         filename = None
    356         lineno = None
    357         cond = None
    358         comma = arg.find(',')
    359         if comma > 0:
    360             # parse stuff after comma: "condition"
    361             cond = arg[comma+1:].lstrip()
    362             arg = arg[:comma].rstrip()
    363         # parse stuff before comma: [filename:]lineno | function
    364         colon = arg.rfind(':')
    365         funcname = None
    366         if colon >= 0:
    367             filename = arg[:colon].rstrip()
    368             f = self.lookupmodule(filename)
    369             if not f:
    370                 print >>self.stdout, '*** ', repr(filename),
    371                 print >>self.stdout, 'not found from sys.path'
    372                 return
    373             else:
    374                 filename = f
    375             arg = arg[colon+1:].lstrip()
    376             try:
    377                 lineno = int(arg)
    378             except ValueError, msg:
    379                 print >>self.stdout, '*** Bad lineno:', arg
    380                 return
    381         else:
    382             # no colon; can be lineno or function
    383             try:
    384                 lineno = int(arg)
    385             except ValueError:
    386                 try:
    387                     func = eval(arg,
    388                                 self.curframe.f_globals,
    389                                 self.curframe_locals)
    390                 except:
    391                     func = arg
    392                 try:
    393                     if hasattr(func, 'im_func'):
    394                         func = func.im_func
    395                     code = func.func_code
    396                     #use co_name to identify the bkpt (function names
    397                     #could be aliased, but co_name is invariant)
    398                     funcname = code.co_name
    399                     lineno = code.co_firstlineno
    400                     filename = code.co_filename
    401                 except:
    402                     # last thing to try
    403                     (ok, filename, ln) = self.lineinfo(arg)
    404                     if not ok:
    405                         print >>self.stdout, '*** The specified object',
    406                         print >>self.stdout, repr(arg),
    407                         print >>self.stdout, 'is not a function'
    408                         print >>self.stdout, 'or was not found along sys.path.'
    409                         return
    410                     funcname = ok # ok contains a function name
    411                     lineno = int(ln)
    412         if not filename:
    413             filename = self.defaultFile()
    414         # Check for reasonable breakpoint
    415         line = self.checkline(filename, lineno)
    416         if line:
    417             # now set the break point
    418             err = self.set_break(filename, line, temporary, cond, funcname)
    419             if err: print >>self.stdout, '***', err
    420             else:
    421                 bp = self.get_breaks(filename, line)[-1]
    422                 print >>self.stdout, "Breakpoint %d at %s:%d" % (bp.number,
    423                                                                  bp.file,
    424                                                                  bp.line)
    425 
    426     # To be overridden in derived debuggers
    427     def defaultFile(self):
    428         """Produce a reasonable default."""
    429         filename = self.curframe.f_code.co_filename
    430         if filename == '<string>' and self.mainpyfile:
    431             filename = self.mainpyfile
    432         return filename
    433 
    434     do_b = do_break
    435 
    436     def do_tbreak(self, arg):
    437         self.do_break(arg, 1)
    438 
    439     def lineinfo(self, identifier):
    440         failed = (None, None, None)
    441         # Input is identifier, may be in single quotes
    442         idstring = identifier.split("'")
    443         if len(idstring) == 1:
    444             # not in single quotes
    445             id = idstring[0].strip()
    446         elif len(idstring) == 3:
    447             # quoted
    448             id = idstring[1].strip()
    449         else:
    450             return failed
    451         if id == '': return failed
    452         parts = id.split('.')
    453         # Protection for derived debuggers
    454         if parts[0] == 'self':
    455             del parts[0]
    456             if len(parts) == 0:
    457                 return failed
    458         # Best first guess at file to look at
    459         fname = self.defaultFile()
    460         if len(parts) == 1:
    461             item = parts[0]
    462         else:
    463             # More than one part.
    464             # First is module, second is method/class
    465             f = self.lookupmodule(parts[0])
    466             if f:
    467                 fname = f
    468             item = parts[1]
    469         answer = find_function(item, fname)
    470         return answer or failed
    471 
    472     def checkline(self, filename, lineno):
    473         """Check whether specified line seems to be executable.
    474 
    475         Return `lineno` if it is, 0 if not (e.g. a docstring, comment, blank
    476         line or EOF). Warning: testing is not comprehensive.
    477         """
    478         # this method should be callable before starting debugging, so default
    479         # to "no globals" if there is no current frame
    480         globs = self.curframe.f_globals if hasattr(self, 'curframe') else None
    481         line = linecache.getline(filename, lineno, globs)
    482         if not line:
    483             print >>self.stdout, 'End of file'
    484             return 0
    485         line = line.strip()
    486         # Don't allow setting breakpoint at a blank line
    487         if (not line or (line[0] == '#') or
    488              (line[:3] == '"""') or line[:3] == "'''"):
    489             print >>self.stdout, '*** Blank or comment'
    490             return 0
    491         return lineno
    492 
    493     def do_enable(self, arg):
    494         args = arg.split()
    495         for i in args:
    496             try:
    497                 i = int(i)
    498             except ValueError:
    499                 print >>self.stdout, 'Breakpoint index %r is not a number' % i
    500                 continue
    501 
    502             if not (0 <= i < len(bdb.Breakpoint.bpbynumber)):
    503                 print >>self.stdout, 'No breakpoint numbered', i
    504                 continue
    505 
    506             bp = bdb.Breakpoint.bpbynumber[i]
    507             if bp:
    508                 bp.enable()
    509 
    510     def do_disable(self, arg):
    511         args = arg.split()
    512         for i in args:
    513             try:
    514                 i = int(i)
    515             except ValueError:
    516                 print >>self.stdout, 'Breakpoint index %r is not a number' % i
    517                 continue
    518 
    519             if not (0 <= i < len(bdb.Breakpoint.bpbynumber)):
    520                 print >>self.stdout, 'No breakpoint numbered', i
    521                 continue
    522 
    523             bp = bdb.Breakpoint.bpbynumber[i]
    524             if bp:
    525                 bp.disable()
    526 
    527     def do_condition(self, arg):
    528         # arg is breakpoint number and condition
    529         args = arg.split(' ', 1)
    530         try:
    531             bpnum = int(args[0].strip())
    532         except ValueError:
    533             # something went wrong
    534             print >>self.stdout, \
    535                 'Breakpoint index %r is not a number' % args[0]
    536             return
    537         try:
    538             cond = args[1]
    539         except:
    540             cond = None
    541         try:
    542             bp = bdb.Breakpoint.bpbynumber[bpnum]
    543         except IndexError:
    544             print >>self.stdout, 'Breakpoint index %r is not valid' % args[0]
    545             return
    546         if bp:
    547             bp.cond = cond
    548             if not cond:
    549                 print >>self.stdout, 'Breakpoint', bpnum,
    550                 print >>self.stdout, 'is now unconditional.'
    551 
    552     def do_ignore(self,arg):
    553         """arg is bp number followed by ignore count."""
    554         args = arg.split()
    555         try:
    556             bpnum = int(args[0].strip())
    557         except ValueError:
    558             # something went wrong
    559             print >>self.stdout, \
    560                 'Breakpoint index %r is not a number' % args[0]
    561             return
    562         try:
    563             count = int(args[1].strip())
    564         except:
    565             count = 0
    566         try:
    567             bp = bdb.Breakpoint.bpbynumber[bpnum]
    568         except IndexError:
    569             print >>self.stdout, 'Breakpoint index %r is not valid' % args[0]
    570             return
    571         if bp:
    572             bp.ignore = count
    573             if count > 0:
    574                 reply = 'Will ignore next '
    575                 if count > 1:
    576                     reply = reply + '%d crossings' % count
    577                 else:
    578                     reply = reply + '1 crossing'
    579                 print >>self.stdout, reply + ' of breakpoint %d.' % bpnum
    580             else:
    581                 print >>self.stdout, 'Will stop next time breakpoint',
    582                 print >>self.stdout, bpnum, 'is reached.'
    583 
    584     def do_clear(self, arg):
    585         """Three possibilities, tried in this order:
    586         clear -> clear all breaks, ask for confirmation
    587         clear file:lineno -> clear all breaks at file:lineno
    588         clear bpno bpno ... -> clear breakpoints by number"""
    589         if not arg:
    590             try:
    591                 reply = raw_input('Clear all breaks? ')
    592             except EOFError:
    593                 reply = 'no'
    594             reply = reply.strip().lower()
    595             if reply in ('y', 'yes'):
    596                 self.clear_all_breaks()
    597             return
    598         if ':' in arg:
    599             # Make sure it works for "clear C:\foo\bar.py:12"
    600             i = arg.rfind(':')
    601             filename = arg[:i]
    602             arg = arg[i+1:]
    603             try:
    604                 lineno = int(arg)
    605             except ValueError:
    606                 err = "Invalid line number (%s)" % arg
    607             else:
    608                 err = self.clear_break(filename, lineno)
    609             if err: print >>self.stdout, '***', err
    610             return
    611         numberlist = arg.split()
    612         for i in numberlist:
    613             try:
    614                 i = int(i)
    615             except ValueError:
    616                 print >>self.stdout, 'Breakpoint index %r is not a number' % i
    617                 continue
    618 
    619             if not (0 <= i < len(bdb.Breakpoint.bpbynumber)):
    620                 print >>self.stdout, 'No breakpoint numbered', i
    621                 continue
    622             err = self.clear_bpbynumber(i)
    623             if err:
    624                 print >>self.stdout, '***', err
    625             else:
    626                 print >>self.stdout, 'Deleted breakpoint', i
    627     do_cl = do_clear # 'c' is already an abbreviation for 'continue'
    628 
    629     def do_where(self, arg):
    630         self.print_stack_trace()
    631     do_w = do_where
    632     do_bt = do_where
    633 
    634     def do_up(self, arg):
    635         if self.curindex == 0:
    636             print >>self.stdout, '*** Oldest frame'
    637         else:
    638             self.curindex = self.curindex - 1
    639             self.curframe = self.stack[self.curindex][0]
    640             self.curframe_locals = self.curframe.f_locals
    641             self.print_stack_entry(self.stack[self.curindex])
    642             self.lineno = None
    643     do_u = do_up
    644 
    645     def do_down(self, arg):
    646         if self.curindex + 1 == len(self.stack):
    647             print >>self.stdout, '*** Newest frame'
    648         else:
    649             self.curindex = self.curindex + 1
    650             self.curframe = self.stack[self.curindex][0]
    651             self.curframe_locals = self.curframe.f_locals
    652             self.print_stack_entry(self.stack[self.curindex])
    653             self.lineno = None
    654     do_d = do_down
    655 
    656     def do_until(self, arg):
    657         self.set_until(self.curframe)
    658         return 1
    659     do_unt = do_until
    660 
    661     def do_step(self, arg):
    662         self.set_step()
    663         return 1
    664     do_s = do_step
    665 
    666     def do_next(self, arg):
    667         self.set_next(self.curframe)
    668         return 1
    669     do_n = do_next
    670 
    671     def do_run(self, arg):
    672         """Restart program by raising an exception to be caught in the main
    673         debugger loop.  If arguments were given, set them in sys.argv."""
    674         if arg:
    675             import shlex
    676             argv0 = sys.argv[0:1]
    677             sys.argv = shlex.split(arg)
    678             sys.argv[:0] = argv0
    679         raise Restart
    680 
    681     do_restart = do_run
    682 
    683     def do_return(self, arg):
    684         self.set_return(self.curframe)
    685         return 1
    686     do_r = do_return
    687 
    688     def do_continue(self, arg):
    689         self.set_continue()
    690         return 1
    691     do_c = do_cont = do_continue
    692 
    693     def do_jump(self, arg):
    694         if self.curindex + 1 != len(self.stack):
    695             print >>self.stdout, "*** You can only jump within the bottom frame"
    696             return
    697         try:
    698             arg = int(arg)
    699         except ValueError:
    700             print >>self.stdout, "*** The 'jump' command requires a line number."
    701         else:
    702             try:
    703                 # Do the jump, fix up our copy of the stack, and display the
    704                 # new position
    705                 self.curframe.f_lineno = arg
    706                 self.stack[self.curindex] = self.stack[self.curindex][0], arg
    707                 self.print_stack_entry(self.stack[self.curindex])
    708             except ValueError, e:
    709                 print >>self.stdout, '*** Jump failed:', e
    710     do_j = do_jump
    711 
    712     def do_debug(self, arg):
    713         sys.settrace(None)
    714         globals = self.curframe.f_globals
    715         locals = self.curframe_locals
    716         p = Pdb(self.completekey, self.stdin, self.stdout)
    717         p.prompt = "(%s) " % self.prompt.strip()
    718         print >>self.stdout, "ENTERING RECURSIVE DEBUGGER"
    719         sys.call_tracing(p.run, (arg, globals, locals))
    720         print >>self.stdout, "LEAVING RECURSIVE DEBUGGER"
    721         sys.settrace(self.trace_dispatch)
    722         self.lastcmd = p.lastcmd
    723 
    724     def do_quit(self, arg):
    725         self._user_requested_quit = 1
    726         self.set_quit()
    727         return 1
    728 
    729     do_q = do_quit
    730     do_exit = do_quit
    731 
    732     def do_EOF(self, arg):
    733         print >>self.stdout
    734         self._user_requested_quit = 1
    735         self.set_quit()
    736         return 1
    737 
    738     def do_args(self, arg):
    739         co = self.curframe.f_code
    740         dict = self.curframe_locals
    741         n = co.co_argcount
    742         if co.co_flags & 4: n = n+1
    743         if co.co_flags & 8: n = n+1
    744         for i in range(n):
    745             name = co.co_varnames[i]
    746             print >>self.stdout, name, '=',
    747             if name in dict: print >>self.stdout, dict[name]
    748             else: print >>self.stdout, "*** undefined ***"
    749     do_a = do_args
    750 
    751     def do_retval(self, arg):
    752         if '__return__' in self.curframe_locals:
    753             print >>self.stdout, self.curframe_locals['__return__']
    754         else:
    755             print >>self.stdout, '*** Not yet returned!'
    756     do_rv = do_retval
    757 
    758     def _getval(self, arg):
    759         try:
    760             return eval(arg, self.curframe.f_globals,
    761                         self.curframe_locals)
    762         except:
    763             t, v = sys.exc_info()[:2]
    764             if isinstance(t, str):
    765                 exc_type_name = t
    766             else: exc_type_name = t.__name__
    767             print >>self.stdout, '***', exc_type_name + ':', repr(v)
    768             raise
    769 
    770     def do_p(self, arg):
    771         try:
    772             print >>self.stdout, repr(self._getval(arg))
    773         except:
    774             pass
    775 
    776     def do_pp(self, arg):
    777         try:
    778             pprint.pprint(self._getval(arg), self.stdout)
    779         except:
    780             pass
    781 
    782     def do_list(self, arg):
    783         self.lastcmd = 'list'
    784         last = None
    785         if arg:
    786             try:
    787                 x = eval(arg, {}, {})
    788                 if type(x) == type(()):
    789                     first, last = x
    790                     first = int(first)
    791                     last = int(last)
    792                     if last < first:
    793                         # Assume it's a count
    794                         last = first + last
    795                 else:
    796                     first = max(1, int(x) - 5)
    797             except:
    798                 print >>self.stdout, '*** Error in argument:', repr(arg)
    799                 return
    800         elif self.lineno is None:
    801             first = max(1, self.curframe.f_lineno - 5)
    802         else:
    803             first = self.lineno + 1
    804         if last is None:
    805             last = first + 10
    806         filename = self.curframe.f_code.co_filename
    807         breaklist = self.get_file_breaks(filename)
    808         try:
    809             for lineno in range(first, last+1):
    810                 line = linecache.getline(filename, lineno,
    811                                          self.curframe.f_globals)
    812                 if not line:
    813                     print >>self.stdout, '[EOF]'
    814                     break
    815                 else:
    816                     s = repr(lineno).rjust(3)
    817                     if len(s) < 4: s = s + ' '
    818                     if lineno in breaklist: s = s + 'B'
    819                     else: s = s + ' '
    820                     if lineno == self.curframe.f_lineno:
    821                         s = s + '->'
    822                     print >>self.stdout, s + '\t' + line,
    823                     self.lineno = lineno
    824         except KeyboardInterrupt:
    825             pass
    826     do_l = do_list
    827 
    828     def do_whatis(self, arg):
    829         try:
    830             value = eval(arg, self.curframe.f_globals,
    831                             self.curframe_locals)
    832         except:
    833             t, v = sys.exc_info()[:2]
    834             if type(t) == type(''):
    835                 exc_type_name = t
    836             else: exc_type_name = t.__name__
    837             print >>self.stdout, '***', exc_type_name + ':', repr(v)
    838             return
    839         code = None
    840         # Is it a function?
    841         try: code = value.func_code
    842         except: pass
    843         if code:
    844             print >>self.stdout, 'Function', code.co_name
    845             return
    846         # Is it an instance method?
    847         try: code = value.im_func.func_code
    848         except: pass
    849         if code:
    850             print >>self.stdout, 'Method', code.co_name
    851             return
    852         # None of the above...
    853         print >>self.stdout, type(value)
    854 
    855     def do_alias(self, arg):
    856         args = arg.split()
    857         if len(args) == 0:
    858             keys = self.aliases.keys()
    859             keys.sort()
    860             for alias in keys:
    861                 print >>self.stdout, "%s = %s" % (alias, self.aliases[alias])
    862             return
    863         if args[0] in self.aliases and len(args) == 1:
    864             print >>self.stdout, "%s = %s" % (args[0], self.aliases[args[0]])
    865         else:
    866             self.aliases[args[0]] = ' '.join(args[1:])
    867 
    868     def do_unalias(self, arg):
    869         args = arg.split()
    870         if len(args) == 0: return
    871         if args[0] in self.aliases:
    872             del self.aliases[args[0]]
    873 
    874     #list of all the commands making the program resume execution.
    875     commands_resuming = ['do_continue', 'do_step', 'do_next', 'do_return',
    876                          'do_quit', 'do_jump']
    877 
    878     # Print a traceback starting at the top stack frame.
    879     # The most recently entered frame is printed last;
    880     # this is different from dbx and gdb, but consistent with
    881     # the Python interpreter's stack trace.
    882     # It is also consistent with the up/down commands (which are
    883     # compatible with dbx and gdb: up moves towards 'main()'
    884     # and down moves towards the most recent stack frame).
    885 
    886     def print_stack_trace(self):
    887         try:
    888             for frame_lineno in self.stack:
    889                 self.print_stack_entry(frame_lineno)
    890         except KeyboardInterrupt:
    891             pass
    892 
    893     def print_stack_entry(self, frame_lineno, prompt_prefix=line_prefix):
    894         frame, lineno = frame_lineno
    895         if frame is self.curframe:
    896             print >>self.stdout, '>',
    897         else:
    898             print >>self.stdout, ' ',
    899         print >>self.stdout, self.format_stack_entry(frame_lineno,
    900                                                      prompt_prefix)
    901 
    902 
    903     # Help methods (derived from pdb.doc)
    904 
    905     def help_help(self):
    906         self.help_h()
    907 
    908     def help_h(self):
    909         print >>self.stdout, """h(elp)
    910 Without argument, print the list of available commands.
    911 With a command name as argument, print help about that command
    912 "help pdb" pipes the full documentation file to the $PAGER
    913 "help exec" gives help on the ! command"""
    914 
    915     def help_where(self):
    916         self.help_w()
    917 
    918     def help_w(self):
    919         print >>self.stdout, """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     help_bt = help_w
    925 
    926     def help_down(self):
    927         self.help_d()
    928 
    929     def help_d(self):
    930         print >>self.stdout, """d(own)
    931 Move the current frame one level down in the stack trace
    932 (to a newer frame)."""
    933 
    934     def help_up(self):
    935         self.help_u()
    936 
    937     def help_u(self):
    938         print >>self.stdout, """u(p)
    939 Move the current frame one level up in the stack trace
    940 (to an older frame)."""
    941 
    942     def help_break(self):
    943         self.help_b()
    944 
    945     def help_b(self):
    946         print >>self.stdout, """b(reak) ([file:]lineno | function) [, condition]
    947 With a line number argument, set a break there in the current
    948 file.  With a function name, set a break at first executable line
    949 of that function.  Without argument, list all breaks.  If a second
    950 argument is present, it is a string specifying an expression
    951 which must evaluate to true before the breakpoint is honored.
    952 
    953 The line number may be prefixed with a filename and a colon,
    954 to specify a breakpoint in another file (probably one that
    955 hasn't been loaded yet).  The file is searched for on sys.path;
    956 the .py suffix may be omitted."""
    957 
    958     def help_clear(self):
    959         self.help_cl()
    960 
    961     def help_cl(self):
    962         print >>self.stdout, "cl(ear) filename:lineno"
    963         print >>self.stdout, """cl(ear) [bpnumber [bpnumber...]]
    964 With a space separated list of breakpoint numbers, clear
    965 those breakpoints.  Without argument, clear all breaks (but
    966 first ask confirmation).  With a filename:lineno argument,
    967 clear all breaks at that line in that file.
    968 
    969 Note that the argument is different from previous versions of
    970 the debugger (in python distributions 1.5.1 and before) where
    971 a linenumber was used instead of either filename:lineno or
    972 breakpoint numbers."""
    973 
    974     def help_tbreak(self):
    975         print >>self.stdout, """tbreak  same arguments as break, but breakpoint
    976 is removed when first hit."""
    977 
    978     def help_enable(self):
    979         print >>self.stdout, """enable bpnumber [bpnumber ...]
    980 Enables the breakpoints given as a space separated list of
    981 bp numbers."""
    982 
    983     def help_disable(self):
    984         print >>self.stdout, """disable bpnumber [bpnumber ...]
    985 Disables the breakpoints given as a space separated list of
    986 bp numbers."""
    987 
    988     def help_ignore(self):
    989         print >>self.stdout, """ignore bpnumber count
    990 Sets the ignore count for the given breakpoint number.  A breakpoint
    991 becomes active when the ignore count is zero.  When non-zero, the
    992 count is decremented each time the breakpoint is reached and the
    993 breakpoint is not disabled and any associated condition evaluates
    994 to true."""
    995 
    996     def help_condition(self):
    997         print >>self.stdout, """condition bpnumber str_condition
    998 str_condition is a string specifying an expression which
    999 must evaluate to true before the breakpoint is honored.
   1000 If str_condition is absent, any existing condition is removed;
   1001 i.e., the breakpoint is made unconditional."""
   1002 
   1003     def help_step(self):
   1004         self.help_s()
   1005 
   1006     def help_s(self):
   1007         print >>self.stdout, """s(tep)
   1008 Execute the current line, stop at the first possible occasion
   1009 (either in a function that is called or in the current function)."""
   1010 
   1011     def help_until(self):
   1012         self.help_unt()
   1013 
   1014     def help_unt(self):
   1015         print """unt(il)
   1016 Continue execution until the line with a number greater than the current
   1017 one is reached or until the current frame returns"""
   1018 
   1019     def help_next(self):
   1020         self.help_n()
   1021 
   1022     def help_n(self):
   1023         print >>self.stdout, """n(ext)
   1024 Continue execution until the next line in the current function
   1025 is reached or it returns."""
   1026 
   1027     def help_return(self):
   1028         self.help_r()
   1029 
   1030     def help_r(self):
   1031         print >>self.stdout, """r(eturn)
   1032 Continue execution until the current function returns."""
   1033 
   1034     def help_continue(self):
   1035         self.help_c()
   1036 
   1037     def help_cont(self):
   1038         self.help_c()
   1039 
   1040     def help_c(self):
   1041         print >>self.stdout, """c(ont(inue))
   1042 Continue execution, only stop when a breakpoint is encountered."""
   1043 
   1044     def help_jump(self):
   1045         self.help_j()
   1046 
   1047     def help_j(self):
   1048         print >>self.stdout, """j(ump) lineno
   1049 Set the next line that will be executed."""
   1050 
   1051     def help_debug(self):
   1052         print >>self.stdout, """debug code
   1053 Enter a recursive debugger that steps through the code argument
   1054 (which is an arbitrary expression or statement to be executed
   1055 in the current environment)."""
   1056 
   1057     def help_list(self):
   1058         self.help_l()
   1059 
   1060     def help_l(self):
   1061         print >>self.stdout, """l(ist) [first [,last]]
   1062 List source code for the current file.
   1063 Without arguments, list 11 lines around the current line
   1064 or continue the previous listing.
   1065 With one argument, list 11 lines starting at that line.
   1066 With two arguments, list the given range;
   1067 if the second argument is less than the first, it is a count."""
   1068 
   1069     def help_args(self):
   1070         self.help_a()
   1071 
   1072     def help_a(self):
   1073         print >>self.stdout, """a(rgs)
   1074 Print the arguments of the current function."""
   1075 
   1076     def help_p(self):
   1077         print >>self.stdout, """p expression
   1078 Print the value of the expression."""
   1079 
   1080     def help_pp(self):
   1081         print >>self.stdout, """pp expression
   1082 Pretty-print the value of the expression."""
   1083 
   1084     def help_exec(self):
   1085         print >>self.stdout, """(!) statement
   1086 Execute the (one-line) statement in the context of
   1087 the current stack frame.
   1088 The exclamation point can be omitted unless the first word
   1089 of the statement resembles a debugger command.
   1090 To assign to a global variable you must always prefix the
   1091 command with a 'global' command, e.g.:
   1092 (Pdb) global list_options; list_options = ['-l']
   1093 (Pdb)"""
   1094 
   1095     def help_run(self):
   1096         print """run [args...]
   1097 Restart the debugged python program. If a string is supplied, it is
   1098 splitted with "shlex" and the result is used as the new sys.argv.
   1099 History, breakpoints, actions and debugger options are preserved.
   1100 "restart" is an alias for "run"."""
   1101 
   1102     help_restart = help_run
   1103 
   1104     def help_quit(self):
   1105         self.help_q()
   1106 
   1107     def help_q(self):
   1108         print >>self.stdout, """q(uit) or exit - Quit from the debugger.
   1109 The program being executed is aborted."""
   1110 
   1111     help_exit = help_q
   1112 
   1113     def help_whatis(self):
   1114         print >>self.stdout, """whatis arg
   1115 Prints the type of the argument."""
   1116 
   1117     def help_EOF(self):
   1118         print >>self.stdout, """EOF
   1119 Handles the receipt of EOF as a command."""
   1120 
   1121     def help_alias(self):
   1122         print >>self.stdout, """alias [name [command [parameter parameter ...]]]
   1123 Creates an alias called 'name' the executes 'command'.  The command
   1124 must *not* be enclosed in quotes.  Replaceable parameters are
   1125 indicated by %1, %2, and so on, while %* is replaced by all the
   1126 parameters.  If no command is given, the current alias for name
   1127 is shown. If no name is given, all aliases are listed.
   1128 
   1129 Aliases may be nested and can contain anything that can be
   1130 legally typed at the pdb prompt.  Note!  You *can* override
   1131 internal pdb commands with aliases!  Those internal commands
   1132 are then hidden until the alias is removed.  Aliasing is recursively
   1133 applied to the first word of the command line; all other words
   1134 in the line are left alone.
   1135 
   1136 Some useful aliases (especially when placed in the .pdbrc file) are:
   1137 
   1138 #Print instance variables (usage "pi classInst")
   1139 alias pi for k in %1.__dict__.keys(): print "%1.",k,"=",%1.__dict__[k]
   1140 
   1141 #Print instance variables in self
   1142 alias ps pi self
   1143 """
   1144 
   1145     def help_unalias(self):
   1146         print >>self.stdout, """unalias name
   1147 Deletes the specified alias."""
   1148 
   1149     def help_commands(self):
   1150         print >>self.stdout, """commands [bpnumber]
   1151 (com) ...
   1152 (com) end
   1153 (Pdb)
   1154 
   1155 Specify a list of commands for breakpoint number bpnumber.  The
   1156 commands themselves appear on the following lines.  Type a line
   1157 containing just 'end' to terminate the commands.
   1158 
   1159 To remove all commands from a breakpoint, type commands and
   1160 follow it immediately with  end; that is, give no commands.
   1161 
   1162 With no bpnumber argument, commands refers to the last
   1163 breakpoint set.
   1164 
   1165 You can use breakpoint commands to start your program up again.
   1166 Simply use the continue command, or step, or any other
   1167 command that resumes execution.
   1168 
   1169 Specifying any command resuming execution (currently continue,
   1170 step, next, return, jump, quit and their abbreviations) terminates
   1171 the command list (as if that command was immediately followed by end).
   1172 This is because any time you resume execution
   1173 (even with a simple next or step), you may encounter
   1174 another breakpoint--which could have its own command list, leading to
   1175 ambiguities about which list to execute.
   1176 
   1177    If you use the 'silent' command in the command list, the
   1178 usual message about stopping at a breakpoint is not printed.  This may
   1179 be desirable for breakpoints that are to print a specific message and
   1180 then continue.  If none of the other commands print anything, you
   1181 see no sign that the breakpoint was reached.
   1182 """
   1183 
   1184     def help_pdb(self):
   1185         help()
   1186 
   1187     def lookupmodule(self, filename):
   1188         """Helper function for break/clear parsing -- may be overridden.
   1189 
   1190         lookupmodule() translates (possibly incomplete) file or module name
   1191         into an absolute file name.
   1192         """
   1193         if os.path.isabs(filename) and  os.path.exists(filename):
   1194             return filename
   1195         f = os.path.join(sys.path[0], filename)
   1196         if  os.path.exists(f) and self.canonic(f) == self.mainpyfile:
   1197             return f
   1198         root, ext = os.path.splitext(filename)
   1199         if ext == '':
   1200             filename = filename + '.py'
   1201         if os.path.isabs(filename):
   1202             return filename
   1203         for dirname in sys.path:
   1204             while os.path.islink(dirname):
   1205                 dirname = os.readlink(dirname)
   1206             fullname = os.path.join(dirname, filename)
   1207             if os.path.exists(fullname):
   1208                 return fullname
   1209         return None
   1210 
   1211     def _runscript(self, filename):
   1212         # The script has to run in __main__ namespace (or imports from
   1213         # __main__ will break).
   1214         #
   1215         # So we clear up the __main__ and set several special variables
   1216         # (this gets rid of pdb's globals and cleans old variables on restarts).
   1217         import __main__
   1218         __main__.__dict__.clear()
   1219         __main__.__dict__.update({"__name__"    : "__main__",
   1220                                   "__file__"    : filename,
   1221                                   "__builtins__": __builtins__,
   1222                                  })
   1223 
   1224         # When bdb sets tracing, a number of call and line events happens
   1225         # BEFORE debugger even reaches user's code (and the exact sequence of
   1226         # events depends on python version). So we take special measures to
   1227         # avoid stopping before we reach the main script (see user_line and
   1228         # user_call for details).
   1229         self._wait_for_mainpyfile = 1
   1230         self.mainpyfile = self.canonic(filename)
   1231         self._user_requested_quit = 0
   1232         statement = 'execfile(%r)' % filename
   1233         self.run(statement)
   1234 
   1235 # Simplified interface
   1236 
   1237 def run(statement, globals=None, locals=None):
   1238     Pdb().run(statement, globals, locals)
   1239 
   1240 def runeval(expression, globals=None, locals=None):
   1241     return Pdb().runeval(expression, globals, locals)
   1242 
   1243 def runctx(statement, globals, locals):
   1244     # B/W compatibility
   1245     run(statement, globals, locals)
   1246 
   1247 def runcall(*args, **kwds):
   1248     return Pdb().runcall(*args, **kwds)
   1249 
   1250 def set_trace():
   1251     Pdb().set_trace(sys._getframe().f_back)
   1252 
   1253 # Post-Mortem interface
   1254 
   1255 def post_mortem(t=None):
   1256     # handling the default
   1257     if t is None:
   1258         # sys.exc_info() returns (type, value, traceback) if an exception is
   1259         # being handled, otherwise it returns None
   1260         t = sys.exc_info()[2]
   1261         if t is None:
   1262             raise ValueError("A valid traceback must be passed if no "
   1263                                                "exception is being handled")
   1264 
   1265     p = Pdb()
   1266     p.reset()
   1267     p.interaction(None, t)
   1268 
   1269 def pm():
   1270     post_mortem(sys.last_traceback)
   1271 
   1272 
   1273 # Main program for testing
   1274 
   1275 TESTCMD = 'import x; x.main()'
   1276 
   1277 def test():
   1278     run(TESTCMD)
   1279 
   1280 # print help
   1281 def help():
   1282     for dirname in sys.path:
   1283         fullname = os.path.join(dirname, 'pdb.doc')
   1284         if os.path.exists(fullname):
   1285             sts = os.system('${PAGER-more} '+fullname)
   1286             if sts: print '*** Pager exit status:', sts
   1287             break
   1288     else:
   1289         print 'Sorry, can\'t find the help file "pdb.doc"',
   1290         print 'along the Python search path'
   1291 
   1292 def main():
   1293     if not sys.argv[1:] or sys.argv[1] in ("--help", "-h"):
   1294         print "usage: pdb.py scriptfile [arg] ..."
   1295         sys.exit(2)
   1296 
   1297     mainpyfile =  sys.argv[1]     # Get script filename
   1298     if not os.path.exists(mainpyfile):
   1299         print 'Error:', mainpyfile, 'does not exist'
   1300         sys.exit(1)
   1301 
   1302     del sys.argv[0]         # Hide "pdb.py" from argument list
   1303 
   1304     # Replace pdb's dir with script's dir in front of module search path.
   1305     sys.path[0] = os.path.dirname(mainpyfile)
   1306 
   1307     # Note on saving/restoring sys.argv: it's a good idea when sys.argv was
   1308     # modified by the script being debugged. It's a bad idea when it was
   1309     # changed by the user from the command line. There is a "restart" command
   1310     # which allows explicit specification of command line arguments.
   1311     pdb = Pdb()
   1312     while True:
   1313         try:
   1314             pdb._runscript(mainpyfile)
   1315             if pdb._user_requested_quit:
   1316                 break
   1317             print "The program finished and will be restarted"
   1318         except Restart:
   1319             print "Restarting", mainpyfile, "with arguments:"
   1320             print "\t" + " ".join(sys.argv[1:])
   1321         except SystemExit:
   1322             # In most cases SystemExit does not warrant a post-mortem session.
   1323             print "The program exited via sys.exit(). Exit status: ",
   1324             print sys.exc_info()[1]
   1325         except:
   1326             traceback.print_exc()
   1327             print "Uncaught exception. Entering post mortem debugging"
   1328             print "Running 'cont' or 'step' will restart the program"
   1329             t = sys.exc_info()[2]
   1330             pdb.interaction(None, t)
   1331             print "Post mortem debugger finished. The " + mainpyfile + \
   1332                   " will be restarted"
   1333 
   1334 
   1335 # When invoked as main program, invoke the debugger on a script
   1336 if __name__ == '__main__':
   1337     import pdb
   1338     pdb.main()
   1339