[pypy-commit] pypy win64-stage1: Merge
ctismer
noreply at buildbot.pypy.org
Fri Mar 23 16:35:39 CET 2012
Author: Christian Tismer <tismer at stackless.com>
Branch: win64-stage1
Changeset: r53942:0d31ed29ac76
Date: 2012-03-23 16:34 +0100
http://bitbucket.org/pypy/pypy/changeset/0d31ed29ac76/
Log: Merge
diff --git a/lib-python/modified-2.7/site.py b/lib-python/modified-2.7/site.py
--- a/lib-python/modified-2.7/site.py
+++ b/lib-python/modified-2.7/site.py
@@ -550,9 +550,18 @@
"'import usercustomize' failed; use -v for traceback"
+def import_builtin_stuff():
+ """PyPy specific: pre-import a few built-in modules, because
+ some programs actually rely on them to be in sys.modules :-("""
+ import exceptions
+ if 'zipimport' in sys.builtin_module_names:
+ import zipimport
+
+
def main():
global ENABLE_USER_SITE
+ import_builtin_stuff()
abs__file__()
known_paths = removeduppaths()
if (os.name == "posix" and sys.path and
diff --git a/lib_pypy/_locale.py b/lib_pypy/_locale.py
deleted file mode 100644
--- a/lib_pypy/_locale.py
+++ /dev/null
@@ -1,337 +0,0 @@
-# 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',)
diff --git a/lib_pypy/array.py b/lib_pypy/array.py
deleted file mode 100644
--- a/lib_pypy/array.py
+++ /dev/null
@@ -1,531 +0,0 @@
-"""This module defines an object type which can efficiently represent
-an array of basic values: characters, integers, floating point
-numbers. Arrays are sequence types and behave very much like lists,
-except that the type of objects stored in them is constrained. The
-type is specified at object creation time by using a type code, which
-is a single character. The following type codes are defined:
-
- Type code C Type Minimum size in bytes
- 'c' character 1
- 'b' signed integer 1
- 'B' unsigned integer 1
- 'u' Unicode character 2
- 'h' signed integer 2
- 'H' unsigned integer 2
- 'i' signed integer 2
- 'I' unsigned integer 2
- 'l' signed integer 4
- 'L' unsigned integer 4
- 'f' floating point 4
- 'd' floating point 8
-
-The constructor is:
-
-array(typecode [, initializer]) -- create a new array
-"""
-
-from struct import calcsize, pack, pack_into, unpack_from
-import operator
-
-# the buffer-like object to use internally: trying from
-# various places in order...
-try:
- import _rawffi # a reasonable implementation based
- _RAWARRAY = _rawffi.Array('c') # on raw_malloc, and providing a
- def bytebuffer(size): # real address
- return _RAWARRAY(size, autofree=True)
- def getbufaddress(buf):
- return buf.buffer
-except ImportError:
- try:
- from __pypy__ import bytebuffer # a reasonable implementation
- def getbufaddress(buf): # compatible with oo backends,
- return 0 # but no address
- except ImportError:
- # not running on PyPy. Fall back to ctypes...
- import ctypes
- bytebuffer = ctypes.create_string_buffer
- def getbufaddress(buf):
- voidp = ctypes.cast(ctypes.pointer(buf), ctypes.c_void_p)
- return voidp.value
-
-# ____________________________________________________________
-
-TYPECODES = "cbBuhHiIlLfd"
-
-class array(object):
- """array(typecode [, initializer]) -> array
-
- Return a new array whose items are restricted by typecode, and
- initialized from the optional initializer value, which must be a list,
- string. or iterable over elements of the appropriate type.
-
- Arrays represent basic values and behave very much like lists, except
- the type of objects stored in them is constrained.
-
- Methods:
-
- append() -- append a new item to the end of the array
- buffer_info() -- return information giving the current memory info
- byteswap() -- byteswap all the items of the array
- count() -- return number of occurences of an object
- extend() -- extend array by appending multiple elements from an iterable
- fromfile() -- read items from a file object
- fromlist() -- append items from the list
- fromstring() -- append items from the string
- index() -- return index of first occurence of an object
- insert() -- insert a new item into the array at a provided position
- pop() -- remove and return item (default last)
- read() -- DEPRECATED, use fromfile()
- remove() -- remove first occurence of an object
- reverse() -- reverse the order of the items in the array
- tofile() -- write all items to a file object
- tolist() -- return the array converted to an ordinary list
- tostring() -- return the array converted to a string
- write() -- DEPRECATED, use tofile()
-
- Attributes:
-
- typecode -- the typecode character used to create the array
- itemsize -- the length in bytes of one array item
- """
- __slots__ = ["typecode", "itemsize", "_data", "_descriptor", "__weakref__"]
-
- def __new__(cls, typecode, initializer=[], **extrakwds):
- self = object.__new__(cls)
- if cls is array and extrakwds:
- raise TypeError("array() does not take keyword arguments")
- if not isinstance(typecode, str) or len(typecode) != 1:
- raise TypeError(
- "array() argument 1 must be char, not %s" % type(typecode))
- if typecode not in TYPECODES:
- raise ValueError(
- "bad typecode (must be one of %s)" % ', '.join(TYPECODES))
- self._data = bytebuffer(0)
- self.typecode = typecode
- self.itemsize = calcsize(typecode)
- if isinstance(initializer, list):
- self.fromlist(initializer)
- elif isinstance(initializer, str):
- self.fromstring(initializer)
- elif isinstance(initializer, unicode) and self.typecode == "u":
- self.fromunicode(initializer)
- else:
- self.extend(initializer)
- return self
-
- def _clear(self):
- self._data = bytebuffer(0)
-
- ##### array-specific operations
-
- def fromfile(self, f, n):
- """Read n objects from the file object f and append them to the end of
- the array. Also called as read."""
- if not isinstance(f, file):
- raise TypeError("arg1 must be open file")
- size = self.itemsize * n
- item = f.read(size)
- if len(item) < size:
- raise EOFError("not enough items in file")
- self.fromstring(item)
-
- def fromlist(self, l):
- """Append items to array from list."""
- if not isinstance(l, list):
- raise TypeError("arg must be list")
- self._fromiterable(l)
-
- def fromstring(self, s):
- """Appends items from the string, interpreting it as an array of machine
- values, as if it had been read from a file using the fromfile()
- method."""
- if isinstance(s, unicode):
- s = str(s)
- self._frombuffer(s)
-
- def _frombuffer(self, s):
- length = len(s)
- if length % self.itemsize != 0:
- raise ValueError("string length not a multiple of item size")
- boundary = len(self._data)
- newdata = bytebuffer(boundary + length)
- newdata[:boundary] = self._data
- newdata[boundary:] = s
- self._data = newdata
-
- def fromunicode(self, ustr):
- """Extends this array with data from the unicode string ustr. The array
- must be a type 'u' array; otherwise a ValueError is raised. Use
- array.fromstring(ustr.encode(...)) to append Unicode data to an array of
- some other type."""
- if not self.typecode == "u":
- raise ValueError(
- "fromunicode() may only be called on type 'u' arrays")
- # XXX the following probable bug is not emulated:
- # CPython accepts a non-unicode string or a buffer, and then
- # behaves just like fromstring(), except that it strangely truncates
- # string arguments at multiples of the unicode byte size.
- # Let's only accept unicode arguments for now.
- if not isinstance(ustr, unicode):
- raise TypeError("fromunicode() argument should probably be "
- "a unicode string")
- # _frombuffer() does the currect thing using
- # the buffer behavior of unicode objects
- self._frombuffer(buffer(ustr))
-
- def tofile(self, f):
- """Write all items (as machine values) to the file object f. Also
- called as write."""
- if not isinstance(f, file):
- raise TypeError("arg must be open file")
- f.write(self.tostring())
-
- def tolist(self):
- """Convert array to an ordinary list with the same items."""
- count = len(self._data) // self.itemsize
- return list(unpack_from('%d%s' % (count, self.typecode), self._data))
-
- def tostring(self):
- return self._data[:]
-
- def __buffer__(self):
- return buffer(self._data)
-
- def tounicode(self):
- """Convert the array to a unicode string. The array must be a type 'u'
- array; otherwise a ValueError is raised. Use array.tostring().decode()
- to obtain a unicode string from an array of some other type."""
- if self.typecode != "u":
- raise ValueError("tounicode() may only be called on type 'u' arrays")
- # XXX performance is not too good
- return u"".join(self.tolist())
-
- def byteswap(self):
- """Byteswap all items of the array. If the items in the array are not
- 1, 2, 4, or 8 bytes in size, RuntimeError is raised."""
- if self.itemsize not in [1, 2, 4, 8]:
- raise RuntimeError("byteswap not supported for this array")
- # XXX slowish
- itemsize = self.itemsize
- bytes = self._data
- for start in range(0, len(bytes), itemsize):
- stop = start + itemsize
- bytes[start:stop] = bytes[start:stop][::-1]
-
- def buffer_info(self):
- """Return a tuple (address, length) giving the current memory address
- and the length in items of the buffer used to hold array's contents. The
- length should be multiplied by the itemsize attribute to calculate the
- buffer length in bytes. On PyPy the address might be meaningless
- (returned as 0), depending on the available modules."""
- return (getbufaddress(self._data), len(self))
-
- read = fromfile
-
- write = tofile
-
- ##### general object protocol
-
- def __repr__(self):
- if len(self._data) == 0:
- return "array('%s')" % self.typecode
- elif self.typecode == "c":
- return "array('%s', %s)" % (self.typecode, repr(self.tostring()))
- elif self.typecode == "u":
- return "array('%s', %s)" % (self.typecode, repr(self.tounicode()))
- else:
- return "array('%s', %s)" % (self.typecode, repr(self.tolist()))
-
- def __copy__(self):
- a = array(self.typecode)
- a._data = bytebuffer(len(self._data))
- a._data[:] = self._data
- return a
-
- def __eq__(self, other):
- if not isinstance(other, array):
- return NotImplemented
- if self.typecode == 'c':
- return buffer(self._data) == buffer(other._data)
- else:
- return self.tolist() == other.tolist()
-
- def __ne__(self, other):
- if not isinstance(other, array):
- return NotImplemented
- if self.typecode == 'c':
- return buffer(self._data) != buffer(other._data)
- else:
- return self.tolist() != other.tolist()
-
- def __lt__(self, other):
- if not isinstance(other, array):
- return NotImplemented
- if self.typecode == 'c':
- return buffer(self._data) < buffer(other._data)
- else:
- return self.tolist() < other.tolist()
-
- def __gt__(self, other):
- if not isinstance(other, array):
- return NotImplemented
- if self.typecode == 'c':
- return buffer(self._data) > buffer(other._data)
- else:
- return self.tolist() > other.tolist()
-
- def __le__(self, other):
- if not isinstance(other, array):
- return NotImplemented
- if self.typecode == 'c':
- return buffer(self._data) <= buffer(other._data)
- else:
- return self.tolist() <= other.tolist()
-
- def __ge__(self, other):
- if not isinstance(other, array):
- return NotImplemented
- if self.typecode == 'c':
- return buffer(self._data) >= buffer(other._data)
- else:
- return self.tolist() >= other.tolist()
-
- def __reduce__(self):
- dict = getattr(self, '__dict__', None)
- data = self.tostring()
- if data:
- initargs = (self.typecode, data)
- else:
- initargs = (self.typecode,)
- return (type(self), initargs, dict)
-
- ##### list methods
-
- def append(self, x):
- """Append new value x to the end of the array."""
- self._frombuffer(pack(self.typecode, x))
-
- def count(self, x):
- """Return number of occurences of x in the array."""
- return operator.countOf(self, x)
-
- def extend(self, iterable):
- """Append items to the end of the array."""
- if isinstance(iterable, array) \
- and not self.typecode == iterable.typecode:
- raise TypeError("can only extend with array of same kind")
- self._fromiterable(iterable)
-
- def index(self, x):
- """Return index of first occurence of x in the array."""
- return operator.indexOf(self, x)
-
- def insert(self, i, x):
- """Insert a new item x into the array before position i."""
- seqlength = len(self)
- if i < 0:
- i += seqlength
- if i < 0:
- i = 0
- elif i > seqlength:
- i = seqlength
- boundary = i * self.itemsize
- data = pack(self.typecode, x)
- newdata = bytebuffer(len(self._data) + len(data))
- newdata[:boundary] = self._data[:boundary]
- newdata[boundary:boundary+self.itemsize] = data
- newdata[boundary+self.itemsize:] = self._data[boundary:]
- self._data = newdata
-
- def pop(self, i=-1):
- """Return the i-th element and delete it from the array. i defaults to
- -1."""
- seqlength = len(self)
- if i < 0:
- i += seqlength
- if not (0 <= i < seqlength):
- raise IndexError(i)
- boundary = i * self.itemsize
- result = unpack_from(self.typecode, self._data, boundary)[0]
- newdata = bytebuffer(len(self._data) - self.itemsize)
- newdata[:boundary] = self._data[:boundary]
- newdata[boundary:] = self._data[boundary+self.itemsize:]
- self._data = newdata
- return result
-
- def remove(self, x):
- """Remove the first occurence of x in the array."""
- self.pop(self.index(x))
-
- def reverse(self):
- """Reverse the order of the items in the array."""
- lst = self.tolist()
- lst.reverse()
- self._clear()
- self.fromlist(lst)
-
- ##### list protocol
-
- def __len__(self):
- return len(self._data) // self.itemsize
-
- def __add__(self, other):
- if not isinstance(other, array):
- raise TypeError("can only append array to array")
- if self.typecode != other.typecode:
- raise TypeError("bad argument type for built-in operation")
- return array(self.typecode, buffer(self._data) + buffer(other._data))
-
- def __mul__(self, repeat):
- return array(self.typecode, buffer(self._data) * repeat)
-
- __rmul__ = __mul__
-
- def __getitem__(self, i):
- seqlength = len(self)
- if isinstance(i, slice):
- start, stop, step = i.indices(seqlength)
- if step != 1:
- sublist = self.tolist()[i] # fall-back
- return array(self.typecode, sublist)
- if start < 0:
- start = 0
- if stop < start:
- stop = start
- assert stop <= seqlength
- return array(self.typecode, self._data[start * self.itemsize :
- stop * self.itemsize])
- else:
- if i < 0:
- i += seqlength
- if self.typecode == 'c': # speed trick
- return self._data[i]
- if not (0 <= i < seqlength):
- raise IndexError(i)
- boundary = i * self.itemsize
- return unpack_from(self.typecode, self._data, boundary)[0]
-
- def __getslice__(self, i, j):
- return self.__getitem__(slice(i, j))
-
- def __setitem__(self, i, x):
- if isinstance(i, slice):
- if (not isinstance(x, array)
- or self.typecode != x.typecode):
- raise TypeError("can only assign array of same kind"
- " to array slice")
- seqlength = len(self)
- start, stop, step = i.indices(seqlength)
- if step != 1:
- sublist = self.tolist() # fall-back
- sublist[i] = x.tolist()
- self._clear()
- self.fromlist(sublist)
- return
- if start < 0:
- start = 0
- if stop < start:
- stop = start
- assert stop <= seqlength
- boundary1 = start * self.itemsize
- boundary2 = stop * self.itemsize
- boundary2new = boundary1 + len(x._data)
- if boundary2 == boundary2new:
- self._data[boundary1:boundary2] = x._data
- else:
- newdata = bytebuffer(len(self._data) + boundary2new-boundary2)
- newdata[:boundary1] = self._data[:boundary1]
- newdata[boundary1:boundary2new] = x._data
- newdata[boundary2new:] = self._data[boundary2:]
- self._data = newdata
- else:
- seqlength = len(self)
- if i < 0:
- i += seqlength
- if self.typecode == 'c': # speed trick
- self._data[i] = x
- return
- if not (0 <= i < seqlength):
- raise IndexError(i)
- boundary = i * self.itemsize
- pack_into(self.typecode, self._data, boundary, x)
-
- def __setslice__(self, i, j, x):
- self.__setitem__(slice(i, j), x)
-
- def __delitem__(self, i):
- if isinstance(i, slice):
- seqlength = len(self)
- start, stop, step = i.indices(seqlength)
- if start < 0:
- start = 0
- if stop < start:
- stop = start
- assert stop <= seqlength
- if step != 1:
- sublist = self.tolist() # fall-back
- del sublist[i]
- self._clear()
- self.fromlist(sublist)
- return
- dellength = stop - start
- boundary1 = start * self.itemsize
- boundary2 = stop * self.itemsize
- newdata = bytebuffer(len(self._data) - (boundary2-boundary1))
- newdata[:boundary1] = self._data[:boundary1]
- newdata[boundary1:] = self._data[boundary2:]
- self._data = newdata
- else:
- seqlength = len(self)
- if i < 0:
- i += seqlength
- if not (0 <= i < seqlength):
- raise IndexError(i)
- boundary = i * self.itemsize
- newdata = bytebuffer(len(self._data) - self.itemsize)
- newdata[:boundary] = self._data[:boundary]
- newdata[boundary:] = self._data[boundary+self.itemsize:]
- self._data = newdata
-
- def __delslice__(self, i, j):
- self.__delitem__(slice(i, j))
-
- def __contains__(self, item):
- for x in self:
- if x == item:
- return True
- return False
-
- def __iadd__(self, other):
- if not isinstance(other, array):
- raise TypeError("can only extend array with array")
- self.extend(other)
- return self
-
- def __imul__(self, repeat):
- newdata = buffer(self._data) * repeat
- self._data = bytebuffer(len(newdata))
- self._data[:] = newdata
- return self
-
- def __iter__(self):
- p = 0
- typecode = self.typecode
- itemsize = self.itemsize
- while p < len(self._data):
- yield unpack_from(typecode, self._data, p)[0]
- p += itemsize
-
- ##### internal methods
-
- def _fromiterable(self, iterable):
- iterable = tuple(iterable)
- n = len(iterable)
- boundary = len(self._data)
- newdata = bytebuffer(boundary + n * self.itemsize)
- newdata[:boundary] = self._data
- pack_into('%d%s' % (n, self.typecode), newdata, boundary, *iterable)
- self._data = newdata
-
-ArrayType = array
diff --git a/lib_pypy/binascii.py b/lib_pypy/binascii.py
deleted file mode 100644
--- a/lib_pypy/binascii.py
+++ /dev/null
@@ -1,720 +0,0 @@
-"""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
diff --git a/lib_pypy/numpypy/core/numeric.py b/lib_pypy/numpypy/core/numeric.py
--- a/lib_pypy/numpypy/core/numeric.py
+++ b/lib_pypy/numpypy/core/numeric.py
@@ -306,6 +306,125 @@
else:
return multiarray.set_string_function(f, repr)
+def array_equal(a1, a2):
+ """
+ True if two arrays have the same shape and elements, False otherwise.
+
+ Parameters
+ ----------
+ a1, a2 : array_like
+ Input arrays.
+
+ Returns
+ -------
+ b : bool
+ Returns True if the arrays are equal.
+
+ See Also
+ --------
+ allclose: Returns True if two arrays are element-wise equal within a
+ tolerance.
+ array_equiv: Returns True if input arrays are shape consistent and all
+ elements equal.
+
+ Examples
+ --------
+ >>> np.array_equal([1, 2], [1, 2])
+ True
+ >>> np.array_equal(np.array([1, 2]), np.array([1, 2]))
+ True
+ >>> np.array_equal([1, 2], [1, 2, 3])
+ False
+ >>> np.array_equal([1, 2], [1, 4])
+ False
+
+ """
+ try:
+ a1, a2 = asarray(a1), asarray(a2)
+ except:
+ return False
+ if a1.shape != a2.shape:
+ return False
+ return bool((a1 == a2).all())
+
+def asarray(a, dtype=None, order=None, maskna=None, ownmaskna=False):
+ """
+ Convert the input to an array.
+
+ Parameters
+ ----------
+ a : array_like
+ Input data, in any form that can be converted to an array. This
+ includes lists, lists of tuples, tuples, tuples of tuples, tuples
+ of lists and ndarrays.
+ dtype : data-type, optional
+ By default, the data-type is inferred from the input data.
+ order : {'C', 'F'}, optional
+ Whether to use row-major ('C') or column-major ('F' for FORTRAN)
+ memory representation. Defaults to 'C'.
+ maskna : bool or None, optional
+ If this is set to True, it forces the array to have an NA mask.
+ If this is set to False, it forces the array to not have an NA
+ mask.
+ ownmaskna : bool, optional
+ If this is set to True, forces the array to have a mask which
+ it owns.
+
+ Returns
+ -------
+ out : ndarray
+ Array interpretation of `a`. No copy is performed if the input
+ is already an ndarray. If `a` is a subclass of ndarray, a base
+ class ndarray is returned.
+
+ See Also
+ --------
+ asanyarray : Similar function which passes through subclasses.
+ ascontiguousarray : Convert input to a contiguous array.
+ asfarray : Convert input to a floating point ndarray.
+ asfortranarray : Convert input to an ndarray with column-major
+ memory order.
+ asarray_chkfinite : Similar function which checks input for NaNs and Infs.
+ fromiter : Create an array from an iterator.
+ fromfunction : Construct an array by executing a function on grid
+ positions.
+
+ Examples
+ --------
+ Convert a list into an array:
+
+ >>> a = [1, 2]
+ >>> np.asarray(a)
+ array([1, 2])
+
+ Existing arrays are not copied:
+
+ >>> a = np.array([1, 2])
+ >>> np.asarray(a) is a
+ True
+
+ If `dtype` is set, array is copied only if dtype does not match:
+
+ >>> a = np.array([1, 2], dtype=np.float32)
+ >>> np.asarray(a, dtype=np.float32) is a
+ True
+ >>> np.asarray(a, dtype=np.float64) is a
+ False
+
+ Contrary to `asanyarray`, ndarray subclasses are not passed through:
+
+ >>> issubclass(np.matrix, np.ndarray)
+ True
+ >>> a = np.matrix([[1, 2]])
+ >>> np.asarray(a) is a
+ False
+ >>> np.asanyarray(a) is a
+ True
+
+ """
+ return array(a, dtype, copy=False, order=order,
+ maskna=maskna, ownmaskna=ownmaskna)
+
set_string_function(array_str, 0)
set_string_function(array_repr, 1)
diff --git a/lib_pypy/pypy_test/test_binascii.py b/lib_pypy/pypy_test/test_binascii.py
deleted file mode 100644
--- a/lib_pypy/pypy_test/test_binascii.py
+++ /dev/null
@@ -1,168 +0,0 @@
-from __future__ import absolute_import
-import py
-from lib_pypy import binascii
-
-# Create binary test data
-data = "The quick brown fox jumps over the lazy dog.\r\n"
-# Be slow so we don't depend on other modules
-data += "".join(map(chr, xrange(256)))
-data += "\r\nHello world.\n"
-
-def test_exceptions():
- # Check module exceptions
- assert issubclass(binascii.Error, Exception)
- assert issubclass(binascii.Incomplete, Exception)
-
-def test_functions():
- # Check presence of all functions
- funcs = []
- for suffix in "base64", "hqx", "uu", "hex":
- prefixes = ["a2b_", "b2a_"]
- if suffix == "hqx":
- prefixes.extend(["crc_", "rlecode_", "rledecode_"])
- for prefix in prefixes:
- name = prefix + suffix
- assert callable(getattr(binascii, name))
- py.test.raises(TypeError, getattr(binascii, name))
- for name in ("hexlify", "unhexlify"):
- assert callable(getattr(binascii, name))
- py.test.raises(TypeError, getattr(binascii, name))
-
-def test_base64valid():
- # Test base64 with valid data
- MAX_BASE64 = 57
- lines = []
- for i in range(0, len(data), MAX_BASE64):
- b = data[i:i+MAX_BASE64]
- a = binascii.b2a_base64(b)
- lines.append(a)
- res = ""
- for line in lines:
- b = binascii.a2b_base64(line)
- res = res + b
- assert res == data
-
-def test_base64invalid():
- # Test base64 with random invalid characters sprinkled throughout
- # (This requires a new version of binascii.)
- MAX_BASE64 = 57
- lines = []
- for i in range(0, len(data), MAX_BASE64):
- b = data[i:i+MAX_BASE64]
- a = binascii.b2a_base64(b)
- lines.append(a)
-
- fillers = ""
- valid = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/"
- for i in xrange(256):
- c = chr(i)
- if c not in valid:
- fillers += c
- def addnoise(line):
- noise = fillers
- ratio = len(line) // len(noise)
- res = ""
- while line and noise:
- if len(line) // len(noise) > ratio:
- c, line = line[0], line[1:]
- else:
- c, noise = noise[0], noise[1:]
- res += c
- return res + noise + line
- res = ""
- for line in map(addnoise, lines):
- b = binascii.a2b_base64(line)
- res += b
- assert res == data
-
- # Test base64 with just invalid characters, which should return
- # empty strings. TBD: shouldn't it raise an exception instead ?
- assert binascii.a2b_base64(fillers) == ''
-
-def test_uu():
- MAX_UU = 45
- lines = []
- for i in range(0, len(data), MAX_UU):
- b = data[i:i+MAX_UU]
- a = binascii.b2a_uu(b)
- lines.append(a)
- res = ""
- for line in lines:
- b = binascii.a2b_uu(line)
- res += b
- assert res == data
-
- assert binascii.a2b_uu("\x7f") == "\x00"*31
- assert binascii.a2b_uu("\x80") == "\x00"*32
- assert binascii.a2b_uu("\xff") == "\x00"*31
- py.test.raises(binascii.Error, binascii.a2b_uu, "\xff\x00")
- py.test.raises(binascii.Error, binascii.a2b_uu, "!!!!")
-
- py.test.raises(binascii.Error, binascii.b2a_uu, 46*"!")
-
-def test_crc32():
- crc = binascii.crc32("Test the CRC-32 of")
- crc = binascii.crc32(" this string.", crc)
- assert crc == 1571220330
-
- crc = binascii.crc32('frotz\n', 0)
- assert crc == -372923920
-
- py.test.raises(TypeError, binascii.crc32)
-
-def test_hex():
- # test hexlification
- s = '{s\005\000\000\000worldi\002\000\000\000s\005\000\000\000helloi\001\000\000\0000'
- t = binascii.b2a_hex(s)
- u = binascii.a2b_hex(t)
- assert s == u
- py.test.raises(TypeError, binascii.a2b_hex, t[:-1])
- py.test.raises(TypeError, binascii.a2b_hex, t[:-1] + 'q')
-
- # Verify the treatment of Unicode strings
- assert binascii.hexlify(unicode('a', 'ascii')) == '61'
-
-def test_qp():
- # A test for SF bug 534347 (segfaults without the proper fix)
- try:
- binascii.a2b_qp("", **{1:1})
- except TypeError:
- pass
- else:
- fail("binascii.a2b_qp(**{1:1}) didn't raise TypeError")
- assert binascii.a2b_qp("= ") == "= "
- assert binascii.a2b_qp("==") == "="
- assert binascii.a2b_qp("=AX") == "=AX"
- py.test.raises(TypeError, binascii.b2a_qp, foo="bar")
- assert binascii.a2b_qp("=00\r\n=00") == "\x00\r\n\x00"
- assert binascii.b2a_qp("\xff\r\n\xff\n\xff") == "=FF\r\n=FF\r\n=FF"
- target = "0"*75+"=\r\n=FF\r\n=FF\r\n=FF"
- assert binascii.b2a_qp("0"*75+"\xff\r\n\xff\r\n\xff") == target
-
-def test_empty_string():
- # A test for SF bug #1022953. Make sure SystemError is not raised.
- for n in ['b2a_qp', 'a2b_hex', 'b2a_base64', 'a2b_uu', 'a2b_qp',
- 'b2a_hex', 'unhexlify', 'hexlify', 'crc32', 'b2a_hqx',
- 'a2b_hqx', 'a2b_base64', 'rlecode_hqx', 'b2a_uu',
- 'rledecode_hqx']:
- f = getattr(binascii, n)
- f('')
- binascii.crc_hqx('', 0)
-
-def test_qp_bug_case():
- assert binascii.b2a_qp('y'*77, False, False) == 'y'*75 + '=\nyy'
- assert binascii.b2a_qp(' '*77, False, False) == ' '*75 + '=\n =20'
- assert binascii.b2a_qp('y'*76, False, False) == 'y'*76
- assert binascii.b2a_qp(' '*76, False, False) == ' '*75 + '=\n=20'
-
-def test_wrong_padding():
- s = 'CSixpLDtKSC/7Liuvsax4iC6uLmwMcijIKHaILzSwd/H0SC8+LCjwLsgv7W/+Mj3IQ'
- py.test.raises(binascii.Error, binascii.a2b_base64, s)
-
-def test_crap_after_padding():
- s = 'xxx=axxxx'
- assert binascii.a2b_base64(s) == '\xc7\x1c'
-
-def test_wrong_args():
- # this should grow as a way longer list
- py.test.raises(TypeError, binascii.a2b_base64, 42)
diff --git a/lib_pypy/pypy_test/test_locale.py b/lib_pypy/pypy_test/test_locale.py
deleted file mode 100644
--- a/lib_pypy/pypy_test/test_locale.py
+++ /dev/null
@@ -1,79 +0,0 @@
-from __future__ import absolute_import
-import py
-import sys
-
-from lib_pypy.ctypes_config_cache import rebuild
-rebuild.rebuild_one('locale.ctc.py')
-
-from lib_pypy import _locale
-
-
-def setup_module(mod):
- if sys.platform == 'darwin':
- py.test.skip("Locale support on MacOSX is minimal and cannot be tested")
-
-class TestLocale:
- def setup_class(cls):
- cls.oldlocale = _locale.setlocale(_locale.LC_NUMERIC)
- if sys.platform.startswith("win"):
- cls.tloc = "en"
- elif sys.platform.startswith("freebsd"):
- cls.tloc = "en_US.US-ASCII"
- else:
- cls.tloc = "en_US.UTF8"
- try:
- _locale.setlocale(_locale.LC_NUMERIC, cls.tloc)
- except _locale.Error:
- py.test.skip("test locale %s not supported" % cls.tloc)
-
- def teardown_class(cls):
- _locale.setlocale(_locale.LC_NUMERIC, cls.oldlocale)
-
- def test_format(self):
- py.test.skip("XXX fix or kill me")
-
- def testformat(formatstr, value, grouping = 0, output=None):
- if output:
- print "%s %% %s =? %s ..." %\
- (repr(formatstr), repr(value), repr(output)),
- else:
- print "%s %% %s works? ..." % (repr(formatstr), repr(value)),
- result = locale.format(formatstr, value, grouping = grouping)
- assert result == output
-
- testformat("%f", 1024, grouping=1, output='1,024.000000')
- testformat("%f", 102, grouping=1, output='102.000000')
- testformat("%f", -42, grouping=1, output='-42.000000')
- testformat("%+f", -42, grouping=1, output='-42.000000')
- testformat("%20.f", -42, grouping=1, output=' -42')
- testformat("%+10.f", -4200, grouping=1, output=' -4,200')
- testformat("%-10.f", 4200, grouping=1, output='4,200 ')
-
- def test_getpreferredencoding(self):
- py.test.skip("XXX fix or kill me")
- # Invoke getpreferredencoding to make sure it does not cause exceptions
- _locale.getpreferredencoding()
-
- # Test BSD Rune locale's bug for isctype functions.
- def test_bsd_bug(self):
- def teststrop(s, method, output):
- print "%s.%s() =? %s ..." % (repr(s), method, repr(output)),
- result = getattr(s, method)()
- assert result == output
-
- oldlocale = _locale.setlocale(_locale.LC_CTYPE)
- _locale.setlocale(_locale.LC_CTYPE, self.tloc)
- try:
- teststrop('\x20', 'isspace', True)
- teststrop('\xa0', 'isspace', False)
- teststrop('\xa1', 'isspace', False)
- teststrop('\xc0', 'isalpha', False)
- teststrop('\xc0', 'isalnum', False)
- teststrop('\xc0', 'isupper', False)
- teststrop('\xc0', 'islower', False)
- teststrop('\xec\xa0\xbc', 'split', ['\xec\xa0\xbc'])
- teststrop('\xed\x95\xa0', 'strip', '\xed\x95\xa0')
- teststrop('\xcc\x85', 'lower', '\xcc\x85')
- teststrop('\xed\x95\xa0', 'upper', '\xed\x95\xa0')
- finally:
- _locale.setlocale(_locale.LC_CTYPE, oldlocale)
diff --git a/lib_pypy/pypy_test/test_site_extra.py b/lib_pypy/pypy_test/test_site_extra.py
new file mode 100644
--- /dev/null
+++ b/lib_pypy/pypy_test/test_site_extra.py
@@ -0,0 +1,13 @@
+import sys, os
+
+
+def test_preimported_modules():
+ lst = ['__builtin__', '_codecs', '_warnings', 'codecs', 'encodings',
+ 'exceptions', 'signal', 'sys', 'zipimport']
+ g = os.popen("'%s' -c 'import sys; print sorted(sys.modules)'" %
+ (sys.executable,))
+ real_data = g.read()
+ g.close()
+ for name in lst:
+ quoted_name = repr(name)
+ assert quoted_name in real_data
diff --git a/lib_pypy/pypy_test/test_struct_extra.py b/lib_pypy/pypy_test/test_struct_extra.py
deleted file mode 100644
--- a/lib_pypy/pypy_test/test_struct_extra.py
+++ /dev/null
@@ -1,25 +0,0 @@
-from __future__ import absolute_import
-from lib_pypy import struct
-
-def test_simple():
- morezeros = '\x00' * (struct.calcsize('l')-4)
- assert struct.pack('<l', 16) == '\x10\x00\x00\x00' + morezeros
- assert struct.pack('4s', 'WAVE') == 'WAVE'
- assert struct.pack('<4sl', 'WAVE', 16) == 'WAVE\x10\x00\x00\x00' + morezeros
- s = 'ABCD01234567\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00'
- assert struct.unpack('<4s4H2lH', s) == ('ABCD', 0x3130, 0x3332, 0x3534,
- 0x3736, 1, 2, 3)
-
-def test_infinity():
- INFINITY = 1e200 * 1e200
- assert str(struct.unpack("!d", struct.pack("!d", INFINITY))[0]) \
- == str(INFINITY)
- assert str(struct.unpack("!d", struct.pack("!d", -INFINITY))[0]) \
- == str(-INFINITY)
-
-def test_nan():
- INFINITY = 1e200 * 1e200
- NAN = INFINITY / INFINITY
- assert str(struct.unpack("!d", '\xff\xf8\x00\x00\x00\x00\x00\x00')[0]) \
- == str(NAN)
- assert str(struct.unpack("!d", struct.pack("!d", NAN))[0]) == str(NAN)
diff --git a/lib_pypy/struct.py b/lib_pypy/struct.py
deleted file mode 100644
--- a/lib_pypy/struct.py
+++ /dev/null
@@ -1,417 +0,0 @@
-#
-# 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)
diff --git a/pypy/doc/project-ideas.rst b/pypy/doc/project-ideas.rst
--- a/pypy/doc/project-ideas.rst
+++ b/pypy/doc/project-ideas.rst
@@ -103,21 +103,13 @@
* A concurrent garbage collector (a lot of work)
-Remove the GIL
---------------
+STM, a.k.a. "remove the GIL"
+----------------------------
-This is a major task that requires lots of thinking. However, few subprojects
-can be potentially specified, unless a better plan can be thought out:
+Removing the GIL --- or more precisely, a GIL-less thread-less solution ---
+is `now work in progress.`__ Contributions welcome.
-* A thread-aware garbage collector
-
-* Better RPython primitives for dealing with concurrency
-
-* JIT passes to remove locks on objects
-
-* (maybe) implement locking in Python interpreter
-
-* alternatively, look at Software Transactional Memory
+.. __: http://pypy.org/tmdonate.html
Introduce new benchmarks
------------------------
diff --git a/pypy/doc/sandbox.rst b/pypy/doc/sandbox.rst
--- a/pypy/doc/sandbox.rst
+++ b/pypy/doc/sandbox.rst
@@ -82,7 +82,10 @@
In pypy/translator/goal::
- ./translate.py --sandbox targetpypystandalone.py
+ ./translate.py -O2 --sandbox targetpypystandalone.py
+
+If you don't have a regular PyPy installed, you should, because it's
+faster to translate, but you can also run ``python translate.py`` instead.
To run it, use the tools in the pypy/translator/sandbox directory::
diff --git a/pypy/doc/you-want-to-help.rst b/pypy/doc/you-want-to-help.rst
new file mode 100644
--- /dev/null
+++ b/pypy/doc/you-want-to-help.rst
@@ -0,0 +1,68 @@
+
+You want to help with PyPy, now what?
+=====================================
+
+PyPy is a very large project that has a reputation of being hard to dive into.
+Some of this fame is warranted, some of it is purely accidental. There are three
+important lessons that everyone willing to contribute should learn:
+
+* PyPy has layers. There are many pieces of architecture that are very well
+ separated from each other. More about this below, but often the manifestation
+ of this is that things are at a different layer than you would expect them
+ to be. For example if you are looking for the JIT implementation, you will
+ not find it in the implementation of the Python programming language.
+
+* Because of the above, we are very serious about Test Driven Development.
+ It's not only what we believe in, but also that PyPy's architecture is
+ working very well with TDD in mind and not so well without it. Often
+ the development means progressing in an unrelated corner, one unittest
+ at a time and then flipping a giant switch. It's worth repeating - PyPy
+ approach is great if you do TDD, not so great otherwise.
+
+* PyPy uses an entirely different set of tools - most of them included
+ in the PyPy repository. There is no Makefile, nor autoconf. More below
+
+Architecture
+============
+
+PyPy has layers. The 100 mile view:
+
+* `RPython`_ is a language in which we write interpreter in PyPy. Not the entire
+ PyPy project is written in RPython, only parts that are compiled in
+ the translation process. The interesting point is that RPython has no parser,
+ it's compiled from the live python objects, which make it possible to do
+ all kinds of metaprogramming during import time. In short, Python is a meta
+ programming language for RPython.
+
+ RPython standard library is to be found in ``rlib`` subdirectory.
+
+.. _`RPython`: coding-guide.html#RPython
+
+* Translation toolchain - this is the part that takes care about translating
+ RPython to flow graphs and then to C. There is more in `architecture`_
+ document written about it.
+
+ It mostly lives in ``rpython``, ``annotator`` and ``objspace/flow``.
+
+.. _`architecture`: architecture.html
+
+* Python Interpreter
+
+ xxx
+
+* Python modules
+
+ xxx
+
+* JIT
+
+ xxx
+
+* Garbage Collectors
+
+ xxx
+
+Toolset
+=======
+
+xxx
diff --git a/pypy/interpreter/test/test_objspace.py b/pypy/interpreter/test/test_objspace.py
--- a/pypy/interpreter/test/test_objspace.py
+++ b/pypy/interpreter/test/test_objspace.py
@@ -312,8 +312,8 @@
mods = space.get_builtinmodule_to_install()
assert '__pypy__' in mods # real builtin
- assert 'array' not in mods # in lib_pypy
- assert 'faked+array' not in mods # in lib_pypy
+ assert '_functools' not in mods # in lib_pypy
+ assert 'faked+_functools' not in mods # in lib_pypy
assert 'this_doesnt_exist' not in mods # not in lib_pypy
assert 'faked+this_doesnt_exist' in mods # not in lib_pypy, but in
# ALL_BUILTIN_MODULES
diff --git a/pypy/interpreter/test/test_zzpickle_and_slow.py b/pypy/interpreter/test/test_zzpickle_and_slow.py
--- a/pypy/interpreter/test/test_zzpickle_and_slow.py
+++ b/pypy/interpreter/test/test_zzpickle_and_slow.py
@@ -75,6 +75,7 @@
class AppTestInterpObjectPickling:
pytestmark = py.test.mark.skipif("config.option.runappdirect")
def setup_class(cls):
+ cls.space = gettestobjspace(usemodules=['struct'])
_attach_helpers(cls.space)
def teardown_class(cls):
diff --git a/pypy/jit/backend/x86/rx86.py b/pypy/jit/backend/x86/rx86.py
--- a/pypy/jit/backend/x86/rx86.py
+++ b/pypy/jit/backend/x86/rx86.py
@@ -601,7 +601,9 @@
CVTSS2SD_xb = xmminsn('\xF3', rex_nw, '\x0F\x5A',
register(1, 8), stack_bp(2))
- # These work on machine sized registers.
+ # These work on machine sized registers, so MOVD is actually MOVQ
+ # when running on 64 bits. Note a bug in the Intel documentation:
+ # http://lists.gnu.org/archive/html/bug-binutils/2007-07/msg00095.html
MOVD_rx = xmminsn('\x66', rex_w, '\x0F\x7E', register(2, 8), register(1), '\xC0')
MOVD_xr = xmminsn('\x66', rex_w, '\x0F\x6E', register(1, 8), register(2), '\xC0')
MOVD_xb = xmminsn('\x66', rex_w, '\x0F\x6E', register(1, 8), stack_bp(2))
diff --git a/pypy/jit/backend/x86/test/test_rx86_32_auto_encoding.py b/pypy/jit/backend/x86/test/test_rx86_32_auto_encoding.py
--- a/pypy/jit/backend/x86/test/test_rx86_32_auto_encoding.py
+++ b/pypy/jit/backend/x86/test/test_rx86_32_auto_encoding.py
@@ -182,6 +182,12 @@
filename = str(testdir.join(FILENAME % methname))
g = open(inputname, 'w')
g.write('\x09.string "%s"\n' % BEGIN_TAG)
+ #
+ if instrname == 'MOVD' and self.WORD == 8:
+ instrname = 'MOVQ'
+ if argmodes == 'xb':
+ py.test.skip('"as" uses an undocumented alternate encoding??')
+ #
for args in args_lists:
suffix = ""
## all = instr.as_all_suffixes
@@ -229,9 +235,6 @@
# movq $xxx, %rax => movl $xxx, %eax
suffix = 'l'
ops[1] = reduce_to_32bit(ops[1])
- if instrname.lower() == 'movd':
- ops[0] = reduce_to_32bit(ops[0])
- ops[1] = reduce_to_32bit(ops[1])
#
op = '\t%s%s %s%s' % (instrname.lower(), suffix,
', '.join(ops), following)
diff --git a/pypy/jit/codewriter/test/test_flatten.py b/pypy/jit/codewriter/test/test_flatten.py
--- a/pypy/jit/codewriter/test/test_flatten.py
+++ b/pypy/jit/codewriter/test/test_flatten.py
@@ -972,10 +972,16 @@
from pypy.rlib.longlong2float import float2longlong
def f(x):
return float2longlong(x)
+ if longlong.is_64_bit:
+ result_var = "%i0"
+ return_op = "int_return"
+ else:
+ result_var = "%f1"
+ return_op = "float_return"
self.encoding_test(f, [25.0], """
- convert_float_bytes_to_longlong %f0 -> %i0
- int_return %i0
- """)
+ convert_float_bytes_to_longlong %%f0 -> %(result_var)s
+ %(return_op)s %(result_var)s
+ """ % {"result_var": result_var, "return_op": return_op})
def check_force_cast(FROM, TO, operations, value):
diff --git a/pypy/module/__builtin__/interp_memoryview.py b/pypy/module/__builtin__/interp_memoryview.py
--- a/pypy/module/__builtin__/interp_memoryview.py
+++ b/pypy/module/__builtin__/interp_memoryview.py
@@ -69,6 +69,10 @@
return W_MemoryView(buf)
def descr_buffer(self, space):
+ """Note that memoryview() objects in PyPy support buffer(), whereas
+ not in CPython; but CPython supports passing memoryview() to most
+ built-in functions that accept buffers, with the notable exception
+ of the buffer() built-in."""
return space.wrap(self.buf)
def descr_tobytes(self, space):
diff --git a/pypy/module/_ast/test/test_ast.py b/pypy/module/_ast/test/test_ast.py
--- a/pypy/module/_ast/test/test_ast.py
+++ b/pypy/module/_ast/test/test_ast.py
@@ -1,9 +1,10 @@
import py
-
+from pypy.conftest import gettestobjspace
class AppTestAST:
def setup_class(cls):
+ cls.space = gettestobjspace(usemodules=['struct'])
cls.w_ast = cls.space.appexec([], """():
import _ast
return _ast""")
diff --git a/pypy/module/_codecs/test/test_codecs.py b/pypy/module/_codecs/test/test_codecs.py
--- a/pypy/module/_codecs/test/test_codecs.py
+++ b/pypy/module/_codecs/test/test_codecs.py
@@ -4,7 +4,7 @@
class AppTestCodecs:
def setup_class(cls):
- space = gettestobjspace(usemodules=('unicodedata',))
+ space = gettestobjspace(usemodules=('unicodedata', 'struct'))
cls.space = space
def test_register_noncallable(self):
diff --git a/pypy/module/_continuation/test/test_zpickle.py b/pypy/module/_continuation/test/test_zpickle.py
--- a/pypy/module/_continuation/test/test_zpickle.py
+++ b/pypy/module/_continuation/test/test_zpickle.py
@@ -106,8 +106,9 @@
version = 0
def setup_class(cls):
- cls.space = gettestobjspace(usemodules=('_continuation',),
+ cls.space = gettestobjspace(usemodules=('_continuation', 'struct'),
CALL_METHOD=True)
+ cls.space.config.translation.continuation = True
cls.space.appexec([], """():
global continulet, A, __name__
diff --git a/pypy/module/_hashlib/test/test_hashlib.py b/pypy/module/_hashlib/test/test_hashlib.py
--- a/pypy/module/_hashlib/test/test_hashlib.py
+++ b/pypy/module/_hashlib/test/test_hashlib.py
@@ -3,7 +3,7 @@
class AppTestHashlib:
def setup_class(cls):
- cls.space = gettestobjspace(usemodules=['_hashlib'])
+ cls.space = gettestobjspace(usemodules=['_hashlib', 'array', 'struct'])
def test_simple(self):
import _hashlib
diff --git a/pypy/module/_io/test/test_io.py b/pypy/module/_io/test/test_io.py
--- a/pypy/module/_io/test/test_io.py
+++ b/pypy/module/_io/test/test_io.py
@@ -158,7 +158,7 @@
class AppTestOpen:
def setup_class(cls):
- cls.space = gettestobjspace(usemodules=['_io', '_locale'])
+ cls.space = gettestobjspace(usemodules=['_io', '_locale', 'array', 'struct'])
tmpfile = udir.join('tmpfile').ensure()
cls.w_tmpfile = cls.space.wrap(str(tmpfile))
diff --git a/pypy/module/_multiprocessing/test/test_connection.py b/pypy/module/_multiprocessing/test/test_connection.py
--- a/pypy/module/_multiprocessing/test/test_connection.py
+++ b/pypy/module/_multiprocessing/test/test_connection.py
@@ -92,7 +92,8 @@
class AppTestSocketConnection(BaseConnectionTest):
def setup_class(cls):
- space = gettestobjspace(usemodules=('_multiprocessing', 'thread', 'signal'))
+ space = gettestobjspace(usemodules=('_multiprocessing', 'thread', 'signal',
+ 'struct', 'array'))
cls.space = space
cls.w_connections = space.newlist([])
diff --git a/pypy/module/_socket/test/test_sock_app.py b/pypy/module/_socket/test/test_sock_app.py
--- a/pypy/module/_socket/test/test_sock_app.py
+++ b/pypy/module/_socket/test/test_sock_app.py
@@ -6,7 +6,7 @@
from pypy.rpython.lltypesystem import lltype, rffi
def setup_module(mod):
- mod.space = gettestobjspace(usemodules=['_socket', 'array'])
+ mod.space = gettestobjspace(usemodules=['_socket', 'array', 'struct'])
global socket
import socket
mod.w_socket = space.appexec([], "(): import _socket as m; return m")
@@ -372,10 +372,9 @@
def test_socket_connect(self):
import _socket, os
s = _socket.socket(_socket.AF_INET, _socket.SOCK_STREAM, 0)
- # XXX temporarily we use python.org to test, will have more robust tests
- # in the absence of a network connection later when more parts of the
- # socket API are implemented. Currently skip the test if there is no
- # connection.
+ # it would be nice to have a test which works even if there is no
+ # network connection. However, this one is "good enough" for now. Skip
+ # it if there is no connection.
try:
s.connect(("www.python.org", 80))
except _socket.gaierror, ex:
diff --git a/pypy/module/_ssl/test/test_ssl.py b/pypy/module/_ssl/test/test_ssl.py
--- a/pypy/module/_ssl/test/test_ssl.py
+++ b/pypy/module/_ssl/test/test_ssl.py
@@ -90,7 +90,7 @@
class AppTestConnectedSSL:
def setup_class(cls):
- space = gettestobjspace(usemodules=('_ssl', '_socket'))
+ space = gettestobjspace(usemodules=('_ssl', '_socket', 'struct'))
cls.space = space
def setup_method(self, method):
@@ -179,7 +179,7 @@
# to exercise the poll() calls
def setup_class(cls):
- space = gettestobjspace(usemodules=('_ssl', '_socket'))
+ space = gettestobjspace(usemodules=('_ssl', '_socket', 'struct'))
cls.space = space
cls.space.appexec([], """():
import socket; socket.setdefaulttimeout(1)
diff --git a/pypy/module/cpyext/test/conftest.py b/pypy/module/cpyext/test/conftest.py
--- a/pypy/module/cpyext/test/conftest.py
+++ b/pypy/module/cpyext/test/conftest.py
@@ -10,7 +10,7 @@
return False
def pytest_funcarg__space(request):
- return gettestobjspace(usemodules=['cpyext', 'thread', '_rawffi'])
+ return gettestobjspace(usemodules=['cpyext', 'thread', '_rawffi', 'array'])
def pytest_funcarg__api(request):
return request.cls.api
diff --git a/pypy/module/cpyext/test/test_api.py b/pypy/module/cpyext/test/test_api.py
--- a/pypy/module/cpyext/test/test_api.py
+++ b/pypy/module/cpyext/test/test_api.py
@@ -19,7 +19,8 @@
class BaseApiTest(LeakCheckingTest):
def setup_class(cls):
- cls.space = space = gettestobjspace(usemodules=['cpyext', 'thread', '_rawffi'])
+ cls.space = space = gettestobjspace(usemodules=['cpyext', 'thread', '_rawffi',
+ 'array'])
# warm up reference counts:
# - the posix module allocates a HCRYPTPROV on Windows
diff --git a/pypy/module/cpyext/test/test_arraymodule.py b/pypy/module/cpyext/test/test_arraymodule.py
--- a/pypy/module/cpyext/test/test_arraymodule.py
+++ b/pypy/module/cpyext/test/test_arraymodule.py
@@ -1,3 +1,4 @@
+from pypy.conftest import gettestobjspace
from pypy.module.cpyext.test.test_cpyext import AppTestCpythonExtensionBase
import py
diff --git a/pypy/module/cpyext/test/test_cpyext.py b/pypy/module/cpyext/test/test_cpyext.py
--- a/pypy/module/cpyext/test/test_cpyext.py
+++ b/pypy/module/cpyext/test/test_cpyext.py
@@ -35,7 +35,7 @@
class AppTestApi:
def setup_class(cls):
- cls.space = gettestobjspace(usemodules=['cpyext', 'thread', '_rawffi'])
+ cls.space = gettestobjspace(usemodules=['cpyext', 'thread', '_rawffi', 'array'])
from pypy.rlib.libffi import get_libc_name
cls.w_libc = cls.space.wrap(get_libc_name())
@@ -165,8 +165,9 @@
return leaking
class AppTestCpythonExtensionBase(LeakCheckingTest):
+
def setup_class(cls):
- cls.space = gettestobjspace(usemodules=['cpyext', 'thread', '_rawffi'])
+ cls.space = gettestobjspace(usemodules=['cpyext', 'thread', '_rawffi', 'array'])
cls.space.getbuiltinmodule("cpyext")
from pypy.module.imp.importing import importhook
importhook(cls.space, "os") # warm up reference counts
diff --git a/pypy/module/cpyext/test/test_import.py b/pypy/module/cpyext/test/test_import.py
--- a/pypy/module/cpyext/test/test_import.py
+++ b/pypy/module/cpyext/test/test_import.py
@@ -19,7 +19,7 @@
space.wrap('__name__'))) == 'foobar'
def test_getmoduledict(self, space, api):
- testmod = "binascii"
+ testmod = "_functools"
w_pre_dict = api.PyImport_GetModuleDict()
assert not space.is_true(space.contains(w_pre_dict, space.wrap(testmod)))
diff --git a/pypy/module/fcntl/test/test_fcntl.py b/pypy/module/fcntl/test/test_fcntl.py
--- a/pypy/module/fcntl/test/test_fcntl.py
+++ b/pypy/module/fcntl/test/test_fcntl.py
@@ -13,7 +13,7 @@
class AppTestFcntl:
def setup_class(cls):
- space = gettestobjspace(usemodules=('fcntl', 'array'))
+ space = gettestobjspace(usemodules=('fcntl', 'array', 'struct'))
cls.space = space
tmpprefix = str(udir.ensure('test_fcntl', dir=1).join('tmp_'))
cls.w_tmp = space.wrap(tmpprefix)
diff --git a/pypy/module/imp/test/test_import.py b/pypy/module/imp/test/test_import.py
--- a/pypy/module/imp/test/test_import.py
+++ b/pypy/module/imp/test/test_import.py
@@ -987,6 +987,10 @@
os.environ['LANG'] = oldlang
class AppTestImportHooks(object):
+
+ def setup_class(cls):
+ cls.space = gettestobjspace(usemodules=('struct',))
+
def test_meta_path(self):
tried_imports = []
class Importer(object):
diff --git a/pypy/module/itertools/test/test_itertools.py b/pypy/module/itertools/test/test_itertools.py
--- a/pypy/module/itertools/test/test_itertools.py
+++ b/pypy/module/itertools/test/test_itertools.py
@@ -891,7 +891,7 @@
class AppTestItertools27:
def setup_class(cls):
- cls.space = gettestobjspace(usemodules=['itertools'])
+ cls.space = gettestobjspace(usemodules=['itertools', 'struct'])
if cls.space.is_true(cls.space.appexec([], """():
import sys; return sys.version_info < (2, 7)
""")):
diff --git a/pypy/module/marshal/test/make_test_marshal.py b/pypy/module/marshal/test/make_test_marshal.py
deleted file mode 100644
--- a/pypy/module/marshal/test/make_test_marshal.py
+++ /dev/null
@@ -1,78 +0,0 @@
-
-TESTCASES = """\
- None
- False
- True
- StopIteration
- Ellipsis
- 42
- -17
- sys.maxint
- -1.25
- -1.25 #2
- 2+5j
- 2+5j #2
- 42L
- -1234567890123456789012345678901234567890L
- hello # not interned
- "hello"
- ()
- (1, 2)
- []
- [3, 4]
- {}
- {5: 6, 7: 8}
- func.func_code
- scopefunc.func_code
- u'hello'
- set()
- set([1, 2])
- frozenset()
- frozenset([3, 4])
-""".strip().split('\n')
-
-def readable(s):
- for c, repl in (
- ("'", '_quote_'), ('"', '_Quote_'), (':', '_colon_'), ('.', '_dot_'),
- ('[', '_list_'), (']', '_tsil_'), ('{', '_dict_'), ('}', '_tcid_'),
- ('-', '_minus_'), ('+', '_plus_'),
- (',', '_comma_'), ('(', '_brace_'), (')', '_ecarb_') ):
- s = s.replace(c, repl)
- lis = list(s)
- for i, c in enumerate(lis):
- if c.isalnum() or c == '_':
- continue
- lis[i] = '_'
- return ''.join(lis)
-
-print """class AppTestMarshal:
-"""
-for line in TESTCASES:
- line = line.strip()
- name = readable(line)
- version = ''
- extra = ''
- if line.endswith('#2'):
- version = ', 2'
- extra = '; assert len(s) in (9, 17)'
- src = '''\
- def test_%(name)s(self):
- import sys
- hello = "he"
- hello += "llo"
- def func(x):
- return lambda y: x+y
- scopefunc = func(42)
- import marshal, StringIO
- case = %(line)s
- print "case: %%-30s func=%(name)s" %% (case, )
- s = marshal.dumps(case%(version)s)%(extra)s
- x = marshal.loads(s)
- assert x == case
- f = StringIO.StringIO()
- marshal.dump(case, f)
- f.seek(0)
- x = marshal.load(f)
- assert x == case
-''' % {'name': name, 'line': line, 'version' : version, 'extra': extra}
- print src
diff --git a/pypy/module/math/test/test_math.py b/pypy/module/math/test/test_math.py
--- a/pypy/module/math/test/test_math.py
+++ b/pypy/module/math/test/test_math.py
@@ -6,7 +6,7 @@
class AppTestMath:
def setup_class(cls):
- cls.space = gettestobjspace(usemodules=['math'])
+ cls.space = gettestobjspace(usemodules=['math', 'struct'])
cls.w_cases = cls.space.wrap(test_direct.MathTests.TESTCASES)
cls.w_consistent_host = cls.space.wrap(test_direct.consistent_host)
diff --git a/pypy/module/micronumpy/interp_dtype.py b/pypy/module/micronumpy/interp_dtype.py
--- a/pypy/module/micronumpy/interp_dtype.py
+++ b/pypy/module/micronumpy/interp_dtype.py
@@ -359,6 +359,7 @@
name="int64",
char="q",
w_box_type=space.gettypefor(interp_boxes.W_Int64Box),
+ alternate_constructors=[space.w_long],
)
self.w_uint64dtype = W_Dtype(
types.UInt64(),
@@ -386,23 +387,6 @@
alternate_constructors=[space.w_float],
aliases=["float"],
)
- self.w_longlongdtype = W_Dtype(
- types.Int64(),
- num=9,
- kind=SIGNEDLTR,
- name='int64',
- char='q',
- w_box_type = space.gettypefor(interp_boxes.W_LongLongBox),
- alternate_constructors=[space.w_long],
- )
- self.w_ulonglongdtype = W_Dtype(
- types.UInt64(),
- num=10,
- kind=UNSIGNEDLTR,
- name='uint64',
- char='Q',
- w_box_type = space.gettypefor(interp_boxes.W_ULongLongBox),
- )
self.w_stringdtype = W_Dtype(
types.StringType(1),
num=18,
@@ -435,17 +419,19 @@
self.w_booldtype, self.w_int8dtype, self.w_uint8dtype,
self.w_int16dtype, self.w_uint16dtype, self.w_int32dtype,
self.w_uint32dtype, self.w_longdtype, self.w_ulongdtype,
- self.w_longlongdtype, self.w_ulonglongdtype,
+ self.w_int64dtype, self.w_uint64dtype,
self.w_float32dtype,
self.w_float64dtype, self.w_stringdtype, self.w_unicodedtype,
self.w_voiddtype,
]
- self.dtypes_by_num_bytes = sorted(
+ self.float_dtypes_by_num_bytes = sorted(
(dtype.itemtype.get_element_size(), dtype)
- for dtype in self.builtin_dtypes
+ for dtype in [self.w_float32dtype, self.w_float64dtype]
)
self.dtypes_by_name = {}
- for dtype in self.builtin_dtypes:
+ # we reverse, so the stuff with lower numbers override stuff with
+ # higher numbers
+ for dtype in reversed(self.builtin_dtypes):
self.dtypes_by_name[dtype.name] = dtype
can_name = dtype.kind + str(dtype.itemtype.get_element_size())
self.dtypes_by_name[can_name] = dtype
@@ -473,7 +459,7 @@
'LONG': self.w_longdtype,
'UNICODE': self.w_unicodedtype,
#'OBJECT',
- 'ULONGLONG': self.w_ulonglongdtype,
+ 'ULONGLONG': self.w_uint64dtype,
'STRING': self.w_stringdtype,
#'CDOUBLE',
#'DATETIME',
diff --git a/pypy/module/micronumpy/interp_numarray.py b/pypy/module/micronumpy/interp_numarray.py
--- a/pypy/module/micronumpy/interp_numarray.py
+++ b/pypy/module/micronumpy/interp_numarray.py
@@ -1125,7 +1125,8 @@
@unwrap_spec(subok=bool, copy=bool, ownmaskna=bool)
def array(space, w_item_or_iterable, w_dtype=None, w_order=None,
- subok=True, copy=True, w_maskna=None, ownmaskna=False):
+ subok=True, copy=True, w_maskna=None, ownmaskna=False,
+ w_ndmin=None):
# find scalar
if w_maskna is None:
w_maskna = space.w_None
@@ -1170,8 +1171,13 @@
break
if dtype is None:
dtype = interp_dtype.get_dtype_cache(space).w_float64dtype
+ shapelen = len(shape)
+ if w_ndmin is not None and not space.is_w(w_ndmin, space.w_None):
+ ndmin = space.int_w(w_ndmin)
+ if ndmin > shapelen:
+ shape = [1] * (ndmin - shapelen) + shape
+ shapelen = ndmin
arr = W_NDimArray(shape[:], dtype=dtype, order=order)
- shapelen = len(shape)
arr_iter = arr.create_iter()
# XXX we might want to have a jitdriver here
for i in range(len(elems_w)):
diff --git a/pypy/module/micronumpy/interp_ufuncs.py b/pypy/module/micronumpy/interp_ufuncs.py
--- a/pypy/module/micronumpy/interp_ufuncs.py
+++ b/pypy/module/micronumpy/interp_ufuncs.py
@@ -314,7 +314,7 @@
return dt
if dt.num >= 5:
return interp_dtype.get_dtype_cache(space).w_float64dtype
- for bytes, dtype in interp_dtype.get_dtype_cache(space).dtypes_by_num_bytes:
+ for bytes, dtype in interp_dtype.get_dtype_cache(space).float_dtypes_by_num_bytes:
if (dtype.kind == interp_dtype.FLOATINGLTR and
dtype.itemtype.get_element_size() > dt.itemtype.get_element_size()):
return dtype
diff --git a/pypy/module/micronumpy/test/test_dtypes.py b/pypy/module/micronumpy/test/test_dtypes.py
--- a/pypy/module/micronumpy/test/test_dtypes.py
+++ b/pypy/module/micronumpy/test/test_dtypes.py
@@ -302,6 +302,7 @@
else:
raises(OverflowError, numpy.int32, 2147483648)
raises(OverflowError, numpy.int32, '2147483648')
+ assert numpy.dtype('int32') is numpy.dtype(numpy.int32)
def test_uint32(self):
import sys
@@ -333,15 +334,11 @@
assert numpy.dtype(numpy.int64).type is numpy.int64
assert numpy.int64(3) == 3
- if sys.maxint >= 2 ** 63 - 1:
- assert numpy.int64(9223372036854775807) == 9223372036854775807
- assert numpy.int64('9223372036854775807') == 9223372036854775807
- else:
- raises(OverflowError, numpy.int64, 9223372036854775807)
- raises(OverflowError, numpy.int64, '9223372036854775807')
+ assert numpy.int64(9223372036854775807) == 9223372036854775807
+ assert numpy.int64(9223372036854775807) == 9223372036854775807
raises(OverflowError, numpy.int64, 9223372036854775808)
- raises(OverflowError, numpy.int64, '9223372036854775808')
+ raises(OverflowError, numpy.int64, 9223372036854775808L)
def test_uint64(self):
import sys
diff --git a/pypy/module/micronumpy/test/test_numarray.py b/pypy/module/micronumpy/test/test_numarray.py
--- a/pypy/module/micronumpy/test/test_numarray.py
+++ b/pypy/module/micronumpy/test/test_numarray.py
@@ -211,6 +211,18 @@
assert a.shape == (3,)
assert a.dtype is dtype(int)
+ def test_ndmin(self):
+ from _numpypy import array
+
+ arr = array([[[1]]], ndmin=1)
+ assert arr.shape == (1, 1, 1)
+
+ def test_noop_ndmin(self):
+ from _numpypy import array
+
+ arr = array([1], ndmin=3)
+ assert arr.shape == (1, 1, 1)
+
def test_type(self):
from _numpypy import array
ar = array(range(5))
diff --git a/pypy/module/micronumpy/test/test_ufuncs.py b/pypy/module/micronumpy/test/test_ufuncs.py
--- a/pypy/module/micronumpy/test/test_ufuncs.py
+++ b/pypy/module/micronumpy/test/test_ufuncs.py
@@ -197,7 +197,6 @@
def test_signbit(self):
from _numpypy import signbit, copysign
- import struct
assert (signbit([0, 0.0, 1, 1.0, float('inf'), float('nan')]) ==
[False, False, False, False, False, False]).all()
diff --git a/pypy/module/micronumpy/types.py b/pypy/module/micronumpy/types.py
--- a/pypy/module/micronumpy/types.py
+++ b/pypy/module/micronumpy/types.py
@@ -500,6 +500,19 @@
BoxType = interp_boxes.W_ULongBox
format_code = "L"
+def _int64_coerce(self, space, w_item):
+ try:
+ return self._base_coerce(space, w_item)
+ except OperationError, e:
+ if not e.match(space, space.w_OverflowError):
+ raise
+ bigint = space.bigint_w(w_item)
+ try:
+ value = bigint.tolonglong()
+ except OverflowError:
+ raise OperationError(space.w_OverflowError, space.w_None)
+ return self.box(value)
+
class Int64(BaseType, Integer):
_attrs_ = ()
@@ -507,6 +520,8 @@
BoxType = interp_boxes.W_Int64Box
format_code = "q"
+ _coerce = func_with_new_name(_int64_coerce, '_coerce')
+
class NonNativeInt64(BaseType, NonNativeInteger):
_attrs_ = ()
@@ -514,6 +529,8 @@
BoxType = interp_boxes.W_Int64Box
format_code = "q"
+ _coerce = func_with_new_name(_int64_coerce, '_coerce')
+
def _uint64_coerce(self, space, w_item):
try:
return self._base_coerce(space, w_item)
diff --git a/pypy/module/posix/test/test_posix2.py b/pypy/module/posix/test/test_posix2.py
--- a/pypy/module/posix/test/test_posix2.py
+++ b/pypy/module/posix/test/test_posix2.py
@@ -14,10 +14,10 @@
def setup_module(mod):
if os.name != 'nt':
- mod.space = gettestobjspace(usemodules=['posix', 'fcntl'])
+ mod.space = gettestobjspace(usemodules=['posix', 'fcntl', 'struct'])
else:
# On windows, os.popen uses the subprocess module
- mod.space = gettestobjspace(usemodules=['posix', '_rawffi', 'thread'])
+ mod.space = gettestobjspace(usemodules=['posix', '_rawffi', 'thread', 'struct'])
mod.path = udir.join('posixtestfile.txt')
mod.path.write("this is a test")
mod.path2 = udir.join('test_posix2-')
diff --git a/pypy/module/rctime/test/test_rctime.py b/pypy/module/rctime/test/test_rctime.py
--- a/pypy/module/rctime/test/test_rctime.py
+++ b/pypy/module/rctime/test/test_rctime.py
@@ -3,7 +3,7 @@
class AppTestRCTime:
def setup_class(cls):
- space = gettestobjspace(usemodules=('rctime',))
+ space = gettestobjspace(usemodules=('rctime', 'struct'))
cls.space = space
def test_attributes(self):
diff --git a/pypy/module/test_lib_pypy/numpypy/core/test_numeric.py b/pypy/module/test_lib_pypy/numpypy/core/test_numeric.py
--- a/pypy/module/test_lib_pypy/numpypy/core/test_numeric.py
+++ b/pypy/module/test_lib_pypy/numpypy/core/test_numeric.py
@@ -142,3 +142,39 @@
assert str(b) == "[7 8 9]"
b = a[2:1, ]
assert str(b) == "[]"
+
+ def test_equal(self):
+ from _numpypy import array
+ from numpypy import array_equal
+
+ a = [1, 2, 3]
+ b = [1, 2, 3]
+
+ assert array_equal(a, b)
+ assert array_equal(a, array(b))
+ assert array_equal(array(a), b)
+ assert array_equal(array(a), array(b))
+
+ def test_not_equal(self):
+ from _numpypy import array
+ from numpypy import array_equal
+
+ a = [1, 2, 3]
+ b = [1, 2, 4]
+
+ assert not array_equal(a, b)
+ assert not array_equal(a, array(b))
+ assert not array_equal(array(a), b)
+ assert not array_equal(array(a), array(b))
+
+ def test_mismatched_shape(self):
+ from _numpypy import array
+ from numpypy import array_equal
+
+ a = [1, 2, 3]
+ b = [[1, 2, 3], [1, 2, 3]]
+
+ assert not array_equal(a, b)
+ assert not array_equal(a, array(b))
+ assert not array_equal(array(a), b)
+ assert not array_equal(array(a), array(b))
diff --git a/pypy/module/test_lib_pypy/test_binascii.py b/pypy/module/test_lib_pypy/test_binascii.py
deleted file mode 100644
--- a/pypy/module/test_lib_pypy/test_binascii.py
+++ /dev/null
@@ -1,8 +0,0 @@
-
-""" Some more binascii.py tests
-"""
-
-class AppTestBinAscii:
- def test_incorrect_padding(self):
- import binascii
- raises(binascii.Error, "'x'.decode('base64')")
diff --git a/pypy/module/zipimport/test/test_undocumented.py b/pypy/module/zipimport/test/test_undocumented.py
--- a/pypy/module/zipimport/test/test_undocumented.py
+++ b/pypy/module/zipimport/test/test_undocumented.py
@@ -19,7 +19,7 @@
class AppTestZipImport:
def setup_class(cls):
- space = gettestobjspace(usemodules=['zipimport', 'rctime'])
+ space = gettestobjspace(usemodules=['zipimport', 'rctime', 'struct'])
cls.space = space
cls.w_created_paths = space.wrap(created_paths)
diff --git a/pypy/module/zipimport/test/test_zipimport.py b/pypy/module/zipimport/test/test_zipimport.py
--- a/pypy/module/zipimport/test/test_zipimport.py
+++ b/pypy/module/zipimport/test/test_zipimport.py
@@ -47,9 +47,9 @@
""").compile()
if cls.compression == ZIP_DEFLATED:
- space = gettestobjspace(usemodules=['zipimport', 'zlib', 'rctime'])
+ space = gettestobjspace(usemodules=['zipimport', 'zlib', 'rctime', 'struct'])
else:
- space = gettestobjspace(usemodules=['zipimport', 'rctime'])
+ space = gettestobjspace(usemodules=['zipimport', 'rctime', 'struct'])
cls.space = space
tmpdir = udir.ensure('zipimport_%s' % cls.__name__, dir=1)
diff --git a/pypy/objspace/flow/model.py b/pypy/objspace/flow/model.py
--- a/pypy/objspace/flow/model.py
+++ b/pypy/objspace/flow/model.py
@@ -7,8 +7,7 @@
from pypy.tool.uid import uid, Hashable
from pypy.tool.descriptor import roproperty
from pypy.tool.sourcetools import PY_IDENTIFIER, nice_repr_for_func
-from pypy.tool.identity_dict import identity_dict
-from pypy.rlib.rarithmetic import is_valid_int, r_longlong, r_ulonglong
+from pypy.rlib.rarithmetic import is_valid_int, r_longlong, r_ulonglong, r_uint
"""
@@ -546,7 +545,7 @@
for n in cases[:len(cases)-has_default]:
if is_valid_int(n):
continue
- if isinstance(n, (r_longlong, r_ulonglong)):
+ if isinstance(n, (r_longlong, r_ulonglong, r_uint)):
continue
if isinstance(n, (str, unicode)) and len(n) == 1:
continue
diff --git a/pypy/objspace/std/ropeobject.py b/pypy/objspace/std/ropeobject.py
--- a/pypy/objspace/std/ropeobject.py
+++ b/pypy/objspace/std/ropeobject.py
@@ -41,11 +41,6 @@
return w_self
return W_RopeObject(w_self._node)
- def unicode_w(w_self, space):
- # XXX should this use the default encoding?
- from pypy.objspace.std.unicodetype import plain_str2unicode
- return plain_str2unicode(space, w_self._node.flatten_string())
-
W_RopeObject.EMPTY = W_RopeObject(rope.LiteralStringNode.EMPTY)
W_RopeObject.PREBUILT = [W_RopeObject(rope.LiteralStringNode.PREBUILT[i])
for i in range(256)]
diff --git a/pypy/objspace/std/stringobject.py b/pypy/objspace/std/stringobject.py
--- a/pypy/objspace/std/stringobject.py
+++ b/pypy/objspace/std/stringobject.py
@@ -37,6 +37,20 @@
return None
return space.wrap(compute_unique_id(space.str_w(self)))
+ def unicode_w(w_self, space):
+ # Use the default encoding.
+ from pypy.objspace.std.unicodetype import unicode_from_string, \
+ decode_object
+ w_defaultencoding = space.call_function(space.sys.get(
+ 'getdefaultencoding'))
+ from pypy.objspace.std.unicodetype import _get_encoding_and_errors, \
+ unicode_from_string, decode_object
+ encoding, errors = _get_encoding_and_errors(space, w_defaultencoding,
+ space.w_None)
+ if encoding is None and errors is None:
+ return space.unicode_w(unicode_from_string(space, w_self))
+ return space.unicode_w(decode_object(space, w_self, encoding, errors))
+
class W_StringObject(W_AbstractStringObject):
from pypy.objspace.std.stringtype import str_typedef as typedef
@@ -55,20 +69,6 @@
def str_w(w_self, space):
return w_self._value
- def unicode_w(w_self, space):
- # Use the default encoding.
- from pypy.objspace.std.unicodetype import unicode_from_string, \
- decode_object
- w_defaultencoding = space.call_function(space.sys.get(
- 'getdefaultencoding'))
- from pypy.objspace.std.unicodetype import _get_encoding_and_errors, \
- unicode_from_string, decode_object
- encoding, errors = _get_encoding_and_errors(space, w_defaultencoding,
- space.w_None)
- if encoding is None and errors is None:
- return space.unicode_w(unicode_from_string(space, w_self))
- return space.unicode_w(decode_object(space, w_self, encoding, errors))
-
registerimplementation(W_StringObject)
W_StringObject.EMPTY = W_StringObject('')
diff --git a/pypy/objspace/std/test/test_obj.py b/pypy/objspace/std/test/test_obj.py
--- a/pypy/objspace/std/test/test_obj.py
+++ b/pypy/objspace/std/test/test_obj.py
@@ -265,4 +265,7 @@
space = objspace.StdObjSpace()
w_a = space.wrap("a")
space.type = None
+ # if it crashes, it means that space._type_isinstance didn't go through
+ # the fast path, and tries to call type() (which is set to None just
+ # above)
space.isinstance_w(w_a, space.w_str) # does not crash
diff --git a/pypy/rlib/rzipfile.py b/pypy/rlib/rzipfile.py
--- a/pypy/rlib/rzipfile.py
+++ b/pypy/rlib/rzipfile.py
@@ -12,8 +12,7 @@
rzlib = None
# XXX hack to get crc32 to work
-from pypy.tool.lib_pypy import import_from_lib_pypy
-crc_32_tab = import_from_lib_pypy('binascii').crc_32_tab
+from pypy.module.binascii.interp_crc32 import crc_32_tab
rcrc_32_tab = [r_uint(i) for i in crc_32_tab]
diff --git a/pypy/rpython/llinterp.py b/pypy/rpython/llinterp.py
--- a/pypy/rpython/llinterp.py
+++ b/pypy/rpython/llinterp.py
@@ -770,6 +770,10 @@
checkadr(adr)
return llmemory.cast_adr_to_int(adr, mode)
+ def op_convert_float_bytes_to_longlong(self, f):
+ from pypy.rlib import longlong2float
+ return longlong2float.float2longlong(f)
+
def op_weakref_create(self, v_obj):
def objgetter(): # special support for gcwrapper.py
return self.getval(v_obj)
diff --git a/pypy/rpython/lltypesystem/lloperation.py b/pypy/rpython/lltypesystem/lloperation.py
--- a/pypy/rpython/lltypesystem/lloperation.py
+++ b/pypy/rpython/lltypesystem/lloperation.py
@@ -349,6 +349,7 @@
'cast_float_to_ulonglong':LLOp(canfold=True),
'truncate_longlong_to_int':LLOp(canfold=True),
'force_cast': LLOp(sideeffects=False), # only for rffi.cast()
+ 'convert_float_bytes_to_longlong': LLOp(canfold=True),
# __________ pointer operations __________
diff --git a/pypy/tool/test/test_lib_pypy.py b/pypy/tool/test/test_lib_pypy.py
--- a/pypy/tool/test/test_lib_pypy.py
+++ b/pypy/tool/test/test_lib_pypy.py
@@ -11,7 +11,7 @@
assert lib_pypy.LIB_PYTHON_MODIFIED.check(dir=1)
def test_import_from_lib_pypy():
- binascii = lib_pypy.import_from_lib_pypy('binascii')
- assert type(binascii) is type(lib_pypy)
- assert binascii.__name__ == 'lib_pypy.binascii'
- assert hasattr(binascii, 'crc_32_tab')
+ _functools = lib_pypy.import_from_lib_pypy('_functools')
+ assert type(_functools) is type(lib_pypy)
+ assert _functools.__name__ == 'lib_pypy._functools'
+ assert hasattr(_functools, 'partial')
diff --git a/pypy/translator/c/gcc/trackgcroot.py b/pypy/translator/c/gcc/trackgcroot.py
--- a/pypy/translator/c/gcc/trackgcroot.py
+++ b/pypy/translator/c/gcc/trackgcroot.py
@@ -484,7 +484,7 @@
'shl', 'shr', 'sal', 'sar', 'rol', 'ror', 'mul', 'imul', 'div', 'idiv',
'bswap', 'bt', 'rdtsc',
'punpck', 'pshufd', 'pcmp', 'pand', 'psllw', 'pslld', 'psllq',
- 'paddq', 'pinsr', 'pmul', 'psrl',
+ 'paddq', 'pinsr', 'pmul', 'psrl', 'vmul',
# sign-extending moves should not produce GC pointers
'cbtw', 'cwtl', 'cwtd', 'cltd', 'cltq', 'cqto',
# zero-extending moves should not produce GC pointers
diff --git a/pypy/translator/driver.py b/pypy/translator/driver.py
--- a/pypy/translator/driver.py
+++ b/pypy/translator/driver.py
@@ -585,22 +585,6 @@
#
task_compile_c = taskdef(task_compile_c, ['source_c'], "Compiling c source")
- def backend_run(self, backend):
- c_entryp = self.c_entryp
- standalone = self.standalone
- if standalone:
- os.system(c_entryp)
- else:
- runner = self.extra.get('run', lambda f: f())
- runner(c_entryp)
-
- def task_run_c(self):
- self.backend_run('c')
- #
- task_run_c = taskdef(task_run_c, ['compile_c'],
- "Running compiled c source",
- idemp=True)
-
def task_llinterpret_lltype(self):
from pypy.rpython.llinterp import LLInterpreter
py.log.setconsumer("llinterp operation", None)
@@ -710,11 +694,6 @@
shutil.copy(main_exe, '.')
self.log.info("Copied to %s" % os.path.join(os.getcwd(), dllname))
- def task_run_cli(self):
- pass
- task_run_cli = taskdef(task_run_cli, ['compile_cli'],
- 'XXX')
-
def task_source_jvm(self):
from pypy.translator.jvm.genjvm import GenJvm
from pypy.translator.jvm.node import EntryPoint
diff --git a/pypy/translator/goal/translate.py b/pypy/translator/goal/translate.py
--- a/pypy/translator/goal/translate.py
+++ b/pypy/translator/goal/translate.py
@@ -31,7 +31,6 @@
("backendopt", "do backend optimizations", "--backendopt", ""),
("source", "create source", "-s --source", ""),
("compile", "compile", "-c --compile", " (default goal)"),
- ("run", "run the resulting binary", "--run", ""),
("llinterpret", "interpret the rtyped flow graphs", "--llinterpret", ""),
]
def goal_options():
@@ -78,7 +77,7 @@
defaultfactory=list),
# xxx default goals ['annotate', 'rtype', 'backendopt', 'source', 'compile']
ArbitraryOption("skipped_goals", "XXX",
- defaultfactory=lambda: ['run']),
+ defaultfactory=list),
OptionDescription("goal_options",
"Goals that should be reached during translation",
goal_options()),
diff --git a/pypy/translator/jvm/opcodes.py b/pypy/translator/jvm/opcodes.py
--- a/pypy/translator/jvm/opcodes.py
+++ b/pypy/translator/jvm/opcodes.py
@@ -241,4 +241,6 @@
'cast_ulonglong_to_float': jvm.PYPYULONGTODOUBLE,
'cast_primitive': [PushAllArgs, CastPrimitive, StoreResult],
'force_cast': [PushAllArgs, CastPrimitive, StoreResult],
+
+ 'convert_float_bytes_to_longlong': jvm.PYPYDOUBLEBYTESTOLONG,
})
diff --git a/pypy/translator/jvm/typesystem.py b/pypy/translator/jvm/typesystem.py
--- a/pypy/translator/jvm/typesystem.py
+++ b/pypy/translator/jvm/typesystem.py
@@ -941,6 +941,7 @@
PYPYDOUBLETOULONG = Method.s(jPyPy, 'double_to_ulong', (jDouble,), jLong)
PYPYULONGTODOUBLE = Method.s(jPyPy, 'ulong_to_double', (jLong,), jDouble)
PYPYLONGBITWISENEGATE = Method.v(jPyPy, 'long_bitwise_negate', (jLong,), jLong)
+PYPYDOUBLEBYTESTOLONG = Method.v(jPyPy, 'pypy__float2longlong', (jDouble,), jLong)
PYPYSTRTOINT = Method.v(jPyPy, 'str_to_int', (jString,), jInt)
PYPYSTRTOUINT = Method.v(jPyPy, 'str_to_uint', (jString,), jInt)
PYPYSTRTOLONG = Method.v(jPyPy, 'str_to_long', (jString,), jLong)
diff --git a/pypy/translator/test/test_driver.py b/pypy/translator/test/test_driver.py
--- a/pypy/translator/test/test_driver.py
+++ b/pypy/translator/test/test_driver.py
@@ -6,7 +6,7 @@
def test_ctr():
td = TranslationDriver()
expected = ['annotate', 'backendopt', 'llinterpret', 'rtype', 'source',
- 'compile', 'run', 'pyjitpl']
+ 'compile', 'pyjitpl']
assert set(td.exposed) == set(expected)
assert td.backend_select_goals(['compile_c']) == ['compile_c']
@@ -33,7 +33,6 @@
'rtype_ootype', 'rtype_lltype',
'source_cli', 'source_c',
'compile_cli', 'compile_c',
- 'run_c', 'run_cli',
'compile_jvm', 'source_jvm', 'run_jvm',
'pyjitpl_lltype',
'pyjitpl_ootype']
@@ -50,6 +49,6 @@
'backendopt_lltype']
expected = ['annotate', 'backendopt', 'llinterpret', 'rtype', 'source_c',
- 'compile_c', 'run_c', 'pyjitpl']
+ 'compile_c', 'pyjitpl']
assert set(td.exposed) == set(expected)
More information about the pypy-commit
mailing list