Adding Win32 installation of Psyco. This will be used to speed up GYP, adding

psyco_win32/psyco/support.py

+###########################################################################
+# 
+#  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__ = 0x010600f0
+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
+
+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