[pypy-commit] pypy ppc-vsx-support: merge default
plan_rich
pypy.commits at gmail.com
Fri Jul 1 04:42:35 EDT 2016
Author: Richard Plangger <planrichi at gmail.com>
Branch: ppc-vsx-support
Changeset: r85482:71642c531e12
Date: 2016-07-01 10:41 +0200
http://bitbucket.org/pypy/pypy/changeset/71642c531e12/
Log: merge default
diff too long, truncating to 2000 out of 6953 lines
diff --git a/pypy/doc/config/commandline.txt b/pypy/doc/config/commandline.txt
--- a/pypy/doc/config/commandline.txt
+++ b/pypy/doc/config/commandline.txt
@@ -9,7 +9,7 @@
PyPy Python interpreter options
-------------------------------
-The following options can be used after ``translate.py
+The following options can be used after ``rpython
targetpypystandalone`` or as options to ``py.py``.
.. GENERATE: objspace
@@ -22,7 +22,7 @@
General translation options
---------------------------
-The following are options of ``translate.py``. They must be
+The following are options of ``bin/rpython``. They must be
given before the ``targetxxx`` on the command line.
* `--opt -O:`__ set the optimization level `[0, 1, size, mem, 2, 3]`
diff --git a/pypy/doc/config/index.rst b/pypy/doc/config/index.rst
--- a/pypy/doc/config/index.rst
+++ b/pypy/doc/config/index.rst
@@ -15,12 +15,12 @@
./py.py <`objspace options`_>
-and the ``translate.py`` translation entry
+and the ``rpython/bin/rpython`` translation entry
point which takes arguments of this form:
.. parsed-literal::
- ./translate.py <`translation options`_> <target>
+ ./rpython/bin/rpython <`translation options`_> <target>
For the common case of ``<target>`` being ``targetpypystandalone.py``,
you can then pass the `object space options`_ after
@@ -28,7 +28,7 @@
.. parsed-literal::
- ./translate.py <`translation options`_> targetpypystandalone.py <`objspace options`_>
+ ./rpython/bin/rpython <`translation options`_> targetpypystandalone.py <`objspace options`_>
There is an `overview`_ of all command line arguments that can be
passed in either position.
diff --git a/pypy/doc/config/opt.rst b/pypy/doc/config/opt.rst
--- a/pypy/doc/config/opt.rst
+++ b/pypy/doc/config/opt.rst
@@ -4,8 +4,8 @@
This meta-option selects a default set of optimization
settings to use during a translation. Usage::
- translate.py --opt=#
- translate.py -O#
+ bin/rpython --opt=#
+ bin/rpython -O#
where ``#`` is the desired optimization level. The valid choices are:
diff --git a/pypy/doc/config/translation.dont_write_c_files.txt b/pypy/doc/config/translation.dont_write_c_files.txt
--- a/pypy/doc/config/translation.dont_write_c_files.txt
+++ b/pypy/doc/config/translation.dont_write_c_files.txt
@@ -1,4 +1,4 @@
write the generated C files to ``/dev/null`` instead of to the disk. Useful if
-you want to use translate.py as a benchmark and don't want to access the disk.
+you want to use translation as a benchmark and don't want to access the disk.
.. _`translation documentation`: ../translation.html
diff --git a/pypy/doc/config/translation.fork_before.txt b/pypy/doc/config/translation.fork_before.txt
--- a/pypy/doc/config/translation.fork_before.txt
+++ b/pypy/doc/config/translation.fork_before.txt
@@ -1,4 +1,4 @@
This is an option mostly useful when working on the PyPy toolchain. If you use
-it, translate.py will fork before the specified phase. If the translation
+it, translation will fork before the specified phase. If the translation
crashes after that fork, you can fix the bug in the toolchain, and continue
translation at the fork-point.
diff --git a/pypy/doc/cppyy.rst b/pypy/doc/cppyy.rst
--- a/pypy/doc/cppyy.rst
+++ b/pypy/doc/cppyy.rst
@@ -122,7 +122,7 @@
$ hg up reflex-support # optional
# This example shows python, but using pypy-c is faster and uses less memory
- $ python rpython/translator/goal/translate.py --opt=jit pypy/goal/targetpypystandalone --withmod-cppyy
+ $ python rpython/bin/rpython --opt=jit pypy/goal/targetpypystandalone --withmod-cppyy
This will build a ``pypy-c`` that includes the cppyy module, and through that,
Reflex support.
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
@@ -1,6 +1,6 @@
-=========================
+==========================
What's new in PyPy2.7 5.3+
-=========================
+==========================
.. this is a revision shortly after release-pypy2.7-v5.3
.. startrev: 873218a739f1
@@ -37,3 +37,19 @@
.. branch: pyfile-tell
Sync w_file with the c-level FILE* before returning FILE* in PyFile_AsFile
+
+.. branch: rw-PyString_AS_STRING
+Allow rw access to the char* returned from PyString_AS_STRING, also refactor
+PyStringObject to look like cpython's and allow subclassing PyString_Type and
+PyUnicode_Type
+
+.. branch: save_socket_errno
+
+Bug fix: if ``socket.socket()`` failed, the ``socket.error`` did not show
+the errno of the failing system call, but instead some random previous
+errno.
+
+.. branch: PyTuple_Type-subclass
+
+Refactor PyTupleObject to look like cpython's and allow subclassing
+PyTuple_Type
diff --git a/pypy/interpreter/astcompiler/tools/asdl_py.py b/pypy/interpreter/astcompiler/tools/asdl_py.py
--- a/pypy/interpreter/astcompiler/tools/asdl_py.py
+++ b/pypy/interpreter/astcompiler/tools/asdl_py.py
@@ -400,7 +400,7 @@
if not (space.isinstance_w(w_obj, space.w_str) or
space.isinstance_w(w_obj, space.w_unicode)):
raise oefmt(space.w_TypeError,
- "AST string must be of type str or unicode")
+ "AST string must be of type str or unicode")
return w_obj
def get_field(space, w_node, name, optional):
diff --git a/pypy/interpreter/baseobjspace.py b/pypy/interpreter/baseobjspace.py
--- a/pypy/interpreter/baseobjspace.py
+++ b/pypy/interpreter/baseobjspace.py
@@ -1034,7 +1034,7 @@
return (None, None)
def newlist_bytes(self, list_s):
- return self.newlist([self.wrap(s) for s in list_s])
+ return self.newlist([self.newbytes(s) for s in list_s])
def newlist_unicode(self, list_u):
return self.newlist([self.wrap(u) for u in list_u])
@@ -1533,7 +1533,7 @@
# unclear if there is any use at all for getting the bytes in
# the unicode buffer.)
try:
- return self.str_w(w_obj)
+ return self.bytes_w(w_obj)
except OperationError as e:
if not e.match(self, self.w_TypeError):
raise
diff --git a/pypy/interpreter/pycode.py b/pypy/interpreter/pycode.py
--- a/pypy/interpreter/pycode.py
+++ b/pypy/interpreter/pycode.py
@@ -408,14 +408,14 @@
w(self.co_nlocals),
w(self.co_stacksize),
w(self.co_flags),
- w(self.co_code),
+ space.newbytes(self.co_code),
space.newtuple(self.co_consts_w),
space.newtuple(self.co_names_w),
space.newtuple([w(v) for v in self.co_varnames]),
w(self.co_filename),
w(self.co_name),
w(self.co_firstlineno),
- w(self.co_lnotab),
+ space.newbytes(self.co_lnotab),
space.newtuple([w(v) for v in self.co_freevars]),
space.newtuple([w(v) for v in self.co_cellvars]),
w(self.magic),
diff --git a/pypy/interpreter/pyparser/automata.py b/pypy/interpreter/pyparser/automata.py
--- a/pypy/interpreter/pyparser/automata.py
+++ b/pypy/interpreter/pyparser/automata.py
@@ -13,12 +13,11 @@
# PYPY Modification: removed the EMPTY class as it's not needed here
-# PYPY Modification: we don't need a particuliar DEFAULT class here
-# a simple None works fine.
-# (Having a DefaultClass inheriting from str makes
-# the annotator crash)
-DEFAULT = "\00default" # XXX hack, the rtyper does not support dict of with str|None keys
- # anyway using dicts doesn't seem the best final way to store these char indexed tables
+# PYPY Modification: DEFAULT is a singleton, used only in the pre-RPython
+# dicts (see pytokenize.py). Then DFA.__init__() turns these dicts into
+# more compact strings.
+DEFAULT = object()
+
# PYPY Modification : removed all automata functions (any, maybe,
# newArcPair, etc.)
diff --git a/pypy/interpreter/pyparser/genpytokenize.py b/pypy/interpreter/pyparser/genpytokenize.py
--- a/pypy/interpreter/pyparser/genpytokenize.py
+++ b/pypy/interpreter/pyparser/genpytokenize.py
@@ -293,7 +293,7 @@
i = 0
for k, v in sorted(state.items()):
i += 1
- if k == '\x00default':
+ if k == DEFAULT:
k = "automata.DEFAULT"
else:
k = repr(k)
diff --git a/pypy/interpreter/pyparser/parsestring.py b/pypy/interpreter/pyparser/parsestring.py
--- a/pypy/interpreter/pyparser/parsestring.py
+++ b/pypy/interpreter/pyparser/parsestring.py
@@ -81,7 +81,7 @@
if need_encoding:
enc = encoding
v = PyString_DecodeEscape(space, substr, 'strict', enc)
- return space.wrap(v)
+ return space.newbytes(v)
def decode_unicode_utf8(space, s, ps, q):
# ****The Python 2.7 version, producing UTF-32 escapes****
diff --git a/pypy/module/_cffi_backend/ctypeprim.py b/pypy/module/_cffi_backend/ctypeprim.py
--- a/pypy/module/_cffi_backend/ctypeprim.py
+++ b/pypy/module/_cffi_backend/ctypeprim.py
@@ -84,7 +84,7 @@
if self.size == 1:
with cdataobj as ptr:
s = ptr[0]
- return self.space.wrap(s)
+ return self.space.newbytes(s)
return W_CType.string(self, cdataobj, maxlen)
def unpack_ptr(self, w_ctypeptr, ptr, length):
@@ -126,12 +126,12 @@
return self.space.wrap(ord(cdata[0]))
def convert_to_object(self, cdata):
- return self.space.wrap(cdata[0])
+ return self.space.newbytes(cdata[0])
def _convert_to_char(self, w_ob):
space = self.space
if space.isinstance_w(w_ob, space.w_str):
- s = space.str_w(w_ob)
+ s = space.bytes_w(w_ob)
if len(s) == 1:
return s[0]
if (isinstance(w_ob, cdataobj.W_CData) and
@@ -146,7 +146,7 @@
def unpack_ptr(self, w_ctypeptr, ptr, length):
s = rffi.charpsize2str(ptr, length)
- return self.space.wrapbytes(s)
+ return self.space.newbytes(s)
# XXX explicitly use an integer type instead of lltype.UniChar here,
diff --git a/pypy/module/_cffi_backend/ctypeptr.py b/pypy/module/_cffi_backend/ctypeptr.py
--- a/pypy/module/_cffi_backend/ctypeptr.py
+++ b/pypy/module/_cffi_backend/ctypeptr.py
@@ -120,7 +120,7 @@
s = rffi.charp2str(ptr)
else:
s = rffi.charp2strn(ptr, length)
- return space.wrapbytes(s)
+ return space.newbytes(s)
#
# pointer to a wchar_t: builds and returns a unicode
if self.is_unichar_ptr_or_array():
@@ -129,7 +129,7 @@
u = rffi.wcharp2unicode(cdata)
else:
u = rffi.wcharp2unicoden(cdata, length)
- return space.wrap(u)
+ return space.newunicode(u)
#
return W_CType.string(self, cdataobj, maxlen)
diff --git a/pypy/module/_codecs/interp_codecs.py b/pypy/module/_codecs/interp_codecs.py
--- a/pypy/module/_codecs/interp_codecs.py
+++ b/pypy/module/_codecs/interp_codecs.py
@@ -36,12 +36,14 @@
w_errorhandler = lookup_error(space, errors)
if decode:
w_cls = space.w_UnicodeDecodeError
+ w_input = space.newbytes(input)
else:
w_cls = space.w_UnicodeEncodeError
+ w_input = space.newunicode(input)
w_exc = space.call_function(
w_cls,
space.wrap(encoding),
- space.wrap(input),
+ w_input,
space.wrap(startpos),
space.wrap(endpos),
space.wrap(reason))
@@ -314,7 +316,7 @@
@unwrap_spec(errors='str_or_None')
def readbuffer_encode(space, w_data, errors='strict'):
s = space.getarg_w('s#', w_data)
- return space.newtuple([space.wrap(s), space.wrap(len(s))])
+ return space.newtuple([space.newbytes(s), space.wrap(len(s))])
@unwrap_spec(errors='str_or_None')
def charbuffer_encode(space, w_data, errors='strict'):
@@ -377,7 +379,7 @@
state = space.fromcache(CodecState)
func = getattr(runicode, rname)
result = func(uni, len(uni), errors, state.encode_error_handler)
- return space.newtuple([space.wrap(result), space.wrap(len(uni))])
+ return space.newtuple([space.newbytes(result), space.wrap(len(uni))])
wrap_encoder.func_name = rname
globals()[name] = wrap_encoder
@@ -398,7 +400,7 @@
wrap_decoder.func_name = rname
globals()[name] = wrap_decoder
-for encoders in [
+for encoder in [
"ascii_encode",
"latin_1_encode",
"utf_7_encode",
@@ -412,9 +414,9 @@
"raw_unicode_escape_encode",
"unicode_internal_encode",
]:
- make_encoder_wrapper(encoders)
+ make_encoder_wrapper(encoder)
-for decoders in [
+for decoder in [
"ascii_decode",
"latin_1_decode",
"utf_7_decode",
@@ -426,7 +428,7 @@
"utf_32_le_decode",
"raw_unicode_escape_decode",
]:
- make_decoder_wrapper(decoders)
+ make_decoder_wrapper(decoder)
if hasattr(runicode, 'str_decode_mbcs'):
make_encoder_wrapper('mbcs_encode')
@@ -560,7 +562,7 @@
if space.isinstance_w(w_ch, space.w_str):
# Charmap may return a string
- return space.str_w(w_ch)
+ return space.bytes_w(w_ch)
elif space.isinstance_w(w_ch, space.w_int):
# Charmap may return a number
x = space.int_w(w_ch)
@@ -608,7 +610,7 @@
result = runicode.unicode_encode_charmap(
uni, len(uni), errors,
state.encode_error_handler, mapping)
- return space.newtuple([space.wrap(result), space.wrap(len(uni))])
+ return space.newtuple([space.newbytes(result), space.wrap(len(uni))])
@unwrap_spec(chars=unicode)
@@ -696,4 +698,4 @@
def escape_decode(space, data, errors='strict'):
from pypy.interpreter.pyparser.parsestring import PyString_DecodeEscape
result = PyString_DecodeEscape(space, data, errors, None)
- return space.newtuple([space.wrap(result), space.wrap(len(data))])
+ return space.newtuple([space.newbytes(result), space.wrap(len(data))])
diff --git a/pypy/module/_hashlib/interp_hashlib.py b/pypy/module/_hashlib/interp_hashlib.py
--- a/pypy/module/_hashlib/interp_hashlib.py
+++ b/pypy/module/_hashlib/interp_hashlib.py
@@ -111,7 +111,7 @@
def digest(self, space):
"Return the digest value as a string of binary data."
digest = self._digest(space)
- return space.wrap(digest)
+ return space.newbytes(digest)
def hexdigest(self, space):
"Return the digest value as a string of hexadecimal digits."
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
@@ -343,7 +343,7 @@
self._writer_reset_buf()
def _write(self, space, data):
- w_data = space.wrap(data)
+ w_data = space.newbytes(data)
while True:
try:
w_written = space.call_method(self.w_raw, "write", w_data)
@@ -415,7 +415,7 @@
else:
raise oefmt(space.w_ValueError,
"read length must be positive or -1")
- return space.wrap(res)
+ return space.newbytes(res)
@unwrap_spec(size=int)
def peek_w(self, space, size=0):
@@ -432,7 +432,7 @@
have = self._readahead()
if have > 0:
data = ''.join(self.buffer[self.pos:self.pos+have])
- return space.wrap(data)
+ return space.newbytes(data)
# Fill the buffer from the raw stream, and copy it to the result
self._reader_reset_buf()
@@ -442,7 +442,7 @@
size = 0
self.pos = 0
data = ''.join(self.buffer[:size])
- return space.wrap(data)
+ return space.newbytes(data)
@unwrap_spec(size=int)
def read1_w(self, space, size):
@@ -452,7 +452,7 @@
if size < 0:
raise oefmt(space.w_ValueError, "read length must be positive")
if size == 0:
- return space.wrap("")
+ return space.newbytes("")
with self.lock:
# Return up to n bytes. If at least one byte is buffered, we only
@@ -480,7 +480,7 @@
endpos = self.pos + size
data = ''.join(self.buffer[self.pos:endpos])
self.pos = endpos
- return space.wrap(data)
+ return space.newbytes(data)
def _read_all(self, space):
"Read all the file, don't update the cache"
@@ -505,7 +505,7 @@
if current_size == 0:
return w_data
break
- data = space.str_w(w_data)
+ data = space.bytes_w(w_data)
size = len(data)
if size == 0:
break
@@ -513,7 +513,7 @@
current_size += size
if self.abs_pos != -1:
self.abs_pos += size
- return space.wrap(builder.build())
+ return space.newbytes(builder.build())
def _raw_read(self, space, buffer, start, length):
length = intmask(length)
@@ -644,11 +644,11 @@
else:
pos = -1
if pos >= 0:
- w_res = space.wrap(''.join(self.buffer[self.pos:pos+1]))
+ w_res = space.newbytes(''.join(self.buffer[self.pos:pos+1]))
self.pos = pos + 1
return w_res
if have == limit:
- w_res = space.wrap(''.join(self.buffer[self.pos:self.pos+have]))
+ w_res = space.newbytes(''.join(self.buffer[self.pos:self.pos+have]))
self.pos += have
return w_res
@@ -690,7 +690,7 @@
written += have
if limit >= 0:
limit -= have
- return space.wrap(''.join(chunks))
+ return space.newbytes(''.join(chunks))
# ____________________________________________________
# Write methods
@@ -1024,7 +1024,6 @@
self._deprecated_max_buffer_size(space)
self.state = STATE_ZERO
-
check_readable_w(space, w_raw)
check_writable_w(space, w_raw)
check_seekable_w(space, w_raw)
diff --git a/pypy/module/_io/interp_bytesio.py b/pypy/module/_io/interp_bytesio.py
--- a/pypy/module/_io/interp_bytesio.py
+++ b/pypy/module/_io/interp_bytesio.py
@@ -32,12 +32,12 @@
def read_w(self, space, w_size=None):
self._check_closed(space)
size = convert_size(space, w_size)
- return space.wrap(self.read(size))
+ return space.newbytes(self.read(size))
def readline_w(self, space, w_limit=None):
self._check_closed(space)
limit = convert_size(space, w_limit)
- return space.wrap(self.readline(limit))
+ return space.newbytes(self.readline(limit))
def read1_w(self, space, w_size):
return self.read_w(space, w_size)
@@ -81,7 +81,7 @@
def getvalue_w(self, space):
self._check_closed(space)
- return space.wrap(self.getvalue())
+ return space.newbytes(self.getvalue())
def tell_w(self, space):
self._check_closed(space)
@@ -128,7 +128,7 @@
def getstate_w(self, space):
self._check_closed(space)
return space.newtuple([
- space.wrap(self.getvalue()),
+ space.newbytes(self.getvalue()),
space.wrap(self.tell()),
self.getdict(space)])
diff --git a/pypy/module/_io/interp_fileio.py b/pypy/module/_io/interp_fileio.py
--- a/pypy/module/_io/interp_fileio.py
+++ b/pypy/module/_io/interp_fileio.py
@@ -361,7 +361,7 @@
raise wrap_oserror(space, e,
exception_name='w_IOError')
- return space.wrap(s)
+ return space.newbytes(s)
def readinto_w(self, space, w_buffer):
self._check_closed(space)
@@ -405,7 +405,7 @@
break
builder.append(chunk)
total += len(chunk)
- return space.wrap(builder.build())
+ return space.newbytes(builder.build())
if sys.platform == "win32":
def _truncate(self, size):
diff --git a/pypy/module/_io/interp_iobase.py b/pypy/module/_io/interp_iobase.py
--- a/pypy/module/_io/interp_iobase.py
+++ b/pypy/module/_io/interp_iobase.py
@@ -192,7 +192,7 @@
length = space.len_w(w_readahead)
if length > 0:
n = 0
- buf = space.str_w(w_readahead)
+ buf = space.bytes_w(w_readahead)
if limit >= 0:
while True:
if n >= length or n >= limit:
@@ -219,7 +219,7 @@
raise oefmt(space.w_IOError,
"peek() should have returned a bytes object, not "
"'%T'", w_read)
- read = space.str_w(w_read)
+ read = space.bytes_w(w_read)
if not read:
break
@@ -229,7 +229,7 @@
if read[-1] == '\n':
break
- return space.wrap(builder.build())
+ return space.newbytes(builder.build())
def readlines_w(self, space, w_hint=None):
hint = convert_size(space, w_hint)
@@ -339,11 +339,11 @@
if not space.isinstance_w(w_data, space.w_str):
raise oefmt(space.w_TypeError, "read() should return bytes")
- data = space.str_w(w_data)
+ data = space.bytes_w(w_data)
if not data:
break
builder.append(data)
- return space.wrap(builder.build())
+ return space.newbytes(builder.build())
W_RawIOBase.typedef = TypeDef(
'_io._RawIOBase', W_IOBase.typedef,
diff --git a/pypy/module/_io/interp_textio.py b/pypy/module/_io/interp_textio.py
--- a/pypy/module/_io/interp_textio.py
+++ b/pypy/module/_io/interp_textio.py
@@ -160,7 +160,7 @@
w_buffer, w_flag = space.unpackiterable(w_state, 2)
flag = space.r_longlong_w(w_flag)
else:
- w_buffer = space.wrap("")
+ w_buffer = space.newbytes("")
flag = 0
flag <<= 1
if self.pendingcr:
@@ -556,7 +556,7 @@
# Given this, we know there was a valid snapshot point
# len(dec_buffer) bytes ago with decoder state (b'', dec_flags).
w_dec_buffer, w_dec_flags = space.unpackiterable(w_state, 2)
- dec_buffer = space.str_w(w_dec_buffer)
+ dec_buffer = space.bytes_w(w_dec_buffer)
dec_flags = space.int_w(w_dec_flags)
else:
dec_buffer = None
@@ -582,7 +582,7 @@
if self.telling:
# At the snapshot point, len(dec_buffer) bytes before the read,
# the next input to be decoded is dec_buffer + input_chunk.
- next_input = dec_buffer + space.str_w(w_input)
+ next_input = dec_buffer + space.bytes_w(w_input)
self.snapshot = PositionSnapshot(dec_flags, next_input)
return not eof
@@ -769,7 +769,7 @@
else:
w_bytes = space.call_method(self.w_encoder, "encode", w_text)
- b = space.str_w(w_bytes)
+ b = space.bytes_w(w_bytes)
if not self.pending_bytes:
self.pending_bytes = []
self.pending_bytes_count = 0
@@ -799,7 +799,8 @@
while True:
try:
- space.call_method(self.w_buffer, "write", space.wrap(pending_bytes))
+ space.call_method(self.w_buffer, "write",
+ space.newbytes(pending_bytes))
except OperationError as e:
if trap_eintr(space, e):
continue
@@ -828,7 +829,7 @@
space.call_method(self.w_decoder, "reset")
else:
space.call_method(self.w_decoder, "setstate",
- space.newtuple([space.wrap(""),
+ space.newtuple([space.newbytes(""),
space.wrap(cookie.dec_flags)]))
def _encoder_setstate(self, space, cookie):
@@ -904,7 +905,7 @@
raise oefmt(space.w_TypeError, msg, w_chunk)
self.snapshot = PositionSnapshot(cookie.dec_flags,
- space.str_w(w_chunk))
+ space.bytes_w(w_chunk))
w_decoded = space.call_method(self.w_decoder, "decode",
w_chunk, space.wrap(cookie.need_eof))
@@ -975,7 +976,7 @@
i = 0
while i < len(input):
w_decoded = space.call_method(self.w_decoder, "decode",
- space.wrap(input[i]))
+ space.newbytes(input[i]))
check_decoded(space, w_decoded)
chars_decoded += len(space.unicode_w(w_decoded))
diff --git a/pypy/module/_md5/interp_md5.py b/pypy/module/_md5/interp_md5.py
--- a/pypy/module/_md5/interp_md5.py
+++ b/pypy/module/_md5/interp_md5.py
@@ -20,7 +20,7 @@
self.update(string)
def digest_w(self):
- return self.space.wrap(self.digest())
+ return self.space.newbytes(self.digest())
def hexdigest_w(self):
return self.space.wrap(self.hexdigest())
diff --git a/pypy/module/_minimal_curses/interp_curses.py b/pypy/module/_minimal_curses/interp_curses.py
--- a/pypy/module/_minimal_curses/interp_curses.py
+++ b/pypy/module/_minimal_curses/interp_curses.py
@@ -83,12 +83,12 @@
return space.w_None
except curses_error as e:
raise convert_error(space, e)
- return space.wrap(result)
+ return space.newbytes(result)
@unwrap_spec(s=str)
def tparm(space, s, args_w):
args = [space.int_w(a) for a in args_w]
try:
- return space.wrap(_curses_tparm(s, args))
+ return space.newbytes(_curses_tparm(s, args))
except curses_error as e:
raise convert_error(space, e)
diff --git a/pypy/module/_multibytecodec/interp_incremental.py b/pypy/module/_multibytecodec/interp_incremental.py
--- a/pypy/module/_multibytecodec/interp_incremental.py
+++ b/pypy/module/_multibytecodec/interp_incremental.py
@@ -113,7 +113,7 @@
pos = c_codecs.pypy_cjk_enc_inbuf_consumed(self.encodebuf)
assert 0 <= pos <= len(object)
self.pending = object[pos:]
- return space.wrap(output)
+ return space.newbytes(output)
@unwrap_spec(errors="str_or_None")
diff --git a/pypy/module/_multibytecodec/interp_multibytecodec.py b/pypy/module/_multibytecodec/interp_multibytecodec.py
--- a/pypy/module/_multibytecodec/interp_multibytecodec.py
+++ b/pypy/module/_multibytecodec/interp_multibytecodec.py
@@ -40,7 +40,7 @@
raise wrap_unicodeencodeerror(space, e, input, self.name)
except RuntimeError:
raise wrap_runtimeerror(space)
- return space.newtuple([space.wrap(output),
+ return space.newtuple([space.newbytes(output),
space.wrap(len(input))])
@@ -66,7 +66,7 @@
space.w_UnicodeDecodeError,
space.newtuple([
space.wrap(name),
- space.wrap(input),
+ space.newbytes(input),
space.wrap(e.start),
space.wrap(e.end),
space.wrap(e.reason)]))
diff --git a/pypy/module/_multiprocessing/interp_connection.py b/pypy/module/_multiprocessing/interp_connection.py
--- a/pypy/module/_multiprocessing/interp_connection.py
+++ b/pypy/module/_multiprocessing/interp_connection.py
@@ -122,9 +122,9 @@
space, self.BUFFER_SIZE, maxlength)
try:
if newbuf:
- return space.wrap(rffi.charpsize2str(newbuf, res))
+ return space.newbytes(rffi.charpsize2str(newbuf, res))
else:
- return space.wrap(rffi.charpsize2str(self.buffer, res))
+ return space.newbytes(rffi.charpsize2str(self.buffer, res))
finally:
if newbuf:
rffi.free_charp(newbuf)
@@ -138,7 +138,7 @@
space, length - offset, PY_SSIZE_T_MAX)
try:
if newbuf:
- raise BufferTooShort(space, space.wrap(
+ raise BufferTooShort(space, space.newbytes(
rffi.charpsize2str(newbuf, res)))
rwbuffer.setslice(offset, rffi.charpsize2str(self.buffer, res))
finally:
@@ -166,9 +166,9 @@
space, self.BUFFER_SIZE, PY_SSIZE_T_MAX)
try:
if newbuf:
- w_received = space.wrap(rffi.charpsize2str(newbuf, res))
+ w_received = space.newbytes(rffi.charpsize2str(newbuf, res))
else:
- w_received = space.wrap(rffi.charpsize2str(self.buffer, res))
+ w_received = space.newbytes(rffi.charpsize2str(self.buffer, res))
finally:
if newbuf:
rffi.free_charp(newbuf)
diff --git a/pypy/module/_rawffi/alt/test/test_type_converter.py b/pypy/module/_rawffi/alt/test/test_type_converter.py
--- a/pypy/module/_rawffi/alt/test/test_type_converter.py
+++ b/pypy/module/_rawffi/alt/test/test_type_converter.py
@@ -12,14 +12,14 @@
handle_signed = handle_all
handle_unsigned = handle_all
handle_pointer = handle_all
- handle_char = handle_all
+ handle_char = handle_all
handle_unichar = handle_all
handle_longlong = handle_all
handle_char_p = handle_all
handle_unichar_p = handle_all
handle_float = handle_all
handle_singlefloat = handle_all
-
+
def handle_struct(self, w_ffitype, w_structinstance):
self.lastval = w_structinstance
@@ -119,12 +119,12 @@
def test_strings(self):
# first, try automatic conversion from applevel
- self.check(app_types.char_p, self.space.wrap('foo'), 'foo')
- self.check(app_types.unichar_p, self.space.wrap(u'foo\u1234'), u'foo\u1234')
- self.check(app_types.unichar_p, self.space.wrap('foo'), u'foo')
+ self.check(app_types.char_p, self.space.newbytes('foo'), 'foo')
+ self.check(app_types.unichar_p, self.space.wrap(u'foo\u1234'), u'foo\u1234')
+ self.check(app_types.unichar_p, self.space.wrap('foo'), u'foo')
# then, try to pass explicit pointers
self.check(app_types.char_p, self.space.wrap(42), 42)
- self.check(app_types.unichar_p, self.space.wrap(42), 42)
+ self.check(app_types.unichar_p, self.space.wrap(42), 42)
@@ -136,7 +136,7 @@
get_signed = get_all
get_unsigned = get_all
get_pointer = get_all
- get_char = get_all
+ get_char = get_all
get_unichar = get_all
get_longlong = get_all
get_char_p = get_all
@@ -144,7 +144,7 @@
get_float = get_all
get_singlefloat = get_all
get_unsigned_which_fits_into_a_signed = get_all
-
+
def convert(self, w_ffitype, val):
self.val = val
return self.do_and_wrap(w_ffitype)
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
@@ -181,7 +181,7 @@
start, stop = self.decodeslice(space, w_slice)
ll_buffer = self.ll_buffer
result = [ll_buffer[i] for i in range(start, stop)]
- return space.wrap(''.join(result))
+ return space.newbytes(''.join(result))
def setslice(self, space, w_slice, w_value):
start, stop = self.decodeslice(space, w_slice)
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
@@ -570,7 +570,7 @@
s = rffi.charp2str(charp_addr)
else:
s = rffi.charp2strn(charp_addr, maxlength)
- return space.wrap(s)
+ return space.newbytes(s)
@unwrap_spec(address=r_uint, maxlength=int)
def wcharp2unicode(space, address, maxlength=-1):
@@ -588,7 +588,7 @@
if maxlength == -1:
return charp2string(space, address)
s = rffi.charpsize2str(rffi.cast(rffi.CCHARP, address), maxlength)
- return space.wrap(s)
+ return space.newbytes(s)
@unwrap_spec(address=r_uint, maxlength=int)
def wcharp2rawunicode(space, address, maxlength=-1):
diff --git a/pypy/module/_socket/interp_func.py b/pypy/module/_socket/interp_func.py
--- a/pypy/module/_socket/interp_func.py
+++ b/pypy/module/_socket/interp_func.py
@@ -209,7 +209,7 @@
buf = rsocket.inet_aton(ip)
except SocketError as e:
raise converted_error(space, e)
- return space.wrap(buf)
+ return space.newbytes(buf)
@unwrap_spec(packed=str)
def inet_ntoa(space, packed):
@@ -234,7 +234,7 @@
buf = rsocket.inet_pton(family, ip)
except SocketError as e:
raise converted_error(space, e)
- return space.wrap(buf)
+ return space.newbytes(buf)
@unwrap_spec(family=int, packed=str)
def inet_ntop(space, family, packed):
@@ -263,10 +263,10 @@
if space.is_w(w_host, space.w_None):
host = None
elif space.isinstance_w(w_host, space.w_str):
- host = space.str_w(w_host)
+ host = space.bytes_w(w_host)
elif space.isinstance_w(w_host, space.w_unicode):
w_shost = space.call_method(w_host, "encode", space.wrap("idna"))
- host = space.str_w(w_shost)
+ host = space.bytes_w(w_shost)
else:
raise oefmt(space.w_TypeError,
"getaddrinfo() argument 1 must be string or None")
@@ -277,7 +277,7 @@
elif space.isinstance_w(w_port, space.w_int) or space.isinstance_w(w_port, space.w_long):
port = str(space.int_w(w_port))
elif space.isinstance_w(w_port, space.w_str):
- port = space.str_w(w_port)
+ port = space.bytes_w(w_port)
else:
raise oefmt(space.w_TypeError,
"getaddrinfo() argument 2 must be integer or string")
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
@@ -296,7 +296,7 @@
except SocketError as e:
raise converted_error(space, e)
buflen = space.int_w(w_buflen)
- return space.wrap(self.sock.getsockopt(level, optname, buflen))
+ return space.newbytes(self.sock.getsockopt(level, optname, buflen))
def gettimeout_w(self, space):
"""gettimeout() -> timeout
@@ -345,7 +345,7 @@
data = self.sock.recv(buffersize, flags)
except SocketError as e:
raise converted_error(space, e)
- return space.wrap(data)
+ return space.newbytes(data)
@unwrap_spec(buffersize='nonnegint', flags=int)
def recvfrom_w(self, space, buffersize, flags=0):
@@ -359,7 +359,7 @@
w_addr = addr_as_object(addr, self.sock.fd, space)
else:
w_addr = space.w_None
- return space.newtuple([space.wrap(data), w_addr])
+ return space.newtuple([space.newbytes(data), w_addr])
except SocketError as e:
raise converted_error(space, e)
@@ -436,7 +436,7 @@
except OperationError as e:
if e.async(space):
raise
- optval = space.str_w(w_optval)
+ optval = space.bytes_w(w_optval)
try:
self.sock.setsockopt(level, optname, optval)
except SocketError as e:
diff --git a/pypy/module/_sre/interp_sre.py b/pypy/module/_sre/interp_sre.py
--- a/pypy/module/_sre/interp_sre.py
+++ b/pypy/module/_sre/interp_sre.py
@@ -36,11 +36,12 @@
def slice_w(space, ctx, start, end, w_default):
if 0 <= start <= end:
if isinstance(ctx, rsre_core.BufMatchContext):
- return space.wrap(ctx._buffer.getslice(start, end, 1, end-start))
+ return space.newbytes(ctx._buffer.getslice(start, end, 1,
+ end-start))
if isinstance(ctx, rsre_core.StrMatchContext):
- return space.wrap(ctx._string[start:end])
+ return space.newbytes(ctx._string[start:end])
elif isinstance(ctx, rsre_core.UnicodeMatchContext):
- return space.wrap(ctx._unicodestr[start:end])
+ return space.newunicode(ctx._unicodestr[start:end])
else:
# unreachable
raise SystemError
@@ -242,7 +243,7 @@
space.isinstance_w(w_string, space.w_unicode) and literal)
else:
try:
- filter_as_string = space.str_w(w_ptemplate)
+ filter_as_string = space.bytes_w(w_ptemplate)
except OperationError as e:
if e.async(space):
raise
@@ -331,15 +332,15 @@
strbuilder, unicodebuilder, last_pos, ctx.end)
if use_builder:
if strbuilder is not None:
- return space.wrap(strbuilder.build()), n
+ return space.newbytes(strbuilder.build()), n
else:
assert unicodebuilder is not None
- return space.wrap(unicodebuilder.build()), n
+ return space.newunicode(unicodebuilder.build()), n
else:
if space.isinstance_w(w_string, space.w_unicode):
- w_emptystr = space.wrap(u'')
+ w_emptystr = space.newunicode(u'')
else:
- w_emptystr = space.wrap('')
+ w_emptystr = space.newbytes('')
w_item = space.call_method(w_emptystr, 'join',
space.newlist(sublist_w))
return w_item, n
@@ -565,11 +566,11 @@
def fget_string(self, space):
ctx = self.ctx
if isinstance(ctx, rsre_core.BufMatchContext):
- return space.wrap(ctx._buffer.as_str())
+ return space.newbytes(ctx._buffer.as_str())
elif isinstance(ctx, rsre_core.StrMatchContext):
- return space.wrap(ctx._string)
+ return space.newbytes(ctx._string)
elif isinstance(ctx, rsre_core.UnicodeMatchContext):
- return space.wrap(ctx._unicodestr)
+ return space.newunicode(ctx._unicodestr)
else:
raise SystemError
diff --git a/pypy/module/_ssl/interp_ssl.py b/pypy/module/_ssl/interp_ssl.py
--- a/pypy/module/_ssl/interp_ssl.py
+++ b/pypy/module/_ssl/interp_ssl.py
@@ -666,7 +666,7 @@
length = libssl_SSL_get_peer_finished(self.ssl, buf, CB_MAXLEN)
if length > 0:
- return space.wrap(rffi.charpsize2str(buf, intmask(length)))
+ return space.newbytes(rffi.charpsize2str(buf, intmask(length)))
def descr_get_context(self, space):
return self.w_ctx
@@ -707,7 +707,7 @@
if length < 0:
raise _ssl_seterror(space, None, 0)
try:
- return space.wrap(rffi.charpsize2str(buf_ptr[0], length))
+ return space.newbytes(rffi.charpsize2str(buf_ptr[0], length))
finally:
libssl_OPENSSL_free(buf_ptr[0])
@@ -926,7 +926,7 @@
if length < 0:
raise _ssl_seterror(space, None, 0)
try:
- w_value = space.wrap(rffi.charpsize2str(buf_ptr[0], length))
+ w_value = space.newbytes(rffi.charpsize2str(buf_ptr[0], length))
w_value = space.call_method(w_value, "decode", space.wrap("utf-8"))
finally:
libssl_OPENSSL_free(buf_ptr[0])
@@ -1232,7 +1232,7 @@
w_ssl_socket, space.w_None, w_ctx)
else:
- w_servername = space.wrapbytes(rffi.charp2str(servername))
+ w_servername = space.newbytes(rffi.charp2str(servername))
try:
w_servername_idna = space.call_method(
w_servername, 'decode', space.wrap('idna'))
@@ -1778,7 +1778,7 @@
if not path:
return space.w_None
else:
- return space.wrapbytes(rffi.charp2str(path))
+ return space.newbytes(rffi.charp2str(path))
def get_default_verify_paths(space):
return space.newtuple([
diff --git a/pypy/module/_ssl/interp_win32.py b/pypy/module/_ssl/interp_win32.py
--- a/pypy/module/_ssl/interp_win32.py
+++ b/pypy/module/_ssl/interp_win32.py
@@ -74,7 +74,7 @@
def w_parseKeyUsage(space, pCertCtx, flags):
with lltype.scoped_alloc(rwin32.LPDWORD.TO, 1) as size_ptr:
- if not CertGetEnhancedKeyUsage(pCertCtx, flags,
+ if not CertGetEnhancedKeyUsage(pCertCtx, flags,
lltype.nullptr(CERT_ENHKEY_USAGE), size_ptr):
last_error = rwin32.lastSavedWindowsError()
if last_error.winerror == CRYPT_E_NOT_FOUND:
@@ -120,7 +120,7 @@
pCertCtx = CertEnumCertificatesInStore(hStore, pCertCtx)
if not pCertCtx:
break
- w_cert = space.wrapbytes(
+ w_cert = space.newbytes(
rffi.charpsize2str(pCertCtx.c_pbCertEncoded,
intmask(pCertCtx.c_cbCertEncoded)))
w_enc = w_certEncodingType(space, pCertCtx.c_dwCertEncodingType)
@@ -162,7 +162,7 @@
pCrlCtx = CertEnumCRLsInStore(hStore, pCrlCtx)
if not pCrlCtx:
break
- w_crl = space.wrapbytes(
+ w_crl = space.newbytes(
rffi.charpsize2str(pCrlCtx.c_pbCrlEncoded,
intmask(pCrlCtx.c_cbCrlEncoded)))
w_enc = w_certEncodingType(space, pCrlCtx.c_dwCertEncodingType)
diff --git a/pypy/module/_winreg/interp_winreg.py b/pypy/module/_winreg/interp_winreg.py
--- a/pypy/module/_winreg/interp_winreg.py
+++ b/pypy/module/_winreg/interp_winreg.py
@@ -380,7 +380,7 @@
return space.newlist(l)
else: # REG_BINARY and all other types
- return space.wrap(rffi.charpsize2str(buf, buflen))
+ return space.newbytes(rffi.charpsize2str(buf, buflen))
@unwrap_spec(value_name=str, typ=int)
def SetValueEx(space, w_hkey, value_name, w_reserved, typ, w_value):
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
@@ -225,11 +225,11 @@
"""
size = self.len
if size == 0:
- return space.wrap('')
+ return space.newbytes('')
cbuf = self._charbuf_start()
s = rffi.charpsize2str(cbuf, size * self.itemsize)
self._charbuf_stop()
- return self.space.wrap(s)
+ return self.space.newbytes(s)
def descr_fromstring(self, space, w_s):
""" fromstring(string)
@@ -263,7 +263,7 @@
except OverflowError:
raise MemoryError
w_item = space.call_method(w_f, 'read', space.wrap(size))
- item = space.str_w(w_item)
+ item = space.bytes_w(w_item)
if len(item) < size:
n = len(item) % self.itemsize
elems = max(0, len(item) - (len(item) % self.itemsize))
@@ -338,10 +338,10 @@
else:
args = [space.wrap(self.typecode)]
try:
- dct = space.getattr(self, space.wrap('__dict__'))
+ w_dict = space.getattr(self, space.wrap('__dict__'))
except OperationError:
- dct = space.w_None
- return space.newtuple([space.type(self), space.newtuple(args), dct])
+ w_dict = space.w_None
+ return space.newtuple([space.type(self), space.newtuple(args), w_dict])
def descr_copy(self, space):
""" copy(array)
diff --git a/pypy/module/binascii/interp_base64.py b/pypy/module/binascii/interp_base64.py
--- a/pypy/module/binascii/interp_base64.py
+++ b/pypy/module/binascii/interp_base64.py
@@ -71,7 +71,7 @@
if leftbits != 0:
raise_Error(space, "Incorrect padding")
- return space.wrap(res.build())
+ return space.newbytes(res.build())
# ____________________________________________________________
@@ -110,4 +110,4 @@
res.append(table_b2a_base64[(leftchar & 0xf) << 2])
res.append(PAD)
res.append('\n')
- return space.wrap(res.build())
+ return space.newbytes(res.build())
diff --git a/pypy/module/binascii/interp_hexlify.py b/pypy/module/binascii/interp_hexlify.py
--- a/pypy/module/binascii/interp_hexlify.py
+++ b/pypy/module/binascii/interp_hexlify.py
@@ -24,7 +24,7 @@
for c in data:
res.append(_value2char(ord(c) >> 4))
res.append(_value2char(ord(c) & 0xf))
- return space.wrap(res.build())
+ return space.newbytes(res.build())
# ____________________________________________________________
@@ -53,4 +53,4 @@
a = _char2value(space, hexstr[i])
b = _char2value(space, hexstr[i+1])
res.append(chr((a << 4) | b))
- return space.wrap(res.build())
+ return space.newbytes(res.build())
diff --git a/pypy/module/binascii/interp_hqx.py b/pypy/module/binascii/interp_hqx.py
--- a/pypy/module/binascii/interp_hqx.py
+++ b/pypy/module/binascii/interp_hqx.py
@@ -11,37 +11,37 @@
FAIL = 0x7d
table_a2b_hqx = [
- #^@ ^A ^B ^C ^D ^E ^F ^G
+ #^@ ^A ^B ^C ^D ^E ^F ^G
FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
- #\b \t \n ^K ^L \r ^N ^O
+ #\b \t \n ^K ^L \r ^N ^O
FAIL, FAIL, SKIP, FAIL, FAIL, SKIP, FAIL, FAIL,
- #^P ^Q ^R ^S ^T ^U ^V ^W
+ #^P ^Q ^R ^S ^T ^U ^V ^W
FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
- #^X ^Y ^Z ^[ ^\ ^] ^^ ^_
+ #^X ^Y ^Z ^[ ^\ ^] ^^ ^_
FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
- # ! " # $ % & '
+ # ! " # $ % & '
FAIL, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
- #( ) * + , - . /
+ #( ) * + , - . /
0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, FAIL, FAIL,
- #0 1 2 3 4 5 6 7
+ #0 1 2 3 4 5 6 7
0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, FAIL,
- #8 9 : ; < = > ?
+ #8 9 : ; < = > ?
0x14, 0x15, DONE, FAIL, FAIL, FAIL, FAIL, FAIL,
- #@ A B C D E F G
+ #@ A B C D E F G
0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D,
- #H I J K L M N O
+ #H I J K L M N O
0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, FAIL,
- #P Q R S T U V W
+ #P Q R S T U V W
0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, FAIL,
- #X Y Z [ \ ] ^ _
+ #X Y Z [ \ ] ^ _
0x2C, 0x2D, 0x2E, 0x2F, FAIL, FAIL, FAIL, FAIL,
- #` a b c d e f g
+ #` a b c d e f g
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, FAIL,
- #h i j k l m n o
+ #h i j k l m n o
0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, FAIL, FAIL,
- #p q r s t u v w
+ #p q r s t u v w
0x3D, 0x3E, 0x3F, FAIL, FAIL, FAIL, FAIL, FAIL,
- #x y z { | } ~ ^?
+ #x y z { | } ~ ^?
FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
@@ -97,7 +97,7 @@
else:
if pending_bits > 0:
raise_Incomplete(space, 'String has incomplete number of bytes')
- return space.newtuple([space.wrap(res.build()), space.wrap(done)])
+ return space.newtuple([space.newbytes(res.build()), space.wrap(done)])
# ____________________________________________________________
@@ -128,7 +128,7 @@
if leftbits > 0:
leftchar <<= (6 - leftbits)
res.append(hqx_encoding[leftchar & 0x3f])
- return space.wrap(res.build())
+ return space.newbytes(res.build())
# ____________________________________________________________
@@ -150,7 +150,7 @@
lastpushed = ord(c)
else:
if i == end:
- raise_Incomplete(space, 'String ends with the RLE code \x90')
+ raise_Incomplete(space, 'String ends with the RLE code \\x90')
count = ord(hexbin[i]) - 1
i += 1
if count < 0:
@@ -158,9 +158,9 @@
lastpushed = 0x90
else:
if lastpushed < 0:
- raise_Error(space, 'String starts with the RLE code \x90')
+ raise_Error(space, 'String starts with the RLE code \\x90')
res.append_multiple_char(chr(lastpushed), count)
- return space.wrap(res.build())
+ return space.newbytes(res.build())
# ____________________________________________________________
@@ -197,7 +197,7 @@
# string that rledecode_hqx() would expand back to 'data', there are
# some programs somewhere that would start failing obscurely in rare
# cases.
- return space.wrap(res.build())
+ return space.newbytes(res.build())
# ____________________________________________________________
diff --git a/pypy/module/binascii/interp_qp.py b/pypy/module/binascii/interp_qp.py
--- a/pypy/module/binascii/interp_qp.py
+++ b/pypy/module/binascii/interp_qp.py
@@ -56,7 +56,7 @@
if header and c == '_':
c = ' '
odata.append(c)
- return space.wrap(odata.build())
+ return space.newbytes(odata.build())
# ____________________________________________________________
@@ -159,4 +159,4 @@
odata.append(c)
inp += 1
- return space.wrap(odata.build())
+ return space.newbytes(odata.build())
diff --git a/pypy/module/binascii/interp_uu.py b/pypy/module/binascii/interp_uu.py
--- a/pypy/module/binascii/interp_uu.py
+++ b/pypy/module/binascii/interp_uu.py
@@ -54,7 +54,7 @@
remaining = length - res.getlength()
if remaining > 0:
res.append_multiple_char('\x00', remaining)
- return space.wrap(res.build())
+ return space.newbytes(res.build())
# ____________________________________________________________
@@ -86,4 +86,4 @@
res.append(chr(0x20 + (C & 0x3F)))
res.append('\n')
- return space.wrap(res.build())
+ return space.newbytes(res.build())
diff --git a/pypy/module/bz2/interp_bz2.py b/pypy/module/bz2/interp_bz2.py
--- a/pypy/module/bz2/interp_bz2.py
+++ b/pypy/module/bz2/interp_bz2.py
@@ -557,7 +557,7 @@
datasize = len(data)
if datasize == 0:
- return self.space.wrap("")
+ return self.space.newbytes("")
if not self.running:
raise oefmt(self.space.w_ValueError,
@@ -582,7 +582,7 @@
out.prepare_next_chunk()
res = out.make_result_string()
- return self.space.wrap(res)
+ return self.space.newbytes(res)
def flush(self):
if not self.running:
@@ -602,7 +602,7 @@
out.prepare_next_chunk()
res = out.make_result_string()
- return self.space.wrap(res)
+ return self.space.newbytes(res)
W_BZ2Compressor.typedef = TypeDef("BZ2Compressor",
__doc__ = W_BZ2Compressor.__doc__,
@@ -669,7 +669,7 @@
raise oefmt(self.space.w_EOFError,
"end of stream was already found")
if data == '':
- return self.space.wrap('')
+ return self.space.newbytes('')
in_bufsize = len(data)
@@ -698,7 +698,7 @@
out.prepare_next_chunk()
res = out.make_result_string()
- return self.space.wrap(res)
+ return self.space.newbytes(res)
W_BZ2Decompressor.typedef = TypeDef("BZ2Decompressor",
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
@@ -800,6 +800,21 @@
pypy_debug_catch_fatal_exception()
assert False
+def _restore_gil_state(pygilstate_release, gilstate, gil_release, _gil_auto, tid):
+ from rpython.rlib import rgil
+ # see "Handling of the GIL" above
+ assert cpyext_glob_tid_ptr[0] == 0
+ if pygilstate_release:
+ from pypy.module.cpyext import pystate
+ unlock = (gilstate == pystate.PyGILState_UNLOCKED)
+ else:
+ unlock = gil_release or _gil_auto
+ if unlock:
+ rgil.release()
+ else:
+ cpyext_glob_tid_ptr[0] = tid
+
+
def make_wrapper_second_level(space, argtypesw, restype,
result_kind, error_value, gil):
from rpython.rlib import rgil
@@ -827,6 +842,7 @@
def wrapper_second_level(callable, pname, *args):
from pypy.module.cpyext.pyobject import make_ref, from_ref, is_pyobj
from pypy.module.cpyext.pyobject import as_pyobj
+ from pypy.module.cpyext import pystate
# we hope that malloc removal removes the newtuple() that is
# inserted exactly here by the varargs specializer
@@ -839,7 +855,6 @@
rgil.acquire()
assert cpyext_glob_tid_ptr[0] == 0
elif pygilstate_ensure:
- from pypy.module.cpyext import pystate
if cpyext_glob_tid_ptr[0] == tid:
cpyext_glob_tid_ptr[0] = 0
args += (pystate.PyGILState_LOCKED,)
@@ -850,6 +865,10 @@
if cpyext_glob_tid_ptr[0] != tid:
no_gil_error(pname)
cpyext_glob_tid_ptr[0] = 0
+ if pygilstate_release:
+ gilstate = rffi.cast(lltype.Signed, args[-1])
+ else:
+ gilstate = pystate.PyGILState_IGNORE
rffi.stackcounter.stacks_counter += 1
llop.gc_stack_bottom(lltype.Void) # marker for trackgcroot.py
@@ -919,24 +938,13 @@
except Exception as e:
unexpected_exception(pname, e, tb)
+ _restore_gil_state(pygilstate_release, gilstate, gil_release, _gil_auto, tid)
return fatal_value
assert lltype.typeOf(retval) == restype
rffi.stackcounter.stacks_counter -= 1
- # see "Handling of the GIL" above
- assert cpyext_glob_tid_ptr[0] == 0
- if pygilstate_release:
- from pypy.module.cpyext import pystate
- arg = rffi.cast(lltype.Signed, args[-1])
- unlock = (arg == pystate.PyGILState_UNLOCKED)
- else:
- unlock = gil_release or _gil_auto
- if unlock:
- rgil.release()
- else:
- cpyext_glob_tid_ptr[0] = tid
-
+ _restore_gil_state(pygilstate_release, gilstate, gil_release, _gil_auto, tid)
return retval
wrapper_second_level._dont_inline_ = True
@@ -1202,8 +1210,6 @@
cpyext_type_init = self.cpyext_type_init
self.cpyext_type_init = None
for pto, w_type in cpyext_type_init:
- if space.is_w(w_type, space.w_str):
- pto.c_tp_itemsize = 1
finish_type_1(space, pto)
finish_type_2(space, pto, w_type)
diff --git a/pypy/module/cpyext/bufferobject.py b/pypy/module/cpyext/bufferobject.py
--- a/pypy/module/cpyext/bufferobject.py
+++ b/pypy/module/cpyext/bufferobject.py
@@ -79,5 +79,5 @@
Py_DecRef(space, py_buf.c_b_base)
else:
rffi.free_charp(rffi.cast(rffi.CCHARP, py_buf.c_b_ptr))
- from pypy.module.cpyext.object import PyObject_dealloc
- PyObject_dealloc(space, py_obj)
+ from pypy.module.cpyext.object import _dealloc
+ _dealloc(space, py_obj)
diff --git a/pypy/module/cpyext/bytearrayobject.py b/pypy/module/cpyext/bytearrayobject.py
--- a/pypy/module/cpyext/bytearrayobject.py
+++ b/pypy/module/cpyext/bytearrayobject.py
@@ -25,55 +25,11 @@
PyByteArrayObjectStruct = lltype.ForwardReference()
PyByteArrayObject = lltype.Ptr(PyByteArrayObjectStruct)
-PyByteArrayObjectFields = PyVarObjectFields
-# (("ob_exports", rffi.INT), ("ob_alloc", rffi.LONG), ("ob_bytes", rffi.CCHARP))
+PyByteArrayObjectFields = PyVarObjectFields
cpython_struct("PyByteArrayObject", PyByteArrayObjectFields, PyByteArrayObjectStruct)
- at bootstrap_function
-def init_bytearrayobject(space):
- "Type description of PyByteArrayObject"
- #make_typedescr(space.w_bytearray.layout.typedef,
- # basestruct=PyByteArrayObject.TO,
- # attach=bytearray_attach,
- # dealloc=bytearray_dealloc,
- # realize=bytearray_realize)
-
PyByteArray_Check, PyByteArray_CheckExact = build_type_checkers("ByteArray", "w_bytearray")
-# XXX dead code to be removed
-#def bytearray_attach(space, py_obj, w_obj):
-# """
-# Fills a newly allocated PyByteArrayObject with the given bytearray object
-# """
-# py_ba = rffi.cast(PyByteArrayObject, py_obj)
-# py_ba.c_ob_size = len(space.str_w(w_obj))
-# py_ba.c_ob_bytes = lltype.nullptr(rffi.CCHARP.TO)
-# py_ba.c_ob_exports = rffi.cast(rffi.INT, 0)
-
-#def bytearray_realize(space, py_obj):
-# """
-# Creates the bytearray in the interpreter.
-# """
-# py_ba = rffi.cast(PyByteArrayObject, py_obj)
-# if not py_ba.c_ob_bytes:
-# py_ba.c_buffer = lltype.malloc(rffi.CCHARP.TO, py_ba.c_ob_size + 1,
-# flavor='raw', zero=True)
-# s = rffi.charpsize2str(py_ba.c_ob_bytes, py_ba.c_ob_size)
-# w_obj = space.wrap(s)
-# py_ba.c_ob_exports = rffi.cast(rffi.INT, 0)
-# track_reference(space, py_obj, w_obj)
-# return w_obj
-
-#@cpython_api([PyObject], lltype.Void, header=None)
-#def bytearray_dealloc(space, py_obj):
-# """Frees allocated PyByteArrayObject resources.
-# """
-# py_ba = rffi.cast(PyByteArrayObject, py_obj)
-# if py_ba.c_ob_bytes:
-# lltype.free(py_ba.c_ob_bytes, flavor="raw")
-# from pypy.module.cpyext.object import PyObject_dealloc
-# PyObject_dealloc(space, py_obj)
-
#_______________________________________________________________________
@cpython_api([PyObject], PyObject, result_is_ll=True)
@@ -90,9 +46,9 @@
"""Create a new bytearray object from string and its length, len. On
failure, NULL is returned."""
if char_p:
- w_s = space.wrap(rffi.charpsize2str(char_p, length))
+ w_s = space.newbytes(rffi.charpsize2str(char_p, length))
else:
- w_s = space.wrap(length)
+ w_s = space.newint(length)
w_buffer = space.call_function(space.w_bytearray, w_s)
return make_ref(space, w_buffer)
@@ -124,7 +80,7 @@
if space.isinstance_w(w_obj, space.w_bytearray):
oldlen = space.len_w(w_obj)
if newlen > oldlen:
- space.call_method(w_obj, 'extend', space.wrap('\x00' * (newlen - oldlen)))
+ space.call_method(w_obj, 'extend', space.newbytes('\x00' * (newlen - oldlen)))
elif oldlen > newlen:
assert newlen >= 0
space.delslice(w_obj, space.wrap(newlen), space.wrap(oldlen))
diff --git a/pypy/module/cpyext/bytesobject.py b/pypy/module/cpyext/bytesobject.py
--- a/pypy/module/cpyext/bytesobject.py
+++ b/pypy/module/cpyext/bytesobject.py
@@ -6,17 +6,19 @@
from pypy.module.cpyext.pyerrors import PyErr_BadArgument
from pypy.module.cpyext.pyobject import (
PyObject, PyObjectP, Py_DecRef, make_ref, from_ref, track_reference,
- make_typedescr, get_typedescr, as_pyobj, Py_IncRef, get_w_obj_and_decref)
+ make_typedescr, get_typedescr, as_pyobj, Py_IncRef, get_w_obj_and_decref,
+ pyobj_has_w_obj)
+from pypy.objspace.std.bytesobject import W_BytesObject
##
-## Implementation of PyStringObject
+## Implementation of PyBytesObject
## ================================
##
## The problem
## -----------
##
## PyString_AsString() must return a (non-movable) pointer to the underlying
-## buffer, whereas pypy strings are movable. C code may temporarily store
+## ob_sval, whereas pypy strings are movable. C code may temporarily store
## this address and use it, as long as it owns a reference to the PyObject.
## There is no "release" function to specify that the pointer is not needed
## any more.
@@ -27,20 +29,23 @@
## Solution
## --------
##
-## PyStringObject contains two additional members: the ob_size and a pointer to a
-## char buffer; it may be NULL.
+## PyBytesObject contains two additional members: the ob_size and a pointer to a
+## char ob_sval; it may be NULL.
##
-## - A string allocated by pypy will be converted into a PyStringObject with a
+## - A string allocated by pypy will be converted into a PyBytesObject with a
## NULL buffer. The first time PyString_AsString() is called, memory is
## allocated (with flavor='raw') and content is copied.
##
## - A string allocated with PyString_FromStringAndSize(NULL, size) will
-## allocate a PyStringObject structure, and a buffer with the specified
+## allocate a PyBytesObject structure, and a buffer with the specified
## size+1, but the reference won't be stored in the global map; there is no
## corresponding object in pypy. When from_ref() or Py_INCREF() is called,
## the pypy string is created, and added to the global map of tracked
## objects. The buffer is then supposed to be immutable.
##
+##- A buffer obtained from PyString_AS_STRING() could be mutable iff
+## there is no corresponding pypy object for the string
+##
## - _PyString_Resize() works only on not-yet-pypy'd strings, and returns a
## similar object.
##
@@ -50,77 +55,73 @@
## corresponds to the pypy gc-managed string.
##
-PyStringObjectStruct = lltype.ForwardReference()
-PyStringObject = lltype.Ptr(PyStringObjectStruct)
-PyStringObjectFields = PyVarObjectFields + \
- (("ob_shash", rffi.LONG), ("ob_sstate", rffi.INT), ("buffer", rffi.CCHARP))
-cpython_struct("PyStringObject", PyStringObjectFields, PyStringObjectStruct)
+PyBytesObjectStruct = lltype.ForwardReference()
+PyBytesObject = lltype.Ptr(PyBytesObjectStruct)
+PyBytesObjectFields = PyVarObjectFields + \
+ (("ob_shash", rffi.LONG), ("ob_sstate", rffi.INT), ("ob_sval", rffi.CArray(lltype.Char)))
+cpython_struct("PyStringObject", PyBytesObjectFields, PyBytesObjectStruct)
@bootstrap_function
-def init_stringobject(space):
- "Type description of PyStringObject"
+def init_bytesobject(space):
+ "Type description of PyBytesObject"
make_typedescr(space.w_str.layout.typedef,
- basestruct=PyStringObject.TO,
- attach=string_attach,
- dealloc=string_dealloc,
- realize=string_realize)
+ basestruct=PyBytesObject.TO,
+ attach=bytes_attach,
+ dealloc=bytes_dealloc,
+ realize=bytes_realize)
PyString_Check, PyString_CheckExact = build_type_checkers("String", "w_str")
def new_empty_str(space, length):
"""
- Allocate a PyStringObject and its buffer, but without a corresponding
- interpreter object. The buffer may be mutated, until string_realize() is
+ Allocate a PyBytesObject and its ob_sval, but without a corresponding
+ interpreter object. The ob_sval may be mutated, until bytes_realize() is
called. Refcount of the result is 1.
"""
typedescr = get_typedescr(space.w_str.layout.typedef)
- py_obj = typedescr.allocate(space, space.w_str)
- py_str = rffi.cast(PyStringObject, py_obj)
-
- buflen = length + 1
- py_str.c_ob_size = length
- py_str.c_buffer = lltype.malloc(rffi.CCHARP.TO, buflen,
- flavor='raw', zero=True,
- add_memory_pressure=True)
+ py_obj = typedescr.allocate(space, space.w_str, length)
+ py_str = rffi.cast(PyBytesObject, py_obj)
+ py_str.c_ob_shash = -1
py_str.c_ob_sstate = rffi.cast(rffi.INT, 0) # SSTATE_NOT_INTERNED
return py_str
-def string_attach(space, py_obj, w_obj):
+def bytes_attach(space, py_obj, w_obj):
"""
- Fills a newly allocated PyStringObject with the given string object. The
- buffer must not be modified.
+ Copy RPython string object contents to a PyBytesObject. The
+ c_ob_sval must not be modified.
"""
- py_str = rffi.cast(PyStringObject, py_obj)
- py_str.c_ob_size = len(space.str_w(w_obj))
- py_str.c_buffer = lltype.nullptr(rffi.CCHARP.TO)
+ py_str = rffi.cast(PyBytesObject, py_obj)
+ s = space.str_w(w_obj)
+ if py_str.c_ob_size < len(s):
+ raise oefmt(space.w_ValueError,
+ "bytes_attach called on object with ob_size %d but trying to store %d",
+ py_str.c_ob_size, len(s))
+ rffi.c_memcpy(py_str.c_ob_sval, rffi.str2charp(s), len(s))
+ py_str.c_ob_sval[len(s)] = '\0'
py_str.c_ob_shash = space.hash_w(w_obj)
py_str.c_ob_sstate = rffi.cast(rffi.INT, 1) # SSTATE_INTERNED_MORTAL
-def string_realize(space, py_obj):
+def bytes_realize(space, py_obj):
"""
- Creates the string in the interpreter. The PyStringObject buffer must not
+ Creates the string in the interpreter. The PyBytesObject ob_sval must not
be modified after this call.
"""
- py_str = rffi.cast(PyStringObject, py_obj)
- if not py_str.c_buffer:
- py_str.c_buffer = lltype.malloc(rffi.CCHARP.TO, py_str.c_ob_size + 1,
- flavor='raw', zero=True)
- s = rffi.charpsize2str(py_str.c_buffer, py_str.c_ob_size)
- w_obj = space.wrap(s)
+ py_str = rffi.cast(PyBytesObject, py_obj)
+ s = rffi.charpsize2str(py_str.c_ob_sval, py_str.c_ob_size)
+ w_type = from_ref(space, rffi.cast(PyObject, py_obj.c_ob_type))
+ w_obj = space.allocate_instance(W_BytesObject, w_type)
+ w_obj.__init__(s)
py_str.c_ob_shash = space.hash_w(w_obj)
py_str.c_ob_sstate = rffi.cast(rffi.INT, 1) # SSTATE_INTERNED_MORTAL
track_reference(space, py_obj, w_obj)
return w_obj
@cpython_api([PyObject], lltype.Void, header=None)
-def string_dealloc(space, py_obj):
- """Frees allocated PyStringObject resources.
+def bytes_dealloc(space, py_obj):
+ """Frees allocated PyBytesObject resources.
"""
- py_str = rffi.cast(PyStringObject, py_obj)
- if py_str.c_buffer:
- lltype.free(py_str.c_buffer, flavor="raw")
- from pypy.module.cpyext.object import PyObject_dealloc
- PyObject_dealloc(space, py_obj)
+ from pypy.module.cpyext.object import _dealloc
+ _dealloc(space, py_obj)
#_______________________________________________________________________
@@ -139,6 +140,9 @@
@cpython_api([PyObject], rffi.CCHARP, error=0)
def PyString_AsString(space, ref):
+ return _PyString_AsString(space, ref)
+
+def _PyString_AsString(space, ref):
if from_ref(space, rffi.cast(PyObject, ref.c_ob_type)) is space.w_str:
pass # typecheck returned "ok" without forcing 'ref' at all
elif not PyString_Check(space, ref): # otherwise, use the alternate way
@@ -150,16 +154,24 @@
raise oefmt(space.w_TypeError,
"expected string or Unicode object, %T found",
from_ref(space, ref))
- ref_str = rffi.cast(PyStringObject, ref)
- if not ref_str.c_buffer:
- # copy string buffer
- w_str = from_ref(space, ref)
- s = space.str_w(w_str)
- ref_str.c_buffer = rffi.str2charp(s)
- return ref_str.c_buffer
+ ref_str = rffi.cast(PyBytesObject, ref)
+ if not pyobj_has_w_obj(ref):
+ # XXX Force the ref?
+ bytes_realize(space, ref)
+ return ref_str.c_ob_sval
+
+ at cpython_api([rffi.VOIDP], rffi.CCHARP, error=0)
+def PyString_AS_STRING(space, void_ref):
+ ref = rffi.cast(PyObject, void_ref)
+ # if no w_str is associated with this ref,
+ # return the c-level ptr as RW
+ if not pyobj_has_w_obj(ref):
+ py_str = rffi.cast(PyBytesObject, ref)
+ return py_str.c_ob_sval
+ return _PyString_AsString(space, ref)
@cpython_api([PyObject, rffi.CCHARPP, rffi.CArrayPtr(Py_ssize_t)], rffi.INT_real, error=-1)
-def PyString_AsStringAndSize(space, ref, buffer, length):
+def PyString_AsStringAndSize(space, ref, data, length):
if not PyString_Check(space, ref):
from pypy.module.cpyext.unicodeobject import (
PyUnicode_Check, _PyUnicode_AsDefaultEncodedString)
@@ -169,18 +181,16 @@
raise oefmt(space.w_TypeError,
"expected string or Unicode object, %T found",
from_ref(space, ref))
- ref_str = rffi.cast(PyStringObject, ref)
- if not ref_str.c_buffer:
- # copy string buffer
- w_str = from_ref(space, ref)
- s = space.str_w(w_str)
- ref_str.c_buffer = rffi.str2charp(s)
- buffer[0] = ref_str.c_buffer
+ if not pyobj_has_w_obj(ref):
+ # force the ref
+ bytes_realize(space, ref)
+ ref_str = rffi.cast(PyBytesObject, ref)
+ data[0] = ref_str.c_ob_sval
if length:
length[0] = ref_str.c_ob_size
else:
i = 0
- while ref_str.c_buffer[i] != '\0':
+ while ref_str.c_ob_sval[i] != '\0':
i += 1
if i != ref_str.c_ob_size:
raise oefmt(space.w_TypeError,
@@ -190,7 +200,7 @@
@cpython_api([PyObject], Py_ssize_t, error=-1)
def PyString_Size(space, ref):
if from_ref(space, rffi.cast(PyObject, ref.c_ob_type)) is space.w_str:
- ref = rffi.cast(PyStringObject, ref)
+ ref = rffi.cast(PyBytesObject, ref)
return ref.c_ob_size
else:
w_obj = from_ref(space, ref)
@@ -209,10 +219,10 @@
set to NULL, a memory exception is set, and -1 is returned.
"""
# XXX always create a new string so far
- py_str = rffi.cast(PyStringObject, ref[0])
- if not py_str.c_buffer:
+ if pyobj_has_w_obj(ref[0]):
raise oefmt(space.w_SystemError,
"_PyString_Resize called on already created string")
+ py_str = rffi.cast(PyBytesObject, ref[0])
try:
py_newstr = new_empty_str(space, newsize)
except MemoryError:
@@ -224,7 +234,7 @@
if oldsize < newsize:
to_cp = oldsize
for i in range(to_cp):
- py_newstr.c_buffer[i] = py_str.c_buffer[i]
+ py_newstr.c_ob_sval[i] = py_str.c_ob_sval[i]
Py_DecRef(space, ref[0])
ref[0] = rffi.cast(PyObject, py_newstr)
return 0
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
@@ -13,7 +13,7 @@
"PyCompilerFlags", (("cf_flags", rffi.INT),))
PyCompilerFlagsPtr = lltype.Ptr(PyCompilerFlags)
-PyCF_MASK = (consts.CO_FUTURE_DIVISION |
+PyCF_MASK = (consts.CO_FUTURE_DIVISION |
consts.CO_FUTURE_ABSOLUTE_IMPORT |
consts.CO_FUTURE_WITH_STATEMENT |
consts.CO_FUTURE_PRINT_FUNCTION |
@@ -94,7 +94,7 @@
Py_eval_input = 258
def compile_string(space, source, filename, start, flags=0):
- w_source = space.wrap(source)
+ w_source = space.newbytes(source)
start = rffi.cast(lltype.Signed, start)
if start == Py_file_input:
mode = 'exec'
@@ -227,4 +227,4 @@
cf.c_cf_flags = rffi.cast(rffi.INT, flags)
return result
-
+
diff --git a/pypy/module/cpyext/frameobject.py b/pypy/module/cpyext/frameobject.py
--- a/pypy/module/cpyext/frameobject.py
+++ b/pypy/module/cpyext/frameobject.py
@@ -46,8 +46,8 @@
Py_DecRef(space, py_code)
Py_DecRef(space, py_frame.c_f_globals)
Py_DecRef(space, py_frame.c_f_locals)
- from pypy.module.cpyext.object import PyObject_dealloc
- PyObject_dealloc(space, py_obj)
+ from pypy.module.cpyext.object import _dealloc
+ _dealloc(space, py_obj)
def frame_realize(space, py_obj):
"""
diff --git a/pypy/module/cpyext/funcobject.py b/pypy/module/cpyext/funcobject.py
--- a/pypy/module/cpyext/funcobject.py
+++ b/pypy/module/cpyext/funcobject.py
@@ -60,8 +60,8 @@
def function_dealloc(space, py_obj):
py_func = rffi.cast(PyFunctionObject, py_obj)
Py_DecRef(space, py_func.c_func_name)
- from pypy.module.cpyext.object import PyObject_dealloc
- PyObject_dealloc(space, py_obj)
+ from pypy.module.cpyext.object import _dealloc
+ _dealloc(space, py_obj)
def code_attach(space, py_obj, w_obj):
py_code = rffi.cast(PyCodeObject, py_obj)
@@ -80,8 +80,8 @@
py_code = rffi.cast(PyCodeObject, py_obj)
Py_DecRef(space, py_code.c_co_name)
Py_DecRef(space, py_code.c_co_filename)
- from pypy.module.cpyext.object import PyObject_dealloc
- PyObject_dealloc(space, py_obj)
+ from pypy.module.cpyext.object import _dealloc
+ _dealloc(space, py_obj)
@cpython_api([PyObject], PyObject, result_borrowed=True)
def PyFunction_GetCode(space, w_func):
diff --git a/pypy/module/cpyext/include/_numpypy/numpy/__multiarray_api.h b/pypy/module/cpyext/include/_numpypy/numpy/__multiarray_api.h
--- a/pypy/module/cpyext/include/_numpypy/numpy/__multiarray_api.h
+++ b/pypy/module/cpyext/include/_numpypy/numpy/__multiarray_api.h
@@ -5,7 +5,12 @@
npy_bool obval;
} PyBoolScalarObject;
-static int import_array(){return 0;};
-static int _import_array(){return 0;};
-static int _import_math(){return 0;};
+#if PY_VERSION_HEX >= 0x03000000
+#define NUMPY_IMPORT_ARRAY_RETVAL NULL
+#else
+#define NUMPY_IMPORT_ARRAY_RETVAL
+#endif
+#define import_array() {return NUMPY_IMPORT_ARRAY_RETVAL;}
+
+
diff --git a/pypy/module/cpyext/include/stringobject.h b/pypy/module/cpyext/include/stringobject.h
--- a/pypy/module/cpyext/include/stringobject.h
+++ b/pypy/module/cpyext/include/stringobject.h
@@ -10,7 +10,6 @@
#include <stdarg.h>
#define PyString_GET_SIZE(op) PyString_Size((PyObject*)(op))
-#define PyString_AS_STRING(op) PyString_AsString((PyObject*)(op))
/*
Type PyStringObject represents a character string. An extra zero byte is
reserved at the end to ensure it is zero-terminated, but a size is
@@ -41,12 +40,11 @@
PyObject_VAR_HEAD
long ob_shash;
int ob_sstate;
- char * buffer; /* change the name from cpython so all non-api c access is thwarted */
+ char ob_sval[1];
/* Invariants
- * (not relevant in PyPy, all stringobjects are backed by a pypy object)
- * buffer contains space for 'ob_size+1' elements.
- * buffer[ob_size] == 0.
+ * ob_sval contains space for 'ob_size+1' elements.
+ * ob_sval[ob_size] == 0.
* ob_shash is the hash of the string or -1 if not computed yet.
* ob_sstate != 0 iff the string object is in stringobject.c's
* 'interned' dictionary; in this case the two references
diff --git a/pypy/module/cpyext/include/tupleobject.h b/pypy/module/cpyext/include/tupleobject.h
--- a/pypy/module/cpyext/include/tupleobject.h
+++ b/pypy/module/cpyext/include/tupleobject.h
@@ -8,9 +8,12 @@
#endif
typedef struct {
- PyObject_HEAD
- Py_ssize_t ob_size;
- PyObject **ob_item; /* XXX optimize to ob_item[] */
+ PyObject_VAR_HEAD
+ PyObject *ob_item[1];
+ /* ob_item contains space for 'ob_size' elements.
+ * Items must normally not be NULL, except during construction when
+ * the tuple is not yet visible outside the function that builds it.
+ */
} PyTupleObject;
/* defined in varargswrapper.c */
diff --git a/pypy/module/cpyext/methodobject.py b/pypy/module/cpyext/methodobject.py
--- a/pypy/module/cpyext/methodobject.py
+++ b/pypy/module/cpyext/methodobject.py
@@ -55,8 +55,8 @@
py_func = rffi.cast(PyCFunctionObject, py_obj)
Py_DecRef(space, py_func.c_m_self)
Py_DecRef(space, py_func.c_m_module)
- from pypy.module.cpyext.object import PyObject_dealloc
- PyObject_dealloc(space, py_obj)
+ from pypy.module.cpyext.object import _dealloc
+ _dealloc(space, py_obj)
class W_PyCFunctionObject(W_Root):
diff --git a/pypy/module/cpyext/object.py b/pypy/module/cpyext/object.py
--- a/pypy/module/cpyext/object.py
+++ b/pypy/module/cpyext/object.py
@@ -54,6 +54,9 @@
@cpython_api([PyObject], lltype.Void)
def PyObject_dealloc(space, obj):
+ return _dealloc(space, obj)
+
+def _dealloc(space, obj):
# This frees an object after its refcount dropped to zero, so we
# assert that it is really zero here.
assert obj.c_ob_refcnt == 0
diff --git a/pypy/module/cpyext/pyfile.py b/pypy/module/cpyext/pyfile.py
--- a/pypy/module/cpyext/pyfile.py
+++ b/pypy/module/cpyext/pyfile.py
@@ -23,7 +23,7 @@
try:
w_readline = space.getattr(w_obj, space.wrap('readline'))
except OperationError:
- raise oefmt(space.w_TypeError,
+ raise oefmt(space.w_TypeError,
"argument must be a file, or have a readline() method.")
n = rffi.cast(lltype.Signed, n)
@@ -41,7 +41,7 @@
On success, return a new file object that is opened on the file given by
filename, with a file mode given by mode, where mode has the same
semantics as the standard C routine fopen(). On failure, return NULL."""
- w_filename = space.wrap(rffi.charp2str(filename))
+ w_filename = space.newbytes(rffi.charp2str(filename))
w_mode = space.wrap(rffi.charp2str(mode))
return space.call_method(space.builtin, 'file', w_filename, w_mode)
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
@@ -7,7 +7,7 @@
from pypy.module.cpyext.api import (
cpython_api, bootstrap_function, PyObject, PyObjectP, ADDR,
CANNOT_FAIL, Py_TPFLAGS_HEAPTYPE, PyTypeObjectPtr, is_PyObject,
- INTERPLEVEL_API)
+ INTERPLEVEL_API, PyVarObject)
from pypy.module.cpyext.state import State
from pypy.objspace.std.typeobject import W_TypeObject
from pypy.objspace.std.objectobject import W_ObjectObject
@@ -47,13 +47,16 @@
size = pytype.c_tp_basicsize
else:
size = rffi.sizeof(self.basestruct)
- if itemcount and w_type is not space.w_str:
+ if pytype.c_tp_itemsize:
size += itemcount * pytype.c_tp_itemsize
assert size >= rffi.sizeof(PyObject.TO)
More information about the pypy-commit
mailing list