Author: Richard Plangger <planri...@gmail.com>
Branch: new-jit-log
Changeset: r85570:4c3925486347
Date: 2016-07-05 17:13 +0200
http://bitbucket.org/pypy/pypy/changeset/4c3925486347/
Log: merge default
diff too long, truncating to 2000 out of 5472 lines
diff --git a/dotviewer/graphparse.py b/dotviewer/graphparse.py
--- a/dotviewer/graphparse.py
+++ b/dotviewer/graphparse.py
@@ -85,10 +85,11 @@
pass
def splitline(line, re_word = re.compile(r'[^\s"]\S*|["]["]|["].*?[^\\]["]')):
+ import ast
result = []
for word in re_word.findall(line):
if word.startswith('"'):
- word = eval(word)
+ word = ast.literal_eval(word)
result.append(word)
return result
diff --git a/lib_pypy/datetime.py b/lib_pypy/datetime.py
--- a/lib_pypy/datetime.py
+++ b/lib_pypy/datetime.py
@@ -839,7 +839,7 @@
month = self._month
if day is None:
day = self._day
- return date(year, month, day)
+ return date.__new__(type(self), year, month, day)
# Comparisons of date objects with other.
@@ -1356,7 +1356,8 @@
microsecond = self.microsecond
if tzinfo is True:
tzinfo = self.tzinfo
- return time(hour, minute, second, microsecond, tzinfo)
+ return time.__new__(type(self),
+ hour, minute, second, microsecond, tzinfo)
def __nonzero__(self):
if self.second or self.microsecond:
@@ -1566,8 +1567,9 @@
microsecond = self.microsecond
if tzinfo is True:
tzinfo = self.tzinfo
- return datetime(year, month, day, hour, minute, second, microsecond,
- tzinfo)
+ return datetime.__new__(type(self),
+ year, month, day, hour, minute, second,
+ microsecond, tzinfo)
def astimezone(self, tz):
if not isinstance(tz, tzinfo):
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
@@ -48,3 +48,8 @@
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/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)
-@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
@@ -11,7 +11,7 @@
from pypy.objspace.std.bytesobject import W_BytesObject
##
-## Implementation of PyStringObject
+## Implementation of PyBytesObject
## ================================
##
## The problem
@@ -29,15 +29,15 @@
## Solution
## --------
##
-## PyStringObject contains two additional members: the ob_size and a pointer
to a
+## 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
@@ -55,58 +55,58 @@
## corresponds to the pypy gc-managed string.
##
-PyStringObjectStruct = lltype.ForwardReference()
-PyStringObject = lltype.Ptr(PyStringObjectStruct)
-PyStringObjectFields = PyVarObjectFields + \
+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", PyStringObjectFields, PyStringObjectStruct)
+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 ob_sval, but without a corresponding
- interpreter object. The ob_sval 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, length)
- py_str = rffi.cast(PyStringObject, py_obj)
+ 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):
"""
- Copy RPython string object contents to a PyStringObject. The
+ 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 = rffi.cast(PyBytesObject, py_obj)
s = space.str_w(w_obj)
if py_str.c_ob_size < len(s):
raise oefmt(space.w_ValueError,
- "string_attach called on object with ob_size %d but trying to
store %d",
- py_str.c_ob_size, len(s))
+ "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 ob_sval 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)
+ 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)
@@ -117,11 +117,11 @@
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.
"""
- from pypy.module.cpyext.object import PyObject_dealloc
- PyObject_dealloc(space, py_obj)
+ from pypy.module.cpyext.object import _dealloc
+ _dealloc(space, py_obj)
#_______________________________________________________________________
@@ -154,10 +154,10 @@
raise oefmt(space.w_TypeError,
"expected string or Unicode object, %T found",
from_ref(space, ref))
- ref_str = rffi.cast(PyStringObject, ref)
+ ref_str = rffi.cast(PyBytesObject, ref)
if not pyobj_has_w_obj(ref):
# XXX Force the ref?
- string_realize(space, ref)
+ bytes_realize(space, ref)
return ref_str.c_ob_sval
@cpython_api([rffi.VOIDP], rffi.CCHARP, error=0)
@@ -166,7 +166,7 @@
# 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(PyStringObject, ref)
+ py_str = rffi.cast(PyBytesObject, ref)
return py_str.c_ob_sval
return _PyString_AsString(space, ref)
@@ -183,8 +183,8 @@
from_ref(space, ref))
if not pyobj_has_w_obj(ref):
# force the ref
- string_realize(space, ref)
- ref_str = rffi.cast(PyStringObject, 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
@@ -200,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)
@@ -222,7 +222,7 @@
if pyobj_has_w_obj(ref[0]):
raise oefmt(space.w_SystemError,
"_PyString_Resize called on already created string")
- py_str = rffi.cast(PyStringObject, ref[0])
+ py_str = rffi.cast(PyBytesObject, ref[0])
try:
py_newstr = new_empty_str(space, newsize)
except MemoryError:
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/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
@@ -164,7 +164,7 @@
pytype = rffi.cast(PyTypeObjectPtr, as_pyobj(space, w_type))
typedescr = get_typedescr(w_obj.typedef)
if pytype.c_tp_itemsize != 0:
- itemcount = space.len_w(w_obj) # PyStringObject and subclasses
+ itemcount = space.len_w(w_obj) # PyBytesObject and subclasses
else:
itemcount = 0
py_obj = typedescr.allocate(space, w_type, itemcount=itemcount)
diff --git a/pypy/module/cpyext/pytraceback.py
b/pypy/module/cpyext/pytraceback.py
--- a/pypy/module/cpyext/pytraceback.py
+++ b/pypy/module/cpyext/pytraceback.py
@@ -46,5 +46,5 @@
py_traceback = rffi.cast(PyTracebackObject, py_obj)
Py_DecRef(space, rffi.cast(PyObject, py_traceback.c_tb_next))
Py_DecRef(space, rffi.cast(PyObject, py_traceback.c_tb_frame))
- 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/sliceobject.py
b/pypy/module/cpyext/sliceobject.py
--- a/pypy/module/cpyext/sliceobject.py
+++ b/pypy/module/cpyext/sliceobject.py
@@ -38,14 +38,14 @@
@cpython_api([PyObject], lltype.Void, header=None)
def slice_dealloc(space, py_obj):
- """Frees allocated PyStringObject resources.
+ """Frees allocated PyBytesObject resources.
"""
py_slice = rffi.cast(PySliceObject, py_obj)
Py_DecRef(space, py_slice.c_start)
Py_DecRef(space, py_slice.c_stop)
Py_DecRef(space, py_slice.c_step)
- from pypy.module.cpyext.object import PyObject_dealloc
- PyObject_dealloc(space, py_obj)
+ from pypy.module.cpyext.object import _dealloc
+ _dealloc(space, py_obj)
PySlice_Check, PySlice_CheckExact = build_type_checkers("Slice")
@@ -73,7 +73,7 @@
length length, and store the length of the slice in slicelength. Out
of bounds indices are clipped in a manner consistent with the handling of
normal slices.
-
+
Returns 0 on success and -1 on error with exception set."""
if not PySlice_Check(space, w_slice):
PyErr_BadInternalCall(space)
@@ -88,11 +88,11 @@
"""Retrieve the start, stop and step indices from the slice object slice,
assuming a sequence of length length. Treats indices greater than
length as errors.
-
+
Returns 0 on success and -1 on error with no exception set (unless one of
the indices was not None and failed to be converted to an integer,
in which case -1 is returned with an exception set).
-
+
You probably do not want to use this function. If you want to use slice
objects in versions of Python prior to 2.3, you would probably do well to
incorporate the source of PySlice_GetIndicesEx(), suitably renamed,
diff --git a/pypy/module/cpyext/test/array.c b/pypy/module/cpyext/test/array.c
--- a/pypy/module/cpyext/test/array.c
+++ b/pypy/module/cpyext/test/array.c
@@ -1858,6 +1858,110 @@
}
}
+static PyObject*
+array_multiply(PyObject* obj1, PyObject* obj2)
+{
+ if (PyList_Check(obj1) && ((arrayobject*)obj2)->ob_descr->typecode == 'i'
&& Py_SIZE(obj2) == 1)
+ {
+ int ii, nn;
+ int n = PyList_Size(obj1);
+ PyObject *v = getarrayitem(obj2, 0);
+ int i = ((PyIntObject*)v)->ob_ival;
+ PyObject * ret = PyList_New(n*i);
+ for (ii = 0; ii < i; ii++)
+ for (nn = 0; nn < n; nn++)
+ {
+ v = PyList_GetItem(obj1, nn);
+ PyList_SetItem(ret, nn+ii*n, v);
+ }
+ return ret;
+ }
+ else if (PyList_Check(obj2) && ((arrayobject*)obj1)->ob_descr->typecode ==
'i' && Py_SIZE(obj1) == 1)
+ {
+ int ii, nn;
+ int n = PyList_Size(obj2);
+ PyObject *v = getarrayitem(obj1, 0);
+ int i = ((PyIntObject*)v)->ob_ival;
+ PyObject * ret = PyList_New(n*i);
+ for (ii = 0; ii < i; ii++)
+ for (nn = 0; nn < n; nn++)
+ {
+ v = PyList_GetItem(obj2, nn);
+ PyList_SetItem(ret, nn+ii*n, v);
+ }
+ return ret;
+ }
+ else if(obj1->ob_type == &Arraytype)
+ fprintf(stderr, "\nCannot multiply array of type %c and %s\n",
+ ((arrayobject*)obj1)->ob_descr->typecode, obj2->ob_type->tp_name);
+ else if(obj2->ob_type == &Arraytype)
+ fprintf(stderr, "\nCannot multiply array of type %c and %s\n",
+ ((arrayobject*)obj2)->ob_descr->typecode, obj1->ob_type->tp_name);
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+static PyNumberMethods array_as_number = {
+ (binaryfunc)NULL, /* nb_add*/
+ (binaryfunc)NULL, /* nb_subtract */
+ (binaryfunc)array_multiply, /* nb_multiply */
+ (binaryfunc)NULL, /* nb_divide */
+};
+
+static PyObject*
+array_base_multiply(PyObject* obj1, PyObject* obj2)
+{
+ if (PyList_Check(obj1) && ((arrayobject*)obj2)->ob_descr->typecode == 'i'
&& Py_SIZE(obj2) == 1)
+ {
+ int nn;
+ int n = PyList_Size(obj1);
+ PyObject *v = getarrayitem(obj2, 0);
+ int i = ((PyIntObject*)v)->ob_ival;
+ PyObject * ret = PyList_New(n);
+ for (nn = 0; nn < n; nn++)
+ {
+ v = PyList_GetItem(obj1, nn);
+ if (PyInt_Check(v))
+ PyList_SetItem(ret, nn, PyLong_FromLong(i *
((PyIntObject*)v)->ob_ival));
+ else
+ PyList_SetItem(ret, nn, v);
+ }
+ return ret;
+ }
+ else if (PyList_Check(obj2) && ((arrayobject*)obj1)->ob_descr->typecode ==
'i' && Py_SIZE(obj1) == 1)
+ {
+ int nn;
+ int n = PyList_Size(obj2);
+ PyObject *v = getarrayitem(obj1, 0);
+ int i = ((PyIntObject*)v)->ob_ival;
+ PyObject * ret = PyList_New(n);
+ for (nn = 0; nn < n; nn++)
+ {
+ v = PyList_GetItem(obj2, nn);
+ if (PyInt_Check(v))
+ PyList_SetItem(ret, nn, PyLong_FromLong(i *
((PyIntObject*)v)->ob_ival));
+ else
+ PyList_SetItem(ret, nn, v);
+ }
+ return ret;
+ }
+ else if(obj1->ob_type == &Arraytype)
+ fprintf(stderr, "\nCannot multiply array of type %c and %s\n",
+ ((arrayobject*)obj1)->ob_descr->typecode, obj2->ob_type->tp_name);
+ else if(obj2->ob_type == &Arraytype)
+ fprintf(stderr, "\nCannot multiply array of type %c and %s\n",
+ ((arrayobject*)obj2)->ob_descr->typecode, obj1->ob_type->tp_name);
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+static PyNumberMethods array_base_as_number = {
+ (binaryfunc)NULL, /* nb_add*/
+ (binaryfunc)NULL, /* nb_subtract */
+ (binaryfunc)array_base_multiply, /* nb_multiply */
+ (binaryfunc)NULL, /* nb_divide */
+};
+
static PyMappingMethods array_as_mapping = {
(lenfunc)array_length,
(binaryfunc)array_subscr,
@@ -2106,6 +2210,49 @@
static PyObject *array_iter(arrayobject *ao);
+static PyTypeObject ArrayBasetype = {
+ PyVarObject_HEAD_INIT(NULL, 0)
+ "array.basearray",
+ sizeof(arrayobject),
+ 0,
+ (destructor)array_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ 0, /* tp_compare */
+ (reprfunc)array_repr, /* tp_repr */
_______________________________________________
pypy-commit mailing list
pypy-commit@python.org
https://mail.python.org/mailman/listinfo/pypy-commit
