[pypy-commit] pypy py3k: merge default
pjenvey
noreply at buildbot.pypy.org
Tue Mar 18 23:24:17 CET 2014
Author: Philip Jenvey <pjenvey at underboss.org>
Branch: py3k
Changeset: r70068:82be71463fe1
Date: 2014-03-18 15:15 -0700
http://bitbucket.org/pypy/pypy/changeset/82be71463fe1/
Log: merge default
diff too long, truncating to 2000 out of 3534 lines
diff --git a/lib_pypy/_sqlite3.py b/lib_pypy/_sqlite3.py
--- a/lib_pypy/_sqlite3.py
+++ b/lib_pypy/_sqlite3.py
@@ -38,6 +38,7 @@
if sys.version_info[0] >= 3:
StandardError = Exception
+ cmp = lambda x, y: (x > y) - (x < y)
long = int
xrange = range
basestring = unicode = str
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
@@ -105,3 +105,12 @@
.. branch: stdlib-2.7.6
Update stdlib to v2.7.6
+
+.. branch: virtual-raw-store-load
+Support for virtualizing raw_store/raw_load operations
+
+.. branch: refactor-buffer-api
+Separate the interp-level buffer API from the buffer type exposed to
+app-level. The `Buffer` class is now used by `W_MemoryView` and
+`W_Buffer`, which is not present in Python 3. Previously `W_Buffer` was
+an alias to `Buffer`, which was wrappable itself.
diff --git a/pypy/interpreter/baseobjspace.py b/pypy/interpreter/baseobjspace.py
--- a/pypy/interpreter/baseobjspace.py
+++ b/pypy/interpreter/baseobjspace.py
@@ -193,6 +193,14 @@
def immutable_unique_id(self, space):
return None
+ def buffer_w(self, space):
+ w_impl = space.lookup(self, '__buffer__')
+ if w_impl is not None:
+ w_result = space.get_and_call_function(w_impl, self)
+ if space.isinstance_w(w_result, space.w_buffer):
+ return w_result.buf
+ self._typed_unwrap_error(space, "buffer")
+
def bytes_w(self, space):
self._typed_unwrap_error(space, "bytes")
@@ -436,14 +444,12 @@
def getbuiltinmodule(self, name, force_init=False):
w_name = self.wrap(name)
w_modules = self.sys.get('modules')
- try:
- w_mod = self.getitem(w_modules, w_name)
- except OperationError, e:
- if not e.match(self, self.w_KeyError):
- raise
- else:
- if not force_init:
- return w_mod
+ if not force_init:
+ try:
+ return self.getitem(w_modules, w_name)
+ except OperationError, e:
+ if not e.match(self, self.w_KeyError):
+ raise
# If the module is a builtin but not yet imported,
# retrieve it and initialize it
@@ -454,13 +460,13 @@
"getbuiltinmodule() called with non-builtin module %s",
name)
else:
- # Add the module to sys.modules
- self.setitem(w_modules, w_name, w_mod)
-
# And initialize it
from pypy.interpreter.module import Module
if isinstance(w_mod, Module):
w_mod.init(self)
+
+ # Add the module to sys.modules
+ self.setitem(w_modules, w_name, w_mod)
return w_mod
def get_builtinmodule_to_install(self):
@@ -1307,10 +1313,7 @@
'to unsigned int'))
def buffer_w(self, w_obj):
- # returns a Buffer instance
- from pypy.interpreter.buffer import Buffer
- w_buffer = self.buffer(w_obj)
- return self.interp_w(Buffer, w_buffer)
+ return w_obj.buffer_w(self)
def rwbuffer_w(self, w_obj):
# returns a RWBuffer instance
@@ -1727,7 +1730,6 @@
('set', 'set', 3, ['__set__']),
('delete', 'delete', 2, ['__delete__']),
('userdel', 'del', 1, ['__del__']),
- ('buffer', 'buffer', 1, ['__buffer__']), # see buffer.py
]
ObjSpace.BuiltinModuleTable = [
diff --git a/pypy/interpreter/buffer.py b/pypy/interpreter/buffer.py
--- a/pypy/interpreter/buffer.py
+++ b/pypy/interpreter/buffer.py
@@ -1,30 +1,12 @@
"""
Buffer protocol support.
"""
+from pypy.interpreter.error import OperationError
+from rpython.rlib.objectmodel import import_from_mixin
-# The implementation of the buffer protocol. The basic idea is that we
-# can ask any app-level object for a 'buffer' view on it, by calling its
-# __buffer__() special method. It should return a wrapped instance of a
-# subclass of the Buffer class defined below. Note that __buffer__() is
-# a PyPy-only extension to the Python language, made necessary by the
-# fact that it's not natural in PyPy to hack an interp-level-only
-# interface.
-# In normal usage, the convenience method space.buffer_w() should be
-# used to get directly a Buffer instance. Doing so also gives you for
-# free the typecheck that __buffer__() really returned a wrapped Buffer.
-
-import operator
-from pypy.interpreter.baseobjspace import W_Root
-from pypy.interpreter.typedef import TypeDef
-from pypy.interpreter.gateway import interp2app, unwrap_spec
-from pypy.interpreter.error import OperationError
-from rpython.rlib.objectmodel import compute_hash, import_from_mixin
-from rpython.rlib.rstring import StringBuilder
-
-
-class Buffer(W_Root):
- """Abstract base class for memory views."""
+class Buffer(object):
+ """Abstract base class for buffers."""
__slots__ = () # no extra slot here
@@ -47,94 +29,12 @@
def get_raw_address(self):
raise ValueError("no raw buffer")
+
def is_writable(self):
return False
- # __________ app-level support __________
-
- def descr_len(self, space):
- return space.wrap(self.getlength())
-
- def descr_getitem(self, space, w_index):
- start, stop, step, size = space.decode_index4(w_index, self.getlength())
- if step == 0: # index only
- return space.wrapbytes(self.getitem(start))
- res = self.getslice(start, stop, step, size)
- return space.wrapbytes(res)
-
- @unwrap_spec(newstring='bufferstr')
- def descr_setitem(self, space, w_index, newstring):
- if not isinstance(self, RWBuffer):
- raise OperationError(space.w_TypeError,
- space.wrap("buffer is read-only"))
- start, stop, step, size = space.decode_index4(w_index, self.getlength())
- if step == 0: # index only
- if len(newstring) != 1:
- msg = 'buffer[index]=x: x must be a single character'
- raise OperationError(space.w_TypeError, space.wrap(msg))
- char = newstring[0] # annotator hint
- self.setitem(start, char)
- elif step == 1:
- if len(newstring) != size:
- msg = "right operand length must match slice length"
- raise OperationError(space.w_ValueError, space.wrap(msg))
- self.setslice(start, newstring)
- else:
- raise OperationError(space.w_ValueError,
- space.wrap("buffer object does not support"
- " slicing with a step"))
-
- def descr__buffer__(self, space):
- return space.wrap(self)
-
- def descr_str(self, space):
- return space.wrap(self.as_str())
-
- @unwrap_spec(other='bufferstr')
- def descr_add(self, space, other):
- return space.wrapbytes(self.as_str() + other)
-
- def _make_descr__cmp(name):
- def descr__cmp(self, space, w_other):
- if not isinstance(w_other, Buffer):
- return space.w_NotImplemented
- # xxx not the most efficient implementation
- str1 = self.as_str()
- str2 = w_other.as_str()
- return space.wrap(getattr(operator, name)(str1, str2))
- descr__cmp.func_name = name
- return descr__cmp
-
- descr_eq = _make_descr__cmp('eq')
- descr_ne = _make_descr__cmp('ne')
- descr_lt = _make_descr__cmp('lt')
- descr_le = _make_descr__cmp('le')
- descr_gt = _make_descr__cmp('gt')
- descr_ge = _make_descr__cmp('ge')
-
- def descr_hash(self, space):
- return space.wrap(compute_hash(self.as_str()))
-
- def descr_mul(self, space, w_times):
- # xxx not the most efficient implementation
- w_string = space.wrapbytes(self.as_str())
- # use the __mul__ method instead of space.mul() so that we
- # return NotImplemented instead of raising a TypeError
- return space.call_method(w_string, '__mul__', w_times)
-
- def descr_repr(self, space):
- if isinstance(self, RWBuffer):
- info = 'read-write buffer'
- else:
- info = 'read-only buffer'
- addrstring = self.getaddrstring(space)
-
- return space.wrap("<%s for 0x%s, size %d>" %
- (info, addrstring, self.getlength()))
-
-
class RWBuffer(Buffer):
- """Abstract base class for read-write memory views."""
+ """Abstract base class for read-write buffers."""
__slots__ = () # no extra slot here
@@ -151,72 +51,6 @@
self.setitem(start + i, string[i])
- at unwrap_spec(offset=int, size=int)
-def descr_buffer__new__(space, w_subtype, w_object, offset=0, size=-1):
- # w_subtype can only be exactly 'buffer' for now
- if not space.is_w(w_subtype, space.gettypefor(Buffer)):
- raise OperationError(space.w_TypeError,
- space.wrap("argument 1 must be 'buffer'"))
-
- if space.isinstance_w(w_object, space.w_unicode):
- # unicode objects support the old buffer interface
- # but not the new buffer interface (change in python 2.7)
- from rpython.rlib.rstruct.unichar import pack_unichar, UNICODE_SIZE
- unistr = space.unicode_w(w_object)
- builder = StringBuilder(len(unistr) * UNICODE_SIZE)
- for unich in unistr:
- pack_unichar(unich, builder)
- from pypy.interpreter.buffer import StringBuffer
- w_buffer = space.wrap(StringBuffer(builder.build()))
- else:
- w_buffer = space.buffer(w_object)
-
- buffer = space.interp_w(Buffer, w_buffer) # type-check
- if offset == 0 and size == -1:
- return w_buffer
- # handle buffer slices
- if offset < 0:
- raise OperationError(space.w_ValueError,
- space.wrap("offset must be zero or positive"))
- if size < -1:
- raise OperationError(space.w_ValueError,
- space.wrap("size must be zero or positive"))
- if isinstance(buffer, RWBuffer):
- buffer = RWSubBuffer(buffer, offset, size)
- else:
- buffer = SubBuffer(buffer, offset, size)
- return space.wrap(buffer)
-
-
-Buffer.typedef = TypeDef(
- "buffer",
- __doc__ = """\
-buffer(object [, offset[, size]])
-
-Create a new buffer object which references the given object.
-The buffer will reference a slice of the target object from the
-start of the object (or at the specified offset). The slice will
-extend to the end of the target object (or with the specified size).
-""",
- __new__ = interp2app(descr_buffer__new__),
- __len__ = interp2app(Buffer.descr_len),
- __getitem__ = interp2app(Buffer.descr_getitem),
- __setitem__ = interp2app(Buffer.descr_setitem),
- __buffer__ = interp2app(Buffer.descr__buffer__),
- __str__ = interp2app(Buffer.descr_str),
- __add__ = interp2app(Buffer.descr_add),
- __eq__ = interp2app(Buffer.descr_eq),
- __ne__ = interp2app(Buffer.descr_ne),
- __lt__ = interp2app(Buffer.descr_lt),
- __le__ = interp2app(Buffer.descr_le),
- __gt__ = interp2app(Buffer.descr_gt),
- __ge__ = interp2app(Buffer.descr_ge),
- __hash__ = interp2app(Buffer.descr_hash),
- __mul__ = interp2app(Buffer.descr_mul),
- __rmul__ = interp2app(Buffer.descr_mul),
- __repr__ = interp2app(Buffer.descr_repr),
-)
-Buffer.typedef.acceptable_as_base_class = False
# ____________________________________________________________
diff --git a/pypy/interpreter/test/test_buffer.py b/pypy/interpreter/test/test_buffer.py
--- a/pypy/interpreter/test/test_buffer.py
+++ b/pypy/interpreter/test/test_buffer.py
@@ -1,5 +1,5 @@
import py
-from pypy.interpreter.buffer import Buffer
+from pypy.module.__builtin__.interp_memoryview import W_Buffer
from rpython.tool.udir import udir
testdir = udir.ensure('test_buffer', dir=1)
@@ -11,13 +11,12 @@
space = self.space
w_hello = space.wrapbytes('hello world')
buf = space.buffer_w(w_hello)
- assert isinstance(buf, Buffer)
assert buf.getlength() == 11
assert buf.as_str() == 'hello world'
assert buf.getslice(1, 6, 1, 5) == 'ello '
- assert space.buffer_w(space.wrap(buf)) is buf
+ assert space.buffer_w(W_Buffer(buf)) is buf
assert space.bufferstr_w(w_hello) == 'hello world'
- assert space.bufferstr_w(space.buffer(w_hello)) == 'hello world'
+ assert space.bufferstr_w(W_Buffer(space.buffer_w(w_hello))) == 'hello world'
space.raises_w(space.w_TypeError, space.buffer_w, space.wrap(5))
e = space.raises_w(space.w_TypeError, space.buffer, space.wrap(5))
message = space.unwrap(e.value.get_w_value(space))
@@ -25,7 +24,7 @@
def test_file_write(self):
space = self.space
- w_buffer = space.buffer(space.wrapbytes('hello world'))
+ w_buffer = W_Buffer(space.buffer_w(space.wrapbytes('hello world')))
filename = str(testdir.join('test_file_write'))
space.appexec([w_buffer, space.wrap(filename)], """(buffer, filename):
f = open(filename, 'wb')
diff --git a/pypy/module/__builtin__/interp_memoryview.py b/pypy/module/__builtin__/interp_memoryview.py
--- a/pypy/module/__builtin__/interp_memoryview.py
+++ b/pypy/module/__builtin__/interp_memoryview.py
@@ -1,22 +1,194 @@
"""
Implementation of the 'buffer' and 'memoryview' types.
"""
+import operator
+
+from pypy.interpreter import buffer
from pypy.interpreter.baseobjspace import W_Root
-from pypy.interpreter import buffer
+from pypy.interpreter.error import OperationError
from pypy.interpreter.gateway import interp2app, unwrap_spec
from pypy.interpreter.typedef import TypeDef, GetSetProperty
-from pypy.interpreter.error import OperationError
-import operator
+from rpython.rlib.objectmodel import compute_hash
+from rpython.rlib.rstring import StringBuilder
-class W_MemoryView(W_Root):
- """Implement the built-in 'memoryview' type as a thin wrapper around
+
+def _buffer_setitem(space, buf, w_index, newstring):
+ start, stop, step, size = space.decode_index4(w_index, buf.getlength())
+ if step == 0: # index only
+ if len(newstring) != 1:
+ msg = 'buffer[index]=x: x must be a single character'
+ raise OperationError(space.w_TypeError, space.wrap(msg))
+ char = newstring[0] # annotator hint
+ buf.setitem(start, char)
+ elif step == 1:
+ if len(newstring) != size:
+ msg = "right operand length must match slice length"
+ raise OperationError(space.w_ValueError, space.wrap(msg))
+ buf.setslice(start, newstring)
+ else:
+ raise OperationError(space.w_ValueError,
+ space.wrap("buffer object does not support"
+ " slicing with a step"))
+
+
+class W_Buffer(W_Root):
+ """Implement the built-in 'buffer' type as a wrapper around
an interp-level buffer.
"""
def __init__(self, buf):
- assert isinstance(buf, buffer.Buffer)
self.buf = buf
+ def buffer_w(self, space):
+ return self.buf
+
+ @staticmethod
+ @unwrap_spec(offset=int, size=int)
+ def descr_new(space, w_subtype, w_object, offset=0, size=-1):
+ if space.isinstance_w(w_object, space.w_unicode):
+ # unicode objects support the old buffer interface
+ # but not the new buffer interface (change in python 2.7)
+ from rpython.rlib.rstruct.unichar import pack_unichar, UNICODE_SIZE
+ unistr = space.unicode_w(w_object)
+ builder = StringBuilder(len(unistr) * UNICODE_SIZE)
+ for unich in unistr:
+ pack_unichar(unich, builder)
+ from pypy.interpreter.buffer import StringBuffer
+ buf = StringBuffer(builder.build())
+ else:
+ buf = space.buffer_w(w_object)
+
+ if offset == 0 and size == -1:
+ return W_Buffer(buf)
+ # handle buffer slices
+ if offset < 0:
+ raise OperationError(space.w_ValueError,
+ space.wrap("offset must be zero or positive"))
+ if size < -1:
+ raise OperationError(space.w_ValueError,
+ space.wrap("size must be zero or positive"))
+ if isinstance(buf, buffer.RWBuffer):
+ buf = buffer.RWSubBuffer(buf, offset, size)
+ else:
+ buf = buffer.SubBuffer(buf, offset, size)
+ return W_Buffer(buf)
+
+ def descr_len(self, space):
+ return space.wrap(self.buf.getlength())
+
+ def descr_getitem(self, space, w_index):
+ start, stop, step, size = space.decode_index4(w_index, self.buf.getlength())
+ if step == 0: # index only
+ return space.wrapbytes(self.buf.getitem(start))
+ res = self.buf.getslice(start, stop, step, size)
+ return space.wrapbytes(res)
+
+ @unwrap_spec(newstring='bufferstr')
+ def descr_setitem(self, space, w_index, newstring):
+ if not isinstance(self.buf, buffer.RWBuffer):
+ raise OperationError(space.w_TypeError,
+ space.wrap("buffer is read-only"))
+ _buffer_setitem(space, self.buf, w_index, newstring)
+
+ def descr_str(self, space):
+ return space.wrap(self.buf.as_str())
+
+ @unwrap_spec(other='bufferstr')
+ def descr_add(self, space, other):
+ return space.wrapbytes(self.buf.as_str() + other)
+
+ def _make_descr__cmp(name):
+ def descr__cmp(self, space, w_other):
+ if not isinstance(w_other, W_Buffer):
+ return space.w_NotImplemented
+ # xxx not the most efficient implementation
+ str1 = self.buf.as_str()
+ str2 = w_other.buf.as_str()
+ return space.wrap(getattr(operator, name)(str1, str2))
+ descr__cmp.func_name = name
+ return descr__cmp
+
+ descr_eq = _make_descr__cmp('eq')
+ descr_ne = _make_descr__cmp('ne')
+ descr_lt = _make_descr__cmp('lt')
+ descr_le = _make_descr__cmp('le')
+ descr_gt = _make_descr__cmp('gt')
+ descr_ge = _make_descr__cmp('ge')
+
+ def descr_hash(self, space):
+ return space.wrap(compute_hash(self.buf.as_str()))
+
+ def descr_mul(self, space, w_times):
+ # xxx not the most efficient implementation
+ w_string = space.wrapbytes(self.buf.as_str())
+ # use the __mul__ method instead of space.mul() so that we
+ # return NotImplemented instead of raising a TypeError
+ return space.call_method(w_string, '__mul__', w_times)
+
+ def descr_repr(self, space):
+ if isinstance(self.buf, buffer.RWBuffer):
+ info = 'read-write buffer'
+ else:
+ info = 'read-only buffer'
+ addrstring = self.getaddrstring(space)
+
+ return space.wrap("<%s for 0x%s, size %d>" %
+ (info, addrstring, self.buf.getlength()))
+
+W_Buffer.typedef = TypeDef(
+ "buffer",
+ __doc__ = """\
+buffer(object [, offset[, size]])
+
+Create a new buffer object which references the given object.
+The buffer will reference a slice of the target object from the
+start of the object (or at the specified offset). The slice will
+extend to the end of the target object (or with the specified size).
+""",
+ __new__ = interp2app(W_Buffer.descr_new),
+ __len__ = interp2app(W_Buffer.descr_len),
+ __getitem__ = interp2app(W_Buffer.descr_getitem),
+ __setitem__ = interp2app(W_Buffer.descr_setitem),
+ __str__ = interp2app(W_Buffer.descr_str),
+ __add__ = interp2app(W_Buffer.descr_add),
+ __eq__ = interp2app(W_Buffer.descr_eq),
+ __ne__ = interp2app(W_Buffer.descr_ne),
+ __lt__ = interp2app(W_Buffer.descr_lt),
+ __le__ = interp2app(W_Buffer.descr_le),
+ __gt__ = interp2app(W_Buffer.descr_gt),
+ __ge__ = interp2app(W_Buffer.descr_ge),
+ __hash__ = interp2app(W_Buffer.descr_hash),
+ __mul__ = interp2app(W_Buffer.descr_mul),
+ __rmul__ = interp2app(W_Buffer.descr_mul),
+ __repr__ = interp2app(W_Buffer.descr_repr),
+)
+W_Buffer.typedef.acceptable_as_base_class = False
+
+
+class W_MemoryView(W_Root):
+ """Implement the built-in 'memoryview' type as a wrapper around
+ an interp-level buffer.
+ """
+
+ def __init__(self, buf):
+ self.buf = buf
+
+ def buffer_w(self, space):
+ """Note that memoryview() is very inconsistent in CPython: it
+ does not support the buffer interface but does support the new
+ buffer interface: as a result, it is possible to pass memoryview
+ to e.g. socket.send() but not to file.write(). For simplicity
+ and consistency, in PyPy memoryview DOES support buffer(), which
+ means that it is accepted in more places than CPython.
+ """
+ self._check_released(space)
+ return self.buf
+
+ @staticmethod
+ def descr_new(space, w_subtype, w_object):
+ w_memoryview = W_MemoryView(space.buffer_w(w_object))
+ return w_memoryview
+
def _make_descr__cmp(name):
def descr__cmp(self, space, w_other):
if self.buf is None:
@@ -28,14 +200,14 @@
return space.wrap(getattr(operator, name)(str1, str2))
try:
- w_buf = space.buffer(w_other)
+ buf = space.buffer_w(w_other)
except OperationError, e:
if not e.match(space, space.w_TypeError):
raise
return space.w_NotImplemented
else:
str1 = self.as_str()
- str2 = space.buffer_w(w_buf).as_str()
+ str2 = buf.as_str()
return space.wrap(getattr(operator, name)(str1, str2))
descr__cmp.func_name = name
return descr__cmp
@@ -62,18 +234,6 @@
buf = buffer.SubBuffer(buf, start, size)
return W_MemoryView(buf)
- def descr_buffer(self, space):
- """
- Note that memoryview() is very inconsistent in CPython: it does not
- support the buffer interface but does support the new buffer
- interface: as a result, it is possible to pass memoryview to
- e.g. socket.send() but not to file.write(). For simplicity and
- consistency, in PyPy memoryview DOES support buffer(), which means
- that it is accepted in more places than CPython.
- """
- self._check_released(space)
- return space.wrap(self.buf)
-
def descr_tobytes(self, space):
self._check_released(space)
return space.wrapbytes(self.as_str())
@@ -102,16 +262,14 @@
@unwrap_spec(newstring='bufferstr')
def descr_setitem(self, space, w_index, newstring):
self._check_released(space)
- buf = self.buf
- if isinstance(buf, buffer.RWBuffer):
- buf.descr_setitem(space, w_index, newstring)
- else:
+ if not isinstance(self.buf, buffer.RWBuffer):
raise OperationError(space.w_TypeError,
space.wrap("cannot modify read-only memory"))
+ _buffer_setitem(space, self.buf, w_index, newstring)
def descr_len(self, space):
self._check_released(space)
- return self.buf.descr_len(space)
+ return space.wrap(self.buf.getlength())
def w_get_format(self, space):
self._check_released(space)
@@ -165,17 +323,12 @@
return space.w_None
-def descr_new(space, w_subtype, w_object):
- memoryview = W_MemoryView(space.buffer(w_object))
- return space.wrap(memoryview)
-
W_MemoryView.typedef = TypeDef(
"memoryview",
__doc__ = """\
Create a new memoryview object which references the given object.
""",
- __new__ = interp2app(descr_new),
- __buffer__ = interp2app(W_MemoryView.descr_buffer),
+ __new__ = interp2app(W_MemoryView.descr_new),
__eq__ = interp2app(W_MemoryView.descr_eq),
__getitem__ = interp2app(W_MemoryView.descr_getitem),
__len__ = interp2app(W_MemoryView.descr_len),
diff --git a/pypy/module/__pypy__/bytebuffer.py b/pypy/module/__pypy__/bytebuffer.py
--- a/pypy/module/__pypy__/bytebuffer.py
+++ b/pypy/module/__pypy__/bytebuffer.py
@@ -4,6 +4,7 @@
from pypy.interpreter.buffer import RWBuffer
from pypy.interpreter.gateway import unwrap_spec
+from pypy.module.__builtin__.interp_memoryview import W_Buffer
class ByteBuffer(RWBuffer):
@@ -23,4 +24,4 @@
@unwrap_spec(length=int)
def bytebuffer(space, length):
- return space.wrap(ByteBuffer(length))
+ return W_Buffer(ByteBuffer(length))
diff --git a/pypy/module/_cffi_backend/cbuffer.py b/pypy/module/_cffi_backend/cbuffer.py
--- a/pypy/module/_cffi_backend/cbuffer.py
+++ b/pypy/module/_cffi_backend/cbuffer.py
@@ -4,6 +4,7 @@
from pypy.interpreter.gateway import unwrap_spec, interp2app
from pypy.interpreter.typedef import TypeDef, make_weakref_descr
from pypy.module._cffi_backend import cdataobj, ctypeptr, ctypearray
+from pypy.module.__builtin__.interp_memoryview import W_Buffer
from rpython.rtyper.annlowlevel import llstr
from rpython.rtyper.lltypesystem import rffi
@@ -39,35 +40,19 @@
copy_string_to_raw(llstr(string), raw_cdata, 0, len(string))
-class MiniBuffer(W_Root):
- # a different subclass of W_Root for the MiniBuffer, because we
- # want a slightly different (simplified) API at the level of Python.
+# Override the typedef to narrow down the interface that's exposed to app-level
+class MiniBuffer(W_Buffer):
def __init__(self, buffer, keepalive=None):
- self.buffer = buffer
+ W_Buffer.__init__(self, buffer)
self.keepalive = keepalive
- def descr_len(self, space):
- return self.buffer.descr_len(space)
-
- def descr_getitem(self, space, w_index):
- return self.buffer.descr_getitem(space, w_index)
-
- @unwrap_spec(newstring='bufferstr')
- def descr_setitem(self, space, w_index, newstring):
- self.buffer.descr_setitem(space, w_index, newstring)
-
- def descr__buffer__(self, space):
- return self.buffer.descr__buffer__(space)
-
-
MiniBuffer.typedef = TypeDef(
"buffer",
__module__ = "_cffi_backend",
__len__ = interp2app(MiniBuffer.descr_len),
__getitem__ = interp2app(MiniBuffer.descr_getitem),
__setitem__ = interp2app(MiniBuffer.descr_setitem),
- __buffer__ = interp2app(MiniBuffer.descr__buffer__),
__weakref__ = make_weakref_descr(MiniBuffer),
)
MiniBuffer.typedef.acceptable_as_base_class = False
diff --git a/pypy/module/_io/interp_bufferedio.py b/pypy/module/_io/interp_bufferedio.py
--- a/pypy/module/_io/interp_bufferedio.py
+++ b/pypy/module/_io/interp_bufferedio.py
@@ -5,6 +5,7 @@
TypeDef, GetSetProperty, generic_new_descr, interp_attrproperty_w)
from pypy.interpreter.gateway import interp2app, unwrap_spec, WrappedDefault
from pypy.interpreter.buffer import RWBuffer
+from pypy.module.__builtin__.interp_memoryview import W_Buffer
from rpython.rlib.rstring import StringBuilder
from rpython.rlib.rarithmetic import r_longlong, intmask
from rpython.rlib import rposix
@@ -521,7 +522,7 @@
def _raw_read(self, space, buffer, start, length):
length = intmask(length)
- w_buf = space.wrap(RawBuffer(buffer, start, length))
+ w_buf = W_Buffer(RawBuffer(buffer, start, length))
while True:
try:
w_size = space.call_method(self.w_raw, "readinto", w_buf)
diff --git a/pypy/module/_multiprocessing/test/test_connection.py b/pypy/module/_multiprocessing/test/test_connection.py
--- a/pypy/module/_multiprocessing/test/test_connection.py
+++ b/pypy/module/_multiprocessing/test/test_connection.py
@@ -9,8 +9,12 @@
class AppTestBufferTooShort:
spaceconfig = {'usemodules': ['_multiprocessing', 'thread', 'signal',
- 'select', 'fcntl', 'struct',
- 'binascii']}
+ 'select', 'struct', 'binascii']}
+ if sys.platform == 'win32':
+ spaceconfig['usemodules'].append('_rawffi')
+ else:
+ spaceconfig['usemodules'].append('fcntl')
+
def setup_class(cls):
if cls.runappdirect:
@@ -75,6 +79,8 @@
'itertools', '_socket', 'binascii',
]
}
+ if sys.platform == 'win32':
+ spaceconfig['usemodules'].append('_rawffi')
def setup_class(cls):
if sys.platform != "win32":
@@ -86,7 +92,6 @@
# just for multiprocessing to import correctly on Windows
w_modules = space.sys.get('modules')
space.setitem(w_modules, space.wrap('msvcrt'), space.sys)
- space.setitem(w_modules, space.wrap('_subprocess'), space.sys)
else:
import _multiprocessing
@@ -100,9 +105,12 @@
spaceconfig = {
"usemodules": [
'_multiprocessing', 'thread', 'signal', 'struct', 'array',
- '_socket', 'binascii', 'select', 'fcntl',
- ]
+ '_socket', 'binascii', 'select' ]
}
+ if sys.platform == 'win32':
+ spaceconfig['usemodules'].append('_rawffi')
+ else:
+ spaceconfig['usemodules'].append('fcntl')
def setup_class(cls):
cls.w_connections = cls.space.newlist([])
diff --git a/pypy/module/_rawffi/array.py b/pypy/module/_rawffi/array.py
--- a/pypy/module/_rawffi/array.py
+++ b/pypy/module/_rawffi/array.py
@@ -207,7 +207,6 @@
__setitem__ = interp2app(W_ArrayInstance.descr_setitem),
__getitem__ = interp2app(W_ArrayInstance.descr_getitem),
__len__ = interp2app(W_ArrayInstance.getlength),
- __buffer__ = interp2app(W_ArrayInstance.descr_buffer),
buffer = GetSetProperty(W_ArrayInstance.getbuffer),
shape = interp_attrproperty('shape', W_ArrayInstance),
free = interp2app(W_ArrayInstance.free),
@@ -232,7 +231,6 @@
__setitem__ = interp2app(W_ArrayInstance.descr_setitem),
__getitem__ = interp2app(W_ArrayInstance.descr_getitem),
__len__ = interp2app(W_ArrayInstance.getlength),
- __buffer__ = interp2app(W_ArrayInstance.descr_buffer),
buffer = GetSetProperty(W_ArrayInstance.getbuffer),
shape = interp_attrproperty('shape', W_ArrayInstance),
byptr = interp2app(W_ArrayInstance.byptr),
diff --git a/pypy/module/_rawffi/interp_rawffi.py b/pypy/module/_rawffi/interp_rawffi.py
--- a/pypy/module/_rawffi/interp_rawffi.py
+++ b/pypy/module/_rawffi/interp_rawffi.py
@@ -359,9 +359,9 @@
lltype.free(self.ll_buffer, flavor='raw')
self.ll_buffer = lltype.nullptr(rffi.VOIDP.TO)
- def descr_buffer(self, space):
+ def buffer_w(self, space):
from pypy.module._rawffi.buffer import RawFFIBuffer
- return space.wrap(RawFFIBuffer(self))
+ return RawFFIBuffer(self)
def getrawsize(self):
raise NotImplementedError("abstract base class")
diff --git a/pypy/module/_rawffi/structure.py b/pypy/module/_rawffi/structure.py
--- a/pypy/module/_rawffi/structure.py
+++ b/pypy/module/_rawffi/structure.py
@@ -364,7 +364,6 @@
__repr__ = interp2app(W_StructureInstance.descr_repr),
__getattr__ = interp2app(W_StructureInstance.getattr),
__setattr__ = interp2app(W_StructureInstance.setattr),
- __buffer__ = interp2app(W_StructureInstance.descr_buffer),
buffer = GetSetProperty(W_StructureInstance.getbuffer),
free = interp2app(W_StructureInstance.free),
shape = interp_attrproperty('shape', W_StructureInstance),
@@ -387,7 +386,6 @@
__repr__ = interp2app(W_StructureInstance.descr_repr),
__getattr__ = interp2app(W_StructureInstance.getattr),
__setattr__ = interp2app(W_StructureInstance.setattr),
- __buffer__ = interp2app(W_StructureInstance.descr_buffer),
buffer = GetSetProperty(W_StructureInstance.getbuffer),
shape = interp_attrproperty('shape', W_StructureInstance),
byptr = interp2app(W_StructureInstance.byptr),
diff --git a/pypy/module/_socket/interp_socket.py b/pypy/module/_socket/interp_socket.py
--- a/pypy/module/_socket/interp_socket.py
+++ b/pypy/module/_socket/interp_socket.py
@@ -69,10 +69,7 @@
else: flowinfo = 0
if len(pieces_w) > 3: scope_id = space.uint_w(pieces_w[3])
else: scope_id = 0
- if flowinfo < 0 or flowinfo > 0xfffff:
- raise OperationError(space.w_OverflowError, space.wrap(
- "flowinfo must be 0-1048575."))
- flowinfo = rffi.cast(lltype.Unsigned, flowinfo)
+ flowinfo = make_unsigned_flowinfo(space, flowinfo)
a = addr.lock(_c.sockaddr_in6)
rffi.setintfield(a, 'c_sin6_port', rsocket.htons(port))
rffi.setintfield(a, 'c_sin6_flowinfo', rsocket.htonl(flowinfo))
@@ -101,10 +98,7 @@
else: flowinfo = 0
if len(pieces_w) > 3: scope_id = space.uint_w(pieces_w[3])
else: scope_id = 0
- if flowinfo < 0 or flowinfo > 0xfffff:
- raise OperationError(space.w_OverflowError, space.wrap(
- "flowinfo must be 0-1048575."))
- flowinfo = rffi.cast(lltype.Unsigned, flowinfo)
+ flowinfo = make_unsigned_flowinfo(space, flowinfo)
return rsocket.INET6Address(host, port, flowinfo, scope_id)
if rsocket.HAS_AF_UNIX and family == rsocket.AF_UNIX:
return rsocket.UNIXAddress(space.str_w(w_address))
@@ -116,10 +110,16 @@
# XXX Hack to seperate rpython and pypy
def make_ushort_port(space, port):
if port < 0 or port > 0xffff:
- raise OperationError(space.w_ValueError, space.wrap(
+ raise OperationError(space.w_OverflowError, space.wrap(
"port must be 0-65535."))
return rffi.cast(rffi.USHORT, port)
+def make_unsigned_flowinfo(space, flowinfo):
+ if flowinfo < 0 or flowinfo > 0xfffff:
+ raise OperationError(space.w_OverflowError, space.wrap(
+ "flowinfo must be 0-1048575."))
+ return rffi.cast(lltype.Unsigned, flowinfo)
+
# XXX Hack to seperate rpython and pypy
def ipaddr_from_object(space, w_sockaddr):
host = space.str_w(space.getitem(w_sockaddr, space.wrap(0)))
diff --git a/pypy/module/_socket/test/test_sock_app.py b/pypy/module/_socket/test/test_sock_app.py
--- a/pypy/module/_socket/test/test_sock_app.py
+++ b/pypy/module/_socket/test/test_sock_app.py
@@ -391,7 +391,7 @@
name = s.getpeername() # Will raise socket.error if not connected
assert name[1] == 80
s.close()
-
+
def test_socket_connect_ex(self):
import _socket
s = _socket.socket(_socket.AF_INET, _socket.SOCK_STREAM, 0)
@@ -417,8 +417,13 @@
def test_bigport(self):
import _socket
s = _socket.socket()
- raises(ValueError, s.connect, ("localhost", 1000000))
- raises(ValueError, s.connect, ("localhost", -1))
+ exc = raises(OverflowError, s.connect, ("localhost", -1))
+ assert "port must be 0-65535." in str(exc.value)
+ exc = raises(OverflowError, s.connect, ("localhost", 1000000))
+ assert "port must be 0-65535." in str(exc.value)
+ s = _socket.socket(_socket.AF_INET6)
+ exc = raises(OverflowError, s.connect, ("::1", 1234, 1048576))
+ assert "flowinfo must be 0-1048575." in str(exc.value)
def test_NtoH(self):
import sys
@@ -466,6 +471,13 @@
import socket
s = socket.socket()
+ def test_subclass(self):
+ from _socket import socket
+ class MySock(socket):
+ blah = 123
+ s = MySock()
+ assert s.blah == 123
+
def test_getsetsockopt(self):
import _socket as socket
import struct
@@ -587,11 +599,11 @@
class AppTestSocketTCP:
+ HOST = 'localhost'
+
def setup_class(cls):
cls.space = space
- HOST = 'localhost'
-
def setup_method(self, method):
w_HOST = space.wrap(self.HOST)
self.w_serv = space.appexec([w_HOST],
@@ -602,6 +614,7 @@
serv.listen(1)
return serv
''')
+
def teardown_method(self, method):
if hasattr(self, 'w_serv'):
space.appexec([self.w_serv], '(serv): serv.close()')
@@ -622,7 +635,7 @@
raises(error, raise_error)
def test_recv_send_timeout(self):
- from _socket import socket, timeout
+ from _socket import socket, timeout, SOL_SOCKET, SO_RCVBUF, SO_SNDBUF
cli = socket()
cli.connect(self.serv.getsockname())
fileno, addr = self.serv._accept()
@@ -643,6 +656,9 @@
assert count is None
buf = t.recv(1)
assert buf == b'?'
+ # speed up filling the buffers
+ t.setsockopt(SOL_SOCKET, SO_RCVBUF, 4096)
+ cli.setsockopt(SOL_SOCKET, SO_SNDBUF, 4096)
# test send() timeout
count = 0
try:
@@ -671,7 +687,7 @@
conn = socket.socket(fileno=fileno)
buf = memoryview(MSG)
conn.send(buf)
- buf = array.array('b', b' '*1024)
+ buf = array.array('b', b' ' * 1024)
nbytes = cli.recv_into(buf)
assert nbytes == len(MSG)
msg = buf.tobytes()[:len(MSG)]
@@ -687,7 +703,7 @@
conn = socket.socket(fileno=fileno)
buf = memoryview(MSG)
conn.send(buf)
- buf = array.array('b', b' '*1024)
+ buf = array.array('b', b' ' * 1024)
nbytes, addr = cli.recvfrom_into(buf)
assert nbytes == len(MSG)
msg = buf.tobytes()[:len(MSG)]
@@ -698,6 +714,7 @@
cli = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
assert cli.family == socket.AF_INET
+
class AppTestErrno:
def setup_class(cls):
cls.space = space
diff --git a/pypy/module/_ssl/test/test_ssl.py b/pypy/module/_ssl/test/test_ssl.py
--- a/pypy/module/_ssl/test/test_ssl.py
+++ b/pypy/module/_ssl/test/test_ssl.py
@@ -1,7 +1,7 @@
from rpython.tool.udir import udir
class AppTestSSL:
- spaceconfig = dict(usemodules=('_ssl', '_socket', 'binascii'))
+ spaceconfig = dict(usemodules=('_ssl', '_socket', 'binascii', 'thread'))
def setup_class(cls):
import os
diff --git a/pypy/module/_ssl/thread_lock.py b/pypy/module/_ssl/thread_lock.py
--- a/pypy/module/_ssl/thread_lock.py
+++ b/pypy/module/_ssl/thread_lock.py
@@ -1,4 +1,5 @@
-from rpython.rlib.ropenssl import *
+from rpython.rlib import rthread
+from rpython.rlib.ropenssl import libraries
from rpython.rtyper.lltypesystem import lltype, rffi
from rpython.translator.tool.cbuild import ExternalCompilationInfo
@@ -22,7 +23,6 @@
# without caring about the GIL.
separate_module_source = """
-
#include <openssl/crypto.h>
static unsigned int _ssl_locks_count = 0;
@@ -62,13 +62,12 @@
}
"""
-from rpython.rlib import rthread
-
eci = rthread.eci.merge(ExternalCompilationInfo(
separate_module_sources=[separate_module_source],
post_include_bits=[
"int _PyPy_SSL_SetupThreads(void);"],
export_symbols=['_PyPy_SSL_SetupThreads'],
+ libraries = libraries,
))
_PyPy_SSL_SetupThreads = rffi.llexternal('_PyPy_SSL_SetupThreads',
diff --git a/pypy/module/array/interp_array.py b/pypy/module/array/interp_array.py
--- a/pypy/module/array/interp_array.py
+++ b/pypy/module/array/interp_array.py
@@ -135,6 +135,9 @@
self.len = 0
self.allocated = 0
+ def buffer_w(self, space):
+ return ArrayBuffer(self)
+
def descr_append(self, space, w_x):
""" append(x)
@@ -505,9 +508,6 @@
def descr_iter(self, space):
return space.wrap(ArrayIterator(self))
- def descr_buffer(self, space):
- return space.wrap(ArrayBuffer(self))
-
def descr_repr(self, space):
if self.len == 0:
return space.wrap("array('%s')" % self.typecode)
@@ -544,7 +544,6 @@
__radd__ = interp2app(W_ArrayBase.descr_radd),
__rmul__ = interp2app(W_ArrayBase.descr_rmul),
- __buffer__ = interp2app(W_ArrayBase.descr_buffer),
__iter__ = interp2app(W_ArrayBase.descr_iter),
__repr__ = interp2app(W_ArrayBase.descr_repr),
diff --git a/pypy/module/cpyext/include/numpy/arrayobject.h b/pypy/module/cpyext/include/numpy/arrayobject.h
--- a/pypy/module/cpyext/include/numpy/arrayobject.h
+++ b/pypy/module/cpyext/include/numpy/arrayobject.h
@@ -20,7 +20,7 @@
#define PyArrayObject PyObject
#define PyArray_Descr PyObject
-extern PyTypeObject PyArray_Type;
+PyAPI_DATA(PyTypeObject) PyArray_Type;
typedef unsigned char npy_bool;
typedef unsigned char npy_uint8;
diff --git a/pypy/module/cpyext/memoryobject.py b/pypy/module/cpyext/memoryobject.py
--- a/pypy/module/cpyext/memoryobject.py
+++ b/pypy/module/cpyext/memoryobject.py
@@ -20,4 +20,4 @@
raise OperationError(space.w_ValueError, space.wrap(msg))
w_obj = from_ref(space, view.c_obj)
buf = CBuffer(space, view.c_buf, view.c_len, w_obj)
- return space.wrap(W_MemoryView(space.wrap(buf)))
+ return space.wrap(W_MemoryView(buf))
diff --git a/pypy/module/cpyext/pystate.py b/pypy/module/cpyext/pystate.py
--- a/pypy/module/cpyext/pystate.py
+++ b/pypy/module/cpyext/pystate.py
@@ -217,7 +217,7 @@
if rffi.aroundstate.after:
# After external call is before entering Python
rffi.aroundstate.after()
- return 0
+ return lltype.nullptr(PyGILState_STATE.TO)
@cpython_api([PyGILState_STATE], lltype.Void)
def PyGILState_Release(space, state):
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
@@ -14,8 +14,9 @@
from pypy.module.cpyext.pyobject import from_ref
from pypy.module.cpyext.pyerrors import PyErr_Occurred
from pypy.module.cpyext.state import State
+from pypy.module.__builtin__.interp_memoryview import W_Buffer
from pypy.interpreter.error import OperationError, oefmt
-from pypy.interpreter.buffer import Buffer as W_Buffer
+from pypy.interpreter.buffer import Buffer
from pypy.interpreter.argument import Arguments
from rpython.rlib.unroll import unrolling_iterable
from rpython.rlib.objectmodel import specialize
@@ -228,7 +229,7 @@
check_num_args(space, w_args, 0)
return space.wrap(generic_cpy_call(space, func_target, w_self))
-class CPyBuffer(W_Buffer):
+class CPyBuffer(Buffer):
# Similar to Py_buffer
def __init__(self, ptr, size, w_obj):
@@ -249,7 +250,7 @@
ret = generic_cpy_call(space, func_target, w_self, view, flags)
if rffi.cast(lltype.Signed, ret) == -1:
space.fromcache(State).check_and_raise_exception(always=True)
- return space.wrap(CPyBuffer(view.c_buf, view.c_len, w_self))
+ return W_Buffer(CPyBuffer(view.c_buf, view.c_len, w_self))
def get_richcmp_func(OP_CONST):
def inner(space, w_self, w_args, func):
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
@@ -64,6 +64,10 @@
kwds["libraries"] = [api_library]
# '%s' undefined; assuming extern returning int
kwds["compile_extra"] = ["/we4013"]
+ # prevent linking with PythonXX.lib
+ w_maj, w_min = space.fixedview(space.sys.get('version_info'), 5)[:2]
+ kwds["link_extra"] = ["/NODEFAULTLIB:Python%d%d.lib" %
+ (space.int_w(w_maj), space.int_w(w_min))]
elif sys.platform == 'darwin':
kwds["link_files"] = [str(api_library + '.dylib')]
else:
@@ -181,6 +185,19 @@
state = cls.space.fromcache(RefcountState)
state.non_heaptypes_w[:] = []
+ def setup_method(self, meth):
+ freeze_refcnts(self)
+
+ def teardown_method(self, meth):
+ self.cleanup_references(self.space)
+ # XXX: like AppTestCpythonExtensionBase.teardown_method:
+ # find out how to disable check_and_print_leaks() if the
+ # test failed
+ assert not self.check_and_print_leaks(), (
+ "Test leaks or loses object(s). You should also check if "
+ "the test actually passed in the first place; if it failed "
+ "it is likely to reach this place.")
+
def test_load_error(self):
import cpyext
raises(ImportError, cpyext.load_module, "missing.file", "foo")
@@ -368,13 +385,12 @@
for name in self.imported_module_names:
self.unimport_module(name)
self.cleanup_references(self.space)
- if self.check_and_print_leaks():
- assert False, (
- "Test leaks or loses object(s). You should also check if "
- "the test actually passed in the first place; if it failed "
- "it is likely to reach this place.")
- # XXX find out how to disable check_and_print_leaks() if the
- # XXX test failed...
+ # XXX: find out how to disable check_and_print_leaks() if the
+ # test failed...
+ assert not self.check_and_print_leaks(), (
+ "Test leaks or loses object(s). You should also check if "
+ "the test actually passed in the first place; if it failed "
+ "it is likely to reach this place.")
class AppTestCpythonExtension(AppTestCpythonExtensionBase):
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
@@ -1,38 +1,36 @@
import os
-import sys
+from rpython.rlib import jit
+from rpython.rlib.objectmodel import specialize
+from rpython.rlib.rstring import rsplit
+from rpython.rtyper.annlowlevel import llhelper
from rpython.rtyper.lltypesystem import rffi, lltype
-from rpython.rtyper.annlowlevel import llhelper
+
from pypy.interpreter.baseobjspace import W_Root, DescrMismatch
-from pypy.objspace.std.typeobject import W_TypeObject, find_best_base
+from pypy.interpreter.error import OperationError
from pypy.interpreter.typedef import GetSetProperty
+from pypy.module.__builtin__.abstractinst import abstract_issubclass_w
+from pypy.module.cpyext import structmemberdefs
from pypy.module.cpyext.api import (
cpython_api, cpython_struct, bootstrap_function, Py_ssize_t, Py_ssize_tP,
generic_cpy_call, Py_TPFLAGS_READY, Py_TPFLAGS_READYING,
Py_TPFLAGS_HEAPTYPE, METH_VARARGS, METH_KEYWORDS, CANNOT_FAIL,
- Py_TPFLAGS_HAVE_GETCHARBUFFER,
- build_type_checkers, PyObjectFields, Py_buffer)
+ Py_TPFLAGS_HAVE_GETCHARBUFFER, build_type_checkers, Py_buffer)
+from pypy.module.cpyext.methodobject import (
+ PyDescr_NewWrapper, PyCFunction_NewEx, PyCFunction_typedef)
+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,
- track_reference, RefcountState, borrow_from)
-from pypy.interpreter.module import Module
-from pypy.module.cpyext import structmemberdefs
-from pypy.module.cpyext.modsupport import convert_method_defs
+ track_reference, RefcountState, borrow_from, Py_DecRef)
+from pypy.module.cpyext.slotdefs import (
+ slotdefs_for_tp_slots, slotdefs_for_wrappers, get_slot_tp_function)
from pypy.module.cpyext.state import State
-from pypy.module.cpyext.methodobject import (
- PyDescr_NewWrapper, PyCFunction_NewEx, PyCFunction_typedef)
-from pypy.module.cpyext.pyobject import Py_IncRef, Py_DecRef, _Py_Dealloc
from pypy.module.cpyext.structmember import PyMember_GetOne, PyMember_SetOne
from pypy.module.cpyext.typeobjectdefs import (
PyTypeObjectPtr, PyTypeObject, PyGetSetDef, PyMemberDef, newfunc,
PyNumberMethods, PyMappingMethods, PySequenceMethods, PyBufferProcs)
-from pypy.module.cpyext.slotdefs import (
- slotdefs_for_tp_slots, slotdefs_for_wrappers, get_slot_tp_function)
-from pypy.interpreter.error import OperationError
-from rpython.rlib.rstring import rsplit
-from rpython.rlib.objectmodel import specialize
-from pypy.module.__builtin__.abstractinst import abstract_issubclass_w
-from rpython.rlib import jit
+from pypy.objspace.std.typeobject import W_TypeObject, find_best_base
+
WARN_ABOUT_MISSING_SLOT_FUNCTIONS = False
@@ -421,7 +419,6 @@
def type_alloc(space, w_metatype):
- size = rffi.sizeof(PyHeapTypeObject)
metatype = rffi.cast(PyTypeObjectPtr, make_ref(space, w_metatype))
# Don't increase refcount for non-heaptypes
if metatype:
diff --git a/pypy/module/imp/importing.py b/pypy/module/imp/importing.py
--- a/pypy/module/imp/importing.py
+++ b/pypy/module/imp/importing.py
@@ -243,12 +243,10 @@
fromlist_w = None
rel_modulename = None
- if (level != 0 and
- w_globals is not None and
- space.isinstance_w(w_globals, space.w_dict)):
-
- rel_modulename, rel_level = _get_relative_name(space, modulename, level, w_globals)
-
+ if (level != 0 and w_globals is not None and
+ space.isinstance_w(w_globals, space.w_dict)):
+ rel_modulename, rel_level = _get_relative_name(space, modulename, level,
+ w_globals)
if rel_modulename:
# if no level was set, ignore import errors, and
# fall back to absolute import at the end of the
@@ -582,6 +580,7 @@
def load_module(space, w_modulename, find_info, reuse=False):
if find_info is None:
return
+
if find_info.w_loader:
return space.call_method(find_info.w_loader, "load_module", w_modulename)
@@ -607,7 +606,7 @@
try:
if find_info.modtype == PY_SOURCE:
load_source_module(
- space, w_modulename, w_mod,
+ space, w_modulename, w_mod,
find_info.filename, find_info.stream.readall(),
find_info.stream.try_to_find_file_descriptor())
return w_mod
diff --git a/pypy/module/imp/test/test_import.py b/pypy/module/imp/test/test_import.py
--- a/pypy/module/imp/test/test_import.py
+++ b/pypy/module/imp/test/test_import.py
@@ -232,7 +232,6 @@
import _warnings
def simplefilter(action, category):
_warnings.filters.insert(0, (action, None, category, None, 0))
-
simplefilter('error', ImportWarning)
try:
raises(ImportWarning, imp)
@@ -467,7 +466,7 @@
def test_future_relative_import_level_1(self):
from pkg import relative_c
assert relative_c.inpackage == 1
-
+
def test_future_relative_import_level_2(self):
from pkg.pkg1 import relative_d
assert relative_d.inpackage == 1
@@ -751,10 +750,7 @@
import imp
import pkg
import os
-
- info = ('.py', 'r', imp.PY_SOURCE)
pathname = os.path.join(os.path.dirname(pkg.__file__), 'a.py')
-
module = imp.load_module('a', open(pathname),
'invalid_path_name', ('.py', 'r', imp.PY_SOURCE))
assert module.__name__ == 'a'
@@ -1284,7 +1280,7 @@
def load_module(self, name):
sys.modules[name] = sys
return sys
-
+
def importer_for_path(path):
if path == "xxx":
return Importer()
diff --git a/pypy/module/marshal/__init__.py b/pypy/module/marshal/__init__.py
--- a/pypy/module/marshal/__init__.py
+++ b/pypy/module/marshal/__init__.py
@@ -8,7 +8,7 @@
appleveldefs = {
}
-
+
interpleveldefs = {
'dump' : 'interp_marshal.dump',
'dumps' : 'interp_marshal.dumps',
diff --git a/pypy/module/micronumpy/boxes.py b/pypy/module/micronumpy/boxes.py
--- a/pypy/module/micronumpy/boxes.py
+++ b/pypy/module/micronumpy/boxes.py
@@ -335,8 +335,8 @@
def descr_copy(self, space):
return self.convert_to(space, self.get_dtype(space))
- def descr_buffer(self, space):
- return self.descr_ravel(space).descr_get_data(space)
+ def buffer_w(self, space):
+ return self.descr_ravel(space).buffer_w(space)
def descr_byteswap(self, space):
return self.get_dtype(space).itemtype.byteswap(self)
@@ -547,7 +547,6 @@
__bool__ = interp2app(W_GenericBox.descr_nonzero),
__oct__ = interp2app(W_GenericBox.descr_oct),
__hex__ = interp2app(W_GenericBox.descr_hex),
- __buffer__ = interp2app(W_GenericBox.descr_buffer),
__add__ = interp2app(W_GenericBox.descr_add),
__sub__ = interp2app(W_GenericBox.descr_sub),
diff --git a/pypy/module/micronumpy/ndarray.py b/pypy/module/micronumpy/ndarray.py
--- a/pypy/module/micronumpy/ndarray.py
+++ b/pypy/module/micronumpy/ndarray.py
@@ -7,6 +7,7 @@
from rpython.rlib.rawstorage import RAW_STORAGE_PTR
from rpython.rtyper.lltypesystem import rffi
from rpython.tool.sourcetools import func_with_new_name
+from pypy.module.__builtin__.interp_memoryview import W_Buffer
from pypy.module.micronumpy import descriptor, ufuncs, boxes, arrayops, loop, \
support, constants as NPY
from pypy.module.micronumpy.appbridge import get_appbridge_cache
@@ -602,8 +603,11 @@
raise OperationError(space.w_NotImplementedError, space.wrap(
"ctypes not implemented yet"))
+ def buffer_w(self, space):
+ return self.implementation.get_buffer(space)
+
def descr_get_data(self, space):
- return self.implementation.get_buffer(space)
+ return W_Buffer(self.buffer_w(space))
@unwrap_spec(offset=int, axis1=int, axis2=int)
def descr_diagonal(self, space, offset=0, axis1=0, axis2=1):
@@ -1248,7 +1252,6 @@
__float__ = interp2app(W_NDimArray.descr_float),
__hex__ = interp2app(W_NDimArray.descr_hex),
__oct__ = interp2app(W_NDimArray.descr_oct),
- __buffer__ = interp2app(W_NDimArray.descr_get_data),
__index__ = interp2app(W_NDimArray.descr_index),
__pos__ = interp2app(W_NDimArray.descr_pos),
diff --git a/pypy/module/micronumpy/test/test_zjit.py b/pypy/module/micronumpy/test/test_zjit.py
--- a/pypy/module/micronumpy/test/test_zjit.py
+++ b/pypy/module/micronumpy/test/test_zjit.py
@@ -480,23 +480,19 @@
def test_flat_setitem(self):
result = self.run("flat_setitem")
assert result == 1.0
- py.test.skip("don't run for now")
self.check_trace_count(1)
- # XXX not ideal, but hey, let's ignore it for now
- self.check_simple_loop({'raw_load': 1,
- 'raw_store': 1,
- 'int_lt': 1,
- 'int_gt': 1,
- 'int_add': 4,
- 'guard_true': 2,
- 'arraylen_gc': 2,
- 'jump': 1,
- 'int_sub': 1,
- # XXX bad part
- 'int_and': 1,
- 'int_mod': 1,
- 'int_rshift': 1,
- })
+ self.check_simple_loop({
+ 'call': 2,
+ 'getfield_gc': 2,
+ 'guard_no_exception': 2,
+ 'guard_not_invalidated': 1,
+ 'guard_true': 1,
+ 'int_gt': 1,
+ 'int_sub': 1,
+ 'jump': 1,
+ 'raw_load': 1,
+ 'raw_store': 1,
+ })
def define_dot():
return """
@@ -509,6 +505,7 @@
def test_dot(self):
result = self.run("dot")
assert result == 184
+ self.check_trace_count(3)
self.check_simple_loop({'float_add': 1,
'float_mul': 1,
'guard_not_invalidated': 1,
@@ -526,7 +523,7 @@
'guard_class': 4,
'guard_false': 2,
'guard_no_exception': 3,
- 'guard_nonnull': 8,
+ 'guard_nonnull': 12,
'guard_nonnull_class': 4,
'guard_not_invalidated': 2,
'guard_true': 9,
diff --git a/pypy/module/mmap/interp_mmap.py b/pypy/module/mmap/interp_mmap.py
--- a/pypy/module/mmap/interp_mmap.py
+++ b/pypy/module/mmap/interp_mmap.py
@@ -17,6 +17,10 @@
self.space = space
self.mmap = mmap_obj
+ def buffer_w(self, space):
+ self.check_valid()
+ return MMapBuffer(self.space, self.mmap)
+
def close(self):
self.mmap.close()
@@ -202,10 +206,6 @@
self.mmap.setitem(start, value[i])
start += step
- def descr_buffer(self):
- self.check_valid()
- return self.space.wrap(MMapBuffer(self.space, self.mmap))
-
def descr_enter(self, space):
self.check_valid()
return space.wrap(self)
@@ -270,7 +270,6 @@
__len__ = interp2app(W_MMap.__len__),
__getitem__ = interp2app(W_MMap.descr_getitem),
__setitem__ = interp2app(W_MMap.descr_setitem),
- __buffer__ = interp2app(W_MMap.descr_buffer),
__enter__ = interp2app(W_MMap.descr_enter),
__exit__ = interp2app(W_MMap.descr_exit),
diff --git a/pypy/module/posix/test/test_posix2.py b/pypy/module/posix/test/test_posix2.py
--- a/pypy/module/posix/test/test_posix2.py
+++ b/pypy/module/posix/test/test_posix2.py
@@ -177,17 +177,9 @@
import sys
import errno
for fn in [self.posix.stat, self.posix.lstat]:
- try:
- fn("nonexistentdir/nonexistentfile")
- except OSError as e:
- assert e.errno == errno.ENOENT
- assert e.filename == "nonexistentdir/nonexistentfile"
- # On Windows, when the parent directory does not exist,
- # the winerror is 3 (cannot find the path specified)
- # instead of 2 (cannot find the file specified)
- if sys.platform == 'win32':
- assert isinstance(e, WindowsError)
- assert e.winerror == 3
+ exc = raises(OSError, fn, "nonexistentdir/nonexistentfile")
+ assert exc.value.errno == errno.ENOENT
+ assert exc.value.filename == "nonexistentdir/nonexistentfile"
if hasattr(__import__(os.name), "statvfs"):
def test_statvfs(self):
diff --git a/pypy/module/pwd/test/test_pwd.py b/pypy/module/pwd/test/test_pwd.py
--- a/pypy/module/pwd/test/test_pwd.py
+++ b/pypy/module/pwd/test/test_pwd.py
@@ -1,8 +1,8 @@
import os
-import py
+import pytest
if os.name != 'posix':
- py.test.skip('pwd module only available on unix')
+ pytest.skip('pwd module only available on unix')
class AppTestPwd:
spaceconfig = dict(usemodules=['pwd'])
diff --git a/pypy/module/pwd/test/test_ztranslation.py b/pypy/module/pwd/test/test_ztranslation.py
--- a/pypy/module/pwd/test/test_ztranslation.py
+++ b/pypy/module/pwd/test/test_ztranslation.py
@@ -1,5 +1,9 @@
+import os
+import pytest
from pypy.objspace.fake.checkmodule import checkmodule
+if os.name != 'posix':
+ pytest.skip('pwd module only available on unix')
def test_checkmodule():
checkmodule('pwd')
diff --git a/pypy/module/pyexpat/interp_pyexpat.py b/pypy/module/pyexpat/interp_pyexpat.py
--- a/pypy/module/pyexpat/interp_pyexpat.py
+++ b/pypy/module/pyexpat/interp_pyexpat.py
@@ -428,7 +428,7 @@
self.handlers = [None] * NB_HANDLERS
- self.buffer_w = None
+ self.buffer = None
self.buffer_size = 8192
self.buffer_used = 0
self.w_character_data_handler = None
@@ -537,7 +537,7 @@
def buffer_string(self, space, w_string, length):
ll_length = rffi.cast(lltype.Signed, length)
- if self.buffer_w is not None:
+ if self.buffer is not None:
if self.buffer_used + ll_length > self.buffer_size:
self.flush_character_buffer(space)
# handler might have changed; drop the rest on the floor
@@ -545,11 +545,11 @@
if self.w_character_data_handler is None:
return True
if ll_length <= self.buffer_size:
- self.buffer_w.append(w_string)
+ self.buffer.append(w_string)
self.buffer_used += ll_length
return True
else:
- self.buffer_w = []
+ self.buffer = []
self.buffer_used = 0
return False
@@ -680,12 +680,12 @@
return space.wrap(parser)
def flush_character_buffer(self, space):
- if not self.buffer_w:
+ if not self.buffer:
return
w_data = space.call_function(
space.getattr(space.wrap(''), space.wrap('join')),
- space.newlist(self.buffer_w))
- self.buffer_w = []
+ space.newlist(self.buffer))
+ self.buffer = []
self.buffer_used = 0
if self.w_character_data_handler:
@@ -730,14 +730,14 @@
self.buffer_size = value
def get_buffer_text(self, space):
- return space.wrap(self.buffer_w is not None)
+ return space.wrap(self.buffer is not None)
def set_buffer_text(self, space, w_value):
if space.is_true(w_value):
- self.buffer_w = []
+ self.buffer = []
self.buffer_used = 0
else:
self.flush_character_buffer(space)
- self.buffer_w = None
+ self.buffer = None
def get_intern(self, space):
if self.w_intern:
diff --git a/pypy/module/pypyjit/test_pypy_c/test_ffi.py b/pypy/module/pypyjit/test_pypy_c/test_ffi.py
--- a/pypy/module/pypyjit/test_pypy_c/test_ffi.py
+++ b/pypy/module/pypyjit/test_pypy_c/test_ffi.py
@@ -207,14 +207,13 @@
...
""")
ops = loop.ops_by_id('cfficall')
- assert 'raw_malloc' not in str(ops)
- assert 'raw_free' not in str(ops)
- assert 'getarrayitem_raw' not in log.opnames(ops)
- assert 'setarrayitem_raw' not in log.opnames(ops)
+ for name in ['raw_malloc', 'raw_free']:
+ assert name not in str(ops)
+ for name in ['raw_load', 'raw_store', 'getarrayitem_raw', 'setarrayitem_raw']:
+ assert name not in log.opnames(ops)
# so far just check that call_release_gil() is produced.
# later, also check that the arguments to call_release_gil()
# are constants
- # are constants, and that the numerous raw_mallocs are removed
def test_cffi_call_guard_not_forced_fails(self):
# this is the test_pypy_c equivalent of
@@ -341,13 +340,11 @@
guard_value(p166, ConstPtr(ptr72), descr=...)
p167 = call(ConstClass(_ll_0_alloc_with_del___), descr=<Callr . EF=4>)
guard_no_exception(descr=...)
- i168 = call(ConstClass(_ll_1_raw_malloc_varsize__Signed), 6, descr=<Calli . i EF=4>)
- setfield_gc(p167, 0, descr=<FieldU pypy.module._cffi_backend.cdataobj.W_CData.inst__cdata .>)
- setfield_gc(p167, ConstPtr(ptr86), descr=<FieldP pypy.module._cffi_backend.cdataobj.W_CData.inst__lifeline_ .+>)
- guard_no_exception(descr=...)
+ i168 = call(ConstClass(_ll_1_raw_malloc_varsize__Signed), 6, descr=<Calli . i EF=4 OS=110>)
i169 = int_add(i168, i97)
i170 = int_sub(i160, i106)
setfield_gc(p167, i168, descr=<FieldU pypy.module._cffi_backend.cdataobj.W_CData.inst__cdata .>)
+ setfield_gc(p167, ConstPtr(null), descr=<FieldP pypy.module._cffi_backend.cdataobj.W_CData.inst__lifeline_ .+>)
setfield_gc(p167, ConstPtr(ptr89), descr=<FieldP pypy.module._cffi_backend.cdataobj.W_CData.inst_ctype .+>)
i171 = uint_gt(i170, i108)
guard_false(i171, descr=...)
diff --git a/pypy/objspace/fake/objspace.py b/pypy/objspace/fake/objspace.py
--- a/pypy/objspace/fake/objspace.py
+++ b/pypy/objspace/fake/objspace.py
@@ -302,6 +302,11 @@
ec._py_repr = None
return ec
+ def buffer_w(self, w_obj):
+ from pypy.interpreter.buffer import Buffer
+ is_root(w_obj)
+ return Buffer()
+
def unicode_from_object(self, w_obj):
return w_some_obj()
diff --git a/pypy/objspace/std/bytearrayobject.py b/pypy/objspace/std/bytearrayobject.py
--- a/pypy/objspace/std/bytearrayobject.py
+++ b/pypy/objspace/std/bytearrayobject.py
@@ -28,6 +28,9 @@
"""representation for debugging purposes"""
return "%s(%s)" % (w_self.__class__.__name__, ''.join(w_self.data))
+ def buffer_w(w_self, space):
+ return BytearrayBuffer(w_self.data)
+
def _new(self, value):
return W_BytearrayObject(_make_data(value))
@@ -240,9 +243,6 @@
raise
return space.newbool(res)
- def descr_buffer(self, space):
- return BytearrayBuffer(self.data)
-
def descr_inplace_add(self, space, w_other):
if isinstance(w_other, W_BytearrayObject):
self.data += w_other.data
@@ -941,7 +941,6 @@
__init__ = interp2app(W_BytearrayObject.descr_init,
doc=BytearrayDocstrings.__init__.__doc__),
- __buffer__ = interp2app(W_BytearrayObject.descr_buffer),
__iadd__ = interp2app(W_BytearrayObject.descr_inplace_add,
doc=BytearrayDocstrings.__iadd__.__doc__),
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
@@ -379,9 +379,6 @@
of the specified width. The string S is never truncated.
"""
- def descr_buffer(self, space):
- pass
-
class W_BytesObject(W_AbstractBytesObject):
import_from_mixin(StringMethods)
@@ -401,6 +398,9 @@
def bytes_w(w_self, space):
return w_self._value
+ def buffer_w(w_self, space):
+ return StringBuffer(w_self._value)
+
def listview_bytes(self):
return _create_list_from_bytes(self._value)
@@ -521,9 +521,6 @@
x = compute_hash(self._value)
return space.wrap(x)
- def descr_buffer(self, space):
- return space.wrap(StringBuffer(self._value))
-
def descr_eq(self, space, w_other):
if space.config.objspace.std.withstrbuf:
from pypy.objspace.std.strbufobject import W_StringBufferObject
@@ -837,7 +834,6 @@
upper = interpindirect2app(W_AbstractBytesObject.descr_upper),
zfill = interpindirect2app(W_AbstractBytesObject.descr_zfill),
- __buffer__ = interpindirect2app(W_AbstractBytesObject.descr_buffer),
__getnewargs__ = interpindirect2app(
W_AbstractBytesObject.descr_getnewargs),
diff --git a/pypy/objspace/std/intobject.py b/pypy/objspace/std/intobject.py
--- a/pypy/objspace/std/intobject.py
+++ b/pypy/objspace/std/intobject.py
@@ -889,7 +889,7 @@
else:
# If object supports the buffer interface
try:
- w_buffer = space.buffer(w_value)
+ buf = space.buffer_w(w_value)
except OperationError as e:
if not e.match(space, space.w_TypeError):
raise
@@ -897,7 +897,6 @@
"int() argument must be a string or a number, "
"not '%T'", w_value)
else:
- buf = space.interp_w(Buffer, w_buffer)
return _string_to_int_or_long(space, w_inttype, w_value,
buf.as_str())
else:
diff --git a/pypy/objspace/std/model.py b/pypy/objspace/std/model.py
--- a/pypy/objspace/std/model.py
+++ b/pypy/objspace/std/model.py
@@ -61,6 +61,7 @@
from pypy.objspace.std import unicodeobject
from pypy.objspace.std import dictproxyobject
from pypy.objspace.std import proxyobject
+ from pypy.module.__builtin__.interp_memoryview import W_Buffer
import pypy.objspace.std.default # register a few catch-all multimethods
import pypy.objspace.std.marshal_impl # install marshal multimethods
@@ -79,6 +80,7 @@
self.pythontypes.append(intobject.W_IntObject.typedef)
self.pythontypes.append(boolobject.W_BoolObject.typedef)
self.pythontypes.append(longobject.W_LongObject.typedef)
+ self.pythontypes.append(W_Buffer.typedef)
# the set of implementation types
self.typeorder = {
diff --git a/pypy/objspace/std/strbufobject.py b/pypy/objspace/std/strbufobject.py
--- a/pypy/objspace/std/strbufobject.py
+++ b/pypy/objspace/std/strbufobject.py
@@ -2,11 +2,12 @@
import py
-from pypy.objspace.std.bytesobject import W_AbstractBytesObject, W_BytesObject
-from pypy.objspace.std.stdtypedef import StdTypeDef
+from pypy.objspace.std.bytesobject import (W_AbstractBytesObject,
+ W_BytesObject, StringBuffer)
from pypy.interpreter.gateway import interp2app, unwrap_spec
from rpython.rlib.rstring import StringBuilder
+
class W_StringBufferObject(W_AbstractBytesObject):
w_str = None
@@ -35,6 +36,9 @@
def bytes_w(self, space):
return self.force()
+ def buffer_w(self, space):
+ return StringBuffer(self.force())
+
def descr_len(self, space):
return space.wrap(self.length)
diff --git a/rpython/annotator/test/test_annrpython.py b/rpython/annotator/test/test_annrpython.py
--- a/rpython/annotator/test/test_annrpython.py
+++ b/rpython/annotator/test/test_annrpython.py
@@ -2872,7 +2872,6 @@
py.test.raises(Exception, a.build_types, fun, [s_nonneg, int])
def test_sig_bug(self):
- py.test.skip("_annenforceargs_ does not work for default arguments")
def g(x, y=5):
return y == 5
g._annenforceargs_ = (int, int)
@@ -2880,7 +2879,8 @@
return g(x)
a = self.RPythonAnnotator()
s = a.build_types(fun, [int])
- assert not s.is_constant()
+ assert s.knowntype is bool
+ assert s.is_constant()
def test_sig_list(self):
def g(buf):
diff --git a/rpython/jit/codewriter/jtransform.py b/rpython/jit/codewriter/jtransform.py
--- a/rpython/jit/codewriter/jtransform.py
+++ b/rpython/jit/codewriter/jtransform.py
@@ -547,20 +547,18 @@
track_allocation = d.pop('track_allocation', True)
if d:
raise UnsupportedMallocFlags(d)
- TYPE = op.args[0].value
if zero:
name += '_zero'
if add_memory_pressure:
name += '_add_memory_pressure'
if not track_allocation:
name += '_no_track_allocation'
+ TYPE = op.args[0].value
op1 = self.prepare_builtin_call(op, name, args, (TYPE,), TYPE)
- if name == 'raw_malloc_varsize':
- ITEMTYPE = op.args[0].value.OF
- if ITEMTYPE == lltype.Char:
- return self._handle_oopspec_call(op1, args,
- EffectInfo.OS_RAW_MALLOC_VARSIZE_CHAR,
- EffectInfo.EF_CAN_RAISE)
+ if name.startswith('raw_malloc_varsize') and TYPE.OF == lltype.Char:
+ return self._handle_oopspec_call(op1, args,
+ EffectInfo.OS_RAW_MALLOC_VARSIZE_CHAR,
+ EffectInfo.EF_CAN_RAISE)
return self.rewrite_op_direct_call(op1)
def rewrite_op_malloc_varsize(self, op):
@@ -591,7 +589,7 @@
name += '_no_track_allocation'
op1 = self.prepare_builtin_call(op, name, [op.args[0]], (STRUCT,),
STRUCT)
- if name == 'raw_free':
+ if name.startswith('raw_free'):
return self._handle_oopspec_call(op1, [op.args[0]],
EffectInfo.OS_RAW_FREE,
EffectInfo.EF_CANNOT_RAISE)
@@ -837,8 +835,8 @@
RESULT = lltype.Ptr(STRUCT)
assert RESULT == op.result.concretetype
return self._do_builtin_call(op, 'alloc_with_del', [],
- extra = (RESULT, vtable),
- extrakey = STRUCT)
+ extra=(RESULT, vtable),
+ extrakey=STRUCT)
heaptracker.register_known_gctype(self.cpu, vtable, STRUCT)
opname = 'new_with_vtable'
else:
@@ -1237,7 +1235,7 @@
op1 = self.prepare_builtin_call(op, "llong_%s", args)
op2 = self._handle_oopspec_call(op1, args,
EffectInfo.OS_LLONG_%s,
- EffectInfo.EF_ELIDABLE_CANNOT_RAISE)
+ EffectInfo.EF_ELIDABLE_CANNOT_RAISE)
if %r == "TO_INT":
assert op2.result.concretetype == lltype.Signed
return op2
@@ -1269,7 +1267,7 @@
op1 = self.prepare_builtin_call(op, "ullong_%s", args)
op2 = self._handle_oopspec_call(op1, args,
EffectInfo.OS_LLONG_%s,
- EffectInfo.EF_ELIDABLE_CANNOT_RAISE)
+ EffectInfo.EF_ELIDABLE_CANNOT_RAISE)
return op2
''' % (_op, _oopspec.lower(), _oopspec)).compile()
diff --git a/rpython/jit/codewriter/test/test_jtransform.py b/rpython/jit/codewriter/test/test_jtransform.py
--- a/rpython/jit/codewriter/test/test_jtransform.py
+++ b/rpython/jit/codewriter/test/test_jtransform.py
@@ -60,7 +60,7 @@
class FakeResidualCallControl:
def guess_call_kind(self, op):
return 'residual'
- def getcalldescr(self, op, **kwds):
+ def getcalldescr(self, op, oopspecindex=None, extraeffect=None):
return 'calldescr'
def calldescr_canraise(self, calldescr):
return True
diff --git a/rpython/jit/metainterp/optimizeopt/heap.py b/rpython/jit/metainterp/optimizeopt/heap.py
--- a/rpython/jit/metainterp/optimizeopt/heap.py
+++ b/rpython/jit/metainterp/optimizeopt/heap.py
@@ -93,6 +93,11 @@
# possible aliasing).
self.clear()
self._lazy_setfield = None
+ if optheap.postponed_op:
+ for a in op.getarglist():
+ if a is optheap.postponed_op.result:
+ optheap.emit_postponed_op()
+ break
optheap.next_optimization.propagate_forward(op)
if not can_cache:
return
@@ -179,6 +184,9 @@
def flush(self):
self.force_all_lazy_setfields_and_arrayitems()
+ self.emit_postponed_op()
+
+ def emit_postponed_op(self):
if self.postponed_op:
postponed_op = self.postponed_op
self.postponed_op = None
@@ -227,10 +235,7 @@
def emit_operation(self, op):
self.emitting_operation(op)
- if self.postponed_op:
- postponed_op = self.postponed_op
- self.postponed_op = None
- self.next_optimization.propagate_forward(postponed_op)
+ self.emit_postponed_op()
if (op.is_comparison() or op.getopnum() == rop.CALL_MAY_FORCE
or op.is_ovf()):
self.postponed_op = op
diff --git a/rpython/jit/metainterp/optimizeopt/test/test_optimizebasic.py b/rpython/jit/metainterp/optimizeopt/test/test_optimizebasic.py
--- a/rpython/jit/metainterp/optimizeopt/test/test_optimizebasic.py
+++ b/rpython/jit/metainterp/optimizeopt/test/test_optimizebasic.py
@@ -1660,6 +1660,16 @@
"""
self.optimize_loop(ops, ops)
+ def test_setfield_int_eq_result(self):
+ # test that the setfield_gc does not end up before int_eq
+ ops = """
+ [p1, i1, i2]
+ i3 = int_eq(i1, i2)
+ setfield_gc(p1, i3, descr=valuedescr)
+ jump(p1, i1, i2)
+ """
+ self.optimize_loop(ops, ops)
+
def test_duplicate_setfield_aliasing(self):
# a case where aliasing issues (and not enough cleverness) mean
# that we fail to remove any setfield_gc
diff --git a/rpython/jit/metainterp/optimizeopt/test/test_optimizeopt.py b/rpython/jit/metainterp/optimizeopt/test/test_optimizeopt.py
--- a/rpython/jit/metainterp/optimizeopt/test/test_optimizeopt.py
+++ b/rpython/jit/metainterp/optimizeopt/test/test_optimizeopt.py
@@ -1,14 +1,15 @@
import py
from rpython.rlib.objectmodel import instantiate
+from rpython.jit.metainterp import compile, resume
+from rpython.jit.metainterp.history import AbstractDescr, ConstInt, BoxInt, TreeLoop
+from rpython.jit.metainterp.optimize import InvalidLoop
+from rpython.jit.metainterp.optimizeopt import build_opt_chain
from rpython.jit.metainterp.optimizeopt.test.test_util import (
LLtypeMixin, BaseTest, convert_old_style_to_targets)
-from rpython.jit.metainterp.optimizeopt import build_opt_chain
-from rpython.jit.metainterp.optimize import InvalidLoop
-from rpython.jit.metainterp.history import AbstractDescr, ConstInt, BoxInt
-from rpython.jit.metainterp.history import TreeLoop
-from rpython.jit.metainterp import compile, resume
+from rpython.jit.metainterp.optimizeopt.test.test_optimizebasic import \
+ FakeMetaInterpStaticData
from rpython.jit.metainterp.resoperation import rop, opname, oparity
-from rpython.jit.metainterp.optimizeopt.test.test_optimizebasic import FakeMetaInterpStaticData
+
def test_build_opt_chain():
def check(chain, expected_names):
@@ -40,7 +41,6 @@
class BaseTestWithUnroll(BaseTest):
-
enable_opts = "intbounds:rewrite:virtualize:string:earlyforce:pure:heap:unroll"
def optimize_loop(self, ops, expected, expected_preamble=None,
@@ -93,8 +93,8 @@
def raises(self, e, fn, *args):
return py.test.raises(e, fn, *args).value
+
class OptimizeOptTest(BaseTestWithUnroll):
-
def setup_method(self, meth=None):
class FailDescr(compile.ResumeGuardDescr):
oparse = None
@@ -130,7 +130,6 @@
self.namespace.pop('fdescr', None)
self.namespace.pop('fdescr2', None)
-
def test_simple(self):
ops = """
[]
@@ -606,9 +605,9 @@
i1 = ptr_eq(p0, NULL)
guard_false(i1) []
i2 = ptr_ne(NULL, p0)
- guard_true(i0) []
+ guard_true(i2) []
i3 = ptr_eq(NULL, p0)
- guard_false(i1) []
+ guard_false(i3) []
guard_nonnull(p0) []
jump(p0)
"""
@@ -623,6 +622,30 @@
"""
self.optimize_loop(ops, expected, preamble)
+ def test_nonnull_2(self):
More information about the pypy-commit
mailing list