[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�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�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�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