[pypy-commit] pypy builtin-module: Finished the conversion. Now fixing bugs...

arigo noreply at buildbot.pypy.org
Sun Dec 4 10:47:50 CET 2011


Author: Armin Rigo <arigo at tunes.org>
Branch: builtin-module
Changeset: r50106:fa68a5d5cd5a
Date: 2011-12-04 10:46 +0100
http://bitbucket.org/pypy/pypy/changeset/fa68a5d5cd5a/

Log:	Finished the conversion. Now fixing bugs...

diff --git a/lib_pypy/_locale.py b/lib_pypy/__locale.py
copy from lib_pypy/_locale.py
copy to lib_pypy/__locale.py
diff --git a/lib_pypy/_md5.py b/lib_pypy/__md5.py
copy from lib_pypy/_md5.py
copy to lib_pypy/__md5.py
diff --git a/lib_pypy/_minimal_curses.py b/lib_pypy/__minimal_curses.py
copy from lib_pypy/_minimal_curses.py
copy to lib_pypy/__minimal_curses.py
--- a/lib_pypy/_minimal_curses.py
+++ b/lib_pypy/__minimal_curses.py
@@ -5,8 +5,8 @@
 to use it, you have to import it and stick it in sys.modules['_curses']
 manually.
 
-Note that there is also a built-in module _minimal_curses which will
-hide this one if compiled in.
+Note that there is also a built-in module __buitltin__minimal_curses which
+will be imported instead of this one if compiled in.
 """
 
 import ctypes, ctypes.util
diff --git a/lib_pypy/_sha.py b/lib_pypy/__sha.py
copy from lib_pypy/_sha.py
copy to lib_pypy/__sha.py
diff --git a/lib_pypy/binascii.py b/lib_pypy/_binascii.py
copy from lib_pypy/binascii.py
copy to lib_pypy/_binascii.py
diff --git a/lib_pypy/_continuation.py b/lib_pypy/_continuation.py
--- a/lib_pypy/_continuation.py
+++ b/lib_pypy/_continuation.py
@@ -1,3 +1,4 @@
 # indirection needed; otherwise the built-in module "_continuation" shadows
 # any file _continuation.py that would be found in the user dirs
 from __builtin__continuation import *
+from __builtin__continuation import __doc__
diff --git a/lib_pypy/_ffi.py b/lib_pypy/_ffi.py
new file mode 100644
--- /dev/null
+++ b/lib_pypy/_ffi.py
@@ -0,0 +1,3 @@
+# indirection needed; otherwise the built-in module "_ffi" shadows
+# any file _ffi.py that would be found in the user dirs
+from __builtin__ffi import *
diff --git a/lib_pypy/_hashlib.py b/lib_pypy/_hashlib.py
new file mode 100644
--- /dev/null
+++ b/lib_pypy/_hashlib.py
@@ -0,0 +1,3 @@
+# indirection needed; otherwise the built-in module "_hashlib" shadows
+# any file _hashlib.py that would be found in the user dirs
+from __builtin__hashlib import *
diff --git a/lib_pypy/_locale.py b/lib_pypy/_locale.py
--- a/lib_pypy/_locale.py
+++ b/lib_pypy/_locale.py
@@ -1,337 +1,6 @@
-# ctypes implementation of _locale module by Victor Stinner, 2008-03-27
-
-# ------------------------------------------------------------
-#  Note that we also have our own interp-level implementation
-# ------------------------------------------------------------
-
-"""
-Support for POSIX locales.
-"""
-
-from ctypes import (Structure, POINTER, create_string_buffer,
-    c_ubyte, c_int, c_char_p, c_wchar_p, c_size_t)
-from ctypes_support import standard_c_lib as libc
-from ctypes_support import get_errno
-
-# load the platform-specific cache made by running locale.ctc.py
-from ctypes_config_cache._locale_cache import *
-
-try: from __pypy__ import builtinify
-except ImportError: builtinify = lambda f: f
-
-
-# Ubuntu Gusty i386 structure
-class lconv(Structure):
-    _fields_ = (
-        # Numeric (non-monetary) information.
-        ("decimal_point", c_char_p),    # Decimal point character.
-        ("thousands_sep", c_char_p),    # Thousands separator.
-
-        # Each element is the number of digits in each group;
-        # elements with higher indices are farther left.
-        # An element with value CHAR_MAX means that no further grouping is done.
-        # An element with value 0 means that the previous element is used
-        # for all groups farther left.  */
-        ("grouping", c_char_p),
-
-        # Monetary information.
-
-        # First three chars are a currency symbol from ISO 4217.
-        # Fourth char is the separator.  Fifth char is '\0'.
-        ("int_curr_symbol", c_char_p),
-        ("currency_symbol", c_char_p),   # Local currency symbol.
-        ("mon_decimal_point", c_char_p), # Decimal point character.
-        ("mon_thousands_sep", c_char_p), # Thousands separator.
-        ("mon_grouping", c_char_p),      # Like `grouping' element (above).
-        ("positive_sign", c_char_p),     # Sign for positive values.
-        ("negative_sign", c_char_p),     # Sign for negative values.
-        ("int_frac_digits", c_ubyte),    # Int'l fractional digits.
-        ("frac_digits", c_ubyte),        # Local fractional digits.
-        # 1 if currency_symbol precedes a positive value, 0 if succeeds.
-        ("p_cs_precedes", c_ubyte),
-        # 1 iff a space separates currency_symbol from a positive value.
-        ("p_sep_by_space", c_ubyte),
-        # 1 if currency_symbol precedes a negative value, 0 if succeeds.
-        ("n_cs_precedes", c_ubyte),
-        # 1 iff a space separates currency_symbol from a negative value.
-        ("n_sep_by_space", c_ubyte),
-
-        # Positive and negative sign positions:
-        # 0 Parentheses surround the quantity and currency_symbol.
-        # 1 The sign string precedes the quantity and currency_symbol.
-        # 2 The sign string follows the quantity and currency_symbol.
-        # 3 The sign string immediately precedes the currency_symbol.
-        # 4 The sign string immediately follows the currency_symbol.
-        ("p_sign_posn", c_ubyte),
-        ("n_sign_posn", c_ubyte),
-        # 1 if int_curr_symbol precedes a positive value, 0 if succeeds.
-        ("int_p_cs_precedes", c_ubyte),
-        # 1 iff a space separates int_curr_symbol from a positive value.
-        ("int_p_sep_by_space", c_ubyte),
-        # 1 if int_curr_symbol precedes a negative value, 0 if succeeds.
-        ("int_n_cs_precedes", c_ubyte),
-        # 1 iff a space separates int_curr_symbol from a negative value.
-        ("int_n_sep_by_space", c_ubyte),
-         # Positive and negative sign positions:
-         # 0 Parentheses surround the quantity and int_curr_symbol.
-         # 1 The sign string precedes the quantity and int_curr_symbol.
-         # 2 The sign string follows the quantity and int_curr_symbol.
-         # 3 The sign string immediately precedes the int_curr_symbol.
-         # 4 The sign string immediately follows the int_curr_symbol.
-        ("int_p_sign_posn", c_ubyte),
-        ("int_n_sign_posn", c_ubyte),
-    )
-
-_setlocale = libc.setlocale
-_setlocale.argtypes = (c_int, c_char_p)
-_setlocale.restype = c_char_p
-
-_localeconv = libc.localeconv
-_localeconv.argtypes = None
-_localeconv.restype = POINTER(lconv)
-
-_strcoll = libc.strcoll
-_strcoll.argtypes = (c_char_p, c_char_p)
-_strcoll.restype = c_int
-
-_wcscoll = libc.wcscoll
-_wcscoll.argtypes = (c_wchar_p, c_wchar_p)
-_wcscoll.restype = c_int
-
-_strxfrm = libc.strxfrm
-_strxfrm.argtypes = (c_char_p, c_char_p, c_size_t)
-_strxfrm.restype = c_size_t
-
-HAS_LIBINTL = hasattr(libc, 'gettext')
-if HAS_LIBINTL:
-    _gettext = libc.gettext
-    _gettext.argtypes = (c_char_p,)
-    _gettext.restype = c_char_p
-
-    _dgettext = libc.dgettext
-    _dgettext.argtypes = (c_char_p, c_char_p)
-    _dgettext.restype = c_char_p
-
-    _dcgettext = libc.dcgettext
-    _dcgettext.argtypes = (c_char_p, c_char_p, c_int)
-    _dcgettext.restype = c_char_p
-
-    _textdomain = libc.textdomain
-    _textdomain.argtypes = (c_char_p,)
-    _textdomain.restype = c_char_p
-
-    _bindtextdomain = libc.bindtextdomain
-    _bindtextdomain.argtypes = (c_char_p, c_char_p)
-    _bindtextdomain.restype = c_char_p
-
-    HAS_BIND_TEXTDOMAIN_CODESET = hasattr(libc, 'bindtextdomain_codeset')
-    if HAS_BIND_TEXTDOMAIN_CODESET:
-        _bind_textdomain_codeset = libc.bindtextdomain_codeset
-        _bind_textdomain_codeset.argtypes = (c_char_p, c_char_p)
-        _bind_textdomain_codeset.restype = c_char_p
-
-class Error(Exception):
-    pass
-
-def fixup_ulcase():
-    import string
-    #import strop
-
-    # create uppercase map string
-    ul = []
-    for c in xrange(256):
-        c = chr(c)
-        if c.isupper():
-            ul.append(c)
-    ul = ''.join(ul)
-    string.uppercase = ul
-    #strop.uppercase = ul
-
-    # create lowercase string
-    ul = []
-    for c in xrange(256):
-        c = chr(c)
-        if c.islower():
-            ul.append(c)
-    ul = ''.join(ul)
-    string.lowercase = ul
-    #strop.lowercase = ul
-
-    # create letters string
-    ul = []
-    for c in xrange(256):
-        c = chr(c)
-        if c.isalpha():
-            ul.append(c)
-    ul = ''.join(ul)
-    string.letters = ul
-
- at builtinify
-def setlocale(category, locale=None):
-    "(integer,string=None) -> string. Activates/queries locale processing."
-    if locale:
-        # set locale
-        result = _setlocale(category, locale)
-        if not result:
-            raise Error("unsupported locale setting")
-
-        # record changes to LC_CTYPE
-        if category in (LC_CTYPE, LC_ALL):
-            fixup_ulcase()
-    else:
-        # get locale
-        result = _setlocale(category, None)
-        if not result:
-            raise Error("locale query failed")
-    return result
-
-def _copy_grouping(text):
-    groups = [ ord(group) for group in text ]
-    if groups:
-        groups.append(0)
-    return groups
-
- at builtinify
-def localeconv():
-    "() -> dict. Returns numeric and monetary locale-specific parameters."
-
-    # if LC_NUMERIC is different in the C library, use saved value
-    lp = _localeconv()
-    l = lp.contents
-
-    # hopefully, the localeconv result survives the C library calls
-    # involved herein
-
-    # Numeric information
-    result = {
-        "decimal_point": l.decimal_point,
-        "thousands_sep": l.thousands_sep,
-        "grouping": _copy_grouping(l.grouping),
-        "int_curr_symbol": l.int_curr_symbol,
-        "currency_symbol": l.currency_symbol,
-        "mon_decimal_point": l.mon_decimal_point,
-        "mon_thousands_sep": l.mon_thousands_sep,
-        "mon_grouping": _copy_grouping(l.mon_grouping),
-        "positive_sign": l.positive_sign,
-        "negative_sign": l.negative_sign,
-        "int_frac_digits": l.int_frac_digits,
-        "frac_digits": l.frac_digits,
-        "p_cs_precedes": l.p_cs_precedes,
-        "p_sep_by_space": l.p_sep_by_space,
-        "n_cs_precedes": l.n_cs_precedes,
-        "n_sep_by_space": l.n_sep_by_space,
-        "p_sign_posn": l.p_sign_posn,
-        "n_sign_posn": l.n_sign_posn,
-    }
-    return result
-
- at builtinify
-def strcoll(s1, s2):
-    "string,string -> int. Compares two strings according to the locale."
-
-    # If both arguments are byte strings, use strcoll.
-    if isinstance(s1, str) and isinstance(s2, str):
-        return _strcoll(s1, s2)
-
-    # If neither argument is unicode, it's an error.
-    if not isinstance(s1, unicode) and not isinstance(s2, unicode):
-        raise ValueError("strcoll arguments must be strings")
-
-    # Convert the non-unicode argument to unicode.
-    s1 = unicode(s1)
-    s2 = unicode(s2)
-
-    # Collate the strings.
-    return _wcscoll(s1, s2)
-
- at builtinify
-def strxfrm(s):
-    "string -> string. Returns a string that behaves for cmp locale-aware."
-
-    # assume no change in size, first
-    n1 = len(s) + 1
-    buf = create_string_buffer(n1)
-    n2 = _strxfrm(buf, s, n1) + 1
-    if n2 > n1:
-        # more space needed
-        buf = create_string_buffer(n2)
-        _strxfrm(buf, s, n2)
-    return buf.value
-
- at builtinify
-def getdefaultlocale():
-    # TODO: Port code from CPython for Windows and Mac OS
-    raise NotImplementedError()
-
-if HAS_LANGINFO:
-    _nl_langinfo = libc.nl_langinfo
-    _nl_langinfo.argtypes = (nl_item,)
-    _nl_langinfo.restype = c_char_p
-
-    def nl_langinfo(key):
-        """nl_langinfo(key) -> string
-        Return the value for the locale information associated with key."""
-        # Check whether this is a supported constant. GNU libc sometimes
-        # returns numeric values in the char* return value, which would
-        # crash PyString_FromString.
-        result = _nl_langinfo(key)
-        if result is not None:
-            return result
-        raise ValueError("unsupported langinfo constant")
-
-if HAS_LIBINTL:
-    @builtinify
-    def gettext(msg):
-        """gettext(msg) -> string
-        Return translation of msg."""
-        return _gettext(msg)
-
-    @builtinify
-    def dgettext(domain, msg):
-        """dgettext(domain, msg) -> string
-        Return translation of msg in domain."""
-        return _dgettext(domain, msg)
-
-    @builtinify
-    def dcgettext(domain, msg, category):
-        """dcgettext(domain, msg, category) -> string
-        Return translation of msg in domain and category."""
-        return _dcgettext(domain, msg, category)
-
-    @builtinify
-    def textdomain(domain):
-        """textdomain(domain) -> string
-        Set the C library's textdomain to domain, returning the new domain."""
-        return _textdomain(domain)
-
-    @builtinify
-    def bindtextdomain(domain, dir):
-        """bindtextdomain(domain, dir) -> string
-        Bind the C library's domain to dir."""
-        dirname = _bindtextdomain(domain, dir)
-        if not dirname:
-            errno = get_errno()
-            raise OSError(errno)
-        return dirname
-
-    if HAS_BIND_TEXTDOMAIN_CODESET:
-        @builtinify
-        def bind_textdomain_codeset(domain, codeset):
-            """bind_textdomain_codeset(domain, codeset) -> string
-            Bind the C library's domain to codeset."""
-            codeset = _bind_textdomain_codeset(domain, codeset)
-            if codeset:
-                return codeset
-            return None
-
-__all__ = (
-    'Error',
-    'setlocale', 'localeconv', 'strxfrm', 'strcoll',
-) + ALL_CONSTANTS
-if HAS_LIBINTL:
-    __all__ += ('gettext', 'dgettext', 'dcgettext', 'textdomain',
-                'bindtextdomain')
-    if HAS_BIND_TEXTDOMAIN_CODESET:
-        __all__ += ('bind_textdomain_codeset',)
-if HAS_LANGINFO:
-    __all__ += ('nl_langinfo',)
+# indirection needed; otherwise the built-in module "_locale" shadows
+# any file _locale.py that would be found in the user dirs
+try:
+    from __builtin__locale import *
+except ImportError:
+    from __locale import *
diff --git a/lib_pypy/_lsprof.py b/lib_pypy/_lsprof.py
new file mode 100644
--- /dev/null
+++ b/lib_pypy/_lsprof.py
@@ -0,0 +1,3 @@
+# indirection needed; otherwise the built-in module "_lsprof" shadows
+# any file _lsprof.py that would be found in the user dirs
+from __builtin__lsprof import *
diff --git a/lib_pypy/_md5.py b/lib_pypy/_md5.py
--- a/lib_pypy/_md5.py
+++ b/lib_pypy/_md5.py
@@ -1,388 +1,6 @@
-#!/usr/bin/env python
-# -*- coding: iso-8859-1 -*-
-
-# Note that PyPy contains also a built-in module 'md5' which will hide
-# this one if compiled in.
-
-"""A sample implementation of MD5 in pure Python.
-
-This is an implementation of the MD5 hash function, as specified by
-RFC 1321, in pure Python. It was implemented using Bruce Schneier's
-excellent book "Applied Cryptography", 2nd ed., 1996.
-
-Surely this is not meant to compete with the existing implementation
-of the Python standard library (written in C). Rather, it should be
-seen as a Python complement that is more readable than C and can be
-used more conveniently for learning and experimenting purposes in
-the field of cryptography.
-
-This module tries very hard to follow the API of the existing Python
-standard library's "md5" module, but although it seems to work fine,
-it has not been extensively tested! (But note that there is a test
-module, test_md5py.py, that compares this Python implementation with
-the C one of the Python standard library.
-
-BEWARE: this comes with no guarantee whatsoever about fitness and/or
-other properties! Specifically, do not use this in any production
-code! License is Python License!
-
-Special thanks to Aurelian Coman who fixed some nasty bugs!
-
-Dinu C. Gherman
-"""
-
-
-__date__    = '2004-11-17'
-__version__ = 0.91 # Modernised by J. Hall&#65533;n and L. Creighton for Pypy
-
-__metaclass__ = type # or genrpy won't work
-
-import struct, copy
-
-
-# ======================================================================
-# Bit-Manipulation helpers
-# ======================================================================
-
-def _bytelist2long(list):
-    "Transform a list of characters into a list of longs."
-
-    imax = len(list)/4
-    hl = [0L] * imax
-
-    j = 0
-    i = 0
-    while i < imax:
-        b0 = long(ord(list[j]))
-        b1 = (long(ord(list[j+1]))) << 8
-        b2 = (long(ord(list[j+2]))) << 16
-        b3 = (long(ord(list[j+3]))) << 24
-        hl[i] = b0 | b1 |b2 | b3
-        i = i+1
-        j = j+4
-
-    return hl
-
-
-def _rotateLeft(x, n):
-    "Rotate x (32 bit) left n bits circularly."
-
-    return (x << n) | (x >> (32-n))
-
-
-# ======================================================================
-# The real MD5 meat...
-#
-#   Implemented after "Applied Cryptography", 2nd ed., 1996,
-#   pp. 436-441 by Bruce Schneier.
-# ======================================================================
-
-# F, G, H and I are basic MD5 functions.
-
-def F(x, y, z):
-    return (x & y) | ((~x) & z)
-
-def G(x, y, z):
-    return (x & z) | (y & (~z))
-
-def H(x, y, z):
-    return x ^ y ^ z
-
-def I(x, y, z):
-    return y ^ (x | (~z))
-
-
-def XX(func, a, b, c, d, x, s, ac):
-    """Wrapper for call distribution to functions F, G, H and I.
-
-    This replaces functions FF, GG, HH and II from "Appl. Crypto."
-    Rotation is separate from addition to prevent recomputation
-    (now summed-up in one function).
-    """
-
-    res = 0L
-    res = res + a + func(b, c, d)
-    res = res + x 
-    res = res + ac
-    res = res & 0xffffffffL
-    res = _rotateLeft(res, s)
-    res = res & 0xffffffffL
-    res = res + b
-
-    return res & 0xffffffffL
-
-
-class MD5Type:
-    "An implementation of the MD5 hash function in pure Python."
-
-    digest_size = digestsize = 16
-    block_size = 64
-
-    def __init__(self):
-        "Initialisation."
-        
-        # Initial message length in bits(!).
-        self.length = 0L
-        self.count = [0, 0]
-
-        # Initial empty message as a sequence of bytes (8 bit characters).
-        self.input = []
-
-        # Call a separate init function, that can be used repeatedly
-        # to start from scratch on the same object.
-        self.init()
-
-
-    def init(self):
-        "Initialize the message-digest and set all fields to zero."
-
-        self.length = 0L
-        self.count = [0, 0]
-        self.input = []
-
-        # Load magic initialization constants.
-        self.A = 0x67452301L
-        self.B = 0xefcdab89L
-        self.C = 0x98badcfeL
-        self.D = 0x10325476L
-
-
-    def _transform(self, inp):
-        """Basic MD5 step transforming the digest based on the input.
-
-        Note that if the Mysterious Constants are arranged backwards
-        in little-endian order and decrypted with the DES they produce
-        OCCULT MESSAGES!
-        """
-
-        a, b, c, d = A, B, C, D = self.A, self.B, self.C, self.D
-
-        # Round 1.
-
-        S11, S12, S13, S14 = 7, 12, 17, 22
-
-        a = XX(F, a, b, c, d, inp[ 0], S11, 0xD76AA478L) # 1 
-        d = XX(F, d, a, b, c, inp[ 1], S12, 0xE8C7B756L) # 2 
-        c = XX(F, c, d, a, b, inp[ 2], S13, 0x242070DBL) # 3 
-        b = XX(F, b, c, d, a, inp[ 3], S14, 0xC1BDCEEEL) # 4 
-        a = XX(F, a, b, c, d, inp[ 4], S11, 0xF57C0FAFL) # 5 
-        d = XX(F, d, a, b, c, inp[ 5], S12, 0x4787C62AL) # 6 
-        c = XX(F, c, d, a, b, inp[ 6], S13, 0xA8304613L) # 7 
-        b = XX(F, b, c, d, a, inp[ 7], S14, 0xFD469501L) # 8 
-        a = XX(F, a, b, c, d, inp[ 8], S11, 0x698098D8L) # 9 
-        d = XX(F, d, a, b, c, inp[ 9], S12, 0x8B44F7AFL) # 10 
-        c = XX(F, c, d, a, b, inp[10], S13, 0xFFFF5BB1L) # 11 
-        b = XX(F, b, c, d, a, inp[11], S14, 0x895CD7BEL) # 12 
-        a = XX(F, a, b, c, d, inp[12], S11, 0x6B901122L) # 13 
-        d = XX(F, d, a, b, c, inp[13], S12, 0xFD987193L) # 14 
-        c = XX(F, c, d, a, b, inp[14], S13, 0xA679438EL) # 15 
-        b = XX(F, b, c, d, a, inp[15], S14, 0x49B40821L) # 16 
-
-        # Round 2.
-
-        S21, S22, S23, S24 = 5, 9, 14, 20
-
-        a = XX(G, a, b, c, d, inp[ 1], S21, 0xF61E2562L) # 17 
-        d = XX(G, d, a, b, c, inp[ 6], S22, 0xC040B340L) # 18 
-        c = XX(G, c, d, a, b, inp[11], S23, 0x265E5A51L) # 19 
-        b = XX(G, b, c, d, a, inp[ 0], S24, 0xE9B6C7AAL) # 20 
-        a = XX(G, a, b, c, d, inp[ 5], S21, 0xD62F105DL) # 21 
-        d = XX(G, d, a, b, c, inp[10], S22, 0x02441453L) # 22 
-        c = XX(G, c, d, a, b, inp[15], S23, 0xD8A1E681L) # 23 
-        b = XX(G, b, c, d, a, inp[ 4], S24, 0xE7D3FBC8L) # 24 
-        a = XX(G, a, b, c, d, inp[ 9], S21, 0x21E1CDE6L) # 25 
-        d = XX(G, d, a, b, c, inp[14], S22, 0xC33707D6L) # 26 
-        c = XX(G, c, d, a, b, inp[ 3], S23, 0xF4D50D87L) # 27 
-        b = XX(G, b, c, d, a, inp[ 8], S24, 0x455A14EDL) # 28 
-        a = XX(G, a, b, c, d, inp[13], S21, 0xA9E3E905L) # 29 
-        d = XX(G, d, a, b, c, inp[ 2], S22, 0xFCEFA3F8L) # 30 
-        c = XX(G, c, d, a, b, inp[ 7], S23, 0x676F02D9L) # 31 
-        b = XX(G, b, c, d, a, inp[12], S24, 0x8D2A4C8AL) # 32 
-
-        # Round 3.
-
-        S31, S32, S33, S34 = 4, 11, 16, 23
-
-        a = XX(H, a, b, c, d, inp[ 5], S31, 0xFFFA3942L) # 33 
-        d = XX(H, d, a, b, c, inp[ 8], S32, 0x8771F681L) # 34 
-        c = XX(H, c, d, a, b, inp[11], S33, 0x6D9D6122L) # 35 
-        b = XX(H, b, c, d, a, inp[14], S34, 0xFDE5380CL) # 36 
-        a = XX(H, a, b, c, d, inp[ 1], S31, 0xA4BEEA44L) # 37 
-        d = XX(H, d, a, b, c, inp[ 4], S32, 0x4BDECFA9L) # 38 
-        c = XX(H, c, d, a, b, inp[ 7], S33, 0xF6BB4B60L) # 39 
-        b = XX(H, b, c, d, a, inp[10], S34, 0xBEBFBC70L) # 40 
-        a = XX(H, a, b, c, d, inp[13], S31, 0x289B7EC6L) # 41 
-        d = XX(H, d, a, b, c, inp[ 0], S32, 0xEAA127FAL) # 42 
-        c = XX(H, c, d, a, b, inp[ 3], S33, 0xD4EF3085L) # 43 
-        b = XX(H, b, c, d, a, inp[ 6], S34, 0x04881D05L) # 44 
-        a = XX(H, a, b, c, d, inp[ 9], S31, 0xD9D4D039L) # 45 
-        d = XX(H, d, a, b, c, inp[12], S32, 0xE6DB99E5L) # 46 
-        c = XX(H, c, d, a, b, inp[15], S33, 0x1FA27CF8L) # 47 
-        b = XX(H, b, c, d, a, inp[ 2], S34, 0xC4AC5665L) # 48 
-
-        # Round 4.
-
-        S41, S42, S43, S44 = 6, 10, 15, 21
-
-        a = XX(I, a, b, c, d, inp[ 0], S41, 0xF4292244L) # 49 
-        d = XX(I, d, a, b, c, inp[ 7], S42, 0x432AFF97L) # 50 
-        c = XX(I, c, d, a, b, inp[14], S43, 0xAB9423A7L) # 51 
-        b = XX(I, b, c, d, a, inp[ 5], S44, 0xFC93A039L) # 52 
-        a = XX(I, a, b, c, d, inp[12], S41, 0x655B59C3L) # 53 
-        d = XX(I, d, a, b, c, inp[ 3], S42, 0x8F0CCC92L) # 54 
-        c = XX(I, c, d, a, b, inp[10], S43, 0xFFEFF47DL) # 55 
-        b = XX(I, b, c, d, a, inp[ 1], S44, 0x85845DD1L) # 56 
-        a = XX(I, a, b, c, d, inp[ 8], S41, 0x6FA87E4FL) # 57 
-        d = XX(I, d, a, b, c, inp[15], S42, 0xFE2CE6E0L) # 58 
-        c = XX(I, c, d, a, b, inp[ 6], S43, 0xA3014314L) # 59 
-        b = XX(I, b, c, d, a, inp[13], S44, 0x4E0811A1L) # 60 
-        a = XX(I, a, b, c, d, inp[ 4], S41, 0xF7537E82L) # 61 
-        d = XX(I, d, a, b, c, inp[11], S42, 0xBD3AF235L) # 62 
-        c = XX(I, c, d, a, b, inp[ 2], S43, 0x2AD7D2BBL) # 63 
-        b = XX(I, b, c, d, a, inp[ 9], S44, 0xEB86D391L) # 64 
-
-        A = (A + a) & 0xffffffffL
-        B = (B + b) & 0xffffffffL
-        C = (C + c) & 0xffffffffL
-        D = (D + d) & 0xffffffffL
-
-        self.A, self.B, self.C, self.D = A, B, C, D
-
-
-    # Down from here all methods follow the Python Standard Library
-    # API of the md5 module.
-
-    def update(self, inBuf):
-        """Add to the current message.
-
-        Update the md5 object with the string arg. Repeated calls
-        are equivalent to a single call with the concatenation of all
-        the arguments, i.e. m.update(a); m.update(b) is equivalent
-        to m.update(a+b).
-
-        The hash is immediately calculated for all full blocks. The final
-        calculation is made in digest(). This allows us to keep an
-        intermediate value for the hash, so that we only need to make
-        minimal recalculation if we call update() to add moredata to
-        the hashed string.
-        """
-
-        leninBuf = long(len(inBuf))
-
-        # Compute number of bytes mod 64.
-        index = (self.count[0] >> 3) & 0x3FL
-
-        # Update number of bits.
-        self.count[0] = self.count[0] + (leninBuf << 3)
-        if self.count[0] < (leninBuf << 3):
-            self.count[1] = self.count[1] + 1
-        self.count[1] = self.count[1] + (leninBuf >> 29)
-
-        partLen = 64 - index
-
-        if leninBuf >= partLen:
-            self.input[index:] = list(inBuf[:partLen])
-            self._transform(_bytelist2long(self.input))
-            i = partLen
-            while i + 63 < leninBuf:
-                self._transform(_bytelist2long(list(inBuf[i:i+64])))
-                i = i + 64
-            else:
-                self.input = list(inBuf[i:leninBuf])
-        else:
-            i = 0
-            self.input = self.input + list(inBuf)
-
-
-    def digest(self):
-        """Terminate the message-digest computation and return digest.
-
-        Return the digest of the strings passed to the update()
-        method so far. This is a 16-byte string which may contain
-        non-ASCII characters, including null bytes.
-        """
-
-        A = self.A
-        B = self.B
-        C = self.C
-        D = self.D
-        input = [] + self.input
-        count = [] + self.count
-
-        index = (self.count[0] >> 3) & 0x3fL
-
-        if index < 56:
-            padLen = 56 - index
-        else:
-            padLen = 120 - index
-
-        padding = ['\200'] + ['\000'] * 63
-        self.update(padding[:padLen])
-
-        # Append length (before padding).
-        bits = _bytelist2long(self.input[:56]) + count
-
-        self._transform(bits)
-
-        # Store state in digest.
-        digest = struct.pack("<IIII", self.A, self.B, self.C, self.D)
-
-        self.A = A 
-        self.B = B
-        self.C = C
-        self.D = D
-        self.input = input 
-        self.count = count 
-
-        return digest
-
-
-    def hexdigest(self):
-        """Terminate and return digest in HEX form.
-
-        Like digest() except the digest is returned as a string of
-        length 32, containing only hexadecimal digits. This may be
-        used to exchange the value safely in email or other non-
-        binary environments.
-        """
-
-        return ''.join(['%02x' % ord(c) for c in self.digest()])
-
-    def copy(self):
-        """Return a clone object.
-
-        Return a copy ('clone') of the md5 object. This can be used
-        to efficiently compute the digests of strings that share
-        a common initial substring.
-        """
-        if 0: # set this to 1 to make the flow space crash
-            return copy.deepcopy(self)
-        clone = self.__class__()
-        clone.length = self.length
-        clone.count  = [] + self.count[:]
-        clone.input  = [] + self.input
-        clone.A = self.A
-        clone.B = self.B
-        clone.C = self.C
-        clone.D = self.D
-        return clone
-
-
-# ======================================================================
-# Mimic Python top-level functions from standard library API
-# for consistency with the _md5 module of the standard library.
-# ======================================================================
-
-digest_size = 16
-
-def new(arg=None):
-    """Return a new md5 crypto object.
-    If arg is present, the method call update(arg) is made.
-    """
-
-    crypto = MD5Type()
-    if arg:
-        crypto.update(arg)
-
-    return crypto
-
+# indirection needed; otherwise the built-in module "_md5" shadows
+# any file _md5.py that would be found in the user dirs
+try:
+    from __builtin__md5 import *
+except ImportError:
+    from __md5 import *
diff --git a/lib_pypy/_minimal_curses.py b/lib_pypy/_minimal_curses.py
--- a/lib_pypy/_minimal_curses.py
+++ b/lib_pypy/_minimal_curses.py
@@ -1,60 +1,6 @@
-"""Minimal '_curses' module, the low-level interface for curses module
-which is not meant to be used directly.
-
-Based on ctypes.  It's too incomplete to be really called '_curses', so
-to use it, you have to import it and stick it in sys.modules['_curses']
-manually.
-
-Note that there is also a built-in module _minimal_curses which will
-hide this one if compiled in.
-"""
-
-import ctypes, ctypes.util
-
-class error(Exception):
-    pass
-
-
-_clibpath = ctypes.util.find_library('curses')
-if not _clibpath:
-    raise ImportError("curses library not found")
-clib = ctypes.cdll.LoadLibrary(_clibpath)
-
-clib.setupterm.argtypes = [ctypes.c_char_p, ctypes.c_int,
-                           ctypes.POINTER(ctypes.c_int)]
-clib.setupterm.restype = ctypes.c_int
-
-clib.tigetstr.argtypes = [ctypes.c_char_p]
-clib.tigetstr.restype = ctypes.POINTER(ctypes.c_char)
-
-clib.tparm.argtypes = [ctypes.c_char_p] + 9 * [ctypes.c_int]
-clib.tparm.restype = ctypes.c_char_p
-
-OK = 0
-ERR = -1
-
-# ____________________________________________________________
-
-try: from __pypy__ import builtinify
-except ImportError: builtinify = lambda f: f
-
- at builtinify
-def setupterm(termstr, fd):
-    err = ctypes.c_int(0)
-    result = clib.setupterm(termstr, fd, ctypes.byref(err))
-    if result == ERR:
-        raise error("setupterm() failed (err=%d)" % err.value)
-
- at builtinify
-def tigetstr(cap):
-    result = clib.tigetstr(cap)
-    if ctypes.cast(result, ctypes.c_void_p).value == ERR:
-        return None
-    return ctypes.cast(result, ctypes.c_char_p).value
-
- at builtinify
-def tparm(str, i1=0, i2=0, i3=0, i4=0, i5=0, i6=0, i7=0, i8=0, i9=0):
-    result = clib.tparm(str, i1, i2, i3, i4, i5, i6, i7, i8, i9)
-    if result is None:
-        raise error("tparm() returned NULL")
-    return result
+# indirection needed; otherwise the built-in module "_minimal_curses" shadows
+# any file _minimal_curses.py that would be found in the user dirs
+try:
+    from __builtin__minimal_curses import *
+except ImportError:
+    from __minimal_curses import *
diff --git a/lib_pypy/_multibytecodec.py b/lib_pypy/_multibytecodec.py
new file mode 100644
--- /dev/null
+++ b/lib_pypy/_multibytecodec.py
@@ -0,0 +1,3 @@
+# indirection needed; otherwise the built-in module "_multibytecodec" shadows
+# any file _multibytecodec.py that would be found in the user dirs
+from __builtin__multibytecodec import *
diff --git a/lib_pypy/_multiprocessing.py b/lib_pypy/_multiprocessing.py
new file mode 100644
--- /dev/null
+++ b/lib_pypy/_multiprocessing.py
@@ -0,0 +1,3 @@
+# indirection needed; otherwise the built-in module "_multiprocessing" shadows
+# any file _multiprocessing.py that would be found in the user dirs
+from __builtin__multiprocessing import *
diff --git a/lib_pypy/pyexpat.py b/lib_pypy/_pyexpat.py
copy from lib_pypy/pyexpat.py
copy to lib_pypy/_pyexpat.py
diff --git a/lib_pypy/_rawffi.py b/lib_pypy/_rawffi.py
new file mode 100644
--- /dev/null
+++ b/lib_pypy/_rawffi.py
@@ -0,0 +1,3 @@
+# indirection needed; otherwise the built-in module "_rawffi" shadows
+# any file _rawffi.py that would be found in the user dirs
+from __builtin__rawffi import *
diff --git a/lib_pypy/_sha.py b/lib_pypy/_sha.py
--- a/lib_pypy/_sha.py
+++ b/lib_pypy/_sha.py
@@ -1,352 +1,6 @@
-#!/usr/bin/env python
-# -*- coding: iso-8859-1 -*-
-
-# Note that PyPy contains also a built-in module 'sha' which will hide
-# this one if compiled in.
-
-"""A sample implementation of SHA-1 in pure Python.
-
-   Framework adapted from Dinu Gherman's MD5 implementation by
-   J. Hall&#65533;n and L. Creighton. SHA-1 implementation based directly on
-   the text of the NIST standard FIPS PUB 180-1.
-"""
-
-
-__date__    = '2004-11-17'
-__version__ = 0.91 # Modernised by J. Hall&#65533;n and L. Creighton for Pypy
-
-
-import struct, copy
-
-
-# ======================================================================
-# Bit-Manipulation helpers
-#
-#   _long2bytes() was contributed by Barry Warsaw
-#   and is reused here with tiny modifications.
-# ======================================================================
-
-def _long2bytesBigEndian(n, blocksize=0):
-    """Convert a long integer to a byte string.
-
-    If optional blocksize is given and greater than zero, pad the front
-    of the byte string with binary zeros so that the length is a multiple
-    of blocksize.
-    """
-
-    # After much testing, this algorithm was deemed to be the fastest.
-    s = ''
-    pack = struct.pack
-    while n > 0:
-        s = pack('>I', n & 0xffffffffL) + s
-        n = n >> 32
-
-    # Strip off leading zeros.
-    for i in range(len(s)):
-        if s[i] <> '\000':
-            break
-    else:
-        # Only happens when n == 0.
-        s = '\000'
-        i = 0
-
-    s = s[i:]
-
-    # Add back some pad bytes. This could be done more efficiently
-    # w.r.t. the de-padding being done above, but sigh...
-    if blocksize > 0 and len(s) % blocksize:
-        s = (blocksize - len(s) % blocksize) * '\000' + s
-
-    return s
-
-
-def _bytelist2longBigEndian(list):
-    "Transform a list of characters into a list of longs."
-
-    imax = len(list)/4
-    hl = [0L] * imax
-
-    j = 0
-    i = 0
-    while i < imax:
-        b0 = long(ord(list[j])) << 24
-        b1 = long(ord(list[j+1])) << 16
-        b2 = long(ord(list[j+2])) << 8
-        b3 = long(ord(list[j+3]))
-        hl[i] = b0 | b1 | b2 | b3
-        i = i+1
-        j = j+4
-
-    return hl
-
-
-def _rotateLeft(x, n):
-    "Rotate x (32 bit) left n bits circularly."
-
-    return (x << n) | (x >> (32-n))
-
-
-# ======================================================================
-# The SHA transformation functions
-#
-# ======================================================================
-
-def f0_19(B, C, D):
-    return (B & C) | ((~ B) & D)
-
-def f20_39(B, C, D):
-    return B ^ C ^ D
-
-def f40_59(B, C, D):
-    return (B & C) | (B & D) | (C & D)
-
-def f60_79(B, C, D):
-    return B ^ C ^ D
-
-
-f = [f0_19, f20_39, f40_59, f60_79]
-
-# Constants to be used
-K = [
-    0x5A827999L, # ( 0 <= t <= 19)
-    0x6ED9EBA1L, # (20 <= t <= 39)
-    0x8F1BBCDCL, # (40 <= t <= 59)
-    0xCA62C1D6L  # (60 <= t <= 79)
-    ]
-
-class sha:
-    "An implementation of the MD5 hash function in pure Python."
-
-    digest_size = digestsize = 20
-    block_size = 1
-
-    def __init__(self):
-        "Initialisation."
-        
-        # Initial message length in bits(!).
-        self.length = 0L
-        self.count = [0, 0]
-
-        # Initial empty message as a sequence of bytes (8 bit characters).
-        self.input = []
-
-        # Call a separate init function, that can be used repeatedly
-        # to start from scratch on the same object.
-        self.init()
-
-
-    def init(self):
-        "Initialize the message-digest and set all fields to zero."
-
-        self.length = 0L
-        self.input = []
-
-        # Initial 160 bit message digest (5 times 32 bit).
-        self.H0 = 0x67452301L
-        self.H1 = 0xEFCDAB89L
-        self.H2 = 0x98BADCFEL
-        self.H3 = 0x10325476L
-        self.H4 = 0xC3D2E1F0L
-
-    def _transform(self, W):
-
-        for t in range(16, 80):
-            W.append(_rotateLeft(
-                W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16], 1) & 0xffffffffL)
-
-        A = self.H0
-        B = self.H1
-        C = self.H2
-        D = self.H3
-        E = self.H4
-
-        """
-        This loop was unrolled to gain about 10% in speed
-        for t in range(0, 80):
-            TEMP = _rotateLeft(A, 5) + f[t/20] + E + W[t] + K[t/20]
-            E = D
-            D = C
-            C = _rotateLeft(B, 30) & 0xffffffffL
-            B = A
-            A = TEMP & 0xffffffffL
-        """
-
-        for t in range(0, 20):
-            TEMP = _rotateLeft(A, 5) + ((B & C) | ((~ B) & D)) + E + W[t] + K[0]
-            E = D
-            D = C
-            C = _rotateLeft(B, 30) & 0xffffffffL
-            B = A
-            A = TEMP & 0xffffffffL
-
-        for t in range(20, 40):
-            TEMP = _rotateLeft(A, 5) + (B ^ C ^ D) + E + W[t] + K[1]
-            E = D
-            D = C
-            C = _rotateLeft(B, 30) & 0xffffffffL
-            B = A
-            A = TEMP & 0xffffffffL
-
-        for t in range(40, 60):
-            TEMP = _rotateLeft(A, 5) + ((B & C) | (B & D) | (C & D)) + E + W[t] + K[2]
-            E = D
-            D = C
-            C = _rotateLeft(B, 30) & 0xffffffffL
-            B = A
-            A = TEMP & 0xffffffffL
-
-        for t in range(60, 80):
-            TEMP = _rotateLeft(A, 5) + (B ^ C ^ D)  + E + W[t] + K[3]
-            E = D
-            D = C
-            C = _rotateLeft(B, 30) & 0xffffffffL
-            B = A
-            A = TEMP & 0xffffffffL
-
-
-        self.H0 = (self.H0 + A) & 0xffffffffL
-        self.H1 = (self.H1 + B) & 0xffffffffL
-        self.H2 = (self.H2 + C) & 0xffffffffL
-        self.H3 = (self.H3 + D) & 0xffffffffL
-        self.H4 = (self.H4 + E) & 0xffffffffL
-    
-
-    # Down from here all methods follow the Python Standard Library
-    # API of the sha module.
-
-    def update(self, inBuf):
-        """Add to the current message.
-
-        Update the md5 object with the string arg. Repeated calls
-        are equivalent to a single call with the concatenation of all
-        the arguments, i.e. m.update(a); m.update(b) is equivalent
-        to m.update(a+b).
-
-        The hash is immediately calculated for all full blocks. The final
-        calculation is made in digest(). It will calculate 1-2 blocks,
-        depending on how much padding we have to add. This allows us to
-        keep an intermediate value for the hash, so that we only need to
-        make minimal recalculation if we call update() to add more data
-        to the hashed string.
-        """
-
-        leninBuf = long(len(inBuf))
-
-        # Compute number of bytes mod 64.
-        index = (self.count[1] >> 3) & 0x3FL
-
-        # Update number of bits.
-        self.count[1] = self.count[1] + (leninBuf << 3)
-        if self.count[1] < (leninBuf << 3):
-            self.count[0] = self.count[0] + 1
-        self.count[0] = self.count[0] + (leninBuf >> 29)
-
-        partLen = 64 - index
-
-        if leninBuf >= partLen:
-            self.input[index:] = list(inBuf[:partLen])
-            self._transform(_bytelist2longBigEndian(self.input))
-            i = partLen
-            while i + 63 < leninBuf:
-                self._transform(_bytelist2longBigEndian(list(inBuf[i:i+64])))
-                i = i + 64
-            else:
-                self.input = list(inBuf[i:leninBuf])
-        else:
-            i = 0
-            self.input = self.input + list(inBuf)
-
-
-    def digest(self):
-        """Terminate the message-digest computation and return digest.
-
-        Return the digest of the strings passed to the update()
-        method so far. This is a 16-byte string which may contain
-        non-ASCII characters, including null bytes.
-        """
-
-        H0 = self.H0
-        H1 = self.H1
-        H2 = self.H2
-        H3 = self.H3
-        H4 = self.H4
-        input = [] + self.input
-        count = [] + self.count
-
-        index = (self.count[1] >> 3) & 0x3fL
-
-        if index < 56:
-            padLen = 56 - index
-        else:
-            padLen = 120 - index
-
-        padding = ['\200'] + ['\000'] * 63
-        self.update(padding[:padLen])
-
-        # Append length (before padding).
-        bits = _bytelist2longBigEndian(self.input[:56]) + count
-
-        self._transform(bits)
-
-        # Store state in digest.
-        digest = _long2bytesBigEndian(self.H0, 4) + \
-                 _long2bytesBigEndian(self.H1, 4) + \
-                 _long2bytesBigEndian(self.H2, 4) + \
-                 _long2bytesBigEndian(self.H3, 4) + \
-                 _long2bytesBigEndian(self.H4, 4)
-
-        self.H0 = H0 
-        self.H1 = H1 
-        self.H2 = H2
-        self.H3 = H3
-        self.H4 = H4
-        self.input = input 
-        self.count = count 
-
-        return digest
-
-
-    def hexdigest(self):
-        """Terminate and return digest in HEX form.
-
-        Like digest() except the digest is returned as a string of
-        length 32, containing only hexadecimal digits. This may be
-        used to exchange the value safely in email or other non-
-        binary environments.
-        """
-        return ''.join(['%02x' % ord(c) for c in self.digest()])
-
-    def copy(self):
-        """Return a clone object.
-
-        Return a copy ('clone') of the md5 object. This can be used
-        to efficiently compute the digests of strings that share
-        a common initial substring.
-        """
-
-        return copy.deepcopy(self)
-
-
-# ======================================================================
-# Mimic Python top-level functions from standard library API
-# for consistency with the _sha module of the standard library.
-# ======================================================================
-
-# These are mandatory variables in the module. They have constant values
-# in the SHA standard.
-
-digest_size = 20
-digestsize = 20
-blocksize = 1
-
-def new(arg=None):
-    """Return a new sha crypto object.
-
-    If arg is present, the method call update(arg) is made.
-    """
-
-    crypto = sha()
-    if arg:
-        crypto.update(arg)
-
-    return crypto
+# indirection needed; otherwise the built-in module "_sha" shadows
+# any file _sha.py that would be found in the user dirs
+try:
+    from __builtin__sha import *
+except ImportError:
+    from __sha import *
diff --git a/lib_pypy/struct.py b/lib_pypy/_struct.py
copy from lib_pypy/struct.py
copy to lib_pypy/_struct.py
diff --git a/lib_pypy/_winreg.py b/lib_pypy/_winreg.py
new file mode 100644
--- /dev/null
+++ b/lib_pypy/_winreg.py
@@ -0,0 +1,3 @@
+# indirection needed; otherwise the built-in module "_winreg" shadows
+# any file _winreg.py that would be found in the user dirs
+from __builtin__winreg import *
diff --git a/lib_pypy/binascii.py b/lib_pypy/binascii.py
--- a/lib_pypy/binascii.py
+++ b/lib_pypy/binascii.py
@@ -1,720 +1,6 @@
-"""A pure Python implementation of binascii.
-
-Rather slow and buggy in corner cases.
-PyPy provides an RPython version too.
-"""
-
-class Error(Exception):
-    pass
-
-class Done(Exception):
-    pass
-
-class Incomplete(Exception):
-    pass
-
-def a2b_uu(s):
-    if not s:
-        return ''
-    
-    length = (ord(s[0]) - 0x20) % 64
-
-    def quadruplets_gen(s):
-        while s:
-            try:
-                yield ord(s[0]), ord(s[1]), ord(s[2]), ord(s[3])
-            except IndexError:
-                s += '   '
-                yield ord(s[0]), ord(s[1]), ord(s[2]), ord(s[3])
-                return
-            s = s[4:]
-
-    try:
-        result = [''.join(
-            [chr((A - 0x20) << 2 | (((B - 0x20) >> 4) & 0x3)),
-            chr(((B - 0x20) & 0xf) << 4 | (((C - 0x20) >> 2) & 0xf)),
-            chr(((C - 0x20) & 0x3) << 6 | ((D - 0x20) & 0x3f))
-            ]) for A, B, C, D in quadruplets_gen(s[1:].rstrip())]
-    except ValueError:
-        raise Error('Illegal char')
-    result = ''.join(result)
-    trailingdata = result[length:]
-    if trailingdata.strip('\x00'):
-        raise Error('Trailing garbage')
-    result = result[:length]
-    if len(result) < length:
-        result += ((length - len(result)) * '\x00')
-    return result
-
-                               
-def b2a_uu(s):
-    length = len(s)
-    if length > 45:
-        raise Error('At most 45 bytes at once')
-
-    def triples_gen(s):
-        while s:
-            try:
-                yield ord(s[0]), ord(s[1]), ord(s[2])
-            except IndexError:
-                s += '\0\0'
-                yield ord(s[0]), ord(s[1]), ord(s[2])
-                return
-            s = s[3:]
-
-    result = [''.join(
-        [chr(0x20 + (( A >> 2                    ) & 0x3F)),
-         chr(0x20 + (((A << 4) | ((B >> 4) & 0xF)) & 0x3F)),
-         chr(0x20 + (((B << 2) | ((C >> 6) & 0x3)) & 0x3F)),
-         chr(0x20 + (( C                         ) & 0x3F))])
-              for A, B, C in triples_gen(s)]
-    return chr(ord(' ') + (length & 077)) + ''.join(result) + '\n'
-
-
-table_a2b_base64 = {
-    'A': 0,
-    'B': 1,
-    'C': 2,
-    'D': 3,
-    'E': 4,
-    'F': 5,
-    'G': 6,
-    'H': 7,
-    'I': 8,
-    'J': 9,
-    'K': 10,
-    'L': 11,
-    'M': 12,
-    'N': 13,
-    'O': 14,
-    'P': 15,
-    'Q': 16,
-    'R': 17,
-    'S': 18,
-    'T': 19,
-    'U': 20,
-    'V': 21,
-    'W': 22,
-    'X': 23,
-    'Y': 24,
-    'Z': 25,
-    'a': 26,
-    'b': 27,
-    'c': 28,
-    'd': 29,
-    'e': 30,
-    'f': 31,
-    'g': 32,
-    'h': 33,
-    'i': 34,
-    'j': 35,
-    'k': 36,
-    'l': 37,
-    'm': 38,
-    'n': 39,
-    'o': 40,
-    'p': 41,
-    'q': 42,
-    'r': 43,
-    's': 44,
-    't': 45,
-    'u': 46,
-    'v': 47,
-    'w': 48,
-    'x': 49,
-    'y': 50,
-    'z': 51,
-    '0': 52,
-    '1': 53,
-    '2': 54,
-    '3': 55,
-    '4': 56,
-    '5': 57,
-    '6': 58,
-    '7': 59,
-    '8': 60,
-    '9': 61,
-    '+': 62,
-    '/': 63,
-    '=': 0,
-}
-
-
-def a2b_base64(s):
-    if not isinstance(s, (str, unicode)):
-        raise TypeError("expected string or unicode, got %r" % (s,))
-    s = s.rstrip()
-    # clean out all invalid characters, this also strips the final '=' padding
-    # check for correct padding
-
-    def next_valid_char(s, pos):
-        for i in range(pos + 1, len(s)):
-            c = s[i]
-            if c < '\x7f':
-                try:
-                    table_a2b_base64[c]
-                    return c
-                except KeyError:
-                    pass
-        return None
-    
-    quad_pos = 0
-    leftbits = 0
-    leftchar = 0
-    res = []
-    for i, c in enumerate(s):
-        if c > '\x7f' or c == '\n' or c == '\r' or c == ' ':
-            continue
-        if c == '=':
-            if quad_pos < 2 or (quad_pos == 2 and next_valid_char(s, i) != '='):
-                continue
-            else:
-                leftbits = 0
-                break
-        try:
-            next_c = table_a2b_base64[c]
-        except KeyError:
-            continue
-        quad_pos = (quad_pos + 1) & 0x03
-        leftchar = (leftchar << 6) | next_c
-        leftbits += 6
-        if leftbits >= 8:
-            leftbits -= 8
-            res.append((leftchar >> leftbits & 0xff))
-            leftchar &= ((1 << leftbits) - 1)
-    if leftbits != 0:
-        raise Error('Incorrect padding')
-    
-    return ''.join([chr(i) for i in res])
-    
-table_b2a_base64 = \
-"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
-
-def b2a_base64(s):
-    length = len(s)
-    final_length = length % 3
-
-    def triples_gen(s):
-        while s:
-            try:
-                yield ord(s[0]), ord(s[1]), ord(s[2])
-            except IndexError:
-                s += '\0\0'
-                yield ord(s[0]), ord(s[1]), ord(s[2])
-                return
-            s = s[3:]
-
-    
-    a = triples_gen(s[ :length - final_length])
-
-    result = [''.join(
-        [table_b2a_base64[( A >> 2                    ) & 0x3F],
-         table_b2a_base64[((A << 4) | ((B >> 4) & 0xF)) & 0x3F],
-         table_b2a_base64[((B << 2) | ((C >> 6) & 0x3)) & 0x3F],
-         table_b2a_base64[( C                         ) & 0x3F]])
-              for A, B, C in a]
-
-    final = s[length - final_length:]
-    if final_length == 0:
-        snippet = ''
-    elif final_length == 1:
-        a = ord(final[0])
-        snippet = table_b2a_base64[(a >> 2 ) & 0x3F] + \
-                  table_b2a_base64[(a << 4 ) & 0x3F] + '=='
-    else:
-        a = ord(final[0])
-        b = ord(final[1])
-        snippet = table_b2a_base64[(a >> 2) & 0x3F] + \
-                  table_b2a_base64[((a << 4) | (b >> 4) & 0xF) & 0x3F] + \
-                  table_b2a_base64[(b << 2) & 0x3F] + '='
-    return ''.join(result) + snippet + '\n'
-
-def a2b_qp(s, header=False):
-    inp = 0
-    odata = []
-    while inp < len(s):
-        if s[inp] == '=':
-            inp += 1
-            if inp >= len(s):
-                break
-            # Soft line breaks
-            if (s[inp] == '\n') or (s[inp] == '\r'):
-                if s[inp] != '\n':
-                    while inp < len(s) and s[inp] != '\n':
-                        inp += 1
-                if inp < len(s):
-                    inp += 1
-            elif s[inp] == '=':
-                # broken case from broken python qp
-                odata.append('=')
-                inp += 1
-            elif s[inp] in hex_numbers and s[inp + 1] in hex_numbers:
-                ch = chr(int(s[inp:inp+2], 16))
-                inp += 2
-                odata.append(ch)
-            else:
-                odata.append('=')
-        elif header and s[inp] == '_':
-            odata.append(' ')
-            inp += 1
-        else:
-            odata.append(s[inp])
-            inp += 1
-    return ''.join(odata)
-
-def b2a_qp(data, quotetabs=False, istext=True, header=False):
-    """quotetabs=True means that tab and space characters are always
-       quoted.
-       istext=False means that \r and \n are treated as regular characters
-       header=True encodes space characters with '_' and requires
-       real '_' characters to be quoted.
-    """
-    MAXLINESIZE = 76
-
-    # See if this string is using CRLF line ends
-    lf = data.find('\n')
-    crlf = lf > 0 and data[lf-1] == '\r'
-
-    inp = 0
-    linelen = 0
-    odata = []
-    while inp < len(data):
-        c = data[inp]
-        if (c > '~' or
-            c == '=' or
-            (header and c == '_') or
-            (c == '.' and linelen == 0 and (inp+1 == len(data) or
-                                            data[inp+1] == '\n' or
-                                            data[inp+1] == '\r')) or
-            (not istext and (c == '\r' or c == '\n')) or
-            ((c == '\t' or c == ' ') and (inp + 1 == len(data))) or
-            (c <= ' ' and c != '\r' and c != '\n' and
-             (quotetabs or (not quotetabs and (c != '\t' and c != ' '))))):
-            linelen += 3
-            if linelen >= MAXLINESIZE:
-                odata.append('=')
-                if crlf: odata.append('\r')
-                odata.append('\n')
-                linelen = 3
-            odata.append('=' + two_hex_digits(ord(c)))
-            inp += 1
-        else:
-            if (istext and
-                (c == '\n' or (inp+1 < len(data) and c == '\r' and
-                               data[inp+1] == '\n'))):
-                linelen = 0
-                # Protect against whitespace on end of line
-                if (len(odata) > 0 and
-                    (odata[-1] == ' ' or odata[-1] == '\t')):
-                    ch = ord(odata[-1])
-                    odata[-1] = '='
-                    odata.append(two_hex_digits(ch))
-
-                if crlf: odata.append('\r')
-                odata.append('\n')
-                if c == '\r':
-                    inp += 2
-                else:
-                    inp += 1
-            else:
-                if (inp + 1 < len(data) and
-                    data[inp+1] != '\n' and
-                    (linelen + 1) >= MAXLINESIZE):
-                    odata.append('=')
-                    if crlf: odata.append('\r')
-                    odata.append('\n')
-                    linelen = 0
-
-                linelen += 1
-                if header and c == ' ':
-                    c = '_'
-                odata.append(c)
-                inp += 1
-    return ''.join(odata)
-
-hex_numbers = '0123456789ABCDEF'
-def hex(n):
-    if n == 0:
-        return '0'
-    
-    if n < 0:
-        n = -n
-        sign = '-'
-    else:
-        sign = ''
-    arr = []
-
-    def hex_gen(n):
-        """ Yield a nibble at a time. """
-        while n:
-            yield n % 0x10
-            n = n / 0x10
-
-    for nibble in hex_gen(n):
-        arr = [hex_numbers[nibble]] + arr
-    return sign + ''.join(arr)
-
-def two_hex_digits(n):
-    return hex_numbers[n / 0x10] + hex_numbers[n % 0x10]
-    
-
-def strhex_to_int(s):
-    i = 0
-    for c in s:
-        i = i * 0x10 + hex_numbers.index(c)
-    return i
-
-hqx_encoding = '!"#$%&\'()*+,-012345689 at ABCDEFGHIJKLMNPQRSTUVXYZ[`abcdefhijklmpqr'
-
-DONE = 0x7f
-SKIP = 0x7e
-FAIL = 0x7d
-    
-table_a2b_hqx = [
-    #^@    ^A    ^B    ^C    ^D    ^E    ^F    ^G   
-    FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
-    #\b    \t    \n    ^K    ^L    \r    ^N    ^O   
-    FAIL, FAIL, SKIP, FAIL, FAIL, SKIP, FAIL, FAIL,
-    #^P    ^Q    ^R    ^S    ^T    ^U    ^V    ^W   
-    FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
-    #^X    ^Y    ^Z    ^[    ^\    ^]    ^^    ^_   
-    FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
-    #      !     "     #     $     %     &     '   
-    FAIL, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
-    #(     )     *     +     ,     -     .     /   
-    0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, FAIL, FAIL,
-    #0     1     2     3     4     5     6     7   
-    0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, FAIL,
-    #8     9     :     ;     <     =     >     ?   
-    0x14, 0x15, DONE, FAIL, FAIL, FAIL, FAIL, FAIL,
-    #@     A     B     C     D     E     F     G   
-    0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D,
-    #H     I     J     K     L     M     N     O   
-    0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, FAIL,
-    #P     Q     R     S     T     U     V     W   
-    0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, FAIL,
-    #X     Y     Z     [     \     ]     ^     _   
-    0x2C, 0x2D, 0x2E, 0x2F, FAIL, FAIL, FAIL, FAIL,
-    #`     a     b     c     d     e     f     g   
-    0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, FAIL,
-    #h     i     j     k     l     m     n     o   
-    0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, FAIL, FAIL,
-    #p     q     r     s     t     u     v     w   
-    0x3D, 0x3E, 0x3F, FAIL, FAIL, FAIL, FAIL, FAIL,
-    #x     y     z     {     |     }     ~    ^?   
-    FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
-    FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
-    FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
-    FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
-    FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
-    FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
-    FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
-    FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
-    FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
-    FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
-    FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
-    FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
-    FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
-    FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
-    FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
-    FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
-    FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
-]
-
-def a2b_hqx(s):
-    result = []
-
-    def quadruples_gen(s):
-        t = []
-        for c in s:
-            res = table_a2b_hqx[ord(c)]
-            if res == SKIP:
-                continue
-            elif res == FAIL:
-                raise Error('Illegal character')
-            elif res == DONE:
-                yield t
-                raise Done
-            else:
-                t.append(res)
-            if len(t) == 4:
-                yield t
-                t = []
-        yield t
-        
-    done = 0
-    try:
-        for snippet in quadruples_gen(s):
-            length = len(snippet)
-            if length == 4:
-                result.append(chr(((snippet[0] & 0x3f) << 2) | (snippet[1] >> 4))) 
-                result.append(chr(((snippet[1] & 0x0f) << 4) | (snippet[2] >> 2))) 
-                result.append(chr(((snippet[2] & 0x03) << 6) | (snippet[3]))) 
-            elif length == 3:
-                result.append(chr(((snippet[0] & 0x3f) << 2) | (snippet[1] >> 4))) 
-                result.append(chr(((snippet[1] & 0x0f) << 4) | (snippet[2] >> 2))) 
-            elif length == 2:
-                result.append(chr(((snippet[0] & 0x3f) << 2) | (snippet[1] >> 4))) 
-    except Done:
-        done = 1
-    except Error:
-        raise
-    return (''.join(result), done)
-
-def b2a_hqx(s):
-    result =[]
-
-    def triples_gen(s):
-        while s:
-            try:
-                yield ord(s[0]), ord(s[1]), ord(s[2])
-            except IndexError:
-                yield tuple([ord(c) for c in s])
-            s = s[3:]
-
-    for snippet in triples_gen(s):
-        length = len(snippet)
-        if length == 3:
-            result.append(
-                hqx_encoding[(snippet[0] & 0xfc) >> 2])
-            result.append(hqx_encoding[
-                ((snippet[0] & 0x03) << 4) | ((snippet[1] & 0xf0) >> 4)])
-            result.append(hqx_encoding[
-                (snippet[1] & 0x0f) << 2 | ((snippet[2] & 0xc0) >> 6)])
-            result.append(hqx_encoding[snippet[2] & 0x3f])
-        elif length == 2:
-            result.append(
-                hqx_encoding[(snippet[0] & 0xfc) >> 2])
-            result.append(hqx_encoding[
-                ((snippet[0] & 0x03) << 4) | ((snippet[1] & 0xf0) >> 4)])
-            result.append(hqx_encoding[
-                (snippet[1] & 0x0f) << 2])
-        elif length == 1:
-            result.append(
-                hqx_encoding[(snippet[0] & 0xfc) >> 2])
-            result.append(hqx_encoding[
-                ((snippet[0] & 0x03) << 4)])
-    return ''.join(result)
-
-crctab_hqx = [
-        0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
-        0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
-        0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
-        0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
-        0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
-        0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
-        0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
-        0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
-        0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
-        0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
-        0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
-        0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
-        0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
-        0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
-        0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
-        0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
-        0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
-        0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
-        0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
-        0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
-        0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
-        0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
-        0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
-        0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
-        0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
-        0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
-        0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
-        0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
-        0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
-        0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
-        0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
-        0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0,
-]
-
-def crc_hqx(s, crc):
-    for c in s:
-        crc = ((crc << 8) & 0xff00) ^ crctab_hqx[((crc >> 8) & 0xff) ^ ord(c)]
-
-    return crc
-
-def rlecode_hqx(s):
-    """
-    Run length encoding for binhex4.
-    The CPython implementation does not do run length encoding
-    of \x90 characters. This implementation does.
-    """
-    if not s:
-        return ''
-    result = []
-    prev = s[0]
-    count = 1
-    # Add a dummy character to get the loop to go one extra round.
-    # The dummy must be different from the last character of s.
-    # In the same step we remove the first character, which has
-    # already been stored in prev.
-    if s[-1] == '!':
-        s = s[1:] + '?'
-    else:
-        s = s[1:] + '!'
-        
-    for c in s:
-        if c == prev and count < 255:
-            count += 1
-        else:
-            if count == 1:
-                if prev != '\x90':
-                    result.append(prev)
-                else:
-                    result.extend(['\x90', '\x00'])
-            elif count < 4:
-                if prev != '\x90':
-                    result.extend([prev] * count)
-                else:
-                    result.extend(['\x90', '\x00'] * count)
-            else:
-                if prev != '\x90':
-                    result.extend([prev, '\x90', chr(count)])
-                else:
-                    result.extend(['\x90', '\x00', '\x90', chr(count)]) 
-            count = 1
-            prev = c
-        
-    return ''.join(result)
-
-def rledecode_hqx(s):
-    s = s.split('\x90')
-    result = [s[0]]
-    prev = s[0]
-    for snippet in s[1:]:
-        count = ord(snippet[0])
-        if count > 0:
-            result.append(prev[-1] * (count-1))
-            prev = snippet
-        else:
-            result. append('\x90')
-            prev = '\x90'
-        result.append(snippet[1:])
-
-    return ''.join(result)
-
-crc_32_tab = [
-    0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
-    0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
-    0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
-    0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
-    0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
-    0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
-    0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
-    0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
-    0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
-    0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
-    0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
-    0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
-    0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
-    0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
-    0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
-    0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
-    0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
-    0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
-    0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
-    0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
-    0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
-    0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
-    0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
-    0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
-    0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
-    0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
-    0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
-    0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
-    0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
-    0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
-    0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
-    0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
-    0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
-    0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
-    0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
-    0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
-    0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
-    0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
-    0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
-    0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
-    0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
-    0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
-    0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
-    0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
-    0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
-    0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
-    0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
-    0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
-    0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
-    0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
-    0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
-    0x2d02ef8dL
-]
-
-def crc32(s, crc=0):
-    result = 0
-    crc = ~long(crc) & 0xffffffffL
-    for c in s:
-        crc = crc_32_tab[(crc ^ long(ord(c))) & 0xffL] ^ (crc >> 8)
-        #/* Note:  (crc >> 8) MUST zero fill on left
-
-    result = crc ^ 0xffffffffL
-    
-    if result > 2**31:
-        result = ((result + 2**31) % 2**32) - 2**31
-
-    return result
-
-def b2a_hex(s):
-    result = []
-    for char in s:
-        c = (ord(char) >> 4) & 0xf
-        if c > 9:
-            c = c + ord('a') - 10
-        else:
-            c = c + ord('0')
-        result.append(chr(c))
-        c = ord(char) & 0xf
-        if c > 9:
-            c = c + ord('a') - 10
-        else:
-            c = c + ord('0')
-        result.append(chr(c))
-    return ''.join(result)
-
-hexlify = b2a_hex
-
-table_hex = [
-    -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
-    -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
-    -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
-    0, 1, 2, 3,  4, 5, 6, 7,  8, 9,-1,-1, -1,-1,-1,-1,
-    -1,10,11,12, 13,14,15,-1, -1,-1,-1,-1, -1,-1,-1,-1,
-    -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
-    -1,10,11,12, 13,14,15,-1, -1,-1,-1,-1, -1,-1,-1,-1,
-    -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1
-]
-
-
-def a2b_hex(t):
-    result = []
-
-    def pairs_gen(s):
-        while s:
-            try:
-                yield table_hex[ord(s[0])], table_hex[ord(s[1])]
-            except IndexError:
-                if len(s):
-                    raise TypeError('Odd-length string')
-                return
-            s = s[2:]
-
-    for a, b in pairs_gen(t):
-        if a < 0 or b < 0:
-            raise TypeError('Non-hexadecimal digit found')
-        result.append(chr((a << 4) + b))
-    return ''.join(result)
-    
-
-unhexlify = a2b_hex
+# indirection needed; otherwise the built-in module "binascii" shadows
+# any file binascii.py that would be found in the user dirs
+try:
+    from __builtin_binascii import *
+except ImportError:
+    from _binascii import *
diff --git a/lib_pypy/bz2.py b/lib_pypy/bz2.py
new file mode 100644
--- /dev/null
+++ b/lib_pypy/bz2.py
@@ -0,0 +1,3 @@
+# indirection needed; otherwise the built-in module "bz2" shadows
+# any file bz2.py that would be found in the user dirs
+from __builtin_bz2 import *
diff --git a/lib_pypy/cStringIO.py b/lib_pypy/cStringIO.py
--- a/lib_pypy/cStringIO.py
+++ b/lib_pypy/cStringIO.py
@@ -1,16 +1,19 @@
-#
-# StringIO-based cStringIO implementation.
-#
+# indirection needed; otherwise the built-in module "cStringIO" shadows
+# any file cStringIO.py that would be found in the user dirs
 
