home *** CD-ROM | disk | FTP | other *** search
/ Chip 2003 January / Chip_2003-01_cd2.bin / convert / eJayMp3Pro / mp3pro_demo.exe / BDB.PYC (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2000-06-29  |  20.5 KB  |  606 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.     '''Generic Python debugger base class.
  10.  
  11. \tThis class takes care of details of the trace facility;
  12. \ta derived class should implement user interaction.
  13. \tThe standard debugger class (pdb.Pdb) is an example.
  14. \t'''
  15.     
  16.     def __init__(self):
  17.         self.breaks = { }
  18.         if not hasattr(self, 'canonic'):
  19.             self.canonic = str
  20.         
  21.  
  22.     
  23.     def reset(self):
  24.         import linecache
  25.         linecache.checkcache()
  26.         self.botframe = None
  27.         self.stopframe = None
  28.         self.returnframe = None
  29.         self.quitting = 0
  30.  
  31.     
  32.     def trace_dispatch(self, frame, event, arg):
  33.         if self.quitting:
  34.             return None
  35.         
  36.         if event == 'line':
  37.             return self.dispatch_line(frame)
  38.         
  39.         if event == 'call':
  40.             return self.dispatch_call(frame, arg)
  41.         
  42.         if event == 'return':
  43.             return self.dispatch_return(frame, arg)
  44.         
  45.         if event == 'exception':
  46.             return self.dispatch_exception(frame, arg)
  47.         
  48.         print 'bdb.Bdb.dispatch: unknown debugging event:', `event`
  49.         return self.trace_dispatch
  50.  
  51.     
  52.     def dispatch_line(self, frame):
  53.         if self.stop_here(frame) or self.break_here(frame):
  54.             self.user_line(frame)
  55.             if self.quitting:
  56.                 raise BdbQuit
  57.             
  58.         
  59.         return self.trace_dispatch
  60.  
  61.     
  62.     def dispatch_call(self, frame, arg):
  63.         if self.botframe is None:
  64.             self.botframe = frame
  65.             return self.trace_dispatch
  66.         
  67.         if not self.stop_here(frame):
  68.             pass
  69.         if not self.break_anywhere(frame):
  70.             return None
  71.         
  72.         self.user_call(frame, arg)
  73.         if self.quitting:
  74.             raise BdbQuit
  75.         
  76.         return self.trace_dispatch
  77.  
  78.     
  79.     def dispatch_return(self, frame, arg):
  80.         if self.stop_here(frame) or frame == self.returnframe:
  81.             self.user_return(frame, arg)
  82.             if self.quitting:
  83.                 raise BdbQuit
  84.             
  85.         
  86.  
  87.     
  88.     def dispatch_exception(self, frame, arg):
  89.         if self.stop_here(frame):
  90.             self.user_exception(frame, arg)
  91.             if self.quitting:
  92.                 raise BdbQuit
  93.             
  94.         
  95.         return self.trace_dispatch
  96.  
  97.     
  98.     def stop_here(self, frame):
  99.         if self.stopframe is None:
  100.             return 1
  101.         
  102.         if frame is self.stopframe:
  103.             return 1
  104.         
  105.         while frame is not None and frame is not self.stopframe:
  106.             if frame is self.botframe:
  107.                 return 1
  108.             
  109.             frame = frame.f_back
  110.         return 0
  111.  
  112.     
  113.     def break_here(self, frame):
  114.         filename = self.canonic(frame.f_code.co_filename)
  115.         if not self.breaks.has_key(filename):
  116.             return 0
  117.         
  118.         lineno = frame.f_lineno
  119.         if not (lineno in self.breaks[filename]):
  120.             return 0
  121.         
  122.         (bp, flag) = effective(filename, lineno, frame)
  123.         if bp:
  124.             self.currentbp = bp.number
  125.             if flag and bp.temporary:
  126.                 self.do_clear(str(bp.number))
  127.             
  128.             return 1
  129.         else:
  130.             return 0
  131.  
  132.     
  133.     def break_anywhere(self, frame):
  134.         return self.breaks.has_key(self.canonic(frame.f_code.co_filename))
  135.  
  136.     
  137.     def user_call(self, frame, argument_list):
  138.         pass
  139.  
  140.     
  141.     def user_line(self, frame):
  142.         pass
  143.  
  144.     
  145.     def user_return(self, frame, return_value):
  146.         pass
  147.  
  148.     
  149.     def user_exception(self, frame, .4):
  150.         (exc_type, exc_value, exc_traceback) = .4
  151.  
  152.     
  153.     def set_step(self):
  154.         self.stopframe = None
  155.         self.returnframe = None
  156.         self.quitting = 0
  157.  
  158.     
  159.     def set_next(self, frame):
  160.         self.stopframe = frame
  161.         self.returnframe = None
  162.         self.quitting = 0
  163.  
  164.     
  165.     def set_return(self, frame):
  166.         self.stopframe = frame.f_back
  167.         self.returnframe = frame
  168.         self.quitting = 0
  169.  
  170.     
  171.     def set_trace(self):
  172.         
  173.         try:
  174.             1 + ''
  175.         except:
  176.             frame = sys.exc_info()[2].tb_frame.f_back
  177.  
  178.         self.reset()
  179.         while frame:
  180.             frame.f_trace = self.trace_dispatch
  181.             self.botframe = frame
  182.             frame = frame.f_back
  183.         self.set_step()
  184.         sys.settrace(self.trace_dispatch)
  185.  
  186.     
  187.     def set_continue(self):
  188.         self.stopframe = self.botframe
  189.         self.returnframe = None
  190.         self.quitting = 0
  191.         if not (self.breaks):
  192.             sys.settrace(None)
  193.             
  194.             try:
  195.                 1 + ''
  196.             except:
  197.                 frame = sys.exc_info()[2].tb_frame.f_back
  198.  
  199.             while frame and frame is not self.botframe:
  200.                 del frame.f_trace
  201.                 frame = frame.f_back
  202.         
  203.  
  204.     
  205.     def set_quit(self):
  206.         self.stopframe = self.botframe
  207.         self.returnframe = None
  208.         self.quitting = 1
  209.         sys.settrace(None)
  210.  
  211.     
  212.     def set_break(self, filename, lineno, temporary = 0, cond = None):
  213.         filename = self.canonic(filename)
  214.         import linecache
  215.         line = linecache.getline(filename, lineno)
  216.         if not line:
  217.             return 'Line %s:%d does not exist' % (filename, lineno)
  218.         
  219.         if not self.breaks.has_key(filename):
  220.             self.breaks[filename] = []
  221.         
  222.         list = self.breaks[filename]
  223.         if not (lineno in list):
  224.             list.append(lineno)
  225.         
  226.         bp = Breakpoint(filename, lineno, temporary, cond)
  227.  
  228.     
  229.     def clear_break(self, filename, lineno):
  230.         filename = self.canonic(filename)
  231.         if not self.breaks.has_key(filename):
  232.             return 'There are no breakpoints in %s' % filename
  233.         
  234.         if lineno not in self.breaks[filename]:
  235.             return 'There is no breakpoint at %s:%d' % (filename, lineno)
  236.         
  237.         for bp in Breakpoint.bplist[(filename, lineno)][:]:
  238.             bp.deleteMe()
  239.         
  240.         if not self.breaks[filename]:
  241.             del self.breaks[filename]
  242.         
  243.  
  244.     
  245.     def clear_bpbynumber(self, arg):
  246.         
  247.         try:
  248.             number = int(arg)
  249.         except:
  250.             return 'Non-numeric breakpoint number (%s)' % arg
  251.  
  252.         
  253.         try:
  254.             bp = Breakpoint.bpbynumber[number]
  255.         except IndexError:
  256.             return 'Breakpoint number (%d) out of range' % number
  257.  
  258.         if not bp:
  259.             return 'Breakpoint (%d) already deleted' % number
  260.         
  261.         self.clear_break(bp.file, bp.line)
  262.  
  263.     
  264.     def clear_all_file_breaks(self, filename):
  265.         filename = self.canonic(filename)
  266.         if not self.breaks.has_key(filename):
  267.             return 'There are no breakpoints in %s' % filename
  268.         
  269.         for line in self.breaks[filename]:
  270.             blist = Breakpoint.bplist[(filename, line)]
  271.             for bp in blist:
  272.                 bp.deleteMe()
  273.             
  274.         
  275.         del self.breaks[filename]
  276.  
  277.     
  278.     def clear_all_breaks(self):
  279.         if not (self.breaks):
  280.             return 'There are no breakpoints'
  281.         
  282.         for bp in Breakpoint.bpbynumber:
  283.             pass
  284.         
  285.         self.breaks = { }
  286.  
  287.     
  288.     def get_break(self, filename, lineno):
  289.         filename = self.canonic(filename)
  290.         if self.breaks.has_key(filename):
  291.             pass
  292.         return lineno in self.breaks[filename]
  293.  
  294.     
  295.     def get_breaks(self, filename, lineno):
  296.         filename = self.canonic(filename)
  297.         if not self.breaks.has_key(filename) and lineno in self.breaks[filename] and Breakpoint.bplist[(filename, lineno)]:
  298.             pass
  299.         return []
  300.  
  301.     
  302.     def get_file_breaks(self, filename):
  303.         filename = self.canonic(filename)
  304.         if self.breaks.has_key(filename):
  305.             return self.breaks[filename]
  306.         else:
  307.             return []
  308.  
  309.     
  310.     def get_all_breaks(self):
  311.         return self.breaks
  312.  
  313.     
  314.     def get_stack(self, f, t):
  315.         stack = []
  316.         if t and t.tb_frame is f:
  317.             t = t.tb_next
  318.         
  319.         while f is not None:
  320.             stack.append((f, f.f_lineno))
  321.             if f is self.botframe:
  322.                 break
  323.             
  324.             f = f.f_back
  325.         stack.reverse()
  326.         i = max(0, len(stack) - 1)
  327.         while t is not None:
  328.             stack.append((t.tb_frame, t.tb_lineno))
  329.             t = t.tb_next
  330.         return (stack, i)
  331.  
  332.     
  333.     def format_stack_entry(self, frame_lineno, lprefix = ': '):
  334.         import linecache
  335.         import repr
  336.         import string
  337.         (frame, lineno) = frame_lineno
  338.         filename = self.canonic(frame.f_code.co_filename)
  339.         s = filename + '(' + `lineno` + ')'
  340.         if frame.f_code.co_name:
  341.             s = s + frame.f_code.co_name
  342.         else:
  343.             s = s + '<lambda>'
  344.         if frame.f_locals.has_key('__args__'):
  345.             args = frame.f_locals['__args__']
  346.         else:
  347.             args = None
  348.         if args:
  349.             s = s + repr.repr(args)
  350.         else:
  351.             s = s + '()'
  352.         if frame.f_locals.has_key('__return__'):
  353.             rv = frame.f_locals['__return__']
  354.             s = s + '->'
  355.             s = s + repr.repr(rv)
  356.         
  357.         line = linecache.getline(filename, lineno)
  358.         if line:
  359.             s = s + lprefix + string.strip(line)
  360.         
  361.         return s
  362.  
  363.     
  364.     def run(self, cmd, globals = None, locals = None):
  365.         if globals is None:
  366.             import __main__
  367.             globals = __main__.__dict__
  368.         
  369.         if locals is None:
  370.             locals = globals
  371.         
  372.         self.reset()
  373.         sys.settrace(self.trace_dispatch)
  374.         if type(cmd) != types.CodeType:
  375.             cmd = cmd + '\n'
  376.         
  377.         
  378.         try:
  379.             
  380.             try:
  381.                 exec cmd in globals, locals
  382.             except BdbQuit:
  383.                 pass
  384.  
  385.         finally:
  386.             self.quitting = 1
  387.             sys.settrace(None)
  388.  
  389.  
  390.     
  391.     def runeval(self, expr, globals = None, locals = None):
  392.         if globals is None:
  393.             import __main__
  394.             globals = __main__.__dict__
  395.         
  396.         if locals is None:
  397.             locals = globals
  398.         
  399.         self.reset()
  400.         sys.settrace(self.trace_dispatch)
  401.         if type(expr) != types.CodeType:
  402.             expr = expr + '\n'
  403.         
  404.         
  405.         try:
  406.             
  407.             try:
  408.                 return eval(expr, globals, locals)
  409.             except BdbQuit:
  410.                 pass
  411.  
  412.         finally:
  413.             self.quitting = 1
  414.             sys.settrace(None)
  415.  
  416.  
  417.     
  418.     def runctx(self, cmd, globals, locals):
  419.         self.run(cmd, globals, locals)
  420.  
  421.     
  422.     def runcall(self, func, *args):
  423.         self.reset()
  424.         sys.settrace(self.trace_dispatch)
  425.         res = None
  426.         
  427.         try:
  428.             
  429.             try:
  430.                 res = apply(func, args)
  431.             except BdbQuit:
  432.                 pass
  433.  
  434.         finally:
  435.             self.quitting = 1
  436.             sys.settrace(None)
  437.  
  438.         return res
  439.  
  440.  
  441.  
  442. def set_trace():
  443.     Bdb().set_trace()
  444.  
  445.  
  446. class Breakpoint:
  447.     '''Breakpoint class
  448.  
  449. \tImplements temporary breakpoints, ignore counts, disabling and
  450. \t(re)-enabling, and conditionals.
  451.  
  452. \tBreakpoints are indexed by number through bpbynumber and by
  453. \tthe file,line tuple using bplist.  The former points to a
  454. \tsingle instance of class Breakpoint.  The latter points to a
  455. \tlist of such instances since there may be more than one
  456. \tbreakpoint per line.
  457.  
  458. \t'''
  459.     next = 1
  460.     bplist = { }
  461.     bpbynumber = [
  462.         None]
  463.     
  464.     def __init__(self, file, line, temporary = 0, cond = None):
  465.         self.file = file
  466.         self.line = line
  467.         self.temporary = temporary
  468.         self.cond = cond
  469.         self.enabled = 1
  470.         self.ignore = 0
  471.         self.hits = 0
  472.         self.number = Breakpoint.next
  473.         Breakpoint.next = Breakpoint.next + 1
  474.         self.bpbynumber.append(self)
  475.         if self.bplist.has_key((file, line)):
  476.             self.bplist[(file, line)].append(self)
  477.         else:
  478.             self.bplist[(file, line)] = [
  479.                 self]
  480.  
  481.     
  482.     def deleteMe(self):
  483.         index = (self.file, self.line)
  484.         self.bpbynumber[self.number] = None
  485.         self.bplist[index].remove(self)
  486.         if not self.bplist[index]:
  487.             del self.bplist[index]
  488.         
  489.  
  490.     
  491.     def enable(self):
  492.         self.enabled = 1
  493.  
  494.     
  495.     def disable(self):
  496.         self.enabled = 0
  497.  
  498.     
  499.     def bpprint(self):
  500.         if self.temporary:
  501.             disp = 'del  '
  502.         else:
  503.             disp = 'keep '
  504.         if self.enabled:
  505.             disp = disp + 'yes'
  506.         else:
  507.             disp = disp + 'no '
  508.         print '%-4dbreakpoint\t %s at %s:%d' % (self.number, disp, self.file, self.line)
  509.         if self.cond:
  510.             print '\tstop only if %s' % (self.cond,)
  511.         
  512.         if self.ignore:
  513.             print '\tignore next %d hits' % self.ignore
  514.         
  515.         if self.hits:
  516.             if self.hits > 1:
  517.                 ss = 's'
  518.             else:
  519.                 ss = ''
  520.             print '\tbreakpoint already hit %d time%s' % (self.hits, ss)
  521.         
  522.  
  523.  
  524.  
  525. def effective(file, line, frame):
  526.     '''Determine which breakpoint for this file:line is to be acted upon.
  527.  
  528. \tCalled only if we know there is a bpt at this
  529. \tlocation.  Returns breakpoint that was triggered and a flag
  530. \tthat indicates if it is ok to delete a temporary bp.
  531.  
  532. \t'''
  533.     possibles = Breakpoint.bplist[(file, line)]
  534.     for i in range(0, len(possibles)):
  535.         b = possibles[i]
  536.         b.hits = b.hits + 1
  537.         if not (b.cond):
  538.             if b.ignore > 0:
  539.                 b.ignore = b.ignore - 1
  540.                 continue
  541.             else:
  542.                 return (b, 1)
  543.         else:
  544.             
  545.             try:
  546.                 val = eval(b.cond, frame.f_globals, frame.f_locals)
  547.                 if val:
  548.                     if b.ignore > 0:
  549.                         b.ignore = b.ignore - 1
  550.                     else:
  551.                         return (b, 1)
  552.             except:
  553.                 return (b, 0)
  554.  
  555.     
  556.     return (None, None)
  557.  
  558.  
  559. class Tdb(Bdb):
  560.     
  561.     def user_call(self, frame, args):
  562.         name = frame.f_code.co_name
  563.         if not name:
  564.             name = '???'
  565.         
  566.         print '+++ call', name, args
  567.  
  568.     
  569.     def user_line(self, frame):
  570.         import linecache
  571.         import string
  572.         name = frame.f_code.co_name
  573.         if not name:
  574.             name = '???'
  575.         
  576.         fn = self.canonic(frame.f_code.co_filename)
  577.         line = linecache.getline(fn, frame.f_lineno)
  578.         print '+++', fn, frame.f_lineno, name, ':', string.strip(line)
  579.  
  580.     
  581.     def user_return(self, frame, retval):
  582.         print '+++ return', retval
  583.  
  584.     
  585.     def user_exception(self, frame, exc_stuff):
  586.         print '+++ exception', exc_stuff
  587.         self.set_continue()
  588.  
  589.  
  590.  
  591. def foo(n):
  592.     print 'foo(', n, ')'
  593.     x = bar(n * 10)
  594.     print 'bar returned', x
  595.  
  596.  
  597. def bar(a):
  598.     print 'bar(', a, ')'
  599.     return a / 2
  600.  
  601.  
  602. def test():
  603.     t = Tdb()
  604.     t.run('import bdb; bdb.foo(10)')
  605.  
  606.