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
  16 # Create a custom safe Repr instance and increase its maxstring.
  17 # The default of 30 truncates error messages too easily.
  18 _repr = Repr()
  19 _repr.maxstring = 200
  20 _saferepr = _repr.repr
  21
  22 __all__ = ["run", "pm", "Pdb", "runeval", "runctx", "runcall", "set_trace",
  23            "post_mortem", "help"]
  24
  25 def find_function(funcname, filename):
  26     cre = re.compile(r'def\s+%s\s*[(]' % funcname)
  27     try:
  28         fp = open(filename)
  29     except IOError:
  30         return None
  31     # consumer of this info expects the first line to be 1
  32     lineno = 1
  33     answer = None
  34     while 1:
  35         line = fp.readline()
  36         if line == '':
  37             break
  38         if cre.match(line):
  39             answer = funcname, filename, lineno
  40             break
  41         lineno = lineno + 1
  42     fp.close()
  43     return answer
  44
  45
  46 # Interaction prompt line will separate file and call info from code
  47 # text using value of line_prefix string.  A newline and arrow may
  48 # be to your liking.  You can set it once pdb is imported using the
  49 # command "pdb.line_prefix = '\n% '".
  50 # line_prefix = ': '    # Use this to get the old situation back
  51 line_prefix = '\n-> '   # Probably a better default
  52
  53 class Pdb(bdb.Bdb, cmd.Cmd):
  54
  55     def __init__(self):
  56         bdb.Bdb.__init__(self)
  57         cmd.Cmd.__init__(self)
  58         self.prompt = '(Pdb) '
  59         self.aliases = {}
  60         # Try to load readline if it exists
  61         try:
  62             import readline
  63         except ImportError:
  64             pass
  65
  66         # Read $HOME/.pdbrc and ./.pdbrc
  67         self.rcLines = []
  68         if 'HOME' in os.environ:
  69             envHome = os.environ['HOME']
  70             try:
  71                 rcFile = open(os.path.join(envHome, ".pdbrc"))
  72             except IOError:
  73                 pass
  74             else:
  75                 for line in rcFile.readlines():
  76                     self.rcLines.append(line)
  77                 rcFile.close()
  78         try:
  79             rcFile = open(".pdbrc")
  80         except IOError:
  81             pass
  82         else:
  83             for line in rcFile.readlines():
  84                 self.rcLines.append(line)
  85             rcFile.close()
  86
  87     def reset(self):
  88         bdb.Bdb.reset(self)
  89         self.forget()
  90
  91     def forget(self):
  92         self.lineno = None
  93         self.stack = []
  94         self.curindex = 0
  95         self.curframe = None
  96
  97     def setup(self, f, t):
  98         self.forget()
  99         self.stack, self.curindex = self.get_stack(f, t)
 100         self.curframe = self.stack[self.curindex][0]
 101         self.execRcLines()
 102
 103     # Can be executed earlier than 'setup' if desired
 104     def execRcLines(self):
 105         if self.rcLines:
 106             # Make local copy because of recursion
 107             rcLines = self.rcLines
 108             # executed only once
 109             self.rcLines = []
 110             for line in rcLines:
 111                 line = line[:-1]
 112                 if len(line) > 0 and line[0] != '#':
 113                     self.onecmd(line)
 114
 115     # Override Bdb methods
 116
 117     def user_call(self, frame, argument_list):
 118         """This method is called when there is the remote possibility
 119         that we ever need to stop in this function."""
 120         if self.stop_here(frame):
 121             print '--Call--'
 122             self.interaction(frame, None)
 123
 124     def user_line(self, frame):
 125         """This function is called when we stop or break at this line."""
 126         self.interaction(frame, None)
 127
 128     def user_return(self, frame, return_value):
 129         """This function is called when a return trap is set here."""
 130         frame.f_locals['__return__'] = return_value
 131         print '--Return--'
 132         self.interaction(frame, None)
 133
 134     def user_exception(self, frame, (exc_type, exc_value, exc_traceback)):
 135         """This function is called if an exception occurs,
 136         but only if we are to stop at or just below this level."""
 137         frame.f_locals['__exception__'] = exc_type, exc_value
 138         if type(exc_type) == type(''):
 139             exc_type_name = exc_type
 140         else: exc_type_name = exc_type.__name__
 141         print exc_type_name + ':', _saferepr(exc_value)
 142         self.interaction(frame, exc_traceback)
 143
 144     # General interaction function
 145
 146     def interaction(self, frame, traceback):
 147         self.setup(frame, traceback)
 148         self.print_stack_entry(self.stack[self.curindex])
 149         self.cmdloop()
 150         self.forget()
 151
 152     def default(self, line):
 153         if line[:1] == '!': line = line[1:]
 154         locals = self.curframe.f_locals
 155         globals = self.curframe.f_globals
 156         try:
 157             code = compile(line + '\n', '<stdin>', 'single')
 158             exec code in globals, locals
 159         except:
 160             t, v = sys.exc_info()[:2]
 161             if type(t) == type(''):
 162                 exc_type_name = t
 163             else: exc_type_name = t.__name__
 164             print '***', exc_type_name + ':', v
 165
 166     def precmd(self, line):
 167         """Handle alias expansion and ';;' separator."""
 168         if not line.strip():
 169             return line
 170         args = line.split()
 171         while args[0] in self.aliases:
 172             line = self.aliases[args[0]]
 173             ii = 1
 174             for tmpArg in args[1:]:
 175                 line = line.replace("%" + str(ii),
 176                                       tmpArg)
 177                 ii = ii + 1
 178             line = line.replace("%*", ' '.join(args[1:]))
 179             args = line.split()
 180         # split into ';;' separated commands
 181         # unless it's an alias command
 182         if args[0] != 'alias':
 183             marker = line.find(';;')
 184             if marker >= 0:
 185                 # queue up everything after marker
 186                 next = line[marker+2:].lstrip()
 187                 self.cmdqueue.append(next)
 188                 line = line[:marker].rstrip()
 189         return line
 190
 191     # Command definitions, called by cmdloop()
 192     # The argument is the remaining string on the command line
 193     # Return true to exit from the command loop
 194
 195     do_h = cmd.Cmd.do_help
 196
 197     def do_break(self, arg, temporary = 0):
 198         # break [ ([filename:]lineno | function) [, "condition"] ]
 199         if not arg:
 200             if self.breaks:  # There's at least one
 201                 print "Num Type         Disp Enb   Where"
 202                 for bp in bdb.Breakpoint.bpbynumber:
 203                     if bp:
 204                         bp.bpprint()
 205             return
 206         # parse arguments; comma has lowest precedence
 207         # and cannot occur in filename
 208         filename = None
 209         lineno = None
 210         cond = None
 211         comma = arg.find(',')
 212         if comma > 0:
 213             # parse stuff after comma: "condition"
 214             cond = arg[comma+1:].lstrip()
 215             arg = arg[:comma].rstrip()
 216         # parse stuff before comma: [filename:]lineno | function
 217         colon = arg.rfind(':')
 218         if colon >= 0:
 219             filename = arg[:colon].rstrip()
 220             f = self.lookupmodule(filename)
 221             if not f:
 222                 print '*** ', `filename`,
 223                 print 'not found from sys.path'
 224                 return
 225             else:
 226                 filename = f
 227             arg = arg[colon+1:].lstrip()
 228             try:
 229                 lineno = int(arg)
 230             except ValueError, msg:
 231                 print '*** Bad lineno:', arg
 232                 return
 233         else:
 234             # no colon; can be lineno or function
 235             try:
 236                 lineno = int(arg)
 237             except ValueError:
 238                 try:
 239                     func = eval(arg,
 240                                 self.curframe.f_globals,
 241                                 self.curframe.f_locals)
 242                 except:
 243                     func = arg
 244                 try:
 245                     if hasattr(func, 'im_func'):
 246                         func = func.im_func
 247                     code = func.func_code
 248                     lineno = code.co_firstlineno
 249                     filename = code.co_filename
 250                 except:
 251                     # last thing to try
 252                     (ok, filename, ln) = self.lineinfo(arg)
 253                     if not ok:
 254                         print '*** The specified object',
 255                         print `arg`,
 256                         print 'is not a function'
 257                         print ('or was not found '
 258                                'along sys.path.')
 259                         return
 260                     lineno = int(ln)
 261         if not filename:
 262             filename = self.defaultFile()
 263         # Check for reasonable breakpoint
 264         line = self.checkline(filename, lineno)
 265         if line:
 266             # now set the break point
 267             err = self.set_break(filename, line, temporary, cond)
 268             if err: print '***', err
 269             else:
 270                 bp = self.get_breaks(filename, line)[-1]
 271                 print "Breakpoint %d at %s:%d" % (bp.number,
 272                                                   bp.file,
 273                                                   bp.line)
 274
 275     # To be overridden in derived debuggers
 276     def defaultFile(self):
 277         """Produce a reasonable default."""
 278         filename = self.curframe.f_code.co_filename
 279         if filename == '<string>' and mainpyfile:
 280             filename = mainpyfile
 281         return filename
 282
 283     do_b = do_break
 284
 285     def do_tbreak(self, arg):
 286         self.do_break(arg, 1)
 287
 288     def lineinfo(self, identifier):
 289         failed = (None, None, None)
 290         # Input is identifier, may be in single quotes
 291         idstring = identifier.split("'")
 292         if len(idstring) == 1:
 293             # not in single quotes
 294             id = idstring[0].strip()
 295         elif len(idstring) == 3:
 296             # quoted
 297             id = idstring[1].strip()
 298         else:
 299             return failed
 300         if id == '': return failed
 301         parts = id.split('.')
 302         # Protection for derived debuggers
 303         if parts[0] == 'self':
 304             del parts[0]
 305             if len(parts) == 0:
 306                 return failed
 307         # Best first guess at file to look at
 308         fname = self.defaultFile()
 309         if len(parts) == 1:
 310             item = parts[0]
 311         else:
 312             # More than one part.
 313             # First is module, second is method/class
 314             f = self.lookupmodule(parts[0])
 315             if f:
 316                 fname = f
 317             item = parts[1]
 318         answer = find_function(item, fname)
 319         return answer or failed
 320
 321     def checkline(self, filename, lineno):
 322         """Return line number of first line at or after input
 323         argument such that if the input points to a 'def', the
 324         returned line number is the first
 325         non-blank/non-comment line to follow.  If the input
 326         points to a blank or comment line, return 0.  At end
 327         of file, also return 0."""
 328
 329         line = linecache.getline(filename, lineno)
 330         if not line:
 331             print 'End of file'
 332             return 0
 333         line = line.strip()
 334         # Don't allow setting breakpoint at a blank line
 335         if (not line or (line[0] == '#') or
 336              (line[:3] == '"""') or line[:3] == "'''"):
 337             print '*** Blank or comment'
 338             return 0
 339         # When a file is read in and a breakpoint is at
 340         # the 'def' statement, the system stops there at
 341         # code parse time.  We don't want that, so all breakpoints
 342         # set at 'def' statements are moved one line onward
 343         if line[:3] == 'def':
 344             instr = ''
 345             brackets = 0
 346             while 1:
 347                 skipone = 0
 348                 for c in line:
 349                     if instr:
 350                         if skipone:
 351                             skipone = 0
 352                         elif c == '\\':
 353                             skipone = 1
 354                         elif c == instr:
 355                             instr = ''
 356                     elif c == '#':
 357                         break
 358                     elif c in ('"',"'"):
 359                         instr = c
 360                     elif c in ('(','{','['):
 361                         brackets = brackets + 1
 362                     elif c in (')','}',']'):
 363                         brackets = brackets - 1
 364                 lineno = lineno+1
 365                 line = linecache.getline(filename, lineno)
 366                 if not line:
 367                     print 'end of file'
 368                     return 0
 369                 line = line.strip()
 370                 if not line: continue   # Blank line
 371                 if brackets <= 0 and line[0] not in ('#','"',"'"):
 372                     break
 373         return lineno
 374
 375     def do_enable(self, arg):
 376         args = arg.split()
 377         for i in args:
 378             bp = bdb.Breakpoint.bpbynumber[int(i)]
 379             if bp:
 380                 bp.enable()
 381
 382     def do_disable(self, arg):
 383         args = arg.split()
 384         for i in args:
 385             bp = bdb.Breakpoint.bpbynumber[int(i)]
 386             if bp:
 387                 bp.disable()
 388
 389     def do_condition(self, arg):
 390         # arg is breakpoint number and condition
 391         args = arg.split(' ', 1)
 392         bpnum = int(args[0].strip())
 393         try:
 394             cond = args[1]
 395         except:
 396             cond = None
 397         bp = bdb.Breakpoint.bpbynumber[bpnum]
 398         if bp:
 399             bp.cond = cond
 400             if not cond:
 401                 print 'Breakpoint', bpnum,
 402                 print 'is now unconditional.'
 403
 404     def do_ignore(self,arg):
 405         """arg is bp number followed by ignore count."""
 406         args = arg.split()
 407         bpnum = int(args[0].strip())
 408         try:
 409             count = int(args[1].strip())
 410         except:
 411             count = 0
 412         bp = bdb.Breakpoint.bpbynumber[bpnum]
 413         if bp:
 414             bp.ignore = count
 415             if count > 0:
 416                 reply = 'Will ignore next '
 417                 if count > 1:
 418                     reply = reply + '%d crossings' % count
 419                 else:
 420                     reply = reply + '1 crossing'
 421                 print reply + ' of breakpoint %d.' % bpnum
 422             else:
 423                 print 'Will stop next time breakpoint',
 424                 print bpnum, 'is reached.'
 425
 426     def do_clear(self, arg):
 427         """Three possibilities, tried in this order:
 428         clear -> clear all breaks, ask for confirmation
 429         clear file:lineno -> clear all breaks at file:lineno
 430         clear bpno bpno ... -> clear breakpoints by number"""
 431         if not arg:
 432             try:
 433                 reply = raw_input('Clear all breaks? ')
 434             except EOFError:
 435                 reply = 'no'
 436             reply = reply.strip().lower()
 437             if reply in ('y', 'yes'):
 438                 self.clear_all_breaks()
 439             return
 440         if ':' in arg:
 441             # Make sure it works for "clear C:\foo\bar.py:12"
 442             i = arg.rfind(':')
 443             filename = arg[:i]
 444             arg = arg[i+1:]
 445             try:
 446                 lineno = int(arg)
 447             except:
 448                 err = "Invalid line number (%s)" % arg
 449             else:
 450                 err = self.clear_break(filename, lineno)
 451             if err: print '***', err
 452             return
 453         numberlist = arg.split()
 454         for i in numberlist:
 455             err = self.clear_bpbynumber(i)
 456             if err:
 457                 print '***', err
 458             else:
 459                 print 'Deleted breakpoint %s ' % (i,)
 460     do_cl = do_clear # 'c' is already an abbreviation for 'continue'
 461
 462     def do_where(self, arg):
 463         self.print_stack_trace()
 464     do_w = do_where
 465     do_bt = do_where
 466
 467     def do_up(self, arg):
 468         if self.curindex == 0:
 469             print '*** Oldest frame'
 470         else:
 471             self.curindex = self.curindex - 1
 472             self.curframe = self.stack[self.curindex][0]
 473             self.print_stack_entry(self.stack[self.curindex])
 474             self.lineno = None
 475     do_u = do_up
 476
 477     def do_down(self, arg):
 478         if self.curindex + 1 == len(self.stack):
 479             print '*** Newest frame'
 480         else:
 481             self.curindex = self.curindex + 1
 482             self.curframe = self.stack[self.curindex][0]
 483             self.print_stack_entry(self.stack[self.curindex])
 484             self.lineno = None
 485     do_d = do_down
 486
 487     def do_step(self, arg):
 488         self.set_step()
 489         return 1
 490     do_s = do_step
 491
 492     def do_next(self, arg):
 493         self.set_next(self.curframe)
 494         return 1
 495     do_n = do_next
 496
 497     def do_return(self, arg):
 498         self.set_return(self.curframe)
 499         return 1
 500     do_r = do_return
 501
 502     def do_continue(self, arg):
 503         self.set_continue()
 504         return 1
 505     do_c = do_cont = do_continue
 506
 507     def do_jump(self, arg):
 508         if self.curindex + 1 != len(self.stack):
 509             print "*** You can only jump within the bottom frame"
 510             return
 511         try:
 512             arg = int(arg)
 513         except ValueError:
 514             print "*** The 'jump' command requires a line number."
 515         else:
 516             try:
 517                 # Do the jump, fix up our copy of the stack, and display the
 518                 # new position
 519                 self.curframe.f_lineno = arg
 520                 self.stack[self.curindex] = self.stack[self.curindex][0], arg
 521                 self.print_stack_entry(self.stack[self.curindex])
 522             except ValueError, e:
 523                 print '*** Jump failed:', e
 524     do_j = do_jump
 525
 526     def do_quit(self, arg):
 527         self.set_quit()
 528         return 1
 529     do_q = do_quit
 530     do_exit = do_quit
 531
 532     def do_EOF(self, arg):
 533         print
 534         self.set_quit()
 535         return 1
 536
 537     def do_args(self, arg):
 538         f = self.curframe
 539         co = f.f_code
 540         dict = f.f_locals
 541         n = co.co_argcount
 542         if co.co_flags & 4: n = n+1
 543         if co.co_flags & 8: n = n+1
 544         for i in range(n):
 545             name = co.co_varnames[i]
 546             print name, '=',
 547             if name in dict: print dict[name]
 548             else: print "*** undefined ***"
 549     do_a = do_args
 550
 551     def do_retval(self, arg):
 552         if '__return__' in self.curframe.f_locals:
 553             print self.curframe.f_locals['__return__']
 554         else:
 555             print '*** Not yet returned!'
 556     do_rv = do_retval
 557
 558     def _getval(self, arg):
 559         try:
 560             return eval(arg, self.curframe.f_globals,
 561                         self.curframe.f_locals)
 562         except:
 563             t, v = sys.exc_info()[:2]
 564             if isinstance(t, str):
 565                 exc_type_name = t
 566             else: exc_type_name = t.__name__
 567             print '***', exc_type_name + ':', `v`
 568             raise
 569
 570     def do_p(self, arg):
 571         try:
 572             print repr(self._getval(arg))
 573         except:
 574             pass
 575
 576     def do_pp(self, arg):
 577         try:
 578             pprint.pprint(self._getval(arg))
 579         except:
 580             pass
 581
 582     def do_list(self, arg):
 583         self.lastcmd = 'list'
 584         last = None
 585         if arg:
 586             try:
 587                 x = eval(arg, {}, {})
 588                 if type(x) == type(()):
 589                     first, last = x
 590                     first = int(first)
 591                     last = int(last)
 592                     if last < first:
 593                         # Assume it's a count
 594                         last = first + last
 595                 else:
 596                     first = max(1, int(x) - 5)
 597             except:
 598                 print '*** Error in argument:', `arg`
 599                 return
 600         elif self.lineno is None:
 601             first = max(1, self.curframe.f_lineno - 5)
 602         else:
 603             first = self.lineno + 1
 604         if last is None:
 605             last = first + 10
 606         filename = self.curframe.f_code.co_filename
 607         breaklist = self.get_file_breaks(filename)
 608         try:
 609             for lineno in range(first, last+1):
 610                 line = linecache.getline(filename, lineno)
 611                 if not line:
 612                     print '[EOF]'
 613                     break
 614                 else:
 615                     s = `lineno`.rjust(3)
 616                     if len(s) < 4: s = s + ' '
 617                     if lineno in breaklist: s = s + 'B'
 618                     else: s = s + ' '
 619                     if lineno == self.curframe.f_lineno:
 620                         s = s + '->'
 621                     print s + '\t' + line,
 622                     self.lineno = lineno
 623         except KeyboardInterrupt:
 624             pass
 625     do_l = do_list
 626
 627     def do_whatis(self, arg):
 628         try:
 629             value = eval(arg, self.curframe.f_globals,
 630                             self.curframe.f_locals)
 631         except:
 632             t, v = sys.exc_info()[:2]
 633             if type(t) == type(''):
 634                 exc_type_name = t
 635             else: exc_type_name = t.__name__
 636             print '***', exc_type_name + ':', `v`
 637             return
 638         code = None
 639         # Is it a function?
 640         try: code = value.func_code
 641         except: pass
 642         if code:
 643             print 'Function', code.co_name
 644             return
 645         # Is it an instance method?
 646         try: code = value.im_func.func_code
 647         except: pass
 648         if code:
 649             print 'Method', code.co_name
 650             return
 651         # None of the above...
 652         print type(value)
 653
 654     def do_alias(self, arg):
 655         args = arg.split()
 656         if len(args) == 0:
 657             keys = self.aliases.keys()
 658             keys.sort()
 659             for alias in keys:
 660                 print "%s = %s" % (alias, self.aliases[alias])
 661             return
 662         if args[0] in self.aliases and len(args) == 1:
 663             print "%s = %s" % (args[0], self.aliases[args[0]])
 664         else:
 665             self.aliases[args[0]] = ' '.join(args[1:])
 666
 667     def do_unalias(self, arg):
 668         args = arg.split()
 669         if len(args) == 0: return
 670         if args[0] in self.aliases:
 671             del self.aliases[args[0]]
 672
 673     # Print a traceback starting at the top stack frame.
 674     # The most recently entered frame is printed last;
 675     # this is different from dbx and gdb, but consistent with
 676     # the Python interpreter's stack trace.
 677     # It is also consistent with the up/down commands (which are
 678     # compatible with dbx and gdb: up moves towards 'main()'
 679     # and down moves towards the most recent stack frame).
 680
 681     def print_stack_trace(self):
 682         try:
 683             for frame_lineno in self.stack:
 684                 self.print_stack_entry(frame_lineno)
 685         except KeyboardInterrupt:
 686             pass
 687
 688     def print_stack_entry(self, frame_lineno, prompt_prefix=line_prefix):
 689         frame, lineno = frame_lineno
 690         if frame is self.curframe:
 691             print '>',
 692         else:
 693             print ' ',
 694         print self.format_stack_entry(frame_lineno, prompt_prefix)
 695
 696
 697     # Help methods (derived from pdb.doc)
 698
 699     def help_help(self):
 700         self.help_h()
 701
 702     def help_h(self):
 703         print """h(elp)
 704 Without argument, print the list of available commands.
 705 With a command name as argument, print help about that command
 706 "help pdb" pipes the full documentation file to the $PAGER
 707 "help exec" gives help on the ! command"""
 708
 709     def help_where(self):
 710         self.help_w()
 711
 712     def help_w(self):
 713         print """w(here)
 714 Print a stack trace, with the most recent frame at the bottom.
 715 An arrow indicates the "current frame", which determines the
 716 context of most commands.  'bt' is an alias for this command."""
 717
 718     help_bt = help_w
 719
 720     def help_down(self):
 721         self.help_d()
 722
 723     def help_d(self):
 724         print """d(own)
 725 Move the current frame one level down in the stack trace
 726 (to an older frame)."""
 727
 728     def help_up(self):
 729         self.help_u()
 730
 731     def help_u(self):
 732         print """u(p)
 733 Move the current frame one level up in the stack trace
 734 (to a newer frame)."""
 735
 736     def help_break(self):
 737         self.help_b()
 738
 739     def help_b(self):
 740         print """b(reak) ([file:]lineno | function) [, condition]
 741 With a line number argument, set a break there in the current
 742 file.  With a function name, set a break at first executable line
 743 of that function.  Without argument, list all breaks.  If a second
 744 argument is present, it is a string specifying an expression
 745 which must evaluate to true before the breakpoint is honored.
 746
 747 The line number may be prefixed with a filename and a colon,
 748 to specify a breakpoint in another file (probably one that
 749 hasn't been loaded yet).  The file is searched for on sys.path;
 750 the .py suffix may be omitted."""
 751
 752     def help_clear(self):
 753         self.help_cl()
 754
 755     def help_cl(self):
 756         print "cl(ear) filename:lineno"
 757         print """cl(ear) [bpnumber [bpnumber...]]
 758 With a space separated list of breakpoint numbers, clear
 759 those breakpoints.  Without argument, clear all breaks (but
 760 first ask confirmation).  With a filename:lineno argument,
 761 clear all breaks at that line in that file.
 762
 763 Note that the argument is different from previous versions of
 764 the debugger (in python distributions 1.5.1 and before) where
 765 a linenumber was used instead of either filename:lineno or
 766 breakpoint numbers."""
 767
 768     def help_tbreak(self):
 769         print """tbreak  same arguments as break, but breakpoint is
 770 removed when first hit."""
 771
 772     def help_enable(self):
 773         print """enable bpnumber [bpnumber ...]
 774 Enables the breakpoints given as a space separated list of
 775 bp numbers."""
 776
 777     def help_disable(self):
 778         print """disable bpnumber [bpnumber ...]
 779 Disables the breakpoints given as a space separated list of
 780 bp numbers."""
 781
 782     def help_ignore(self):
 783         print """ignore bpnumber count
 784 Sets the ignore count for the given breakpoint number.  A breakpoint
 785 becomes active when the ignore count is zero.  When non-zero, the
 786 count is decremented each time the breakpoint is reached and the
 787 breakpoint is not disabled and any associated condition evaluates
 788 to true."""
 789
 790     def help_condition(self):
 791         print """condition bpnumber str_condition
 792 str_condition is a string specifying an expression which
 793 must evaluate to true before the breakpoint is honored.
 794 If str_condition is absent, any existing condition is removed;
 795 i.e., the breakpoint is made unconditional."""
 796
 797     def help_step(self):
 798         self.help_s()
 799
 800     def help_s(self):
 801         print """s(tep)
 802 Execute the current line, stop at the first possible occasion
 803 (either in a function that is called or in the current function)."""
 804
 805     def help_next(self):
 806         self.help_n()
 807
 808     def help_n(self):
 809         print """n(ext)
 810 Continue execution until the next line in the current function
 811 is reached or it returns."""
 812
 813     def help_return(self):
 814         self.help_r()
 815
 816     def help_r(self):
 817         print """r(eturn)
 818 Continue execution until the current function returns."""
 819
 820     def help_continue(self):
 821         self.help_c()
 822
 823     def help_cont(self):
 824         self.help_c()
 825
 826     def help_c(self):
 827         print """c(ont(inue))
 828 Continue execution, only stop when a breakpoint is encountered."""
 829
 830     def help_jump(self):
 831         self.help_j()
 832
 833     def help_j(self):
 834         print """j(ump) lineno
 835 Set the next line that will be executed."""
 836
 837     def help_list(self):
 838         self.help_l()
 839
 840     def help_l(self):
 841         print """l(ist) [first [,last]]
 842 List source code for the current file.
 843 Without arguments, list 11 lines around the current line
 844 or continue the previous listing.
 845 With one argument, list 11 lines starting at that line.
 846 With two arguments, list the given range;
 847 if the second argument is less than the first, it is a count."""
 848
 849     def help_args(self):
 850         self.help_a()
 851
 852     def help_a(self):
 853         print """a(rgs)
 854 Print the arguments of the current function."""
 855
 856     def help_p(self):
 857         print """p expression
 858 Print the value of the expression."""
 859
 860     def help_pp(self):
 861         print """pp expression
 862 Pretty-print the value of the expression."""
 863
 864     def help_exec(self):
 865         print """(!) statement
 866 Execute the (one-line) statement in the context of
 867 the current stack frame.
 868 The exclamation point can be omitted unless the first word
 869 of the statement resembles a debugger command.
 870 To assign to a global variable you must always prefix the
 871 command with a 'global' command, e.g.:
 872 (Pdb) global list_options; list_options = ['-l']
 873 (Pdb)"""
 874
 875     def help_quit(self):
 876         self.help_q()
 877
 878     def help_q(self):
 879         print """q(uit) or exit - Quit from the debugger.
 880 The program being executed is aborted."""
 881
 882     help_exit = help_q
 883
 884     def help_whatis(self):
 885         print """whatis arg
 886 Prints the type of the argument."""
 887
 888     def help_EOF(self):
 889         print """EOF
 890 Handles the receipt of EOF as a command."""
 891
 892     def help_alias(self):
 893         print """alias [name [command [parameter parameter ...] ]]
 894 Creates an alias called 'name' the executes 'command'.  The command
 895 must *not* be enclosed in quotes.  Replaceable parameters are
 896 indicated by %1, %2, and so on, while %* is replaced by all the
 897 parameters.  If no command is given, the current alias for name
 898 is shown. If no name is given, all aliases are listed.
 899
 900 Aliases may be nested and can contain anything that can be
 901 legally typed at the pdb prompt.  Note!  You *can* override
 902 internal pdb commands with aliases!  Those internal commands
 903 are then hidden until the alias is removed.  Aliasing is recursively
 904 applied to the first word of the command line; all other words
 905 in the line are left alone.
 906
 907 Some useful aliases (especially when placed in the .pdbrc file) are:
 908
 909 #Print instance variables (usage "pi classInst")
 910 alias pi for k in %1.__dict__.keys(): print "%1.",k,"=",%1.__dict__[k]
 911
 912 #Print instance variables in self
 913 alias ps pi self
 914 """
 915
 916     def help_unalias(self):
 917         print """unalias name
 918 Deletes the specified alias."""
 919
 920     def help_pdb(self):
 921         help()
 922
 923     def lookupmodule(self, filename):
 924         """Helper function for break/clear parsing -- may be overridden."""
 925         root, ext = os.path.splitext(filename)
 926         if ext == '':
 927             filename = filename + '.py'
 928         if os.path.isabs(filename):
 929             return filename
 930         for dirname in sys.path:
 931             while os.path.islink(dirname):
 932                 dirname = os.readlink(dirname)
 933             fullname = os.path.join(dirname, filename)
 934             if os.path.exists(fullname):
 935                 return fullname
 936         return None
 937
 938 # Simplified interface
 939
 940 def run(statement, globals=None, locals=None):
 941     Pdb().run(statement, globals, locals)
 942
 943 def runeval(expression, globals=None, locals=None):
 944     return Pdb().runeval(expression, globals, locals)
 945
 946 def runctx(statement, globals, locals):
 947     # B/W compatibility
 948     run(statement, globals, locals)
 949
 950 def runcall(*args):
 951     return Pdb().runcall(*args)
 952
 953 def set_trace():
 954     Pdb().set_trace()
 955
 956 # Post-Mortem interface
 957
 958 def post_mortem(t):
 959     p = Pdb()
 960     p.reset()
 961     while t.tb_next is not None:
 962         t = t.tb_next
 963     p.interaction(t.tb_frame, t)
 964
 965 def pm():
 966     post_mortem(sys.last_traceback)
 967
 968
 969 # Main program for testing
 970
 971 TESTCMD = 'import x; x.main()'
 972
 973 def test():
 974     run(TESTCMD)
 975
 976 # print help
 977 def help():
 978     for dirname in sys.path:
 979         fullname = os.path.join(dirname, 'pdb.doc')
 980         if os.path.exists(fullname):
 981             sts = os.system('${PAGER-more} '+fullname)
 982             if sts: print '*** Pager exit status:', sts
 983             break
 984     else:
 985         print 'Sorry, can\'t find the help file "pdb.doc"',
 986         print 'along the Python search path'
 987
 988 mainmodule = ''
 989 mainpyfile = ''
 990
 991 # When invoked as main program, invoke the debugger on a script
 992 if __name__=='__main__':
 993     if not sys.argv[1:]:
 994         print "usage: pdb.py scriptfile [arg] ..."
 995         sys.exit(2)
 996
 997     mainpyfile = filename = sys.argv[1]     # Get script filename
 998     if not os.path.exists(filename):
 999         print 'Error:', `filename`, 'does not exist'
1000         sys.exit(1)
1001     mainmodule = os.path.basename(filename)
1002     del sys.argv[0]         # Hide "pdb.py" from argument list
1003
1004     # Insert script directory in front of module search path
1005     sys.path.insert(0, os.path.dirname(filename))
1006
1007     run('execfile(' + `filename` + ')')