-# Note that PyPy contains also a built-in module 'cStringIO' which will hide
-# this one if compiled in.
+try:
+    from __builtin_cStringIO import *
 
-from StringIO import *
-from StringIO import __doc__
+except ImportError:
+    #
+    # StringIO-based cStringIO implementation.
+    #
+    from StringIO import *
+    from StringIO import __doc__
 
-class StringIO(StringIO):
-    def reset(self):
-        """
-        reset() -- Reset the file position to the beginning
-        """
-        self.seek(0, 0)
+    class StringIO(StringIO):
+        def reset(self):
+            """
+            reset() -- Reset the file position to the beginning
+            """
+            self.seek(0, 0)
diff --git a/lib_pypy/cmath.py b/lib_pypy/cmath.py
--- a/lib_pypy/cmath.py
+++ b/lib_pypy/cmath.py
@@ -1,3 +1,4 @@
 # indirection needed; otherwise the built-in module "cmath" shadows
 # any file cmath.py that would be found in the user dirs
 from __builtin_cmath import *
+from __builtin_cmath import __doc__
diff --git a/lib_pypy/cpyext.py b/lib_pypy/cpyext.py
new file mode 100644
--- /dev/null
+++ b/lib_pypy/cpyext.py
@@ -0,0 +1,3 @@
+# indirection needed; otherwise the built-in module "cpyext" shadows
+# any file cpyext.py that would be found in the user dirs
+from __builtin_cpyext import *
diff --git a/lib_pypy/crypt.py b/lib_pypy/crypt.py
new file mode 100644
--- /dev/null
+++ b/lib_pypy/crypt.py
@@ -0,0 +1,3 @@
+# indirection needed; otherwise the built-in module "crypt" shadows
+# any file crypt.py that would be found in the user dirs
+from __builtin_crypt import *
diff --git a/lib_pypy/cx_Oracle.py b/lib_pypy/cx_Oracle.py
new file mode 100644
--- /dev/null
+++ b/lib_pypy/cx_Oracle.py
@@ -0,0 +1,3 @@
+# indirection needed; otherwise the built-in module "cx_Oracle" shadows
+# any file cx_Oracle.py that would be found in the user dirs
+from __builtin_cx_Oracle import *
diff --git a/lib_pypy/fcntl.py b/lib_pypy/fcntl.py
new file mode 100644
--- /dev/null
+++ b/lib_pypy/fcntl.py
@@ -0,0 +1,3 @@
+# indirection needed; otherwise the built-in module "fcntl" shadows
+# any file fcntl.py that would be found in the user dirs
+from __builtin_fcntl import *
diff --git a/lib_pypy/math.py b/lib_pypy/math.py
--- a/lib_pypy/math.py
+++ b/lib_pypy/math.py
@@ -1,3 +1,4 @@
 # indirection needed; otherwise the built-in module "math" shadows
 # any file math.py that would be found in the user dirs
 from __builtin_math import *
