[pypy-commit] pypy vecopt-merge: merged default
plan_rich
noreply at buildbot.pypy.org
Mon Oct 12 11:17:53 CEST 2015
Author: Richard Plangger <planrichi at gmail.com>
Branch: vecopt-merge
Changeset: r80121:ea700f0ebd08
Date: 2015-10-12 11:16 +0200
http://bitbucket.org/pypy/pypy/changeset/ea700f0ebd08/
Log: merged default
diff too long, truncating to 2000 out of 5166 lines
diff --git a/lib_pypy/cffi/api.py b/lib_pypy/cffi/api.py
--- a/lib_pypy/cffi/api.py
+++ b/lib_pypy/cffi/api.py
@@ -310,6 +310,22 @@
"""
return self._backend.from_buffer(self.BCharA, python_buffer)
+ def memmove(self, dest, src, n):
+ """ffi.memmove(dest, src, n) copies n bytes of memory from src to dest.
+
+ Like the C function memmove(), the memory areas may overlap;
+ apart from that it behaves like the C function memcpy().
+
+ 'src' can be any cdata ptr or array, or any Python buffer object.
+ 'dest' can be any cdata ptr or array, or a writable Python buffer
+ object. The size to copy, 'n', is always measured in bytes.
+
+ Unlike other methods, this one supports all Python buffer including
+ byte strings and bytearrays---but it still does not support
+ non-contiguous buffers.
+ """
+ return self._backend.memmove(dest, src, n)
+
def callback(self, cdecl, python_callable=None, error=None, onerror=None):
"""Return a callback object or a decorator making such a
callback object. 'cdecl' must name a C function pointer type.
diff --git a/pypy/doc/whatsnew-head.rst b/pypy/doc/whatsnew-head.rst
--- a/pypy/doc/whatsnew-head.rst
+++ b/pypy/doc/whatsnew-head.rst
@@ -57,6 +57,18 @@
.. branch: cffi-stdcall
Win32: support '__stdcall' in CFFI.
+.. branch: callfamily
+
+Refactorings of annotation and rtyping of function calls.
+
+.. branch: fortran-order
+
+Allow creation of fortran-ordered ndarrays
+
+.. branch: type_system-cleanup
+
+Remove some remnants of the old ootypesystem vs lltypesystem dichotomy.
+
.. branch: vecopt
.. branch: vecopt-merge
diff --git a/pypy/interpreter/baseobjspace.py b/pypy/interpreter/baseobjspace.py
--- a/pypy/interpreter/baseobjspace.py
+++ b/pypy/interpreter/baseobjspace.py
@@ -1058,6 +1058,14 @@
args = Arguments.frompacked(self, w_args, w_kwds)
return self.call_args(w_callable, args)
+ def _try_fetch_pycode(self, w_func):
+ from pypy.interpreter.function import Function, Method
+ if isinstance(w_func, Method):
+ w_func = w_func.w_function
+ if isinstance(w_func, Function):
+ return w_func.code
+ return None
+
def call_function(self, w_func, *args_w):
nargs = len(args_w) # used for pruning funccall versions
if not self.config.objspace.disable_call_speedhacks and nargs < 5:
diff --git a/pypy/module/_cffi_backend/__init__.py b/pypy/module/_cffi_backend/__init__.py
--- a/pypy/module/_cffi_backend/__init__.py
+++ b/pypy/module/_cffi_backend/__init__.py
@@ -47,6 +47,7 @@
'string': 'func.string',
'buffer': 'cbuffer.buffer',
+ 'memmove': 'func.memmove',
'get_errno': 'cerrno.get_errno',
'set_errno': 'cerrno.set_errno',
diff --git a/pypy/module/_cffi_backend/ccallback.py b/pypy/module/_cffi_backend/ccallback.py
--- a/pypy/module/_cffi_backend/ccallback.py
+++ b/pypy/module/_cffi_backend/ccallback.py
@@ -3,12 +3,12 @@
"""
import sys, os
-from rpython.rlib import clibffi, rweakref, jit, jit_libffi
-from rpython.rlib.objectmodel import compute_unique_id, keepalive_until_here
+from rpython.rlib import clibffi, jit, jit_libffi
+from rpython.rlib.objectmodel import keepalive_until_here
from rpython.rtyper.lltypesystem import lltype, rffi
from pypy.interpreter.error import OperationError, oefmt
-from pypy.module._cffi_backend import cerrno, misc
+from pypy.module._cffi_backend import cerrno, misc, handle
from pypy.module._cffi_backend.cdataobj import W_CData
from pypy.module._cffi_backend.ctypefunc import SIZE_OF_FFI_ARG, W_CTypeFunc
from pypy.module._cffi_backend.ctypeprim import W_CTypePrimitiveSigned
@@ -34,7 +34,7 @@
class W_CDataCallback(W_CData):
- #_immutable_fields_ = ...
+ _immutable_fields_ = ['key_pycode']
w_onerror = None
def __init__(self, space, ctype, w_callable, w_error, w_onerror):
@@ -46,6 +46,7 @@
raise oefmt(space.w_TypeError,
"expected a callable object, not %T", w_callable)
self.w_callable = w_callable
+ self.key_pycode = space._try_fetch_pycode(w_callable)
if not space.is_none(w_onerror):
if not space.is_true(space.callable(w_onerror)):
raise oefmt(space.w_TypeError,
@@ -64,8 +65,14 @@
convert_from_object_fficallback(fresult, self._closure.ll_error,
w_error)
#
- self.unique_id = compute_unique_id(self)
- global_callback_mapping.set(self.unique_id, self)
+ # We must setup the GIL here, in case the callback is invoked in
+ # some other non-Pythonic thread. This is the same as cffi on
+ # CPython.
+ if space.config.translation.thread:
+ from pypy.module.thread.os_thread import setup_threads
+ setup_threads(space)
+ #
+ handle_index = handle.get_handles(space).reserve_next_handle_index()
#
cif_descr = self.getfunctype().cif_descr
if not cif_descr:
@@ -74,7 +81,7 @@
"return type or with '...'", self.getfunctype().name)
with self as ptr:
closure_ptr = rffi.cast(clibffi.FFI_CLOSUREP, ptr)
- unique_id = rffi.cast(rffi.VOIDP, self.unique_id)
+ unique_id = rffi.cast(rffi.VOIDP, handle_index)
res = clibffi.c_ffi_prep_closure(closure_ptr, cif_descr.cif,
invoke_callback,
unique_id)
@@ -82,12 +89,8 @@
raise OperationError(space.w_SystemError,
space.wrap("libffi failed to build this callback"))
#
- # We must setup the GIL here, in case the callback is invoked in
- # some other non-Pythonic thread. This is the same as cffi on
- # CPython.
- if space.config.translation.thread:
- from pypy.module.thread.os_thread import setup_threads
- setup_threads(space)
+ _current_space.space = space
+ handle.get_handles(space).store_handle(handle_index, self)
def _repr_extra(self):
space = self.space
@@ -105,6 +108,7 @@
def invoke(self, ll_args):
space = self.space
ctype = self.getfunctype()
+ ctype = jit.promote(ctype)
args_w = []
for i, farg in enumerate(ctype.fargs):
ll_arg = rffi.cast(rffi.CCHARP, ll_args[i])
@@ -127,9 +131,6 @@
keepalive_until_here(self) # to keep self._closure.ll_error alive
-global_callback_mapping = rweakref.RWeakValueDictionary(int, W_CDataCallback)
-
-
def convert_from_object_fficallback(fresult, ll_res, w_res):
space = fresult.space
small_result = fresult.size < SIZE_OF_FFI_ARG
@@ -200,8 +201,18 @@
extra_line="\nDuring the call to 'onerror', "
"another exception occurred:\n\n")
- at jit.jit_callback("CFFI")
+def get_printable_location(key_pycode):
+ if key_pycode is None:
+ return 'cffi_callback <?>'
+ return 'cffi_callback ' + key_pycode.get_repr()
+
+jitdriver = jit.JitDriver(name='cffi_callback',
+ greens=['callback.key_pycode'],
+ reds=['ll_res', 'll_args', 'callback'],
+ get_printable_location=get_printable_location)
+
def py_invoke_callback(callback, ll_res, ll_args):
+ jitdriver.jit_merge_point(callback=callback, ll_res=ll_res, ll_args=ll_args)
extra_line = ''
try:
w_res = callback.invoke(ll_args)
@@ -210,6 +221,12 @@
except OperationError, e:
_handle_applevel_exception(callback, e, ll_res, extra_line)
+class CurrentSpace:
+ def _cleanup_(self):
+ if hasattr(self, 'space'):
+ del self.space
+_current_space = CurrentSpace()
+
def _invoke_callback(ffi_cif, ll_res, ll_args, ll_userdata):
""" Callback specification.
ffi_cif - something ffi specific, don't care
@@ -220,8 +237,9 @@
"""
ll_res = rffi.cast(rffi.CCHARP, ll_res)
unique_id = rffi.cast(lltype.Signed, ll_userdata)
- callback = global_callback_mapping.get(unique_id)
- if callback is None:
+ space = _current_space.space
+ callback = handle.get_handles(space).fetch_handle(unique_id)
+ if callback is None or not isinstance(callback, W_CDataCallback):
# oups!
try:
os.write(STDERR, "SystemError: invoking a callback "
@@ -234,7 +252,6 @@
return
#
must_leave = False
- space = callback.space
try:
must_leave = space.threadlocals.try_enter_thread(space)
py_invoke_callback(callback, ll_res, ll_args)
diff --git a/pypy/module/_cffi_backend/ctypearray.py b/pypy/module/_cffi_backend/ctypearray.py
--- a/pypy/module/_cffi_backend/ctypearray.py
+++ b/pypy/module/_cffi_backend/ctypearray.py
@@ -18,6 +18,7 @@
_attrs_ = ['ctptr']
_immutable_fields_ = ['ctptr']
kind = "array"
+ is_nonfunc_pointer_or_array = True
def __init__(self, space, ctptr, length, arraysize, extra):
W_CTypePtrOrArray.__init__(self, space, arraysize, extra, 0,
diff --git a/pypy/module/_cffi_backend/ctypeobj.py b/pypy/module/_cffi_backend/ctypeobj.py
--- a/pypy/module/_cffi_backend/ctypeobj.py
+++ b/pypy/module/_cffi_backend/ctypeobj.py
@@ -21,6 +21,7 @@
cast_anything = False
is_primitive_integer = False
+ is_nonfunc_pointer_or_array = False
kind = "?"
def __init__(self, space, size, name, name_position):
diff --git a/pypy/module/_cffi_backend/ctypeptr.py b/pypy/module/_cffi_backend/ctypeptr.py
--- a/pypy/module/_cffi_backend/ctypeptr.py
+++ b/pypy/module/_cffi_backend/ctypeptr.py
@@ -172,6 +172,7 @@
_immutable_fields_ = ['is_file', 'cache_array_type?', 'is_void_ptr']
kind = "pointer"
cache_array_type = None
+ is_nonfunc_pointer_or_array = True
def __init__(self, space, ctitem):
from pypy.module._cffi_backend import ctypearray
diff --git a/pypy/module/_cffi_backend/ffi_obj.py b/pypy/module/_cffi_backend/ffi_obj.py
--- a/pypy/module/_cffi_backend/ffi_obj.py
+++ b/pypy/module/_cffi_backend/ffi_obj.py
@@ -391,6 +391,25 @@
return cerrno.getwinerror(self.space, code)
+ @unwrap_spec(n=int)
+ def descr_memmove(self, w_dest, w_src, n):
+ """\
+ffi.memmove(dest, src, n) copies n bytes of memory from src to dest.
+
+Like the C function memmove(), the memory areas may overlap;
+apart from that it behaves like the C function memcpy().
+
+'src' can be any cdata ptr or array, or any Python buffer object.
+'dest' can be any cdata ptr or array, or a writable Python buffer
+object. The size to copy, 'n', is always measured in bytes.
+
+Unlike other methods, this one supports all Python buffer including
+byte strings and bytearrays---but it still does not support
+non-contiguous buffers."""
+ #
+ return func.memmove(self.space, w_dest, w_src, n)
+
+
@unwrap_spec(w_init=WrappedDefault(None))
def descr_new(self, w_arg, w_init):
"""\
@@ -623,6 +642,7 @@
gc = interp2app(W_FFIObject.descr_gc),
getctype = interp2app(W_FFIObject.descr_getctype),
integer_const = interp2app(W_FFIObject.descr_integer_const),
+ memmove = interp2app(W_FFIObject.descr_memmove),
new = interp2app(W_FFIObject.descr_new),
new_allocator = interp2app(W_FFIObject.descr_new_allocator),
new_handle = interp2app(W_FFIObject.descr_new_handle),
diff --git a/pypy/module/_cffi_backend/func.py b/pypy/module/_cffi_backend/func.py
--- a/pypy/module/_cffi_backend/func.py
+++ b/pypy/module/_cffi_backend/func.py
@@ -1,3 +1,8 @@
+from rpython.rtyper.annlowlevel import llstr
+from rpython.rtyper.lltypesystem import lltype, rffi
+from rpython.rtyper.lltypesystem.rstr import copy_string_to_raw
+from rpython.rlib.objectmodel import keepalive_until_here
+
from pypy.interpreter.error import OperationError, oefmt
from pypy.interpreter.gateway import unwrap_spec, WrappedDefault
from pypy.module._cffi_backend import ctypeobj, cdataobj, allocator
@@ -79,6 +84,26 @@
# ____________________________________________________________
+def _fetch_as_read_buffer(space, w_x):
+ # xxx do we really need to implement the same mess as in CPython 2.7
+ # w.r.t. buffers and memoryviews??
+ try:
+ buf = space.readbuf_w(w_x)
+ except OperationError, e:
+ if not e.match(space, space.w_TypeError):
+ raise
+ buf = space.buffer_w(w_x, space.BUF_SIMPLE)
+ return buf
+
+def _fetch_as_write_buffer(space, w_x):
+ try:
+ buf = space.writebuf_w(w_x)
+ except OperationError, e:
+ if not e.match(space, space.w_TypeError):
+ raise
+ buf = space.buffer_w(w_x, space.BUF_WRITABLE)
+ return buf
+
@unwrap_spec(w_ctype=ctypeobj.W_CType)
def from_buffer(space, w_ctype, w_x):
from pypy.module._cffi_backend import ctypearray, ctypeprim
@@ -88,14 +113,7 @@
raise oefmt(space.w_TypeError,
"needs 'char[]', got '%s'", w_ctype.name)
#
- # xxx do we really need to implement the same mess as in CPython 2.7
- # w.r.t. buffers and memoryviews??
- try:
- buf = space.readbuf_w(w_x)
- except OperationError, e:
- if not e.match(space, space.w_TypeError):
- raise
- buf = space.buffer_w(w_x, space.BUF_SIMPLE)
+ buf = _fetch_as_read_buffer(space, w_x)
try:
_cdata = buf.get_raw_address()
except ValueError:
@@ -106,6 +124,76 @@
#
return cdataobj.W_CDataFromBuffer(space, _cdata, w_ctype, buf, w_x)
+
+def unsafe_escaping_ptr_for_ptr_or_array(w_cdata):
+ if not w_cdata.ctype.is_nonfunc_pointer_or_array:
+ raise oefmt(w_cdata.space.w_TypeError,
+ "expected a pointer or array ctype, got '%s'",
+ w_cdata.ctype.name)
+ return w_cdata.unsafe_escaping_ptr()
+
+c_memmove = rffi.llexternal('memmove', [rffi.CCHARP, rffi.CCHARP,
+ rffi.SIZE_T], lltype.Void,
+ _nowrapper=True)
+
+ at unwrap_spec(n=int)
+def memmove(space, w_dest, w_src, n):
+ if n < 0:
+ raise oefmt(space.w_ValueError, "negative size")
+
+ # cases...
+ src_buf = None
+ src_data = lltype.nullptr(rffi.CCHARP.TO)
+ if isinstance(w_src, cdataobj.W_CData):
+ src_data = unsafe_escaping_ptr_for_ptr_or_array(w_src)
+ src_is_ptr = True
+ else:
+ src_buf = _fetch_as_read_buffer(space, w_src)
+ try:
+ src_data = src_buf.get_raw_address()
+ src_is_ptr = True
+ except ValueError:
+ src_is_ptr = False
+
+ if src_is_ptr:
+ src_string = None
+ else:
+ if n == src_buf.getlength():
+ src_string = src_buf.as_str()
+ else:
+ src_string = src_buf.getslice(0, n, 1, n)
+
+ dest_buf = None
+ dest_data = lltype.nullptr(rffi.CCHARP.TO)
+ if isinstance(w_dest, cdataobj.W_CData):
+ dest_data = unsafe_escaping_ptr_for_ptr_or_array(w_dest)
+ dest_is_ptr = True
+ else:
+ dest_buf = _fetch_as_write_buffer(space, w_dest)
+ try:
+ dest_data = dest_buf.get_raw_address()
+ dest_is_ptr = True
+ except ValueError:
+ dest_is_ptr = False
+
+ if dest_is_ptr:
+ if src_is_ptr:
+ c_memmove(dest_data, src_data, rffi.cast(rffi.SIZE_T, n))
+ else:
+ copy_string_to_raw(llstr(src_string), dest_data, 0, n)
+ else:
+ if src_is_ptr:
+ for i in range(n):
+ dest_buf.setitem(i, src_data[i])
+ else:
+ for i in range(n):
+ dest_buf.setitem(i, src_string[i])
+
+ keepalive_until_here(src_buf)
+ keepalive_until_here(dest_buf)
+ keepalive_until_here(w_src)
+ keepalive_until_here(w_dest)
+
# ____________________________________________________________
@unwrap_spec(w_cdata=cdataobj.W_CData)
diff --git a/pypy/module/_cffi_backend/handle.py b/pypy/module/_cffi_backend/handle.py
--- a/pypy/module/_cffi_backend/handle.py
+++ b/pypy/module/_cffi_backend/handle.py
@@ -9,16 +9,16 @@
def __init__(self, space):
self.initialize()
-def get(space):
+def get_handles(space):
return space.fromcache(CffiHandles)
# ____________________________________________________________
def _newp_handle(space, w_ctype, w_x):
- index = get(space).reserve_next_handle_index()
+ index = get_handles(space).reserve_next_handle_index()
_cdata = rffi.cast(rffi.CCHARP, index + 1)
new_cdataobj = cdataobj.W_CDataHandle(space, _cdata, w_ctype, w_x)
- get(space).store_handle(index, new_cdataobj)
+ get_handles(space).store_handle(index, new_cdataobj)
return new_cdataobj
@unwrap_spec(w_ctype=ctypeobj.W_CType)
@@ -39,7 +39,7 @@
"new_handle(), got '%s'", ctype.name)
with w_cdata as ptr:
index = rffi.cast(lltype.Signed, ptr)
- original_cdataobj = get(space).fetch_handle(index - 1)
+ original_cdataobj = get_handles(space).fetch_handle(index - 1)
#
if isinstance(original_cdataobj, cdataobj.W_CDataHandle):
return original_cdataobj.w_keepalive
diff --git a/pypy/module/_cffi_backend/test/_backend_test_c.py b/pypy/module/_cffi_backend/test/_backend_test_c.py
--- a/pypy/module/_cffi_backend/test/_backend_test_c.py
+++ b/pypy/module/_cffi_backend/test/_backend_test_c.py
@@ -3393,6 +3393,78 @@
check(4 | 8, "CHB", "GTB")
check(4 | 16, "CHB", "ROB")
+def test_memmove():
+ Short = new_primitive_type("short")
+ ShortA = new_array_type(new_pointer_type(Short), None)
+ Char = new_primitive_type("char")
+ CharA = new_array_type(new_pointer_type(Char), None)
+ p = newp(ShortA, [-1234, -2345, -3456, -4567, -5678])
+ memmove(p, p + 1, 4)
+ assert list(p) == [-2345, -3456, -3456, -4567, -5678]
+ p[2] = 999
+ memmove(p + 2, p, 6)
+ assert list(p) == [-2345, -3456, -2345, -3456, 999]
+ memmove(p + 4, newp(CharA, b"\x71\x72"), 2)
+ if sys.byteorder == 'little':
+ assert list(p) == [-2345, -3456, -2345, -3456, 0x7271]
+ else:
+ assert list(p) == [-2345, -3456, -2345, -3456, 0x7172]
+
+def test_memmove_buffer():
+ import array
+ Short = new_primitive_type("short")
+ ShortA = new_array_type(new_pointer_type(Short), None)
+ a = array.array('H', [10000, 20000, 30000])
+ p = newp(ShortA, 5)
+ memmove(p, a, 6)
+ assert list(p) == [10000, 20000, 30000, 0, 0]
+ memmove(p + 1, a, 6)
+ assert list(p) == [10000, 10000, 20000, 30000, 0]
+ b = array.array('h', [-1000, -2000, -3000])
+ memmove(b, a, 4)
+ assert b.tolist() == [10000, 20000, -3000]
+ assert a.tolist() == [10000, 20000, 30000]
+ p[0] = 999
+ p[1] = 998
+ p[2] = 997
+ p[3] = 996
+ p[4] = 995
+ memmove(b, p, 2)
+ assert b.tolist() == [999, 20000, -3000]
+ memmove(b, p + 2, 4)
+ assert b.tolist() == [997, 996, -3000]
+ p[2] = -p[2]
+ p[3] = -p[3]
+ memmove(b, p + 2, 6)
+ assert b.tolist() == [-997, -996, 995]
+
+def test_memmove_readonly_readwrite():
+ SignedChar = new_primitive_type("signed char")
+ SignedCharA = new_array_type(new_pointer_type(SignedChar), None)
+ p = newp(SignedCharA, 5)
+ memmove(p, b"abcde", 3)
+ assert list(p) == [ord("a"), ord("b"), ord("c"), 0, 0]
+ memmove(p, bytearray(b"ABCDE"), 2)
+ assert list(p) == [ord("A"), ord("B"), ord("c"), 0, 0]
+ py.test.raises((TypeError, BufferError), memmove, b"abcde", p, 3)
+ ba = bytearray(b"xxxxx")
+ memmove(dest=ba, src=p, n=3)
+ assert ba == bytearray(b"ABcxx")
+ memmove(ba, b"EFGH", 4)
+ assert ba == bytearray(b"EFGHx")
+
+def test_memmove_sign_check():
+ SignedChar = new_primitive_type("signed char")
+ SignedCharA = new_array_type(new_pointer_type(SignedChar), None)
+ p = newp(SignedCharA, 5)
+ py.test.raises(ValueError, memmove, p, p + 1, -1) # not segfault
+
+def test_memmove_bad_cdata():
+ BInt = new_primitive_type("int")
+ p = cast(BInt, 42)
+ py.test.raises(TypeError, memmove, p, bytearray(b'a'), 1)
+ py.test.raises(TypeError, memmove, bytearray(b'a'), p, 1)
+
def test_dereference_null_ptr():
BInt = new_primitive_type("int")
BIntPtr = new_pointer_type(BInt)
diff --git a/pypy/module/_cffi_backend/test/test_ffi_obj.py b/pypy/module/_cffi_backend/test/test_ffi_obj.py
--- a/pypy/module/_cffi_backend/test/test_ffi_obj.py
+++ b/pypy/module/_cffi_backend/test/test_ffi_obj.py
@@ -247,6 +247,63 @@
ffi.cast("unsigned short *", c)[1] += 500
assert list(a) == [10000, 20500, 30000]
+ def test_memmove(self):
+ import sys
+ import _cffi_backend as _cffi1_backend
+ ffi = _cffi1_backend.FFI()
+ p = ffi.new("short[]", [-1234, -2345, -3456, -4567, -5678])
+ ffi.memmove(p, p + 1, 4)
+ assert list(p) == [-2345, -3456, -3456, -4567, -5678]
+ p[2] = 999
+ ffi.memmove(p + 2, p, 6)
+ assert list(p) == [-2345, -3456, -2345, -3456, 999]
+ ffi.memmove(p + 4, ffi.new("char[]", b"\x71\x72"), 2)
+ if sys.byteorder == 'little':
+ assert list(p) == [-2345, -3456, -2345, -3456, 0x7271]
+ else:
+ assert list(p) == [-2345, -3456, -2345, -3456, 0x7172]
+
+ def test_memmove_buffer(self):
+ import _cffi_backend as _cffi1_backend
+ import array
+ ffi = _cffi1_backend.FFI()
+ a = array.array('H', [10000, 20000, 30000])
+ p = ffi.new("short[]", 5)
+ ffi.memmove(p, a, 6)
+ assert list(p) == [10000, 20000, 30000, 0, 0]
+ ffi.memmove(p + 1, a, 6)
+ assert list(p) == [10000, 10000, 20000, 30000, 0]
+ b = array.array('h', [-1000, -2000, -3000])
+ ffi.memmove(b, a, 4)
+ assert b.tolist() == [10000, 20000, -3000]
+ assert a.tolist() == [10000, 20000, 30000]
+ p[0] = 999
+ p[1] = 998
+ p[2] = 997
+ p[3] = 996
+ p[4] = 995
+ ffi.memmove(b, p, 2)
+ assert b.tolist() == [999, 20000, -3000]
+ ffi.memmove(b, p + 2, 4)
+ assert b.tolist() == [997, 996, -3000]
+ p[2] = -p[2]
+ p[3] = -p[3]
+ ffi.memmove(b, p + 2, 6)
+ assert b.tolist() == [-997, -996, 995]
+
+ def test_memmove_readonly_readwrite(self):
+ import _cffi_backend as _cffi1_backend
+ ffi = _cffi1_backend.FFI()
+ p = ffi.new("signed char[]", 5)
+ ffi.memmove(p, b"abcde", 3)
+ assert list(p) == [ord("a"), ord("b"), ord("c"), 0, 0]
+ ffi.memmove(p, bytearray(b"ABCDE"), 2)
+ assert list(p) == [ord("A"), ord("B"), ord("c"), 0, 0]
+ raises((TypeError, BufferError), ffi.memmove, b"abcde", p, 3)
+ ba = bytearray(b"xxxxx")
+ ffi.memmove(dest=ba, src=p, n=3)
+ assert ba == bytearray(b"ABcxx")
+
def test_ffi_types(self):
import _cffi_backend as _cffi1_backend
CData = _cffi1_backend.FFI.CData
diff --git a/pypy/module/_io/interp_io.py b/pypy/module/_io/interp_io.py
--- a/pypy/module/_io/interp_io.py
+++ b/pypy/module/_io/interp_io.py
@@ -118,7 +118,7 @@
if buffering < 0:
buffering = DEFAULT_BUFFER_SIZE
- if space.config.translation.type_system == 'lltype' and 'st_blksize' in STAT_FIELD_TYPES:
+ if 'st_blksize' in STAT_FIELD_TYPES:
fileno = space.c_int_w(space.call_method(w_raw, "fileno"))
try:
st = os.fstat(fileno)
diff --git a/pypy/module/cpyext/ndarrayobject.py b/pypy/module/cpyext/ndarrayobject.py
--- a/pypy/module/cpyext/ndarrayobject.py
+++ b/pypy/module/cpyext/ndarrayobject.py
@@ -12,6 +12,7 @@
from pypy.module.micronumpy.descriptor import get_dtype_cache, W_Dtype
from pypy.module.micronumpy.concrete import ConcreteArray
from pypy.module.micronumpy import ufuncs
+import pypy.module.micronumpy.constants as NPY
from rpython.rlib.rawstorage import RAW_STORAGE_PTR
from pypy.interpreter.typedef import TypeDef
from pypy.interpreter.baseobjspace import W_Root
@@ -203,12 +204,12 @@
return shape, dtype
def simple_new(space, nd, dims, typenum,
- order='C', owning=False, w_subtype=None):
+ order=NPY.CORDER, owning=False, w_subtype=None):
shape, dtype = get_shape_and_dtype(space, nd, dims, typenum)
return W_NDimArray.from_shape(space, shape, dtype)
def simple_new_from_data(space, nd, dims, typenum, data,
- order='C', owning=False, w_subtype=None):
+ order=NPY.CORDER, owning=False, w_subtype=None):
shape, dtype = get_shape_and_dtype(space, nd, dims, typenum)
storage = rffi.cast(RAW_STORAGE_PTR, data)
return W_NDimArray.from_shape_and_storage(space, shape, storage, dtype,
@@ -238,7 +239,7 @@
raise OperationError(space.w_NotImplementedError,
space.wrap("strides must be NULL"))
- order = 'C' if flags & NPY_C_CONTIGUOUS else 'F'
+ order = NPY.CORDER if flags & NPY_C_CONTIGUOUS else NPY.FORTRANORDER
owning = True if flags & NPY_OWNDATA else False
w_subtype = None
diff --git a/pypy/module/cpyext/test/test_ndarrayobject.py b/pypy/module/cpyext/test/test_ndarrayobject.py
--- a/pypy/module/cpyext/test/test_ndarrayobject.py
+++ b/pypy/module/cpyext/test/test_ndarrayobject.py
@@ -4,16 +4,17 @@
from rpython.rtyper.lltypesystem import rffi, lltype
from pypy.module.micronumpy.ndarray import W_NDimArray
from pypy.module.micronumpy.descriptor import get_dtype_cache
+import pypy.module.micronumpy.constants as NPY
def scalar(space):
dtype = get_dtype_cache(space).w_float64dtype
return W_NDimArray.new_scalar(space, dtype, space.wrap(10.))
-def array(space, shape, order='C'):
+def array(space, shape, order=NPY.CORDER):
dtype = get_dtype_cache(space).w_float64dtype
return W_NDimArray.from_shape(space, shape, dtype, order=order)
-def iarray(space, shape, order='C'):
+def iarray(space, shape, order=NPY.CORDER):
dtype = get_dtype_cache(space).w_int64dtype
return W_NDimArray.from_shape(space, shape, dtype, order=order)
@@ -32,8 +33,8 @@
def test_FLAGS(self, space, api):
s = array(space, [10])
- c = array(space, [10, 5, 3], order='C')
- f = array(space, [10, 5, 3], order='F')
+ c = array(space, [10, 5, 3], order=NPY.CORDER)
+ f = array(space, [10, 5, 3], order=NPY.FORTRANORDER)
assert api._PyArray_FLAGS(s) & 0x0001
assert api._PyArray_FLAGS(s) & 0x0002
assert api._PyArray_FLAGS(c) & 0x0001
diff --git a/pypy/module/micronumpy/arrayops.py b/pypy/module/micronumpy/arrayops.py
--- a/pypy/module/micronumpy/arrayops.py
+++ b/pypy/module/micronumpy/arrayops.py
@@ -108,7 +108,8 @@
w_axis = space.wrap(0)
if space.is_none(w_axis):
args_w = [w_arg.reshape(space,
- space.newlist([w_arg.descr_get_size(space)]))
+ space.newlist([w_arg.descr_get_size(space)]),
+ w_arg.get_order())
for w_arg in args_w]
w_axis = space.wrap(0)
dtype = args_w[0].get_dtype()
@@ -140,7 +141,7 @@
dtype = find_result_type(space, args_w, [])
# concatenate does not handle ndarray subtypes, it always returns a ndarray
- res = W_NDimArray.from_shape(space, shape, dtype, 'C')
+ res = W_NDimArray.from_shape(space, shape, dtype, NPY.CORDER)
chunks = [Chunk(0, i, 1, i) for i in shape]
axis_start = 0
for arr in args_w:
diff --git a/pypy/module/micronumpy/base.py b/pypy/module/micronumpy/base.py
--- a/pypy/module/micronumpy/base.py
+++ b/pypy/module/micronumpy/base.py
@@ -38,7 +38,8 @@
self.implementation = implementation
@staticmethod
- def from_shape(space, shape, dtype, order='C', w_instance=None, zero=True):
+ def from_shape(space, shape, dtype, order=NPY.CORDER,
+ w_instance=None, zero=True):
from pypy.module.micronumpy import concrete, descriptor, boxes
from pypy.module.micronumpy.strides import calc_strides
if len(shape) > NPY.MAXDIMS:
@@ -59,8 +60,9 @@
@staticmethod
def from_shape_and_storage(space, shape, storage, dtype, storage_bytes=-1,
- order='C', owning=False, w_subtype=None,
- w_base=None, writable=True, strides=None, start=0):
+ order=NPY.CORDER, owning=False, w_subtype=None,
+ w_base=None, writable=True, strides=None,
+ start=0):
from pypy.module.micronumpy import concrete
from pypy.module.micronumpy.strides import (calc_strides,
calc_backstrides)
diff --git a/pypy/module/micronumpy/concrete.py b/pypy/module/micronumpy/concrete.py
--- a/pypy/module/micronumpy/concrete.py
+++ b/pypy/module/micronumpy/concrete.py
@@ -56,6 +56,9 @@
jit.hint(len(backstrides), promote=True)
return backstrides
+ def get_flags(self):
+ return self.flags
+
def getitem(self, index):
return self.dtype.read(self, index, 0)
@@ -89,17 +92,18 @@
def get_storage_size(self):
return self.size
- def reshape(self, orig_array, new_shape):
+ def reshape(self, orig_array, new_shape, order=NPY.ANYORDER):
# Since we got to here, prod(new_shape) == self.size
+ order = support.get_order_as_CF(self.order, order)
new_strides = None
if self.size == 0:
- new_strides, _ = calc_strides(new_shape, self.dtype, self.order)
+ new_strides, _ = calc_strides(new_shape, self.dtype, order)
else:
if len(self.get_shape()) == 0:
new_strides = [self.dtype.elsize] * len(new_shape)
else:
new_strides = calc_new_strides(new_shape, self.get_shape(),
- self.get_strides(), self.order)
+ self.get_strides(), order)
if new_strides is None or len(new_strides) != len(new_shape):
return None
if new_strides is not None:
@@ -303,10 +307,11 @@
return SliceArray(self.start, strides,
backstrides, shape, self, orig_array)
- def copy(self, space):
+ def copy(self, space, order=NPY.ANYORDER):
+ order = support.get_order_as_CF(self.order, order)
strides, backstrides = calc_strides(self.get_shape(), self.dtype,
- self.order)
- impl = ConcreteArray(self.get_shape(), self.dtype, self.order, strides,
+ order)
+ impl = ConcreteArray(self.get_shape(), self.dtype, order, strides,
backstrides)
return loop.setslice(space, self.get_shape(), impl, self)
@@ -360,12 +365,12 @@
# but make the array storage contiguous in memory
shape = self.get_shape()
strides = self.get_strides()
- if order not in ('C', 'F'):
- raise oefmt(space.w_ValueError, "Unknown order %s in astype", order)
+ if order not in (NPY.KEEPORDER, NPY.FORTRANORDER, NPY.CORDER):
+ raise oefmt(space.w_ValueError, "Unknown order %d in astype", order)
if len(strides) == 0:
t_strides = []
backstrides = []
- elif order != self.order:
+ elif order in (NPY.FORTRANORDER, NPY.CORDER):
t_strides, backstrides = calc_strides(shape, dtype, order)
else:
indx_array = range(len(strides))
@@ -378,6 +383,7 @@
t_strides[i] = base
base *= shape[i]
backstrides = calc_backstrides(t_strides, shape)
+ order = support.get_order_as_CF(self.order, order)
impl = ConcreteArray(shape, dtype, order, t_strides, backstrides)
loop.setslice(space, impl.get_shape(), impl, self)
return impl
@@ -429,6 +435,8 @@
self.shape = shape
# already tested for overflow in from_shape_and_storage
self.size = support.product(shape) * dtype.elsize
+ if order not in (NPY.CORDER, NPY.FORTRANORDER):
+ raise oefmt(dtype.itemtype.space.w_ValueError, "ConcreteArrayNotOwning but order is not 0,1 rather %d", order)
self.order = order
self.dtype = dtype
self.strides = strides
@@ -562,6 +570,8 @@
self.parent = parent
self.storage = parent.storage
self.gcstruct = parent.gcstruct
+ if parent.order not in (NPY.CORDER, NPY.FORTRANORDER):
+ raise oefmt(dtype.itemtype.space.w_ValueError, "SliceArray but parent order is not 0,1 rather %d", parent.order)
self.order = parent.order
self.dtype = dtype
try:
@@ -602,13 +612,13 @@
s = self.get_strides()[0] // dtype.elsize
except IndexError:
s = 1
- if self.order == 'C':
+ if self.order != NPY.FORTRANORDER:
new_shape.reverse()
for sh in new_shape:
strides.append(s * dtype.elsize)
backstrides.append(s * (sh - 1) * dtype.elsize)
s *= max(1, sh)
- if self.order == 'C':
+ if self.order != NPY.FORTRANORDER:
strides.reverse()
backstrides.reverse()
new_shape.reverse()
diff --git a/pypy/module/micronumpy/converters.py b/pypy/module/micronumpy/converters.py
--- a/pypy/module/micronumpy/converters.py
+++ b/pypy/module/micronumpy/converters.py
@@ -77,9 +77,8 @@
elif order.startswith('K') or order.startswith('k'):
return NPY.KEEPORDER
else:
- raise OperationError(space.w_TypeError, space.wrap(
- "order not understood"))
-
+ raise oefmt(space.w_TypeError, "Unknown order: '%s'", order)
+ return -1
def multi_axis_converter(space, w_axis, ndim):
if space.is_none(w_axis):
diff --git a/pypy/module/micronumpy/ctors.py b/pypy/module/micronumpy/ctors.py
--- a/pypy/module/micronumpy/ctors.py
+++ b/pypy/module/micronumpy/ctors.py
@@ -5,10 +5,10 @@
from rpython.rtyper.lltypesystem import lltype, rffi
from pypy.module.micronumpy import descriptor, loop, support
-from pypy.module.micronumpy.base import (
+from pypy.module.micronumpy.base import (wrap_impl,
W_NDimArray, convert_to_array, W_NumpyObject)
-from pypy.module.micronumpy.converters import shape_converter
-from . import constants as NPY
+from pypy.module.micronumpy.converters import shape_converter, order_converter
+import pypy.module.micronumpy.constants as NPY
from .casting import scalar2dtype
@@ -101,13 +101,8 @@
dtype = descriptor.decode_w_dtype(space, w_dtype)
if space.is_none(w_order):
- order = 'C'
- else:
- order = space.str_w(w_order)
- if order == 'K':
- order = 'C'
- if order != 'C': # or order != 'F':
- raise oefmt(space.w_ValueError, "Unknown order: %s", order)
+ w_order = space.wrap('C')
+ npy_order = order_converter(space, w_order, NPY.CORDER)
if isinstance(w_object, W_NDimArray):
if (dtype is None or w_object.get_dtype() is dtype):
@@ -126,7 +121,7 @@
copy = True
if copy:
shape = w_object.get_shape()
- w_arr = W_NDimArray.from_shape(space, shape, dtype, order=order)
+ w_arr = W_NDimArray.from_shape(space, shape, dtype, order=npy_order)
if support.product(shape) == 1:
w_arr.set_scalar_value(dtype.coerce(space,
w_object.implementation.getitem(0)))
@@ -151,7 +146,7 @@
if dtype is None or (dtype.is_str_or_unicode() and dtype.elsize < 1):
dtype = find_dtype_for_seq(space, elems_w, dtype)
- w_arr = W_NDimArray.from_shape(space, shape, dtype, order=order)
+ w_arr = W_NDimArray.from_shape(space, shape, dtype, order=npy_order)
if support.product(shape) == 1: # safe from overflow since from_shape checks
w_arr.set_scalar_value(dtype.coerce(space, elems_w[0]))
else:
@@ -268,6 +263,7 @@
def _zeros_or_empty(space, w_shape, w_dtype, w_order, zero):
+ order = order_converter(space, w_order, NPY.CORDER)
dtype = space.interp_w(descriptor.W_Dtype,
space.call_function(space.gettypefor(descriptor.W_Dtype), w_dtype))
if dtype.is_str_or_unicode() and dtype.elsize < 1:
@@ -281,7 +277,7 @@
support.product_check(shape)
except OverflowError:
raise oefmt(space.w_ValueError, "array is too big.")
- return W_NDimArray.from_shape(space, shape, dtype=dtype, zero=zero)
+ return W_NDimArray.from_shape(space, shape, dtype, order, zero=zero)
def empty(space, w_shape, w_dtype=None, w_order=None):
return _zeros_or_empty(space, w_shape, w_dtype, w_order, zero=False)
@@ -293,6 +289,7 @@
@unwrap_spec(subok=bool)
def empty_like(space, w_a, w_dtype=None, w_order=None, subok=True):
w_a = convert_to_array(space, w_a)
+ npy_order = order_converter(space, w_order, w_a.get_order())
if space.is_none(w_dtype):
dtype = w_a.get_dtype()
else:
@@ -300,7 +297,16 @@
space.call_function(space.gettypefor(descriptor.W_Dtype), w_dtype))
if dtype.is_str_or_unicode() and dtype.elsize < 1:
dtype = descriptor.variable_dtype(space, dtype.char + '1')
+ if npy_order in (NPY.KEEPORDER, NPY.ANYORDER):
+ # Try to copy the stride pattern
+ impl = w_a.implementation.astype(space, dtype, NPY.KEEPORDER)
+ if subok:
+ w_type = space.type(w_a)
+ else:
+ w_type = None
+ return wrap_impl(space, w_type, w_a, impl)
return W_NDimArray.from_shape(space, w_a.get_shape(), dtype=dtype,
+ order=npy_order,
w_instance=w_a if subok else None,
zero=False)
diff --git a/pypy/module/micronumpy/loop.py b/pypy/module/micronumpy/loop.py
--- a/pypy/module/micronumpy/loop.py
+++ b/pypy/module/micronumpy/loop.py
@@ -777,7 +777,7 @@
def tostring(space, arr):
builder = StringBuilder()
iter, state = arr.create_iter()
- w_res_str = W_NDimArray.from_shape(space, [1], arr.get_dtype(), order='C')
+ w_res_str = W_NDimArray.from_shape(space, [1], arr.get_dtype())
itemsize = arr.get_dtype().elsize
with w_res_str.implementation as storage:
res_str_casted = rffi.cast(rffi.CArrayPtr(lltype.Char),
diff --git a/pypy/module/micronumpy/ndarray.py b/pypy/module/micronumpy/ndarray.py
--- a/pypy/module/micronumpy/ndarray.py
+++ b/pypy/module/micronumpy/ndarray.py
@@ -97,11 +97,15 @@
self.fill(space, self.get_dtype().coerce(space, w_value))
def descr_tostring(self, space, w_order=None):
- order = order_converter(space, w_order, NPY.CORDER)
- if order == NPY.FORTRANORDER:
- raise OperationError(space.w_NotImplementedError, space.wrap(
- "unsupported value for order"))
- return space.wrap(loop.tostring(space, self))
+ try:
+ order = order_converter(space, w_order, NPY.CORDER)
+ except:
+ raise oefmt(space.w_TypeError, "order not understood")
+ order = support.get_order_as_CF(self.get_order(), order)
+ arr = self
+ if order != arr.get_order():
+ arr = W_NDimArray(self.implementation.transpose(self, None))
+ return space.wrap(loop.tostring(space, arr))
def getitem_filter(self, space, arr):
if arr.ndims() > 1 and arr.get_shape() != self.get_shape():
@@ -365,11 +369,13 @@
return self.implementation.getitem(self.implementation.start)
def descr_copy(self, space, w_order=None):
- order = order_converter(space, w_order, NPY.KEEPORDER)
- if order == NPY.FORTRANORDER:
- raise OperationError(space.w_NotImplementedError, space.wrap(
- "unsupported value for order"))
- copy = self.implementation.copy(space)
+ if w_order is None:
+ order = NPY.KEEPORDER
+ elif space.isinstance_w(w_order, space.w_int):
+ order = space.int_w(w_order)
+ else:
+ order = order_converter(space, w_order, NPY.KEEPORDER)
+ copy = self.implementation.copy(space, order)
w_subtype = space.type(self)
return wrap_impl(space, w_subtype, self, copy)
@@ -392,15 +398,15 @@
'array does not have imaginary part to set')
self.implementation.set_imag(space, self, w_value)
- def reshape(self, space, w_shape):
+ def reshape(self, space, w_shape, order):
new_shape = get_shape_from_iterable(space, self.get_size(), w_shape)
- new_impl = self.implementation.reshape(self, new_shape)
+ new_impl = self.implementation.reshape(self, new_shape, order)
if new_impl is not None:
return wrap_impl(space, space.type(self), self, new_impl)
# Create copy with contiguous data
- arr = self.descr_copy(space)
+ arr = self.descr_copy(space, space.wrap(order))
if arr.get_size() > 0:
- new_implementation = arr.implementation.reshape(self, new_shape)
+ new_implementation = arr.implementation.reshape(self, new_shape, order)
if new_implementation is None:
raise oefmt(space.w_ValueError,
'could not reshape array of size %d to shape %s',
@@ -434,16 +440,13 @@
if order == NPY.KEEPORDER:
raise OperationError(space.w_ValueError, space.wrap(
"order 'K' is not permitted for reshaping"))
- if order != NPY.CORDER and order != NPY.ANYORDER:
- raise OperationError(space.w_NotImplementedError, space.wrap(
- "unsupported value for order"))
if len(args_w) == 1:
if space.is_none(args_w[0]):
return self.descr_view(space)
w_shape = args_w[0]
else:
w_shape = space.newtuple(args_w)
- return self.reshape(space, w_shape)
+ return self.reshape(space, w_shape, order)
def descr_get_transpose(self, space, axes=None):
return W_NDimArray(self.implementation.transpose(self, axes))
@@ -514,20 +517,8 @@
return space.newlist(l_w)
def descr_ravel(self, space, w_order=None):
- if space.is_none(w_order):
- order = 'C'
- else:
- order = space.str_w(w_order)
- if order == 'K' and is_c_contiguous(self.implementation):
- for s in self.implementation.get_strides():
- if s < 0:
- break
- else:
- order = 'C'
- if order != 'C':
- raise OperationError(space.w_NotImplementedError, space.wrap(
- "order != 'C' only partially implemented"))
- return self.reshape(space, space.wrap(-1))
+ order = order_converter(space, w_order, self.get_order())
+ return self.reshape(space, space.wrap(-1), order)
@unwrap_spec(w_axis=WrappedDefault(None),
w_out=WrappedDefault(None),
@@ -541,14 +532,15 @@
space.wrap("axis unsupported for compress"))
arr = self
else:
- arr = self.reshape(space, space.wrap(-1))
+ arr = self.reshape(space, space.wrap(-1), self.get_order())
index = convert_to_array(space, w_obj)
return arr.getitem_filter(space, index)
def descr_flatten(self, space, w_order=None):
+ order = order_converter(space, w_order, self.get_order())
if self.is_scalar():
# scalars have no storage
- return self.reshape(space, space.wrap(1))
+ return self.reshape(space, space.wrap(1), order)
w_res = self.descr_ravel(space, w_order)
if w_res.implementation.storage == self.implementation.storage:
return w_res.descr_copy(space)
@@ -631,7 +623,7 @@
space.newtuple([space.wrap(addr), space.w_False]))
space.setitem_str(w_d, 'shape', self.descr_get_shape(space))
space.setitem_str(w_d, 'typestr', self.get_dtype().descr_get_str(space))
- if self.implementation.order == 'C':
+ if self.implementation.order == NPY.CORDER:
# Array is contiguous, no strides in the interface.
strides = space.w_None
else:
@@ -690,8 +682,9 @@
"according to the rule %s",
space.str_w(self.get_dtype().descr_repr(space)),
space.str_w(new_dtype.descr_repr(space)), casting)
- order = support.get_order_as_CF(self.get_order(), order)
- if (not copy and new_dtype == self.get_dtype() and order == self.get_order()
+ order = order_converter(space, space.wrap(order), self.get_order())
+ if (not copy and new_dtype == self.get_dtype()
+ and (order in (NPY.KEEPORDER, NPY.ANYORDER) or order == self.get_order())
and (subok or type(self) is W_NDimArray)):
return self
impl = self.implementation
@@ -972,7 +965,7 @@
raise OperationError(space.w_ValueError, space.wrap(
"new type not compatible with array."))
# Adapt the smallest dim to the new itemsize
- if self.get_order() == 'F':
+ if self.get_order() == NPY.FORTRANORDER:
minstride = strides[0]
mini = 0
else:
@@ -1136,7 +1129,7 @@
matches = True
if dtype != out.get_dtype():
matches = False
- elif not out.implementation.order == "C":
+ elif not out.implementation.order == NPY.CORDER:
matches = False
elif out.ndims() != len(out_shape):
matches = False
@@ -1195,7 +1188,7 @@
out = out_converter(space, w_out)
if space.is_none(w_axis):
w_axis = space.wrap(0)
- arr = self.reshape(space, space.wrap(-1))
+ arr = self.reshape(space, space.wrap(-1), self.get_order())
else:
arr = self
ufunc = getattr(ufuncs.get(space), ufunc_name)
@@ -1408,10 +1401,6 @@
strides=strides)
order = order_converter(space, w_order, NPY.CORDER)
- if order == NPY.CORDER:
- order = 'C'
- else:
- order = 'F'
if space.is_w(w_subtype, space.gettypefor(W_NDimArray)):
return W_NDimArray.from_shape(space, shape, dtype, order)
strides, backstrides = calc_strides(shape, dtype.base, order)
@@ -1448,7 +1437,7 @@
raise OperationError(space.w_ValueError, space.wrap(
"subtype must be a subtype of ndarray, not a class instance"))
return W_NDimArray.from_shape_and_storage(space, shape, storage, dtype,
- buf_len, 'C', False, w_subtype,
+ buf_len, NPY.CORDER, False, w_subtype,
strides=strides)
else:
return W_NDimArray.from_shape_and_storage(space, shape, storage, dtype,
diff --git a/pypy/module/micronumpy/nditer.py b/pypy/module/micronumpy/nditer.py
--- a/pypy/module/micronumpy/nditer.py
+++ b/pypy/module/micronumpy/nditer.py
@@ -11,6 +11,8 @@
shape_agreement, shape_agreement_multiple)
from pypy.module.micronumpy.casting import (find_binop_result_dtype,
can_cast_array, can_cast_type)
+import pypy.module.micronumpy.constants as NPY
+from pypy.module.micronumpy.converters import order_converter
def parse_op_arg(space, name, w_op_flags, n, parse_one_arg):
@@ -142,14 +144,13 @@
'Iterator flag EXTERNAL_LOOP cannot be used if an index or '
'multi-index is being tracked')
-
-def is_backward(imp, order):
- if order == 'K' or (order == 'C' and imp.order == 'C'):
+def is_backward(imp_order, order):
+ if imp_order == order:
return False
- elif order == 'F' and imp.order == 'C':
+ if order == NPY.KEEPORDER:
+ return False
+ else:
return True
- else:
- raise NotImplementedError('not implemented yet')
class OperandIter(ArrayIter):
@@ -234,7 +235,7 @@
continue
assert isinstance(op_it, ArrayIter)
indx = len(op_it.strides)
- if it.order == 'F':
+ if it.order == NPY.FORTRANORDER:
indx = len(op_it.array.strides) - indx
assert indx >=0
astrides = op_it.array.strides[indx:]
@@ -250,7 +251,7 @@
it.order)
it.iters[i] = (new_iter, new_iter.reset())
if len(it.shape) > 1:
- if it.order == 'F':
+ if it.order == NPY.FORTRANORDER:
it.shape = it.shape[1:]
else:
it.shape = it.shape[:-1]
@@ -261,10 +262,10 @@
break
# Always coalesce at least one
for i in range(len(it.iters)):
- new_iter = coalesce_iter(it.iters[i][0], it.op_flags[i], it, 'C')
+ new_iter = coalesce_iter(it.iters[i][0], it.op_flags[i], it, NPY.CORDER)
it.iters[i] = (new_iter, new_iter.reset())
if len(it.shape) > 1:
- if it.order == 'F':
+ if it.order == NPY.FORTRANORDER:
it.shape = it.shape[1:]
else:
it.shape = it.shape[:-1]
@@ -287,7 +288,7 @@
return old_iter
strides = old_iter.strides
backstrides = old_iter.backstrides
- if order == 'F':
+ if order == NPY.FORTRANORDER:
new_shape = shape[1:]
new_strides = strides[1:]
new_backstrides = backstrides[1:]
@@ -346,8 +347,8 @@
class W_NDIter(W_NumpyObject):
_immutable_fields_ = ['ndim', ]
def __init__(self, space, w_seq, w_flags, w_op_flags, w_op_dtypes,
- w_casting, w_op_axes, w_itershape, buffersize=0, order='K'):
- self.order = order
+ w_casting, w_op_axes, w_itershape, buffersize=0,
+ order=NPY.KEEPORDER):
self.external_loop = False
self.buffered = False
self.tracked_index = ''
@@ -375,7 +376,25 @@
for w_elem in w_seq_as_list]
else:
self.seq = [convert_to_array(space, w_seq)]
-
+ if order == NPY.ANYORDER:
+ # 'A' means "'F' order if all the arrays are Fortran contiguous,
+ # 'C' order otherwise"
+ order = NPY.CORDER
+ for s in self.seq:
+ if s and not(s.get_flags() & NPY.ARRAY_F_CONTIGUOUS):
+ break
+ else:
+ order = NPY.FORTRANORDER
+ elif order == NPY.KEEPORDER:
+ # 'K' means "as close to the order the array elements appear in
+ # memory as possible", so match self.order to seq.order
+ order = NPY.CORDER
+ for s in self.seq:
+ if s and not(s.get_order() == NPY.FORTRANORDER):
+ break
+ else:
+ order = NPY.FORTRANORDER
+ self.order = order
parse_func_flags(space, self, w_flags)
self.op_flags = parse_op_arg(space, 'op_flags', w_op_flags,
len(self.seq), parse_op_flag)
@@ -439,12 +458,15 @@
str(self.shape))
if self.tracked_index != "":
- if self.order == "K":
- self.order = self.seq[0].implementation.order
+ order = self.order
+ if order == NPY.KEEPORDER:
+ order = self.seq[0].implementation.order
if self.tracked_index == "multi":
backward = False
else:
- backward = self.order != self.tracked_index
+ backward = ((
+ order == NPY.CORDER and self.tracked_index != 'C') or (
+ order == NPY.FORTRANORDER and self.tracked_index != 'F'))
self.index_iter = IndexIterator(self.shape, backward=backward)
# handle w_op_dtypes part 2: copy where needed if possible
@@ -456,7 +478,6 @@
self.dtypes[i] = seq_d
elif self_d != seq_d:
impl = self.seq[i].implementation
- order = support.get_order_as_CF(impl.order, self.order)
if self.buffered or 'r' in self.op_flags[i].tmp_copy:
if not can_cast_array(
space, self.seq[i], self_d, self.casting):
@@ -466,7 +487,7 @@
space.str_w(seq_d.descr_repr(space)),
space.str_w(self_d.descr_repr(space)),
self.casting)
-
+ order = support.get_order_as_CF(impl.order, self.order)
new_impl = impl.astype(space, self_d, order).copy(space)
self.seq[i] = W_NDimArray(new_impl)
else:
@@ -484,7 +505,7 @@
space.str_w(self_d.descr_repr(space)),
space.str_w(seq_d.descr_repr(space)),
i, self.casting)
- elif self.buffered:
+ elif self.buffered and not (self.external_loop and len(self.seq)<2):
for i in range(len(self.seq)):
if i not in outargs:
self.seq[i] = self.seq[i].descr_copy(space,
@@ -506,12 +527,19 @@
def get_iter(self, space, i):
arr = self.seq[i]
- dtype = self.dtypes[i]
- shape = self.shape
imp = arr.implementation
- backward = is_backward(imp, self.order)
if arr.is_scalar():
return ConcreteIter(imp, 1, [], [], [], self.op_flags[i], self)
+ shape = self.shape
+ if (self.external_loop and len(self.seq)<2 and self.buffered):
+ # Special case, always return a memory-ordered iterator
+ stride = imp.dtype.elsize
+ backstride = imp.size * stride - stride
+ return ConcreteIter(imp, imp.get_size(),
+ [support.product(shape)], [stride], [backstride],
+ self.op_flags[i], self)
+ backward = imp.order != self.order
+ # XXX cleanup needed
if (abs(imp.strides[0]) < abs(imp.strides[-1]) and not backward) or \
(abs(imp.strides[0]) > abs(imp.strides[-1]) and backward):
# flip the strides. Is this always true for multidimension?
@@ -704,13 +732,15 @@
@unwrap_spec(w_flags=WrappedDefault(None), w_op_flags=WrappedDefault(None),
- w_op_dtypes=WrappedDefault(None), order=str,
+ w_op_dtypes=WrappedDefault(None), w_order=WrappedDefault(None),
w_casting=WrappedDefault(None), w_op_axes=WrappedDefault(None),
- w_itershape=WrappedDefault(None), buffersize=int)
+ w_itershape=WrappedDefault(None), w_buffersize=WrappedDefault(0))
def descr_new_nditer(space, w_subtype, w_seq, w_flags, w_op_flags, w_op_dtypes,
- w_casting, w_op_axes, w_itershape, buffersize=0, order='K'):
+ w_casting, w_op_axes, w_itershape, w_buffersize, w_order):
+ npy_order = order_converter(space, w_order, NPY.KEEPORDER)
+ buffersize = space.int_w(w_buffersize)
return W_NDIter(space, w_seq, w_flags, w_op_flags, w_op_dtypes, w_casting, w_op_axes,
- w_itershape, buffersize, order)
+ w_itershape, buffersize, npy_order)
W_NDIter.typedef = TypeDef('numpy.nditer',
__new__ = interp2app(descr_new_nditer),
diff --git a/pypy/module/micronumpy/strides.py b/pypy/module/micronumpy/strides.py
--- a/pypy/module/micronumpy/strides.py
+++ b/pypy/module/micronumpy/strides.py
@@ -311,14 +311,14 @@
backstrides = []
s = 1
shape_rev = shape[:]
- if order == 'C':
+ if order in [NPY.CORDER, NPY.ANYORDER]:
shape_rev.reverse()
for sh in shape_rev:
slimit = max(sh, 1)
strides.append(s * dtype.elsize)
backstrides.append(s * (slimit - 1) * dtype.elsize)
s *= slimit
- if order == 'C':
+ if order in [NPY.CORDER, NPY.ANYORDER]:
strides.reverse()
backstrides.reverse()
return strides, backstrides
@@ -346,7 +346,7 @@
last_step = 1
oldI = 0
new_strides = []
- if order == 'F':
+ if order == NPY.FORTRANORDER:
for i in range(len(old_shape)):
steps.append(old_strides[i] / last_step)
last_step *= old_shape[i]
@@ -366,7 +366,7 @@
if oldI < len(old_shape):
cur_step = steps[oldI]
n_old_elems_to_use *= old_shape[oldI]
- elif order == 'C':
+ else:
for i in range(len(old_shape) - 1, -1, -1):
steps.insert(0, old_strides[i] / last_step)
last_step *= old_shape[i]
diff --git a/pypy/module/micronumpy/support.py b/pypy/module/micronumpy/support.py
--- a/pypy/module/micronumpy/support.py
+++ b/pypy/module/micronumpy/support.py
@@ -7,6 +7,7 @@
from pypy.interpreter.typedef import GetSetProperty
from pypy.objspace.std.typeobject import W_TypeObject
from pypy.objspace.std.objspace import StdObjSpace
+from pypy.module.micronumpy import constants as NPY
def issequence_w(space, w_obj):
from pypy.module.micronumpy.base import W_NDimArray
@@ -176,15 +177,11 @@
return space.is_true(space.gt(w_priority_r, w_priority_l))
def get_order_as_CF(proto_order, req_order):
- if req_order == 'C':
- return 'C'
- elif req_order == 'F':
- return 'F'
- elif req_order == 'K':
- return proto_order
- elif req_order == 'A':
- return proto_order
-
+ if req_order == NPY.CORDER:
+ return NPY.CORDER
+ elif req_order == NPY.FORTRANORDER:
+ return NPY.FORTRANORDER
+ return proto_order
def descr_set_docstring(space, w_obj, w_docstring):
if not isinstance(space, StdObjSpace):
diff --git a/pypy/module/micronumpy/test/test_ndarray.py b/pypy/module/micronumpy/test/test_ndarray.py
--- a/pypy/module/micronumpy/test/test_ndarray.py
+++ b/pypy/module/micronumpy/test/test_ndarray.py
@@ -6,6 +6,7 @@
from pypy.module.micronumpy.appbridge import get_appbridge_cache
from pypy.module.micronumpy.strides import Chunk, new_view, EllipsisChunk
from pypy.module.micronumpy.ndarray import W_NDimArray
+import pypy.module.micronumpy.constants as NPY
from pypy.module.micronumpy.test.test_base import BaseNumpyAppTest
@@ -45,20 +46,20 @@
return self.space.newtuple(args_w)
def test_strides_f(self):
- a = create_array(self.space, [10, 5, 3], MockDtype(), order='F')
+ a = create_array(self.space, [10, 5, 3], MockDtype(), order=NPY.FORTRANORDER)
assert a.strides == [1, 10, 50]
assert a.backstrides == [9, 40, 100]
def test_strides_c(self):
- a = create_array(self.space, [10, 5, 3], MockDtype(), order='C')
+ a = create_array(self.space, [10, 5, 3], MockDtype(), order=NPY.CORDER)
assert a.strides == [15, 3, 1]
assert a.backstrides == [135, 12, 2]
- a = create_array(self.space, [1, 0, 7], MockDtype(), order='C')
+ a = create_array(self.space, [1, 0, 7], MockDtype(), order=NPY.CORDER)
assert a.strides == [7, 7, 1]
assert a.backstrides == [0, 0, 6]
def test_create_slice_f(self):
- a = create_array(self.space, [10, 5, 3], MockDtype(), order='F')
+ a = create_array(self.space, [10, 5, 3], MockDtype(), order=NPY.FORTRANORDER)
s = create_slice(self.space, a, [Chunk(3, 0, 0, 1)])
assert s.start == 3
assert s.strides == [10, 50]
@@ -77,7 +78,7 @@
assert s.shape == [10, 3]
def test_create_slice_c(self):
- a = create_array(self.space, [10, 5, 3], MockDtype(), order='C')
+ a = create_array(self.space, [10, 5, 3], MockDtype(), order=NPY.CORDER)
s = create_slice(self.space, a, [Chunk(3, 0, 0, 1)])
assert s.start == 45
assert s.strides == [3, 1]
@@ -97,7 +98,7 @@
assert s.shape == [10, 3]
def test_slice_of_slice_f(self):
- a = create_array(self.space, [10, 5, 3], MockDtype(), order='F')
+ a = create_array(self.space, [10, 5, 3], MockDtype(), order=NPY.FORTRANORDER)
s = create_slice(self.space, a, [Chunk(5, 0, 0, 1)])
assert s.start == 5
s2 = create_slice(self.space, s, [Chunk(3, 0, 0, 1)])
@@ -114,7 +115,7 @@
assert s2.start == 1 * 15 + 2 * 3
def test_slice_of_slice_c(self):
- a = create_array(self.space, [10, 5, 3], MockDtype(), order='C')
+ a = create_array(self.space, [10, 5, 3], MockDtype(), order=NPY.CORDER)
s = create_slice(self.space, a, [Chunk(5, 0, 0, 1)])
assert s.start == 15 * 5
s2 = create_slice(self.space, s, [Chunk(3, 0, 0, 1)])
@@ -131,14 +132,14 @@
assert s2.start == 1 * 15 + 2 * 3
def test_negative_step_f(self):
- a = create_array(self.space, [10, 5, 3], MockDtype(), order='F')
+ a = create_array(self.space, [10, 5, 3], MockDtype(), order=NPY.FORTRANORDER)
s = create_slice(self.space, a, [Chunk(9, -1, -2, 5)])
assert s.start == 9
assert s.strides == [-2, 10, 50]
assert s.backstrides == [-8, 40, 100]
def test_negative_step_c(self):
- a = create_array(self.space, [10, 5, 3], MockDtype(), order='C')
+ a = create_array(self.space, [10, 5, 3], MockDtype(), order=NPY.CORDER)
s = create_slice(self.space, a, [Chunk(9, -1, -2, 5)])
assert s.start == 135
assert s.strides == [-30, 3, 1]
@@ -155,17 +156,17 @@
def test_calc_new_strides(self):
from pypy.module.micronumpy.strides import calc_new_strides
- assert calc_new_strides([2, 4], [4, 2], [4, 2], "C") == [8, 2]
- assert calc_new_strides([2, 4, 3], [8, 3], [1, 16], 'F') == [1, 2, 16]
- assert calc_new_strides([2, 3, 4], [8, 3], [1, 16], 'F') is None
- assert calc_new_strides([24], [2, 4, 3], [48, 6, 1], 'C') is None
- assert calc_new_strides([24], [2, 4, 3], [24, 6, 2], 'C') == [2]
- assert calc_new_strides([105, 1], [3, 5, 7], [35, 7, 1],'C') == [1, 1]
- assert calc_new_strides([1, 105], [3, 5, 7], [35, 7, 1],'C') == [105, 1]
- assert calc_new_strides([1, 105], [3, 5, 7], [35, 7, 1],'F') is None
- assert calc_new_strides([1, 1, 1, 105, 1], [15, 7], [7, 1],'C') == \
+ assert calc_new_strides([2, 4], [4, 2], [4, 2], NPY.CORDER) == [8, 2]
+ assert calc_new_strides([2, 4, 3], [8, 3], [1, 16], NPY.FORTRANORDER) == [1, 2, 16]
+ assert calc_new_strides([2, 3, 4], [8, 3], [1, 16], NPY.FORTRANORDER) is None
+ assert calc_new_strides([24], [2, 4, 3], [48, 6, 1], NPY.CORDER) is None
+ assert calc_new_strides([24], [2, 4, 3], [24, 6, 2], NPY.CORDER) == [2]
+ assert calc_new_strides([105, 1], [3, 5, 7], [35, 7, 1],NPY.CORDER) == [1, 1]
+ assert calc_new_strides([1, 105], [3, 5, 7], [35, 7, 1],NPY.CORDER) == [105, 1]
+ assert calc_new_strides([1, 105], [3, 5, 7], [35, 7, 1],NPY.FORTRANORDER) is None
+ assert calc_new_strides([1, 1, 1, 105, 1], [15, 7], [7, 1],NPY.CORDER) == \
[105, 105, 105, 1, 1]
- assert calc_new_strides([1, 1, 105, 1, 1], [7, 15], [1, 7],'F') == \
+ assert calc_new_strides([1, 1, 105, 1, 1], [7, 15], [1, 7],NPY.FORTRANORDER) == \
[1, 1, 1, 105, 105]
def test_find_shape(self):
@@ -444,6 +445,8 @@
b = np.empty_like(A((2, 3)), subok=False)
assert b.shape == (2, 3)
assert type(b) is np.ndarray
+ b = np.empty_like(np.array(3.0), order='A')
+ assert type(b) is np.ndarray
def test_size(self):
from numpy import array,arange,cos
@@ -534,10 +537,10 @@
assert (b == a).all()
b = a.copy(order='A')
assert (b == a).all()
- import sys
- if '__pypy__' in sys.builtin_module_names:
- raises(NotImplementedError, a.copy, order='F')
- raises(NotImplementedError, a.copy, order=True)
+ b = a.copy(order='F')
+ assert (b == a).all()
+ b = a.copy(order=True)
+ assert (b == a).all()
def test_iterator_init(self):
from numpy import array
@@ -918,9 +921,11 @@
assert a.reshape((0,), order='A').shape == (0,)
raises(TypeError, a.reshape, (0,), badarg="C")
raises(ValueError, a.reshape, (0,), order="K")
- import sys
- if '__pypy__' in sys.builtin_module_names:
- raises(NotImplementedError, a.reshape, (0,), order='F')
+ b = a.reshape((0,), order='F')
+ assert b.shape == (0,)
+ a = array(range(24), 'uint8')
+ assert a.reshape([2, 3, 4], order=True).strides ==(1, 2, 6)
+ assert a.reshape([2, 3, 4], order=False).strides ==(12, 4, 1)
def test_slice_reshape(self):
from numpy import zeros, arange
@@ -2676,11 +2681,11 @@
assert a[1][2][1] == 15
def test_create_order(self):
- import sys, numpy as np
+ import numpy as np
for order in [False, True, 'C', 'F']:
a = np.empty((2, 3), float, order=order)
assert a.shape == (2, 3)
- if order in [True, 'F'] and '__pypy__' not in sys.builtin_module_names:
+ if order in [True, 'F']:
assert a.flags['F']
assert not a.flags['C']
else:
@@ -3577,10 +3582,7 @@
assert a.tostring(order) == '\x01\x02\x03\x04'
import sys
for order in (True, 'F'):
- if '__pypy__' in sys.builtin_module_names:
- raises(NotImplementedError, a.tostring, order)
- else:
- assert a.tostring(order) == '\x01\x03\x02\x04'
+ assert a.tostring(order) == '\x01\x03\x02\x04'
assert array(2.2-1.1j, dtype='>c16').tostring() == \
'@\x01\x99\x99\x99\x99\x99\x9a\xbf\xf1\x99\x99\x99\x99\x99\x9a'
assert array(2.2-1.1j, dtype='<c16').tostring() == \
diff --git a/pypy/module/micronumpy/test/test_nditer.py b/pypy/module/micronumpy/test/test_nditer.py
--- a/pypy/module/micronumpy/test/test_nditer.py
+++ b/pypy/module/micronumpy/test/test_nditer.py
@@ -114,14 +114,11 @@
from numpy import nditer, array
a = array([[1, 2], [3, 4]], order="C")
- try:
- b = array([[1, 2], [3, 4]], order="F")
- except (NotImplementedError, ValueError):
- skip('Fortran order not implemented')
+ b = array([[1, 2], [3, 4]], order="F")
it = nditer([a, b])
-
- assert list(it) == zip(range(1, 5), range(1, 5))
+ r = list(it)
+ assert r == zip(range(1, 5), range(1, 5))
def test_interface(self):
from numpy import arange, nditer, zeros
@@ -161,11 +158,7 @@
assert r[0][0] == 100
r = []
- try:
- it = nditer(a, flags=['buffered'], order='F')
- except NotImplementedError as e:
- assert 'unsupported value for order' in str(e)
- skip('buffered with order="F" requires fortran tmp array creation')
+ it = nditer(a, flags=['buffered'], order='F')
for x in it:
r.append(x)
array_r = array(r)
diff --git a/pypy/module/micronumpy/ufuncs.py b/pypy/module/micronumpy/ufuncs.py
--- a/pypy/module/micronumpy/ufuncs.py
+++ b/pypy/module/micronumpy/ufuncs.py
@@ -668,9 +668,9 @@
for dt_in, dt_out in self.dtypes:
if can_cast_to(dtype, dt_in) and dt_out == dt_in:
return dt_in
- raise ValueError(
+ raise oefmt(space.w_ValueError,
"could not find a matching type for %s.accumulate, "
- "requested type has type code '%s'" % (self.name, dtype.char))
+ "requested type has type code '%s'", self.name, dtype.char)
@jit.unroll_safe
diff --git a/pypy/module/sys/vm.py b/pypy/module/sys/vm.py
--- a/pypy/module/sys/vm.py
+++ b/pypy/module/sys/vm.py
@@ -57,8 +57,7 @@
raise OperationError(space.w_ValueError,
space.wrap("recursion limit must be positive"))
space.sys.recursionlimit = new_limit
- if space.config.translation.type_system == 'lltype':
- _stack_set_length_fraction(new_limit * 0.001)
+ _stack_set_length_fraction(new_limit * 0.001)
def getrecursionlimit(space):
"""Return the last value set by setrecursionlimit().
diff --git a/pypy/module/test_lib_pypy/cffi_tests/cffi0/test_ffi_backend.py b/pypy/module/test_lib_pypy/cffi_tests/cffi0/test_ffi_backend.py
--- a/pypy/module/test_lib_pypy/cffi_tests/cffi0/test_ffi_backend.py
+++ b/pypy/module/test_lib_pypy/cffi_tests/cffi0/test_ffi_backend.py
@@ -314,6 +314,59 @@
ffi.cast("unsigned short *", c)[1] += 500
assert list(a) == [10000, 20500, 30000]
+ def test_memmove(self):
+ ffi = FFI()
+ p = ffi.new("short[]", [-1234, -2345, -3456, -4567, -5678])
+ ffi.memmove(p, p + 1, 4)
+ assert list(p) == [-2345, -3456, -3456, -4567, -5678]
+ p[2] = 999
+ ffi.memmove(p + 2, p, 6)
+ assert list(p) == [-2345, -3456, -2345, -3456, 999]
+ ffi.memmove(p + 4, ffi.new("char[]", b"\x71\x72"), 2)
+ if sys.byteorder == 'little':
+ assert list(p) == [-2345, -3456, -2345, -3456, 0x7271]
+ else:
+ assert list(p) == [-2345, -3456, -2345, -3456, 0x7172]
+
+ def test_memmove_buffer(self):
+ import array
+ ffi = FFI()
+ a = array.array('H', [10000, 20000, 30000])
+ p = ffi.new("short[]", 5)
+ ffi.memmove(p, a, 6)
+ assert list(p) == [10000, 20000, 30000, 0, 0]
+ ffi.memmove(p + 1, a, 6)
+ assert list(p) == [10000, 10000, 20000, 30000, 0]
+ b = array.array('h', [-1000, -2000, -3000])
+ ffi.memmove(b, a, 4)
+ assert b.tolist() == [10000, 20000, -3000]
+ assert a.tolist() == [10000, 20000, 30000]
+ p[0] = 999
+ p[1] = 998
+ p[2] = 997
+ p[3] = 996
+ p[4] = 995
+ ffi.memmove(b, p, 2)
+ assert b.tolist() == [999, 20000, -3000]
+ ffi.memmove(b, p + 2, 4)
+ assert b.tolist() == [997, 996, -3000]
+ p[2] = -p[2]
+ p[3] = -p[3]
+ ffi.memmove(b, p + 2, 6)
+ assert b.tolist() == [-997, -996, 995]
+
+ def test_memmove_readonly_readwrite(self):
+ ffi = FFI()
+ p = ffi.new("signed char[]", 5)
+ ffi.memmove(p, b"abcde", 3)
+ assert list(p) == [ord("a"), ord("b"), ord("c"), 0, 0]
+ ffi.memmove(p, bytearray(b"ABCDE"), 2)
+ assert list(p) == [ord("A"), ord("B"), ord("c"), 0, 0]
+ py.test.raises((TypeError, BufferError), ffi.memmove, b"abcde", p, 3)
+ ba = bytearray(b"xxxxx")
+ ffi.memmove(dest=ba, src=p, n=3)
+ assert ba == bytearray(b"ABcxx")
+
def test_all_primitives(self):
ffi = FFI()
for name in [
diff --git a/pypy/module/test_lib_pypy/cffi_tests/cffi0/test_verify.py b/pypy/module/test_lib_pypy/cffi_tests/cffi0/test_verify.py
--- a/pypy/module/test_lib_pypy/cffi_tests/cffi0/test_verify.py
+++ b/pypy/module/test_lib_pypy/cffi_tests/cffi0/test_verify.py
@@ -2276,16 +2276,16 @@
@ffi.callback("int __stdcall(int)")
def cb2(x):
return x * 3
- print 'cb1 =', cb1
+ #print 'cb1 =', cb1
res = lib.call1(cb1)
assert res == 500*999*2
- print 'cb2 =', cb2
- print ffi.typeof(lib.call2)
- print 'call2 =', lib.call2
+ #print 'cb2 =', cb2
+ #print ffi.typeof(lib.call2)
+ #print 'call2 =', lib.call2
res = lib.call2(cb2)
- print '...'
+ #print '...'
assert res == -500*999*3
- print 'done'
+ #print 'done'
if sys.platform == 'win32':
assert '__stdcall' in str(ffi.typeof(cb2))
assert '__stdcall' not in str(ffi.typeof(cb1))
diff --git a/pypy/module/test_lib_pypy/cffi_tests/cffi1/test_ffi_obj.py b/pypy/module/test_lib_pypy/cffi_tests/cffi1/test_ffi_obj.py
--- a/pypy/module/test_lib_pypy/cffi_tests/cffi1/test_ffi_obj.py
+++ b/pypy/module/test_lib_pypy/cffi_tests/cffi1/test_ffi_obj.py
@@ -237,6 +237,59 @@
ffi.cast("unsigned short *", c)[1] += 500
assert list(a) == [10000, 20500, 30000]
+def test_memmove():
+ ffi = _cffi1_backend.FFI()
+ p = ffi.new("short[]", [-1234, -2345, -3456, -4567, -5678])
+ ffi.memmove(p, p + 1, 4)
+ assert list(p) == [-2345, -3456, -3456, -4567, -5678]
+ p[2] = 999
+ ffi.memmove(p + 2, p, 6)
+ assert list(p) == [-2345, -3456, -2345, -3456, 999]
+ ffi.memmove(p + 4, ffi.new("char[]", b"\x71\x72"), 2)
+ if sys.byteorder == 'little':
+ assert list(p) == [-2345, -3456, -2345, -3456, 0x7271]
+ else:
+ assert list(p) == [-2345, -3456, -2345, -3456, 0x7172]
+
+def test_memmove_buffer():
+ import array
+ ffi = _cffi1_backend.FFI()
+ a = array.array('H', [10000, 20000, 30000])
+ p = ffi.new("short[]", 5)
+ ffi.memmove(p, a, 6)
+ assert list(p) == [10000, 20000, 30000, 0, 0]
+ ffi.memmove(p + 1, a, 6)
+ assert list(p) == [10000, 10000, 20000, 30000, 0]
+ b = array.array('h', [-1000, -2000, -3000])
+ ffi.memmove(b, a, 4)
+ assert b.tolist() == [10000, 20000, -3000]
+ assert a.tolist() == [10000, 20000, 30000]
+ p[0] = 999
+ p[1] = 998
+ p[2] = 997
+ p[3] = 996
+ p[4] = 995
+ ffi.memmove(b, p, 2)
+ assert b.tolist() == [999, 20000, -3000]
+ ffi.memmove(b, p + 2, 4)
+ assert b.tolist() == [997, 996, -3000]
+ p[2] = -p[2]
+ p[3] = -p[3]
+ ffi.memmove(b, p + 2, 6)
+ assert b.tolist() == [-997, -996, 995]
+
+def test_memmove_readonly_readwrite():
+ ffi = _cffi1_backend.FFI()
+ p = ffi.new("signed char[]", 5)
+ ffi.memmove(p, b"abcde", 3)
+ assert list(p) == [ord("a"), ord("b"), ord("c"), 0, 0]
+ ffi.memmove(p, bytearray(b"ABCDE"), 2)
+ assert list(p) == [ord("A"), ord("B"), ord("c"), 0, 0]
+ py.test.raises((TypeError, BufferError), ffi.memmove, b"abcde", p, 3)
+ ba = bytearray(b"xxxxx")
+ ffi.memmove(dest=ba, src=p, n=3)
+ assert ba == bytearray(b"ABcxx")
+
def test_ffi_types():
CData = _cffi1_backend.FFI.CData
CType = _cffi1_backend.FFI.CType
diff --git a/pypy/module/test_lib_pypy/cffi_tests/cffi1/test_recompiler.py b/pypy/module/test_lib_pypy/cffi_tests/cffi1/test_recompiler.py
--- a/pypy/module/test_lib_pypy/cffi_tests/cffi1/test_recompiler.py
+++ b/pypy/module/test_lib_pypy/cffi_tests/cffi1/test_recompiler.py
@@ -1365,15 +1365,15 @@
return result;
}
""")
- print '<<< cb1 =', ffi.addressof(lib, 'cb1')
+ #print '<<< cb1 =', ffi.addressof(lib, 'cb1')
ptr_call1 = ffi.addressof(lib, 'call1')
assert lib.call1(ffi.addressof(lib, 'cb1')) == 500*999*2
assert ptr_call1(ffi.addressof(lib, 'cb1')) == 500*999*2
- print '<<< cb2 =', ffi.addressof(lib, 'cb2')
+ #print '<<< cb2 =', ffi.addressof(lib, 'cb2')
ptr_call2 = ffi.addressof(lib, 'call2')
assert lib.call2(ffi.addressof(lib, 'cb2')) == -500*999*3
assert ptr_call2(ffi.addressof(lib, 'cb2')) == -500*999*3
- print '<<< done'
+ #print '<<< done'
def test_win32_calling_convention_2():
# any mistake in the declaration of plain function (including the
diff --git a/pypy/objspace/fake/objspace.py b/pypy/objspace/fake/objspace.py
--- a/pypy/objspace/fake/objspace.py
+++ b/pypy/objspace/fake/objspace.py
@@ -318,6 +318,9 @@
def unicode_from_object(self, w_obj):
return w_some_obj()
+ def _try_fetch_pycode(self, w_func):
+ return None
+
# ----------
def translates(self, func=None, argtypes=None, seeobj_w=[], **kwds):
diff --git a/pypy/tool/pypyjit.py b/pypy/tool/pypyjit.py
--- a/pypy/tool/pypyjit.py
+++ b/pypy/tool/pypyjit.py
@@ -93,7 +93,6 @@
try:
interp, graph = get_interpreter(entry_point, [], backendopt=False,
config=config,
- type_system=config.translation.type_system,
policy=PyPyAnnotatorPolicy(space))
except Exception, e:
print '%s: %s' % (e.__class__, e)
diff --git a/rpython/annotator/annrpython.py b/rpython/annotator/annrpython.py
--- a/rpython/annotator/annrpython.py
+++ b/rpython/annotator/annrpython.py
@@ -79,14 +79,11 @@
annmodel.TLS.check_str_without_nul = (
self.translator.config.translation.check_str_without_nul)
- flowgraph, inputcells = self.get_call_parameters(function, args_s, policy)
- if not isinstance(flowgraph, FunctionGraph):
- assert isinstance(flowgraph, annmodel.SomeObject)
- return flowgraph
+ flowgraph, inputs_s = self.get_call_parameters(function, args_s, policy)
if main_entry_point:
self.translator.entry_point_graph = flowgraph
- return self.build_graph_types(flowgraph, inputcells, complete_now=complete_now)
+ return self.build_graph_types(flowgraph, inputs_s, complete_now=complete_now)
def get_call_parameters(self, function, args_s, policy):
desc = self.bookkeeper.getdesc(function)
@@ -213,8 +210,6 @@
v = graph.getreturnvar()
if v.annotation is None:
self.setbinding(v, annmodel.s_ImpossibleValue)
- # policy-dependent computation
- self.bookkeeper.compute_at_fixpoint()
def validate(self):
"""Check that the annotation results are valid"""
@@ -292,6 +287,18 @@
graph, block, index = position_key
self.reflowpendingblock(graph, block)
+ def call_sites(self):
+ newblocks = self.added_blocks
+ if newblocks is None:
+ newblocks = self.annotated # all of them
+ for block in newblocks:
+ for op in block.operations:
+ if op.opname in ('simple_call', 'call_args'):
+ yield op
+
+ # some blocks are partially annotated
+ if op.result.annotation is None:
+ break # ignore the unannotated part
#___ simplification (should be moved elsewhere?) _______
@@ -309,6 +316,7 @@
graphs[graph] = True
for graph in graphs:
simplify.eliminate_empty_blocks(graph)
+ self.bookkeeper.compute_at_fixpoint()
if block_subset is None:
perform_normalizations(self)
@@ -396,8 +404,7 @@
i = 0
while i < len(block.operations):
op = block.operations[i]
- self.bookkeeper.enter((graph, block, i))
- try:
+ with self.bookkeeper.at_position((graph, block, i)):
new_ops = op.transform(self)
if new_ops is not None:
block.operations[i:i+1] = new_ops
@@ -406,8 +413,6 @@
new_ops[-1].result = op.result
op = new_ops[0]
self.consider_op(op)
- finally:
- self.bookkeeper.leave()
i += 1
except BlockedInference as e:
diff --git a/rpython/annotator/bookkeeper.py b/rpython/annotator/bookkeeper.py
--- a/rpython/annotator/bookkeeper.py
+++ b/rpython/annotator/bookkeeper.py
@@ -5,6 +5,7 @@
from __future__ import absolute_import
import sys, types, inspect, weakref
+from contextlib import contextmanager
from rpython.flowspace.model import Constant
from rpython.annotator.model import (SomeOrderedDict,
@@ -88,34 +89,29 @@
del TLS.bookkeeper
del self.position_key
+ @contextmanager
+ def at_position(self, pos):
+ """A context manager calling `self.enter()` and `self.leave()`"""
+ if hasattr(self, 'position_key') and pos is None:
+ yield
+ return
+ self.enter(pos)
+ try:
+ yield
+ finally:
+ self.leave()
+
def compute_at_fixpoint(self):
# getbookkeeper() needs to work during this function, so provide
# one with a dummy position
- self.enter(None)
- try:
- def call_sites():
- newblocks = self.annotator.added_blocks
- if newblocks is None:
- newblocks = self.annotator.annotated # all of them
- annotation = self.annotator.annotation
- for block in newblocks:
- for op in block.operations:
- if op.opname in ('simple_call', 'call_args'):
- yield op
-
- # some blocks are partially annotated
- if annotation(op.result) is None:
- break # ignore the unannotated part
-
- for call_op in call_sites():
+ with self.at_position(None):
+ for call_op in self.annotator.call_sites():
self.consider_call_site(call_op)
for pbc, args_s in self.emulated_pbc_calls.itervalues():
args = simple_args(args_s)
pbc.consider_call_site(args, s_ImpossibleValue, None)
self.emulated_pbc_calls = {}
- finally:
- self.leave()
def check_no_flags_on_instances(self):
# sanity check: no flags attached to heap stored instances
@@ -501,10 +497,6 @@
"""Analyse a call to a SomePBC() with the given args (list of
annotations).
"""
- descs = list(pbc.descriptions)
- first = descs[0]
- first.mergecallfamilies(*descs[1:])
-
if emulated is None:
whence = self.position_key
More information about the pypy-commit
mailing list