[pypy-commit] pypy space-newtext: _io
cfbolz
pypy.commits at gmail.com
Mon Nov 7 08:53:47 EST 2016
Author: Carl Friedrich Bolz <cfbolz at gmx.de>
Branch: space-newtext
Changeset: r88172:d4be9a5ff016
Date: 2016-11-07 14:41 +0100
http://bitbucket.org/pypy/pypy/changeset/d4be9a5ff016/
Log: _io
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
@@ -28,9 +28,9 @@
w_type = space.gettypeobject(W_BlockingIOError.typedef)
w_value = space.call_function(
w_type,
- 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(w_type, w_value)
@@ -62,14 +62,14 @@
class W_BufferedIOBase(W_IOBase):
def _unsupportedoperation(self, space, message):
w_exc = space.getattr(space.getbuiltinmodule('_io'),
- space.wrap('UnsupportedOperation'))
- raise OperationError(w_exc, space.wrap(message))
+ space.newtext('UnsupportedOperation'))
+ raise OperationError(w_exc, space.newtext(message))
def _check_init(self, space):
raise NotImplementedError
def _deprecated_max_buffer_size(self, space):
- space.warn(space.wrap("max_buffer_size is deprecated"),
+ space.warn(space.newtext("max_buffer_size is deprecated"),
space.w_DeprecationWarning)
def read_w(self, space, w_size=None):
@@ -87,13 +87,13 @@
def readinto_w(self, space, w_buffer):
rwbuffer = space.getarg_w('w*', w_buffer)
length = rwbuffer.getlength()
- w_data = space.call_method(self, "read", space.wrap(length))
+ w_data = space.call_method(self, "read", space.newint(length))
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)
rwbuffer.setslice(0, data)
- return space.wrap(len(data))
+ return space.newint(len(data))
W_BufferedIOBase.typedef = TypeDef(
'_io._BufferedIOBase', W_IOBase.typedef,
@@ -190,15 +190,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)
@@ -219,14 +219,14 @@
def repr_w(self, space):
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("<%s>" % (typename,))
+ return space.newtext("<%s>" % (typename,))
else:
name_repr = space.str_w(space.repr(w_name))
- return space.wrap("<%s name=%s>" % (typename, name_repr))
+ return space.newtext("<%s name=%s>" % (typename, name_repr))
# ______________________________________________
@@ -247,7 +247,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):
@@ -273,7 +273,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:
@@ -287,11 +287,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,
@@ -300,7 +300,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)
@@ -723,7 +723,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:
@@ -753,7 +753,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]
@@ -809,7 +809,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_init(space)
@@ -921,13 +921,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
@@ -977,7 +977,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:
@@ -988,7 +988,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:
@@ -1000,7 +1000,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
@@ -27,7 +27,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)
@@ -49,16 +49,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)
@@ -77,7 +77,7 @@
self.seek(0, 2)
else:
self.seek(pos)
- return space.wrap(size)
+ return space.newint(size)
def getvalue_w(self, space):
self._check_closed(space)
@@ -85,7 +85,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):
@@ -105,7 +105,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)
@@ -123,13 +123,13 @@
self.close()
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
@@ -13,7 +13,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):
@@ -21,7 +21,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)
@@ -126,7 +126,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):
@@ -174,7 +174,7 @@
fd_is_own = True
self._dircheck(space, w_name)
- 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
@@ -203,7 +203,7 @@
return 'wb'
def descr_get_mode(self, space):
- return space.wrap(self._mode())
+ return space.newtext(self._mode())
def _closed(self, space):
return self.fd < 0
@@ -212,7 +212,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:
@@ -270,7 +270,7 @@
except OSError as e:
raise wrap_oserror(space, e,
exception_name='w_IOError')
- return space.wrap(pos)
+ return space.newint(pos)
def tell_w(self, space):
self._check_closed(space)
@@ -279,15 +279,15 @@
except OSError as e:
raise wrap_oserror(space, e,
exception_name='w_IOError')
- 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)
@@ -304,7 +304,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)
@@ -312,19 +312,19 @@
res = os.isatty(self.fd)
except OSError as e:
raise wrap_oserror(space, e, exception_name='w_IOError')
- 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]>")
if self.w_name is None:
- return space.wrap(
+ return space.newtext(
"<_io.FileIO fd=%d mode='%s'>" % (
self.fd, self._mode()))
else:
w_repr = space.repr(self.w_name)
- return space.wrap(
+ return space.newtext(
"<_io.FileIO name=%s mode='%s'>" % (
space.str_w(w_repr), self._mode()))
@@ -343,7 +343,7 @@
raise wrap_oserror(space, e,
exception_name='w_IOError')
- return space.wrap(n)
+ return space.newint(n)
def read_w(self, space, w_size=None):
self._check_closed(space)
@@ -376,7 +376,7 @@
raise wrap_oserror(space, e,
exception_name='w_IOError')
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
@@ -103,7 +103,7 @@
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(closefd)
+ space.gettypefor(W_FileIO), w_file, space.newtext(rawmode), space.newbool(closefd)
)
isatty = space.is_true(space.call_method(w_raw, "isatty"))
@@ -142,17 +142,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):
@@ -68,14 +68,14 @@
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
def _finalize_(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.
@@ -102,7 +102,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)
@@ -126,7 +126,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")
@@ -136,14 +136,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")
@@ -170,7 +170,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
@@ -180,7 +180,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
@@ -210,7 +210,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
@@ -327,7 +327,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)
@@ -249,7 +249,7 @@
self.buf = None
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
@@ -257,7 +257,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,17 +272,17 @@
def _determine_encoding(space, encoding):
if encoding is not None:
- return space.wrap(encoding)
+ return space.newtext(encoding)
try:
w_locale = space.call_method(space.builtin, '__import__',
- space.wrap('locale'))
+ space.newtext('locale'))
w_encoding = space.call_method(w_locale, 'getpreferredencoding')
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_str):
return w_encoding
@@ -367,7 +367,7 @@
self.w_encoding = _determine_encoding(space, encoding)
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):
@@ -404,7 +404,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")):
@@ -420,9 +420,9 @@
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
@@ -443,14 +443,14 @@
def descr_repr(self, space):
self._check_init(space)
- w_name = space.findattr(self, space.wrap("name"))
+ w_name = space.findattr(self, space.newtext("name"))
if w_name is None:
- w_name_str = space.wrap("")
+ w_name_str = space.newtext("")
else:
- w_name_str = space.mod(space.wrap("name=%r "), w_name)
+ w_name_str = space.mod(space.newtext("name=%r "), w_name)
w_args = space.newtuple([w_name_str, self.w_encoding])
return space.mod(
- space.wrap("<_io.TextIOWrapper %sencoding=%r>"), w_args
+ space.newtext("<_io.TextIOWrapper %sencoding=%r>"), w_args
)
def readable_w(self, space):
@@ -475,17 +475,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)
@@ -504,7 +504,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:
@@ -564,7 +564,7 @@
# Read a chunk, decode it, and put the result in self._decoded_chars
w_input = space.call_method(self.w_buffer, "read1",
- 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 " \
@@ -573,7 +573,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:
@@ -611,7 +611,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
@@ -637,7 +637,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)
@@ -728,9 +728,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
@@ -754,8 +754,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
@@ -787,7 +787,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:
@@ -830,14 +830,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)
@@ -849,7 +849,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))):
raise oefmt(space.w_IOError,
"can't do nonzero cur-relative seeks")
# Seeking to the current position should attempt to sync the
@@ -858,7 +858,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))):
raise oefmt(space.w_IOError,
"can't do nonzero end-relative seeks")
space.call_method(self, "flush")
@@ -867,14 +867,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)
@@ -886,7 +886,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
@@ -898,7 +898,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'"
@@ -908,7 +908,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))
@@ -1000,8 +1000,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
@@ -1018,7 +1018,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)
More information about the pypy-commit
mailing list