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