+from __builtin_math import __doc__
diff --git a/lib_pypy/mmap.py b/lib_pypy/mmap.py
new file mode 100644
--- /dev/null
+++ b/lib_pypy/mmap.py
@@ -0,0 +1,3 @@
+# indirection needed; otherwise the built-in module "mmap" shadows
+# any file mmap.py that would be found in the user dirs
+from __builtin_mmap import *
diff --git a/lib_pypy/numpy.py b/lib_pypy/numpy.py
new file mode 100644
--- /dev/null
+++ b/lib_pypy/numpy.py
@@ -0,0 +1,3 @@
+# indirection needed; otherwise the built-in module "numpy" shadows
+# any file numpy.py that would be found in the user dirs
+from __builtin_numpypy import *
diff --git a/lib_pypy/numpypy.py b/lib_pypy/numpypy.py
new file mode 100644
--- /dev/null
+++ b/lib_pypy/numpypy.py
@@ -0,0 +1,3 @@
+# indirection needed; otherwise the built-in module "numpypy" shadows
+# any file numpypy.py that would be found in the user dirs
+from __builtin_numpypy import *
diff --git a/lib_pypy/parser.py b/lib_pypy/parser.py
new file mode 100644
--- /dev/null
+++ b/lib_pypy/parser.py
@@ -0,0 +1,3 @@
+# indirection needed; otherwise the built-in module "parser" shadows
+# any file parser.py that would be found in the user dirs
+from __builtin_parser import *
diff --git a/lib_pypy/pwd.py b/lib_pypy/pwd.py
--- a/lib_pypy/pwd.py
+++ b/lib_pypy/pwd.py
@@ -9,6 +9,9 @@
 The uid and gid items are integers, all others are strings. An
 exception is raised if the entry asked for cannot be found.
 """
+# Note that if the built-in module 'pwd' is compiled in, it hides
+# this pwd.py.  Unsure why, but it is also a built-in module in
+# CPython 2.7, instead of an extension module.
 
 import sys
 if sys.platform == 'win32':
diff --git a/lib_pypy/pyexpat.py b/lib_pypy/pyexpat.py
--- a/lib_pypy/pyexpat.py
+++ b/lib_pypy/pyexpat.py
@@ -1,448 +1,6 @@
-
-import ctypes
-import ctypes.util
-from ctypes import c_char_p, c_int, c_void_p, POINTER, c_char, c_wchar_p
-import sys
-
-# load the platform-specific cache made by running pyexpat.ctc.py
-from ctypes_config_cache._pyexpat_cache import *
-
-try: from __pypy__ import builtinify
-except ImportError: builtinify = lambda f: f
-
-
-lib = ctypes.CDLL(ctypes.util.find_library('expat'))
-
-
-XML_Content.children = POINTER(XML_Content)
-XML_Parser = ctypes.c_void_p # an opaque pointer
-assert XML_Char is ctypes.c_char # this assumption is everywhere in
-# cpython's expat, let's explode
-
-def declare_external(name, args, res):
-    func = getattr(lib, name)
-    func.args = args
-    func.restype = res
-    globals()[name] = func
-
-declare_external('XML_ParserCreate', [c_char_p], XML_Parser)
-declare_external('XML_ParserCreateNS', [c_char_p, c_char], XML_Parser)
-declare_external('XML_Parse', [XML_Parser, c_char_p, c_int, c_int], c_int)
-currents = ['CurrentLineNumber', 'CurrentColumnNumber',
-            'CurrentByteIndex']
-for name in currents:
-    func = getattr(lib, 'XML_Get' + name)
-    func.args = [XML_Parser]
-    func.restype = c_int
-
-declare_external('XML_SetReturnNSTriplet', [XML_Parser, c_int], None)
-declare_external('XML_GetSpecifiedAttributeCount', [XML_Parser], c_int)
-declare_external('XML_SetParamEntityParsing', [XML_Parser, c_int], None)
-declare_external('XML_GetErrorCode', [XML_Parser], c_int)
-declare_external('XML_StopParser', [XML_Parser, c_int], None)
-declare_external('XML_ErrorString', [c_int], c_char_p)
-declare_external('XML_SetBase', [XML_Parser, c_char_p], None)
-if XML_COMBINED_VERSION >= 19505:
-    declare_external('XML_UseForeignDTD', [XML_Parser, c_int], None)
-
-declare_external('XML_SetUnknownEncodingHandler', [XML_Parser, c_void_p,
-                                                   c_void_p], None)
-declare_external('XML_FreeContentModel', [XML_Parser, POINTER(XML_Content)],
-                 None)
-declare_external('XML_ExternalEntityParserCreate', [XML_Parser,c_char_p,
-                                                    c_char_p],
-                 XML_Parser)
-
-handler_names = [
-    'StartElement',
-    'EndElement',
-    'ProcessingInstruction',
-    'CharacterData',
-    'UnparsedEntityDecl',
-    'NotationDecl',
-    'StartNamespaceDecl',
-    'EndNamespaceDecl',
-    'Comment',
-    'StartCdataSection',
-    'EndCdataSection',
-    'Default',
-    'DefaultHandlerExpand',
-    'NotStandalone',
-    'ExternalEntityRef',
-    'StartDoctypeDecl',
-    'EndDoctypeDecl',
-    'EntityDecl',
-    'XmlDecl',
-    'ElementDecl',
-    'AttlistDecl',
-    ]
-if XML_COMBINED_VERSION >= 19504:
-    handler_names.append('SkippedEntity')
-setters = {}
-
-for name in handler_names:
-    if name == 'DefaultHandlerExpand':
-        newname = 'XML_SetDefaultHandlerExpand'
-    else:
-        name += 'Handler'
-        newname = 'XML_Set' + name
-    cfunc = getattr(lib, newname)
-    cfunc.args = [XML_Parser, ctypes.c_void_p]
-    cfunc.result = ctypes.c_int
-    setters[name] = cfunc
-
-class ExpatError(Exception):
-    def __str__(self):
-        return self.s
-
-error = ExpatError
-
-class XMLParserType(object):
-    specified_attributes = 0
-    ordered_attributes = 0
-    returns_unicode = 1
-    encoding = 'utf-8'
-    def __init__(self, encoding, namespace_separator, _hook_external_entity=False):
-        self.returns_unicode = 1
-        if encoding:
-            self.encoding = encoding
-        if not _hook_external_entity:
-            if namespace_separator is None:
-                self.itself = XML_ParserCreate(encoding)
-            else:
-                self.itself = XML_ParserCreateNS(encoding, ord(namespace_separator))
-            if not self.itself:
-                raise RuntimeError("Creating parser failed")
-            self._set_unknown_encoding_handler()
-        self.storage = {}
-        self.buffer = None
-        self.buffer_size = 8192
-        self.character_data_handler = None
-        self.intern = {}
-        self.__exc_info = None
-
-    def _flush_character_buffer(self):
-        if not self.buffer:
-            return
-        res = self._call_character_handler(''.join(self.buffer))
-        self.buffer = []
-        return res
-
-    def _call_character_handler(self, buf):
-        if self.character_data_handler:
-            self.character_data_handler(buf)
-
-    def _set_unknown_encoding_handler(self):
-        def UnknownEncoding(encodingData, name, info_p):
-            info = info_p.contents
-            s = ''.join([chr(i) for i in range(256)])
-            u = s.decode(self.encoding, 'replace')
-            for i in range(len(u)):
-                if u[i] == u'\xfffd':
-                    info.map[i] = -1
-                else:
-                    info.map[i] = ord(u[i])
-            info.data = None
-            info.convert = None
-            info.release = None
-            return 1
-        
-        CB = ctypes.CFUNCTYPE(c_int, c_void_p, c_char_p, POINTER(XML_Encoding))
-        cb = CB(UnknownEncoding)
-        self._unknown_encoding_handler = (cb, UnknownEncoding)
-        XML_SetUnknownEncodingHandler(self.itself, cb, None)
-
-    def _set_error(self, code):
-        e = ExpatError()
-        e.code = code
-        lineno = lib.XML_GetCurrentLineNumber(self.itself)
-        colno = lib.XML_GetCurrentColumnNumber(self.itself)
-        e.offset = colno
-        e.lineno = lineno
-        err = XML_ErrorString(code)[:200]
-        e.s = "%s: line: %d, column: %d" % (err, lineno, colno)
-        e.message = e.s
-        self._error = e
-
-    def Parse(self, data, is_final=0):
-        res = XML_Parse(self.itself, data, len(data), is_final)
-        if res == 0:
-            self._set_error(XML_GetErrorCode(self.itself))
-            if self.__exc_info:
-                exc_info = self.__exc_info
-                self.__exc_info = None
-                raise exc_info[0], exc_info[1], exc_info[2]
-            else:
-                raise self._error
-        self._flush_character_buffer()
-        return res
-
-    def _sethandler(self, name, real_cb):
-        setter = setters[name]
-        try:
-            cb = self.storage[(name, real_cb)]
-        except KeyError:
-            cb = getattr(self, 'get_cb_for_%s' % name)(real_cb)
-            self.storage[(name, real_cb)] = cb
-        except TypeError:
-            # weellll...
-            cb = getattr(self, 'get_cb_for_%s' % name)(real_cb)
-        setter(self.itself, cb)
-
-    def _wrap_cb(self, cb):
-        def f(*args):
-            try:
-                return cb(*args)
-            except:
-                self.__exc_info = sys.exc_info()
-                XML_StopParser(self.itself, XML_FALSE)
-        return f
-
-    def get_cb_for_StartElementHandler(self, real_cb):
-        def StartElement(unused, name, attrs):
-            # unpack name and attrs
-            conv = self.conv
-            self._flush_character_buffer()
-            if self.specified_attributes:
-                max = XML_GetSpecifiedAttributeCount(self.itself)
-            else:
-                max = 0
-            while attrs[max]:
-                max += 2 # copied
-            if self.ordered_attributes:
-                res = [attrs[i] for i in range(max)]
-            else:
-                res = {}
-                for i in range(0, max, 2):
-                    res[conv(attrs[i])] = conv(attrs[i + 1])
-            real_cb(conv(name), res)
-        StartElement = self._wrap_cb(StartElement)
-        CB = ctypes.CFUNCTYPE(None, c_void_p, c_char_p, POINTER(c_char_p))
-        return CB(StartElement)
-
-    def get_cb_for_ExternalEntityRefHandler(self, real_cb):
-        def ExternalEntity(unused, context, base, sysId, pubId):
-            self._flush_character_buffer()
-            conv = self.conv
-            res = real_cb(conv(context), conv(base), conv(sysId),
-                          conv(pubId))
-            if res is None:
-                return 0
-            return res
-        ExternalEntity = self._wrap_cb(ExternalEntity)
-        CB = ctypes.CFUNCTYPE(c_int, c_void_p, *([c_char_p] * 4))
-        return CB(ExternalEntity)
-
-    def get_cb_for_CharacterDataHandler(self, real_cb):
-        def CharacterData(unused, s, lgt):
-            if self.buffer is None:
-                self._call_character_handler(self.conv(s[:lgt]))
-            else:
-                if len(self.buffer) + lgt > self.buffer_size:
-                    self._flush_character_buffer()
-                    if self.character_data_handler is None:
-                        return
-                if lgt >= self.buffer_size:
-                    self._call_character_handler(s[:lgt])
-                    self.buffer = []
-                else:
-                    self.buffer.append(s[:lgt])
-        CharacterData = self._wrap_cb(CharacterData)
-        CB = ctypes.CFUNCTYPE(None, c_void_p, POINTER(c_char), c_int)
-        return CB(CharacterData)
-
-    def get_cb_for_NotStandaloneHandler(self, real_cb):
-        def NotStandaloneHandler(unused):
-            return real_cb()
-        NotStandaloneHandler = self._wrap_cb(NotStandaloneHandler)
-        CB = ctypes.CFUNCTYPE(c_int, c_void_p)
-        return CB(NotStandaloneHandler)
-
-    def get_cb_for_EntityDeclHandler(self, real_cb):
-        def EntityDecl(unused, ename, is_param, value, value_len, base,
-                       system_id, pub_id, not_name):
-            self._flush_character_buffer()
-            if not value:
-                value = None
-            else:
-                value = value[:value_len]
-            args = [ename, is_param, value, base, system_id,
-                    pub_id, not_name]
-            args = [self.conv(arg) for arg in args]
-            real_cb(*args)
-        EntityDecl = self._wrap_cb(EntityDecl)
-        CB = ctypes.CFUNCTYPE(None, c_void_p, c_char_p, c_int, c_char_p,
-                               c_int, c_char_p, c_char_p, c_char_p, c_char_p)
-        return CB(EntityDecl)
-
-    def _conv_content_model(self, model):
-        children = tuple([self._conv_content_model(model.children[i])
-                          for i in range(model.numchildren)])
-        return (model.type, model.quant, self.conv(model.name),
-                children)
-
-    def get_cb_for_ElementDeclHandler(self, real_cb):
-        def ElementDecl(unused, name, model):
-            self._flush_character_buffer()
-            modelobj = self._conv_content_model(model[0])
-            real_cb(name, modelobj)
-            XML_FreeContentModel(self.itself, model)
-
-        ElementDecl = self._wrap_cb(ElementDecl)
-        CB = ctypes.CFUNCTYPE(None, c_void_p, c_char_p, POINTER(XML_Content))
-        return CB(ElementDecl)
-
-    def _new_callback_for_string_len(name, sign):
-        def get_callback_for_(self, real_cb):
-            def func(unused, s, len):
-                self._flush_character_buffer()
-                arg = self.conv(s[:len])
-                real_cb(arg)
-            func.func_name = name
-            func = self._wrap_cb(func)
-            CB = ctypes.CFUNCTYPE(*sign)
-            return CB(func)
-        get_callback_for_.func_name = 'get_cb_for_' + name
-        return get_callback_for_
-    
-    for name in ['DefaultHandlerExpand',
-                 'DefaultHandler']:
-        sign = [None, c_void_p, POINTER(c_char), c_int]
-        name = 'get_cb_for_' + name
-        locals()[name] = _new_callback_for_string_len(name, sign)
-
-    def _new_callback_for_starargs(name, sign):
-        def get_callback_for_(self, real_cb):
-            def func(unused, *args):
-                self._flush_character_buffer()
-                args = [self.conv(arg) for arg in args]
-                real_cb(*args)
-            func.func_name = name
-            func = self._wrap_cb(func)
-            CB = ctypes.CFUNCTYPE(*sign)
-            return CB(func)
-        get_callback_for_.func_name = 'get_cb_for_' + name
-        return get_callback_for_
-    
-    for name, num_or_sign in [
-        ('EndElementHandler', 1),
-        ('ProcessingInstructionHandler', 2),
-        ('UnparsedEntityDeclHandler', 5),
-        ('NotationDeclHandler', 4),
-        ('StartNamespaceDeclHandler', 2),
-        ('EndNamespaceDeclHandler', 1),
-        ('CommentHandler', 1),
-        ('StartCdataSectionHandler', 0),
-        ('EndCdataSectionHandler', 0),
-        ('StartDoctypeDeclHandler', [None, c_void_p] + [c_char_p] * 3 + [c_int]),
-        ('XmlDeclHandler', [None, c_void_p, c_char_p, c_char_p, c_int]),
-        ('AttlistDeclHandler', [None, c_void_p] + [c_char_p] * 4 + [c_int]),
-        ('EndDoctypeDeclHandler', 0),
-        ('SkippedEntityHandler', [None, c_void_p, c_char_p, c_int]),
-        ]:
-        if isinstance(num_or_sign, int):
-            sign = [None, c_void_p] + [c_char_p] * num_or_sign
-        else:
-            sign = num_or_sign
-        name = 'get_cb_for_' + name
-        locals()[name] = _new_callback_for_starargs(name, sign)
-
-    def conv_unicode(self, s):
-        if s is None or isinstance(s, int):
-            return s
-        return s.decode(self.encoding, "strict")
-
-    def __setattr__(self, name, value):
-        # forest of ifs...
-        if name in ['ordered_attributes',
-                    'returns_unicode', 'specified_attributes']:
-            if value:
-                if name == 'returns_unicode':
-                    self.conv = self.conv_unicode
-                self.__dict__[name] = 1
-            else:
-                if name == 'returns_unicode':
-                    self.conv = lambda s: s
-                self.__dict__[name] = 0
-        elif name == 'buffer_text':
-            if value:
-                self.buffer = []
-            else:
-                self._flush_character_buffer()
-                self.buffer = None
-        elif name == 'buffer_size':
-            if not isinstance(value, int):
-                raise TypeError("Expected int")
-            if value <= 0:
-                raise ValueError("Expected positive int")
-            self.__dict__[name] = value
-        elif name == 'namespace_prefixes':
-            XML_SetReturnNSTriplet(self.itself, int(bool(value)))
-        elif name in setters:
-            if name == 'CharacterDataHandler':
-                # XXX we need to flush buffer here
-                self._flush_character_buffer()
-                self.character_data_handler = value
-            #print name
-            #print value
-            #print
-            self._sethandler(name, value)
-        else:
-            self.__dict__[name] = value
-
-    def SetParamEntityParsing(self, arg):
-        XML_SetParamEntityParsing(self.itself, arg)
-
-    if XML_COMBINED_VERSION >= 19505:
-        def UseForeignDTD(self, arg=True):
-            if arg:
-                flag = XML_TRUE
-            else:
-                flag = XML_FALSE
-            XML_UseForeignDTD(self.itself, flag)
-
-    def __getattr__(self, name):
-        if name == 'buffer_text':
-            return self.buffer is not None
-        elif name in currents:
-            return getattr(lib, 'XML_Get' + name)(self.itself)
-        elif name == 'ErrorColumnNumber':
-            return lib.XML_GetCurrentColumnNumber(self.itself)
-        elif name == 'ErrorLineNumber':
-            return lib.XML_GetCurrentLineNumber(self.itself)
-        return self.__dict__[name]
-
-    def ParseFile(self, file):
-        return self.Parse(file.read(), False)
-
-    def SetBase(self, base):
-        XML_SetBase(self.itself, base)
-
-    def ExternalEntityParserCreate(self, context, encoding=None):
-        """ExternalEntityParserCreate(context[, encoding])
-        Create a parser for parsing an external entity based on the
-        information passed to the ExternalEntityRefHandler."""
-        new_parser = XMLParserType(encoding, None, True)
-        new_parser.itself = XML_ExternalEntityParserCreate(self.itself,
-                                                           context, encoding)
-        new_parser._set_unknown_encoding_handler()
-        return new_parser
-
- at builtinify
-def ErrorString(errno):
-    return XML_ErrorString(errno)[:200]
-
- at builtinify
-def ParserCreate(encoding=None, namespace_separator=None, intern=None):
-    if (not isinstance(encoding, str) and
-        not encoding is None):
-        raise TypeError("ParserCreate() argument 1 must be string or None, not %s" % encoding.__class__.__name__)
-    if (not isinstance(namespace_separator, str) and
-        not namespace_separator is None):
-        raise TypeError("ParserCreate() argument 2 must be string or None, not %s" % namespace_separator.__class__.__name__)
-    if namespace_separator is not None:
-        if len(namespace_separator) > 1:
-            raise ValueError('namespace_separator must be at most one character, omitted, or None')
-        if len(namespace_separator) == 0:
-            namespace_separator = None
-    return XMLParserType(encoding, namespace_separator)
+# indirection needed; otherwise the built-in module "pyexpat" shadows
+# any file pyexpat.py that would be found in the user dirs
+try:
+    from __builtin_pyexpat import *
+except ImportError:
+    from _pyexpat import *
diff --git a/lib_pypy/pypyjit.py b/lib_pypy/pypyjit.py
new file mode 100644
--- /dev/null
+++ b/lib_pypy/pypyjit.py
@@ -0,0 +1,3 @@
+# indirection needed; otherwise the built-in module "pypyjit" shadows
+# any file pypyjit.py that would be found in the user dirs
+from __builtin_pypyjit import *
diff --git a/lib_pypy/select.py b/lib_pypy/select.py
new file mode 100644
--- /dev/null
+++ b/lib_pypy/select.py
@@ -0,0 +1,3 @@
+# indirection needed; otherwise the built-in module "select" shadows
+# any file select.py that would be found in the user dirs
+from __builtin_select import *
diff --git a/lib_pypy/struct.py b/lib_pypy/struct.py
--- a/lib_pypy/struct.py
+++ b/lib_pypy/struct.py
@@ -1,417 +1,8 @@
-#
-# This module is a pure Python version of pypy.module.struct.
-# It is only imported if the vastly faster pypy.module.struct is not
-# compiled in.  For now we keep this version for reference and
-# because pypy.module.struct is not ootype-backend-friendly yet.
-#
-
-"""Functions to convert between Python values and C structs.
-Python strings are used to hold the data representing the C struct
-and also as format strings to describe the layout of data in the C struct.
-
-The optional first format char indicates byte order, size and alignment:
- @: native order, size & alignment (default)
- =: native order, std. size & alignment
- <: little-endian, std. size & alignment
- >: big-endian, std. size & alignment
- !: same as >
-
-The remaining chars indicate types of args and must match exactly;
-these can be preceded by a decimal repeat count:
-   x: pad byte (no data);
-   c:char;
-   b:signed byte;
-   B:unsigned byte;
-   h:short;
-   H:unsigned short;
-   i:int;
-   I:unsigned int;
-   l:long;
-   L:unsigned long;
-   f:float;
-   d:double.
-Special cases (preceding decimal count indicates length):
-   s:string (array of char); p: pascal string (with count byte).
-Special case (only available in native format):
-   P:an integer type that is wide enough to hold a pointer.
-Special case (not in native mode unless 'long long' in platform C):
-   q:long long;
-   Q:unsigned long long
-Whitespace between formats is ignored.
-
-The variable struct.error is an exception raised on errors."""
-
-import math, sys
-
-# TODO: XXX Find a way to get information on native sizes and alignments
-class StructError(Exception):
-    pass
-error = StructError
-def unpack_int(data,index,size,le):
-    bytes = [ord(b) for b in data[index:index+size]]
-    if le == 'little':
-        bytes.reverse()
-    number = 0L
-    for b in bytes:
-        number = number << 8 | b
-    return int(number)
-
-def unpack_signed_int(data,index,size,le):
-    number = unpack_int(data,index,size,le)
-    max = 2**(size*8)
-    if number > 2**(size*8 - 1) - 1:
-        number = int(-1*(max - number))
-    return number
-
-INFINITY = 1e200 * 1e200
-NAN = INFINITY / INFINITY
-
-def unpack_char(data,index,size,le):
-    return data[index:index+size]
-
-def pack_int(number,size,le):
-    x=number
-    res=[]
-    for i in range(size):
-        res.append(chr(x&0xff))
-        x >>= 8
-    if le == 'big':
-        res.reverse()
-    return ''.join(res)
-
-def pack_signed_int(number,size,le):
-    if not isinstance(number, (int,long)):
-        raise StructError,"argument for i,I,l,L,q,Q,h,H must be integer"
-    if  number > 2**(8*size-1)-1 or number < -1*2**(8*size-1):
-        raise OverflowError,"Number:%i too large to convert" % number
-    return pack_int(number,size,le)
-
-def pack_unsigned_int(number,size,le):
-    if not isinstance(number, (int,long)):
-        raise StructError,"argument for i,I,l,L,q,Q,h,H must be integer"
-    if number < 0:
-        raise TypeError,"can't convert negative long to unsigned"
-    if number > 2**(8*size)-1:
-        raise OverflowError,"Number:%i too large to convert" % number
-    return pack_int(number,size,le)
-
-def pack_char(char,size,le):
-    return str(char)
-
-def isinf(x):
-    return x != 0.0 and x / 2 == x
-def isnan(v):
-    return v != v*1.0 or (v == 1.0 and v == 2.0)
-
-def pack_float(x, size, le):
-    unsigned = float_pack(x, size)
-    result = []
-    for i in range(8):
-        result.append(chr((unsigned >> (i * 8)) & 0xFF))
-    if le == "big":
-        result.reverse()
-    return ''.join(result)
-
-def unpack_float(data, index, size, le):
-    binary = [data[i] for i in range(index, index + 8)]
-    if le == "big":
-        binary.reverse()
-    unsigned = 0
-    for i in range(8):
-        unsigned |= ord(binary[i]) << (i * 8)
-    return float_unpack(unsigned, size, le)
-
-def round_to_nearest(x):
-    """Python 3 style round:  round a float x to the nearest int, but
-    unlike the builtin Python 2.x round function:
-
-      - return an int, not a float
-      - do round-half-to-even, not round-half-away-from-zero.
-
-    We assume that x is finite and nonnegative; except wrong results
-    if you use this for negative x.
-
-    """
-    int_part = int(x)
-    frac_part = x - int_part
-    if frac_part > 0.5 or frac_part == 0.5 and int_part & 1 == 1:
-        int_part += 1
-    return int_part
-
-def float_unpack(Q, size, le):
-    """Convert a 32-bit or 64-bit integer created
-    by float_pack into a Python float."""
-
-    if size == 8:
-        MIN_EXP = -1021  # = sys.float_info.min_exp
-        MAX_EXP = 1024   # = sys.float_info.max_exp
-        MANT_DIG = 53    # = sys.float_info.mant_dig
-        BITS = 64
-    elif size == 4:
-        MIN_EXP = -125   # C's FLT_MIN_EXP
-        MAX_EXP = 128    # FLT_MAX_EXP
-        MANT_DIG = 24    # FLT_MANT_DIG
-        BITS = 32
-    else:
-        raise ValueError("invalid size value")
-
-    if Q >> BITS:
-         raise ValueError("input out of range")
-
-    # extract pieces
-    sign = Q >> BITS - 1
-    exp = (Q & ((1 << BITS - 1) - (1 << MANT_DIG - 1))) >> MANT_DIG - 1
-    mant = Q & ((1 << MANT_DIG - 1) - 1)
-
-    if exp == MAX_EXP - MIN_EXP + 2:
-        # nan or infinity
-        result = float('nan') if mant else float('inf')
-    elif exp == 0:
-        # subnormal or zero
-        result = math.ldexp(float(mant), MIN_EXP - MANT_DIG)
-    else:
-        # normal
-        mant += 1 << MANT_DIG - 1
-        result = math.ldexp(float(mant), exp + MIN_EXP - MANT_DIG - 1)
-    return -result if sign else result
-
-
-def float_pack(x, size):
-    """Convert a Python float x into a 64-bit unsigned integer
-    with the same byte representation."""
-
-    if size == 8:
-        MIN_EXP = -1021  # = sys.float_info.min_exp
-        MAX_EXP = 1024   # = sys.float_info.max_exp
-        MANT_DIG = 53    # = sys.float_info.mant_dig
-        BITS = 64
-    elif size == 4:
-        MIN_EXP = -125   # C's FLT_MIN_EXP
-        MAX_EXP = 128    # FLT_MAX_EXP
-        MANT_DIG = 24    # FLT_MANT_DIG
-        BITS = 32
-    else:
-        raise ValueError("invalid size value")
-
-    sign = math.copysign(1.0, x) < 0.0
-    if math.isinf(x):
-        mant = 0
-        exp = MAX_EXP - MIN_EXP + 2
-    elif math.isnan(x):
-        mant = 1 << (MANT_DIG-2) # other values possible
-        exp = MAX_EXP - MIN_EXP + 2
-    elif x == 0.0:
-        mant = 0
-        exp = 0
-    else:
-        m, e = math.frexp(abs(x))  # abs(x) == m * 2**e
-        exp = e - (MIN_EXP - 1)
-        if exp > 0:
-            # Normal case.
-            mant = round_to_nearest(m * (1 << MANT_DIG))
-            mant -= 1 << MANT_DIG - 1
-        else:
-            # Subnormal case.
-            if exp + MANT_DIG - 1 >= 0:
-                mant = round_to_nearest(m * (1 << exp + MANT_DIG - 1))
-            else:
-                mant = 0
-            exp = 0
-
-        # Special case: rounding produced a MANT_DIG-bit mantissa.
-        assert 0 <= mant <= 1 << MANT_DIG - 1
-        if mant == 1 << MANT_DIG - 1:
-            mant = 0
-            exp += 1
-
-        # Raise on overflow (in some circumstances, may want to return
-        # infinity instead).
-        if exp >= MAX_EXP - MIN_EXP + 2:
-             raise OverflowError("float too large to pack in this format")
-
-    # check constraints
-    assert 0 <= mant < 1 << MANT_DIG - 1
-    assert 0 <= exp <= MAX_EXP - MIN_EXP + 2
-    assert 0 <= sign <= 1
-    return ((sign << BITS - 1) | (exp << MANT_DIG - 1)) | mant
-
-
-big_endian_format = {
-    'x':{ 'size' : 1, 'alignment' : 0, 'pack' : None, 'unpack' : None},
-    'b':{ 'size' : 1, 'alignment' : 0, 'pack' : pack_signed_int, 'unpack' : unpack_signed_int},
-    'B':{ 'size' : 1, 'alignment' : 0, 'pack' : pack_unsigned_int, 'unpack' : unpack_int},
-    'c':{ 'size' : 1, 'alignment' : 0, 'pack' : pack_char, 'unpack' : unpack_char},
-    's':{ 'size' : 1, 'alignment' : 0, 'pack' : None, 'unpack' : None},
-    'p':{ 'size' : 1, 'alignment' : 0, 'pack' : None, 'unpack' : None},
-    'h':{ 'size' : 2, 'alignment' : 0, 'pack' : pack_signed_int, 'unpack' : unpack_signed_int},
-    'H':{ 'size' : 2, 'alignment' : 0, 'pack' : pack_unsigned_int, 'unpack' : unpack_int},
-    'i':{ 'size' : 4, 'alignment' : 0, 'pack' : pack_signed_int, 'unpack' : unpack_signed_int},
-    'I':{ 'size' : 4, 'alignment' : 0, 'pack' : pack_unsigned_int, 'unpack' : unpack_int},
-    'l':{ 'size' : 4, 'alignment' : 0, 'pack' : pack_signed_int, 'unpack' : unpack_signed_int},
-    'L':{ 'size' : 4, 'alignment' : 0, 'pack' : pack_unsigned_int, 'unpack' : unpack_int},
-    'q':{ 'size' : 8, 'alignment' : 0, 'pack' : pack_signed_int, 'unpack' : unpack_signed_int},
-    'Q':{ 'size' : 8, 'alignment' : 0, 'pack' : pack_unsigned_int, 'unpack' : unpack_int},
-    'f':{ 'size' : 4, 'alignment' : 0, 'pack' : pack_float, 'unpack' : unpack_float},
-    'd':{ 'size' : 8, 'alignment' : 0, 'pack' : pack_float, 'unpack' : unpack_float},
-    }
-default = big_endian_format
-formatmode={ '<' : (default, 'little'),
-             '>' : (default, 'big'),
-             '!' : (default, 'big'),
-             '=' : (default, sys.byteorder),
-             '@' : (default, sys.byteorder)
-            }
-
-def getmode(fmt):
-    try:
-        formatdef,endianness = formatmode[fmt[0]]
-        index = 1
-    except KeyError:
-        formatdef,endianness = formatmode['@']
-        index = 0
-    return formatdef,endianness,index
-def getNum(fmt,i):
-    num=None
-    cur = fmt[i]
-    while ('0'<= cur ) and ( cur <= '9'):
-        if num == None:
-            num = int(cur)
-        else:
-            num = 10*num + int(cur)
-        i += 1
-        cur = fmt[i]
-    return num,i
-
-def calcsize(fmt):
-    """calcsize(fmt) -> int
-    Return size of C struct described by format string fmt.
-    See struct.__doc__ for more on format strings."""
-
-    formatdef,endianness,i = getmode(fmt)
-    num = 0
-    result = 0
-    while i<len(fmt):
-        num,i = getNum(fmt,i)
-        cur = fmt[i]
-        try:
-            format = formatdef[cur]
-        except KeyError:
-            raise StructError,"%s is not a valid format"%cur
-        if num != None :
-            result += num*format['size']
-        else:
-            result += format['size']
-        num = 0
-        i += 1
-    return result
-
-def pack(fmt,*args):
-    """pack(fmt, v1, v2, ...) -> string
-       Return string containing values v1, v2, ... packed according to fmt.
-       See struct.__doc__ for more on format strings."""
-    formatdef,endianness,i = getmode(fmt)
-    args = list(args)
-    n_args = len(args)
-    result = []
-    while i<len(fmt):
-        num,i = getNum(fmt,i)
-        cur = fmt[i]
-        try:
-            format = formatdef[cur]
-        except KeyError:
-            raise StructError,"%s is not a valid format"%cur
-        if num == None :
-            num_s = 0
-            num = 1
-        else:
-            num_s = num
-
-        if cur == 'x':
-            result += ['\0'*num]
-        elif cur == 's':
-            if isinstance(args[0], str):
-                padding = num - len(args[0])
-                result += [args[0][:num] + '\0'*padding]
-                args.pop(0)
-            else:
-                raise StructError,"arg for string format not a string"
-        elif cur == 'p':
-            if isinstance(args[0], str):
-                padding = num - len(args[0]) - 1
-
-                if padding > 0:
-                    result += [chr(len(args[0])) + args[0][:num-1] + '\0'*padding]
-                else:
-                    if num<255:
-                        result += [chr(num-1) + args[0][:num-1]]
-                    else:
-                        result += [chr(255) + args[0][:num-1]]
-                args.pop(0)
-            else:
-                raise StructError,"arg for string format not a string"
-
-        else:
-            if len(args) < num:
-                raise StructError,"insufficient arguments to pack"
-            for var in args[:num]:
-                result += [format['pack'](var,format['size'],endianness)]
-            args=args[num:]
-        num = None
-        i += 1
-    if len(args) != 0:
-        raise StructError,"too many arguments for pack format"
-    return ''.join(result)
-
-def unpack(fmt,data):
-    """unpack(fmt, string) -> (v1, v2, ...)
-       Unpack the string, containing packed C structure data, according
-       to fmt.  Requires len(string)==calcsize(fmt).
-       See struct.__doc__ for more on format strings."""
-    formatdef,endianness,i = getmode(fmt)
-    j = 0
-    num = 0
-    result = []
-    length= calcsize(fmt)
-    if length != len (data):
-        raise StructError,"unpack str size does not match format"
-    while i<len(fmt):
-        num,i=getNum(fmt,i)
-        cur = fmt[i]
-        i += 1
-        try:
-            format = formatdef[cur]
-        except KeyError:
-            raise StructError,"%s is not a valid format"%cur
-
-        if not num :
-            num = 1
-
-        if cur == 'x':
-            j += num
-        elif cur == 's':
-            result.append(data[j:j+num])
-            j += num
-        elif cur == 'p':
-            n=ord(data[j])
-            if n >= num:
-                n = num-1
-            result.append(data[j+1:j+n+1])
-            j += num
-        else:
-            for n in range(num):
-                result += [format['unpack'](data,j,format['size'],endianness)]
-                j += format['size']
-
-    return tuple(result)
-
-def pack_into(fmt, buf, offset, *args):
-    data = pack(fmt, *args)
-    buffer(buf)[offset:offset+len(data)] = data
-
-def unpack_from(fmt, buf, offset=0):
-    size = calcsize(fmt)
-    data = buffer(buf)[offset:offset+size]
-    if len(data) != size:
-        raise error("unpack_from requires a buffer of at least %d bytes"
-                    % (size,))
-    return unpack(fmt, data)
+# indirection needed; otherwise the built-in module "struct" shadows
+# any file struct.py that would be found in the user dirs
+try:
+    from __builtin_struct import *
+    from __builtin_struct import __doc__
+except ImportError:
+    from _struct import *
+    from _struct import __doc__
diff --git a/lib_pypy/termios.py b/lib_pypy/termios.py
new file mode 100644
--- /dev/null
+++ b/lib_pypy/termios.py
@@ -0,0 +1,4 @@
+# indirection needed; otherwise the built-in module "termios" shadows
+# any file termios.py that would be found in the user dirs
+from __builtin_termios import *
+from __builtin_termios import __doc__
diff --git a/lib_pypy/time.py b/lib_pypy/time.py
new file mode 100644
--- /dev/null
+++ b/lib_pypy/time.py
@@ -0,0 +1,3 @@
+# indirection needed; otherwise the built-in module "time" shadows
+# any file time.py that would be found in the user dirs
+from __builtin_time import *
diff --git a/lib_pypy/unicodedata.py b/lib_pypy/unicodedata.py
new file mode 100644
--- /dev/null
+++ b/lib_pypy/unicodedata.py
@@ -0,0 +1,3 @@
+# indirection needed; otherwise the built-in module "unicodedata" shadows
+# any file unicodedata.py that would be found in the user dirs
+from __builtin_unicodedata import *
diff --git a/lib_pypy/zlib.py b/lib_pypy/zlib.py
new file mode 100644
--- /dev/null
+++ b/lib_pypy/zlib.py
@@ -0,0 +1,3 @@
+# indirection needed; otherwise the built-in module "zlib" shadows
+# any file zlib.py that would be found in the user dirs
+from __builtin_zlib import *
diff --git a/pypy/interpreter/baseobjspace.py b/pypy/interpreter/baseobjspace.py
--- a/pypy/interpreter/baseobjspace.py
+++ b/pypy/interpreter/baseobjspace.py
@@ -414,39 +414,39 @@
         return name
 
     def getbuiltinmodule(self, name, force_init=False):
-        w_name = self.wrap(name)
-        w_modules = self.sys.get('modules')
-        try:
-            w_mod = self.getitem(w_modules, w_name)
-        except OperationError, e:
-            if not e.match(self, self.w_KeyError):
-                raise
-        else:
-            if not force_init:
-                return w_mod
-
-        # If the module is a builtin but not yet imported,
-        # retrieve it and initialize it
         try:
             w_mod = self.builtin_modules[name]
         except KeyError:
-            raise operationerrfmt(
-                self.w_SystemError,
-                "getbuiltinmodule() called "
-                "with non-builtin module %s", name)
-        else:
-            # Add the module to sys.modules
-            self.setitem(w_modules, w_name, w_mod)
+            tryname = '__builtin_' + name     # hack, but a useful one
+            try:
+                w_mod = self.builtin_modules[tryname]
+                name = tryname
+            except KeyError:
+                raise operationerrfmt(
+                    self.w_SystemError,
+                    "getbuiltinmodule() called "
+                    "with non-builtin module %s", name)
 
-            # And initialize it
-            from pypy.interpreter.module import Module
-            mod = self.interpclass_w(w_mod)
-            if isinstance(mod, Module):
-                self.timer.start("startup " + name)
-                mod.init(self)
-                self.timer.stop("startup " + name)
+        w_name = self.wrap(name)
+        w_modules = self.sys.get('modules')
+        if not force_init and self.is_true(self.contains(w_modules, w_name)):
             return w_mod
 
+        # If the module is a builtin but not yet imported,
+        # retrieve it and initialize it now
+
+        # Add the module to sys.modules
+        self.setitem(w_modules, w_name, w_mod)
+
+        # And initialize it
+        from pypy.interpreter.module import Module
+        mod = self.interpclass_w(w_mod)
+        if isinstance(mod, Module):
+            self.timer.start("startup " + name)
+            mod.init(self)
+            self.timer.stop("startup " + name)
+        return w_mod
+
     def get_builtinmodule_to_install(self):
         """NOT_RPYTHON"""
         from pypy.tool.lib_pypy import LIB_PYPY
diff --git a/pypy/interpreter/function.py b/pypy/interpreter/function.py
--- a/pypy/interpreter/function.py
+++ b/pypy/interpreter/function.py
@@ -259,7 +259,7 @@
     def descr_function__reduce__(self, space):
         from pypy.interpreter.gateway import BuiltinCode
         from pypy.interpreter.mixedmodule import MixedModule
-        w_mod    = space.getbuiltinmodule('__builtin__pickle_support')
+        w_mod    = space.getbuiltinmodule('_pickle_support')
         mod      = space.interp_w(MixedModule, w_mod)
         code = self.code
         if isinstance(code, BuiltinCode):
@@ -559,7 +559,7 @@
     def descr_method__reduce__(self, space):
         from pypy.interpreter.mixedmodule import MixedModule
         from pypy.interpreter.gateway import BuiltinCode
-        w_mod    = space.getbuiltinmodule('__builtin__pickle_support')
+        w_mod    = space.getbuiltinmodule('_pickle_support')
         mod      = space.interp_w(MixedModule, w_mod)
         new_inst = mod.get('method_new')
         w        = space.wrap
diff --git a/pypy/interpreter/gateway.py b/pypy/interpreter/gateway.py
--- a/pypy/interpreter/gateway.py
+++ b/pypy/interpreter/gateway.py
@@ -584,7 +584,7 @@
 
     def descr__reduce__(self, space):
         from pypy.interpreter.mixedmodule import MixedModule
-        w_mod    = space.getbuiltinmodule('__builtin__pickle_support')
+        w_mod    = space.getbuiltinmodule('_pickle_support')
         mod      = space.interp_w(MixedModule, w_mod)
         builtin_code = mod.get('builtin_code')
         return space.newtuple([builtin_code,
diff --git a/pypy/interpreter/generator.py b/pypy/interpreter/generator.py
--- a/pypy/interpreter/generator.py
+++ b/pypy/interpreter/generator.py
@@ -24,7 +24,7 @@
 
     def descr__reduce__(self, space):
         from pypy.interpreter.mixedmodule import MixedModule
-        w_mod    = space.getbuiltinmodule('__builtin__pickle_support')
+        w_mod    = space.getbuiltinmodule('_pickle_support')
         mod      = space.interp_w(MixedModule, w_mod)
         new_inst = mod.get('generator_new')
         w        = space.wrap
diff --git a/pypy/interpreter/module.py b/pypy/interpreter/module.py
--- a/pypy/interpreter/module.py
+++ b/pypy/interpreter/module.py
@@ -86,7 +86,7 @@
         if space.finditem(w_modules, w_name) is None:
             #not imported case
             from pypy.interpreter.mixedmodule import MixedModule
-            w_mod    = space.getbuiltinmodule('__builtin__pickle_support')
+            w_mod    = space.getbuiltinmodule('_pickle_support')
             mod      = space.interp_w(MixedModule, w_mod)
             new_inst = mod.get('module_new')
             return space.newtuple([new_inst,
diff --git a/pypy/interpreter/nestedscope.py b/pypy/interpreter/nestedscope.py
--- a/pypy/interpreter/nestedscope.py
+++ b/pypy/interpreter/nestedscope.py
@@ -46,7 +46,7 @@
         return space.cmp(self.w_value, other.w_value)
 
     def descr__reduce__(self, space):
-        w_mod    = space.getbuiltinmodule('__builtin__pickle_support')
+        w_mod    = space.getbuiltinmodule('_pickle_support')
         mod      = space.interp_w(MixedModule, w_mod)
         new_inst = mod.get('cell_new')
         if self.w_value is None:    #when would this happen?
diff --git a/pypy/interpreter/pycode.py b/pypy/interpreter/pycode.py
--- a/pypy/interpreter/pycode.py
+++ b/pypy/interpreter/pycode.py
@@ -368,7 +368,7 @@
 
     def descr__reduce__(self, space):
         from pypy.interpreter.mixedmodule import MixedModule
-        w_mod    = space.getbuiltinmodule('__builtin__pickle_support')
+        w_mod    = space.getbuiltinmodule('_pickle_support')
         mod      = space.interp_w(MixedModule, w_mod)
         new_inst = mod.get('code_new')
         w        = space.wrap
diff --git a/pypy/interpreter/pyframe.py b/pypy/interpreter/pyframe.py
--- a/pypy/interpreter/pyframe.py
+++ b/pypy/interpreter/pyframe.py
@@ -303,7 +303,7 @@
     def descr__reduce__(self, space):
         from pypy.interpreter.mixedmodule import MixedModule
         from pypy.module._pickle_support import maker # helper fns
-        w_mod    = space.getbuiltinmodule('__builtin__pickle_support')
+        w_mod    = space.getbuiltinmodule('_pickle_support')
         mod      = space.interp_w(MixedModule, w_mod)
         new_inst = mod.get('frame_new')
         w        = space.wrap
diff --git a/pypy/interpreter/pytraceback.py b/pypy/interpreter/pytraceback.py
--- a/pypy/interpreter/pytraceback.py
+++ b/pypy/interpreter/pytraceback.py
@@ -26,7 +26,7 @@
 
     def descr__reduce__(self, space):
         from pypy.interpreter.mixedmodule import MixedModule
-        w_mod    = space.getbuiltinmodule('__builtin__pickle_support')
+        w_mod    = space.getbuiltinmodule('_pickle_support')
         mod      = space.interp_w(MixedModule, w_mod)
         new_inst = mod.get('traceback_new')
         w        = space.wrap
diff --git a/pypy/module/__builtin__/functional.py b/pypy/module/__builtin__/functional.py
--- a/pypy/module/__builtin__/functional.py
+++ b/pypy/module/__builtin__/functional.py
@@ -227,7 +227,7 @@
 
     def descr___reduce__(self, space):
         from pypy.interpreter.mixedmodule import MixedModule
-        w_mod    = space.getbuiltinmodule('__builtin__pickle_support')
+        w_mod    = space.getbuiltinmodule('_pickle_support')
         mod      = space.interp_w(MixedModule, w_mod)
         w_new_inst = mod.get('enumerate_new')
         w_info = space.newtuple([self.w_iter, self.w_index])
@@ -288,7 +288,7 @@
 
     def descr___reduce__(self, space):
         from pypy.interpreter.mixedmodule import MixedModule
-        w_mod    = space.getbuiltinmodule('__builtin__pickle_support')
+        w_mod    = space.getbuiltinmodule('_pickle_support')
         mod      = space.interp_w(MixedModule, w_mod)
         w_new_inst = mod.get('reversed_new')
         info_w = [self.w_sequence, space.wrap(self.remaining)]
@@ -412,7 +412,7 @@
     def descr_reduce(self):
         from pypy.interpreter.mixedmodule import MixedModule
         space    = self.space
-        w_mod    = space.getbuiltinmodule('__builtin__pickle_support')
+        w_mod    = space.getbuiltinmodule('_pickle_support')
         mod      = space.interp_w(MixedModule, w_mod)
         new_inst = mod.get('xrangeiter_new')
         w        = space.wrap
diff --git a/pypy/module/__pypy__/__init__.py b/pypy/module/__pypy__/__init__.py
--- a/pypy/module/__pypy__/__init__.py
+++ b/pypy/module/__pypy__/__init__.py
@@ -5,7 +5,7 @@
 
 
 class BuildersModule(MixedModule):
-    applevel_name = '__pypy__.builders'
+    applevel_name = 'builders'
 
     appleveldefs = {}
 
diff --git a/pypy/module/__pypy__/interp_builders.py b/pypy/module/__pypy__/interp_builders.py
--- a/pypy/module/__pypy__/interp_builders.py
+++ b/pypy/module/__pypy__/interp_builders.py
@@ -50,6 +50,7 @@
 
     W_Builder.__name__ = "W_%s" % name
     W_Builder.typedef = TypeDef(name,
+        __module__ = 'builders',
         __new__ = interp2app(func_with_new_name(
                                     W_Builder.descr__new__.im_func,
                                     '%s_new' % (name,))),
diff --git a/pypy/module/_continuation/app_continuation.py b/pypy/module/_continuation/app_continuation.py
--- a/pypy/module/_continuation/app_continuation.py
+++ b/pypy/module/_continuation/app_continuation.py
@@ -3,7 +3,7 @@
     "Usage error of the _continuation module."
 
 
-import _continuation
+import __builtin__continuation as _continuation
 
 
 class generator(object):
diff --git a/pypy/module/_demo/__init__.py b/pypy/module/_demo/__init__.py
--- a/pypy/module/_demo/__init__.py
+++ b/pypy/module/_demo/__init__.py
@@ -2,6 +2,7 @@
 
 class Module(MixedModule):
     """A demo built-in module based on ctypes."""
+    applevel_name = '_demo'      # not included in default pypy builds
 
     interpleveldefs = {
         'measuretime'      : 'demo.measuretime',
diff --git a/pypy/module/_ffi/__init__.py b/pypy/module/_ffi/__init__.py
--- a/pypy/module/_ffi/__init__.py
+++ b/pypy/module/_ffi/__init__.py
@@ -2,6 +2,7 @@
 from pypy.module._ffi import interp_ffi
 
 class Module(MixedModule):
+    applevel_name = '__builtin__ffi'
 
     interpleveldefs = {
         'CDLL':    'interp_ffi.W_CDLL',
diff --git a/pypy/module/_hashlib/__init__.py b/pypy/module/_hashlib/__init__.py
--- a/pypy/module/_hashlib/__init__.py
+++ b/pypy/module/_hashlib/__init__.py
@@ -3,6 +3,8 @@
 
 
 class Module(MixedModule):
+    applevel_name = '__builtin__hashlib'
+
     interpleveldefs = {
         'new' : 'interp_hashlib.new',
         }
diff --git a/pypy/module/_locale/__init__.py b/pypy/module/_locale/__init__.py
--- a/pypy/module/_locale/__init__.py
+++ b/pypy/module/_locale/__init__.py
@@ -4,6 +4,7 @@
 
 class Module(MixedModule):
     """Support for POSIX locales."""
+    applevel_name = '__builtin__locale'
 
     interpleveldefs  = {
         'setlocale':  'interp_locale.setlocale',
diff --git a/pypy/module/_lsprof/__init__.py b/pypy/module/_lsprof/__init__.py
--- a/pypy/module/_lsprof/__init__.py
+++ b/pypy/module/_lsprof/__init__.py
@@ -5,6 +5,8 @@
 from pypy.interpreter.mixedmodule import MixedModule
 
 class Module(MixedModule):
+    applevel_name = '__builtin__lsprof'
+
     interpleveldefs = {'Profiler':'interp_lsprof.W_Profiler'}
 
     appleveldefs = {}
diff --git a/pypy/module/_md5/__init__.py b/pypy/module/_md5/__init__.py
--- a/pypy/module/_md5/__init__.py
+++ b/pypy/module/_md5/__init__.py
@@ -18,6 +18,8 @@
 a.k.a. ``fingerprint'') of the concatenation of the strings fed to it so
 far using the digest() method."""
 
