text: ###########################################################################
  # 
  #  Psyco general support module.
  #   Copyright (C) 2001-2002  Armin Rigo et.al.
  
  """Psyco general support module.
  
  For internal use.
  """
  ###########################################################################
  
  import sys, _psyco, __builtin__
  
  error = _psyco.error
  class warning(Warning):
      pass
  
  _psyco.NoLocalsWarning = warning
  
  def warn(msg):
      from warnings import warn
      warn(msg, warning, stacklevel=2)
  
  #
  # Version checks
  #
  __version__ = 0x020000f0
  if _psyco.PSYVER != __version__:
      raise error, "version mismatch between Psyco parts, reinstall it"
  
  version_info = (__version__ >> 24,
                  (__version__ >> 16) & 0xff,
                  (__version__ >> 8) & 0xff,
                  {0xa0: 'alpha',
                   0xb0: 'beta',
                   0xc0: 'candidate',
                   0xf0: 'final'}[__version__ & 0xf0],
                  __version__ & 0xf)
  
  
  VERSION_LIMITS = [0x02020200,   # 2.2.2
                    0x02030000,   # 2.3
                    0x02040000,   # 2.4
                    0x02050000,   # 2.5
                    0x02060000]   # 2.6
  
  if ([v for v in VERSION_LIMITS if v <= sys.hexversion] !=
      [v for v in VERSION_LIMITS if v <= _psyco.PYVER  ]):
      if sys.hexversion < VERSION_LIMITS[0]:
          warn("Psyco requires Python version 2.2.2 or later")
      else:
          warn("Psyco version does not match Python version. "
               "Psyco must be updated or recompiled")
  
  
  if hasattr(_psyco, 'ALL_CHECKS') and hasattr(_psyco, 'VERBOSE_LEVEL'):
      print >> sys.stderr, ('psyco: running in debugging mode on %s' %
                            _psyco.PROCESSOR)
  
  
  ###########################################################################
  # sys._getframe() gives strange results on a mixed Psyco- and Python-style
  # stack frame. Psyco provides a replacement that partially emulates Python
  # frames from Psyco frames. The new sys._getframe() may return objects of
  # a custom "Psyco frame" type, which is a subtype of the normal frame type.
  #
  # The same problems require some other built-in functions to be replaced
  # as well. Note that the local variables are not available in any
  # dictionary with Psyco.
  
  
  class Frame:
      pass
  
  
  class PythonFrame(Frame):
  
      def __init__(self, frame):
          self.__dict__.update({
              '_frame': frame,
              })
  
      def __getattr__(self, attr):
          if attr == 'f_back':
              try:
                  result = embedframe(_psyco.getframe(self._frame))
              except ValueError:
                  result = None
              except error:
                  warn("f_back is skipping dead Psyco frames")
                  result = self._frame.f_back
              self.__dict__['f_back'] = result
              return result
          else:
              return getattr(self._frame, attr)
  
      def __setattr__(self, attr, value):
          setattr(self._frame, attr, value)
  
      def __delattr__(self, attr):
          delattr(self._frame, attr)
  
  
  class PsycoFrame(Frame):
  
      def __init__(self, tag):
          self.__dict__.update({
              '_tag'     : tag,
              'f_code'   : tag[0],
              'f_globals': tag[1],
              })
  
      def __getattr__(self, attr):
          if attr == 'f_back':
              try:
                  result = embedframe(_psyco.getframe(self._tag))
              except ValueError:
                  result = None
          elif attr == 'f_lineno':
              result = self.f_code.co_firstlineno  # better than nothing
          elif attr == 'f_builtins':
              result = self.f_globals['__builtins__']
          elif attr == 'f_restricted':
              result = self.f_builtins is not __builtins__
          elif attr == 'f_locals':
              raise AttributeError, ("local variables of functions run by Psyco "
                                     "cannot be accessed in any way, sorry")
          else:
              raise AttributeError, ("emulated Psyco frames have "
                                     "no '%s' attribute" % attr)
          self.__dict__[attr] = result
          return result
  
      def __setattr__(self, attr, value):
          raise AttributeError, "Psyco frame objects are read-only"
  
      def __delattr__(self, attr):
          if attr == 'f_trace':
              # for bdb which relies on CPython frames exhibiting a slightly
              # buggy behavior: you can 'del f.f_trace' as often as you like
              # even without having set it previously.
              return
          raise AttributeError, "Psyco frame objects are read-only"
  
  
  def embedframe(result):
      if type(result) is type(()):
          return PsycoFrame(result)
      else:
          return PythonFrame(result)
  
  def _getframe(depth=0):
      """Return a frame object from the call stack. This is a replacement for
  sys._getframe() which is aware of Psyco frames.
  
  The returned objects are instances of either PythonFrame or PsycoFrame
  instead of being real Python-level frame object, so that they can emulate
  the common attributes of frame objects.
  
  The original sys._getframe() ignoring Psyco frames altogether is stored in
  psyco._getrealframe(). See also psyco._getemulframe()."""
      # 'depth+1' to account for this _getframe() Python function
      return embedframe(_psyco.getframe(depth+1))
  
  def _getemulframe(depth=0):
      """As _getframe(), but the returned objects are real Python frame objects
  emulating Psyco frames. Some of their attributes can be wrong or missing,
  however."""
      # 'depth+1' to account for this _getemulframe() Python function
      return _psyco.getframe(depth+1, 1)
  
  def patch(name, module=__builtin__):
      f = getattr(_psyco, name)
      org = getattr(module, name)
      if org is not f:
          setattr(module, name, f)
          setattr(_psyco, 'original_' + name, org)
  
  _getrealframe = sys._getframe
  sys._getframe = _getframe
  patch('globals')
  patch('eval')
  patch('execfile')
  patch('locals')
  patch('vars')
  patch('dir')
  patch('input')
  _psyco.original_raw_input = raw_input
  __builtin__.__in_psyco__ = 0==1   # False
  
  if hasattr(_psyco, 'compact'):
      import kdictproxy
      _psyco.compactdictproxy = kdictproxy.compactdictproxy
  