home *** CD-ROM | disk | FTP | other *** search
/ Chip 2004 December / CHIP_CD_2004-12.iso / bonus / oo / OOo_1.1.3_ru_RU_infra_WinIntel_install.exe / $PLUGINSDIR / f_0372 / python-core-2.2.2 / lib / hotshot / log.py < prev    next >
Text File  |  2004-10-09  |  6KB  |  195 lines
  1. import _hotshot
  2. import os.path
  3. import parser
  4. import symbol
  5. import sys
  6.  
  7. from _hotshot import \
  8.      WHAT_ENTER, \
  9.      WHAT_EXIT, \
  10.      WHAT_LINENO, \
  11.      WHAT_DEFINE_FILE, \
  12.      WHAT_DEFINE_FUNC, \
  13.      WHAT_ADD_INFO
  14.  
  15.  
  16. __all__ = ["LogReader", "ENTER", "EXIT", "LINE"]
  17.  
  18.  
  19. ENTER = WHAT_ENTER
  20. EXIT  = WHAT_EXIT
  21. LINE  = WHAT_LINENO
  22.  
  23.  
  24. try:
  25.     StopIteration
  26. except NameError:
  27.     StopIteration = IndexError
  28.  
  29.  
  30. class LogReader:
  31.     def __init__(self, logfn):
  32.         # fileno -> filename
  33.         self._filemap = {}
  34.         # (fileno, lineno) -> filename, funcname
  35.         self._funcmap = {}
  36.  
  37.         self._reader = _hotshot.logreader(logfn)
  38.         self._nextitem = self._reader.next
  39.         self._info = self._reader.info
  40.         if self._info.has_key('current-directory'):
  41.             self.cwd = self._info['current-directory']
  42.         else:
  43.             self.cwd = None
  44.         self._stack = []
  45.         self._append = self._stack.append
  46.         self._pop = self._stack.pop
  47.  
  48.     def addinfo(self, key, value):
  49.         """This method is called for each additional ADD_INFO record.
  50.  
  51.         This can be overridden by applications that want to receive
  52.         these events.  The default implementation does not need to be
  53.         called by alternate implementations.
  54.  
  55.         The initial set of ADD_INFO records do not pass through this
  56.         mechanism; this is only needed to receive notification when
  57.         new values are added.  Subclasses can inspect self._info after
  58.         calling LogReader.__init__().
  59.         """
  60.         pass
  61.  
  62.     def get_filename(self, fileno):
  63.         try:
  64.             return self._filemap[fileno]
  65.         except KeyError:
  66.             raise ValueError, "unknown fileno"
  67.  
  68.     def get_filenames(self):
  69.         return self._filemap.values()
  70.  
  71.     def get_fileno(self, filename):
  72.         filename = os.path.normcase(os.path.normpath(filename))
  73.         for fileno, name in self._filemap.items():
  74.             if name == filename:
  75.                 return fileno
  76.         raise ValueError, "unknown filename"
  77.  
  78.     def get_funcname(self, fileno, lineno):
  79.         try:
  80.             return self._funcmap[(fileno, lineno)]
  81.         except KeyError:
  82.             raise ValueError, "unknown function location"
  83.  
  84.     # Iteration support:
  85.     # This adds an optional (& ignored) parameter to next() so that the
  86.     # same bound method can be used as the __getitem__() method -- this
  87.     # avoids using an additional method call which kills the performance.
  88.  
  89.     def next(self, index=0):
  90.         while 1:
  91.             try:
  92.                 what, tdelta, fileno, lineno = self._nextitem()
  93.             except TypeError:
  94.                 # logreader().next() returns None at the end
  95.                 self._reader.close()
  96.                 raise StopIteration()
  97.  
  98.             # handle the most common cases first
  99.  
  100.             if what == WHAT_ENTER:
  101.                 filename, funcname = self._decode_location(fileno, lineno)
  102.                 self._append((filename, funcname, lineno))
  103.                 return what, (filename, lineno, funcname), tdelta
  104.  
  105.             if what == WHAT_EXIT:
  106.                 filename, funcname, lineno = self._pop()
  107.                 return what, (filename, lineno, funcname), tdelta
  108.  
  109.             if what == WHAT_LINENO:
  110.                 filename, funcname, firstlineno = self._stack[-1]
  111.                 return what, (filename, lineno, funcname), tdelta
  112.  
  113.             if what == WHAT_DEFINE_FILE:
  114.                 filename = os.path.normcase(os.path.normpath(tdelta))
  115.                 self._filemap[fileno] = filename
  116.             elif what == WHAT_DEFINE_FUNC:
  117.                 filename = self._filemap[fileno]
  118.                 self._funcmap[(fileno, lineno)] = (filename, tdelta)
  119.             elif what == WHAT_ADD_INFO:
  120.                 # value already loaded into self.info; call the
  121.                 # overridable addinfo() handler so higher-level code
  122.                 # can pick up the new value
  123.                 if tdelta == 'current-directory':
  124.                     self.cwd = lineno
  125.                 self.addinfo(tdelta, lineno)
  126.             else:
  127.                 raise ValueError, "unknown event type"
  128.  
  129.     if sys.version < "2.2":
  130.         # Don't add this for newer Python versions; we only want iteration
  131.         # support, not general sequence support.
  132.         __getitem__ = next
  133.     else:
  134.         def __iter__(self):
  135.             return self
  136.  
  137.     #
  138.     #  helpers
  139.     #
  140.  
  141.     def _decode_location(self, fileno, lineno):
  142.         try:
  143.             return self._funcmap[(fileno, lineno)]
  144.         except KeyError:
  145.             #
  146.             # This should only be needed when the log file does not
  147.             # contain all the DEFINE_FUNC records needed to allow the
  148.             # function name to be retrieved from the log file.
  149.             #
  150.             if self._loadfile(fileno):
  151.                 filename = funcname = None
  152.             try:
  153.                 filename, funcname = self._funcmap[(fileno, lineno)]
  154.             except KeyError:
  155.                 filename = self._filemap.get(fileno)
  156.                 funcname = None
  157.                 self._funcmap[(fileno, lineno)] = (filename, funcname)
  158.         return filename, funcname
  159.  
  160.     def _loadfile(self, fileno):
  161.         try:
  162.             filename = self._filemap[fileno]
  163.         except KeyError:
  164.             print "Could not identify fileId", fileno
  165.             return 1
  166.         if filename is None:
  167.             return 1
  168.         absname = os.path.normcase(os.path.join(self.cwd, filename))
  169.  
  170.         try:
  171.             fp = open(absname)
  172.         except IOError:
  173.             return
  174.         st = parser.suite(fp.read())
  175.         fp.close()
  176.  
  177.         # Scan the tree looking for def and lambda nodes, filling in
  178.         # self._funcmap with all the available information.
  179.         funcdef = symbol.funcdef
  180.         lambdef = symbol.lambdef
  181.  
  182.         stack = [st.totuple(1)]
  183.  
  184.         while stack:
  185.             tree = stack.pop()
  186.             try:
  187.                 sym = tree[0]
  188.             except (IndexError, TypeError):
  189.                 continue
  190.             if sym == funcdef:
  191.                 self._funcmap[(fileno, tree[2][2])] = filename, tree[2][1]
  192.             elif sym == lambdef:
  193.                 self._funcmap[(fileno, tree[1][2])] = filename, "<lambda>"
  194.             stack.extend(list(tree[1:]))
  195.