Lib/pdb.py

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