home *** CD-ROM | disk | FTP | other *** search
/ PC PowerPlay 56 / CDPowerplay56Disc2.iso / demos / blade / data1.cab / Program_Executable_Files / Lib / PythonLib / bdb.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2000-10-27  |  14.4 KB  |  453 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 1.5)
  3.  
  4. import sys
  5. import types
  6. BdbQuit = 'bdb.BdbQuit'
  7.  
  8. class Bdb:
  9.     
  10.     def __init__(self):
  11.         self.breaks = { }
  12.         self.cbreaks = { }
  13.  
  14.     
  15.     def reset(self):
  16.         import linecache
  17.         linecache.checkcache()
  18.         self.botframe = None
  19.         self.stopframe = None
  20.         self.returnframe = None
  21.         self.quitting = 0
  22.  
  23.     
  24.     def trace_dispatch(self, frame, event, arg):
  25.         if self.quitting:
  26.             return None
  27.         
  28.         if event == 'line':
  29.             return self.dispatch_line(frame)
  30.         
  31.         if event == 'call':
  32.             return self.dispatch_call(frame, arg)
  33.         
  34.         if event == 'return':
  35.             return self.dispatch_return(frame, arg)
  36.         
  37.         if event == 'exception':
  38.             return self.dispatch_exception(frame, arg)
  39.         
  40.         print 'bdb.Bdb.dispatch: unknown debugging event:', `event`
  41.         return self.trace_dispatch
  42.  
  43.     
  44.     def dispatch_line(self, frame):
  45.         if self.stop_here(frame) or self.break_here(frame):
  46.             self.user_line(frame)
  47.             if self.quitting:
  48.                 raise BdbQuit
  49.             
  50.         
  51.         return self.trace_dispatch
  52.  
  53.     
  54.     def dispatch_call(self, frame, arg):
  55.         frame.f_locals['__args__'] = arg
  56.         if self.botframe is None:
  57.             self.botframe = frame
  58.             return self.trace_dispatch
  59.         
  60.         if not self.stop_here(frame):
  61.             pass
  62.         if not self.break_anywhere(frame):
  63.             return None
  64.         
  65.         self.user_call(frame, arg)
  66.         if self.quitting:
  67.             raise BdbQuit
  68.         
  69.         return self.trace_dispatch
  70.  
  71.     
  72.     def dispatch_return(self, frame, arg):
  73.         if self.stop_here(frame) or frame == self.returnframe:
  74.             self.user_return(frame, arg)
  75.             if self.quitting:
  76.                 raise BdbQuit
  77.             
  78.         
  79.  
  80.     
  81.     def dispatch_exception(self, frame, arg):
  82.         if self.stop_here(frame):
  83.             self.user_exception(frame, arg)
  84.             if self.quitting:
  85.                 raise BdbQuit
  86.             
  87.         
  88.         return self.trace_dispatch
  89.  
  90.     
  91.     def stop_here(self, frame):
  92.         if self.stopframe is None:
  93.             return 1
  94.         
  95.         if frame is self.stopframe:
  96.             return 1
  97.         
  98.         while frame is not None and frame is not self.stopframe:
  99.             if frame is self.botframe:
  100.                 return 1
  101.             
  102.             frame = frame.f_back
  103.         return 0
  104.  
  105.     
  106.     def break_here(self, frame):
  107.         filename = frame.f_code.co_filename
  108.         if not self.breaks.has_key(filename):
  109.             return 0
  110.         
  111.         lineno = frame.f_lineno
  112.         if not (lineno in self.breaks[filename]):
  113.             return 0
  114.         
  115.         if self.cbreaks.has_key((filename, lineno)):
  116.             cond = self.cbreaks[(filename, lineno)]
  117.             return eval(cond, frame.f_globals, frame.f_locals)
  118.         
  119.         return 1
  120.  
  121.     
  122.     def break_anywhere(self, frame):
  123.         return self.breaks.has_key(frame.f_code.co_filename)
  124.  
  125.     
  126.     def user_call(self, frame, argument_list):
  127.         pass
  128.  
  129.     
  130.     def user_line(self, frame):
  131.         pass
  132.  
  133.     
  134.     def user_return(self, frame, return_value):
  135.         pass
  136.  
  137.     
  138.     def user_exception(self, frame, .4):
  139.         (exc_type, exc_value, exc_traceback) = .4
  140.  
  141.     
  142.     def set_step(self):
  143.         self.stopframe = None
  144.         self.returnframe = None
  145.         self.quitting = 0
  146.  
  147.     
  148.     def set_next(self, frame):
  149.         self.stopframe = frame
  150.         self.returnframe = None
  151.         self.quitting = 0
  152.  
  153.     
  154.     def set_return(self, frame):
  155.         self.stopframe = frame.f_back
  156.         self.returnframe = frame
  157.         self.quitting = 0
  158.  
  159.     
  160.     def set_trace(self):
  161.         
  162.         try:
  163.             1 + ''
  164.         except:
  165.             frame = sys.exc_info()[2].tb_frame.f_back
  166.  
  167.         self.reset()
  168.         while frame:
  169.             frame.f_trace = self.trace_dispatch
  170.             self.botframe = frame
  171.             frame = frame.f_back
  172.         self.set_step()
  173.         sys.settrace(self.trace_dispatch)
  174.  
  175.     
  176.     def set_continue(self):
  177.         self.stopframe = self.botframe
  178.         self.returnframe = None
  179.         self.quitting = 0
  180.         if not (self.breaks):
  181.             sys.settrace(None)
  182.             
  183.             try:
  184.                 1 + ''
  185.             except:
  186.                 frame = sys.exc_info()[2].tb_frame.f_back
  187.  
  188.             while frame and frame is not self.botframe:
  189.                 del frame.f_trace
  190.                 frame = frame.f_back
  191.         
  192.  
  193.     
  194.     def set_quit(self):
  195.         self.stopframe = self.botframe
  196.         self.returnframe = None
  197.         self.quitting = 1
  198.         sys.settrace(None)
  199.  
  200.     
  201.     def set_break(self, filename, lineno, cond = None):
  202.         import linecache
  203.         line = linecache.getline(filename, lineno)
  204.         if not line:
  205.             return 'That line does not exist!'
  206.         
  207.         if not self.breaks.has_key(filename):
  208.             self.breaks[filename] = []
  209.         
  210.         list = self.breaks[filename]
  211.         if lineno in list:
  212.             return 'There is already a breakpoint there!'
  213.         
  214.         list.append(lineno)
  215.         if cond is not None:
  216.             self.cbreaks[(filename, lineno)] = cond
  217.         
  218.  
  219.     
  220.     def clear_break(self, filename, lineno):
  221.         if not self.breaks.has_key(filename):
  222.             return 'There are no breakpoints in that file!'
  223.         
  224.         if lineno not in self.breaks[filename]:
  225.             return 'There is no breakpoint there!'
  226.         
  227.         self.breaks[filename].remove(lineno)
  228.         if not self.breaks[filename]:
  229.             del self.breaks[filename]
  230.         
  231.         
  232.         try:
  233.             del self.cbreaks[(filename, lineno)]
  234.         except:
  235.             pass
  236.  
  237.  
  238.     
  239.     def clear_all_file_breaks(self, filename):
  240.         if not self.breaks.has_key(filename):
  241.             return 'There are no breakpoints in that file!'
  242.         
  243.         del self.breaks[filename]
  244.         for f, l in self.cbreaks.keys():
  245.             pass
  246.         
  247.  
  248.     
  249.     def clear_all_breaks(self):
  250.         if not (self.breaks):
  251.             return 'There are no breakpoints!'
  252.         
  253.         self.breaks = { }
  254.         self.cbreaks = { }
  255.  
  256.     
  257.     def get_break(self, filename, lineno):
  258.         if self.breaks.has_key(filename):
  259.             pass
  260.         return lineno in self.breaks[filename]
  261.  
  262.     
  263.     def get_file_breaks(self, filename):
  264.         if self.breaks.has_key(filename):
  265.             return self.breaks[filename]
  266.         else:
  267.             return []
  268.  
  269.     
  270.     def get_all_breaks(self):
  271.         return self.breaks
  272.  
  273.     
  274.     def get_stack(self, f, t):
  275.         stack = []
  276.         if t and t.tb_frame is f:
  277.             t = t.tb_next
  278.         
  279.         while f is not None:
  280.             stack.append((f, f.f_lineno))
  281.             if f is self.botframe:
  282.                 break
  283.             
  284.             f = f.f_back
  285.         stack.reverse()
  286.         i = max(0, len(stack) - 1)
  287.         while t is not None:
  288.             stack.append((t.tb_frame, t.tb_lineno))
  289.             t = t.tb_next
  290.         return (stack, i)
  291.  
  292.     
  293.     def format_stack_entry(self, frame_lineno, lprefix = ': '):
  294.         import linecache
  295.         import repr
  296.         import string
  297.         (frame, lineno) = frame_lineno
  298.         filename = frame.f_code.co_filename
  299.         s = filename + '(' + `lineno` + ')'
  300.         if frame.f_code.co_name:
  301.             s = s + frame.f_code.co_name
  302.         else:
  303.             s = s + '<lambda>'
  304.         if frame.f_locals.has_key('__args__'):
  305.             args = frame.f_locals['__args__']
  306.         else:
  307.             args = None
  308.         if args:
  309.             s = s + repr.repr(args)
  310.         else:
  311.             s = s + '()'
  312.         if frame.f_locals.has_key('__return__'):
  313.             rv = frame.f_locals['__return__']
  314.             s = s + '->'
  315.             s = s + repr.repr(rv)
  316.         
  317.         line = linecache.getline(filename, lineno)
  318.         if line:
  319.             s = s + lprefix + string.strip(line)
  320.         
  321.         return s
  322.  
  323.     
  324.     def run(self, cmd, globals = None, locals = None):
  325.         if globals is None:
  326.             import __main__
  327.             globals = __main__.__dict__
  328.         
  329.         if locals is None:
  330.             locals = globals
  331.         
  332.         self.reset()
  333.         sys.settrace(self.trace_dispatch)
  334.         if type(cmd) != types.CodeType:
  335.             cmd = cmd + '\n'
  336.         
  337.         
  338.         try:
  339.             
  340.             try:
  341.                 exec cmd in globals, locals
  342.             except BdbQuit:
  343.                 pass
  344.  
  345.         finally:
  346.             self.quitting = 1
  347.             sys.settrace(None)
  348.  
  349.  
  350.     
  351.     def runeval(self, expr, globals = None, locals = None):
  352.         if globals is None:
  353.             import __main__
  354.             globals = __main__.__dict__
  355.         
  356.         if locals is None:
  357.             locals = globals
  358.         
  359.         self.reset()
  360.         sys.settrace(self.trace_dispatch)
  361.         if type(expr) != types.CodeType:
  362.             expr = expr + '\n'
  363.         
  364.         
  365.         try:
  366.             
  367.             try:
  368.                 return eval(expr, globals, locals)
  369.             except BdbQuit:
  370.                 pass
  371.  
  372.         finally:
  373.             self.quitting = 1
  374.             sys.settrace(None)
  375.  
  376.  
  377.     
  378.     def runctx(self, cmd, globals, locals):
  379.         self.run(cmd, globals, locals)
  380.  
  381.     
  382.     def runcall(self, func, *args):
  383.         self.reset()
  384.         sys.settrace(self.trace_dispatch)
  385.         res = None
  386.         
  387.         try:
  388.             
  389.             try:
  390.                 res = apply(func, args)
  391.             except BdbQuit:
  392.                 pass
  393.  
  394.         finally:
  395.             self.quitting = 1
  396.             sys.settrace(None)
  397.  
  398.         return res
  399.  
  400.  
  401.  
  402. def set_trace():
  403.     Bdb().set_trace()
  404.  
  405.  
  406. class Tdb(Bdb):
  407.     
  408.     def user_call(self, frame, args):
  409.         name = frame.f_code.co_name
  410.         if not name:
  411.             name = '???'
  412.         
  413.         print '+++ call', name, args
  414.  
  415.     
  416.     def user_line(self, frame):
  417.         import linecache
  418.         import string
  419.         name = frame.f_code.co_name
  420.         if not name:
  421.             name = '???'
  422.         
  423.         fn = frame.f_code.co_filename
  424.         line = linecache.getline(fn, frame.f_lineno)
  425.         print '+++', fn, frame.f_lineno, name, ':', string.strip(line)
  426.  
  427.     
  428.     def user_return(self, frame, retval):
  429.         print '+++ return', retval
  430.  
  431.     
  432.     def user_exception(self, frame, exc_stuff):
  433.         print '+++ exception', exc_stuff
  434.         self.set_continue()
  435.  
  436.  
  437.  
  438. def foo(n):
  439.     print 'foo(', n, ')'
  440.     x = bar(n * 10)
  441.     print 'bar returned', x
  442.  
  443.  
  444. def bar(a):
  445.     print 'bar(', a, ')'
  446.     return a / 2
  447.  
  448.  
  449. def test():
  450.     t = Tdb()
  451.     t.run('import bdb; bdb.foo(10)')
  452.  
  453.