[pypy-commit] pypy py3.5: merge default into py3.5
mattip
pypy.commits at gmail.com
Mon Mar 26 18:13:46 EDT 2018
Author: Matti Picus <matti.picus at gmail.com>
Branch: py3.5
Changeset: r94140:96851b8e1c6a
Date: 2018-03-26 14:29 +0300
http://bitbucket.org/pypy/pypy/changeset/96851b8e1c6a/
Log: merge default into py3.5
diff too long, truncating to 2000 out of 2028 lines
diff --git a/README.rst b/README.rst
--- a/README.rst
+++ b/README.rst
@@ -4,42 +4,40 @@
Welcome to PyPy!
-PyPy is both an implementation of the Python programming language, and
-an extensive compiler framework for dynamic language implementations.
-You can build self-contained Python implementations which execute
-independently from CPython.
+PyPy is an interperter that implements the Python programming language, based
+on the RPython compiler framework for dynamic language implementations.
-The home page is:
+The home page for the interpreter is:
http://pypy.org/
-If you want to help developing PyPy, this document might help you:
+If you want to help developing PyPy, this documentation might help you:
http://doc.pypy.org/
-It will also point you to the rest of the documentation which is generated
-from files in the pypy/doc directory within the source repositories. Enjoy
-and send us feedback!
+More documentation about the RPython framework can be found here
- the pypy-dev team <pypy-dev at python.org>
+ http://rpython.readthedocs.io
+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
+download and use PyPy as an alternative to CPython.
Building
========
-First switch to or download the correct branch. The basic choices are
-``default`` for Python 2.7 and, for Python 3.X, the corresponding py3.X
-branch (e.g. ``py3.5``).
+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
-Build with:
+ http://doc.pypy.org/en/latest/build.html
-.. code-block:: console
+Enjoy and send us feedback!
- $ rpython/bin/rpython -Ojit pypy/goal/targetpypystandalone.py
+ the pypy-dev team <pypy-dev at python.org>
-This ends up with a ``pypy-c`` or ``pypy3-c`` binary in the main pypy
-directory. We suggest to use virtualenv with the resulting
-pypy-c/pypy3-c as the interpreter; you can find more details about
-various installation schemes here:
- http://doc.pypy.org/en/latest/install.html
diff --git a/pypy/doc/install.rst b/pypy/doc/install.rst
--- a/pypy/doc/install.rst
+++ b/pypy/doc/install.rst
@@ -17,13 +17,18 @@
~~~~~~~~~~~~~~~~~~~~~~~~~
The quickest way to start using PyPy is to download a prebuilt binary for your
-OS and architecture. You can either use the `most recent release`_ or one of
-our `development nightly build`_. Please note that the nightly builds are not
+OS and architecture. You may be able to use either use the
+`most recent release`_ or one of our `development nightly build`_. These
+builds depend on dynamically linked libraries that may not be available on your
+OS. See the section about `Linux binaries` for more info and alternatives that
+may work on your system.
+
+Please note that the nightly builds are not
guaranteed to be as stable as official releases, use them at your own risk.
.. _most recent release: http://pypy.org/download.html
.. _development nightly build: http://buildbot.pypy.org/nightly/trunk/
-
+.. _Linux binaries: http://pypy.org/download.html#linux-binaries-and-common-distributions
Installing PyPy
~~~~~~~~~~~~~~~
@@ -69,9 +74,9 @@
~~~~~~~~~~~~~~~~~~~~~~~~~~~
It is often convenient to run pypy inside a virtualenv. To do this
-you need a recent version of virtualenv -- 1.6.1 or greater. You can
+you need a version of virtualenv -- 1.6.1 or greater. You can
then install PyPy both from a precompiled tarball or from a mercurial
-checkout::
+checkout after translation::
# from a tarball
$ virtualenv -p /opt/pypy-xxx/bin/pypy my-pypy-env
diff --git a/pypy/module/_sre/interp_sre.py b/pypy/module/_sre/interp_sre.py
--- a/pypy/module/_sre/interp_sre.py
+++ b/pypy/module/_sre/interp_sre.py
@@ -357,12 +357,13 @@
sublist_w = []
n = last_pos = 0
while not count or n < count:
+ pattern = ctx.pattern
sub_jitdriver.jit_merge_point(
self=self,
use_builder=use_builder,
filter_is_callable=filter_is_callable,
filter_type=type(w_filter),
- ctx=ctx,
+ ctx=ctx, pattern=pattern,
w_filter=w_filter,
strbuilder=strbuilder,
unicodebuilder=unicodebuilder,
@@ -437,7 +438,7 @@
filter_as_unicode
w_string sublist_w
self""".split(),
- greens=["filter_is_callable", "use_builder", "filter_type", "ctx.pattern"])
+ greens=["filter_is_callable", "use_builder", "filter_type", "pattern"])
def _sub_append_slice(ctx, space, use_builder, sublist_w,
diff --git a/pypy/module/cpyext/api.py b/pypy/module/cpyext/api.py
--- a/pypy/module/cpyext/api.py
+++ b/pypy/module/cpyext/api.py
@@ -135,6 +135,11 @@
'TYPE', 'BYTES'):
constant_names.append('Py_TPFLAGS_%s_SUBCLASS' % name)
+# PyPy-specific flags
+for name in ('FLOAT',):
+ constant_names.append('Py_TPPYPYFLAGS_%s_SUBCLASS' % name)
+
+
for name in constant_names:
setattr(CConfig_constants, name, rffi_platform.ConstantInteger(name))
globals().update(rffi_platform.configure(CConfig_constants))
diff --git a/pypy/module/cpyext/boolobject.py b/pypy/module/cpyext/boolobject.py
--- a/pypy/module/cpyext/boolobject.py
+++ b/pypy/module/cpyext/boolobject.py
@@ -1,9 +1,5 @@
-from rpython.rtyper.lltypesystem import rffi, lltype
-from pypy.module.cpyext.api import (cpython_api, PyObject, CANNOT_FAIL,
- build_type_checkers)
-
-# Inheriting from bool isn't actually possible.
-PyBool_Check = build_type_checkers("Bool")[1]
+from rpython.rtyper.lltypesystem import rffi
+from pypy.module.cpyext.api import cpython_api, PyObject
@cpython_api([rffi.LONG], PyObject)
def PyBool_FromLong(space, value):
diff --git a/pypy/module/cpyext/floatobject.py b/pypy/module/cpyext/floatobject.py
--- a/pypy/module/cpyext/floatobject.py
+++ b/pypy/module/cpyext/floatobject.py
@@ -1,7 +1,7 @@
from rpython.rtyper.lltypesystem import rffi, lltype
from pypy.module.cpyext.api import (PyObjectFields, bootstrap_function,
cpython_struct,
- CANNOT_FAIL, cpython_api, PyObject, build_type_checkers, CONST_STRING)
+ CANNOT_FAIL, cpython_api, PyObject, CONST_STRING)
from pypy.module.cpyext.pyobject import (
make_typedescr, track_reference, from_ref)
from pypy.interpreter.error import OperationError
@@ -38,8 +38,6 @@
track_reference(space, obj, w_obj)
return w_obj
-PyFloat_Check, PyFloat_CheckExact = build_type_checkers("Float")
-
@cpython_api([lltype.Float], PyObject)
def PyFloat_FromDouble(space, value):
return space.newfloat(value)
diff --git a/pypy/module/cpyext/frameobject.py b/pypy/module/cpyext/frameobject.py
--- a/pypy/module/cpyext/frameobject.py
+++ b/pypy/module/cpyext/frameobject.py
@@ -82,10 +82,10 @@
def PyTraceBack_Here(space, w_frame):
from pypy.interpreter.pytraceback import record_application_traceback
state = space.fromcache(State)
- if state.operror is None:
+ if state.get_exception() is None:
return -1
frame = space.interp_w(PyFrame, w_frame)
- record_application_traceback(space, state.operror, frame, 0)
+ record_application_traceback(space, state.get_exception(), frame, 0)
return 0
@cpython_api([PyObject], rffi.INT_real, error=CANNOT_FAIL)
diff --git a/pypy/module/cpyext/include/boolobject.h b/pypy/module/cpyext/include/boolobject.h
--- a/pypy/module/cpyext/include/boolobject.h
+++ b/pypy/module/cpyext/include/boolobject.h
@@ -14,6 +14,8 @@
#define Py_RETURN_TRUE return Py_INCREF(Py_True), Py_True
#define Py_RETURN_FALSE return Py_INCREF(Py_False), Py_False
+#define PyBool_Check(op) ((op)->ob_type == &PyBool_Type)
+
#ifdef __cplusplus
}
#endif
diff --git a/pypy/module/cpyext/include/floatobject.h b/pypy/module/cpyext/include/floatobject.h
--- a/pypy/module/cpyext/include/floatobject.h
+++ b/pypy/module/cpyext/include/floatobject.h
@@ -32,6 +32,11 @@
return PyFloat_FromDouble(-Py_HUGE_VAL); \
} while(0)
+#define PyFloat_Check(op) \
+ _PyPy_Type_FastSubclass((op)->ob_type, Py_TPPYPYFLAGS_FLOAT_SUBCLASS)
+#define PyFloat_CheckExact(op) ((op)->ob_type == &PyFloat_Type)
+
+
#ifdef __cplusplus
}
#endif
diff --git a/pypy/module/cpyext/include/object.h b/pypy/module/cpyext/include/object.h
--- a/pypy/module/cpyext/include/object.h
+++ b/pypy/module/cpyext/include/object.h
@@ -218,6 +218,12 @@
#define Py_TPFLAGS_BASE_EXC_SUBCLASS (1UL << 30)
#define Py_TPFLAGS_TYPE_SUBCLASS (1UL << 31)
+
+/* These are conceptually the same as the flags above, but they are
+ PyPy-specific and are stored inside tp_pypy_flags */
+#define Py_TPPYPYFLAGS_FLOAT_SUBCLASS (1L<<0)
+
+
#define Py_TPFLAGS_DEFAULT ( \
Py_TPFLAGS_HAVE_STACKLESS_EXTENSION | \
Py_TPFLAGS_HAVE_VERSION_TAG | \
@@ -236,6 +242,8 @@
#endif
#define PyType_FastSubclass(t,f) PyType_HasFeature(t,f)
+#define _PyPy_Type_FastSubclass(t,f) (((t)->tp_pypy_flags & (f)) != 0)
+
#define PyType_Check(op) \
PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TYPE_SUBCLASS)
#define PyType_CheckExact(op) (Py_TYPE(op) == &PyType_Type)
diff --git a/pypy/module/cpyext/include/sliceobject.h b/pypy/module/cpyext/include/sliceobject.h
--- a/pypy/module/cpyext/include/sliceobject.h
+++ b/pypy/module/cpyext/include/sliceobject.h
@@ -17,6 +17,8 @@
PyObject *step;
} PySliceObject;
+#define PySlice_Check(op) ((op)->ob_type == &PySlice_Type)
+
#ifdef __cplusplus
}
#endif
diff --git a/pypy/module/cpyext/methodobject.py b/pypy/module/cpyext/methodobject.py
--- a/pypy/module/cpyext/methodobject.py
+++ b/pypy/module/cpyext/methodobject.py
@@ -45,6 +45,18 @@
from pypy.module.cpyext.object import _dealloc
_dealloc(space, py_obj)
+def w_kwargs_from_args(space, __args__):
+ w_kwargs = None
+ if __args__.keywords:
+ # CCC: we should probably have a @jit.look_inside_iff if the
+ # keyword count is constant, as we do in Arguments.unpack
+ w_kwargs = space.newdict()
+ for i in range(len(__args__.keywords)):
+ key = __args__.keywords[i]
+ w_obj = __args__.keywords_w[i]
+ space.setitem(w_kwargs, space.newtext(key), w_obj)
+ return w_kwargs
+
def undotted_name(name):
"""Return the last component of a dotted name"""
dotpos = name.rfind('.')
@@ -136,15 +148,7 @@
def call_keywords(self, space, w_self, __args__):
func = rffi.cast(PyCFunctionKwArgs, self.ml.c_ml_meth)
py_args = tuple_from_args_w(space, __args__.arguments_w)
- w_kwargs = None
- if __args__.keywords:
- # CCC: we should probably have a @jit.look_inside_iff if the
- # keyword count is constant, as we do in Arguments.unpack
- w_kwargs = space.newdict()
- for i in range(len(__args__.keywords)):
- key = __args__.keywords[i]
- w_obj = __args__.keywords_w[i]
- space.setitem(w_kwargs, space.newtext(key), w_obj)
+ w_kwargs = w_kwargs_from_args(space, __args__)
try:
return generic_cpy_call(space, func, w_self, py_args, w_kwargs)
finally:
@@ -243,14 +247,15 @@
(self.name.decode('utf-8'), self.w_objclass.getname(self.space)))
+class W_PyCWrapperObject(W_Root):
+ """
+ Abstract class; for concrete subclasses, see slotdefs.py
+ """
+ _immutable_fields_ = ['offset[*]']
-class W_PyCWrapperObject(W_Root):
- def __init__(self, space, pto, method_name, wrapper_func,
- wrapper_func_kwds, doc, func, offset=None):
+ def __init__(self, space, pto, method_name, doc, func, offset):
self.space = space
self.method_name = method_name
- self.wrapper_func = wrapper_func
- self.wrapper_func_kwds = wrapper_func_kwds
self.doc = doc
self.func = func
self.offset = offset
@@ -259,10 +264,17 @@
assert isinstance(w_type, W_TypeObject)
self.w_objclass = w_type
- def call(self, space, w_self, w_args, w_kw):
+ def descr_call(self, space, w_self, __args__):
+ return self.call(space, w_self, __args__)
+
+ def call(self, space, w_self, __args__):
+ raise NotImplementedError
+
+ @jit.unroll_safe
+ def get_func_to_call(self):
func_to_call = self.func
if self.offset:
- pto = as_pyobj(space, self.w_objclass)
+ pto = as_pyobj(self.space, self.w_objclass)
# make ptr the equivalent of this, using the offsets
#func_to_call = rffi.cast(rffi.VOIDP, ptr.c_tp_as_number.c_nb_multiply)
if pto:
@@ -276,31 +288,33 @@
assert False, "failed to convert w_type %s to PyObject" % str(
self.w_objclass)
assert func_to_call
- if self.wrapper_func is None:
- assert self.wrapper_func_kwds is not None
- return self.wrapper_func_kwds(space, w_self, w_args, func_to_call,
- w_kw)
- if space.is_true(w_kw):
- raise oefmt(space.w_TypeError,
+ return func_to_call
+
+ def check_args(self, __args__, arity):
+ length = len(__args__.arguments_w)
+ if length != arity:
+ raise oefmt(self.space.w_TypeError, "expected %d arguments, got %d",
+ arity, length)
+ if __args__.keywords:
+ raise oefmt(self.space.w_TypeError,
"wrapper %s doesn't take any keyword arguments",
self.method_name)
- return self.wrapper_func(space, w_self, w_args, func_to_call)
+
+ def check_argsv(self, __args__, min, max):
+ length = len(__args__.arguments_w)
+ if not min <= length <= max:
+ raise oefmt(self.space.w_TypeError, "expected %d-%d arguments, got %d",
+ min, max, length)
+ if __args__.keywords:
+ raise oefmt(self.space.w_TypeError,
+ "wrapper %s doesn't take any keyword arguments",
+ self.method_name)
def descr_method_repr(self):
return self.space.newtext("<slot wrapper '%s' of '%s' objects>" %
(self.method_name,
self.w_objclass.name))
- at jit.dont_look_inside
-def cwrapper_descr_call(space, w_self, __args__):
- self = space.interp_w(W_PyCWrapperObject, w_self)
- args_w, kw_w = __args__.unpack()
- w_args = space.newtuple(args_w[1:])
- w_self = args_w[0]
- w_kw = space.newdict()
- for key, w_obj in kw_w.items():
- space.setitem(w_kw, space.newtext(key), w_obj)
- return self.call(space, w_self, w_args, w_kw)
def cmethod_descr_get(space, w_function, w_obj, w_cls=None):
if w_obj is None or space.is_w(w_obj, space.w_None):
@@ -351,7 +365,7 @@
W_PyCWrapperObject.typedef = TypeDef(
'wrapper_descriptor',
- __call__ = interp2app(cwrapper_descr_call),
+ __call__ = interp2app(W_PyCWrapperObject.descr_call),
__get__ = interp2app(cmethod_descr_get),
__name__ = interp_attrproperty('method_name', cls=W_PyCWrapperObject,
wrapfn="newtext_or_none"),
diff --git a/pypy/module/cpyext/parse/cpyext_object.h b/pypy/module/cpyext/parse/cpyext_object.h
--- a/pypy/module/cpyext/parse/cpyext_object.h
+++ b/pypy/module/cpyext/parse/cpyext_object.h
@@ -288,6 +288,11 @@
unsigned int tp_version_tag;
destructor tp_finalize;
+
+ /* PyPy specific extra fields: make sure that they are ALWAYS at the end,
+ for compatibility with CPython */
+ long tp_pypy_flags;
+
} PyTypeObject;
typedef struct{
diff --git a/pypy/module/cpyext/pyerrors.py b/pypy/module/cpyext/pyerrors.py
--- a/pypy/module/cpyext/pyerrors.py
+++ b/pypy/module/cpyext/pyerrors.py
@@ -67,9 +67,10 @@
@cpython_api([], PyObject, result_borrowed=True)
def PyErr_Occurred(space):
state = space.fromcache(State)
- if state.operror is None:
+ operror = state.get_exception()
+ if operror is None:
return None
- return state.operror.w_type # borrowed ref
+ return operror.w_type # borrowed ref
@cpython_api([], lltype.Void)
def PyErr_Clear(space):
diff --git a/pypy/module/cpyext/sliceobject.py b/pypy/module/cpyext/sliceobject.py
--- a/pypy/module/cpyext/sliceobject.py
+++ b/pypy/module/cpyext/sliceobject.py
@@ -47,7 +47,6 @@
from pypy.module.cpyext.object import _dealloc
_dealloc(space, py_obj)
-PySlice_Check, PySlice_CheckExact = build_type_checkers("Slice")
@cpython_api([PyObject, PyObject, PyObject], PyObject)
def PySlice_New(space, w_start, w_stop, w_step):
@@ -75,9 +74,8 @@
normal slices.
Returns 0 on success and -1 on error with exception set."""
- if not PySlice_Check(space, w_slice):
+ if not isinstance(w_slice, W_SliceObject):
PyErr_BadInternalCall(space)
- assert isinstance(w_slice, W_SliceObject)
start_p[0], stop_p[0], step_p[0], slicelength_p[0] = \
w_slice.indices4(space, length)
return 0
@@ -97,9 +95,8 @@
objects in versions of Python prior to 2.3, you would probably do well to
incorporate the source of PySlice_GetIndicesEx(), suitably renamed,
in the source of your extension."""
- if not PySlice_Check(space, w_slice):
+ if not isinstance(w_slice, W_SliceObject):
PyErr_BadInternalCall(space)
- assert isinstance(w_slice, W_SliceObject)
start_p[0], stop_p[0], step_p[0] = \
w_slice.indices3(space, length)
return 0
diff --git a/pypy/module/cpyext/slotdefs.py b/pypy/module/cpyext/slotdefs.py
--- a/pypy/module/cpyext/slotdefs.py
+++ b/pypy/module/cpyext/slotdefs.py
@@ -19,6 +19,8 @@
from pypy.module.cpyext.state import State
from pypy.module.cpyext import userslot
from pypy.module.cpyext.buffer import CBuffer, CPyBuffer, fq
+from pypy.module.cpyext.methodobject import (W_PyCWrapperObject, tuple_from_args_w,
+ w_kwargs_from_args)
from pypy.interpreter.error import OperationError, oefmt
from pypy.interpreter.argument import Arguments
from rpython.rlib.unroll import unrolling_iterable
@@ -38,29 +40,6 @@
Py_GT = 4
Py_GE = 5
-
-def check_num_args(space, w_ob, n):
- from pypy.module.cpyext.tupleobject import PyTuple_CheckExact
- if not PyTuple_CheckExact(space, w_ob):
- raise oefmt(space.w_SystemError,
- "PyArg_UnpackTuple() argument list is not a tuple")
- if n == space.len_w(w_ob):
- return
- raise oefmt(space.w_TypeError,
- "expected %d arguments, got %d",
- n, space.len_w(w_ob))
-
-def check_num_argsv(space, w_ob, low, high):
- from pypy.module.cpyext.tupleobject import PyTuple_CheckExact
- if not PyTuple_CheckExact(space, w_ob):
- raise oefmt(space.w_SystemError,
- "PyArg_UnpackTuple() argument list is not a tuple")
- if low <=space.len_w(w_ob) <= high:
- return
- raise oefmt(space.w_TypeError,
- "expected %d-%d arguments, got %d",
- low, high, space.len_w(w_ob))
-
@not_rpython
def llslot(space, func):
return func.api_func.get_llhelper(space)
@@ -71,325 +50,401 @@
get_llhelper = v_func.value.api_func.get_llhelper
return ctx.appcall(get_llhelper, v_space)
+# NOTE: the following wrap_* are subclasses of W_PyCWrapperObject, even if
+# they don't follow the usual W_* naming convention for subclasses of W_Root:
+# we do this because we automatically generate most of the slots from the
+# CPython code copy&pasted inside slotdefs_str, and thus we need to keep the
+# same names as they are used in C.
-def wrap_init(space, w_self, w_args, func, w_kwargs):
- func_init = rffi.cast(initproc, func)
- res = generic_cpy_call(space, func_init, w_self, w_args, w_kwargs)
- if rffi.cast(lltype.Signed, res) == -1:
- space.fromcache(State).check_and_raise_exception(always=True)
- return None
+class wrap_init(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ func = self.get_func_to_call()
+ func_init = rffi.cast(initproc, func)
+ py_args = tuple_from_args_w(space, __args__.arguments_w)
+ w_kwargs = w_kwargs_from_args(space, __args__)
+ res = generic_cpy_call(space, func_init, w_self, py_args, w_kwargs)
+ if rffi.cast(lltype.Signed, res) == -1:
+ space.fromcache(State).check_and_raise_exception(always=True)
+ return None
-def wrap_unaryfunc(space, w_self, w_args, func):
- func_unary = rffi.cast(unaryfunc, func)
- check_num_args(space, w_args, 0)
- return generic_cpy_call(space, func_unary, w_self)
+class wrap_unaryfunc(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ self.check_args(__args__, 0)
+ func = self.get_func_to_call()
+ func_unary = rffi.cast(unaryfunc, func)
+ return generic_cpy_call(space, func_unary, w_self)
-def wrap_binaryfunc(space, w_self, w_args, func):
- func_binary = rffi.cast(binaryfunc, func)
- check_num_args(space, w_args, 1)
- args_w = space.fixedview(w_args)
- return generic_cpy_call(space, func_binary, w_self, args_w[0])
+class wrap_binaryfunc(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ self.check_args(__args__, 1)
+ func = self.get_func_to_call()
+ func_binary = rffi.cast(binaryfunc, func)
+ w_x = __args__.arguments_w[0]
+ return generic_cpy_call(space, func_binary, w_self, w_x)
def _get_ob_type(space, w_obj):
# please ensure that w_obj stays alive
ob_type = as_pyobj(space, space.type(w_obj))
return rffi.cast(PyTypeObjectPtr, ob_type)
-def wrap_binaryfunc_l(space, w_self, w_args, func):
- func_binary = rffi.cast(binaryfunc, func)
- check_num_args(space, w_args, 1)
- args_w = space.fixedview(w_args)
- return generic_cpy_call(space, func_binary, w_self, args_w[0])
+class wrap_binaryfunc_l(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ self.check_args(__args__, 1)
+ func = self.get_func_to_call()
+ func_binary = rffi.cast(binaryfunc, func)
+ w_value = __args__.arguments_w[0]
+ return generic_cpy_call(space, func_binary, w_self, w_value)
-def wrap_binaryfunc_r(space, w_self, w_args, func):
- func_binary = rffi.cast(binaryfunc, func)
- check_num_args(space, w_args, 1)
- args_w = space.fixedview(w_args)
- return generic_cpy_call(space, func_binary, args_w[0], w_self)
+class wrap_binaryfunc_r(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ self.check_args(__args__, 1)
+ func = self.get_func_to_call()
+ func_binary = rffi.cast(binaryfunc, func)
+ w_value = __args__.arguments_w[0]
+ return generic_cpy_call(space, func_binary, w_value, w_self)
-def wrap_ternaryfunc(space, w_self, w_args, func):
- # The third argument is optional
- func_ternary = rffi.cast(ternaryfunc, func)
- check_num_argsv(space, w_args, 1, 2)
- args_w = space.fixedview(w_args)
- arg3 = space.w_None
- if len(args_w) > 1:
- arg3 = args_w[1]
- return generic_cpy_call(space, func_ternary, w_self, args_w[0], arg3)
+class wrap_ternaryfunc(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ # The third argument is optional
+ self.check_argsv(__args__, 1, 2)
+ func = self.get_func_to_call()
+ func_ternary = rffi.cast(ternaryfunc, func)
+ w_arg0 = __args__.arguments_w[0]
+ if len(__args__.arguments_w) == 2:
+ w_arg1 = __args__.arguments_w[1]
+ else:
+ w_arg1 = space.w_None
+ return generic_cpy_call(space, func_ternary, w_self, w_arg0, w_arg1)
-def wrap_ternaryfunc_r(space, w_self, w_args, func):
- # The third argument is optional
- func_ternary = rffi.cast(ternaryfunc, func)
- check_num_argsv(space, w_args, 1, 2)
- args_w = space.fixedview(w_args)
- arg3 = space.w_None
- if len(args_w) > 1:
- arg3 = args_w[1]
- return generic_cpy_call(space, func_ternary, args_w[0], w_self, arg3)
+class wrap_ternaryfunc_r(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ # The third argument is optional
+ self.check_argsv(__args__, 1, 2)
+ func = self.get_func_to_call()
+ func_ternary = rffi.cast(ternaryfunc, func)
+ w_arg0 = __args__.arguments_w[0]
+ if len(__args__.arguments_w) == 2:
+ w_arg1 = __args__.arguments_w[1]
+ else:
+ w_arg1 = space.w_None
+ return generic_cpy_call(space, func_ternary, w_arg0, w_self, w_arg1)
+class wrap_inquirypred(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ self.check_args(__args__, 0)
+ func = self.get_func_to_call()
+ func_inquiry = rffi.cast(inquiry, func)
+ res = generic_cpy_call(space, func_inquiry, w_self)
+ res = rffi.cast(lltype.Signed, res)
+ if res == -1:
+ space.fromcache(State).check_and_raise_exception(always=True)
+ return space.newbool(bool(res))
-def wrap_inquirypred(space, w_self, w_args, func):
- func_inquiry = rffi.cast(inquiry, func)
- check_num_args(space, w_args, 0)
- res = generic_cpy_call(space, func_inquiry, w_self)
- res = rffi.cast(lltype.Signed, res)
- if res == -1:
- space.fromcache(State).check_and_raise_exception(always=True)
- return space.newbool(bool(res))
+class wrap_getattr(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ self.check_args(__args__, 1)
+ func = self.get_func_to_call()
+ func_target = rffi.cast(getattrfunc, func)
+ w_name = __args__.arguments_w[0]
+ name_ptr = rffi.str2charp(space.text_w(w_name))
+ try:
+ return generic_cpy_call(space, func_target, w_self, name_ptr)
+ finally:
+ rffi.free_charp(name_ptr)
-def wrap_getattr(space, w_self, w_args, func):
- func_target = rffi.cast(getattrfunc, func)
- check_num_args(space, w_args, 1)
- args_w = space.fixedview(w_args)
- name_ptr = rffi.str2charp(space.text_w(args_w[0]))
- try:
- return generic_cpy_call(space, func_target, w_self, name_ptr)
- finally:
- rffi.free_charp(name_ptr)
+class wrap_getattro(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ self.check_args(__args__, 1)
+ func = self.get_func_to_call()
+ func_target = rffi.cast(getattrofunc, func)
+ w_name = __args__.arguments_w[0]
+ return generic_cpy_call(space, func_target, w_self, w_name)
-def wrap_getattro(space, w_self, w_args, func):
- func_target = rffi.cast(getattrofunc, func)
- check_num_args(space, w_args, 1)
- args_w = space.fixedview(w_args)
- return generic_cpy_call(space, func_target, w_self, args_w[0])
+class wrap_setattr(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ self.check_args(__args__, 2)
+ func = self.get_func_to_call()
+ func_target = rffi.cast(setattrofunc, func)
+ w_name = __args__.arguments_w[0]
+ w_value = __args__.arguments_w[1]
+ # XXX "Carlo Verre hack"?
+ res = generic_cpy_call(space, func_target, w_self, w_name, w_value)
+ if rffi.cast(lltype.Signed, res) == -1:
+ space.fromcache(State).check_and_raise_exception(always=True)
-def wrap_setattr(space, w_self, w_args, func):
- func_target = rffi.cast(setattrofunc, func)
- check_num_args(space, w_args, 2)
- w_name, w_value = space.fixedview(w_args)
- # XXX "Carlo Verre hack"?
- res = generic_cpy_call(space, func_target, w_self, w_name, w_value)
- if rffi.cast(lltype.Signed, res) == -1:
- space.fromcache(State).check_and_raise_exception(always=True)
+class wrap_delattr(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ self.check_args(__args__, 1)
+ func = self.get_func_to_call()
+ func_target = rffi.cast(setattrofunc, func)
+ w_name = __args__.arguments_w[0]
+ # XXX "Carlo Verre hack"?
+ res = generic_cpy_call(space, func_target, w_self, w_name, None)
+ if rffi.cast(lltype.Signed, res) == -1:
+ space.fromcache(State).check_and_raise_exception(always=True)
-def wrap_delattr(space, w_self, w_args, func):
- func_target = rffi.cast(setattrofunc, func)
- check_num_args(space, w_args, 1)
- w_name, = space.fixedview(w_args)
- # XXX "Carlo Verre hack"?
- res = generic_cpy_call(space, func_target, w_self, w_name, None)
- if rffi.cast(lltype.Signed, res) == -1:
- space.fromcache(State).check_and_raise_exception(always=True)
+class wrap_descr_get(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ func = self.get_func_to_call()
+ func_target = rffi.cast(descrgetfunc, func)
+ length = len(__args__.arguments_w)
+ if length == 1:
+ w_obj = __args__.arguments_w[0]
+ w_type = None
+ elif length == 2:
+ w_obj = __args__.arguments_w[0]
+ w_type = __args__.arguments_w[1]
+ else:
+ raise oefmt(space.w_TypeError,
+ "expected 1 or 2 arguments, got %d", len(__args__.arguments_w))
+ if w_obj is space.w_None:
+ w_obj = None
+ if w_type is space.w_None:
+ w_type = None
+ if w_obj is None and w_type is None:
+ raise oefmt(space.w_TypeError, "__get__(None, None) is invalid")
+ return generic_cpy_call(space, func_target, w_self, w_obj, w_type)
-def wrap_descr_get(space, w_self, w_args, func):
- func_target = rffi.cast(descrgetfunc, func)
- args_w = space.fixedview(w_args)
- if len(args_w) == 1:
- w_obj, = args_w
- w_type = None
- elif len(args_w) == 2:
- w_obj, w_type = args_w
- else:
- raise oefmt(space.w_TypeError,
- "expected 1 or 2 arguments, got %d", len(args_w))
- if w_obj is space.w_None:
- w_obj = None
- if w_type is space.w_None:
- w_type = None
- if w_obj is None and w_type is None:
- raise oefmt(space.w_TypeError, "__get__(None, None) is invalid")
- return generic_cpy_call(space, func_target, w_self, w_obj, w_type)
+class wrap_descr_set(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ self.check_args(__args__, 2)
+ func = self.get_func_to_call()
+ func_target = rffi.cast(descrsetfunc, func)
+ w_obj = __args__.arguments_w[0]
+ w_value = __args__.arguments_w[1]
+ res = generic_cpy_call(space, func_target, w_self, w_obj, w_value)
+ if rffi.cast(lltype.Signed, res) == -1:
+ space.fromcache(State).check_and_raise_exception(always=True)
-def wrap_descr_set(space, w_self, w_args, func):
- func_target = rffi.cast(descrsetfunc, func)
- check_num_args(space, w_args, 2)
- w_obj, w_value = space.fixedview(w_args)
- res = generic_cpy_call(space, func_target, w_self, w_obj, w_value)
- if rffi.cast(lltype.Signed, res) == -1:
- space.fromcache(State).check_and_raise_exception(always=True)
+class wrap_descr_delete(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ self.check_args(__args__, 1)
+ func = self.get_func_to_call()
+ func_target = rffi.cast(descrsetfunc, func)
+ w_obj = __args__.arguments_w[0]
+ res = generic_cpy_call(space, func_target, w_self, w_obj, None)
+ if rffi.cast(lltype.Signed, res) == -1:
+ space.fromcache(State).check_and_raise_exception(always=True)
-def wrap_descr_delete(space, w_self, w_args, func):
- func_target = rffi.cast(descrsetfunc, func)
- check_num_args(space, w_args, 1)
- w_obj, = space.fixedview(w_args)
- res = generic_cpy_call(space, func_target, w_self, w_obj, None)
- if rffi.cast(lltype.Signed, res) == -1:
- space.fromcache(State).check_and_raise_exception(always=True)
+class wrap_call(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ func = self.get_func_to_call()
+ func_target = rffi.cast(ternaryfunc, func)
+ py_args = tuple_from_args_w(space, __args__.arguments_w)
+ w_kwargs = w_kwargs_from_args(space, __args__)
+ return generic_cpy_call(space, func_target, w_self, py_args, w_kwargs)
-def wrap_call(space, w_self, w_args, func, w_kwds):
- func_target = rffi.cast(ternaryfunc, func)
- return generic_cpy_call(space, func_target, w_self, w_args, w_kwds)
+class wrap_ssizessizeobjargproc(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ self.check_args(__args__, 3)
+ func = self.get_func_to_call()
+ func_target = rffi.cast(ssizessizeobjargproc, func)
+ i = space.int_w(space.index(__args__.arguments_w[0]))
+ j = space.int_w(space.index(__args__.arguments_w[1]))
+ w_y = __args__.arguments_w[2]
+ res = generic_cpy_call(space, func_target, w_self, i, j, w_y)
+ if rffi.cast(lltype.Signed, res) == -1:
+ space.fromcache(State).check_and_raise_exception(always=True)
-def wrap_ssizessizeobjargproc(space, w_self, w_args, func):
- func_target = rffi.cast(ssizessizeobjargproc, func)
- check_num_args(space, w_args, 3)
- args_w = space.fixedview(w_args)
- i = space.int_w(space.index(args_w[0]))
- j = space.int_w(space.index(args_w[1]))
- w_y = args_w[2]
- res = generic_cpy_call(space, func_target, w_self, i, j, w_y)
- if rffi.cast(lltype.Signed, res) == -1:
- space.fromcache(State).check_and_raise_exception(always=True)
+class wrap_lenfunc(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ self.check_args(__args__, 0)
+ func = self.get_func_to_call()
+ func_len = rffi.cast(lenfunc, func)
+ res = generic_cpy_call(space, func_len, w_self)
+ if widen(res) == -1:
+ space.fromcache(State).check_and_raise_exception(always=True)
+ return space.newint(res)
-def wrap_lenfunc(space, w_self, w_args, func):
- func_len = rffi.cast(lenfunc, func)
- check_num_args(space, w_args, 0)
- res = generic_cpy_call(space, func_len, w_self)
- if widen(res) == -1:
- space.fromcache(State).check_and_raise_exception(always=True)
- return space.newint(res)
+class wrap_sq_item(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ self.check_args(__args__, 1)
+ func = self.get_func_to_call()
+ func_target = rffi.cast(ssizeargfunc, func)
+ w_index = __args__.arguments_w[0]
+ index = space.int_w(space.index(w_index))
+ return generic_cpy_call(space, func_target, w_self, index)
-def wrap_sq_item(space, w_self, w_args, func):
- func_target = rffi.cast(ssizeargfunc, func)
- check_num_args(space, w_args, 1)
- args_w = space.fixedview(w_args)
- index = space.int_w(space.index(args_w[0]))
- return generic_cpy_call(space, func_target, w_self, index)
+class wrap_sq_setitem(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ self.check_args(__args__, 2)
+ func = self.get_func_to_call()
+ func_target = rffi.cast(ssizeobjargproc, func)
+ w_index = __args__.arguments_w[0]
+ w_value = __args__.arguments_w[1]
+ index = space.int_w(space.index(w_index))
+ res = generic_cpy_call(space, func_target, w_self, index, w_value)
+ if rffi.cast(lltype.Signed, res) == -1:
+ space.fromcache(State).check_and_raise_exception(always=True)
-def wrap_sq_setitem(space, w_self, w_args, func):
- func_target = rffi.cast(ssizeobjargproc, func)
- check_num_args(space, w_args, 2)
- args_w = space.fixedview(w_args)
- index = space.int_w(space.index(args_w[0]))
- res = generic_cpy_call(space, func_target, w_self, index, args_w[1])
- if rffi.cast(lltype.Signed, res) == -1:
- space.fromcache(State).check_and_raise_exception(always=True)
-
-def wrap_sq_delitem(space, w_self, w_args, func):
- func_target = rffi.cast(ssizeobjargproc, func)
- check_num_args(space, w_args, 1)
- args_w = space.fixedview(w_args)
- index = space.int_w(space.index(args_w[0]))
- null = rffi.cast(PyObject, 0)
- res = generic_cpy_call(space, func_target, w_self, index, null)
- if rffi.cast(lltype.Signed, res) == -1:
- space.fromcache(State).check_and_raise_exception(always=True)
+class wrap_sq_delitem(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ self.check_args(__args__, 1)
+ func = self.get_func_to_call()
+ func_target = rffi.cast(ssizeobjargproc, func)
+ w_index = __args__.arguments_w[0]
+ index = space.int_w(space.index(w_index))
+ null = rffi.cast(PyObject, 0)
+ res = generic_cpy_call(space, func_target, w_self, index, null)
+ if rffi.cast(lltype.Signed, res) == -1:
+ space.fromcache(State).check_and_raise_exception(always=True)
# Warning, confusing function name (like CPython). Used only for sq_contains.
-def wrap_objobjproc(space, w_self, w_args, func):
- func_target = rffi.cast(objobjproc, func)
- check_num_args(space, w_args, 1)
- w_value, = space.fixedview(w_args)
- res = generic_cpy_call(space, func_target, w_self, w_value)
- res = rffi.cast(lltype.Signed, res)
- if res == -1:
- space.fromcache(State).check_and_raise_exception(always=True)
- return space.newbool(bool(res))
+class wrap_objobjproc(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ self.check_args(__args__, 1)
+ func = self.get_func_to_call()
+ func_target = rffi.cast(objobjproc, func)
+ w_value = __args__.arguments_w[0]
+ res = generic_cpy_call(space, func_target, w_self, w_value)
+ res = rffi.cast(lltype.Signed, res)
+ if res == -1:
+ space.fromcache(State).check_and_raise_exception(always=True)
+ return space.newbool(bool(res))
-def wrap_objobjargproc(space, w_self, w_args, func):
- func_target = rffi.cast(objobjargproc, func)
- check_num_args(space, w_args, 2)
- w_key, w_value = space.fixedview(w_args)
- res = generic_cpy_call(space, func_target, w_self, w_key, w_value)
- if rffi.cast(lltype.Signed, res) == -1:
- space.fromcache(State).check_and_raise_exception(always=True)
- return space.w_None
+class wrap_objobjargproc(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ self.check_args(__args__, 2)
+ func = self.get_func_to_call()
+ func_target = rffi.cast(objobjargproc, func)
+ w_key = __args__.arguments_w[0]
+ w_value = __args__.arguments_w[1]
+ res = generic_cpy_call(space, func_target, w_self, w_key, w_value)
+ if rffi.cast(lltype.Signed, res) == -1:
+ space.fromcache(State).check_and_raise_exception(always=True)
+ return space.w_None
-def wrap_delitem(space, w_self, w_args, func):
- func_target = rffi.cast(objobjargproc, func)
- check_num_args(space, w_args, 1)
- w_key, = space.fixedview(w_args)
- null = rffi.cast(PyObject, 0)
- res = generic_cpy_call(space, func_target, w_self, w_key, null)
- if rffi.cast(lltype.Signed, res) == -1:
- space.fromcache(State).check_and_raise_exception(always=True)
- return space.w_None
+class wrap_delitem(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ self.check_args(__args__, 1)
+ func = self.get_func_to_call()
+ func_target = rffi.cast(objobjargproc, func)
+ w_key = __args__.arguments_w[0]
+ null = rffi.cast(PyObject, 0)
+ res = generic_cpy_call(space, func_target, w_self, w_key, null)
+ if rffi.cast(lltype.Signed, res) == -1:
+ space.fromcache(State).check_and_raise_exception(always=True)
+ return space.w_None
-def wrap_ssizessizeargfunc(space, w_self, w_args, func):
- func_target = rffi.cast(ssizessizeargfunc, func)
- check_num_args(space, w_args, 2)
- args_w = space.fixedview(w_args)
- start = space.int_w(args_w[0])
- end = space.int_w(args_w[1])
- return generic_cpy_call(space, func_target, w_self, start, end)
+class wrap_ssizessizeargfunc(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ self.check_args(__args__, 2)
+ func = self.get_func_to_call()
+ func_target = rffi.cast(ssizessizeargfunc, func)
+ start = space.int_w(__args__.arguments_w[0])
+ end = space.int_w(__args__.arguments_w[1])
+ return generic_cpy_call(space, func_target, w_self, start, end)
-def wrap_next(space, w_self, w_args, func):
- from pypy.module.cpyext.api import generic_cpy_call_expect_null
- func_target = rffi.cast(iternextfunc, func)
- check_num_args(space, w_args, 0)
- w_res = generic_cpy_call_expect_null(space, func_target, w_self)
- if not w_res and not PyErr_Occurred(space):
- raise OperationError(space.w_StopIteration, space.w_None)
- return w_res
+class wrap_next(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ from pypy.module.cpyext.api import generic_cpy_call_expect_null
+ self.check_args(__args__, 0)
+ func = self.get_func_to_call()
+ func_target = rffi.cast(iternextfunc, func)
+ w_res = generic_cpy_call_expect_null(space, func_target, w_self)
+ if not w_res and not PyErr_Occurred(space):
+ raise OperationError(space.w_StopIteration, space.w_None)
+ return w_res
-def wrap_hashfunc(space, w_self, w_args, func):
- func_target = rffi.cast(hashfunc, func)
- check_num_args(space, w_args, 0)
- res = generic_cpy_call(space, func_target, w_self)
- if res == -1:
- space.fromcache(State).check_and_raise_exception(always=True)
- return space.newint(res)
+class wrap_hashfunc(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ self.check_args(__args__, 0)
+ func = self.get_func_to_call()
+ func_target = rffi.cast(hashfunc, func)
+ res = generic_cpy_call(space, func_target, w_self)
+ if res == -1:
+ space.fromcache(State).check_and_raise_exception(always=True)
+ return space.newint(res)
-def wrap_getreadbuffer(space, w_self, w_args, func):
- func_target = rffi.cast(readbufferproc, func)
- py_type = _get_ob_type(space, w_self)
- rbp = rffi.cast(rffi.VOIDP, 0)
- if py_type.c_tp_as_buffer:
- rbp = rffi.cast(rffi.VOIDP, py_type.c_tp_as_buffer.c_bf_releasebuffer)
- with lltype.scoped_alloc(rffi.VOIDPP.TO, 1) as ptr:
- index = rffi.cast(Py_ssize_t, 0)
- size = generic_cpy_call(space, func_target, w_self, index, ptr)
- if size < 0:
- space.fromcache(State).check_and_raise_exception(always=True)
- view = CPyBuffer(space, ptr[0], size, w_self,
- releasebufferproc=rbp)
- fq.register_finalizer(view)
- return space.newbuffer(CBuffer(view))
+class wrap_getreadbuffer(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ func = self.get_func_to_call()
+ func_target = rffi.cast(readbufferproc, func)
+ py_type = _get_ob_type(space, w_self)
+ rbp = rffi.cast(rffi.VOIDP, 0)
+ if py_type.c_tp_as_buffer:
+ rbp = rffi.cast(rffi.VOIDP, py_type.c_tp_as_buffer.c_bf_releasebuffer)
+ with lltype.scoped_alloc(rffi.VOIDPP.TO, 1) as ptr:
+ index = rffi.cast(Py_ssize_t, 0)
+ size = generic_cpy_call(space, func_target, w_self, index, ptr)
+ if size < 0:
+ space.fromcache(State).check_and_raise_exception(always=True)
+ view = CPyBuffer(space, ptr[0], size, w_self,
+ releasebufferproc=rbp)
+ fq.register_finalizer(view)
+ return space.newbuffer(CBuffer(view))
-def wrap_getwritebuffer(space, w_self, w_args, func):
- func_target = rffi.cast(readbufferproc, func)
- py_type = _get_ob_type(space, w_self)
- rbp = rffi.cast(rffi.VOIDP, 0)
- if py_type.c_tp_as_buffer:
- rbp = rffi.cast(rffi.VOIDP, py_type.c_tp_as_buffer.c_bf_releasebuffer)
- with lltype.scoped_alloc(rffi.VOIDPP.TO, 1) as ptr:
- index = rffi.cast(Py_ssize_t, 0)
- size = generic_cpy_call(space, func_target, w_self, index, ptr)
- if size < 0:
- space.fromcache(State).check_and_raise_exception(always=True)
- view = CPyBuffer(space, ptr[0], size, w_self, readonly=False,
- releasebufferproc=rbp)
- fq.register_finalizer(view)
- return space.newbuffer(CBuffer(view))
+class wrap_getwritebuffer(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ func = self.get_func_to_call()
+ func_target = rffi.cast(readbufferproc, func)
+ py_type = _get_ob_type(space, w_self)
+ rbp = rffi.cast(rffi.VOIDP, 0)
+ if py_type.c_tp_as_buffer:
+ rbp = rffi.cast(rffi.VOIDP, py_type.c_tp_as_buffer.c_bf_releasebuffer)
+ with lltype.scoped_alloc(rffi.VOIDPP.TO, 1) as ptr:
+ index = rffi.cast(Py_ssize_t, 0)
+ size = generic_cpy_call(space, func_target, w_self, index, ptr)
+ if size < 0:
+ space.fromcache(State).check_and_raise_exception(always=True)
+ view = CPyBuffer(space, ptr[0], size, w_self, readonly=False,
+ releasebufferproc=rbp)
+ fq.register_finalizer(view)
+ return space.newbuffer(CBuffer(view))
-def wrap_getbuffer(space, w_self, w_args, func):
- func_target = rffi.cast(getbufferproc, func)
- py_type = _get_ob_type(space, w_self)
- rbp = rffi.cast(rffi.VOIDP, 0)
- if py_type.c_tp_as_buffer:
- rbp = rffi.cast(rffi.VOIDP, py_type.c_tp_as_buffer.c_bf_releasebuffer)
- with lltype.scoped_alloc(Py_buffer) as pybuf:
- _flags = 0
- if space.len_w(w_args) > 0:
- _flags = space.int_w(space.listview(w_args)[0])
- flags = rffi.cast(rffi.INT_real,_flags)
- size = generic_cpy_call(space, func_target, w_self, pybuf, flags)
- if widen(size) < 0:
- space.fromcache(State).check_and_raise_exception(always=True)
- ptr = pybuf.c_buf
- size = pybuf.c_len
- ndim = widen(pybuf.c_ndim)
- shape = None
- if pybuf.c_shape:
- shape = [pybuf.c_shape[i] for i in range(ndim)]
- strides = None
- if pybuf.c_strides:
- strides = [pybuf.c_strides[i] for i in range(ndim)]
- if pybuf.c_format:
- format = rffi.charp2str(pybuf.c_format)
- else:
- format = 'B'
- # the CPython docs mandates that you do an incref whenever you call
- # bf_getbuffer; so, we pass needs_decref=True to ensure that we don't
- # leak we release the buffer:
- # https://docs.python.org/3.5/c-api/typeobj.html#c.PyBufferProcs.bf_getbuffer
- buf = CPyBuffer(space, ptr, size, w_self, format=format,
- ndim=ndim, shape=shape, strides=strides,
- itemsize=pybuf.c_itemsize,
- readonly=widen(pybuf.c_readonly),
- needs_decref=True,
- releasebufferproc = rbp)
- fq.register_finalizer(buf)
- return buf.wrap(space)
+
+class wrap_getbuffer(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ func = self.get_func_to_call()
+ func_target = rffi.cast(getbufferproc, func)
+ py_type = _get_ob_type(space, w_self)
+ rbp = rffi.cast(rffi.VOIDP, 0)
+ if py_type.c_tp_as_buffer:
+ rbp = rffi.cast(rffi.VOIDP, py_type.c_tp_as_buffer.c_bf_releasebuffer)
+ with lltype.scoped_alloc(Py_buffer) as pybuf:
+ _flags = 0
+ if len(__args__.arguments_w) > 0:
+ _flags = space.int_w(__args__.arguments_w[0])
+ flags = rffi.cast(rffi.INT_real,_flags)
+ size = generic_cpy_call(space, func_target, w_self, pybuf, flags)
+ if widen(size) < 0:
+ space.fromcache(State).check_and_raise_exception(always=True)
+ ptr = pybuf.c_buf
+ size = pybuf.c_len
+ ndim = widen(pybuf.c_ndim)
+ shape = None
+ if pybuf.c_shape:
+ shape = [pybuf.c_shape[i] for i in range(ndim)]
+ strides = None
+ if pybuf.c_strides:
+ strides = [pybuf.c_strides[i] for i in range(ndim)]
+ if pybuf.c_format:
+ format = rffi.charp2str(pybuf.c_format)
+ else:
+ format = 'B'
+ # the CPython docs mandates that you do an incref whenever you call
+ # bf_getbuffer; so, we pass needs_decref=True to ensure that we don't
+ # leak we release the buffer:
+ # https://docs.python.org/3.5/c-api/typeobj.html#c.PyBufferProcs.bf_getbuffer
+ buf = CPyBuffer(space, ptr, size, w_self, format=format,
+ ndim=ndim, shape=shape, strides=strides,
+ itemsize=pybuf.c_itemsize,
+ readonly=widen(pybuf.c_readonly),
+ needs_decref=True,
+ releasebufferproc = rbp)
+ fq.register_finalizer(buf)
+ return buf.wrap(space)
def get_richcmp_func(OP_CONST):
- def inner(space, w_self, w_args, func):
- func_target = rffi.cast(richcmpfunc, func)
- check_num_args(space, w_args, 1)
- w_other, = space.fixedview(w_args)
- return generic_cpy_call(space, func_target,
- w_self, w_other, rffi.cast(rffi.INT_real, OP_CONST))
- return inner
+ class wrap_richcmp(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ self.check_args(__args__, 1)
+ func = self.get_func_to_call()
+ func_target = rffi.cast(richcmpfunc, func)
+ w_other = __args__.arguments_w[0]
+ return generic_cpy_call(space, func_target,
+ w_self, w_other, rffi.cast(rffi.INT_real, OP_CONST))
+ return wrap_richcmp
richcmp_eq = get_richcmp_func(Py_EQ)
richcmp_ne = get_richcmp_func(Py_NE)
@@ -398,17 +453,19 @@
richcmp_gt = get_richcmp_func(Py_GT)
richcmp_ge = get_richcmp_func(Py_GE)
-def wrap_cmpfunc(space, w_self, w_args, func):
- func_target = rffi.cast(cmpfunc, func)
- check_num_args(space, w_args, 1)
- w_other, = space.fixedview(w_args)
+class wrap_cmpfunc(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ self.check_args(__args__, 1)
+ func = self.get_func_to_call()
+ func_target = rffi.cast(cmpfunc, func)
+ w_other = __args__.arguments_w[0]
- if not space.issubtype_w(space.type(w_self), space.type(w_other)):
- raise oefmt(space.w_TypeError,
- "%T.__cmp__(x,y) requires y to be a '%T', not a '%T'",
- w_self, w_self, w_other)
+ if not space.issubtype_w(space.type(w_self), space.type(w_other)):
+ raise oefmt(space.w_TypeError,
+ "%T.__cmp__(x,y) requires y to be a '%T', not a '%T'",
+ w_self, w_self, w_other)
- return space.newint(generic_cpy_call(space, func_target, w_self, w_other))
+ return space.newint(generic_cpy_call(space, func_target, w_self, w_other))
SLOT_FACTORIES = {}
def slot_factory(tp_name):
@@ -776,9 +833,10 @@
missing_wrappers = ['wrap_indexargfunc', 'wrap_del']
for name in missing_wrappers:
assert name not in globals()
- def missing_wrapper(space, w_self, w_args, func):
- print "cpyext: missing slot wrapper " + name
- raise NotImplementedError("Slot wrapper " + name)
+ class missing_wrapper(W_PyCWrapperObject):
+ def call(self, space, w_self, __args__):
+ print "cpyext: missing slot wrapper " + name
+ raise NotImplementedError("Slot wrapper " + name)
missing_wrapper.__name__ = name
globals()[name] = missing_wrapper
@@ -811,13 +869,12 @@
PyWrapperFlag_KEYWORDS = 1
class TypeSlot:
- def __init__(self, method_name, slot_name, function, wrapper1, wrapper2, doc):
+ def __init__(self, method_name, slot_name, function, wrapper, doc):
self.method_name = method_name
self.slot_name = slot_name
self.slot_names = tuple(("c_" + slot_name).split("."))
self.slot_func = function
- self.wrapper_func = wrapper1
- self.wrapper_func_kwds = wrapper2
+ self.wrapper_class = wrapper
self.doc = doc
# adapted from typeobject.c
@@ -838,13 +895,7 @@
function = getattr(userslot, FUNCTION or '!missing', None)
assert FLAGS == 0 or FLAGS == PyWrapperFlag_KEYWORDS
- if FLAGS:
- wrapper1 = None
- wrapper2 = wrapper
- else:
- wrapper1 = wrapper
- wrapper2 = None
- return TypeSlot(NAME, SLOT, function, wrapper1, wrapper2, DOC)
+ return TypeSlot(NAME, SLOT, function, wrapper, DOC)
def TPSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC):
return FLSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC, 0)
@@ -1127,7 +1178,7 @@
x.slot_func.api_func if x.slot_func else None) for x in slotdefs])
slotdefs_for_wrappers = unrolling_iterable(
- [(x.method_name, x.slot_names, x.wrapper_func, x.wrapper_func_kwds, x.doc)
+ [(x.method_name, x.slot_names, x.wrapper_class, x.doc)
for x in slotdefs])
if __name__ == "__main__":
diff --git a/pypy/module/cpyext/state.py b/pypy/module/cpyext/state.py
--- a/pypy/module/cpyext/state.py
+++ b/pypy/module/cpyext/state.py
@@ -2,11 +2,18 @@
from rpython.rtyper.lltypesystem import rffi, lltype
from pypy.interpreter.error import OperationError, oefmt
from pypy.interpreter import executioncontext
+from pypy.interpreter.executioncontext import ExecutionContext
from rpython.rtyper.annlowlevel import llhelper
from rpython.rlib.rdynload import DLLHANDLE
from rpython.rlib import rawrefcount
import sys
+
+# Keep track of exceptions raised in cpyext for a particular execution
+# context.
+ExecutionContext.cpyext_operror = None
+
+
class State:
def __init__(self, space):
self.space = space
@@ -18,7 +25,8 @@
def reset(self):
from pypy.module.cpyext.modsupport import PyMethodDef
- self.operror = None
+ ec = self.space.getexecutioncontext()
+ ec.cpyext_operror = None
self.new_method_def = lltype.nullptr(PyMethodDef)
# When importing a package, use this to keep track
@@ -37,17 +45,24 @@
def set_exception(self, operror):
self.clear_exception()
- self.operror = operror
+ ec = self.space.getexecutioncontext()
+ ec.cpyext_operror = operror
def clear_exception(self):
"""Clear the current exception state, and return the operror."""
- operror = self.operror
- self.operror = None
+ ec = self.space.getexecutioncontext()
+ operror = ec.cpyext_operror
+ ec.cpyext_operror = None
return operror
+ def get_exception(self):
+ ec = self.space.getexecutioncontext()
+ return ec.cpyext_operror
+
@specialize.arg(1)
def check_and_raise_exception(self, always=False):
- operror = self.operror
+ ec = self.space.getexecutioncontext()
+ operror = ec.cpyext_operror
if operror:
self.clear_exception()
raise operror
diff --git a/pypy/module/cpyext/test/test_api.py b/pypy/module/cpyext/test/test_api.py
--- a/pypy/module/cpyext/test/test_api.py
+++ b/pypy/module/cpyext/test/test_api.py
@@ -39,7 +39,7 @@
raise Exception("%s is not callable" % (f,))
f(*args)
state = space.fromcache(State)
- operror = state.operror
+ operror = state.get_exception()
if not operror:
raise Exception("DID NOT RAISE")
if getattr(space, 'w_' + expected_exc.__name__) is not operror.w_type:
diff --git a/pypy/module/cpyext/test/test_boolobject.py b/pypy/module/cpyext/test/test_boolobject.py
--- a/pypy/module/cpyext/test/test_boolobject.py
+++ b/pypy/module/cpyext/test/test_boolobject.py
@@ -1,7 +1,6 @@
from pypy.module.cpyext.test.test_cpyext import AppTestCpythonExtensionBase
from pypy.module.cpyext.test.test_api import BaseApiTest
-from pypy.module.cpyext.boolobject import PyBool_Check, PyBool_FromLong
-from pypy.module.cpyext.floatobject import PyFloat_FromDouble
+from pypy.module.cpyext.boolobject import PyBool_FromLong
class TestBoolObject(BaseApiTest):
def test_fromlong(self, space):
@@ -12,12 +11,6 @@
else:
assert obj is space.w_False
- def test_check(self, space):
- assert PyBool_Check(space, space.w_True)
- assert PyBool_Check(space, space.w_False)
- assert not PyBool_Check(space, space.w_None)
- assert not PyBool_Check(space, PyFloat_FromDouble(space, 1.0))
-
class AppTestBoolMacros(AppTestCpythonExtensionBase):
def test_macros(self):
module = self.import_extension('foo', [
@@ -42,4 +35,14 @@
assert module.to_int(False) == 0
assert module.to_int(True) == 1
-
+ def test_check(self):
+ module = self.import_extension('foo', [
+ ("type_check", "METH_O",
+ '''
+ return PyLong_FromLong(PyBool_Check(args));
+ ''')])
+ assert module.type_check(True)
+ assert module.type_check(False)
+ assert not module.type_check(None)
+ assert not module.type_check(1.0)
+
diff --git a/pypy/module/cpyext/test/test_cpyext.py b/pypy/module/cpyext/test/test_cpyext.py
--- a/pypy/module/cpyext/test/test_cpyext.py
+++ b/pypy/module/cpyext/test/test_cpyext.py
@@ -613,7 +613,8 @@
Py_ssize_t refcnt_after;
Py_INCREF(true_obj);
Py_INCREF(true_obj);
- PyBool_Check(true_obj);
+ if (!PyBool_Check(true_obj))
+ Py_RETURN_NONE;
refcnt_after = true_obj->ob_refcnt;
Py_DECREF(true_obj);
Py_DECREF(true_obj);
diff --git a/pypy/module/cpyext/test/test_floatobject.py b/pypy/module/cpyext/test/test_floatobject.py
--- a/pypy/module/cpyext/test/test_floatobject.py
+++ b/pypy/module/cpyext/test/test_floatobject.py
@@ -102,9 +102,11 @@
"""
PyObject* pyobj = PyFloat_FromDouble(1.0);
PyFloatObject* pfo = (PyFloatObject*)pyobj;
- int res = PyFloat_Check(pyobj) && PyFloat_CheckExact(pyobj) &&
- PyFloat_Check(pfo) && PyFloat_CheckExact(pfo);
+ int res = (PyFloat_Check(pyobj) +
+ PyFloat_CheckExact(pyobj) * 10 +
+ PyFloat_Check(pfo) * 100 +
+ PyFloat_CheckExact(pfo) * 1000);
Py_DecRef(pyobj);
return PyLong_FromLong(res);"""),
])
- assert module.test() == 1
+ assert module.test() == 1111
diff --git a/pypy/module/cpyext/test/test_number.py b/pypy/module/cpyext/test/test_number.py
--- a/pypy/module/cpyext/test/test_number.py
+++ b/pypy/module/cpyext/test/test_number.py
@@ -8,7 +8,6 @@
PyNumber_Index, PyNumber_Add,
PyNumber_Multiply, PyNumber_InPlaceMultiply, PyNumber_Absolute,
PyNumber_Power, PyNumber_InPlacePower)
-from pypy.module.cpyext.floatobject import PyFloat_Check
from pypy.module.cpyext.longobject import PyLong_CheckExact
from pypy.module.cpyext.object import PyObject_Size
diff --git a/pypy/module/cpyext/test/test_pyerrors.py b/pypy/module/cpyext/test/test_pyerrors.py
--- a/pypy/module/cpyext/test/test_pyerrors.py
+++ b/pypy/module/cpyext/test/test_pyerrors.py
@@ -43,7 +43,8 @@
api.PyErr_SetObject(space.w_ValueError, space.wrap("a value"))
assert api.PyErr_Occurred() is space.w_ValueError
state = space.fromcache(State)
- assert space.eq_w(state.operror.get_w_value(space),
+ operror = state.get_exception()
+ assert space.eq_w(operror.get_w_value(space),
space.wrap("a value"))
api.PyErr_Clear()
@@ -51,12 +52,14 @@
def test_SetNone(self, space, api):
api.PyErr_SetNone(space.w_KeyError)
state = space.fromcache(State)
- assert space.eq_w(state.operror.w_type, space.w_KeyError)
- assert space.eq_w(state.operror.get_w_value(space), space.w_None)
+ operror = state.get_exception()
+ assert space.eq_w(operror.w_type, space.w_KeyError)
+ assert space.eq_w(operror.get_w_value(space), space.w_None)
api.PyErr_Clear()
api.PyErr_NoMemory()
- assert space.eq_w(state.operror.w_type, space.w_MemoryError)
+ operror = state.get_exception()
+ assert space.eq_w(operror.w_type, space.w_MemoryError)
api.PyErr_Clear()
def test_Warning(self, space, api, capfd):
@@ -475,3 +478,59 @@
'''),
])
raises(SystemError, module.oops)
+
+ def test_error_thread_race(self):
+ # Check race condition: thread 0 returns from cpyext with error set,
+ # after thread 1 has set an error but before it returns.
+ module = self.import_extension('foo', [
+ ("emit_error", "METH_VARARGS",
+ '''
+ PyThreadState *save = NULL;
+ PyGILState_STATE gilsave;
+
+ /* NB. synchronization due to GIL */
+ static volatile int flag = 0;
+ int id;
+
+ if (!PyArg_ParseTuple(args, "i", &id))
+ return NULL;
+
+ /* Proceed in thread 1 first */
+ save = PyEval_SaveThread();
+ while (id == 0 && flag == 0);
+ gilsave = PyGILState_Ensure();
+
+ PyErr_Format(PyExc_ValueError, "%d", id);
+
+ /* Proceed in thread 0 first */
+ if (id == 1) flag = 1;
+ PyGILState_Release(gilsave);
+ while (id == 1 && flag == 1);
+ PyEval_RestoreThread(save);
+
+ if (id == 0) flag = 0;
+ return NULL;
+ '''
+ ),
+ ])
+
+ import threading
+
+ failures = []
+
+ def worker(arg):
+ try:
+ module.emit_error(arg)
+ failures.append(True)
+ except Exception as exc:
+ if str(exc) != str(arg):
+ failures.append(exc)
+
+ threads = [threading.Thread(target=worker, args=(j,))
+ for j in (0, 1)]
+ for t in threads:
+ t.start()
+ for t in threads:
+ t.join()
+
+ assert not failures
diff --git a/pypy/module/cpyext/test/test_sliceobject.py b/pypy/module/cpyext/test/test_sliceobject.py
--- a/pypy/module/cpyext/test/test_sliceobject.py
+++ b/pypy/module/cpyext/test/test_sliceobject.py
@@ -2,14 +2,8 @@
from pypy.module.cpyext.test.test_api import BaseApiTest
from pypy.module.cpyext.test.test_cpyext import AppTestCpythonExtensionBase
from pypy.module.cpyext.api import Py_ssize_t, Py_ssize_tP
-from pypy.module.cpyext.sliceobject import PySlice_Check
class TestSliceObject(BaseApiTest):
- def test_slice(self, space):
- w_i = space.wrap(10)
- w_slice = space.newslice(w_i, w_i, w_i)
- assert PySlice_Check(space, w_slice)
- assert not PySlice_Check(space, w_i)
def test_GetIndicesEx(self, space, api):
w = space.wrap
@@ -79,3 +73,14 @@
"""),
])
assert module.get_ellipsis() is Ellipsis
+
+ def test_typecheck(self):
+ module = self.import_extension('foo', [
+ ("check", "METH_O",
+ """
+ PySliceObject *slice = (PySliceObject *)args;
+ return PyLong_FromLong(PySlice_Check(slice));
+ """),
+ ])
+ s = slice(10, 20, 30)
+ assert module.check(s)
diff --git a/pypy/module/cpyext/test/test_typeobject.py b/pypy/module/cpyext/test/test_typeobject.py
--- a/pypy/module/cpyext/test/test_typeobject.py
+++ b/pypy/module/cpyext/test/test_typeobject.py
@@ -783,6 +783,36 @@
assert module.tp_init(list, x, ("hi",)) is None
assert x == ["h", "i"]
+ def test_mp_subscript(self):
+ module = self.import_extension('foo', [
+ ("new_obj", "METH_NOARGS",
+ '''
+ PyObject *obj;
+ obj = PyObject_New(PyObject, &Foo_Type);
+ return obj;
+ '''
+ )], prologue='''
+ static PyObject*
+ mp_subscript(PyObject *self, PyObject *key)
+ {
+ return Py_BuildValue("i", 42);
+ }
+ PyMappingMethods tp_as_mapping;
+ static PyTypeObject Foo_Type = {
+ PyVarObject_HEAD_INIT(NULL, 0)
+ "foo.foo",
+ };
+ ''', more_init = '''
+ Foo_Type.tp_flags = Py_TPFLAGS_DEFAULT;
+ Foo_Type.tp_as_mapping = &tp_as_mapping;
+ tp_as_mapping.mp_subscript = (binaryfunc)mp_subscript;
+ if (PyType_Ready(&Foo_Type) < 0) INITERROR;
+ ''')
+ obj = module.new_obj()
+ assert obj[100] == 42
+ raises(TypeError, "obj.__getitem__(100, 101)")
+ raises(TypeError, "obj.__getitem__(100, a=42)")
+
def test_mp_ass_subscript(self):
module = self.import_extension('foo', [
("new_obj", "METH_NOARGS",
@@ -846,6 +876,84 @@
res = "foo" in obj
assert res is True
+ def test_sq_ass_slice(self):
+ module = self.import_extension('foo', [
+ ("new_obj", "METH_NOARGS",
+ '''
+ PyObject *obj;
+ obj = PyObject_New(PyObject, &Foo_Type);
+ return obj;
+ '''
+ )], prologue='''
+ static int
+ sq_ass_slice(PyObject *self, Py_ssize_t a, Py_ssize_t b, PyObject *o)
+ {
+ int expected = (a == 10 && b == 20 &&
+ PyInt_Check(o) && PyInt_AsLong(o) == 42);
+ if (!expected) {
+ PyErr_SetString(PyExc_ValueError, "test failed");
+ return -1;
+ }
+ return 0;
+ }
+ PySequenceMethods tp_as_sequence;
+ static PyTypeObject Foo_Type = {
+ PyVarObject_HEAD_INIT(NULL, 0)
+ "foo.foo",
+ };
+ ''', more_init='''
+ Foo_Type.tp_flags = Py_TPFLAGS_DEFAULT;
+ Foo_Type.tp_as_sequence = &tp_as_sequence;
+ tp_as_sequence.sq_ass_slice = sq_ass_slice;
+ if (PyType_Ready(&Foo_Type) < 0) INITERROR;
+ ''')
+ obj = module.new_obj()
+ obj[10:20] = 42
+ raises(ValueError, "obj[10:20] = 43")
+ raises(ValueError, "obj[11:20] = 42")
+ raises(ValueError, "obj[10:21] = 42")
+
+ def test_sq_ass_item(self):
+ module = self.import_extension('foo', [
+ ("new_obj", "METH_NOARGS",
+ '''
+ PyObject *obj;
+ obj = PyObject_New(PyObject, &Foo_Type);
+ return obj;
+ '''
+ )], prologue='''
+ static int
+ sq_ass_item(PyObject *self, Py_ssize_t i, PyObject *o)
+ {
+ int expected;
+ if (o == NULL) // delitem
+ expected = (i == 12);
+ else // setitem
+ expected = (i == 10 && PyInt_Check(o) && PyInt_AsLong(o) == 42);
+ if (!expected) {
+ PyErr_SetString(PyExc_ValueError, "test failed");
+ return -1;
+ }
+ return 0;
+ }
+ PySequenceMethods tp_as_sequence;
+ static PyTypeObject Foo_Type = {
+ PyVarObject_HEAD_INIT(NULL, 0)
+ "foo.foo",
+ };
+ ''', more_init='''
+ Foo_Type.tp_flags = Py_TPFLAGS_DEFAULT;
+ Foo_Type.tp_as_sequence = &tp_as_sequence;
+ tp_as_sequence.sq_ass_item = sq_ass_item;
+ if (PyType_Ready(&Foo_Type) < 0) INITERROR;
+ ''')
+ obj = module.new_obj()
+ obj[10] = 42
+ raises(ValueError, "obj[10] = 43")
+ raises(ValueError, "obj[11] = 42")
+ del obj[12]
+ raises(ValueError, "del obj[13]")
+
def test_tp_iter(self):
module = self.import_extension('foo', [
("tp_iter", "METH_VARARGS",
@@ -1498,3 +1606,29 @@
class MyList(list):
pass
assert module.test_flags(MyList, Py_TPFLAGS_LIST_SUBCLASS) == 0
+
+ def test_has_pypy_subclass_flag(self):
+ module = self.import_extension('foo', [
+ ("test_pypy_flags", "METH_VARARGS",
+ '''
+ long long in_flag, my_flag;
+ PyObject * obj;
+ if (!PyArg_ParseTuple(args, "OL", &obj, &in_flag))
+ return NULL;
+ if (!PyType_Check(obj))
+ {
+ PyErr_SetString(PyExc_ValueError, "input must be type");
+ return NULL;
+ }
+ my_flag = ((PyTypeObject*)obj)->tp_pypy_flags;
+ if ((my_flag & in_flag) != in_flag)
+ return PyLong_FromLong(-1);
+ return PyLong_FromLong(0);
+ '''),])
+ # copied from object.h
+ Py_TPPYPYFLAGS_FLOAT_SUBCLASS = (1L<<0)
+
+ class MyFloat(float):
+ pass
+ assert module.test_pypy_flags(float, Py_TPPYPYFLAGS_FLOAT_SUBCLASS) == 0
+ assert module.test_pypy_flags(MyFloat, Py_TPPYPYFLAGS_FLOAT_SUBCLASS) == 0
\ No newline at end of file
diff --git a/pypy/module/cpyext/typeobject.py b/pypy/module/cpyext/typeobject.py
--- a/pypy/module/cpyext/typeobject.py
+++ b/pypy/module/cpyext/typeobject.py
@@ -19,11 +19,15 @@
Py_TPFLAGS_TUPLE_SUBCLASS, Py_TPFLAGS_UNICODE_SUBCLASS,
Py_TPFLAGS_DICT_SUBCLASS, Py_TPFLAGS_BASE_EXC_SUBCLASS,
Py_TPFLAGS_TYPE_SUBCLASS,
- Py_TPFLAGS_BYTES_SUBCLASS)
+ Py_TPFLAGS_BYTES_SUBCLASS
+ Py_TPPYPYFLAGS_FLOAT_SUBCLASS,
+ )
+
from pypy.module.cpyext.cparser import CTypeSpace
from pypy.module.cpyext.methodobject import (W_PyCClassMethodObject,
- W_PyCWrapperObject, PyCFunction_NewEx, PyCFunction, PyMethodDef,
- W_PyCMethodObject, W_PyCFunctionObject, extract_doc, extract_txtsig)
+ PyCFunction_NewEx, PyCFunction, PyMethodDef,
+ W_PyCMethodObject, W_PyCFunctionObject, extract_doc, extract_txtsig,
+ W_PyCWrapperObject)
from pypy.module.cpyext.modsupport import convert_method_defs
from pypy.module.cpyext.pyobject import (
PyObject, make_ref, from_ref, get_typedescr, make_typedescr,
@@ -311,7 +315,7 @@
def add_operators(space, dict_w, pto, name):
from pypy.module.cpyext.object import PyObject_HashNotImplemented
hash_not_impl = llslot(space, PyObject_HashNotImplemented)
- for method_name, slot_names, wrapper_func, wrapper_func_kwds, doc in slotdefs_for_wrappers:
+ for method_name, slot_names, wrapper_class, doc in slotdefs_for_wrappers:
if method_name in dict_w:
continue
offset = [rffi.offsetof(lltype.typeOf(pto).TO, slot_names[0])]
@@ -336,10 +340,11 @@
func_voidp = rffi.cast(rffi.VOIDP, func)
if not func:
continue
- if wrapper_func is None and wrapper_func_kwds is None:
+ if wrapper_class is None:
continue
- w_obj = W_PyCWrapperObject(space, pto, method_name, wrapper_func,
- wrapper_func_kwds, doc, func_voidp, offset=offset)
+
+ assert issubclass(wrapper_class, W_PyCWrapperObject)
+ w_obj = wrapper_class(space, pto, method_name, doc, func_voidp, offset=offset[:])
dict_w[method_name] = w_obj
if pto.c_tp_doc:
raw_doc = rffi.charp2str(cts.cast('char*', pto.c_tp_doc))
@@ -424,6 +429,9 @@
pto.c_tp_flags |= Py_TPFLAGS_LIST_SUBCLASS
elif space.issubtype_w(w_obj, space.w_dict):
pto.c_tp_flags |= Py_TPFLAGS_DICT_SUBCLASS
+ # the following types are a pypy-specific extensions, using tp_pypy_flags
+ elif space.issubtype_w(w_obj, space.w_float):
+ pto.c_tp_pypy_flags |= Py_TPPYPYFLAGS_FLOAT_SUBCLASS
def check_descr(space, w_self, w_type):
if not space.isinstance_w(w_self, w_type):
diff --git a/rpython/annotator/signature.py b/rpython/annotator/signature.py
--- a/rpython/annotator/signature.py
+++ b/rpython/annotator/signature.py
@@ -103,7 +103,7 @@
elif bookkeeper and not hasattr(t, '_freeze_'):
return SomeInstance(bookkeeper.getuniqueclassdef(t))
else:
- raise AssertionError("annotationoftype(%r)" % (t,))
+ raise TypeError("Annotation of type %r not supported" % (t,))
class Sig(object):
diff --git a/rpython/doc/rpython.rst b/rpython/doc/rpython.rst
--- a/rpython/doc/rpython.rst
+++ b/rpython/doc/rpython.rst
@@ -259,6 +259,26 @@
intmask().
+Type Enforcing and Checking
+---------------------------
+
+RPython provides a helper decorator to force RPython-level types on function
+arguments. The decorator, called ``enforceargs()``, accepts as parameters the
+types expected to match the arguments of the function.
+
+Functions decorated with ``enforceargs()`` have their function signature
+analyzed and their RPython-level type inferred at import time (for further
+details about the flavor of translation performed in RPython, see the
+`Annotation pass documentation`_). Encountering types not supported by RPython
+will raise a ``TypeError``.
+
+``enforceargs()`` by default also performs type checking of parameter types
+each time the function is invoked. To disable this behavior, it's possible to
+pass the ``typecheck=False`` parameter to the decorator.
+
+.. _Annotation pass documentation: http://rpython.readthedocs.io/en/latest/translation.html#annotator
+
+
Exception rules
---------------
diff --git a/rpython/doc/translation.rst b/rpython/doc/translation.rst
--- a/rpython/doc/translation.rst
+++ b/rpython/doc/translation.rst
@@ -48,7 +48,7 @@
be present in memory as a form that is "static enough" in the sense of
:doc:`RPython <rpython>`.
-2. The Annotator_ performs a global analysis starting from an specified
+2. The Annotator_ performs a global analysis starting from a specified
entry point to deduce type and other information about what each
variable can contain at run-time, :ref:`building flow graphs <flow-graphs>`
as it encounters them.
diff --git a/rpython/memory/gctransform/framework.py b/rpython/memory/gctransform/framework.py
--- a/rpython/memory/gctransform/framework.py
+++ b/rpython/memory/gctransform/framework.py
@@ -1592,8 +1592,7 @@
index = self.get_finalizer_queue_index(hop)
c_index = rmodel.inputconst(lltype.Signed, index)
v_ptr = hop.spaceop.args[1]
- v_ptr = hop.genop("cast_opaque_ptr", [v_ptr],
- resulttype=llmemory.GCREF)
+ assert v_ptr.concretetype == llmemory.GCREF
hop.genop("direct_call", [self.register_finalizer_ptr, self.c_const_gc,
c_index, v_ptr])
diff --git a/rpython/memory/gcwrapper.py b/rpython/memory/gcwrapper.py
--- a/rpython/memory/gcwrapper.py
+++ b/rpython/memory/gcwrapper.py
@@ -235,11 +235,11 @@
obj = deque.popleft()
else:
obj = llmemory.NULL
- return llmemory.cast_adr_to_ptr(obj, rclass.OBJECTPTR)
+ return llmemory.cast_adr_to_ptr(obj, llmemory.GCREF)
def gc_fq_register(self, fq_tag, ptr):
index = self.get_finalizer_queue_index(fq_tag)
- ptr = lltype.cast_opaque_ptr(llmemory.GCREF, ptr)
+ assert lltype.typeOf(ptr) == llmemory.GCREF
self.gc.register_finalizer(index, ptr)
# ____________________________________________________________
diff --git a/rpython/rlib/objectmodel.py b/rpython/rlib/objectmodel.py
--- a/rpython/rlib/objectmodel.py
+++ b/rpython/rlib/objectmodel.py
@@ -120,7 +120,7 @@
""" Decorate a function with forcing of RPython-level types on arguments.
None means no enforcing.
- When not translated, the type of the actual arguments are checked against
+ When not translated, the type of the actual arguments is checked against
the enforced types every time the function is called. You can disable the
typechecking by passing ``typecheck=False`` to @enforceargs.
"""
@@ -147,8 +147,7 @@
# they are already homogeneous, so we only check the first
# item. The case of empty list/dict is handled inside typecheck()
if isinstance(arg, list):
- item = arg[0]
- return [get_type_descr_of_argument(item)]
+ return [get_type_descr_of_argument(arg[0])]
elif isinstance(arg, dict):
key, value = next(arg.iteritems())
return {get_type_descr_of_argument(key): get_type_descr_of_argument(value)}
diff --git a/rpython/rlib/rgc.py b/rpython/rlib/rgc.py
--- a/rpython/rlib/rgc.py
+++ b/rpython/rlib/rgc.py
@@ -378,13 +378,12 @@
class FinalizerQueue(object):
"""A finalizer queue. See pypy/doc/discussion/finalizer-order.rst.
- Note: only works with the framework GCs (like minimark). It is
- ignored with Boehm or with refcounting (used by tests).
"""
# Must be subclassed, and the subclass needs these attributes:
#
# Class:
# the class (or base class) of finalized objects
+ # --or-- None to handle low-level GCREFs directly
#
# def finalizer_trigger(self):
# called to notify that new items have been put in the queue
@@ -397,11 +396,13 @@
def next_dead(self):
if we_are_translated():
from rpython.rtyper.lltypesystem.lloperation import llop
- from rpython.rtyper.rclass import OBJECTPTR
- from rpython.rtyper.annlowlevel import cast_base_ptr_to_instance
+ from rpython.rtyper.lltypesystem.llmemory import GCREF
+ from rpython.rtyper.annlowlevel import cast_gcref_to_instance
tag = FinalizerQueue._get_tag(self)
- ptr = llop.gc_fq_next_dead(OBJECTPTR, tag)
- return cast_base_ptr_to_instance(self.Class, ptr)
+ ptr = llop.gc_fq_next_dead(GCREF, tag)
+ if self.Class is not None:
+ ptr = cast_gcref_to_instance(self.Class, ptr)
+ return ptr
try:
return self._queue.popleft()
except (AttributeError, IndexError):
@@ -410,14 +411,18 @@
@specialize.arg(0)
@jit.dont_look_inside
def register_finalizer(self, obj):
- assert isinstance(obj, self.Class)
+ from rpython.rtyper.lltypesystem.llmemory import GCREF
+ if self.Class is None:
+ assert lltype.typeOf(obj) == GCREF
+ else:
+ assert isinstance(obj, self.Class)
if we_are_translated():
from rpython.rtyper.lltypesystem.lloperation import llop
- from rpython.rtyper.rclass import OBJECTPTR
- from rpython.rtyper.annlowlevel import cast_instance_to_base_ptr
+ from rpython.rtyper.annlowlevel import cast_instance_to_gcref
tag = FinalizerQueue._get_tag(self)
- ptr = cast_instance_to_base_ptr(obj)
- llop.gc_fq_register(lltype.Void, tag, ptr)
+ if self.Class is not None:
+ obj = cast_instance_to_gcref(obj)
+ llop.gc_fq_register(lltype.Void, tag, obj)
return
else:
self._untranslated_register_finalizer(obj)
diff --git a/rpython/rlib/test/test_rgc.py b/rpython/rlib/test/test_rgc.py
--- a/rpython/rlib/test/test_rgc.py
+++ b/rpython/rlib/test/test_rgc.py
@@ -599,3 +599,94 @@
e = py.test.raises(TyperError, gengraph, f, [])
assert str(e.value).startswith('the RPython-level __del__() method in')
+
+ def test_translated_boehm(self):
+ self._test_translated(use_gc="boehm", llcase=False)
+
+ def test_translated_boehm_ll(self):
+ self._test_translated(use_gc="boehm", llcase=True)
+
+ def test_translated_incminimark(self):
+ self._test_translated(use_gc="incminimark", llcase=False)
+
+ def test_translated_incminimark_ll(self):
+ self._test_translated(use_gc="incminimark", llcase=True)
+
+ def _test_translated(self, use_gc, llcase):
+ import subprocess
+ from rpython.rlib import objectmodel
+ from rpython.translator.interactive import Translation
+ #
+ class Seen:
+ count = 0
+ class MySimpleFQ(rgc.FinalizerQueue):
+ if not llcase:
+ Class = T_Root
+ else:
+ Class = None
+ def finalizer_trigger(self):
+ seen.count += 1
+ seen = Seen()
+ fq = MySimpleFQ()
+ if not llcase:
+ EMPTY = None
+ llbuilder = T_Int
+ else:
+ from rpython.rtyper.annlowlevel import llstr
+ EMPTY = lltype.nullptr(llmemory.GCREF.TO)
+ def llbuilder(n):
+ return lltype.cast_opaque_ptr(llmemory.GCREF, llstr(str(n)))
+
+ def subfunc():
+ w0 = llbuilder(40); fq.register_finalizer(w0)
+ w1 = llbuilder(41); fq.register_finalizer(w1)
+ w2 = llbuilder(42); fq.register_finalizer(w2)
+ w3 = llbuilder(43); fq.register_finalizer(w3)
+ w4 = llbuilder(44); fq.register_finalizer(w4)
+ w5 = llbuilder(45); fq.register_finalizer(w5)
+ w6 = llbuilder(46); fq.register_finalizer(w6)
+ w7 = llbuilder(47); fq.register_finalizer(w7)
+ w8 = llbuilder(48); fq.register_finalizer(w8)
+ w9 = llbuilder(49); fq.register_finalizer(w9)
+ gc.collect()
+ assert seen.count == 0
+ assert fq.next_dead() is EMPTY
+ objectmodel.keepalive_until_here(w0)
+ objectmodel.keepalive_until_here(w1)
+ objectmodel.keepalive_until_here(w2)
+ objectmodel.keepalive_until_here(w3)
+ objectmodel.keepalive_until_here(w4)
+ objectmodel.keepalive_until_here(w5)
+ objectmodel.keepalive_until_here(w6)
+ objectmodel.keepalive_until_here(w7)
+ objectmodel.keepalive_until_here(w8)
+ objectmodel.keepalive_until_here(w9)
+
More information about the pypy-commit
mailing list