diff options
Diffstat (limited to 'Lib/io.py')
| -rw-r--r-- | Lib/io.py | 146 |
1 files changed, 64 insertions, 82 deletions
@@ -1180,14 +1180,14 @@ class TextIOWrapper(TextIOBase): self._encoder = None self._decoder = None self._decoded_text = "" # buffer for text produced by decoder - self._decoded_text_offset = 0 # offset to text returned by read() self._snapshot = None # info for reconstructing decoder state self._seekable = self._telling = self.buffer.seekable() # A word about _snapshot. This attribute is either None, or a tuple - # (decoder_state, next_input) where decoder_state is the second - # (integer) item of the decoder state, and next_input is the chunk - # of bytes that comes after the snapshot point in the input. + # (decoder_state, input_chunk, decoded_chars) where decoder_state is + # the second (integer) item of the decoder state, input_chunk is the + # chunk of bytes that was read, and decoded_chars is the number of + # characters rendered by the decoder after feeding it those bytes. # We use this to reconstruct intermediate decoder states in tell(). # Naming convention: @@ -1271,10 +1271,10 @@ class TextIOWrapper(TextIOBase): """ Read and decode the next chunk of data from the BufferedReader. - The return value is True unless EOF was reached. The decoded string - is placed in self._decoded_text (replacing its previous value). - (The entire input chunk is sent to the decoder, though some of it - may remain buffered in the decoder, yet to be converted.) + Return a tuple of two elements: all the bytes that were read, and + the decoded string produced by the decoder. (The entire input + chunk is sent to the decoder, but some of it may remain buffered + in the decoder, yet to be converted.) """ if self._decoder is None: @@ -1283,9 +1283,8 @@ class TextIOWrapper(TextIOBase): # No one should call tell(), so don't bother taking a snapshot. input_chunk = self.buffer.read1(self._CHUNK_SIZE) eof = not input_chunk - self._decoded_text = self._decoder.decode(input_chunk, eof) - self._decoded_text_offset = 0 - return not eof + decoded = self._decoder.decode(input_chunk, eof) + return (input_chunk, decoded) # The cookie returned by tell() cannot include the contents of # the decoder's buffer, so we need to snapshot a point in the @@ -1299,15 +1298,16 @@ class TextIOWrapper(TextIOBase): input_chunk = self.buffer.read1(self._CHUNK_SIZE) eof = not input_chunk - self._decoded_text = self._decoder.decode(input_chunk, eof) - self._decoded_text_offset = 0 + decoded = self._decoder.decode(input_chunk, eof) - # At the snapshot point, len(dec_buffer) bytes ago, the next input - # to be passed to the decoder is dec_buffer + input_chunk. - self._snapshot = (dec_flags, dec_buffer + input_chunk) - return not eof + # At the snapshot point len(dec_buffer) bytes ago, the next input + # to be passed to the decoder is dec_buffer + input_chunk. Save + # len(decoded) so that later, tell() can figure out how much + # decoded data has been used up by TextIOWrapper.read(). + self._snapshot = (dec_flags, dec_buffer + input_chunk, len(decoded)) + return (input_chunk, decoded) - def _pack_cookie(self, position, dec_flags=0, + def _encode_tell_cookie(self, position, dec_flags=0, feed_bytes=0, need_eof=0, skip_chars=0): # The meaning of a tell() cookie is: seek to position, set the # decoder flags to dec_flags, read feed_bytes bytes, feed them @@ -1317,7 +1317,7 @@ class TextIOWrapper(TextIOBase): return (position | (dec_flags<<64) | (feed_bytes<<128) | (skip_chars<<192) | bool(need_eof)<<256) - def _unpack_cookie(self, bigint): + def _decode_tell_cookie(self, bigint): rest, position = divmod(bigint, 1<<64) rest, dec_flags = divmod(rest, 1<<64) rest, feed_bytes = divmod(rest, 1<<64) @@ -1339,14 +1339,14 @@ class TextIOWrapper(TextIOBase): return position # Skip backward to the snapshot point (see _read_chunk). - dec_flags, next_input = self._snapshot + dec_flags, next_input, decoded_chars = self._snapshot position -= len(next_input) - # How many decoded characters have been returned since the snapshot? - skip_chars = self._decoded_text_offset + # How many decoded characters have been consumed since the snapshot? + skip_chars = decoded_chars - len(self._decoded_text) if skip_chars == 0: # We haven't moved from the snapshot point. - return self._pack_cookie(position, dec_flags) + return self._encode_tell_cookie(position, dec_flags) # Walk the decoder forward, one byte at a time, to find the minimum # input necessary to give us the decoded characters we need to skip. @@ -1373,8 +1373,8 @@ class TextIOWrapper(TextIOBase): if decoded_chars >= skip_chars: break else: - # We didn't get enough decoded data; signal EOF to get more. - decoded = decoder.decode(b"", final=True) + # We didn't get enough decoded data; send EOF to get more. + decoded = decoder.decode(b"", True) decoded_chars += len(decoded) need_eof = 1 if decoded_chars < skip_chars: @@ -1385,7 +1385,7 @@ class TextIOWrapper(TextIOBase): position += safe_fed_bytes fed_bytes -= safe_fed_bytes skip_chars -= safe_decoded_chars - return self._pack_cookie( + return self._encode_tell_cookie( position, dec_flags, fed_bytes, need_eof, skip_chars) finally: decoder.setstate(saved_state) @@ -1405,7 +1405,8 @@ class TextIOWrapper(TextIOBase): raise IOError("can't do nonzero end-relative seeks") self.flush() position = self.buffer.seek(0, 2) - self._clear_decoded_text() + self._decoded_text = "" + self._snapshot = None if self._decoder: self._decoder.reset() return position @@ -1418,70 +1419,48 @@ class TextIOWrapper(TextIOBase): # Seek back to the snapshot point. position, dec_flags, feed_bytes, need_eof, skip_chars = \ - self._unpack_cookie(cookie) + self._decode_tell_cookie(cookie) self.buffer.seek(position) - self._clear_decoded_text() + self._decoded_text = "" + self._snapshot = None if self._decoder or dec_flags or feed_bytes or need_eof: # Restore the decoder flags to their values from the snapshot. self._decoder = self._decoder or self._get_decoder() self._decoder.setstate((b"", dec_flags)) - self._snapshot = (dec_flags, b'') if feed_bytes or need_eof: # Feed feed_bytes bytes to the decoder. input_chunk = self.buffer.read(feed_bytes) - self._decoded_text = self._decoder.decode(input_chunk, need_eof) - if len(self._decoded_text) < skip_chars: + decoded = self._decoder.decode(input_chunk, need_eof) + if len(decoded) < skip_chars: raise IOError("can't restore logical file position") # Skip skip_chars of the decoded characters. - self._decoded_text_offset = skip_chars + self._decoded_text = decoded[skip_chars:] # Restore the snapshot. - self._snapshot = (dec_flags, input_chunk) + self._snapshot = (dec_flags, input_chunk, len(decoded)) return cookie - def _clear_decoded_text(self): - """Reset the _decoded_text buffer.""" - self._decoded_text = '' - self._decoded_text_offset = 0 - self._snapshot = None - - def _emit_decoded_text(self, n=None): - """Advance into the _decoded_text buffer.""" - offset = self._decoded_text_offset - if n is None: - text = self._decoded_text[offset:] - else: - text = self._decoded_text[offset:offset + n] - self._decoded_text_offset += len(text) - return text - - def _unemit_decoded_text(self, n): - """Rewind the _decoded_text buffer.""" - if self._decoded_text_offset < n: - raise AssertionError("unemit out of bounds") - self._decoded_text_offset -= n - def read(self, n=None): if n is None: n = -1 decoder = self._decoder or self._get_decoder() + result = self._decoded_text if n < 0: - # Read everything. - result = (self._emit_decoded_text() + - decoder.decode(self.buffer.read(), final=True)) - self._clear_decoded_text() + result += decoder.decode(self.buffer.read(), True) + self._decoded_text = "" + self._snapshot = None return result else: - # Keep reading chunks until we have n characters to return. - eof = False - result = self._emit_decoded_text(n) - while len(result) < n and not eof: - eof = not self._read_chunk() - result += self._emit_decoded_text(n - len(result)) - return result + while len(result) < n: + input_chunk, decoded = self._read_chunk() + result += decoded + if not input_chunk: + break + self._decoded_text = result[n:] + return result[:n] def __next__(self): self._telling = False @@ -1495,20 +1474,21 @@ class TextIOWrapper(TextIOBase): def readline(self, limit=None): if limit is None: limit = -1 + if limit >= 0: + # XXX Hack to support limit argument, for backwards compatibility + line = self.readline() + if len(line) <= limit: + return line + line, self._decoded_text = \ + line[:limit], line[limit:] + self._decoded_text + return line - # Grab all the decoded text (we will rewind any extra bits later). - line = self._emit_decoded_text() - + line = self._decoded_text start = 0 decoder = self._decoder or self._get_decoder() pos = endpos = None while True: - if limit >= 0 and len(line) >= limit: - # Length limit has been reached. - endpos = limit - break - if self._readtranslate: # Newlines are already translated, only search for \n pos = line.find('\n', start) @@ -1558,18 +1538,20 @@ class TextIOWrapper(TextIOBase): # No line ending seen yet - get more data more_line = '' - while self._read_chunk(): - if self._decoded_text: + while True: + readahead, pending = self._read_chunk() + more_line = pending + if more_line or not readahead: break - if self._decoded_text: - line += self._emit_decoded_text() + if more_line: + line += more_line else: # end of file - self._clear_decoded_text() + self._decoded_text = '' + self._snapshot = None return line - # Rewind _decoded_text to just after the line ending we found. - self._unemit_decoded_text(len(line) - endpos) + self._decoded_text = line[endpos:] return line[:endpos] @property |