Lib/bdb.py

   1 # A generic Python debugger base class.
   2 # This class takes care of details of the trace facility;
   3 # a derived class should implement user interaction.
   4 # There are two debuggers based upon this:
   5 # 'pdb', a text-oriented debugger not unlike dbx or gdb;
   6 # and 'wdb', a window-oriented debugger.
   7 # And of course... you can roll your own!
   8
   9 import sys
  10
  11 BdbQuit = 'bdb.BdbQuit' # Exception to give up completely
  12
  13
  14 class Bdb: # Basic Debugger
  15
  16         def __init__(self):
  17                 self.breaks = {}
  18
  19         def reset(self):
  20                 import linecache
  21                 linecache.checkcache()
  22                 self.botframe = None
  23                 self.stopframe = None
  24                 self.returnframe = None
  25                 self.quitting = 0
  26
  27         def trace_dispatch(self, frame, event, arg):
  28                 if self.quitting:
  29                         return # None
  30                 if event == 'line':
  31                         return self.dispatch_line(frame)
  32                 if event == 'call':
  33                         return self.dispatch_call(frame, arg)
  34                 if event == 'return':
  35                         return self.dispatch_return(frame, arg)
  36                 if event == 'exception':
  37                         return self.dispatch_exception(frame, arg)
  38                 print 'bdb.Bdb.dispatch: unknown debugging event:', `event`
  39                 return self.trace_dispatch
  40
  41         def dispatch_line(self, frame):
  42                 if self.stop_here(frame) or self.break_here(frame):
  43                         self.user_line(frame)
  44                         if self.quitting: raise BdbQuit
  45                 return self.trace_dispatch
  46
  47         def dispatch_call(self, frame, arg):
  48                 frame.f_locals['__args__'] = arg
  49                 if self.botframe is None:
  50                         # First call of dispatch since reset()
  51                         self.botframe = frame
  52                         return self.trace_dispatch
  53                 if not (self.stop_here(frame) or self.break_anywhere(frame)):
  54                         # No need to trace this function
  55                         return # None
  56                 self.user_call(frame, arg)
  57                 if self.quitting: raise BdbQuit
  58                 return self.trace_dispatch
  59
  60         def dispatch_return(self, frame, arg):
  61                 if self.stop_here(frame) or frame == self.returnframe:
  62                         self.user_return(frame, arg)
  63                         if self.quitting: raise BdbQuit
  64
  65         def dispatch_exception(self, frame, arg):
  66                 if self.stop_here(frame):
  67                         self.user_exception(frame, arg)
  68                         if self.quitting: raise BdbQuit
  69                 return self.trace_dispatch
  70
  71         # Normally derived classes don't override the following
  72         # methods, but they may if they want to redefine the
  73         # definition of stopping and breakpoints.
  74
  75         def stop_here(self, frame):
  76                 if self.stopframe is None:
  77                         return 1
  78                 if frame is self.stopframe:
  79                         return 1
  80                 while frame is not None and frame is not self.stopframe:
  81                         if frame is self.botframe:
  82                                 return 1
  83                         frame = frame.f_back
  84                 return 0
  85
  86         def break_here(self, frame):
  87                 if not self.breaks.has_key(frame.f_code.co_filename):
  88                         return 0
  89                 if not frame.f_lineno in \
  90                                 self.breaks[frame.f_code.co_filename]:
  91                         return 0
  92                 return 1
  93
  94         def break_anywhere(self, frame):
  95                 return self.breaks.has_key(frame.f_code.co_filename)
  96
  97         # Derived classes should override the user_* methods
  98         # to gain control.
  99
 100         def user_call(self, frame, argument_list):
 101                 # This method is called when there is the remote possibility
 102                 # that we ever need to stop in this function
 103                 pass
 104
 105         def user_line(self, frame):
 106                 # This method is called when we stop or break at this line
 107                 pass
 108
 109         def user_return(self, frame, return_value):
 110                 # This method is called when a return trap is set here
 111                 pass
 112
 113         def user_exception(self, frame, (exc_type, exc_value, exc_traceback)):
 114                 # This method is called if an exception occurs,
 115                 # but only if we are to stop at or just below this level
 116                 pass
 117
 118         # Derived classes and clients can call the following methods
 119         # to affect the stepping state.
 120
 121         def set_step(self):
 122                 # Stop after one line of code
 123                 self.stopframe = None
 124                 self.returnframe = None
 125                 self.quitting = 0
 126
 127         def set_next(self, frame):
 128                 # Stop on the next line in or below the given frame
 129                 self.stopframe = frame
 130                 self.returnframe = None
 131                 self.quitting = 0
 132
 133         def set_return(self, frame):
 134                 # Stop when returning from the given frame
 135                 self.stopframe = frame.f_back
 136                 self.returnframe = frame
 137                 self.quitting = 0
 138
 139         def set_trace(self):
 140                 # Start debugging from here
 141                 try:
 142                         1 + ''
 143                 except:
 144                         frame = sys.exc_traceback.tb_frame.f_back
 145                 self.reset()
 146                 while frame:
 147                         frame.f_trace = self.trace_dispatch
 148                         self.botframe = frame
 149                         frame = frame.f_back
 150                 self.set_step()
 151                 sys.settrace(self.trace_dispatch)
 152
 153         def set_continue(self):
 154                 # Don't stop except at breakpoints or when finished
 155                 self.stopframe = self.botframe
 156                 self.returnframe = None
 157                 self.quitting = 0
 158                 if not self.breaks:
 159                         # no breakpoints; run without debugger overhead
 160                         sys.settrace(None)
 161                         try:
 162                                 1 + ''  # raise an exception
 163                         except:
 164                                 frame = sys.exc_traceback.tb_frame.f_back
 165                         while frame and frame is not self.botframe:
 166                                 del frame.f_trace
 167                                 frame = frame.f_back
 168
 169         def set_quit(self):
 170                 self.stopframe = self.botframe
 171                 self.returnframe = None
 172                 self.quitting = 1
 173                 sys.settrace(None)
 174
 175         # Derived classes and clients can call the following methods
 176         # to manipulate breakpoints.  These methods return an
 177         # error message is something went wrong, None if all is well.
 178         # Call self.get_*break*() to see the breakpoints.
 179
 180         def set_break(self, filename, lineno):
 181                 import linecache # Import as late as possible
 182                 line = linecache.getline(filename, lineno)
 183                 if not line:
 184                         return 'That line does not exist!'
 185                 if not self.breaks.has_key(filename):
 186                         self.breaks[filename] = []
 187                 list = self.breaks[filename]
 188                 if lineno in list:
 189                         return 'There is already a breakpoint there!'
 190                 list.append(lineno)
 191
 192         def clear_break(self, filename, lineno):
 193                 if not self.breaks.has_key(filename):
 194                         return 'There are no breakpoints in that file!'
 195                 if lineno not in self.breaks[filename]:
 196                         return 'There is no breakpoint there!'
 197                 self.breaks[filename].remove(lineno)
 198                 if not self.breaks[filename]:
 199                         del self.breaks[filename]
 200
 201         def clear_all_file_breaks(self, filename):
 202                 if not self.breaks.has_key(filename):
 203                         return 'There are no breakpoints in that file!'
 204                 del self.breaks[filename]
 205
 206         def clear_all_breaks(self):
 207                 if not self.breaks:
 208                         return 'There are no breakpoints!'
 209                 self.breaks = {}
 210
 211         def get_break(self, filename, lineno):
 212                 return self.breaks.has_key(filename) and \
 213                         lineno in self.breaks[filename]
 214
 215         def get_file_breaks(self, filename):
 216                 if self.breaks.has_key(filename):
 217                         return self.breaks[filename]
 218                 else:
 219                         return []
 220
 221         def get_all_breaks(self):
 222                 return self.breaks
 223
 224         # Derived classes and clients can call the following method
 225         # to get a data structure representing a stack trace.
 226
 227         def get_stack(self, f, t):
 228                 stack = []
 229                 if t and t.tb_frame is f:
 230                         t = t.tb_next
 231                 while f is not None:
 232                         stack.append((f, f.f_lineno))
 233                         if f is self.botframe:
 234                                 break
 235                         f = f.f_back
 236                 stack.reverse()
 237                 i = max(0, len(stack) - 1)
 238                 while t is not None:
 239                         stack.append((t.tb_frame, t.tb_lineno))
 240                         t = t.tb_next
 241                 return stack, i
 242
 243         #
 244
 245         def format_stack_entry(self, frame_lineno, lprefix=': '):
 246                 import linecache, repr, string
 247                 frame, lineno = frame_lineno
 248                 filename = frame.f_code.co_filename
 249                 s = filename + '(' + `lineno` + ')'
 250                 if frame.f_code.co_name:
 251                     s = s + frame.f_code.co_name
 252                 else:
 253                     s = s + "<lambda>"
 254                 if frame.f_locals.has_key('__args__'):
 255                         args = frame.f_locals['__args__']
 256                 else:
 257                         args = None
 258                 if args:
 259                         s = s + repr.repr(args)
 260                 else:
 261                         s = s + '()'
 262                 if frame.f_locals.has_key('__return__'):
 263                         rv = frame.f_locals['__return__']
 264                         s = s + '->'
 265                         s = s + repr.repr(rv)
 266                 line = linecache.getline(filename, lineno)
 267                 if line: s = s + lprefix + string.strip(line)
 268                 return s
 269
 270         # The following two methods can be called by clients to use
 271         # a debugger to debug a statement, given as a string.
 272
 273         def run(self, cmd, globals=None, locals=None):
 274                 if globals is None:
 275                         import __main__
 276                         globals = __main__.__dict__
 277                 if locals is None:
 278                         locals = globals
 279                 self.reset()
 280                 sys.settrace(self.trace_dispatch)
 281                 try:
 282                         try:
 283                                 exec cmd + '\n' in globals, locals
 284                         except BdbQuit:
 285                                 pass
 286                 finally:
 287                         self.quitting = 1
 288                         sys.settrace(None)
 289
 290         def runeval(self, expr, globals=None, locals=None):
 291                 if globals is None:
 292                         import __main__
 293                         globals = __main__.__dict__
 294                 if locals is None:
 295                         locals = globals
 296                 self.reset()
 297                 sys.settrace(self.trace_dispatch)
 298                 try:
 299                         try:
 300                                 return eval(expr + '\n', globals, locals)
 301                         except BdbQuit:
 302                                 pass
 303                 finally:
 304                         self.quitting = 1
 305                         sys.settrace(None)
 306
 307         def runctx(self, cmd, globals, locals):
 308                 # B/W compatibility
 309                 self.run(cmd, globals, locals)
 310
 311         # This method is more useful to debug a single function call.
 312
 313         def runcall(self, func, *args):
 314                 self.reset()
 315                 sys.settrace(self.trace_dispatch)
 316                 res = None
 317                 try:
 318                         try:
 319                                 res = apply(func, args)
 320                         except BdbQuit:
 321                                 pass
 322                 finally:
 323                         self.quitting = 1
 324                         sys.settrace(None)
 325                 return res
 326
 327
 328 def set_trace():
 329         Bdb().set_trace()
 330
 331 # -------------------- testing --------------------
 332
 333 class Tdb(Bdb):
 334         def user_call(self, frame, args):
 335                 name = frame.f_code.co_name
 336                 if not name: name = '???'
 337                 print '+++ call', name, args
 338         def user_line(self, frame):
 339                 import linecache, string
 340                 name = frame.f_code.co_name
 341                 if not name: name = '???'
 342                 fn = frame.f_code.co_filename
 343                 line = linecache.getline(fn, frame.f_lineno)
 344                 print '+++', fn, frame.f_lineno, name, ':', string.strip(line)
 345         def user_return(self, frame, retval):
 346                 print '+++ return', retval
 347         def user_exception(self, frame, exc_stuff):
 348                 print '+++ exception', exc_stuff
 349                 self.set_continue()
 350
 351 def foo(n):
 352         print 'foo(', n, ')'
 353         x = bar(n*10)
 354         print 'bar returned', x
 355
 356 def bar(a):
 357         print 'bar(', a, ')'
 358         return a/2
 359
 360 def test():
 361         t = Tdb()
 362         t.run('import bdb; bdb.foo(10)')