+    applevel_name = '__builtin__md5'
+
     interpleveldefs = {
         'new': 'interp_md5.W_MD5',
         'MD5Type': 'interp_md5.W_MD5',
diff --git a/pypy/module/_minimal_curses/__init__.py b/pypy/module/_minimal_curses/__init__.py
--- a/pypy/module/_minimal_curses/__init__.py
+++ b/pypy/module/_minimal_curses/__init__.py
@@ -17,6 +17,7 @@
     """ Low-level interface for curses module,
     not meant to be used directly
     """
+    applevel_name = '__builtin__minimal_curses'
 
     appleveldefs = {
         'error'          : 'app_curses.error',
diff --git a/pypy/module/_multibytecodec/__init__.py b/pypy/module/_multibytecodec/__init__.py
--- a/pypy/module/_multibytecodec/__init__.py
+++ b/pypy/module/_multibytecodec/__init__.py
@@ -2,6 +2,7 @@
 
 
 class Module(MixedModule):
+    applevel_name = '__builtin__multibytecodec'
 
     interpleveldefs = {
         # for compatibility this name is obscured, and should be called
diff --git a/pypy/module/_multiprocessing/__init__.py b/pypy/module/_multiprocessing/__init__.py
--- a/pypy/module/_multiprocessing/__init__.py
+++ b/pypy/module/_multiprocessing/__init__.py
@@ -2,6 +2,7 @@
 import sys
 
 class Module(MixedModule):
+    applevel_name = '__builtin__multiprocessing'
 
     interpleveldefs = {
         'Connection'      : 'interp_connection.W_FileConnection',
diff --git a/pypy/module/_rawffi/__init__.py b/pypy/module/_rawffi/__init__.py
--- a/pypy/module/_rawffi/__init__.py
+++ b/pypy/module/_rawffi/__init__.py
@@ -9,6 +9,7 @@
 import sys
 
 class Module(MixedModule):
+    applevel_name = '__builtin__rawffi'
 
     interpleveldefs = {
         'CDLL'               : 'interp_rawffi.W_CDLL',
diff --git a/pypy/module/_sha/__init__.py b/pypy/module/_sha/__init__.py
--- a/pypy/module/_sha/__init__.py
+++ b/pypy/module/_sha/__init__.py
@@ -17,6 +17,7 @@
 the update() method, and at any point you can ask it for the digest of
 the concatenation of the strings fed to it so far. SHA-1 digests are 160
 bits instead of MD5's 128 bits."""
+    applevel_name = '__builtin__sha'
 
     interpleveldefs = {
         'new': 'interp_sha.W_SHA',
diff --git a/pypy/module/_warnings/__init__.py b/pypy/module/_warnings/__init__.py
--- a/pypy/module/_warnings/__init__.py
+++ b/pypy/module/_warnings/__init__.py
@@ -3,6 +3,7 @@
 class Module(MixedModule):
     """provides basic warning filtering support.
     It is a helper module to speed up interpreter start-up."""
+    applevel_name = '_warnings'
 
     interpleveldefs = {
         'warn'         : 'interp_warnings.warn',
diff --git a/pypy/module/_winreg/__init__.py b/pypy/module/_winreg/__init__.py
--- a/pypy/module/_winreg/__init__.py
+++ b/pypy/module/_winreg/__init__.py
@@ -39,6 +39,7 @@
 Many constants are defined - see the documentation for each function
 to see what constants are used, and where."""
 
+    applevel_name = '__builtin__winreg'
     appleveldefs = {
     }
     interpleveldefs = {
diff --git a/pypy/module/binascii/__init__.py b/pypy/module/binascii/__init__.py
--- a/pypy/module/binascii/__init__.py
+++ b/pypy/module/binascii/__init__.py
@@ -10,6 +10,7 @@
 
 class Module(MixedModule):
     """binascii - Conversion between binary data and ASCII"""
+    applevel_name = '__builtin_binascii'
 
     appleveldefs = {
         }
diff --git a/pypy/module/bz2/__init__.py b/pypy/module/bz2/__init__.py
--- a/pypy/module/bz2/__init__.py
+++ b/pypy/module/bz2/__init__.py
@@ -6,6 +6,7 @@
 the bz2 compression library. It implements a complete file
 interface, one shot (de)compression functions, and types for
 sequential (de)compression."""
+    applevel_name = '__builtin_bz2'
 
     interpleveldefs = {
         'BZ2Compressor': 'interp_bz2.W_BZ2Compressor',
diff --git a/pypy/module/cStringIO/__init__.py b/pypy/module/cStringIO/__init__.py
--- a/pypy/module/cStringIO/__init__.py
+++ b/pypy/module/cStringIO/__init__.py
@@ -3,6 +3,8 @@
 from pypy.interpreter.mixedmodule import MixedModule
 
 class Module(MixedModule):
+    applevel_name = '__builtin_cStringIO'
+
     appleveldefs = {
     }
 
diff --git a/pypy/module/clr/__init__.py b/pypy/module/clr/__init__.py
--- a/pypy/module/clr/__init__.py
+++ b/pypy/module/clr/__init__.py
@@ -6,6 +6,8 @@
 class Module(MixedModule):
     """CLR module"""
 
+    applevel_name = 'clr'
+
     appleveldefs = {
         'dotnetimporter': 'app_importer.importer'
         }
diff --git a/pypy/module/cpyext/__init__.py b/pypy/module/cpyext/__init__.py
--- a/pypy/module/cpyext/__init__.py
+++ b/pypy/module/cpyext/__init__.py
@@ -5,6 +5,8 @@
 from pypy.rpython.lltypesystem import rffi, lltype
 
 class Module(MixedModule):
+    applevel_name = '__builtin_cpyext'
+
     interpleveldefs = {
         'load_module': 'api.load_extension_module',
     }
diff --git a/pypy/module/crypt/__init__.py b/pypy/module/crypt/__init__.py
--- a/pypy/module/crypt/__init__.py
+++ b/pypy/module/crypt/__init__.py
@@ -2,6 +2,7 @@
 
 class Module(MixedModule):
     """A demo built-in module based on rffi."""
+    applevel_name = '__builtin_crypt'
 
     interpleveldefs = {
         'crypt'    : 'interp_crypt.crypt',
diff --git a/pypy/module/fcntl/__init__.py b/pypy/module/fcntl/__init__.py
--- a/pypy/module/fcntl/__init__.py
+++ b/pypy/module/fcntl/__init__.py
@@ -2,6 +2,8 @@
 from pypy.rlib.rarithmetic import intmask
 
 class Module(MixedModule):
+    applevel_name = '__builtin_fcntl'
+
     interpleveldefs = {
         'fcntl': 'interp_fcntl.fcntl',
         'flock': 'interp_fcntl.flock',
diff --git a/pypy/module/micronumpy/__init__.py b/pypy/module/micronumpy/__init__.py
--- a/pypy/module/micronumpy/__init__.py
+++ b/pypy/module/micronumpy/__init__.py
@@ -2,7 +2,7 @@
 
 
 class Module(MixedModule):
-    applevel_name = 'numpypy'
+    applevel_name = '__builtin_numpypy'
 
     interpleveldefs = {
         'ndarray': 'interp_numarray.W_NDimArray',
diff --git a/pypy/module/mmap/__init__.py b/pypy/module/mmap/__init__.py
--- a/pypy/module/mmap/__init__.py
+++ b/pypy/module/mmap/__init__.py
@@ -2,6 +2,8 @@
 from pypy.rlib import rmmap
 
 class Module(MixedModule):
+    applevel_name = '__builtin_mmap'
+
     interpleveldefs = {
         'PAGESIZE': 'space.wrap(interp_mmap.PAGESIZE)',
         'ALLOCATIONGRANULARITY': 'space.wrap(interp_mmap.ALLOCATIONGRANULARITY)',
diff --git a/pypy/module/oracle/__init__.py b/pypy/module/oracle/__init__.py
--- a/pypy/module/oracle/__init__.py
+++ b/pypy/module/oracle/__init__.py
@@ -1,7 +1,7 @@
 from pypy.interpreter.mixedmodule import MixedModule
 
 class Module(MixedModule):
-    applevel_name = 'cx_Oracle'
+    applevel_name = '__builtin_cx_Oracle'
 
     interpleveldefs = {
         'connect': 'interp_connect.W_Connection',
diff --git a/pypy/module/parser/__init__.py b/pypy/module/parser/__init__.py
--- a/pypy/module/parser/__init__.py
+++ b/pypy/module/parser/__init__.py
@@ -4,15 +4,12 @@
 class Module(MixedModule):
      """The builtin parser module."""
 
-     applevel_name = 'parser'
+     applevel_name = '__builtin_parser'
 
      appleveldefs = {
          }
 
      interpleveldefs = {
-         '__name__'     : '(space.wrap("parser"))',
-         '__doc__'      : '(space.wrap("parser module"))',
-
          'suite'        : 'pyparser.suite',
          'expr'         : 'pyparser.expr',
          'issuite'      : 'pyparser.issuite',
diff --git a/pypy/module/pwd/__init__.py b/pypy/module/pwd/__init__.py
--- a/pypy/module/pwd/__init__.py
+++ b/pypy/module/pwd/__init__.py
@@ -11,6 +11,8 @@
     The uid and gid items are integers, all others are strings. An
     exception is raised if the entry asked for cannot be found.
     """
+    applevel_name = 'pwd'   # this is a built-in module on CPython too,
+                            # instead of an extension module.  Unsure why
 
     interpleveldefs = {
         'getpwuid': 'interp_pwd.getpwuid',
diff --git a/pypy/module/pyexpat/__init__.py b/pypy/module/pyexpat/__init__.py
--- a/pypy/module/pyexpat/__init__.py
+++ b/pypy/module/pyexpat/__init__.py
@@ -4,6 +4,7 @@
 
 class ErrorsModule(MixedModule):
     "Definition of pyexpat.errors module."
+    applevel_name = 'errors'
     appleveldefs = {}
     interpleveldefs = {}
 
@@ -16,6 +17,7 @@
 
 class ModelModule(MixedModule):
     "Definition of pyexpat.model module."
+    applevel_name = 'model'
     appleveldefs = {}
     interpleveldefs = {}
 
@@ -28,6 +30,7 @@
 
 class Module(MixedModule):
     "Python wrapper for Expat parser."
+    applevel_name = '__builtin_pyexpat'
 
     appleveldefs = {
         }
diff --git a/pypy/module/pypyjit/__init__.py b/pypy/module/pypyjit/__init__.py
--- a/pypy/module/pypyjit/__init__.py
+++ b/pypy/module/pypyjit/__init__.py
@@ -1,6 +1,8 @@
 from pypy.interpreter.mixedmodule import MixedModule
 
 class Module(MixedModule):
+    applevel_name = '__builtin_pypyjit'
+
     appleveldefs = {
     }
 
diff --git a/pypy/module/rbench/__init__.py b/pypy/module/rbench/__init__.py
--- a/pypy/module/rbench/__init__.py
+++ b/pypy/module/rbench/__init__.py
@@ -3,6 +3,7 @@
 
 class Module(MixedModule):
     """geninterpreted benchmarks"""
+    applevel_name = 'rbench'   # not in standard translations
 
     appleveldefs = {
         'pystone': 'app_bench.pystone',
diff --git a/pypy/module/rctime/__init__.py b/pypy/module/rctime/__init__.py
--- a/pypy/module/rctime/__init__.py
+++ b/pypy/module/rctime/__init__.py
@@ -5,7 +5,7 @@
 _WIN = os.name == "nt"
 
 class Module(MixedModule):
-    applevel_name = 'time'
+    applevel_name = '__builtin_time'
 
     interpleveldefs = {
         'time': 'interp_time.time',
diff --git a/pypy/module/select/__init__.py b/pypy/module/select/__init__.py
--- a/pypy/module/select/__init__.py
+++ b/pypy/module/select/__init__.py
@@ -6,6 +6,8 @@
 
 
 class Module(MixedModule):
+    applevel_name = '__builtin_select'
+
     appleveldefs = {
     }
 
diff --git a/pypy/module/signal/__init__.py b/pypy/module/signal/__init__.py
--- a/pypy/module/signal/__init__.py
+++ b/pypy/module/signal/__init__.py
@@ -4,6 +4,8 @@
 import signal as cpy_signal
 
 class Module(MixedModule):
+    applevel_name = 'signal'
+
     interpleveldefs = {
         'signal':              'interp_signal.signal',
         'getsignal':           'interp_signal.getsignal',
diff --git a/pypy/module/struct/__init__.py b/pypy/module/struct/__init__.py
--- a/pypy/module/struct/__init__.py
+++ b/pypy/module/struct/__init__.py
@@ -45,6 +45,8 @@
 
 The variable struct.error is an exception raised on errors."""
 
+    applevel_name = '__builtin_struct'
+
     interpleveldefs = {
         'calcsize': 'interp_struct.calcsize',
         'pack': 'interp_struct.pack',
diff --git a/pypy/module/termios/__init__.py b/pypy/module/termios/__init__.py
--- a/pypy/module/termios/__init__.py
+++ b/pypy/module/termios/__init__.py
@@ -13,6 +13,8 @@
     argument. This can be an integer file descriptor, such as returned by\n\
     sys.stdin.fileno(), or a file object, such as sys.stdin itself."
 
+    applevel_name = '__builtin_termios'
+
     appleveldefs = {
     }
     
diff --git a/pypy/module/thread/__init__.py b/pypy/module/thread/__init__.py
--- a/pypy/module/thread/__init__.py
+++ b/pypy/module/thread/__init__.py
@@ -3,6 +3,8 @@
 from pypy.interpreter.mixedmodule import MixedModule
 
 class Module(MixedModule):
+    applevel_name = 'thread'
+
     appleveldefs = {
     }
 
diff --git a/pypy/module/time/__init__.py b/pypy/module/time/__init__.py
--- a/pypy/module/time/__init__.py
+++ b/pypy/module/time/__init__.py
@@ -5,6 +5,7 @@
 
 class Module(MixedModule):
     """time module"""
+    applevel_name = '__builtin_time'
 
     appleveldefs = {
     }
diff --git a/pypy/module/unicodedata/__init__.py b/pypy/module/unicodedata/__init__.py
--- a/pypy/module/unicodedata/__init__.py
+++ b/pypy/module/unicodedata/__init__.py
@@ -8,6 +8,7 @@
 # http://www.fileformat.info/info/unicode/char/search.htm
 
 class Module(MixedModule):
+    applevel_name = '__builtin_unicodedata'
     appleveldefs = {
     }
     interpleveldefs = {
diff --git a/pypy/module/zipimport/__init__.py b/pypy/module/zipimport/__init__.py
--- a/pypy/module/zipimport/__init__.py
+++ b/pypy/module/zipimport/__init__.py
@@ -5,6 +5,7 @@
 from pypy.interpreter.mixedmodule import MixedModule
 
 class Module(MixedModule):
+    applevel_name = 'zipimport'
 
     interpleveldefs = {
         'zipimporter':'interp_zipimport.W_ZipImporter',
diff --git a/pypy/module/zlib/__init__.py b/pypy/module/zlib/__init__.py
--- a/pypy/module/zlib/__init__.py
+++ b/pypy/module/zlib/__init__.py
@@ -23,6 +23,8 @@
 Compressor objects support compress() and flush() methods; decompressor
 objects support decompress() and flush()."""
 
+    applevel_name = '__builtin_zlib'
+
     interpleveldefs = {
         'crc32': 'interp_zlib.crc32',
         'adler32': 'interp_zlib.adler32',
diff --git a/pypy/objspace/std/dicttype.py b/pypy/objspace/std/dicttype.py
--- a/pypy/objspace/std/dicttype.py
+++ b/pypy/objspace/std/dicttype.py
@@ -148,7 +148,7 @@
     XXX to do: remove this __reduce__ method and do
     a registration with copy_reg, instead.
     """
-    w_mod    = space.getbuiltinmodule('__builtin__pickle_support')
+    w_mod    = space.getbuiltinmodule('_pickle_support')
     mod      = space.interp_w(MixedModule, w_mod)
     new_inst = mod.get('dictiter_surrogate_new')
     w_typeobj = space.gettypeobject(dictiter_typedef)
diff --git a/pypy/objspace/std/itertype.py b/pypy/objspace/std/itertype.py
--- a/pypy/objspace/std/itertype.py
+++ b/pypy/objspace/std/itertype.py
@@ -17,7 +17,7 @@
     from pypy.objspace.std.iterobject import W_AbstractSeqIterObject
     assert isinstance(w_self, W_AbstractSeqIterObject)
     from pypy.interpreter.mixedmodule import MixedModule
-    w_mod    = space.getbuiltinmodule('__builtin__pickle_support')
+    w_mod    = space.getbuiltinmodule('_pickle_support')
     mod      = space.interp_w(MixedModule, w_mod)
     new_inst = mod.get('seqiter_new')
     tup      = [w_self.w_seq, space.wrap(w_self.index)]
@@ -33,7 +33,7 @@
     from pypy.objspace.std.iterobject import W_ReverseSeqIterObject
     assert isinstance(w_self, W_ReverseSeqIterObject)
     from pypy.interpreter.mixedmodule import MixedModule
-    w_mod    = space.getbuiltinmodule('__builtin__pickle_support')
+    w_mod    = space.getbuiltinmodule('_pickle_support')
     mod      = space.interp_w(MixedModule, w_mod)
     new_inst = mod.get('reverseseqiter_new')
     tup      = [w_self.w_seq, space.wrap(w_self.index)]


More information about the pypy-commit mailing list