[pypy-commit] pypy py3tests: hg merge py3.5
rlamy
pypy.commits at gmail.com
Thu Nov 8 13:45:44 EST 2018
Author: Ronan Lamy <ronan.lamy at gmail.com>
Branch: py3tests
Changeset: r95282:e018b8a5f031
Date: 2018-11-07 16:47 +0000
http://bitbucket.org/pypy/pypy/changeset/e018b8a5f031/
Log: hg merge py3.5
diff too long, truncating to 2000 out of 6925 lines
diff --git a/README.rst b/README.rst
--- a/README.rst
+++ b/README.rst
@@ -4,7 +4,7 @@
Welcome to PyPy!
-PyPy is an interperter that implements the Python programming language, based
+PyPy is an interpreter that implements the Python programming language, based
on the RPython compiler framework for dynamic language implementations.
The home page for the interpreter is:
@@ -15,29 +15,29 @@
http://doc.pypy.org/
-More documentation about the RPython framework can be found here
+More documentation about the RPython framework can be found here:
- http://rpython.readthedocs.io
+ http://rpython.readthedocs.io/
-The source for the documentation is in the pypy/doc directory
+The source for the documentation is in the pypy/doc directory.
+
Using PyPy instead of CPython
-=============================
+-----------------------------
-Please read the information at http://pypy.org to find the correct way to
+Please read the information at http://pypy.org/ to find the correct way to
download and use PyPy as an alternative to CPython.
+
Building
-========
+--------
Building PyPy is not the recommended way to obtain the PyPy alternative python
interpreter. It is time-consuming and requires significant computing resources.
-More information can be found here
+More information can be found here:
http://doc.pypy.org/en/latest/build.html
Enjoy and send us feedback!
the pypy-dev team <pypy-dev at python.org>
-
-
diff --git a/lib-python/3/distutils/sysconfig_pypy.py b/lib-python/3/distutils/sysconfig_pypy.py
--- a/lib-python/3/distutils/sysconfig_pypy.py
+++ b/lib-python/3/distutils/sysconfig_pypy.py
@@ -8,11 +8,9 @@
available.
"""
-__revision__ = "$Id: sysconfig.py 85358 2010-10-10 09:54:59Z antoine.pitrou $"
-
import sys
import os
-import imp
+import imp, _imp
from distutils.errors import DistutilsPlatformError
@@ -71,9 +69,17 @@
def _init_nt():
"""Initialize the module as appropriate for NT"""
g = {}
+ # set basic install directories
+ g['LIBDEST'] = get_python_lib(plat_specific=0, standard_lib=1)
+ g['BINLIBDEST'] = get_python_lib(plat_specific=1, standard_lib=1)
+
+ # XXX hmmm.. a normal install puts include files here
+ g['INCLUDEPY'] = get_python_inc(plat_specific=0)
+
+ g['EXT_SUFFIX'] = _imp.extension_suffixes()[0]
g['EXE'] = ".exe"
- g['SO'] = ".pyd"
- g['SOABI'] = g['SO'].rsplit('.')[0] # xxx?
+ g['VERSION'] = get_python_version().replace(".", "")
+ g['BINDIR'] = os.path.dirname(os.path.abspath(sys.executable))
global _config_vars
_config_vars = g
diff --git a/lib-python/3/test/test_inspect.py b/lib-python/3/test/test_inspect.py
--- a/lib-python/3/test/test_inspect.py
+++ b/lib-python/3/test/test_inspect.py
@@ -61,6 +61,9 @@
git = mod.StupidGit()
+class ExampleClassWithSlot(object):
+ __slots__ = 'myslot'
+
class IsTestBase(unittest.TestCase):
predicates = set([inspect.isbuiltin, inspect.isclass, inspect.iscode,
inspect.isframe, inspect.isfunction, inspect.ismethod,
@@ -131,8 +134,11 @@
self.istest(inspect.iscoroutinefunction, 'coroutine_function_example')
if hasattr(types, 'MemberDescriptorType'):
- self.istest(inspect.ismemberdescriptor,
- 'type(lambda: None).__globals__')
+ # App-level slots are member descriptors on both PyPy and
+ # CPython, but the various built-in attributes are all
+ # getsetdescriptors on PyPy. So check ismemberdescriptor()
+ # with an app-level slot.
+ self.istest(inspect.ismemberdescriptor, 'ExampleClassWithSlot.myslot')
else:
self.assertFalse(inspect.ismemberdescriptor(datetime.timedelta.days))
diff --git a/lib-python/3/types.py b/lib-python/3/types.py
--- a/lib-python/3/types.py
+++ b/lib-python/3/types.py
@@ -41,9 +41,19 @@
FrameType = type(tb.tb_frame)
tb = None; del tb
-# For Jython, the following two types are identical
+#
+# On CPython, FunctionType.__code__ is a 'getset_descriptor', but
+# FunctionType.__globals__ is a 'member_descriptor', just like app-level
+# slots. On PyPy, all descriptors of built-in types are
+# 'getset_descriptor', but the app-level slots are 'member_descriptor'
+# as well. (On Jython the situation might still be different.)
+#
+# Note that MemberDescriptorType was equal to GetSetDescriptorType in
+# PyPy <= 6.0.
+#
GetSetDescriptorType = type(FunctionType.__code__)
-MemberDescriptorType = type(FunctionType.__globals__)
+class _C: __slots__ = 's'
+MemberDescriptorType = type(_C.s)
del sys, _f, _g, _C, _c, # Not for export
diff --git a/lib_pypy/_cffi_ssl/_stdssl/__init__.py b/lib_pypy/_cffi_ssl/_stdssl/__init__.py
--- a/lib_pypy/_cffi_ssl/_stdssl/__init__.py
+++ b/lib_pypy/_cffi_ssl/_stdssl/__init__.py
@@ -186,7 +186,7 @@
# Prefer poll, if available, since you can poll() any fd
# which can't be done with select().
if HAVE_POLL:
- p.register(sock.fileno(), POLLOUT | POLLIN)
+ p.register(sock.fileno(), POLLOUT if writing else POLLIN)
rc = len(p.poll(timeout * 1000.0))
else:
diff --git a/lib_pypy/_ctypes/array.py b/lib_pypy/_ctypes/array.py
--- a/lib_pypy/_ctypes/array.py
+++ b/lib_pypy/_ctypes/array.py
@@ -189,6 +189,7 @@
self._buffer = self._ffiarray(self._length_, autofree=True)
for i, arg in enumerate(args):
self[i] = arg
+ _init_no_arg_ = __init__
def _fix_index(self, index):
if index < 0:
diff --git a/lib_pypy/_ctypes/basics.py b/lib_pypy/_ctypes/basics.py
--- a/lib_pypy/_ctypes/basics.py
+++ b/lib_pypy/_ctypes/basics.py
@@ -110,7 +110,7 @@
raise ValueError(
"Buffer size too small (%d instead of at least %d bytes)"
% (buf.nbytes, offset + size))
- result = self()
+ result = self._newowninstance_()
dest = result._buffer.buffer
try:
raw_addr = buf._pypy_raw_address() + offset
@@ -121,6 +121,11 @@
memmove(dest, raw_addr, size)
return result
+ def _newowninstance_(self):
+ result = self.__new__(self)
+ result._init_no_arg_()
+ return result
+
class CArgObject(object):
""" simple wrapper around buffer, just for the case of freeing
@@ -151,6 +156,7 @@
def __init__(self, *args, **kwds):
raise TypeError("%s has no type" % (type(self),))
+ _init_no_arg_ = __init__
def _ensure_objects(self):
if '_objects' not in self.__dict__:
diff --git a/lib_pypy/_ctypes/function.py b/lib_pypy/_ctypes/function.py
--- a/lib_pypy/_ctypes/function.py
+++ b/lib_pypy/_ctypes/function.py
@@ -267,6 +267,7 @@
return
raise TypeError("Unknown constructor %s" % (args,))
+ _init_no_arg_ = __init__
def _wrap_callable(self, to_call, argtypes):
def f(*args):
@@ -485,6 +486,8 @@
return cobj, cobj._to_ffi_param(), type(cobj)
def _convert_args_for_callback(self, argtypes, args):
+ from _ctypes.structure import StructOrUnion
+ #
assert len(argtypes) == len(args)
newargs = []
for argtype, arg in zip(argtypes, args):
@@ -494,6 +497,10 @@
param = param._get_buffer_value()
elif self._is_primitive(argtype):
param = param.value
+ elif isinstance(param, StructOrUnion): # not a *pointer* to struct
+ newparam = StructOrUnion.__new__(type(param))
+ param._copy_to(newparam._buffer.buffer)
+ param = newparam
newargs.append(param)
return newargs
@@ -557,7 +564,7 @@
keepalive, newarg, newargtype = self._conv_param(argtype, defval)
else:
import ctypes
- val = argtype._type_()
+ val = argtype._type_._newowninstance_()
keepalive = None
newarg = ctypes.byref(val)
newargtype = type(newarg)
diff --git a/lib_pypy/_ctypes/pointer.py b/lib_pypy/_ctypes/pointer.py
--- a/lib_pypy/_ctypes/pointer.py
+++ b/lib_pypy/_ctypes/pointer.py
@@ -67,8 +67,11 @@
self._buffer = ffiarray(1, autofree=True)
if value is not None:
self.contents = value
+ def _init_no_arg_(self):
+ self._buffer = ffiarray(1, autofree=True)
self._ffiarray = ffiarray
self.__init__ = __init__
+ self._init_no_arg_ = _init_no_arg_
self._type_ = TP
def _build_ffiargtype(self):
@@ -136,27 +139,21 @@
if not (isinstance(tp, _CDataMeta) and tp._is_pointer_like()):
raise TypeError("cast() argument 2 must be a pointer type, not %s"
% (tp,))
+ result = tp._newowninstance_()
if isinstance(obj, int):
- result = tp()
result._buffer[0] = obj
return result
elif obj is None:
- result = tp()
return result
elif isinstance(obj, Array):
- ptr = tp.__new__(tp)
- ptr._buffer = tp._ffiarray(1, autofree=True)
- ptr._buffer[0] = obj._buffer
- result = ptr
+ result._buffer[0] = obj._buffer
elif isinstance(obj, bytes):
- result = tp()
result._buffer[0] = memoryview(obj)._pypy_raw_address()
return result
elif not (isinstance(obj, _CData) and type(obj)._is_pointer_like()):
raise TypeError("cast() argument 1 must be a pointer, not %s"
% (type(obj),))
else:
- result = tp()
result._buffer[0] = obj._buffer[0]
# The casted objects '_objects' member:
diff --git a/lib_pypy/_ctypes/primitive.py b/lib_pypy/_ctypes/primitive.py
--- a/lib_pypy/_ctypes/primitive.py
+++ b/lib_pypy/_ctypes/primitive.py
@@ -378,11 +378,14 @@
self._buffer = self._ffiarray(1, autofree=True)
if value is not DEFAULT_VALUE:
self.value = value
+ _init_no_arg_ = __init__
def _ensure_objects(self):
- if self._type_ not in 'zZP':
- assert self._objects is None
- return self._objects
+ # No '_objects' is the common case for primitives. Examples
+ # where there is an _objects is if _type in 'zZP', or if
+ # self comes from 'from_buffer(buf)'. See module/test_lib_pypy/
+ # ctypes_test/test_buffers.py: test_from_buffer_keepalive.
+ return getattr(self, '_objects', None)
def _getvalue(self):
return self._buffer[0]
diff --git a/lib_pypy/_ctypes/structure.py b/lib_pypy/_ctypes/structure.py
--- a/lib_pypy/_ctypes/structure.py
+++ b/lib_pypy/_ctypes/structure.py
@@ -280,6 +280,7 @@
self.__setattr__(name, arg)
for name, arg in kwds.items():
self.__setattr__(name, arg)
+ _init_no_arg_ = __init__
def _subarray(self, fieldtype, name):
"""Return a _rawffi array of length 1 whose address is the same as
diff --git a/lib_pypy/cffi/_cffi_errors.h b/lib_pypy/cffi/_cffi_errors.h
--- a/lib_pypy/cffi/_cffi_errors.h
+++ b/lib_pypy/cffi/_cffi_errors.h
@@ -50,7 +50,9 @@
"import sys\n"
"class FileLike:\n"
" def write(self, x):\n"
- " of.write(x)\n"
+ " try:\n"
+ " of.write(x)\n"
+ " except: pass\n"
" self.buf += x\n"
"fl = FileLike()\n"
"fl.buf = ''\n"
diff --git a/lib_pypy/cffi/_cffi_include.h b/lib_pypy/cffi/_cffi_include.h
--- a/lib_pypy/cffi/_cffi_include.h
+++ b/lib_pypy/cffi/_cffi_include.h
@@ -8,20 +8,43 @@
the same works for the other two macros. Py_DEBUG implies them,
but not the other way around.
- Issue #350 is still open: on Windows, the code here causes it to link
- with PYTHON36.DLL (for example) instead of PYTHON3.DLL. A fix was
- attempted in 164e526a5515 and 14ce6985e1c3, but reverted: virtualenv
- does not make PYTHON3.DLL available, and so the "correctly" compiled
- version would not run inside a virtualenv. We will re-apply the fix
- after virtualenv has been fixed for some time. For explanation, see
- issue #355. For a workaround if you want PYTHON3.DLL and don't worry
- about virtualenv, see issue #350. See also 'py_limited_api' in
- setuptools_ext.py.
+ The implementation is messy (issue #350): on Windows, with _MSC_VER,
+ we have to define Py_LIMITED_API even before including pyconfig.h.
+ In that case, we guess what pyconfig.h will do to the macros above,
+ and check our guess after the #include.
+
+ Note that on Windows, with CPython 3.x, you need virtualenv version
+ >= 16.0.0. Older versions don't copy PYTHON3.DLL. As a workaround
+ you can remove the definition of Py_LIMITED_API here.
+
+ See also 'py_limited_api' in cffi/setuptools_ext.py.
*/
#if !defined(_CFFI_USE_EMBEDDING) && !defined(Py_LIMITED_API)
-# include <pyconfig.h>
-# if !defined(Py_DEBUG) && !defined(Py_TRACE_REFS) && !defined(Py_REF_DEBUG)
-# define Py_LIMITED_API
+# ifdef _MSC_VER
+# if !defined(_DEBUG) && !defined(Py_DEBUG) && !defined(Py_TRACE_REFS) && !defined(Py_REF_DEBUG)
+# define Py_LIMITED_API
+# endif
+# include <pyconfig.h>
+ /* sanity-check: Py_LIMITED_API will cause crashes if any of these
+ are also defined. Normally, the Python file PC/pyconfig.h does not
+ cause any of these to be defined, with the exception that _DEBUG
+ causes Py_DEBUG. Double-check that. */
+# ifdef Py_LIMITED_API
+# if defined(Py_DEBUG)
+# error "pyconfig.h unexpectedly defines Py_DEBUG, but Py_LIMITED_API is set"
+# endif
+# if defined(Py_TRACE_REFS)
+# error "pyconfig.h unexpectedly defines Py_TRACE_REFS, but Py_LIMITED_API is set"
+# endif
+# if defined(Py_REF_DEBUG)
+# error "pyconfig.h unexpectedly defines Py_REF_DEBUG, but Py_LIMITED_API is set"
+# endif
+# endif
+# else
+# include <pyconfig.h>
+# if !defined(Py_DEBUG) && !defined(Py_TRACE_REFS) && !defined(Py_REF_DEBUG)
+# define Py_LIMITED_API
+# endif
# endif
#endif
diff --git a/lib_pypy/cffi/backend_ctypes.py b/lib_pypy/cffi/backend_ctypes.py
--- a/lib_pypy/cffi/backend_ctypes.py
+++ b/lib_pypy/cffi/backend_ctypes.py
@@ -636,6 +636,10 @@
if isinstance(init, bytes):
init = [init[i:i+1] for i in range(len(init))]
else:
+ if isinstance(init, CTypesGenericArray):
+ if (len(init) != len(blob) or
+ not isinstance(init, CTypesArray)):
+ raise TypeError("length/type mismatch: %s" % (init,))
init = tuple(init)
if len(init) > len(blob):
raise IndexError("too many initializers")
diff --git a/lib_pypy/cffi/setuptools_ext.py b/lib_pypy/cffi/setuptools_ext.py
--- a/lib_pypy/cffi/setuptools_ext.py
+++ b/lib_pypy/cffi/setuptools_ext.py
@@ -81,13 +81,8 @@
it doesn't so far, creating troubles. That's why we check
for "not hasattr(sys, 'gettotalrefcount')" (the 2.7 compatible equivalent
of 'd' not in sys.abiflags). (http://bugs.python.org/issue28401)
-
- On Windows, it's better not to use py_limited_api until issue #355
- can be resolved (by having virtualenv copy PYTHON3.DLL). See also
- the start of _cffi_include.h.
"""
- if ('py_limited_api' not in kwds and not hasattr(sys, 'gettotalrefcount')
- and sys.platform != 'win32'):
+ if 'py_limited_api' not in kwds and not hasattr(sys, 'gettotalrefcount'):
import setuptools
try:
setuptools_major_version = int(setuptools.__version__.partition('.')[0])
@@ -167,6 +162,17 @@
module_path = module_name.split('.')
module_path[-1] += '.py'
generate_mod(os.path.join(self.build_lib, *module_path))
+ def get_source_files(self):
+ # This is called from 'setup.py sdist' only. Exclude
+ # the generate .py module in this case.
+ saved_py_modules = self.py_modules
+ try:
+ if saved_py_modules:
+ self.py_modules = [m for m in saved_py_modules
+ if m != module_name]
+ return base_class.get_source_files(self)
+ finally:
+ self.py_modules = saved_py_modules
dist.cmdclass['build_py'] = build_py_make_mod
# distutils and setuptools have no notion I could find of a
@@ -176,6 +182,7 @@
# the module. So we add it here, which gives a few apparently
# harmless warnings about not finding the file outside the
# build directory.
+ # Then we need to hack more in get_source_files(); see above.
if dist.py_modules is None:
dist.py_modules = []
dist.py_modules.append(module_name)
diff --git a/lib_pypy/grp.py b/lib_pypy/grp.py
--- a/lib_pypy/grp.py
+++ b/lib_pypy/grp.py
@@ -5,8 +5,8 @@
import os
from _pwdgrp_cffi import ffi, lib
import _structseq
-import thread
-_lock = thread.allocate_lock()
+import _thread
+_lock = _thread.allocate_lock()
try: from __pypy__ import builtinify
except ImportError: builtinify = lambda f: f
diff --git a/lib_pypy/pwd.py b/lib_pypy/pwd.py
--- a/lib_pypy/pwd.py
+++ b/lib_pypy/pwd.py
@@ -12,8 +12,8 @@
from _pwdgrp_cffi import ffi, lib
import _structseq
-import thread
-_lock = thread.allocate_lock()
+import _thread
+_lock = _thread.allocate_lock()
try: from __pypy__ import builtinify
except ImportError: builtinify = lambda f: f
diff --git a/lib_pypy/pyrepl/unix_console.py b/lib_pypy/pyrepl/unix_console.py
--- a/lib_pypy/pyrepl/unix_console.py
+++ b/lib_pypy/pyrepl/unix_console.py
@@ -27,6 +27,12 @@
from .console import Console, Event
from .unix_eventqueue import EventQueue
from .trace import trace
+try:
+ from __pypy__ import pyos_inputhook
+except ImportError:
+ def pyos_inputhook():
+ pass
+
class InvalidTerminal(RuntimeError):
pass
@@ -76,8 +82,8 @@
pass
def register(self, fd, flag):
self.fd = fd
- def poll(self, timeout=None):
- r,w,e = select.select([self.fd],[],[],timeout)
+ def poll(self): # note: a 'timeout' argument would be *milliseconds*
+ r,w,e = select.select([self.fd],[],[])
return r
POLLIN = getattr(select, "POLLIN", None)
@@ -407,6 +413,7 @@
def get_event(self, block=1):
while self.event_queue.empty():
while 1: # All hail Unix!
+ pyos_inputhook()
try:
self.push_char(os.read(self.input_fd, 1))
except (IOError, OSError) as err:
diff --git a/pypy/config/pypyoption.py b/pypy/config/pypyoption.py
--- a/pypy/config/pypyoption.py
+++ b/pypy/config/pypyoption.py
@@ -200,6 +200,10 @@
default=False,
requires=[("objspace.usemodules.cpyext", False)]),
+ BoolOption("disable_entrypoints_in_cffi",
+ "Disable only cffi's embedding mode.",
+ default=False),
+
BoolOption("fstrings",
"if you are really convinced that f-strings are a security "
"issue, you can disable them here",
diff --git a/pypy/doc/cpython_differences.rst b/pypy/doc/cpython_differences.rst
--- a/pypy/doc/cpython_differences.rst
+++ b/pypy/doc/cpython_differences.rst
@@ -330,7 +330,8 @@
-------------
* Hash randomization (``-R``) `is ignored in PyPy`_. In CPython
- before 3.4 it has `little point`_.
+ before 3.4 it has `little point`_. Both CPython >= 3.4 and PyPy3
+ implement the randomized SipHash algorithm and ignore ``-R``.
* You can't store non-string keys in type objects. For example::
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
@@ -7,7 +7,8 @@
.. branch: cppyy-packaging
-Upgrade to backend 1.2.0, improved handling of templated methods and
+Main items: vastly better template resolution and improved performance. In
+detail: upgrade to backend 1.4, improved handling of templated methods and
functions (in particular automatic deduction of types), improved pythonization
interface, range of compatibility fixes for Python3, free functions now take
fast libffi path when possible, moves for strings (incl. from Python str),
@@ -35,3 +36,18 @@
.. branch: pyparser-improvements-3
Small refactorings in the Python parser.
+
+.. branch: fix-readme-typo
+
+.. branch: avoid_shell_injection_in_shutil
+
+Backport CPython fix for possible shell injection issue in `distutils.spawn`,
+https://bugs.python.org/issue34540
+
+.. branch: cffi_dlopen_unicode
+
+Enable use of unicode file names in `dlopen`
+
+.. branch: rlock-in-rpython
+
+Backport CPython fix for `thread.RLock`
diff --git a/pypy/interpreter/baseobjspace.py b/pypy/interpreter/baseobjspace.py
--- a/pypy/interpreter/baseobjspace.py
+++ b/pypy/interpreter/baseobjspace.py
@@ -1511,10 +1511,19 @@
if readonly and flags & self.BUF_WRITABLE == self.BUF_WRITABLE:
raise oefmt(self.w_BufferError, "Object is not writable.")
+ def _try_buffer_w(self, w_obj, flags):
+ if not we_are_translated():
+ if w_obj.buffer_w.im_func != W_Root.buffer_w.im_func:
+ # when 'buffer_w()' is overridden in the subclass of
+ # W_Root, we need to specify __buffer="read" or
+ # __buffer="read-write" in the TypeDef.
+ assert type(w_obj).typedef.buffer is not None
+ return w_obj.buffer_w(self, flags)
+
def buffer_w(self, w_obj, flags):
# New buffer interface, returns a buffer based on flags (PyObject_GetBuffer)
try:
- return w_obj.buffer_w(self, flags)
+ return self._try_buffer_w(w_obj, flags)
except BufferInterfaceNotFound:
raise oefmt(self.w_TypeError,
"'%T' does not support the buffer interface", w_obj)
@@ -1522,14 +1531,14 @@
def readbuf_w(self, w_obj):
# Old buffer interface, returns a readonly buffer (PyObject_AsReadBuffer)
try:
- return w_obj.buffer_w(self, self.BUF_SIMPLE).as_readbuf()
+ return self._try_buffer_w(w_obj, self.BUF_SIMPLE).as_readbuf()
except BufferInterfaceNotFound:
self._getarg_error("bytes-like object", w_obj)
def writebuf_w(self, w_obj):
# Old buffer interface, returns a writeable buffer (PyObject_AsWriteBuffer)
try:
- return w_obj.buffer_w(self, self.BUF_WRITABLE).as_writebuf()
+ return self._try_buffer_w(w_obj, self.BUF_WRITABLE).as_writebuf()
except (BufferInterfaceNotFound, OperationError):
self._getarg_error("read-write bytes-like object", w_obj)
@@ -1563,7 +1572,7 @@
# NB. CPython forbids surrogates here
return StringBuffer(w_obj.text_w(self))
try:
- return w_obj.buffer_w(self, self.BUF_SIMPLE).as_readbuf()
+ return self._try_buffer_w(w_obj, self.BUF_SIMPLE).as_readbuf()
except BufferInterfaceNotFound:
self._getarg_error("bytes or buffer", w_obj)
elif code == 's#':
@@ -1575,7 +1584,7 @@
if self.isinstance_w(w_obj, self.w_unicode): # NB. CPython forbids
return w_obj.text_w(self) # surrogates here
try:
- return w_obj.buffer_w(self, self.BUF_SIMPLE).as_str()
+ return self._try_buffer_w(w_obj, self.BUF_SIMPLE).as_str()
except BufferInterfaceNotFound:
self._getarg_error("bytes or read-only buffer", w_obj)
elif code == 'w*':
diff --git a/pypy/interpreter/pyopcode.py b/pypy/interpreter/pyopcode.py
--- a/pypy/interpreter/pyopcode.py
+++ b/pypy/interpreter/pyopcode.py
@@ -2076,7 +2076,7 @@
else:
skip_leading_underscores = False
for name in all:
- if skip_leading_underscores and name[0]=='_':
+ if skip_leading_underscores and name and name[0] == '_':
continue
into_locals[name] = getattr(module, name)
''', filename=__file__)
diff --git a/pypy/interpreter/pyparser/pyparse.py b/pypy/interpreter/pyparser/pyparse.py
--- a/pypy/interpreter/pyparser/pyparse.py
+++ b/pypy/interpreter/pyparser/pyparse.py
@@ -236,7 +236,7 @@
next_token_seen is not None and
next_token_seen.value != '('):
msg = "Missing parentheses in call to '%s'" % (
- last_token_seen,)
+ last_token_seen.value,)
else:
msg = "invalid syntax"
if e.expected_str is not None:
diff --git a/pypy/interpreter/test/test_syntax.py b/pypy/interpreter/test/test_syntax.py
--- a/pypy/interpreter/test/test_syntax.py
+++ b/pypy/interpreter/test/test_syntax.py
@@ -701,6 +701,15 @@
pass
"""
+ def test_bug_annotation_inside_nested_function(self):
+ """
+ # this used to crash
+ def f1():
+ def f2(*args: int):
+ pass
+ f1()
+ """
+
class AppTestSyntaxError:
def test_tokenizer_error_location(self):
diff --git a/pypy/interpreter/typedef.py b/pypy/interpreter/typedef.py
--- a/pypy/interpreter/typedef.py
+++ b/pypy/interpreter/typedef.py
@@ -28,6 +28,9 @@
self.bases = bases
# Used in cpyext to fill tp_as_buffer slots
assert __buffer in {None, 'read-write', 'read'}, "Unknown value for __buffer"
+ for base in bases:
+ if __buffer is None:
+ __buffer = base.buffer
self.buffer = __buffer
self.heaptype = False
self.hasdict = '__dict__' in rawdict
diff --git a/pypy/module/__builtin__/functional.py b/pypy/module/__builtin__/functional.py
--- a/pypy/module/__builtin__/functional.py
+++ b/pypy/module/__builtin__/functional.py
@@ -108,97 +108,99 @@
max_jitdriver = jit.JitDriver(name='max',
greens=['has_key', 'has_item', 'w_type'], reds='auto')
-def make_min_max(unroll):
- @specialize.arg(2)
- def min_max_impl(space, args, implementation_of):
- if implementation_of == "max":
- compare = space.gt
- jitdriver = max_jitdriver
+ at specialize.arg(4)
+def min_max_sequence(space, w_sequence, w_key, w_default, implementation_of):
+ if implementation_of == "max":
+ compare = space.gt
+ jitdriver = max_jitdriver
+ else:
+ compare = space.lt
+ jitdriver = min_jitdriver
+ w_iter = space.iter(w_sequence)
+ w_type = space.type(w_iter)
+ has_key = w_key is not None
+ has_item = False
+ w_max_item = w_default
+ w_max_val = None
+ while True:
+ jitdriver.jit_merge_point(has_key=has_key, has_item=has_item,
+ w_type=w_type)
+ try:
+ w_item = space.next(w_iter)
+ except OperationError as e:
+ if not e.match(space, space.w_StopIteration):
+ raise
+ break
+ if has_key:
+ w_compare_with = space.call_function(w_key, w_item)
else:
- compare = space.lt
- jitdriver = min_jitdriver
- any_kwds = bool(args.keywords)
- args_w = args.arguments_w
- if len(args_w) > 1:
- if unroll and len(args_w) == 2 and not any_kwds:
- # a fast path for the common case, useful for interpreted
- # mode and to reduce the length of the jit trace
- w0, w1 = args_w
- if space.is_true(compare(w1, w0)):
- return w1
- else:
- return w0
- w_sequence = space.newtuple(args_w)
- elif len(args_w):
- w_sequence = args_w[0]
+ w_compare_with = w_item
+ if (not has_item or
+ space.is_true(compare(w_compare_with, w_max_val))):
+ has_item = True
+ w_max_item = w_item
+ w_max_val = w_compare_with
+ if w_max_item is None:
+ raise oefmt(space.w_ValueError, "arg is an empty sequence")
+ return w_max_item
+
+ at specialize.arg(3)
+ at jit.look_inside_iff(lambda space, args_w, w_key, implementation_of:
+ jit.loop_unrolling_heuristic(args_w, len(args_w), 3))
+def min_max_multiple_args(space, args_w, w_key, implementation_of):
+ # case of multiple arguments (at least two). We unroll it if there
+ # are 2 or 3 arguments.
+ if implementation_of == "max":
+ compare = space.gt
+ else:
+ compare = space.lt
+ w_max_item = args_w[0]
+ if w_key is not None:
+ w_max_val = space.call_function(w_key, w_max_item)
+ else:
+ w_max_val = w_max_item
+ for i in range(1, len(args_w)):
+ w_item = args_w[i]
+ if w_key is not None:
+ w_compare_with = space.call_function(w_key, w_item)
else:
- raise oefmt(space.w_TypeError,
- "%s() expects at least one argument",
- implementation_of)
- w_key = None
- w_default = None
- if any_kwds:
- kwds = args.keywords
- for n in range(len(kwds)):
- if kwds[n] == "key":
- w_key = args.keywords_w[n]
- elif kwds[n] == "default":
- w_default = args.keywords_w[n]
- else:
- raise oefmt(space.w_TypeError,
- "%s() got unexpected keyword argument",
- implementation_of)
+ w_compare_with = w_item
+ if space.is_true(compare(w_compare_with, w_max_val)):
+ w_max_item = w_item
+ w_max_val = w_compare_with
+ return w_max_item
- if w_default is not None and len(args_w) > 1:
- raise oefmt(space.w_TypeError,
- "Cannot specify a default for %s() with multiple positional arguments",
- implementation_of)
-
- w_iter = space.iter(w_sequence)
- w_type = space.type(w_iter)
- has_key = w_key is not None
- has_item = False
- w_max_item = None
- w_max_val = None
- while True:
- if not unroll:
- jitdriver.jit_merge_point(has_key=has_key, has_item=has_item, w_type=w_type)
- try:
- w_item = space.next(w_iter)
- except OperationError as e:
- if not e.match(space, space.w_StopIteration):
- raise
- break
- if has_key:
- w_compare_with = space.call_function(w_key, w_item)
- else:
- w_compare_with = w_item
- if not has_item or \
- space.is_true(compare(w_compare_with, w_max_val)):
- has_item = True
- w_max_item = w_item
- w_max_val = w_compare_with
- if w_max_item is None:
- if w_default is not None:
- w_max_item = w_default
- else:
- raise oefmt(space.w_ValueError, "arg is an empty sequence")
- return w_max_item
- if unroll:
- min_max_impl = jit.unroll_safe(min_max_impl)
- return min_max_impl
-
-min_max_unroll = make_min_max(True)
-min_max_normal = make_min_max(False)
-
+ at jit.unroll_safe # the loop over kwds
@specialize.arg(2)
def min_max(space, args, implementation_of):
- if not jit.we_are_jitted() or len(args.arguments_w) != 1 and \
- jit.loop_unrolling_heuristic(args.arguments_w, len(args.arguments_w)):
- return min_max_unroll(space, args, implementation_of)
+ w_key = None
+ w_default = None
+ if bool(args.keywords):
+ kwds = args.keywords
+ for n in range(len(kwds)):
+ if kwds[n] == "key":
+ w_key = args.keywords_w[n]
+ elif kwds[n] == "default":
+ w_default = args.keywords_w[n]
+ else:
+ raise oefmt(space.w_TypeError,
+ "%s() got unexpected keyword argument",
+ implementation_of)
+ #
+ args_w = args.arguments_w
+ if len(args_w) > 1:
+ if w_default is not None:
+ raise oefmt(space.w_TypeError,
+ "Cannot specify a default for %s() with multiple "
+ "positional arguments", implementation_of)
+ return min_max_multiple_args(space, args_w, w_key, implementation_of)
+ elif len(args_w):
+ return min_max_sequence(space, args_w[0], w_key, w_default,
+ implementation_of)
else:
- return min_max_normal(space, args, implementation_of)
-min_max._always_inline = True
+ raise oefmt(space.w_TypeError,
+ "%s() expects at least one argument",
+ implementation_of)
def max(space, __args__):
"""max(iterable[, key=func]) -> value
diff --git a/pypy/module/__builtin__/test/test_functional.py b/pypy/module/__builtin__/test/test_functional.py
--- a/pypy/module/__builtin__/test/test_functional.py
+++ b/pypy/module/__builtin__/test/test_functional.py
@@ -654,6 +654,10 @@
raises(TypeError, max, 1, default=0)
raises(TypeError, max, default=1)
+ def test_max_list_and_key(self):
+ assert max(["100", "50", "30", "-200"], key=int) == "100"
+ assert max("100", "50", "30", "-200", key=int) == "100"
+
try:
from hypothesis import given, strategies, example
diff --git a/pypy/module/__pypy__/interp_magic.py b/pypy/module/__pypy__/interp_magic.py
--- a/pypy/module/__pypy__/interp_magic.py
+++ b/pypy/module/__pypy__/interp_magic.py
@@ -209,3 +209,13 @@
def revdb_stop(space):
from pypy.interpreter.reverse_debugging import stop_point
stop_point()
+
+def pyos_inputhook(space):
+ """Call PyOS_InputHook() from the CPython C API."""
+ if not space.config.objspace.usemodules.cpyext:
+ return
+ w_modules = space.sys.get('modules')
+ if space.finditem_str(w_modules, 'cpyext') is None:
+ return # cpyext not imported yet, ignore
+ from pypy.module.cpyext.api import invoke_pyos_inputhook
+ invoke_pyos_inputhook(space)
diff --git a/pypy/module/__pypy__/moduledef.py b/pypy/module/__pypy__/moduledef.py
--- a/pypy/module/__pypy__/moduledef.py
+++ b/pypy/module/__pypy__/moduledef.py
@@ -110,6 +110,7 @@
'stack_almost_full' : 'interp_magic.stack_almost_full',
'fsencode' : 'interp_magic.fsencode',
'fsdecode' : 'interp_magic.fsdecode',
+ 'pyos_inputhook' : 'interp_magic.pyos_inputhook',
}
submodules = {
diff --git a/pypy/module/_cffi_backend/cbuffer.py b/pypy/module/_cffi_backend/cbuffer.py
--- a/pypy/module/_cffi_backend/cbuffer.py
+++ b/pypy/module/_cffi_backend/cbuffer.py
@@ -156,7 +156,7 @@
return MiniBuffer(LLBuffer(ptr, size), w_cdata)
MiniBuffer.typedef = TypeDef(
- "_cffi_backend.buffer",
+ "_cffi_backend.buffer", None, None, "read-write",
__new__ = interp2app(MiniBuffer___new__),
__len__ = interp2app(MiniBuffer.descr_len),
__getitem__ = interp2app(MiniBuffer.descr_getitem),
diff --git a/pypy/module/_cffi_backend/cdataobj.py b/pypy/module/_cffi_backend/cdataobj.py
--- a/pypy/module/_cffi_backend/cdataobj.py
+++ b/pypy/module/_cffi_backend/cdataobj.py
@@ -79,13 +79,6 @@
w_result = self.ctype.cast_to_int(ptr)
return w_result
- def long(self, space):
- w_result = self.int(space)
- space = self.space
- if space.is_w(space.type(w_result), space.w_int):
- w_result = space.newlong(space.int_w(w_result))
- return w_result
-
def float(self):
with self as ptr:
w_result = self.ctype.float(ptr)
@@ -664,7 +657,6 @@
__repr__ = interp2app(W_CData.repr),
__bool__ = interp2app(W_CData.bool),
__int__ = interp2app(W_CData.int),
- __long__ = interp2app(W_CData.long),
__float__ = interp2app(W_CData.float),
__complex__ = interp2app(W_CData.complex),
__len__ = interp2app(W_CData.len),
diff --git a/pypy/module/_cffi_backend/cdlopen.py b/pypy/module/_cffi_backend/cdlopen.py
--- a/pypy/module/_cffi_backend/cdlopen.py
+++ b/pypy/module/_cffi_backend/cdlopen.py
@@ -1,31 +1,24 @@
from rpython.rtyper.lltypesystem import lltype, llmemory, rffi
from rpython.rlib.objectmodel import specialize, we_are_translated
-from rpython.rlib.rdynload import DLLHANDLE, dlopen, dlsym, dlclose, DLOpenError
+from rpython.rlib.rdynload import DLLHANDLE, dlsym, dlclose
from pypy.interpreter.error import oefmt
-from pypy.module._rawffi.interp_rawffi import wrap_dlopenerror
from pypy.module._cffi_backend.parse_c_type import (
_CFFI_OPCODE_T, GLOBAL_S, CDL_INTCONST_S, STRUCT_UNION_S, FIELD_S,
ENUM_S, TYPENAME_S, ll_set_cdl_realize_global_int)
from pypy.module._cffi_backend.realize_c_type import getop
from pypy.module._cffi_backend.lib_obj import W_LibObject
-from pypy.module._cffi_backend import cffi_opcode, cffi1_module
-
+from pypy.module._cffi_backend import cffi_opcode, cffi1_module, misc
class W_DlOpenLibObject(W_LibObject):
- def __init__(self, ffi, filename, flags):
- with rffi.scoped_str2charp(filename) as ll_libname:
- if filename is None:
- filename = "<None>"
- try:
- handle = dlopen(ll_libname, flags)
- except DLOpenError as e:
- raise wrap_dlopenerror(ffi.space, e, filename)
- W_LibObject.__init__(self, ffi, filename)
+ def __init__(self, ffi, w_filename, flags):
+ space = ffi.space
+ fname, handle = misc.dlopen_w(space, w_filename, flags)
+ W_LibObject.__init__(self, ffi, fname)
self.libhandle = handle
- self.register_finalizer(ffi.space)
+ self.register_finalizer(space)
def _finalize_(self):
h = self.libhandle
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
@@ -104,7 +104,15 @@
return self.ctptr
def convert_from_object(self, cdata, w_ob):
- self.convert_array_from_object(cdata, w_ob)
+ if isinstance(w_ob, cdataobj.W_CData) and w_ob.ctype is self:
+ length = w_ob.get_array_length()
+ with w_ob as source:
+ source = rffi.cast(rffi.VOIDP, source)
+ target = rffi.cast(rffi.VOIDP, cdata)
+ size = rffi.cast(rffi.SIZE_T, self.ctitem.size * length)
+ rffi.c_memcpy(target, source, size)
+ else:
+ self.convert_array_from_object(cdata, w_ob)
def convert_to_object(self, cdata):
if self.length < 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
@@ -51,9 +51,12 @@
def unpack_list_of_float_items(self, ptr, length):
return None
- def pack_list_of_items(self, cdata, w_ob):
+ def pack_list_of_items(self, cdata, w_ob, expected_length):
return False
+ def _within_bounds(self, actual_length, expected_length):
+ return expected_length < 0 or actual_length <= expected_length
+
def newp(self, w_init, allocator):
space = self.space
raise oefmt(space.w_TypeError,
@@ -102,6 +105,11 @@
# ctype 'A' must be a pointer to same type, not cdata
# 'B'", but with A=B, then give instead a different error
# message to try to clear up the confusion
+ if self is w_got.ctype:
+ raise oefmt(space.w_SystemError,
+ "initializer for ctype '%s' is correct, but we get "
+ "an internal mismatch--please report a bug",
+ self.name)
return oefmt(space.w_TypeError,
"initializer for ctype '%s' appears indeed to "
"be '%s', but the types are different (check "
diff --git a/pypy/module/_cffi_backend/ctypeprim.py b/pypy/module/_cffi_backend/ctypeprim.py
--- a/pypy/module/_cffi_backend/ctypeprim.py
+++ b/pypy/module/_cffi_backend/ctypeprim.py
@@ -292,9 +292,10 @@
return res
return None
- def pack_list_of_items(self, cdata, w_ob):
+ def pack_list_of_items(self, cdata, w_ob, expected_length):
int_list = self.space.listview_int(w_ob)
- if int_list is not None:
+ if (int_list is not None and
+ self._within_bounds(len(int_list), expected_length)):
if self.size == rffi.sizeof(rffi.LONG): # fastest path
from rpython.rlib.rrawarray import copy_list_to_raw_array
cdata = rffi.cast(rffi.LONGP, cdata)
@@ -305,7 +306,8 @@
if overflowed != 0:
self._overflow(self.space.newint(overflowed))
return True
- return W_CTypePrimitive.pack_list_of_items(self, cdata, w_ob)
+ return W_CTypePrimitive.pack_list_of_items(self, cdata, w_ob,
+ expected_length)
class W_CTypePrimitiveUnsigned(W_CTypePrimitive):
@@ -375,15 +377,17 @@
return res
return None
- def pack_list_of_items(self, cdata, w_ob):
+ def pack_list_of_items(self, cdata, w_ob, expected_length):
int_list = self.space.listview_int(w_ob)
- if int_list is not None:
+ if (int_list is not None and
+ self._within_bounds(len(int_list), expected_length)):
overflowed = misc.pack_list_to_raw_array_bounds_unsigned(
int_list, cdata, self.size, self.vrangemax)
if overflowed != 0:
self._overflow(self.space.newint(overflowed))
return True
- return W_CTypePrimitive.pack_list_of_items(self, cdata, w_ob)
+ return W_CTypePrimitive.pack_list_of_items(self, cdata, w_ob,
+ expected_length)
class W_CTypePrimitiveBool(W_CTypePrimitiveUnsigned):
@@ -471,9 +475,10 @@
return res
return None
- def pack_list_of_items(self, cdata, w_ob):
+ def pack_list_of_items(self, cdata, w_ob, expected_length):
float_list = self.space.listview_float(w_ob)
- if float_list is not None:
+ if (float_list is not None and
+ self._within_bounds(len(float_list), expected_length)):
if self.size == rffi.sizeof(rffi.DOUBLE): # fastest path
from rpython.rlib.rrawarray import copy_list_to_raw_array
cdata = rffi.cast(rffi.DOUBLEP, cdata)
@@ -483,7 +488,8 @@
misc.pack_float_list_to_raw_array(float_list, cdata,
rffi.FLOAT, rffi.FLOATP)
return True
- return W_CTypePrimitive.pack_list_of_items(self, cdata, w_ob)
+ return W_CTypePrimitive.pack_list_of_items(self, cdata, w_ob,
+ expected_length)
def unpack_ptr(self, w_ctypeptr, ptr, length):
result = self.unpack_list_of_float_items(ptr, length)
@@ -553,13 +559,15 @@
# 'list(array-of-longdouble)' returns a list of cdata objects,
# not a list of floats.
- def pack_list_of_items(self, cdata, w_ob):
+ def pack_list_of_items(self, cdata, w_ob, expected_length):
float_list = self.space.listview_float(w_ob)
- if float_list is not None:
+ if (float_list is not None and
+ self._within_bounds(len(float_list), expected_length)):
misc.pack_float_list_to_raw_array(float_list, cdata,
rffi.LONGDOUBLE, rffi.LONGDOUBLEP)
return True
- return W_CTypePrimitive.pack_list_of_items(self, cdata, w_ob)
+ return W_CTypePrimitive.pack_list_of_items(self, cdata, w_ob,
+ expected_length)
@jit.dont_look_inside
def nonzero(self, cdata):
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
@@ -58,7 +58,7 @@
def _convert_array_from_listview(self, cdata, lst_w):
space = self.space
- if self.length >= 0 and len(lst_w) > self.length:
+ if not self._within_bounds(len(lst_w), self.length):
raise oefmt(space.w_IndexError,
"too many initializers for '%s' (got %d)",
self.name, len(lst_w))
@@ -71,8 +71,8 @@
space = self.space
if (space.isinstance_w(w_ob, space.w_list) or
space.isinstance_w(w_ob, space.w_tuple)):
- if self.ctitem.pack_list_of_items(cdata, w_ob): # fast path
- pass
+ if self.ctitem.pack_list_of_items(cdata, w_ob, self.length):
+ pass # fast path
else:
self._convert_array_from_listview(cdata, space.listview(w_ob))
elif self.accept_str:
@@ -317,9 +317,7 @@
if isinstance(self.ctitem, ctypeprim.W_CTypePrimitiveBool):
self._must_be_string_of_zero_or_one(value)
keepalives[i] = value
- buf, buf_flag = rffi.get_nonmovingbuffer_final_null(value)
- rffi.cast(rffi.CCHARPP, cdata)[0] = buf
- return ord(buf_flag) # 4, 5 or 6
+ return misc.write_string_as_charp(cdata, value)
#
if (space.isinstance_w(w_init, space.w_list) or
space.isinstance_w(w_init, space.w_tuple)):
diff --git a/pypy/module/_cffi_backend/embedding.py b/pypy/module/_cffi_backend/embedding.py
--- a/pypy/module/_cffi_backend/embedding.py
+++ b/pypy/module/_cffi_backend/embedding.py
@@ -95,7 +95,9 @@
if os.name == 'nt':
do_includes = r"""
+#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0501
+#endif
#include <windows.h>
static void _cffi_init(void);
diff --git a/pypy/module/_cffi_backend/errorbox.py b/pypy/module/_cffi_backend/errorbox.py
--- a/pypy/module/_cffi_backend/errorbox.py
+++ b/pypy/module/_cffi_backend/errorbox.py
@@ -69,7 +69,10 @@
import sys
class FileLike:
def write(self, x):
- of.write(x)
+ try:
+ of.write(x)
+ except:
+ pass
self.buf += x
fl = FileLike()
fl.buf = ''
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
@@ -573,8 +573,8 @@
return self.ffi_type(w_arg, ACCEPT_STRING | ACCEPT_CDATA)
- @unwrap_spec(filename="fsencode_or_none", flags=int)
- def descr_dlopen(self, filename, flags=0):
+ @unwrap_spec(flags=int)
+ def descr_dlopen(self, w_filename, flags=0):
"""\
Load and return a dynamic library identified by 'name'. The standard
C library can be loaded by passing None.
@@ -585,7 +585,7 @@
first access."""
#
from pypy.module._cffi_backend import cdlopen
- return cdlopen.W_DlOpenLibObject(self, filename, flags)
+ return cdlopen.W_DlOpenLibObject(self, w_filename, flags)
def descr_dlclose(self, w_lib):
diff --git a/pypy/module/_cffi_backend/libraryobj.py b/pypy/module/_cffi_backend/libraryobj.py
--- a/pypy/module/_cffi_backend/libraryobj.py
+++ b/pypy/module/_cffi_backend/libraryobj.py
@@ -4,28 +4,21 @@
from pypy.interpreter.error import oefmt
from pypy.interpreter.gateway import interp2app, unwrap_spec
from pypy.interpreter.typedef import TypeDef
-from pypy.module._rawffi.interp_rawffi import wrap_dlopenerror
from rpython.rtyper.lltypesystem import rffi
-from rpython.rlib.rdynload import DLLHANDLE, dlopen, dlsym, dlclose, DLOpenError
+from rpython.rlib.rdynload import DLLHANDLE, dlsym, dlclose
from pypy.module._cffi_backend.cdataobj import W_CData
from pypy.module._cffi_backend.ctypeobj import W_CType
+from pypy.module._cffi_backend import misc
class W_Library(W_Root):
_immutable_ = True
- def __init__(self, space, filename, flags):
+ def __init__(self, space, w_filename, flags):
self.space = space
- with rffi.scoped_str2charp(filename) as ll_libname:
- if filename is None:
- filename = "<None>"
- try:
- self.handle = dlopen(ll_libname, flags)
- except DLOpenError as e:
- raise wrap_dlopenerror(space, e, filename)
- self.name = filename
+ self.name, self.handle = misc.dlopen_w(space, w_filename, flags)
self.register_finalizer(space)
def _finalize_(self):
@@ -104,7 +97,7 @@
W_Library.typedef.acceptable_as_base_class = False
- at unwrap_spec(filename="fsencode_or_none", flags=int)
-def load_library(space, filename, flags=0):
- lib = W_Library(space, filename, flags)
+ at unwrap_spec(flags=int)
+def load_library(space, w_filename, flags=0):
+ lib = W_Library(space, w_filename, flags)
return lib
diff --git a/pypy/module/_cffi_backend/misc.py b/pypy/module/_cffi_backend/misc.py
--- a/pypy/module/_cffi_backend/misc.py
+++ b/pypy/module/_cffi_backend/misc.py
@@ -1,14 +1,24 @@
from __future__ import with_statement
+import sys
from pypy.interpreter.error import OperationError, oefmt
+from pypy.module._rawffi.interp_rawffi import wrap_dlopenerror
from rpython.rlib import jit
-from rpython.rlib.objectmodel import specialize
+from rpython.rlib.objectmodel import specialize, we_are_translated
from rpython.rlib.rarithmetic import r_uint, r_ulonglong
from rpython.rlib.unroll import unrolling_iterable
+from rpython.rlib.rdynload import dlopen, DLOpenError
+from rpython.rlib.nonconst import NonConstant
from rpython.rtyper.lltypesystem import lltype, llmemory, rffi
from rpython.translator.tool.cbuild import ExternalCompilationInfo
+if sys.platform == 'win32':
+ from rpython.rlib.rdynload import dlopenU
+ WIN32 = True
+else:
+ WIN32 = False
+
# ____________________________________________________________
@@ -102,6 +112,12 @@
def write_raw_longdouble_data(target, source):
rffi.cast(rffi.LONGDOUBLEP, target)[0] = source
+ at jit.dont_look_inside # lets get_nonmovingbuffer_final_null be inlined
+def write_string_as_charp(target, string):
+ buf, buf_flag = rffi.get_nonmovingbuffer_final_null(string)
+ rffi.cast(rffi.CCHARPP, target)[0] = buf
+ return ord(buf_flag) # 4, 5 or 6
+
# ____________________________________________________________
sprintf_longdouble = rffi.llexternal(
@@ -129,21 +145,14 @@
# This version accepts a Python int too, and does convertions from
# other types of objects. It refuses floats.
try:
- value = space.int_w(w_ob)
+ return space.int_w(w_ob, allow_conversion=False)
except OperationError as e:
if not (e.match(space, space.w_OverflowError) or
e.match(space, space.w_TypeError)):
raise
- else:
- return value
- try:
- bigint = space.bigint_w(w_ob, allow_conversion=False)
- except OperationError as e:
- if not e.match(space, space.w_TypeError):
- raise
if _is_a_float(space, w_ob):
raise
- bigint = space.bigint_w(space.int(w_ob), allow_conversion=False)
+ bigint = space.bigint_w(w_ob, allow_conversion=True)
try:
return bigint.tolonglong()
except OverflowError:
@@ -151,20 +160,15 @@
def as_long(space, w_ob):
# Same as as_long_long(), but returning an int instead.
- if space.is_w(space.type(w_ob), space.w_int): # shortcut
- return space.int_w(w_ob)
try:
- bigint = space.bigint_w(w_ob, allow_conversion=False)
+ return space.int_w(w_ob, allow_conversion=False)
except OperationError as e:
- if not e.match(space, space.w_TypeError):
+ if not (e.match(space, space.w_OverflowError) or
+ e.match(space, space.w_TypeError)):
raise
if _is_a_float(space, w_ob):
raise
- bigint = space.bigint_w(space.int(w_ob), allow_conversion=False)
- try:
- return bigint.toint()
- except OverflowError:
- raise OperationError(space.w_OverflowError, space.newtext(ovf_msg))
+ return space.int_w(w_ob, allow_conversion=True)
def as_unsigned_long_long(space, w_ob, strict):
# (possibly) convert and cast a Python object to an unsigned long long.
@@ -172,23 +176,19 @@
# objects. If 'strict', complains with OverflowError; if 'not strict',
# mask the result and round floats.
try:
- value = space.int_w(w_ob)
+ value = space.int_w(w_ob, allow_conversion=False)
except OperationError as e:
if not (e.match(space, space.w_OverflowError) or
e.match(space, space.w_TypeError)):
raise
+ if strict and _is_a_float(space, w_ob):
+ raise
else:
if strict and value < 0:
raise OperationError(space.w_OverflowError, space.newtext(neg_msg))
return r_ulonglong(value)
- try:
- bigint = space.bigint_w(w_ob, allow_conversion=False)
- except OperationError as e:
- if not e.match(space, space.w_TypeError):
- raise
- if strict and _is_a_float(space, w_ob):
- raise
- bigint = space.bigint_w(space.int(w_ob), allow_conversion=False)
+ # note that if not 'strict', then space.int() will round down floats
+ bigint = space.bigint_w(space.int(w_ob), allow_conversion=False)
if strict:
try:
return bigint.toulonglong()
@@ -202,13 +202,22 @@
def as_unsigned_long(space, w_ob, strict):
# same as as_unsigned_long_long(), but returning just an Unsigned
try:
- bigint = space.bigint_w(w_ob, allow_conversion=False)
+ value = space.int_w(w_ob, allow_conversion=False)
except OperationError as e:
- if not e.match(space, space.w_TypeError):
+ if not (e.match(space, space.w_OverflowError) or
+ e.match(space, space.w_TypeError)):
raise
if strict and _is_a_float(space, w_ob):
raise
- bigint = space.bigint_w(space.int(w_ob), allow_conversion=False)
+ else:
+ if strict and value < 0:
+ raise OperationError(space.w_OverflowError, space.newtext(neg_msg))
+ if not we_are_translated():
+ if isinstance(value, NonConstant): # hack for test_ztranslation
+ return r_uint(0)
+ return r_uint(value)
+ # note that if not 'strict', then space.int() will round down floats
+ bigint = space.bigint_w(space.int(w_ob), allow_conversion=False)
if strict:
try:
return bigint.touint()
@@ -241,7 +250,12 @@
def _standard_object_as_bool(space, w_ob):
if space.isinstance_w(w_ob, space.w_int):
- return space.bigint_w(w_ob).tobool()
+ try:
+ return space.int_w(w_ob) != 0
+ except OperationError as e:
+ if not e.match(space, space.w_OverflowError):
+ raise
+ return space.bigint_w(w_ob).tobool()
if space.isinstance_w(w_ob, space.w_float):
return space.float_w(w_ob) != 0.0
raise _NotStandardObject
@@ -388,3 +402,28 @@
ptr = rffi.cast(rffi.FLOATP, source)
for i in range(len(float_list)):
float_list[i] = rffi.cast(lltype.Float, ptr[i])
+
+# ____________________________________________________________
+
+def dlopen_w(space, w_filename, flags):
+ if WIN32 and space.isinstance_w(w_filename, space.w_unicode):
+ fname = space.text_w(space.repr(w_filename))
+ unicode_name = space.unicode_w(w_filename)
+ with rffi.scoped_unicode2wcharp(unicode_name) as ll_libname:
+ try:
+ handle = dlopenU(ll_libname, flags)
+ except DLOpenError as e:
+ raise wrap_dlopenerror(space, e, fname)
+ else:
+ if space.is_none(w_filename):
+ fname = None
+ else:
+ fname = space.fsencode_w(w_filename)
+ with rffi.scoped_str2charp(fname) as ll_libname:
+ if fname is None:
+ fname = "<None>"
+ try:
+ handle = dlopen(ll_libname, flags)
+ except DLOpenError as e:
+ raise wrap_dlopenerror(space, e, fname)
+ return fname, handle
diff --git a/pypy/module/_cffi_backend/moduledef.py b/pypy/module/_cffi_backend/moduledef.py
--- a/pypy/module/_cffi_backend/moduledef.py
+++ b/pypy/module/_cffi_backend/moduledef.py
@@ -71,7 +71,8 @@
def __init__(self, space, *args):
MixedModule.__init__(self, space, *args)
#
- if not space.config.objspace.disable_entrypoints:
+ if (not space.config.objspace.disable_entrypoints and
+ not space.config.objspace.disable_entrypoints_in_cffi):
# import 'embedding', which has the side-effect of registering
# the 'pypy_init_embedded_cffi_module' entry point
from pypy.module._cffi_backend import embedding
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
@@ -334,8 +334,18 @@
max = (1 << (8*size-1)) - 1
assert newp(pp, min)[0] == min
assert newp(pp, max)[0] == max
+ py.test.raises(OverflowError, newp, pp, min - 2 ** 32)
+ py.test.raises(OverflowError, newp, pp, min - 2 ** 64)
+ py.test.raises(OverflowError, newp, pp, max + 2 ** 32)
+ py.test.raises(OverflowError, newp, pp, max + 2 ** 64)
py.test.raises(OverflowError, newp, pp, min - 1)
py.test.raises(OverflowError, newp, pp, max + 1)
+ py.test.raises(OverflowError, newp, pp, min - 1 - 2 ** 32)
+ py.test.raises(OverflowError, newp, pp, min - 1 - 2 ** 64)
+ py.test.raises(OverflowError, newp, pp, max + 1)
+ py.test.raises(OverflowError, newp, pp, max + 1 + 2 ** 32)
+ py.test.raises(OverflowError, newp, pp, max + 1 + 2 ** 64)
+ py.test.raises(TypeError, newp, pp, 1.0)
for name in ['char', 'short', 'int', 'long', 'long long']:
p = new_primitive_type('unsigned ' + name)
pp = new_pointer_type(p)
@@ -1862,7 +1872,7 @@
def test_newp_copying():
"""Test that we can do newp(<type>, <cdata of the given type>) for most
- types, with the exception of arrays, like in C.
+ types, including same-type arrays.
"""
BInt = new_primitive_type("int")
p = newp(new_pointer_type(BInt), cast(BInt, 42))
@@ -1891,8 +1901,9 @@
a1 = newp(BArray, [1, 2, 3, 4])
py.test.raises(TypeError, newp, BArray, a1)
BArray6 = new_array_type(new_pointer_type(BInt), 6)
- a1 = newp(BArray6, None)
- py.test.raises(TypeError, newp, BArray6, a1)
+ a1 = newp(BArray6, [10, 20, 30])
+ a2 = newp(BArray6, a1)
+ assert list(a2) == [10, 20, 30, 0, 0, 0]
#
s1 = newp(BStructPtr, [42])
s2 = newp(BStructPtr, s1[0])
@@ -3946,6 +3957,7 @@
z3 = cast(BVoidP, 0)
z4 = cast(BUCharP, 0)
with warnings.catch_warnings(record=True) as w:
+ warnings.simplefilter("always")
newp(new_pointer_type(BIntP), z1) # warn
assert len(w) == 1
newp(new_pointer_type(BVoidP), z1) # fine
diff --git a/pypy/module/_cffi_backend/test/test_fastpath.py b/pypy/module/_cffi_backend/test/test_fastpath.py
--- a/pypy/module/_cffi_backend/test/test_fastpath.py
+++ b/pypy/module/_cffi_backend/test/test_fastpath.py
@@ -267,3 +267,17 @@
assert lst == [1.25, -2.5, 3.75]
if not self.runappdirect:
assert self.get_count() == 1
+
+ def test_too_many_initializers(self):
+ import _cffi_backend
+ ffi = _cffi_backend.FFI()
+ raises(IndexError, ffi.new, "int[4]", [10, 20, 30, 40, 50])
+ raises(IndexError, ffi.new, "int[4]", tuple(range(999)))
+ raises(IndexError, ffi.new, "unsigned int[4]", [10, 20, 30, 40, 50])
+ raises(IndexError, ffi.new, "float[4]", [10, 20, 30, 40, 50])
+ raises(IndexError, ffi.new, "long double[4]", [10, 20, 30, 40, 50])
+ raises(IndexError, ffi.new, "char[4]", [10, 20, 30, 40, 50])
+ raises(IndexError, ffi.new, "wchar_t[4]", [10, 20, 30, 40, 50])
+ raises(IndexError, ffi.new, "_Bool[4]", [10, 20, 30, 40, 50])
+ raises(IndexError, ffi.new, "int[4][4]", [[3,4,5,6]] * 5)
+ raises(IndexError, ffi.new, "int[4][4]", [[3,4,5,6,7]] * 4)
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
@@ -572,3 +572,13 @@
assert len(z) == 2
assert ffi.cast("int *", z)[0] == 0x12345
assert list(z) == [u'\U00012345', u'\x00'] # maybe a 2-unichars str
+
+ def test_ffi_array_as_init(self):
+ import _cffi_backend as _cffi1_backend
+ ffi = _cffi1_backend.FFI()
+ p = ffi.new("int[4]", [10, 20, 30, 400])
+ q = ffi.new("int[4]", p)
+ assert list(q) == [10, 20, 30, 400]
+ raises(TypeError, ffi.new, "int[3]", p)
+ raises(TypeError, ffi.new, "int[5]", p)
+ raises(TypeError, ffi.new, "int16_t[4]", p)
diff --git a/pypy/module/_cffi_backend/test/test_re_python.py b/pypy/module/_cffi_backend/test/test_re_python.py
--- a/pypy/module/_cffi_backend/test/test_re_python.py
+++ b/pypy/module/_cffi_backend/test/test_re_python.py
@@ -1,8 +1,13 @@
import py
+import sys, shutil, os
from rpython.tool.udir import udir
from pypy.interpreter.gateway import interp2app
from pypy.module._cffi_backend.newtype import _clean_cache
+if sys.platform == 'win32':
+ WIN32 = True
+else:
+ WIN32 = False
class AppTestRecompilerPython:
spaceconfig = dict(usemodules=['_cffi_backend'])
@@ -40,6 +45,18 @@
'globalconst42', 'globalconsthello'])
outputfilename = ffiplatform.compile(str(tmpdir), ext)
cls.w_extmod = space.wrap(outputfilename)
+ if WIN32:
+ unicode_name = u'load\u03betest.dll'
+ else:
+ unicode_name = u'load_caf\xe9' + os.path.splitext(outputfilename)[1]
+ try:
+ unicode_name.encode(sys.getfilesystemencoding())
+ except UnicodeEncodeError:
+ unicode_name = None # skip test_dlopen_unicode
+ if unicode_name is not None:
+ outputfileUname = os.path.join(unicode(udir), unicode_name)
+ shutil.copyfile(outputfilename, outputfileUname)
+ cls.w_extmodU = space.wrap(outputfileUname)
#mod.tmpdir = tmpdir
#
ffi = FFI()
@@ -108,6 +125,16 @@
assert lib.add42(-10) == 32
assert type(lib.add42) is _cffi_backend.FFI.CData
+ def test_dlopen_unicode(self):
+ if not getattr(self, 'extmodU', None):
+ skip("no unicode file name")
+ import _cffi_backend, sys
+ sys.pypy_initfsencoding() # initialize space.sys.filesystemencoding
+ self.fix_path()
+ from re_python_pysrc import ffi
+ lib = ffi.dlopen(self.extmodU)
+ assert lib.add42(-10) == 32
+
def test_dlclose(self):
import _cffi_backend
self.fix_path()
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
@@ -761,6 +761,26 @@
assert b"\\u3042\u3xxx".decode("unicode-escape", "test.handler1") == \
u"\u3042[<92><117><51>]xxx"
+ def test_unicode_internal_error_handler_infinite_loop(self):
+ import codecs
+ class MyException(Exception):
+ pass
+ seen = [0]
+ def handler_unicodeinternal(exc):
+ if not isinstance(exc, UnicodeDecodeError):
+ raise TypeError("don't know how to handle %r" % exc)
+ seen[0] += 1
+ if seen[0] == 20: # stop the 20th time this is called
+ raise MyException
+ return (u"\x01", 4) # 4 < len(input), so will try and fail again
+ codecs.register_error("test.inf", handler_unicodeinternal)
+ try:
+ b"\x00\x00\x00\x00\x00".decode("unicode-internal", "test.inf")
+ except MyException:
+ pass
+ else:
+ raise AssertionError("should have gone into infinite loop")
+
def test_encode_error_bad_handler(self):
import codecs
codecs.register_error("test.bad_handler", lambda e: (repl, 1))
diff --git a/pypy/module/_cppyy/capi/loadable_capi.py b/pypy/module/_cppyy/capi/loadable_capi.py
--- a/pypy/module/_cppyy/capi/loadable_capi.py
+++ b/pypy/module/_cppyy/capi/loadable_capi.py
@@ -1,13 +1,18 @@
import os
+
from rpython.rtyper.lltypesystem import rffi, lltype
from rpython.rlib.rarithmetic import intmask
from rpython.rlib import jit, jit_libffi, libffi, rdynload, objectmodel
from rpython.rlib.rarithmetic import r_singlefloat
from rpython.tool import leakfinder
-from pypy.interpreter.gateway import interp2app
-from pypy.interpreter.error import oefmt
+from pypy.interpreter.error import OperationError, oefmt
+from pypy.interpreter.argument import Arguments
+from pypy.interpreter.gateway import interp2app, interpindirect2app
+from pypy.interpreter.typedef import TypeDef
+from pypy.objspace.std.iterobject import W_AbstractSeqIterObject
+from pypy.module._rawffi.array import W_ArrayInstance
from pypy.module._cffi_backend import ctypefunc, ctypeprim, cdataobj, misc
from pypy.module._cffi_backend import newtype
from pypy.module._cppyy import ffitypes
@@ -23,10 +28,11 @@
class _Arg: # poor man's union
_immutable_ = True
- def __init__(self, tc, h = 0, l = -1, s = '', p = rffi.cast(rffi.VOIDP, 0)):
+ def __init__(self, tc, h = 0, l = -1, d = -1., s = '', p = rffi.cast(rffi.VOIDP, 0)):
self.tc = tc
self._handle = h
self._long = l
+ self._double = d
self._string = s
self._voidp = p
@@ -40,6 +46,11 @@
def __init__(self, val):
_Arg.__init__(self, 'l', l = val)
+class _ArgD(_Arg):
+ _immutable_ = True
+ def __init__(self, val):
+ _Arg.__init__(self, 'd', d = val)
+
class _ArgS(_Arg):
_immutable_ = True
def __init__(self, val):
@@ -89,6 +100,9 @@
assert obj._voidp != rffi.cast(rffi.VOIDP, 0)
data = rffi.cast(rffi.VOIDPP, data)
data[0] = obj._voidp
+ elif obj.tc == 'd':
+ assert isinstance(argtype, ctypeprim.W_CTypePrimitiveFloat)
+ misc.write_raw_float_data(data, rffi.cast(rffi.DOUBLE, obj._double), argtype.size)
else: # only other use is string
assert obj.tc == 's'
n = len(obj._string)
@@ -182,6 +196,7 @@
'call_f' : ([c_method, c_object, c_int, c_voidp], c_float),
'call_d' : ([c_method, c_object, c_int, c_voidp], c_double),
'call_ld' : ([c_method, c_object, c_int, c_voidp], c_ldouble),
+ 'call_nld' : ([c_method, c_object, c_int, c_voidp], c_double),
'call_r' : ([c_method, c_object, c_int, c_voidp], c_voidp),
# call_s actually takes an size_t* as last parameter, but this will do
@@ -236,6 +251,8 @@
'method_prototype' : ([c_scope, c_method, c_int], c_ccharp),
'is_const_method' : ([c_method], c_int),
+ 'get_num_templated_methods': ([c_scope], c_int),
+ 'get_templated_method_name': ([c_scope, c_index], c_ccharp),
'exists_method_template' : ([c_scope, c_ccharp], c_int),
'method_is_template' : ([c_scope, c_index], c_int),
'get_method_template' : ([c_scope, c_ccharp, c_ccharp], c_method),
@@ -272,9 +289,11 @@
'stdstring2charp' : ([c_object, c_voidp], c_ccharp),
'stdstring2stdstring' : ([c_object], c_object),
- 'stdvector_valuetype' : ([c_ccharp], c_ccharp),
- 'stdvector_valuesize' : ([c_ccharp], c_size_t),
+ 'longdouble2double' : ([c_voidp], c_double),
+ 'double2longdouble' : ([c_double, c_voidp], c_void),
+ 'vectorbool_getitem' : ([c_object, c_int], c_int),
+ 'vectorbool_setitem' : ([c_object, c_int, c_int], c_void),
}
# size/offset are backend-specific but fixed after load
@@ -289,10 +308,10 @@
dldflags = rdynload.RTLD_LOCAL | rdynload.RTLD_LAZY
if os.environ.get('CPPYY_BACKEND_LIBRARY'):
libname = os.environ['CPPYY_BACKEND_LIBRARY']
- state.backend = W_Library(space, libname, dldflags)
+ state.backend = W_Library(space, space.newtext(libname), dldflags)
else:
# try usual lookups
- state.backend = W_Library(space, backend_library, dldflags)
+ state.backend = W_Library(space, space.newtext(backend_library), dldflags)
if state.backend:
# fix constants
@@ -401,7 +420,9 @@
return rffi.cast(rffi.DOUBLE, space.float_w(call_capi(space, 'call_d', args)))
def c_call_ld(space, cppmethod, cppobject, nargs, cargs):
args = [_ArgH(cppmethod), _ArgH(cppobject), _ArgL(nargs), _ArgP(cargs)]
- return rffi.cast(rffi.LONGDOUBLE, space.float_w(call_capi(space, 'call_ld', args)))
+ #return rffi.cast(rffi.LONGDOUBLE, space.float_w(call_capi(space, 'call_ld', args)))
+ # call_nld narrows long double to double
+ return rffi.cast(rffi.DOUBLE, space.float_w(call_capi(space, 'call_nld', args)))
def c_call_r(space, cppmethod, cppobject, nargs, cargs):
args = [_ArgH(cppmethod), _ArgH(cppobject), _ArgL(nargs), _ArgP(cargs)]
@@ -561,16 +582,21 @@
def c_is_const_method(space, cppmeth):
return space.bool_w(call_capi(space, 'is_const_method', [_ArgH(cppmeth)]))
+def c_get_num_templated_methods(space, cppscope):
+ return space.int_w(call_capi(space, 'method_is_template', [_ArgH(cppscope.handle)]))
+def c_get_templated_method_name(space, cppscope, index):
+ args = [_ArgH(cppscope.handle), _ArgL(index)]
+ return charp2str_free(space, call_capi(space, 'method_is_template', args))
def c_exists_method_template(space, cppscope, name):
args = [_ArgH(cppscope.handle), _ArgS(name)]
return space.bool_w(call_capi(space, 'exists_method_template', args))
def c_method_is_template(space, cppscope, index):
args = [_ArgH(cppscope.handle), _ArgL(index)]
return space.bool_w(call_capi(space, 'method_is_template', args))
-
def c_get_method_template(space, cppscope, name, proto):
args = [_ArgH(cppscope.handle), _ArgS(name), _ArgS(proto)]
return rffi.cast(C_METHOD, space.uint_w(call_capi(space, 'get_method_template', args)))
+
def c_get_global_operator(space, nss, lc, rc, op):
if nss is not None:
args = [_ArgH(nss.handle), _ArgH(lc.handle), _ArgH(rc.handle), _ArgS(op)]
@@ -619,7 +645,7 @@
return space.bool_w(call_capi(space, 'is_enum_data', args))
def c_get_dimension_size(space, cppscope, datamember_index, dim_idx):
args = [_ArgH(cppscope.handle), _ArgL(datamember_index), _ArgL(dim_idx)]
- return space.bool_w(call_capi(space, 'get_dimension_size', args))
+ return space.int_w(call_capi(space, 'get_dimension_size', args))
# misc helpers ---------------------------------------------------------------
def c_strtoll(space, svalue):
@@ -650,24 +676,94 @@
def c_stdstring2stdstring(space, cppobject):
return _cdata_to_cobject(space, call_capi(space, 'stdstring2stdstring', [_ArgH(cppobject)]))
-def c_stdvector_valuetype(space, pystr):
- return charp2str_free(space, call_capi(space, 'stdvector_valuetype', [_ArgS(pystr)]))
+def c_longdouble2double(space, addr):
+ return space.float_w(call_capi(space, 'longdouble2double', [_ArgP(addr)]))
+def c_double2longdouble(space, dval, addr):
+ call_capi(space, 'double2longdouble', [_ArgD(dval), _ArgP(addr)])
-def c_stdvector_valuetype(space, pystr):
- return charp2str_free(space, call_capi(space, 'stdvector_valuetype', [_ArgS(pystr)]))
-def c_stdvector_valuesize(space, pystr):
- return _cdata_to_size_t(space, call_capi(space, 'stdvector_valuesize', [_ArgS(pystr)]))
+def c_vectorbool_getitem(space, vbool, idx):
+ return call_capi(space, 'vectorbool_getitem', [_ArgH(vbool), _ArgL(idx)])
+def c_vectorbool_setitem(space, vbool, idx, value):
+ call_capi(space, 'vectorbool_setitem', [_ArgH(vbool), _ArgL(idx), _ArgL(value)])
# TODO: factor these out ...
# pythonizations
def stdstring_c_str(space, w_self):
"""Return a python string taking into account \0"""
-
from pypy.module._cppyy import interp_cppyy
cppstr = space.interp_w(interp_cppyy.W_CPPInstance, w_self, can_be_None=False)
return space.newtext(c_stdstring2charp(space, cppstr._rawobject))
+def vbool_getindex(space, w_vbool, w_idx):
+ idx = space.getindex_w(w_idx, space.w_IndexError, "std::vector<bool> index")
+ sz = space.len_w(w_vbool)
+ if idx < 0: idx += sz
+ if idx < 0 or idx >= sz:
+ raise IndexError
+ return idx
+
+def vectorbool_getitem(space, w_self, w_idx):
+ """Index a std::vector<bool>, return the value"""
+ from pypy.module._cppyy import interp_cppyy
+ vbool = space.interp_w(interp_cppyy.W_CPPInstance, w_self, can_be_None=False)
+ idx = vbool_getindex(space, w_self, w_idx)
+ item = c_vectorbool_getitem(space, vbool._rawobject, idx)
+ return space.newbool(space.is_true(item))
+
+def vectorbool_setitem(space, w_self, w_idx, w_value):
+ """Index a std::vector<bool>, set the value"""
+ from pypy.module._cppyy import interp_cppyy
+ vbool = space.interp_w(interp_cppyy.W_CPPInstance, w_self, can_be_None=False)
+ idx = vbool_getindex(space, w_self, w_idx)
+ c_vectorbool_setitem(space, vbool._rawobject, idx, int(space.is_true(w_value)))
+
+class W_STLVectorIter(W_AbstractSeqIterObject):
+ # w_seq and index are in base class
+ _immutable_fields_ = ['converter', 'data', 'len', 'stride']
+
+ def __init__(self, space, w_vector):
+ W_AbstractSeqIterObject.__init__(self, w_vector)
+ # TODO: this should live in rpythonize.py or something so that the
+ # imports can move to the top w/o getting circles
+ from pypy.module._cppyy import interp_cppyy
+ assert isinstance(w_vector, interp_cppyy.W_CPPInstance)
+ vector = space.interp_w(interp_cppyy.W_CPPInstance, w_vector)
+
+ v_type = c_resolve_name(space, vector.clsdecl.name+'::value_type')
+ v_size = c_size_of_type(space, v_type)
+
+ if not v_type or not v_size:
+ raise NotImplementedError # fallback on getitem
+
+ from pypy.module._cppyy import converter
+ self.converter = converter.get_converter(space, v_type, '')
+
+ # this 'data' is from the decl, so not the pythonized data from pythonify.py
+ w_arr = space.call_obj_args(vector.clsdecl.get_overload('data'), w_vector, Arguments(space, []))
+ arr = space.interp_w(W_ArrayInstance, w_arr, can_be_None=True)
+ if not arr:
+ raise OperationError(space.w_StopIteration, space.w_None)
+
+ self.data = rffi.cast(rffi.CCHARP, space.uint_w(arr.getbuffer(space)))
+ self.len = space.uint_w(space.call_obj_args(vector.clsdecl.get_overload('size'), w_vector, Arguments(space, [])))
+ self.stride = v_size
+
+ def descr_next(self, space):
+ if self.w_seq is None:
+ raise OperationError(space.w_StopIteration, space.w_None)
+ if self.len <= self.index:
+ self.w_seq = None
+ raise OperationError(space.w_StopIteration, space.w_None)
+ offset = lltype.direct_ptradd(self.data, rffi.cast(rffi.SIZE_T, self.index*self.stride))
+ w_item = self.converter.from_memory(space, space.w_None, rffi.cast(rffi.LONG, offset))
+ self.index += 1
+ return w_item
+
+def stdvector_iter(space, w_self):
+ return W_STLVectorIter(space, w_self)
+
+
# setup pythonizations for later use at run-time
_pythonizations = {}
def register_pythonizations(space):
@@ -678,6 +774,12 @@
### std::string
stdstring_c_str,
+ ### std::vector
+ stdvector_iter,
+
+ ### std::vector<bool>
+ vectorbool_getitem,
+ vectorbool_setitem,
]
for f in allfuncs:
@@ -692,3 +794,10 @@
space.setattr(w_pycppclass, space.newtext("c_str"), _pythonizations["stdstring_c_str"])
_method_alias(space, w_pycppclass, "_cppyy_as_builtin", "c_str")
_method_alias(space, w_pycppclass, "__str__", "c_str")
+
+ if name.find("std::vector<bool", 0, 16) == 0:
+ space.setattr(w_pycppclass, space.newtext("__getitem__"), _pythonizations["vectorbool_getitem"])
+ space.setattr(w_pycppclass, space.newtext("__setitem__"), _pythonizations["vectorbool_setitem"])
+
+ elif name.find("std::vector", 0, 11) == 0:
+ space.setattr(w_pycppclass, space.newtext("__iter__"), _pythonizations["stdvector_iter"])
diff --git a/pypy/module/_cppyy/converter.py b/pypy/module/_cppyy/converter.py
--- a/pypy/module/_cppyy/converter.py
+++ b/pypy/module/_cppyy/converter.py
@@ -115,7 +115,7 @@
from pypy.module._cppyy.interp_cppyy import FastCallNotPossible
raise FastCallNotPossible
- def from_memory(self, space, w_obj, w_pycppclass, offset):
+ def from_memory(self, space, w_obj, offset):
self._is_abstract(space)
def to_memory(self, space, w_obj, w_value, offset):
@@ -142,7 +142,7 @@
state = space.fromcache(ffitypes.State)
return state.c_voidp
- def from_memory(self, space, w_obj, w_pycppclass, offset):
+ def from_memory(self, space, w_obj, offset):
# read access, so no copy needed
address_value = self._get_raw_address(space, w_obj, offset)
address = rffi.cast(rffi.ULONG, address_value)
@@ -184,7 +184,7 @@
ba = rffi.cast(rffi.CCHARP, address)
ba[capi.c_function_arg_typeoffset(space)] = 'o'
- def from_memory(self, space, w_obj, w_pycppclass, offset):
+ def from_memory(self, space, w_obj, offset):
# read access, so no copy needed
address_value = self._get_raw_address(space, w_obj, offset)
address = rffi.cast(rffi.ULONGP, address_value)
@@ -211,10 +211,13 @@
x[0] = self._unwrap_object(space, w_obj)
def default_argument_libffi(self, space, address):
+ if not self.valid_default:
+ from pypy.module._cppyy.interp_cppyy import FastCallNotPossible
+ raise FastCallNotPossible
x = rffi.cast(self.c_ptrtype, address)
x[0] = self.default
- def from_memory(self, space, w_obj, w_pycppclass, offset):
+ def from_memory(self, space, w_obj, offset):
address = self._get_raw_address(space, w_obj, offset)
rffiptr = rffi.cast(self.c_ptrtype, address)
return self._wrap_object(space, rffiptr[0])
@@ -224,7 +227,7 @@
rffiptr = rffi.cast(self.c_ptrtype, address)
rffiptr[0] = self._unwrap_object(space, w_value)
-class ConstRefNumericTypeConverterMixin(NumericTypeConverterMixin):
+class ConstRefNumericTypeConverterMixin(object):
_mixin_ = True
def cffi_type(self, space):
@@ -283,7 +286,7 @@
x = rffi.cast(rffi.LONGP, address)
x[0] = self._unwrap_object(space, w_obj)
- def from_memory(self, space, w_obj, w_pycppclass, offset):
+ def from_memory(self, space, w_obj, offset):
address = rffi.cast(rffi.CCHARP, self._get_raw_address(space, w_obj, offset))
if address[0] == '\x01':
return space.w_True
@@ -308,7 +311,7 @@
x = rffi.cast(self.c_ptrtype, address)
x[0] = self._unwrap_object(space, w_obj)
- def from_memory(self, space, w_obj, w_pycppclass, offset):
+ def from_memory(self, space, w_obj, offset):
address = rffi.cast(rffi.CCHARP, self._get_raw_address(space, w_obj, offset))
return space.newbytes(address[0])
@@ -321,59 +324,92 @@
pass
class FloatConverter(ffitypes.typeid(rffi.FLOAT), FloatTypeConverterMixin, TypeConverter):
- _immutable_fields_ = ['default']
+ _immutable_fields_ = ['default', 'valid_default']
def __init__(self, space, default):
- if default:
+ self.valid_default = False
+ try:
fval = float(rfloat.rstring_to_float(default))
- else:
+ self.valid_default = True
+ except Exception:
fval = float(0.)
- self.default = r_singlefloat(fval)
+ self.default = rffi.cast(rffi.FLOAT, r_singlefloat(fval))
- def from_memory(self, space, w_obj, w_pycppclass, offset):
+ def from_memory(self, space, w_obj, offset):
address = self._get_raw_address(space, w_obj, offset)
rffiptr = rffi.cast(self.c_ptrtype, address)
return self._wrap_object(space, rffiptr[0])
More information about the pypy-commit
mailing list