Author: Armin Rigo <ar...@tunes.org>
Branch: py3.5-newtext
Changeset: r90115:a675735c36bf
Date: 2017-02-14 17:36 +0100
http://bitbucket.org/pypy/pypy/changeset/a675735c36bf/
Log: hg merge c5c3e2fb39a6
diff too long, truncating to 2000 out of 4500 lines
diff --git a/pypy/module/_cffi_backend/allocator.py
b/pypy/module/_cffi_backend/allocator.py
--- a/pypy/module/_cffi_backend/allocator.py
+++ b/pypy/module/_cffi_backend/allocator.py
@@ -27,7 +27,7 @@
return cdataobj.W_CDataNewStd(space, ptr, ctype, length)
else:
w_raw_cdata = space.call_function(self.w_alloc,
- space.wrap(datasize))
+ space.newint(datasize))
if not isinstance(w_raw_cdata, cdataobj.W_CData):
raise oefmt(space.w_TypeError,
"alloc() must return a cdata object (got %T)",
@@ -76,7 +76,7 @@
if w_alloc is None and w_free is not None:
raise oefmt(space.w_TypeError, "cannot pass 'free' without 'alloc'")
alloc = W_Allocator(ffi, w_alloc, w_free, bool(should_clear_after_alloc))
- return space.wrap(alloc)
+ return alloc
default_allocator = W_Allocator(None, None, None,
should_clear_after_alloc=True)
diff --git a/pypy/module/_cffi_backend/call_python.py
b/pypy/module/_cffi_backend/call_python.py
--- a/pypy/module/_cffi_backend/call_python.py
+++ b/pypy/module/_cffi_backend/call_python.py
@@ -90,7 +90,7 @@
ffi = space.interp_w(W_FFIObject, w_ffi)
if space.is_w(w_name, space.w_None):
- w_name = space.getattr(w_python_callable, space.wrap('__name__'))
+ w_name = space.getattr(w_python_callable, space.newtext('__name__'))
name = space.str_w(w_name)
ctx = ffi.ctxobj.ctx
@@ -130,4 +130,4 @@
@specialize.memo()
def get_generic_decorator(space):
- return space.wrap(interp2app(externpy_deco))
+ return space.wrap(interp2app(externpy_deco)) # init time
diff --git a/pypy/module/_cffi_backend/cdataobj.py
b/pypy/module/_cffi_backend/cdataobj.py
--- a/pypy/module/_cffi_backend/cdataobj.py
+++ b/pypy/module/_cffi_backend/cdataobj.py
@@ -58,21 +58,21 @@
def repr(self):
extra2 = self._repr_extra()
- extra1 = u''
+ extra1 = ''
if not isinstance(self, W_CDataNewOwning):
# it's slightly confusing to get "<cdata 'struct foo' 0x...>"
# because the struct foo is not owned. Trying to make it
# clearer, write in this case "<cdata 'struct foo &' 0x...>".
from pypy.module._cffi_backend import ctypestruct
if isinstance(self.ctype, ctypestruct.W_CTypeStructOrUnion):
- extra1 = u' &'
- return self.space.wrap(u"<cdata '%s%s' %s>" % (
- self.ctype.name.decode('utf-8'), extra1, extra2.decode('utf-8')))
+ extra1 = ' &'
+ return self.space.newtext("<cdata '%s%s' %s>" % (
+ self.ctype.name, extra1, extra2))
def bool(self):
with self as ptr:
nonzero = self.ctype.nonzero(ptr)
- return self.space.wrap(nonzero)
+ return self.space.newbool(nonzero)
def int(self, space):
with self as ptr:
@@ -95,7 +95,7 @@
from pypy.module._cffi_backend import ctypearray
space = self.space
if isinstance(self.ctype, ctypearray.W_CTypeArray):
- return space.wrap(self.get_array_length())
+ return space.newint(self.get_array_length())
raise oefmt(space.w_TypeError,
"cdata of type '%s' has no len()", self.ctype.name)
@@ -137,7 +137,7 @@
# alignment (to 4, 8, maybe 16 bytes), so we use the following
# formula to avoid the trailing bits being always 0.
h = h ^ (h >> 4)
- return self.space.wrap(h)
+ return self.space.newint(h)
def getitem(self, w_index):
space = self.space
@@ -319,7 +319,7 @@
"pointer subtraction: the distance between the two "
"pointers is not a multiple of the item size")
diff //= itemsize
- return space.wrap(diff)
+ return space.newint(diff)
#
return self._add_or_sub(w_other, -1)
@@ -441,7 +441,7 @@
if isinstance(ct, W_CTypePointer):
ct = ct.ctitem
lst = ct.cdata_dir()
- return space.newlist([space.wrap(s) for s in lst])
+ return space.newlist([space.newtext(s) for s in lst])
def get_structobj(self):
return None
diff --git a/pypy/module/_cffi_backend/cerrno.py
b/pypy/module/_cffi_backend/cerrno.py
--- a/pypy/module/_cffi_backend/cerrno.py
+++ b/pypy/module/_cffi_backend/cerrno.py
@@ -13,7 +13,7 @@
_errno_after = rposix._errno_after
def get_errno(space):
- return space.wrap(rposix.get_saved_alterrno())
+ return space.newint(rposix.get_saved_alterrno())
@unwrap_spec(errno=int)
def set_errno(space, errno):
@@ -27,4 +27,4 @@
if code == -1:
code = GetLastError_alt_saved()
message = FormatError(code)
- return space.newtuple([space.wrap(code), space.wrap(message)])
+ return space.newtuple([space.newint(code), space.newtext(message)])
diff --git a/pypy/module/_cffi_backend/cffi1_module.py
b/pypy/module/_cffi_backend/cffi1_module.py
--- a/pypy/module/_cffi_backend/cffi1_module.py
+++ b/pypy/module/_cffi_backend/cffi1_module.py
@@ -39,12 +39,12 @@
if src_ctx.c_includes:
lib.make_includes_from(src_ctx.c_includes)
- w_name = space.wrap(name)
+ w_name = space.newtext(name)
module = Module(space, w_name)
if path is not None:
module.setdictvalue(space, '__file__', space.wrap_fsdecoded(path))
- module.setdictvalue(space, 'ffi', space.wrap(ffi))
- module.setdictvalue(space, 'lib', space.wrap(lib))
+ module.setdictvalue(space, 'ffi', ffi)
+ module.setdictvalue(space, 'lib', lib)
w_modules_dict = space.sys.get('modules')
- space.setitem(w_modules_dict, w_name, space.wrap(module))
- space.setitem(w_modules_dict, space.wrap(name + '.lib'), space.wrap(lib))
+ space.setitem(w_modules_dict, w_name, space.newtext(module))
+ space.setitem(w_modules_dict, space.newtext(name + '.lib'),
space.newtext(lib))
diff --git a/pypy/module/_cffi_backend/ctypearray.py
b/pypy/module/_cffi_backend/ctypearray.py
--- a/pypy/module/_cffi_backend/ctypearray.py
+++ b/pypy/module/_cffi_backend/ctypearray.py
@@ -100,7 +100,7 @@
return self.space.wrap(self.ctitem)
if attrchar == 'l': # length
if self.length >= 0:
- return self.space.wrap(self.length)
+ return self.space.newint(self.length)
else:
return self.space.w_None
return W_CTypePtrOrArray._fget(self, attrchar)
@@ -121,7 +121,7 @@
self._stop = rffi.ptradd(self._next, length * ctitem.size)
def iter_w(self):
- return self.space.wrap(self)
+ return self
def next_w(self):
result = self._next
diff --git a/pypy/module/_cffi_backend/ctypefunc.py
b/pypy/module/_cffi_backend/ctypefunc.py
--- a/pypy/module/_cffi_backend/ctypefunc.py
+++ b/pypy/module/_cffi_backend/ctypefunc.py
@@ -120,11 +120,11 @@
return self.space.newtuple([self.space.wrap(a)
for a in self.fargs])
if attrchar == 'r': # result
- return self.space.wrap(self.ctitem)
+ return self.ctitem
if attrchar == 'E': # ellipsis
return self.space.wrap(self.ellipsis)
if attrchar == 'A': # abi
- return self.space.wrap(self.abi)
+ return self.space.newint(self.abi)
return W_CTypePtrBase._fget(self, attrchar)
def call(self, funcaddr, args_w):
diff --git a/pypy/module/_cffi_backend/ctypeobj.py
b/pypy/module/_cffi_backend/ctypeobj.py
--- a/pypy/module/_cffi_backend/ctypeobj.py
+++ b/pypy/module/_cffi_backend/ctypeobj.py
@@ -34,7 +34,7 @@
def repr(self):
space = self.space
- return space.wrap("<ctype '%s'>" % (self.name,))
+ return space.newtext("<ctype '%s'>" % (self.name,))
def extra_repr(self, cdata):
if cdata:
@@ -229,17 +229,17 @@
# __________ app-level attributes __________
def dir(self):
space = self.space
- lst = [space.wrap(name)
+ lst = [space.newtext(name)
for name in _name_of_attributes
- if space.findattr(self, space.wrap(name)) is not None]
+ if space.findattr(self, space.newtext(name)) is not None]
return space.newlist(lst)
def _fget(self, attrchar):
space = self.space
if attrchar == 'k': # kind
- return space.wrap(self.kind) # class attribute
+ return space.newtext(self.kind) # class attribute
if attrchar == 'c': # cname
- return space.wrap(self.name)
+ return space.newtext(self.name)
raise oefmt(space.w_AttributeError,
"ctype '%s' has no such attribute", self.name)
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
@@ -122,7 +122,7 @@
_attrs_ = []
def cast_to_int(self, cdata):
- return self.space.wrap(ord(cdata[0]))
+ return self.space.newint(ord(cdata[0]))
def convert_to_object(self, cdata):
return self.space.newbytes(cdata[0])
@@ -166,11 +166,11 @@
def cast_to_int(self, cdata):
unichardata = rffi.cast(WCHAR_INTP, cdata)
- return self.space.wrap(unichardata[0])
+ return self.space.newint(unichardata[0])
def convert_to_object(self, cdata):
unichardata = rffi.cast(rffi.CWCHARP, cdata)
- return self.space.wrap(unichardata[0])
+ return self.space.newunicode(unichardata[0])
def string(self, cdataobj, maxlen):
with cdataobj as ptr:
@@ -195,7 +195,7 @@
def unpack_ptr(self, w_ctypeptr, ptr, length):
u = rffi.wcharpsize2unicode(rffi.cast(rffi.CWCHARP, ptr), length)
- return self.space.wrap(u)
+ return self.space.newunicode(u)
class W_CTypePrimitiveSigned(W_CTypePrimitive):
@@ -214,14 +214,14 @@
def convert_to_object(self, cdata):
if self.value_fits_long:
value = misc.read_raw_long_data(cdata, self.size)
- return self.space.wrap(value)
+ return self.space.newint(value)
else:
return self._convert_to_object_longlong(cdata)
def _convert_to_object_longlong(self, cdata):
# in its own function: LONGLONG may make the whole function jit-opaque
value = misc.read_raw_signed_data(cdata, self.size)
- return self.space.wrap(value) # r_longlong => on 32-bit, 'long'
+ return self.space.newint(value) # r_longlong => on 32-bit, 'long'
def convert_from_object(self, cdata, w_ob):
if self.value_fits_long:
@@ -271,7 +271,7 @@
overflowed = misc.pack_list_to_raw_array_bounds_signed(
int_list, cdata, self.size)
if overflowed != 0:
- self._overflow(self.space.wrap(overflowed))
+ self._overflow(self.space.newint(overflowed))
return True
return W_CTypePrimitive.pack_list_of_items(self, cdata, w_ob)
@@ -316,16 +316,16 @@
if self.value_fits_ulong:
value = misc.read_raw_ulong_data(cdata, self.size)
if self.value_fits_long:
- return self.space.wrap(intmask(value))
+ return self.space.newint(intmask(value))
else:
- return self.space.wrap(value) # r_uint => 'long' object
+ return self.space.newint(value) # r_uint => 'long' object
else:
return self._convert_to_object_longlong(cdata)
def _convert_to_object_longlong(self, cdata):
# in its own function: LONGLONG may make the whole function jit-opaque
value = misc.read_raw_unsigned_data(cdata, self.size)
- return self.space.wrap(value) # r_ulonglong => 'long' object
+ return self.space.newint(value) # r_ulonglong => 'long' object
def get_vararg_type(self):
if self.size < rffi.sizeof(rffi.INT):
@@ -349,7 +349,7 @@
overflowed = misc.pack_list_to_raw_array_bounds_unsigned(
int_list, cdata, self.size, self.vrangemax)
if overflowed != 0:
- self._overflow(self.space.wrap(overflowed))
+ self._overflow(self.space.newint(overflowed))
return True
return W_CTypePrimitive.pack_list_of_items(self, cdata, w_ob)
@@ -419,7 +419,7 @@
def convert_to_object(self, cdata):
value = misc.read_raw_float_data(cdata, self.size)
- return self.space.wrap(value)
+ return self.space.newfloat(value)
def convert_from_object(self, cdata, w_ob):
space = self.space
@@ -499,7 +499,7 @@
def float(self, cdata):
value = self._read_from_longdouble(cdata)
- return self.space.wrap(value)
+ return self.space.newfloat(value)
def convert_to_object(self, cdata):
w_cdata = cdataobj.W_CDataMem(self.space, self)
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
@@ -176,7 +176,7 @@
"will be forbidden in the future (check that the types "
"are as you expect; use an explicit ffi.cast() if they "
"are correct)" % (other.name, self.name))
- space.warn(space.wrap(msg), space.w_UserWarning)
+ space.warn(space.newtext(msg), space.w_UserWarning)
else:
raise self._convert_error("compatible pointer", w_ob)
@@ -385,7 +385,7 @@
def _fget(self, attrchar):
if attrchar == 'i': # item
- return self.space.wrap(self.ctitem)
+ return self.ctitem
return W_CTypePtrBase._fget(self, attrchar)
# ____________________________________________________________
diff --git a/pypy/module/_cffi_backend/ctypestruct.py
b/pypy/module/_cffi_backend/ctypestruct.py
--- a/pypy/module/_cffi_backend/ctypestruct.py
+++ b/pypy/module/_cffi_backend/ctypestruct.py
@@ -70,8 +70,8 @@
result = [None] * len(self._fields_list)
for fname, field in self._fields_dict.iteritems():
i = self._fields_list.index(field)
- result[i] = space.newtuple([space.wrap(fname),
- space.wrap(field)])
+ result[i] = space.newtuple([space.newtext(fname),
+ field])
return space.newlist(result)
return W_CType._fget(self, attrchar)
@@ -93,7 +93,7 @@
try:
cfield = self._getcfield_const(fieldname)
except KeyError:
- raise OperationError(space.w_KeyError, space.wrap(fieldname))
+ raise OperationError(space.w_KeyError, space.newtext(fieldname))
if cfield.bitshift >= 0:
raise oefmt(space.w_TypeError, "not supported for bitfields")
return (cfield.ctype, cfield.offset)
@@ -280,14 +280,14 @@
shiftforsign = r_uint(1) << (self.bitsize - 1)
value = ((value >> self.bitshift) + shiftforsign) & valuemask
result = intmask(value) - intmask(shiftforsign)
- return space.wrap(result)
+ return space.newint(result)
else:
value = misc.read_raw_unsigned_data(cdata, ctype.size)
valuemask = (r_ulonglong(1) << self.bitsize) - 1
shiftforsign = r_ulonglong(1) << (self.bitsize - 1)
value = ((value >> self.bitshift) + shiftforsign) & valuemask
result = r_longlong(value) - r_longlong(shiftforsign)
- return space.wrap(result)
+ return space.newint(result)
#
if isinstance(ctype, ctypeprim.W_CTypePrimitiveUnsigned):
value_fits_long = ctype.value_fits_long
@@ -303,14 +303,14 @@
valuemask = (r_uint(1) << self.bitsize) - 1
value = (value >> self.bitshift) & valuemask
if value_fits_long:
- return space.wrap(intmask(value))
+ return space.newint(intmask(value))
else:
- return space.wrap(value) # uint => wrapped long object
+ return space.newint(value) # uint => wrapped long object
else:
value = misc.read_raw_unsigned_data(cdata, ctype.size)
valuemask = (r_ulonglong(1) << self.bitsize) - 1
value = (value >> self.bitshift) & valuemask
- return space.wrap(value) # ulonglong => wrapped long object
+ return space.newint(value) # ulonglong => wrapped long object
def convert_bitfield_from_object(self, cdata, w_ob):
ctype = self.ctype
diff --git a/pypy/module/_cffi_backend/embedding.py
b/pypy/module/_cffi_backend/embedding.py
--- a/pypy/module/_cffi_backend/embedding.py
+++ b/pypy/module/_cffi_backend/embedding.py
@@ -38,7 +38,7 @@
compiler = space.createcompiler()
pycode = compiler.compile(code, "<init code for '%s'>" % name, 'exec', 0)
w_globals = space.newdict(module=True)
- space.setitem_str(w_globals, "__builtins__", space.wrap(space.builtin))
+ space.setitem_str(w_globals, "__builtins__", space.builtin)
pycode.exec_code(space, w_globals, w_globals)
diff --git a/pypy/module/_cffi_backend/func.py
b/pypy/module/_cffi_backend/func.py
--- a/pypy/module/_cffi_backend/func.py
+++ b/pypy/module/_cffi_backend/func.py
@@ -46,17 +46,17 @@
"ctype '%s' is of unknown size", w_obj.name)
else:
raise oefmt(space.w_TypeError, "expected a 'cdata' or 'ctype' object")
- return space.wrap(size)
+ return space.newint(size)
@unwrap_spec(w_ctype=ctypeobj.W_CType)
def alignof(space, w_ctype):
align = w_ctype.alignof()
- return space.wrap(align)
+ return space.newint(align)
@unwrap_spec(w_ctype=ctypeobj.W_CType, following=int)
def typeoffsetof(space, w_ctype, w_field_or_index, following=0):
ctype, offset = w_ctype.direct_typeoffsetof(w_field_or_index, following)
- return space.newtuple([space.wrap(ctype), space.wrap(offset)])
+ return space.newtuple([space.wrap(ctype), space.newint(offset)])
@unwrap_spec(w_ctype=ctypeobj.W_CType, w_cdata=cdataobj.W_CData, offset=int)
def rawaddressof(space, w_ctype, w_cdata, offset):
@@ -68,7 +68,7 @@
def getcname(space, w_ctype, replace_with):
p = w_ctype.name_position
s = '%s%s%s' % (w_ctype.name[:p], replace_with, w_ctype.name[p:])
- return space.wrap(s)
+ return space.newtext(s)
# ____________________________________________________________
diff --git a/pypy/module/_cffi_backend/lib_obj.py
b/pypy/module/_cffi_backend/lib_obj.py
--- a/pypy/module/_cffi_backend/lib_obj.py
+++ b/pypy/module/_cffi_backend/lib_obj.py
@@ -26,7 +26,7 @@
self.libname = libname # some string that gives the name of the lib
def descr_repr(self):
- return self.space.wrap("<Lib object for '%s'>" % self.libname)
+ return self.space.newtext("<Lib object for '%s'>" % self.libname)
def make_includes_from(self, c_includes):
space = self.space
@@ -35,7 +35,7 @@
while c_includes[num]:
include_name = rffi.charp2str(c_includes[num])
try:
- w_lib1 = space.appexec([space.wrap(include_name)],
"""(modname):
+ w_lib1 = space.appexec([space.newtext(include_name)],
"""(modname):
mod = __import__(modname, None, None, ['ffi', 'lib'])
return mod.lib""")
lib1 = space.interp_w(W_LibObject, w_lib1)
@@ -185,7 +185,7 @@
return w_result
def _get_attr(self, w_attr, is_getattr=False):
- attr = self.space.str_w(w_attr)
+ attr = self.space.text_w(w_attr)
try:
w_value = self._get_attr_elidable(attr)
except KeyError:
@@ -202,7 +202,7 @@
from pypy.interpreter.module import Module
return self.space.gettypeobject(Module.typedef)
if is_getattr and attr == '__name__':
- return self.space.wrap("%s.lib" % self.libname)
+ return self.space.newtext("%s.lib" % self.libname)
raise oefmt(self.space.w_AttributeError,
"cffi library '%s' has no function, constant "
"or global variable named '%s'",
diff --git a/pypy/module/_cffi_backend/libraryobj.py
b/pypy/module/_cffi_backend/libraryobj.py
--- a/pypy/module/_cffi_backend/libraryobj.py
+++ b/pypy/module/_cffi_backend/libraryobj.py
@@ -36,7 +36,7 @@
def repr(self):
space = self.space
- return space.wrap("<clibrary '%s'>" % self.name)
+ return space.newtext("<clibrary '%s'>" % self.name)
@unwrap_spec(w_ctype=W_CType, name=str)
def load_function(self, w_ctype, name):
@@ -94,4 +94,4 @@
@unwrap_spec(filename="str_or_None", flags=int)
def load_library(space, filename, flags=0):
lib = W_Library(space, filename, flags)
- return space.wrap(lib)
+ return lib
diff --git a/pypy/module/_cffi_backend/misc.py
b/pypy/module/_cffi_backend/misc.py
--- a/pypy/module/_cffi_backend/misc.py
+++ b/pypy/module/_cffi_backend/misc.py
@@ -147,7 +147,7 @@
try:
return bigint.tolonglong()
except OverflowError:
- raise OperationError(space.w_OverflowError, space.wrap(ovf_msg))
+ raise OperationError(space.w_OverflowError, space.newtext(ovf_msg))
def as_long(space, w_ob):
# Same as as_long_long(), but returning an int instead.
@@ -164,7 +164,7 @@
try:
return bigint.toint()
except OverflowError:
- raise OperationError(space.w_OverflowError, space.wrap(ovf_msg))
+ raise OperationError(space.w_OverflowError, space.newtext(ovf_msg))
def as_unsigned_long_long(space, w_ob, strict):
# (possibly) convert and cast a Python object to an unsigned long long.
@@ -179,7 +179,7 @@
raise
else:
if strict and value < 0:
- raise OperationError(space.w_OverflowError, space.wrap(neg_msg))
+ raise OperationError(space.w_OverflowError, space.newtext(neg_msg))
return r_ulonglong(value)
try:
bigint = space.bigint_w(w_ob, allow_conversion=False)
@@ -193,9 +193,9 @@
try:
return bigint.toulonglong()
except ValueError:
- raise OperationError(space.w_OverflowError, space.wrap(neg_msg))
+ raise OperationError(space.w_OverflowError, space.newtext(neg_msg))
except OverflowError:
- raise OperationError(space.w_OverflowError, space.wrap(ovf_msg))
+ raise OperationError(space.w_OverflowError, space.newtext(ovf_msg))
else:
return bigint.ulonglongmask()
@@ -213,9 +213,9 @@
try:
return bigint.touint()
except ValueError:
- raise OperationError(space.w_OverflowError, space.wrap(neg_msg))
+ raise OperationError(space.w_OverflowError, space.newtext(neg_msg))
except OverflowError:
- raise OperationError(space.w_OverflowError, space.wrap(ovf_msg))
+ raise OperationError(space.w_OverflowError, space.newtext(ovf_msg))
else:
return bigint.uintmask()
diff --git a/pypy/module/_cffi_backend/newtype.py
b/pypy/module/_cffi_backend/newtype.py
--- a/pypy/module/_cffi_backend/newtype.py
+++ b/pypy/module/_cffi_backend/newtype.py
@@ -167,7 +167,7 @@
try:
ctypecls, size, align = PRIMITIVE_TYPES[name]
except KeyError:
- raise OperationError(space.w_KeyError, space.wrap(name))
+ raise OperationError(space.w_KeyError, space.newtext(name))
ctype = ctypecls(space, size, name, len(name), align)
unique_cache.primitives[name] = ctype
return ctype
diff --git a/pypy/module/_cffi_backend/realize_c_type.py
b/pypy/module/_cffi_backend/realize_c_type.py
--- a/pypy/module/_cffi_backend/realize_c_type.py
+++ b/pypy/module/_cffi_backend/realize_c_type.py
@@ -131,15 +131,15 @@
if neg == 0: # positive
if value <= rffi.cast(rffi.ULONGLONG, sys.maxint):
- return ffi.space.wrap(intmask(value))
+ return ffi.space.newint(intmask(value))
else:
- return ffi.space.wrap(value)
+ return ffi.space.newint(value)
elif neg == 1: # negative
value = rffi.cast(rffi.LONGLONG, value)
if value >= -sys.maxint-1:
- return ffi.space.wrap(intmask(value))
+ return ffi.space.newint(intmask(value))
else:
- return ffi.space.wrap(value)
+ return ffi.space.newint(value)
if neg == 2:
got = "%d (0x%x)" % (value, value)
@@ -364,7 +364,7 @@
while p[j] != ',' and p[j] != '\x00':
j += 1
enname = rffi.charpsize2str(p, j)
- enumerators_w.append(space.wrap(enname))
+ enumerators_w.append(space.newtext(enname))
gindex = parse_c_type.search_in_globals(ffi.ctxobj.ctx, enname)
assert gindex >= 0
@@ -493,10 +493,10 @@
field_name, "'")
fields_w[i] = space.newtuple([
- space.wrap(field_name),
+ space.newtext(field_name),
w_ctf,
- space.wrap(fbitsize),
- space.wrap(field_offset)])
+ space.newint(fbitsize),
+ space.newint(field_offset)])
sflags = 0
c_flags = rffi.getintfield(s, 'c_flags')
diff --git a/pypy/module/_cffi_backend/test/_backend_test_c.py
b/pypy/module/_cffi_backend/test/_backend_test_c.py
--- a/pypy/module/_cffi_backend/test/_backend_test_c.py
+++ b/pypy/module/_cffi_backend/test/_backend_test_c.py
@@ -1254,20 +1254,6 @@
orig_getline = linecache.getline
try:
linecache.getline = lambda *args: 'LINE' # hack: speed up PyPy tests
- sys.stderr = cStringIO.StringIO()
- assert f(100) == 300
- assert sys.stderr.getvalue() == ''
- assert f(10000) == -42
- assert matches(sys.stderr.getvalue(), """\
-From cffi callback <function$Zcb1 at 0x$>:
-Traceback (most recent call last):
- File "$", line $, in Zcb1
- $
- File "$", line $, in check_value
- $
-ValueError: 42
-""")
- sys.stderr = cStringIO.StringIO()
bigvalue = 20000
assert f(bigvalue) == -42
assert matches(sys.stderr.getvalue(), """\
@@ -1275,59 +1261,6 @@
Trying to convert the result back to C:
OverflowError: integer 60000 does not fit 'short'
""")
- sys.stderr = cStringIO.StringIO()
- bigvalue = 20000
- assert len(seen) == 0
- assert ff(bigvalue) == -42
- assert sys.stderr.getvalue() == ""
- assert len(seen) == 1
- exc, val, tb = seen[0]
- assert exc is OverflowError
- assert str(val) == "integer 60000 does not fit 'short'"
- #
- sys.stderr = cStringIO.StringIO()
- bigvalue = 20000
- del seen[:]
- oops_result = 81
- assert ff(bigvalue) == 81
- oops_result = None
- assert sys.stderr.getvalue() == ""
- assert len(seen) == 1
- exc, val, tb = seen[0]
- assert exc is OverflowError
- assert str(val) == "integer 60000 does not fit 'short'"
- #
- sys.stderr = cStringIO.StringIO()
- bigvalue = 20000
- del seen[:]
- oops_result = "xy" # not None and not an int!
- assert ff(bigvalue) == -42
- oops_result = None
- assert matches(sys.stderr.getvalue(), """\
-From cffi callback <function$Zcb1 at 0x$>:
-Trying to convert the result back to C:
-OverflowError: integer 60000 does not fit 'short'
-
-During the call to 'onerror', another exception occurred:
-
-TypeError: $integer$
-""")
- #
- sys.stderr = cStringIO.StringIO()
- seen = "not a list" # this makes the oops() function crash
- assert ff(bigvalue) == -42
- assert matches(sys.stderr.getvalue(), """\
-From cffi callback <function$Zcb1 at 0x$>:
-Trying to convert the result back to C:
-OverflowError: integer 60000 does not fit 'short'
-
-During the call to 'onerror', another exception occurred:
-
-Traceback (most recent call last):
- File "$", line $, in oops
- $
-AttributeError: 'str' object has no attribute 'append'
-""")
finally:
sys.stderr = orig_stderr
linecache.getline = orig_getline
diff --git a/pypy/module/_cffi_backend/wrapper.py
b/pypy/module/_cffi_backend/wrapper.py
--- a/pypy/module/_cffi_backend/wrapper.py
+++ b/pypy/module/_cffi_backend/wrapper.py
@@ -93,12 +93,12 @@
def descr_repr(self, space):
doc = self.rawfunctype.repr_fn_type(self.ffi, self.fnname)
- return space.wrap("<FFIFunctionWrapper '%s'>" % (doc,))
+ return space.newtext("<FFIFunctionWrapper '%s'>" % (doc,))
def descr_get_doc(self, space):
doc = self.rawfunctype.repr_fn_type(self.ffi, self.fnname)
doc = '%s;\n\nCFFI C function from %s.lib' % (doc, self.modulename)
- return space.wrap(doc)
+ return space.newtext(doc)
def descr_get(self, space, w_obj, w_type=None):
# never bind anything, but a __get__ is still present so that
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
@@ -743,7 +743,7 @@
res, consumed, byteorder = runicode.str_decode_utf_16_helper(
data, len(data), errors, final, state.decode_error_handler, byteorder)
return space.newtuple([space.newunicode(res), space.newint(consumed),
- space.newtext(byteorder)])
+ space.newint(byteorder)])
@unwrap_spec(data='bufferstr', errors='str_or_None', byteorder=int,
w_final=WrappedDefault(False))
@@ -762,7 +762,7 @@
res, consumed, byteorder = runicode.str_decode_utf_32_helper(
data, len(data), errors, final, state.decode_error_handler, byteorder)
return space.newtuple([space.newunicode(res), space.newint(consumed),
- space.newtext(byteorder)])
+ space.newint(byteorder)])
# ____________________________________________________________
# Charmap
diff --git a/pypy/module/_csv/interp_csv.py b/pypy/module/_csv/interp_csv.py
--- a/pypy/module/_csv/interp_csv.py
+++ b/pypy/module/_csv/interp_csv.py
@@ -22,7 +22,7 @@
]
def _fetch(space, w_dialect, name):
- return space.findattr(w_dialect, space.wrap(name))
+ return space.findattr(w_dialect, space.newtext(name))
def _get_bool(space, w_src, default):
if w_src is None:
@@ -134,7 +134,7 @@
w_escapechar, w_lineterminator, w_quotechar,
w_quoting, w_skipinitialspace, w_strict)
if space.is_w(w_subtype, space.gettypeobject(W_Dialect.typedef)):
- return space.wrap(dialect)
+ return dialect
else:
subdialect = space.allocate_instance(W_Dialect, w_subtype)
subdialect.delimiter = dialect.delimiter
@@ -145,18 +145,18 @@
subdialect.quoting = dialect.quoting
subdialect.skipinitialspace = dialect.skipinitialspace
subdialect.strict = dialect.strict
- return space.wrap(subdialect)
+ return subdialect
def _get_escapechar(space, dialect):
if dialect.escapechar == u'\0':
return space.w_None
- return space.wrap(dialect.escapechar)
+ return space.newtext(dialect.escapechar)
def _get_quotechar(space, dialect):
if dialect.quotechar == u'\0':
return space.w_None
- return space.wrap(dialect.quotechar)
+ return space.newtext(dialect.quotechar)
W_Dialect.typedef = TypeDef(
diff --git a/pypy/module/_csv/interp_writer.py
b/pypy/module/_csv/interp_writer.py
--- a/pypy/module/_csv/interp_writer.py
+++ b/pypy/module/_csv/interp_writer.py
@@ -13,7 +13,7 @@
def __init__(self, space, dialect, w_fileobj):
self.space = space
self.dialect = dialect
- self.w_filewrite = space.getattr(w_fileobj, space.wrap('write'))
+ self.w_filewrite = space.getattr(w_fileobj, space.newtext('write'))
# precompute this
special = dialect.delimiter + dialect.lineterminator
if dialect.escapechar != '\0':
@@ -26,8 +26,8 @@
def error(self, msg):
space = self.space
w_module = space.getbuiltinmodule('_csv')
- w_error = space.getattr(w_module, space.wrap('Error'))
- raise OperationError(w_error, space.wrap(msg))
+ w_error = space.getattr(w_module, space.newtext('Error'))
+ raise OperationError(w_error, space.newtext(msg))
def writerow(self, w_fields):
"""Construct and write a CSV record from a sequence of fields.
@@ -115,7 +115,7 @@
rec.append(dialect.lineterminator)
line = rec.build()
- return space.call_function(self.w_filewrite, space.wrap(line))
+ return space.call_function(self.w_filewrite, space.newtext(line))
def writerows(self, w_seqseq):
"""Construct and write a series of sequences to a csv file.
diff --git a/pypy/module/_demo/demo.py b/pypy/module/_demo/demo.py
--- a/pypy/module/_demo/demo.py
+++ b/pypy/module/_demo/demo.py
@@ -15,7 +15,7 @@
def get(space, name):
w_module = space.getbuiltinmodule('_demo')
- return space.getattr(w_module, space.wrap(name))
+ return space.getattr(w_module, space.newtext(name))
@unwrap_spec(repetitions=int)
@@ -27,7 +27,7 @@
for i in range(repetitions):
space.call_function(w_callable)
endtime = time(0)
- return space.wrap(endtime - starttime)
+ return space.newint(endtime - starttime)
@unwrap_spec(n=int)
def sieve(space, n):
@@ -55,10 +55,10 @@
def multiply(self, w_y):
space = self.space
y = space.int_w(w_y)
- return space.wrap(self.x * y)
+ return space.newint(self.x * y)
def fget_x(self, space):
- return space.wrap(self.x)
+ return space.newint(self.x)
def fset_x(self, space, w_value):
self.x = space.int_w(w_value)
@@ -66,8 +66,8 @@
@unwrap_spec(x=int)
def mytype_new(space, w_subtype, x):
if x == 3:
- return space.wrap(MySubType(space, x))
- return space.wrap(W_MyType(space, x))
+ return MySubType(space, x)
+ return W_MyType(space, x)
getset_x = GetSetProperty(W_MyType.fget_x, W_MyType.fset_x, cls=W_MyType)
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
@@ -27,9 +27,9 @@
# that we're getting a reasonable value at this point.
w_value = space.call_function(
space.w_BlockingIOError,
- space.wrap(rposix.get_saved_errno()),
- space.wrap("write could not complete without blocking"),
- space.wrap(written))
+ space.newint(rposix.get_saved_errno()),
+ space.newtext("write could not complete without blocking"),
+ space.newint(written))
return OperationError(space.w_BlockingIOError, w_value)
@@ -115,7 +115,7 @@
def _readinto(self, space, w_buffer, methodname):
rwbuffer = space.getarg_w('w*', w_buffer)
length = rwbuffer.getlength()
- w_data = space.call_method(self, methodname, space.wrap(length))
+ w_data = space.call_method(self, methodname, space.newint(length))
if not space.isinstance_w(w_data, space.w_str):
raise oefmt(space.w_TypeError, "%s() should return bytes",
@@ -127,7 +127,7 @@
"%d bytes requested, %d returned",
methodname, length, len(data))
rwbuffer.setslice(0, data)
- return space.wrap(len(data))
+ return space.newint(len(data))
W_BufferedIOBase.typedef = TypeDef(
'_io._BufferedIOBase', W_IOBase.typedef,
@@ -244,15 +244,15 @@
def closed_get_w(self, space):
self._check_init(space)
- return space.getattr(self.w_raw, space.wrap("closed"))
+ return space.getattr(self.w_raw, space.newtext("closed"))
def name_get_w(self, space):
self._check_init(space)
- return space.getattr(self.w_raw, space.wrap("name"))
+ return space.getattr(self.w_raw, space.newtext("name"))
def mode_get_w(self, space):
self._check_init(space)
- return space.getattr(self.w_raw, space.wrap("mode"))
+ return space.getattr(self.w_raw, space.newtext("mode"))
def readable_w(self, space):
self._check_init(space)
@@ -271,16 +271,16 @@
return space.call_method(self.w_raw, "isatty")
def repr_w(self, space):
- typename = space.type(self).name.decode('utf-8')
+ typename = space.type(self).name
try:
- w_name = space.getattr(self, space.wrap("name"))
+ w_name = space.getattr(self, space.newtext("name"))
except OperationError as e:
if not e.match(space, space.w_Exception):
raise
- return space.wrap(u"<%s>" % (typename,))
+ return space.newtext("<%s>" % (typename,))
else:
- name_repr = space.unicode_w(space.repr(w_name))
- return space.wrap(u"<%s name=%s>" % (typename, name_repr))
+ name_repr = space.text_w(space.repr(w_name))
+ return space.newtext("<%s name=%s>" % (typename, name_repr))
# ______________________________________________
@@ -301,7 +301,7 @@
def tell_w(self, space):
self._check_init(space)
pos = self._raw_tell(space) - self._raw_offset()
- return space.wrap(pos)
+ return space.newint(pos)
@unwrap_spec(pos=r_longlong, whence=int)
def seek_w(self, space, pos, whence=0):
@@ -327,7 +327,7 @@
newpos = self.pos + offset
assert newpos >= 0
self.pos = newpos
- return space.wrap(current - available + offset)
+ return space.newint(current - available + offset)
# Fallback: invoke raw seek() method and clear buffer
with self.lock:
@@ -341,11 +341,11 @@
self.raw_pos = -1
if self.readable:
self._reader_reset_buf()
- return space.wrap(n)
+ return space.newint(n)
def _raw_seek(self, space, pos, whence):
w_pos = space.call_method(self.w_raw, "seek",
- space.wrap(pos), space.wrap(whence))
+ space.newint(pos), space.newint(whence))
pos = space.r_longlong_w(w_pos)
if pos < 0:
raise oefmt(space.w_IOError,
@@ -354,7 +354,7 @@
return pos
def _closed(self, space):
- return space.is_true(space.getattr(self.w_raw, space.wrap("closed")))
+ return space.is_true(space.getattr(self.w_raw,
space.newtext("closed")))
def close_w(self, space):
self._check_init(space)
@@ -781,7 +781,7 @@
self._adjust_position(self.pos + size)
if self.pos > self.write_end:
self.write_end = self.pos
- return space.wrap(size)
+ return space.newint(size)
# First write the current buffer
try:
@@ -809,7 +809,7 @@
self.buffer[self.write_end + i] = data[i]
self.write_end += size
self.pos += size
- return space.wrap(size)
+ return space.newint(size)
# Buffer as much as possible
for i in range(available):
self.buffer[self.write_end + i] = data[i]
@@ -865,7 +865,7 @@
self.write_end = remaining
self._adjust_position(remaining)
self.raw_pos = 0
- return space.wrap(written)
+ return space.newint(written)
def flush_w(self, space):
self._check_closed(space, "flush of closed file")
@@ -976,13 +976,13 @@
if self.w_writer is None:
raise oefmt(space.w_ValueError,
"I/O operation on uninitialized object")
- w_meth = space.getattr(self.w_writer, space.wrap(method))
+ w_meth = space.getattr(self.w_writer, space.newtext(method))
w_result = space.call_args(w_meth, __args__)
if reader:
if self.w_reader is None:
raise oefmt(space.w_ValueError,
"I/O operation on uninitialized object")
- w_meth = space.getattr(self.w_reader, space.wrap(method))
+ w_meth = space.getattr(self.w_reader, space.newtext(method))
w_result = space.call_args(w_meth, __args__)
return w_result
return method_w
@@ -1019,7 +1019,7 @@
if self.w_writer is None:
raise oefmt(space.w_ValueError,
"I/O operation on uninitialized object")
- w_meth = space.getattr(self.w_writer, space.wrap("close"))
+ w_meth = space.getattr(self.w_writer, space.newtext("close"))
try:
space.call_args(w_meth, __args__)
except OperationError as e:
@@ -1030,7 +1030,7 @@
if self.w_reader is None:
raise oefmt(space.w_ValueError,
"I/O operation on uninitialized object")
- w_meth = space.getattr(self.w_reader, space.wrap("close"))
+ w_meth = space.getattr(self.w_reader, space.newtext("close"))
space.call_args(w_meth, __args__)
if e:
@@ -1046,7 +1046,7 @@
return space.call_method(self.w_reader, "isatty")
def closed_get_w(self, space):
- return space.getattr(self.w_writer, space.wrap("closed"))
+ return space.getattr(self.w_writer, space.newtext("closed"))
methods = dict((method, interp2app(getattr(W_BufferedRWPair, method + '_w')))
for method in ['read', 'peek', 'read1', 'readinto', 'readable',
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
@@ -71,7 +71,7 @@
if self.is_closed():
if message is None:
message = "I/O operation on closed file"
- raise OperationError(space.w_ValueError, space.wrap(message))
+ raise OperationError(space.w_ValueError, space.newtext(message))
def read_w(self, space, w_size=None):
self._check_closed(space)
@@ -93,16 +93,16 @@
output = self.read(size)
rwbuffer.setslice(0, output)
- return space.wrap(len(output))
+ return space.newint(len(output))
def write_w(self, space, w_data):
self._check_closed(space)
buf = space.buffer_w(w_data, space.BUF_CONTIG_RO).as_str()
length = len(buf)
if length <= 0:
- return space.wrap(0)
+ return space.newint(0)
self.write(buf)
- return space.wrap(length)
+ return space.newint(length)
def truncate_w(self, space, w_size=None):
self._check_closed(space)
@@ -121,7 +121,7 @@
self.seek(0, 2)
else:
self.seek(pos)
- return space.wrap(size)
+ return space.newint(size)
def getbuffer_w(self, space):
self._check_closed(space)
@@ -133,7 +133,7 @@
def tell_w(self, space):
self._check_closed(space)
- return space.wrap(self.tell())
+ return space.newint(self.tell())
@unwrap_spec(pos=r_longlong, whence=int)
def seek_w(self, space, pos, whence=0):
@@ -153,7 +153,7 @@
"whence must be between 0 and 2, not %d", whence)
self.seek(pos, whence)
- return space.wrap(self.tell())
+ return space.newint(self.tell())
def readable_w(self, space):
self._check_closed(space)
@@ -175,13 +175,13 @@
return type(self) is not W_BytesIO
def closed_get_w(self, space):
- return space.wrap(self.is_closed())
+ return space.newbool(self.is_closed())
def getstate_w(self, space):
self._check_closed(space)
return space.newtuple([
space.newbytes(self.getvalue()),
- space.wrap(self.tell()),
+ space.newint(self.tell()),
self.getdict(space)])
def setstate_w(self, space, w_state):
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
@@ -18,7 +18,7 @@
def fget(space, obj):
w_value = getattr(obj, name)
if w_value is None:
- raise OperationError(space.w_AttributeError, space.wrap(name))
+ raise OperationError(space.w_AttributeError, space.newtext(name))
else:
return w_value
def fset(space, obj, w_value):
@@ -26,7 +26,7 @@
def fdel(space, obj):
w_value = getattr(obj, name)
if w_value is None:
- raise OperationError(space.w_AttributeError, space.wrap(name))
+ raise OperationError(space.w_AttributeError, space.newtext(name))
setattr(obj, name, None)
return GetSetProperty(fget, fset, fdel, cls=cls, doc=doc)
@@ -141,7 +141,7 @@
def descr_new(space, w_subtype, __args__):
self = space.allocate_instance(W_FileIO, w_subtype)
W_FileIO.__init__(self, space)
- return space.wrap(self)
+ return self
@unwrap_spec(mode=str, closefd=int)
def descr_init(self, space, w_name, mode='r', closefd=True, w_opener=None):
@@ -199,7 +199,7 @@
eintr_retry=False)
else:
w_fd = space.call_function(w_opener, w_name,
- space.wrap(flags))
+ space.newint(flags))
try:
self.fd = space.int_w(w_fd)
if self.fd < 0:
@@ -235,7 +235,7 @@
if HAS_BLKSIZE and st.st_blksize > 1:
self.blksize = st.st_blksize
- space.setattr(self, space.wrap("name"), w_name)
+ space.setattr(self, space.newtext("name"), w_name)
if self.appending:
# For consistent behaviour, we explicitly seek to the end of
file
@@ -270,10 +270,10 @@
return 'wb'
def descr_get_mode(self, space):
- return space.wrap(self._mode())
+ return space.newtext(self._mode())
def get_blksize(self, space):
- return space.wrap(self.blksize)
+ return space.newint(self.blksize)
def _closed(self, space):
return self.fd < 0
@@ -282,7 +282,7 @@
if message is None:
message = "I/O operation on closed file"
if self.fd < 0:
- raise OperationError(space.w_ValueError, space.wrap(message))
+ raise OperationError(space.w_ValueError, space.newtext(message))
def _check_readable(self, space):
if not self.readable:
@@ -322,13 +322,13 @@
def _dealloc_warn_w(self, space, w_source):
if self.fd >= 0 and self.closefd:
try:
- msg = (u"unclosed file %s" %
- space.unicode_w(space.repr(w_source)))
- space.warn(space.wrap(msg), space.w_ResourceWarning)
+ msg = ("unclosed file %s" %
+ space.text_w(space.repr(w_source)))
+ space.warn(space.newtext(msg), space.w_ResourceWarning)
except OperationError as e:
# Spurious errors can appear at shutdown
if e.match(space, space.w_Warning):
- e.write_unraisable(space, '', space.wrap(self))
+ e.write_unraisable(space, '', self)
@unwrap_spec(pos=r_longlong, whence=int)
def seek_w(self, space, pos, whence=0):
@@ -339,7 +339,7 @@
raise wrap_oserror(space, e,
exception_name='w_IOError',
eintr_retry=False)
- return space.wrap(pos)
+ return space.newint(pos)
def tell_w(self, space):
self._check_closed(space)
@@ -349,15 +349,15 @@
raise wrap_oserror(space, e,
exception_name='w_IOError',
eintr_retry=False)
- return space.wrap(pos)
+ return space.newint(pos)
def readable_w(self, space):
self._check_closed(space)
- return space.wrap(self.readable)
+ return space.newbool(self.readable)
def writable_w(self, space):
self._check_closed(space)
- return space.wrap(self.writable)
+ return space.newbool(self.writable)
def seekable_w(self, space):
self._check_closed(space)
@@ -374,7 +374,7 @@
def fileno_w(self, space):
self._check_closed(space)
- return space.wrap(self.fd)
+ return space.newint(self.fd)
def isatty_w(self, space):
self._check_closed(space)
@@ -383,23 +383,23 @@
except OSError as e:
raise wrap_oserror(space, e, exception_name='w_IOError',
eintr_retry=False)
- return space.wrap(res)
+ return space.newbool(res)
def repr_w(self, space):
if self.fd < 0:
- return space.wrap("<_io.FileIO [closed]>")
+ return space.newtext("<_io.FileIO [closed]>")
closefd = "True" if self.closefd else "False"
if self.w_name is None:
- return space.wrap(
+ return space.newtext(
"<_io.FileIO fd=%d mode='%s' closefd=%s>" % (
self.fd, self._mode(), closefd))
else:
w_repr = space.repr(self.w_name)
- return space.wrap(
+ return space.newtext(
"<_io.FileIO name=%s mode='%s' closefd=%s>" % (
- space.str_w(w_repr), self._mode(), closefd))
+ space.text_w(w_repr), self._mode(), closefd))
# ______________________________________________
@@ -419,7 +419,7 @@
exception_name='w_IOError',
eintr_retry=True)
- return space.wrap(n)
+ return space.newint(n)
def read_w(self, space, w_size=None):
self._check_closed(space)
@@ -458,7 +458,7 @@
exception_name='w_IOError',
eintr_retry=True)
rwbuffer.setslice(0, buf)
- return space.wrap(len(buf))
+ return space.newint(len(buf))
def readall_w(self, space):
self._check_closed(space)
diff --git a/pypy/module/_io/interp_io.py b/pypy/module/_io/interp_io.py
--- a/pypy/module/_io/interp_io.py
+++ b/pypy/module/_io/interp_io.py
@@ -71,7 +71,7 @@
if writing or appending:
raise oefmt(space.w_ValueError,
"can't use U and writing mode at once")
- space.warn(space.wrap("'U' mode is deprecated ('r' has the same "
+ space.warn(space.newtext("'U' mode is deprecated ('r' has the same "
"effect in Python 3.x)"),
space.w_DeprecationWarning)
if text and binary:
@@ -87,8 +87,8 @@
raise oefmt(space.w_ValueError,
"binary mode doesn't take a newline argument")
w_raw = space.call_function(
- space.gettypefor(W_FileIO), w_file, space.wrap(rawmode),
- space.wrap(bool(closefd)), w_opener)
+ space.gettypefor(W_FileIO), w_file, space.newtext(rawmode),
+ space.newbool(closefd), w_opener)
isatty = space.is_true(space.call_method(w_raw, "isatty"))
line_buffering = buffering == 1 or (buffering < 0 and isatty)
@@ -96,7 +96,7 @@
buffering = -1
if buffering < 0:
- buffering = space.c_int_w(space.getattr(w_raw, space.wrap("_blksize")))
+ buffering = space.c_int_w(space.getattr(w_raw,
space.newtext("_blksize")))
if buffering < 0:
raise oefmt(space.w_ValueError, "invalid buffering size")
@@ -115,17 +115,17 @@
else:
raise oefmt(space.w_ValueError, "unknown mode: '%s'", mode)
w_buffer = space.call_function(
- space.gettypefor(buffer_cls), w_raw, space.wrap(buffering)
+ space.gettypefor(buffer_cls), w_raw, space.newint(buffering)
)
if binary:
return w_buffer
w_wrapper = space.call_function(space.gettypefor(W_TextIOWrapper),
w_buffer,
- space.wrap(encoding),
- space.wrap(errors),
- space.wrap(newline),
- space.wrap(line_buffering)
+ space.newtext_or_none(encoding),
+ space.newtext_or_none(errors),
+ space.newtext_or_none(newline),
+ space.newbool(line_buffering)
)
- space.setattr(w_wrapper, space.wrap("mode"), space.wrap(mode))
+ space.setattr(w_wrapper, space.newtext("mode"), space.newtext(mode))
return w_wrapper
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
@@ -23,15 +23,15 @@
return False
try:
w_value = error.get_w_value(space)
- w_errno = space.getattr(w_value, space.wrap("errno"))
- return space.eq_w(w_errno, space.wrap(EINTR))
+ w_errno = space.getattr(w_value, space.newtext("errno"))
+ return space.eq_w(w_errno, space.newint(EINTR))
except OperationError:
return False
def unsupported(space, message):
w_exc = space.getattr(space.getbuiltinmodule('_io'),
- space.wrap('UnsupportedOperation'))
- return OperationError(w_exc, space.wrap(message))
+ space.newtext('UnsupportedOperation'))
+ return OperationError(w_exc, space.newtext(message))
# May be called with any object
def check_readable_w(space, w_obj):
@@ -69,7 +69,7 @@
def _closed(self, space):
# This gets the derived attribute, which is *not* __IOBase_closed
# in most cases!
- w_closed = space.findattr(self, space.wrap('closed'))
+ w_closed = space.findattr(self, space.newtext('closed'))
if w_closed is not None and space.is_true(w_closed):
return True
return False
@@ -88,7 +88,7 @@
def descr_del(self):
space = self.space
- w_closed = space.findattr(self, space.wrap('closed'))
+ w_closed = space.findattr(self, space.newtext('closed'))
try:
# If `closed` doesn't exist or can't be evaluated as bool, then
# the object is probably in an unusable state, so ignore.
@@ -117,7 +117,7 @@
message = "I/O operation on closed file"
if self._closed(space):
raise OperationError(
- space.w_ValueError, space.wrap(message))
+ space.w_ValueError, space.newtext(message))
def check_closed_w(self, space):
self._check_closed(space)
@@ -156,7 +156,7 @@
self._unsupportedoperation(space, "seek")
def tell_w(self, space):
- return space.call_method(self, "seek", space.wrap(0), space.wrap(1))
+ return space.call_method(self, "seek", space.newint(0),
space.newint(1))
def truncate_w(self, space, w_size=None):
self._unsupportedoperation(space, "truncate")
@@ -166,14 +166,14 @@
def enter_w(self, space):
self._check_closed(space)
- return space.wrap(self)
+ return self
def exit_w(self, space, __args__):
space.call_method(self, "close")
def iter_w(self, space):
self._check_closed(space)
- return space.wrap(self)
+ return self
def next_w(self, space):
w_line = space.call_method(self, "readline")
@@ -203,7 +203,7 @@
# For backwards compatibility, a (slowish) readline().
limit = convert_size(space, w_limit)
- has_peek = space.findattr(self, space.wrap("peek"))
+ has_peek = space.findattr(self, space.newtext("peek"))
builder = StringBuilder()
size = 0
@@ -213,7 +213,7 @@
if has_peek:
try:
- w_readahead = space.call_method(self, "peek",
space.wrap(1))
+ w_readahead = space.call_method(self, "peek",
space.newint(1))
except OperationError as e:
if trap_eintr(space, e):
continue
@@ -243,7 +243,7 @@
nreadahead = n
try:
- w_read = space.call_method(self, "read",
space.wrap(nreadahead))
+ w_read = space.call_method(self, "read",
space.newint(nreadahead))
except OperationError as e:
if trap_eintr(space, e):
continue
@@ -363,7 +363,7 @@
while True:
try:
w_data = space.call_method(self, "read",
- space.wrap(DEFAULT_BUFFER_SIZE))
+ space.newint(DEFAULT_BUFFER_SIZE))
except OperationError as e:
if trap_eintr(space, e):
continue
diff --git a/pypy/module/_io/interp_stringio.py
b/pypy/module/_io/interp_stringio.py
--- a/pypy/module/_io/interp_stringio.py
+++ b/pypy/module/_io/interp_stringio.py
@@ -28,11 +28,11 @@
if (newline is not None and newline != u"" and newline != u"\n" and
newline != u"\r" and newline != u"\r\n"):
- # Not using oefmt() because I don't know how to ues it
+ # Not using oefmt() because I don't know how to use it
# with unicode
raise OperationError(space.w_ValueError,
space.mod(
- space.wrap("illegal newline value: %s"),
space.wrap(newline)
+ space.newtext("illegal newline value: %s"), w_newline
)
)
if newline is not None:
@@ -45,7 +45,7 @@
self.w_decoder = space.call_function(
space.gettypefor(W_IncrementalNewlineDecoder),
space.w_None,
- space.wrap(int(self.readtranslate))
+ space.newint(int(self.readtranslate))
)
if not space.is_none(w_initvalue):
@@ -58,9 +58,9 @@
if self.readnl is None:
w_readnl = space.w_None
else:
- w_readnl = space.str(space.wrap(self.readnl))
+ w_readnl = space.str(space.newunicode(self.readnl)) # YYY
return space.newtuple([
- w_initialval, w_readnl, space.wrap(self.pos), w_dict
+ w_initialval, w_readnl, space.newint(self.pos), w_dict
])
def descr_setstate(self, space, w_state):
@@ -105,7 +105,7 @@
if self.buf is None:
if message is None:
message = "I/O operation on closed file"
- raise OperationError(space.w_ValueError, space.wrap(message))
+ raise OperationError(space.w_ValueError, space.newtext(message))
def resize_buffer(self, newlength):
if len(self.buf) > newlength:
@@ -139,7 +139,7 @@
if self.writenl:
w_decoded = space.call_method(
- w_decoded, "replace", space.wrap("\n"),
space.wrap(self.writenl)
+ w_decoded, "replace", space.newtext("\n"),
space.newunicode(self.writenl)
)
string = space.unicode_w(w_decoded)
@@ -147,7 +147,7 @@
if size:
self.write(string)
- return space.wrap(orig_size)
+ return space.newint(orig_size)
def read_w(self, space, w_size=None):
self._check_closed(space)
@@ -155,21 +155,21 @@
start = self.pos
available = len(self.buf) - start
if available <= 0:
- return space.wrap(u"")
+ return space.newunicode(u"")
if size >= 0 and size <= available:
end = start + size
else:
end = len(self.buf)
assert 0 <= start <= end
self.pos = end
- return space.wrap(u''.join(self.buf[start:end]))
+ return space.newunicode(u''.join(self.buf[start:end]))
def readline_w(self, space, w_limit=None):
self._check_closed(space)
limit = convert_size(space, w_limit)
if self.pos >= len(self.buf):
- return space.wrap(u"")
+ return space.newunicode(u"")
start = self.pos
if limit < 0 or limit > len(self.buf) - self.pos:
@@ -190,7 +190,7 @@
endpos = end
assert endpos >= 0
self.pos = endpos
- return space.wrap(u"".join(self.buf[start:endpos]))
+ return space.newunicode(u"".join(self.buf[start:endpos]))
@unwrap_spec(pos=int, mode=int)
def seek_w(self, space, pos, mode=0):
@@ -212,7 +212,7 @@
assert pos >= 0
self.pos = pos
- return space.wrap(pos)
+ return space.newint(pos)
def truncate_w(self, space, w_size=None):
self._check_closed(space)
@@ -227,11 +227,11 @@
if size < len(self.buf):
self.resize_buffer(size)
- return space.wrap(size)
+ return space.newint(size)
def getvalue_w(self, space):
self._check_closed(space)
- return space.wrap(u''.join(self.buf))
+ return space.newunicode(u''.join(self.buf))
def readable_w(self, space):
self._check_closed(space)
@@ -253,7 +253,7 @@
return type(self) is not W_StringIO
def closed_get_w(self, space):
- return space.wrap(self.buf is None)
+ return space.newbool(self.buf is None)
def line_buffering_get_w(self, space):
return space.w_False
@@ -261,7 +261,7 @@
def newlines_get_w(self, space):
if self.w_decoder is None:
return space.w_None
- return space.getattr(self.w_decoder, space.wrap("newlines"))
+ return space.getattr(self.w_decoder, space.newtext("newlines"))
W_StringIO.typedef = 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
@@ -29,17 +29,17 @@
def __init__(self, space):
self.w_newlines_dict = {
- SEEN_CR: space.wrap(u"\r"),
- SEEN_LF: space.wrap(u"\n"),
- SEEN_CRLF: space.wrap(u"\r\n"),
+ SEEN_CR: space.newunicode(u"\r"),
+ SEEN_LF: space.newunicode(u"\n"),
+ SEEN_CRLF: space.newunicode(u"\r\n"),
SEEN_CR | SEEN_LF: space.newtuple(
- [space.wrap(u"\r"), space.wrap(u"\n")]),
+ [space.newunicode(u"\r"), space.newunicode(u"\n")]),
SEEN_CR | SEEN_CRLF: space.newtuple(
- [space.wrap(u"\r"), space.wrap(u"\r\n")]),
+ [space.newunicode(u"\r"), space.newunicode(u"\r\n")]),
SEEN_LF | SEEN_CRLF: space.newtuple(
- [space.wrap(u"\n"), space.wrap(u"\r\n")]),
+ [space.newunicode(u"\n"), space.newunicode(u"\r\n")]),
SEEN_CR | SEEN_LF | SEEN_CRLF: space.newtuple(
- [space.wrap(u"\r"), space.wrap(u"\n"), space.wrap(u"\r\n")]),
+ [space.newunicode(u"\r"), space.newunicode(u"\n"),
space.newunicode(u"\r\n")]),
}
@unwrap_spec(translate=int)
@@ -47,7 +47,7 @@
self.w_decoder = w_decoder
self.translate = translate
if space.is_none(w_errors):
- self.w_errors = space.wrap("strict")
+ self.w_errors = space.newtext("strict")
else:
self.w_errors = w_errors
@@ -65,7 +65,7 @@
# decode input (with the eventual \r from a previous pass)
if not space.is_w(self.w_decoder, space.w_None):
w_output = space.call_method(self.w_decoder, "decode",
- w_input, space.wrap(final))
+ w_input, space.newbool(final))
else:
w_output = w_input
@@ -91,7 +91,7 @@
output_len -= 1
if output_len == 0:
- return space.wrap(u"")
+ return space.newunicode(u"")
# Record which newlines are read and do newline translation if
# desired, all in one pass.
@@ -146,7 +146,7 @@
output = builder.build()
self.seennl |= seennl
- return space.wrap(output)
+ return space.newunicode(output)
def reset_w(self, space):
self.seennl = 0
@@ -165,7 +165,7 @@
flag <<= 1
if self.pendingcr:
flag |= 1
- return space.newtuple([w_buffer, space.wrap(flag)])
+ return space.newtuple([w_buffer, space.newint(flag)])
def setstate_w(self, space, w_state):
w_buffer, w_flag = space.unpackiterable(w_state, 2)
@@ -174,7 +174,7 @@
flag >>= 1
if self.w_decoder and not space.is_w(self.w_decoder, space.w_None):
- w_state = space.newtuple([w_buffer, space.wrap(flag)])
+ w_state = space.newtuple([w_buffer, space.newint(flag)])
space.call_method(self.w_decoder, "setstate", w_state)
W_IncrementalNewlineDecoder.typedef = TypeDef(
@@ -272,7 +272,7 @@
def _determine_encoding(space, encoding, w_buffer):
if encoding is not None:
- return space.wrap(encoding)
+ return space.newtext(encoding)
# Try os.device_encoding(fileno)
try:
@@ -283,21 +283,21 @@
e.match(space, space.fromcache(Cache).w_unsupportedoperation)):
raise
else:
- w_os = space.call_method(space.builtin, '__import__', space.wrap('os'))
+ w_os = space.call_method(space.builtin, '__import__',
space.newtext('os'))
w_encoding = space.call_method(w_os, 'device_encoding', w_fileno)
if space.isinstance_w(w_encoding, space.w_unicode):
return w_encoding
try:
w_locale = space.call_method(space.builtin, '__import__',
- space.wrap('locale'))
+ space.newtext('locale'))
w_encoding = space.call_method(w_locale, 'getpreferredencoding',
space.w_False)
except OperationError as e:
# getpreferredencoding() may also raise ImportError
if not e.match(space, space.w_ImportError):
raise
- return space.wrap('ascii')
+ return space.newtext('ascii')
else:
if space.isinstance_w(w_encoding, space.w_unicode):
return w_encoding
@@ -383,7 +383,7 @@
self.w_encoding = _determine_encoding(space, encoding, w_buffer)
if space.is_none(w_errors):
- w_errors = space.wrap("strict")
+ w_errors = space.newtext("strict")
self.w_errors = w_errors
if space.is_none(w_newline):
@@ -413,9 +413,9 @@
self.writenl = None
w_codec = interp_codecs.lookup_codec(space,
- space.str_w(self.w_encoding))
+ space.text_w(self.w_encoding))
if not space.is_true(space.getattr(w_codec,
- space.wrap('_is_text_encoding'))):
+
space.newtext('_is_text_encoding'))):
msg = ("%R is not a text encoding; "
"use codecs.open() to handle arbitrary codecs")
raise oefmt(space.w_LookupError, msg, self.w_encoding)
@@ -427,7 +427,7 @@
if self.readuniversal:
self.w_decoder = space.call_function(
space.gettypeobject(W_IncrementalNewlineDecoder.typedef),
- self.w_decoder, space.wrap(self.readtranslate))
+ self.w_decoder, space.newbool(self.readtranslate))
# build the encoder object
if space.is_true(space.call_method(w_buffer, "writable")):
@@ -437,15 +437,15 @@
self.seekable = space.is_true(space.call_method(w_buffer, "seekable"))
self.telling = self.seekable
- self.has_read1 = space.findattr(w_buffer, space.wrap("read1"))
+ self.has_read1 = space.findattr(w_buffer, space.newtext("read1"))
self.encoding_start_of_stream = False
if self.seekable and self.w_encoder:
self.encoding_start_of_stream = True
w_cookie = space.call_method(self.w_buffer, "tell")
- if not space.eq_w(w_cookie, space.wrap(0)):
+ if not space.eq_w(w_cookie, space.newint(0)):
self.encoding_start_of_stream = False
- space.call_method(self.w_encoder, "setstate", space.wrap(0))
+ space.call_method(self.w_encoder, "setstate", space.newint(0))
self.state = STATE_OK
@@ -465,10 +465,10 @@
W_TextIOBase._check_closed(self, space, message)
def __w_attr_repr(self, space, name):
- w_attr = space.findattr(self, space.wrap(name))
+ w_attr = space.findattr(self, space.newtext(name))
if w_attr is None:
- return space.wrap("")
- return space.mod(space.wrap("%s=%%r " % name), w_attr)
+ return space.newtext("")
+ return space.mod(space.newtext("%s=%%r " % name), w_attr)
def descr_repr(self, space):
self._check_init(space)
@@ -476,7 +476,7 @@
self.__w_attr_repr(space, 'mode'),
self.w_encoding])
return space.mod(
- space.wrap("<_io.TextIOWrapper %s%sencoding=%r>"), w_args
+ space.newtext("<_io.TextIOWrapper %s%sencoding=%r>"), w_args
)
def readable_w(self, space):
@@ -501,17 +501,17 @@
def closed_get_w(self, space):
self._check_attached(space)
- return space.getattr(self.w_buffer, space.wrap("closed"))
+ return space.getattr(self.w_buffer, space.newtext("closed"))
def newlines_get_w(self, space):
self._check_attached(space)
if self.w_decoder is None:
return space.w_None
- return space.findattr(self.w_decoder, space.wrap("newlines"))
+ return space.findattr(self.w_decoder, space.newtext("newlines"))
def name_get_w(self, space):
self._check_attached(space)
- return space.getattr(self.w_buffer, space.wrap("name"))
+ return space.getattr(self.w_buffer, space.newtext("name"))
def flush_w(self, space):
self._check_attached(space)
@@ -530,7 +530,7 @@
def close_w(self, space):
self._check_attached(space)
if not space.is_true(space.getattr(self.w_buffer,
- space.wrap("closed"))):
+ space.newtext("closed"))):
try:
space.call_method(self, "flush")
finally:
@@ -594,7 +594,7 @@
# Read a chunk, decode it, and put the result in self._decoded_chars
w_input = space.call_method(self.w_buffer,
"read1" if self.has_read1 else "read",
- space.wrap(self.chunk_size))
+ space.newint(self.chunk_size))
if not space.isinstance_w(w_input, space.w_str):
msg = "decoder getstate() should have returned a bytes " \
@@ -603,7 +603,7 @@
eof = space.len_w(w_input) == 0
w_decoded = space.call_method(self.w_decoder, "decode",
- w_input, space.wrap(eof))
+ w_input, space.newbool(eof))
check_decoded(space, w_decoded)
self._set_decoded_chars(space.unicode_w(w_decoded))
if space.len_w(w_decoded) > 0:
@@ -641,7 +641,7 @@
w_bytes = space.call_method(self.w_buffer, "read")
w_decoded = space.call_method(self.w_decoder, "decode", w_bytes,
space.w_True)
check_decoded(space, w_decoded)
- w_result = space.wrap(self._get_decoded_chars(-1))
+ w_result = space.newunicode(self._get_decoded_chars(-1))
w_final = space.add(w_result, w_decoded)
self.snapshot = None
return w_final
@@ -667,7 +667,7 @@
continue
raise
- return space.wrap(builder.build())
+ return space.newunicode(builder.build())
def readline_w(self, space, w_limit=None):
self._check_attached(space)
@@ -758,9 +758,9 @@
line = u''.join(chunks)
if line:
- return space.wrap(line)
+ return space.newunicode(line)
else:
- return space.wrap(u'')
+ return space.newunicode(u'')
# _____________________________________________________________
# write methods
@@ -784,8 +784,8 @@
if text.find(u'\n') >= 0:
haslf = True
if haslf and self.writetranslate and self.writenl:
- w_text = space.call_method(w_text, "replace", space.wrap(u'\n'),
- space.wrap(self.writenl))
+ w_text = space.call_method(w_text, "replace",
space.newunicode(u'\n'),
+ space.newunicode(self.writenl))
text = space.unicode_w(w_text)
needflush = False
@@ -819,7 +819,7 @@
if self.w_decoder:
space.call_method(self.w_decoder, "reset")
- return space.wrap(textlen)
+ return space.newint(textlen)
def _writeflush(self, space):
if not self.pending_bytes:
@@ -862,14 +862,14 @@
else:
space.call_method(self.w_decoder, "setstate",
space.newtuple([space.newbytes(""),
- space.wrap(cookie.dec_flags)]))
+ space.newint(cookie.dec_flags)]))
def _encoder_setstate(self, space, cookie):
if cookie.start_pos == 0 and cookie.dec_flags == 0:
space.call_method(self.w_encoder, "reset")
self.encoding_start_of_stream = True
else:
- space.call_method(self.w_encoder, "setstate", space.wrap(0))
+ space.call_method(self.w_encoder, "setstate", space.newint(0))
self.encoding_start_of_stream = False
@unwrap_spec(whence=int)
@@ -882,7 +882,7 @@
if whence == 1:
# seek relative to current position
- if not space.is_true(space.eq(w_pos, space.wrap(0))):
+ if not space.is_true(space.eq(w_pos, space.newint(0))):
self._unsupportedoperation(
space, "can't do nonzero cur-relative seeks")
# Seeking to the current position should attempt to sync the
@@ -891,7 +891,7 @@
elif whence == 2:
# seek relative to end of file
- if not space.is_true(space.eq(w_pos, space.wrap(0))):
+ if not space.is_true(space.eq(w_pos, space.newint(0))):
self._unsupportedoperation(
space, "can't do nonzero end-relative seeks")
space.call_method(self, "flush")
@@ -900,14 +900,14 @@
if self.w_decoder:
space.call_method(self.w_decoder, "reset")
return space.call_method(self.w_buffer, "seek",
- w_pos, space.wrap(whence))
+ w_pos, space.newint(whence))
elif whence != 0:
raise oefmt(space.w_ValueError,
"invalid whence (%d, should be 0, 1 or 2)",
whence)
- if space.is_true(space.lt(w_pos, space.wrap(0))):
+ if space.is_true(space.lt(w_pos, space.newint(0))):
r = space.str_w(space.repr(w_pos))
raise oefmt(space.w_ValueError,
"negative seek position %s", r)
@@ -919,7 +919,7 @@
cookie = PositionCookie(space.bigint_w(w_pos))
# Seek back to the safe start point
- space.call_method(self.w_buffer, "seek", space.wrap(cookie.start_pos))
+ space.call_method(self.w_buffer, "seek",
space.newint(cookie.start_pos))
self._set_decoded_chars(None)
self.snapshot = None
@@ -931,7 +931,7 @@
if cookie.chars_to_skip:
# Just like _read_chunk, feed the decoder and save a snapshot.
w_chunk = space.call_method(self.w_buffer, "read",
- space.wrap(cookie.bytes_to_feed))
+ space.newint(cookie.bytes_to_feed))
if not space.isinstance_w(w_chunk, space.w_str):
msg = "underlying read() should have returned " \
"a bytes object, not '%T'"
@@ -941,7 +941,7 @@
space.bytes_w(w_chunk))
w_decoded = space.call_method(self.w_decoder, "decode",
- w_chunk, space.wrap(cookie.need_eof))
+ w_chunk,
space.newbool(cookie.need_eof))
check_decoded(space, w_decoded)
self._set_decoded_chars(space.unicode_w(w_decoded))
@@ -1034,8 +1034,8 @@
else:
# We didn't get enough decoded data; signal EOF to get more.
w_decoded = space.call_method(self.w_decoder, "decode",
- space.wrap(""),
- space.wrap(1)) # final=1
+ space.newbytes(""),
+ space.newint(1)) # final=1
check_decoded(space, w_decoded)
chars_decoded += len(space.unicode_w(w_decoded))
cookie.need_eof = 1
@@ -1052,7 +1052,7 @@
def chunk_size_get_w(self, space):
self._check_attached(space)
- return space.wrap(self.chunk_size)
+ return space.newint(self.chunk_size)
def chunk_size_set_w(self, space, w_size):
self._check_attached(space)
diff --git a/pypy/module/_lsprof/interp_lsprof.py
b/pypy/module/_lsprof/interp_lsprof.py
--- a/pypy/module/_lsprof/interp_lsprof.py
+++ b/pypy/module/_lsprof/interp_lsprof.py
@@ -54,7 +54,7 @@
calls_repr = "None"
else:
calls_repr = space.str_w(space.repr(self.w_calls))
- return space.wrap('("%s", %d, %d, %f, %f, %s)' % (
+ return space.newtext('("%s", %d, %d, %f, %f, %s)' % (
frame_repr, self.callcount, self.reccallcount,
self.tt, self.it, calls_repr))
@@ -82,7 +82,7 @@
_______________________________________________
pypy-commit mailing list
pypy-commit@python.org
https://mail.python.org/mailman/listinfo/pypy-commit
