[pypy-commit] pypy cpyext-unhashable: merge default into branch
mattip
pypy.commits at gmail.com
Mon May 22 03:44:20 EDT 2017
Author: Matti Picus <matti.picus at gmail.com>
Branch: cpyext-unhashable
Changeset: r91359:21f235773e6d
Date: 2017-05-21 00:07 +0300
http://bitbucket.org/pypy/pypy/changeset/21f235773e6d/
Log: merge default into branch
diff --git a/pypy/config/pypyoption.py b/pypy/config/pypyoption.py
--- a/pypy/config/pypyoption.py
+++ b/pypy/config/pypyoption.py
@@ -220,9 +220,6 @@
BoolOption("withsmalllong", "use a version of 'long' in a C long long",
default=False),
- BoolOption("withstrbuf", "use strings optimized for addition (ver 2)",
- default=False),
-
BoolOption("withspecialisedtuple",
"use specialised tuples",
default=False),
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
@@ -39,3 +39,20 @@
Internal refactoring of buffers and memoryviews. Memoryviews will now be
accepted in a few more places, e.g. in compile().
+
+.. branch: sthalik/fix-signed-integer-sizes-1494493539409
+
+.. branch: cpyext-obj-stealing
+
+Redo much of the refcount semantics in PyList_{SG}etItem to closer match
+CPython and ensure the same PyObject stored in the list can be later
+retrieved
+
+.. branch: cpyext-recursionlimit
+
+Implement Py_EnterRecursiveCall and associated functions
+
+.. branch: pypy_ctypes_nosegfault_nofastpath
+
+Remove faulty fastpath from ctypes
+
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
@@ -1557,7 +1557,6 @@
@specialize.memo()
def make_generic_cpy_call(FT, expect_null):
- from pypy.module.cpyext.pyobject import make_ref, from_ref
from pypy.module.cpyext.pyobject import is_pyobj, as_pyobj
from pypy.module.cpyext.pyobject import get_w_obj_and_decref
from pypy.module.cpyext.pyerrors import PyErr_Occurred
diff --git a/pypy/module/cpyext/eval.py b/pypy/module/cpyext/eval.py
--- a/pypy/module/cpyext/eval.py
+++ b/pypy/module/cpyext/eval.py
@@ -1,6 +1,8 @@
from pypy.interpreter.error import oefmt
from pypy.interpreter.astcompiler import consts
from rpython.rtyper.lltypesystem import rffi, lltype
+from rpython.rlib.objectmodel import we_are_translated
+from rpython.rlib.rarithmetic import widen
from pypy.module.cpyext.api import (
cpython_api, CANNOT_FAIL, CONST_STRING, FILEP, fread, feof, Py_ssize_tP,
cpython_struct, is_valid_fp)
@@ -227,4 +229,51 @@
cf.c_cf_flags = rffi.cast(rffi.INT, flags)
return result
+ at cpython_api([], rffi.INT_real, error=CANNOT_FAIL)
+def Py_GetRecursionLimit(space):
+ from pypy.module.sys.vm import getrecursionlimit
+ return space.int_w(getrecursionlimit(space))
+ at cpython_api([rffi.INT_real], lltype.Void, error=CANNOT_FAIL)
+def Py_SetRecursionLimit(space, limit):
+ from pypy.module.sys.vm import setrecursionlimit
+ setrecursionlimit(space, widen(limit))
+
+limit = 0 # for testing
+
+ at cpython_api([rffi.CCHARP], rffi.INT_real, error=1)
+def Py_EnterRecursiveCall(space, where):
+ """Marks a point where a recursive C-level call is about to be performed.
+
+ If USE_STACKCHECK is defined, this function checks if the the OS
+ stack overflowed using PyOS_CheckStack(). In this is the case, it
+ sets a MemoryError and returns a nonzero value.
+
+ The function then checks if the recursion limit is reached. If this is the
+ case, a RuntimeError is set and a nonzero value is returned.
+ Otherwise, zero is returned.
+
+ where should be a string such as " in instance check" to be
+ concatenated to the RuntimeError message caused by the recursion depth
+ limit."""
+ if not we_are_translated():
+ # XXX hack since the stack checks only work translated
+ global limit
+ limit += 1
+ if limit > 10:
+ raise oefmt(space.w_RuntimeError,
+ "maximum recursion depth exceeded%s", rffi.charp2str(where))
+ return 0
+ from rpython.rlib.rstack import stack_almost_full
+ if stack_almost_full():
+ raise oefmt(space.w_RuntimeError,
+ "maximum recursion depth exceeded%s", rffi.charp2str(where))
+ return 0
+
+ at cpython_api([], lltype.Void)
+def Py_LeaveRecursiveCall(space):
+ """Ends a Py_EnterRecursiveCall(). Must be called once for each
+ successful invocation of Py_EnterRecursiveCall()."""
+ # A NOP in PyPy
+ if not we_are_translated():
+ limit = 0
diff --git a/pypy/module/cpyext/include/listobject.h b/pypy/module/cpyext/include/listobject.h
--- a/pypy/module/cpyext/include/listobject.h
+++ b/pypy/module/cpyext/include/listobject.h
@@ -1,1 +1,1 @@
-#define PyList_GET_ITEM(o, i) PyList_GetItem((PyObject*)(o), (i))
+/* empty */
diff --git a/pypy/module/cpyext/listobject.py b/pypy/module/cpyext/listobject.py
--- a/pypy/module/cpyext/listobject.py
+++ b/pypy/module/cpyext/listobject.py
@@ -1,9 +1,10 @@
+from rpython.rlib.objectmodel import always_inline
from rpython.rtyper.lltypesystem import rffi, lltype
from pypy.module.cpyext.api import (cpython_api, CANNOT_FAIL, Py_ssize_t,
build_type_checkers)
from pypy.module.cpyext.pyerrors import PyErr_BadInternalCall
-from pypy.module.cpyext.pyobject import Py_DecRef, PyObject, make_ref
+from pypy.module.cpyext.pyobject import decref, incref, PyObject, make_ref
from pypy.objspace.std.listobject import W_ListObject
from pypy.interpreter.error import oefmt
@@ -19,59 +20,69 @@
PySequence_SetItem() or expose the object to Python code before
setting all items to a real object with PyList_SetItem().
"""
- return space.newlist([None] * len)
+ w_list = space.newlist([None] * len)
+ #w_list.convert_to_cpy_strategy(space)
+ return w_list
- at cpython_api([rffi.VOIDP, Py_ssize_t, PyObject], PyObject, error=CANNOT_FAIL,
- result_borrowed=True)
-def PyList_SET_ITEM(space, w_list, index, w_item):
- """Macro form of PyList_SetItem() without error checking. This is normally
+ at always_inline
+def get_list_storage(space, w_list):
+ from pypy.module.cpyext.sequence import CPyListStrategy
+ w_list.convert_to_cpy_strategy(space)
+ return CPyListStrategy.unerase(w_list.lstorage)
+
+ at cpython_api([rffi.VOIDP, Py_ssize_t, PyObject], lltype.Void, error=CANNOT_FAIL)
+def PyList_SET_ITEM(space, w_list, index, py_item):
+ """Form of PyList_SetItem() without error checking. This is normally
only used to fill in new lists where there is no previous content.
- This function "steals" a reference to item, and, unlike PyList_SetItem(),
- does not discard a reference to any item that it being replaced; any
- reference in list at position i will be leaked.
+ "steals" a reference to item, and, unlike PyList_SetItem(), does not
+ discard a reference to any item that it being replaced; any reference in
+ list at position i will be leaked.
"""
assert isinstance(w_list, W_ListObject)
+ storage = get_list_storage(space, w_list)
assert 0 <= index < w_list.length()
- # Deliberately leak, so that it can be safely decref'd.
- make_ref(space, w_list.getitem(index))
- Py_DecRef(space, w_item)
- w_list.setitem(index, w_item)
- return w_item
-
+ storage._elems[index] = py_item
@cpython_api([PyObject, Py_ssize_t, PyObject], rffi.INT_real, error=-1)
-def PyList_SetItem(space, w_list, index, w_item):
+def PyList_SetItem(space, w_list, index, py_item):
"""Set the item at index index in list to item. Return 0 on success
or -1 on failure.
-
+
This function "steals" a reference to item and discards a reference to
an item already in the list at the affected position.
"""
- Py_DecRef(space, w_item)
if not isinstance(w_list, W_ListObject):
+ decref(space, py_item)
PyErr_BadInternalCall(space)
if index < 0 or index >= w_list.length():
+ decref(space, py_item)
raise oefmt(space.w_IndexError, "list assignment index out of range")
- w_list.setitem(index, w_item)
+ storage = get_list_storage(space, w_list)
+ py_old = storage._elems[index]
+ storage._elems[index] = py_item
+ decref(w_list.space, py_old)
return 0
- at cpython_api([PyObject, Py_ssize_t], PyObject, result_borrowed=True)
+ at cpython_api([rffi.VOIDP, Py_ssize_t], PyObject, result_is_ll=True)
+def PyList_GET_ITEM(space, w_list, index):
+ assert isinstance(w_list, W_ListObject)
+ storage = get_list_storage(space, w_list)
+ assert 0 <= index < w_list.length()
+ return storage._elems[index] # borrowed ref
+
+ at cpython_api([PyObject, Py_ssize_t], PyObject, result_is_ll=True)
def PyList_GetItem(space, w_list, index):
"""Return the object at position pos in the list pointed to by p. The
position must be positive, indexing from the end of the list is not
supported. If pos is out of bounds, return NULL and set an
IndexError exception."""
- from pypy.module.cpyext.sequence import CPyListStrategy
if not isinstance(w_list, W_ListObject):
PyErr_BadInternalCall(space)
if index < 0 or index >= w_list.length():
raise oefmt(space.w_IndexError, "list index out of range")
- cpy_strategy = space.fromcache(CPyListStrategy)
- if w_list.strategy is not cpy_strategy:
- w_list.ensure_object_strategy() # make sure we can return a borrowed obj
- w_res = w_list.getitem(index)
- return w_res # borrowed ref
+ storage = get_list_storage(space, w_list)
+ return storage._elems[index] # borrowed ref
@cpython_api([PyObject, PyObject], rffi.INT_real, error=-1)
diff --git a/pypy/module/cpyext/pyobject.py b/pypy/module/cpyext/pyobject.py
--- a/pypy/module/cpyext/pyobject.py
+++ b/pypy/module/cpyext/pyobject.py
@@ -30,8 +30,7 @@
return subtype_dealloc.api_func
def allocate(self, space, w_type, itemcount=0):
- # similar to PyType_GenericAlloc?
- # except that it's not related to any pypy object.
+ # typically called from PyType_GenericAlloc via typedescr.allocate
# this returns a PyObject with ob_refcnt == 1.
pytype = as_pyobj(space, w_type)
@@ -250,6 +249,8 @@
w_obj = rawrefcount.to_obj(W_Root, pyobj)
return w_obj is not None and w_obj is not w_marker_deallocating
+def w_obj_has_pyobj(w_obj):
+ return bool(rawrefcount.from_obj(PyObject, w_obj))
def is_pyobj(x):
if x is None or isinstance(x, W_Root):
@@ -275,13 +276,14 @@
"""
if is_pyobj(obj):
pyobj = rffi.cast(PyObject, obj)
+ at_least = 1
else:
pyobj = as_pyobj(space, obj, w_userdata)
+ at_least = rawrefcount.REFCNT_FROM_PYPY
if pyobj:
- assert pyobj.c_ob_refcnt > 0
+ assert pyobj.c_ob_refcnt >= at_least
pyobj.c_ob_refcnt += 1
- if not is_pyobj(obj):
- keepalive_until_here(obj)
+ keepalive_until_here(obj)
return pyobj
@@ -315,9 +317,14 @@
obj = rffi.cast(PyObject, obj)
if obj:
assert obj.c_ob_refcnt > 0
+ assert obj.c_ob_pypy_link == 0 or obj.c_ob_refcnt > rawrefcount.REFCNT_FROM_PYPY
obj.c_ob_refcnt -= 1
if obj.c_ob_refcnt == 0:
_Py_Dealloc(space, obj)
+ #else:
+ # w_obj = rawrefcount.to_obj(W_Root, ref)
+ # if w_obj is not None:
+ # assert obj.c_ob_refcnt >= rawrefcount.REFCNT_FROM_PYPY
else:
get_w_obj_and_decref(space, obj)
diff --git a/pypy/module/cpyext/sequence.py b/pypy/module/cpyext/sequence.py
--- a/pypy/module/cpyext/sequence.py
+++ b/pypy/module/cpyext/sequence.py
@@ -256,8 +256,9 @@
def setitem(self, w_list, index, w_obj):
storage = self.unerase(w_list.lstorage)
index = self._check_index(index, storage._length)
- decref(w_list.space, storage._elems[index])
+ py_old = storage._elems[index]
storage._elems[index] = make_ref(w_list.space, w_obj)
+ decref(w_list.space, py_old)
def length(self, w_list):
storage = self.unerase(w_list.lstorage)
diff --git a/pypy/module/cpyext/stubs.py b/pypy/module/cpyext/stubs.py
--- a/pypy/module/cpyext/stubs.py
+++ b/pypy/module/cpyext/stubs.py
@@ -490,29 +490,6 @@
0 on success, -1 on failure."""
raise NotImplementedError
- at cpython_api([rffi.CCHARP], rffi.INT_real, error=1)
-def Py_EnterRecursiveCall(space, where):
- """Marks a point where a recursive C-level call is about to be performed.
-
- If USE_STACKCHECK is defined, this function checks if the the OS
- stack overflowed using PyOS_CheckStack(). In this is the case, it
- sets a MemoryError and returns a nonzero value.
-
- The function then checks if the recursion limit is reached. If this is the
- case, a RuntimeError is set and a nonzero value is returned.
- Otherwise, zero is returned.
-
- where should be a string such as " in instance check" to be
- concatenated to the RuntimeError message caused by the recursion depth
- limit."""
- raise NotImplementedError
-
- at cpython_api([], lltype.Void)
-def Py_LeaveRecursiveCall(space):
- """Ends a Py_EnterRecursiveCall(). Must be called once for each
- successful invocation of Py_EnterRecursiveCall()."""
- raise NotImplementedError
-
@cpython_api([PyFileObject], lltype.Void)
def PyFile_IncUseCount(space, p):
"""Increments the PyFileObject's internal use count to indicate
diff --git a/pypy/module/cpyext/test/array.c b/pypy/module/cpyext/test/array.c
--- a/pypy/module/cpyext/test/array.c
+++ b/pypy/module/cpyext/test/array.c
@@ -1872,6 +1872,7 @@
for (nn = 0; nn < n; nn++)
{
v = PyList_GetItem(obj1, nn);
+ Py_INCREF(v);
PyList_SetItem(ret, nn+ii*n, v);
}
return ret;
@@ -1887,6 +1888,7 @@
for (nn = 0; nn < n; nn++)
{
v = PyList_GetItem(obj2, nn);
+ Py_INCREF(v);
PyList_SetItem(ret, nn+ii*n, v);
}
return ret;
diff --git a/pypy/module/cpyext/test/test_eval.py b/pypy/module/cpyext/test/test_eval.py
--- a/pypy/module/cpyext/test/test_eval.py
+++ b/pypy/module/cpyext/test/test_eval.py
@@ -331,3 +331,30 @@
def nested_flags():
return module.get_flags()""" in ns
assert ns['nested_flags']() == (1, 0x2000) # CO_FUTURE_DIVISION
+
+ def test_recursive_function(self):
+ module = self.import_extension('foo', [
+ ("call_recursive", "METH_NOARGS",
+ """
+ int res = 0;
+ int recurse(void) {
+ if (Py_EnterRecursiveCall(" while calling recurse"))
+ return -1;
+ res ++;
+ return recurse();
+ }
+ int oldlimit = Py_GetRecursionLimit();
+ Py_SetRecursionLimit(200);
+ res = recurse();
+ Py_SetRecursionLimit(oldlimit);
+ if (PyErr_Occurred())
+ return NULL;
+ return PyLong_FromLong(res);
+ """),], prologue= ''' int recurse(void); '''
+ )
+ try:
+ res = module.call_recursive()
+ except RuntimeError as e:
+ assert 'while calling recurse' in str(e)
+ else:
+ assert False, "expected RuntimeError"
diff --git a/pypy/module/cpyext/test/test_listobject.py b/pypy/module/cpyext/test/test_listobject.py
--- a/pypy/module/cpyext/test/test_listobject.py
+++ b/pypy/module/cpyext/test/test_listobject.py
@@ -38,11 +38,13 @@
assert api.PyList_Insert(w_l, 0, space.wrap(1)) == 0
assert api.PyList_Size(w_l) == 3
assert api.PyList_Insert(w_l, 99, space.wrap(2)) == 0
- assert space.unwrap(api.PyList_GetItem(w_l, 3)) == 2
+ assert api.PyObject_Compare(api.PyList_GetItem(w_l, 3),
+ space.wrap(2)) == 0
# insert at index -1: next-to-last
assert api.PyList_Insert(w_l, -1, space.wrap(3)) == 0
- assert space.unwrap(api.PyList_GetItem(w_l, 3)) == 3
-
+ assert api.PyObject_Compare(api.PyList_GET_ITEM(w_l, 3),
+ space.wrap(3)) == 0
+
def test_sort(self, space, api):
l = space.newlist([space.wrap(1), space.wrap(0), space.wrap(7000)])
assert api.PyList_Sort(l) == 0
@@ -152,29 +154,35 @@
def test_list_macros(self):
"""The PyList_* macros cast, and calls expecting that build."""
module = self.import_extension('foo', [
- ("test_macro_invocations", "METH_NOARGS",
+ ("test_macro_invocations", "METH_O",
"""
PyObject* o = PyList_New(2);
PyListObject* l = (PyListObject*)o;
+ Py_INCREF(args);
+ Py_INCREF(args);
+ PyList_SET_ITEM(o, 0, args);
+ PyList_SET_ITEM(l, 1, args);
- Py_INCREF(o);
- PyList_SET_ITEM(o, 0, o);
- Py_INCREF(o);
- PyList_SET_ITEM(l, 1, o);
+ if(PyList_GET_ITEM(o, 0) != PyList_GET_ITEM(l, 1))
+ {
+ PyErr_SetString(PyExc_AssertionError, "PyList_GET_ITEM error");
+ return NULL;
+ }
- PyList_GET_ITEM(o, 0);
- PyList_GET_ITEM(l, 1);
-
- PyList_GET_SIZE(o);
- PyList_GET_SIZE(l);
+ if(PyList_GET_SIZE(o) != PyList_GET_SIZE(l))
+ {
+ PyErr_SetString(PyExc_AssertionError, "PyList_GET_SIZE error");
+ return NULL;
+ }
return o;
"""
)
])
- x = module.test_macro_invocations()
- assert x[0] is x[1] is x
+ s = 'abcdef'
+ x = module.test_macro_invocations(s)
+ assert x[0] is x[1] is s
def test_get_item_macro(self):
module = self.import_extension('foo', [
@@ -183,39 +191,96 @@
PyObject* o, *o2, *o3;
o = PyList_New(1);
- o2 = PyInt_FromLong(0);
+ o2 = PyBytes_FromString("test_get_item0");
+ Py_INCREF(o2);
PyList_SET_ITEM(o, 0, o2);
- o2 = NULL;
o3 = PyList_GET_ITEM(o, 0);
Py_INCREF(o3);
- Py_CLEAR(o);
+ Py_DECREF(o);
+ Py_DECREF(o2);
return o3;
""")])
- assert module.test_get_item() == 0
+ assert module.test_get_item() == b'test_get_item0'
- def test_set_item_macro(self):
+ def test_item_refcounts(self):
"""PyList_SET_ITEM leaks a reference to the target."""
module = self.import_extension('foo', [
- ("test_refcount_diff_after_setitem", "METH_NOARGS",
+ ("test_refcount_diff", "METH_VARARGS",
"""
- PyObject* o = PyList_New(0);
- PyObject* o2 = PyList_New(0);
- Py_ssize_t refcount, new_refcount;
+ /* test that the refcount differences for functions
+ * are correct. diff1 - expected refcount diff for i1,
+ * diff2 - expected refcount diff for i2
+ */
+ #define CHECKCOUNT(diff1, diff2, action) \
+ new_count1 = Py_REFCNT(i1); \
+ new_count2 = Py_REFCNT(i2); \
+ diff = new_count1 - old_count1; \
+ if (diff != diff1) {\
+ sprintf(errbuffer, action \
+ " i1 expected diff of %ld got %ld", (long)diff1, (long)diff); \
+ PyErr_SetString(PyExc_AssertionError, errbuffer); \
+ return NULL; } \
+ diff = new_count2 - old_count2; \
+ if (diff != diff2) {\
+ sprintf(errbuffer, action \
+ " i2 expected diff of %ld got %ld", (long)diff2, (long)diff); \
+ PyErr_SetString(PyExc_AssertionError, errbuffer); \
+ return NULL; } \
+ old_count1 = new_count1; \
+ old_count2 = new_count2;
- PyList_Append(o, o2); // does not steal o2
+ PyObject* tmp, *o = PyList_New(0);
+ char errbuffer[1024];
+ PyObject* i1 = PyTuple_GetItem(args, 0);
+ PyObject* i2 = PyTuple_GetItem(args, 1);
+ Py_ssize_t old_count1, new_count1;
+ Py_ssize_t old_count2, new_count2;
+ Py_ssize_t diff;
+ int ret;
- refcount = Py_REFCNT(o2);
+ old_count1 = Py_REFCNT(i1);
+ old_count2 = Py_REFCNT(i2);
- // Steal a reference to o2, but leak the old reference to o2.
- // The net result should be no change in refcount.
- PyList_SET_ITEM(o, 0, o2);
+ ret = PyList_Append(o, i1);
+ if (ret != 0)
+ return NULL;
+ /* check the result of Append(), and also force the list
+ to use the CPyListStrategy now */
+ if (PyList_GET_ITEM(o, 0) != i1)
+ {
+ PyErr_SetString(PyExc_AssertionError, "Append() error?");
+ return NULL;
+ }
+ CHECKCOUNT(1, 0, "PyList_Append");
- new_refcount = Py_REFCNT(o2);
+ Py_INCREF(i2); /* for PyList_SET_ITEM */
+ CHECKCOUNT(0, 1, "Py_INCREF");
- Py_CLEAR(o);
- Py_DECREF(o2); // append incref'd.
- // Py_CLEAR(o2); // naive implementation would fail here.
- return PyLong_FromSsize_t(new_refcount - refcount);
+ PyList_SET_ITEM(o, 0, i2);
+ CHECKCOUNT(0, 0, "PyList_SET_ITEM");
+
+ tmp = PyList_GET_ITEM(o, 0);
+ if (tmp != i2)
+ {
+ PyErr_SetString(PyExc_AssertionError, "SetItem() error?");
+ return NULL;
+ }
+ CHECKCOUNT(0, 0, "PyList_GET_ITEM");
+
+ PyList_SetItem(o, 0, i1);
+ CHECKCOUNT(0, -1, "PyList_Set_Item");
+
+ PyList_GetItem(o, 0);
+ CHECKCOUNT(0, 0, "PyList_Get_Item");
+
+ Py_DECREF(o);
+ #ifndef PYPY_VERSION
+ {
+ // PyPy deletes only at teardown
+ CHECKCOUNT(-1, 0, "Py_DECREF(o)");
+ }
+ #endif
+ return PyLong_FromSsize_t(0);
""")])
- assert module.test_refcount_diff_after_setitem() == 0
+ assert module.test_refcount_diff(["first"], ["second"]) == 0
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
@@ -24,7 +24,7 @@
W_PyCMethodObject, W_PyCFunctionObject)
from pypy.module.cpyext.modsupport import convert_method_defs
from pypy.module.cpyext.pyobject import (
- PyObject, make_ref, create_ref, from_ref, get_typedescr, make_typedescr,
+ PyObject, make_ref, from_ref, get_typedescr, make_typedescr,
track_reference, Py_DecRef, as_pyobj)
from pypy.module.cpyext.slotdefs import (
slotdefs_for_tp_slots, slotdefs_for_wrappers, get_slot_tp_function,
diff --git a/pypy/objspace/std/bytesobject.py b/pypy/objspace/std/bytesobject.py
--- a/pypy/objspace/std/bytesobject.py
+++ b/pypy/objspace/std/bytesobject.py
@@ -611,55 +611,31 @@
return mod_format(space, w_values, self, do_unicode=False)
def descr_eq(self, space, w_other):
- if space.config.objspace.std.withstrbuf:
- from pypy.objspace.std.strbufobject import W_StringBufferObject
- if isinstance(w_other, W_StringBufferObject):
- return space.newbool(self._value == w_other.force())
if not isinstance(w_other, W_BytesObject):
return space.w_NotImplemented
return space.newbool(self._value == w_other._value)
def descr_ne(self, space, w_other):
- if space.config.objspace.std.withstrbuf:
- from pypy.objspace.std.strbufobject import W_StringBufferObject
- if isinstance(w_other, W_StringBufferObject):
- return space.newbool(self._value != w_other.force())
if not isinstance(w_other, W_BytesObject):
return space.w_NotImplemented
return space.newbool(self._value != w_other._value)
def descr_lt(self, space, w_other):
- if space.config.objspace.std.withstrbuf:
- from pypy.objspace.std.strbufobject import W_StringBufferObject
- if isinstance(w_other, W_StringBufferObject):
- return space.newbool(self._value < w_other.force())
if not isinstance(w_other, W_BytesObject):
return space.w_NotImplemented
return space.newbool(self._value < w_other._value)
def descr_le(self, space, w_other):
- if space.config.objspace.std.withstrbuf:
- from pypy.objspace.std.strbufobject import W_StringBufferObject
- if isinstance(w_other, W_StringBufferObject):
- return space.newbool(self._value <= w_other.force())
if not isinstance(w_other, W_BytesObject):
return space.w_NotImplemented
return space.newbool(self._value <= w_other._value)
def descr_gt(self, space, w_other):
- if space.config.objspace.std.withstrbuf:
- from pypy.objspace.std.strbufobject import W_StringBufferObject
- if isinstance(w_other, W_StringBufferObject):
- return space.newbool(self._value > w_other.force())
if not isinstance(w_other, W_BytesObject):
return space.w_NotImplemented
return space.newbool(self._value > w_other._value)
def descr_ge(self, space, w_other):
- if space.config.objspace.std.withstrbuf:
- from pypy.objspace.std.strbufobject import W_StringBufferObject
- if isinstance(w_other, W_StringBufferObject):
- return space.newbool(self._value >= w_other.force())
if not isinstance(w_other, W_BytesObject):
return space.w_NotImplemented
return space.newbool(self._value >= w_other._value)
@@ -677,18 +653,6 @@
from .bytearrayobject import W_BytearrayObject, _make_data
self_as_bytearray = W_BytearrayObject(_make_data(self._value))
return space.add(self_as_bytearray, w_other)
- if space.config.objspace.std.withstrbuf:
- from pypy.objspace.std.strbufobject import W_StringBufferObject
- try:
- other = self._op_val(space, w_other)
- except OperationError as e:
- if e.match(space, space.w_TypeError):
- return space.w_NotImplemented
- raise
- builder = StringBuilder()
- builder.append(self._value)
- builder.append(other)
- return W_StringBufferObject(builder)
return self._StringMethods_descr_add(space, w_other)
_StringMethods__startswith = _startswith
diff --git a/pypy/objspace/std/listobject.py b/pypy/objspace/std/listobject.py
--- a/pypy/objspace/std/listobject.py
+++ b/pypy/objspace/std/listobject.py
@@ -230,15 +230,13 @@
return list(items)
def switch_to_object_strategy(self):
+ object_strategy = self.space.fromcache(ObjectListStrategy)
+ if self.strategy is object_strategy:
+ return
list_w = self.getitems()
- object_strategy = self.space.fromcache(ObjectListStrategy)
self.strategy = object_strategy
object_strategy.init_from_list_w(self, list_w)
- def ensure_object_strategy(self): # for cpyext
- if self.strategy is not self.space.fromcache(ObjectListStrategy):
- self.switch_to_object_strategy()
-
def _temporarily_as_objects(self):
if self.strategy is self.space.fromcache(ObjectListStrategy):
return self
diff --git a/pypy/objspace/std/objspace.py b/pypy/objspace/std/objspace.py
--- a/pypy/objspace/std/objspace.py
+++ b/pypy/objspace/std/objspace.py
@@ -16,7 +16,7 @@
from pypy.objspace.std.boolobject import W_BoolObject
from pypy.objspace.std.bufferobject import W_Buffer
from pypy.objspace.std.bytearrayobject import W_BytearrayObject
-from pypy.objspace.std.bytesobject import W_AbstractBytesObject, W_BytesObject
+from pypy.objspace.std.bytesobject import W_BytesObject
from pypy.objspace.std.complexobject import W_ComplexObject
from pypy.objspace.std.dictmultiobject import W_DictMultiObject, W_DictObject
from pypy.objspace.std.floatobject import W_FloatObject
@@ -81,9 +81,6 @@
W_TypeObject.typedef: W_TypeObject,
W_UnicodeObject.typedef: W_UnicodeObject,
}
- if self.config.objspace.std.withstrbuf:
- builtin_type_classes[W_BytesObject.typedef] = W_AbstractBytesObject
-
self.builtin_types = {}
self._interplevel_classes = {}
for typedef, cls in builtin_type_classes.items():
@@ -285,7 +282,7 @@
return W_LongObject.fromint(self, val)
@specialize.argtype(1)
- def newlong_from_rarith_int(self, val): # val is an rarithmetic type
+ def newlong_from_rarith_int(self, val): # val is an rarithmetic type
return W_LongObject.fromrarith_int(val)
def newlong_from_rbigint(self, val):
diff --git a/pypy/objspace/std/strbufobject.py b/pypy/objspace/std/strbufobject.py
deleted file mode 100644
--- a/pypy/objspace/std/strbufobject.py
+++ /dev/null
@@ -1,96 +0,0 @@
-import inspect
-
-import py
-
-from pypy.objspace.std.bytesobject import W_AbstractBytesObject, W_BytesObject
-from pypy.interpreter.gateway import interp2app, unwrap_spec
-from pypy.interpreter.buffer import SimpleView, StringBuffer
-from pypy.interpreter.error import OperationError
-from rpython.rlib.rstring import StringBuilder
-
-
-class W_StringBufferObject(W_AbstractBytesObject):
- w_str = None
-
- def __init__(self, builder):
- self.builder = builder # StringBuilder
- self.length = builder.getlength()
-
- def force(self):
- if self.w_str is None:
- s = self.builder.build()
- if self.length < len(s):
- s = s[:self.length]
- self.w_str = W_BytesObject(s)
- return s
- else:
- return self.w_str._value
-
- def __repr__(self):
- """ representation for debugging purposes """
- return "%s(%r[:%d])" % (
- self.__class__.__name__, self.builder, self.length)
-
- def unwrap(self, space):
- return self.force()
-
- def str_w(self, space):
- return self.force()
-
- def buffer_w(self, space, flags):
- return SimpleView(StringBuffer(self.force()))
-
- def descr_len(self, space):
- return space.newint(self.length)
-
- def descr_add(self, space, w_other):
- try:
- other = W_BytesObject._op_val(space, w_other)
- except OperationError as e:
- if e.match(space, space.w_TypeError):
- return space.w_NotImplemented
- raise
- if self.builder.getlength() != self.length:
- builder = StringBuilder()
- builder.append(self.force())
- else:
- builder = self.builder
- builder.append(other)
- return W_StringBufferObject(builder)
-
- def descr_str(self, space):
- # you cannot get subclasses of W_StringBufferObject here
- assert type(self) is W_StringBufferObject
- return self
-
-
-delegation_dict = {}
-for key, value in W_BytesObject.typedef.rawdict.iteritems():
- if not isinstance(value, interp2app):
- continue
- if key in ('__len__', '__add__', '__str__'):
- continue
-
- func = value._code._bltin
- args = inspect.getargs(func.func_code)
- if args.varargs or args.keywords:
- raise TypeError("Varargs and keywords not supported in unwrap_spec")
- argspec = ', '.join([arg for arg in args.args[1:]])
- func_code = py.code.Source("""
- def f(self, %(args)s):
- self.force()
- return self.w_str.%(func_name)s(%(args)s)
- """ % {'args': argspec, 'func_name': func.func_name})
- d = {}
- exec func_code.compile() in d
- f = d['f']
- f.func_defaults = func.func_defaults
- f.__module__ = func.__module__
- # necessary for unique identifiers for pickling
- f.func_name = func.func_name
- unwrap_spec_ = getattr(func, 'unwrap_spec', None)
- if unwrap_spec_ is not None:
- f = unwrap_spec(**unwrap_spec_)(f)
- setattr(W_StringBufferObject, func.func_name, f)
-
-W_StringBufferObject.typedef = W_BytesObject.typedef
diff --git a/pypy/objspace/std/test/test_stdobjspace.py b/pypy/objspace/std/test/test_stdobjspace.py
--- a/pypy/objspace/std/test/test_stdobjspace.py
+++ b/pypy/objspace/std/test/test_stdobjspace.py
@@ -57,13 +57,6 @@
cls = space._get_interplevel_cls(w_sequenceiterator)
assert cls is W_AbstractSeqIterObject
- def test_withstrbuf_fastpath_isinstance(self):
- from pypy.objspace.std.bytesobject import W_AbstractBytesObject
-
- space = gettestobjspace(withstrbuf=True)
- cls = space._get_interplevel_cls(space.w_bytes)
- assert cls is W_AbstractBytesObject
-
def test_wrap_various_unsigned_types(self):
import sys
from rpython.rlib.rarithmetic import r_uint
diff --git a/pypy/objspace/std/test/test_strbufobject.py b/pypy/objspace/std/test/test_strbufobject.py
deleted file mode 100644
--- a/pypy/objspace/std/test/test_strbufobject.py
+++ /dev/null
@@ -1,85 +0,0 @@
-import py
-
-from pypy.objspace.std.test import test_bytesobject
-
-class AppTestStringObject(test_bytesobject.AppTestBytesObject):
- spaceconfig = {"objspace.std.withstrbuf": True}
-
- def test_basic(self):
- import __pypy__
- # cannot do "Hello, " + "World!" because cpy2.5 optimises this
- # away on AST level
- s = "Hello, ".__add__("World!")
- assert type(s) is str
- assert 'W_StringBufferObject' in __pypy__.internal_repr(s)
-
- def test_add_twice(self):
- x = "a".__add__("b")
- y = x + "c"
- c = x + "d"
- assert y == "abc"
- assert c == "abd"
-
- def test_add(self):
- import __pypy__
- all = ""
- for i in range(20):
- all += str(i)
- assert 'W_StringBufferObject' in __pypy__.internal_repr(all)
- assert all == "012345678910111213141516171819"
-
- def test_hash(self):
- import __pypy__
- def join(s): return s[:len(s) // 2] + s[len(s) // 2:]
- t = 'a' * 101
- s = join(t)
- assert 'W_StringBufferObject' in __pypy__.internal_repr(s)
- assert hash(s) == hash(t)
-
- def test_len(self):
- s = "a".__add__("b")
- r = "c".__add__("d")
- t = s + r
- assert len(s) == 2
- assert len(r) == 2
- assert len(t) == 4
-
- def test_buffer(self):
- s = b'a'.__add__(b'b')
- assert buffer(s) == buffer(b'ab')
- assert memoryview(s) == b'ab'
-
- def test_add_strbuf(self):
- # make three strbuf objects
- s = 'a'.__add__('b')
- t = 'x'.__add__('c')
- u = 'y'.__add__('d')
-
- # add two different strbufs to the same string
- v = s + t
- w = s + u
-
- # check that insanity hasn't resulted.
- assert v == "abxc"
- assert w == "abyd"
-
- def test_more_adding_fun(self):
- s = 'a'.__add__('b') # s is a strbuf now
- t = s + 'c'
- u = s + 'd'
- v = s + 'e'
- assert v == 'abe'
- assert u == 'abd'
- assert t == 'abc'
-
- def test_buh_even_more(self):
- a = 'a'.__add__('b')
- b = a + 'c'
- c = '0'.__add__('1')
- x = c + a
- assert x == '01ab'
-
- def test_add_non_string(self):
- a = 'a'
- a += 'b'
- raises(TypeError, "a += 5")
More information about the pypy-commit
mailing list