Spaces:
Runtime error
Runtime error
| # This module contains abstractions for the input stream. You don't have to | |
| # looks further, there are no pretty code. | |
| # | |
| # We define two classes here. | |
| # | |
| # Mark(source, line, column) | |
| # It's just a record and its only use is producing nice error messages. | |
| # Parser does not use it for any other purposes. | |
| # | |
| # Reader(source, data) | |
| # Reader determines the encoding of `data` and converts it to unicode. | |
| # Reader provides the following methods and attributes: | |
| # reader.peek(length=1) - return the next `length` characters | |
| # reader.forward(length=1) - move the current position to `length` characters. | |
| # reader.index - the number of the current character. | |
| # reader.line, stream.column - the line and the column of the current character. | |
| __all__ = ['Reader', 'ReaderError'] | |
| from .error import YAMLError, Mark | |
| import codecs, re | |
| class ReaderError(YAMLError): | |
| def __init__(self, name, position, character, encoding, reason): | |
| self.name = name | |
| self.character = character | |
| self.position = position | |
| self.encoding = encoding | |
| self.reason = reason | |
| def __str__(self): | |
| if isinstance(self.character, bytes): | |
| return "'%s' codec can't decode byte #x%02x: %s\n" \ | |
| " in \"%s\", position %d" \ | |
| % (self.encoding, ord(self.character), self.reason, | |
| self.name, self.position) | |
| else: | |
| return "unacceptable character #x%04x: %s\n" \ | |
| " in \"%s\", position %d" \ | |
| % (self.character, self.reason, | |
| self.name, self.position) | |
| class Reader(object): | |
| # Reader: | |
| # - determines the data encoding and converts it to a unicode string, | |
| # - checks if characters are in allowed range, | |
| # - adds '\0' to the end. | |
| # Reader accepts | |
| # - a `bytes` object, | |
| # - a `str` object, | |
| # - a file-like object with its `read` method returning `str`, | |
| # - a file-like object with its `read` method returning `unicode`. | |
| # Yeah, it's ugly and slow. | |
| def __init__(self, stream): | |
| self.name = None | |
| self.stream = None | |
| self.stream_pointer = 0 | |
| self.eof = True | |
| self.buffer = '' | |
| self.pointer = 0 | |
| self.raw_buffer = None | |
| self.raw_decode = None | |
| self.encoding = None | |
| self.index = 0 | |
| self.line = 0 | |
| self.column = 0 | |
| if isinstance(stream, str): | |
| self.name = "<unicode string>" | |
| self.check_printable(stream) | |
| self.buffer = stream+'\0' | |
| elif isinstance(stream, bytes): | |
| self.name = "<byte string>" | |
| self.raw_buffer = stream | |
| self.determine_encoding() | |
| else: | |
| self.stream = stream | |
| self.name = getattr(stream, 'name', "<file>") | |
| self.eof = False | |
| self.raw_buffer = None | |
| self.determine_encoding() | |
| def peek(self, index=0): | |
| try: | |
| return self.buffer[self.pointer+index] | |
| except IndexError: | |
| self.update(index+1) | |
| return self.buffer[self.pointer+index] | |
| def prefix(self, length=1): | |
| if self.pointer+length >= len(self.buffer): | |
| self.update(length) | |
| return self.buffer[self.pointer:self.pointer+length] | |
| def forward(self, length=1): | |
| if self.pointer+length+1 >= len(self.buffer): | |
| self.update(length+1) | |
| while length: | |
| ch = self.buffer[self.pointer] | |
| self.pointer += 1 | |
| self.index += 1 | |
| if ch in '\n\x85\u2028\u2029' \ | |
| or (ch == '\r' and self.buffer[self.pointer] != '\n'): | |
| self.line += 1 | |
| self.column = 0 | |
| elif ch != '\uFEFF': | |
| self.column += 1 | |
| length -= 1 | |
| def get_mark(self): | |
| if self.stream is None: | |
| return Mark(self.name, self.index, self.line, self.column, | |
| self.buffer, self.pointer) | |
| else: | |
| return Mark(self.name, self.index, self.line, self.column, | |
| None, None) | |
| def determine_encoding(self): | |
| while not self.eof and (self.raw_buffer is None or len(self.raw_buffer) < 2): | |
| self.update_raw() | |
| if isinstance(self.raw_buffer, bytes): | |
| if self.raw_buffer.startswith(codecs.BOM_UTF16_LE): | |
| self.raw_decode = codecs.utf_16_le_decode | |
| self.encoding = 'utf-16-le' | |
| elif self.raw_buffer.startswith(codecs.BOM_UTF16_BE): | |
| self.raw_decode = codecs.utf_16_be_decode | |
| self.encoding = 'utf-16-be' | |
| else: | |
| self.raw_decode = codecs.utf_8_decode | |
| self.encoding = 'utf-8' | |
| self.update(1) | |
| NON_PRINTABLE = re.compile('[^\x09\x0A\x0D\x20-\x7E\x85\xA0-\uD7FF\uE000-\uFFFD\U00010000-\U0010ffff]') | |
| def check_printable(self, data): | |
| match = self.NON_PRINTABLE.search(data) | |
| if match: | |
| character = match.group() | |
| position = self.index+(len(self.buffer)-self.pointer)+match.start() | |
| raise ReaderError(self.name, position, ord(character), | |
| 'unicode', "special characters are not allowed") | |
| def update(self, length): | |
| if self.raw_buffer is None: | |
| return | |
| self.buffer = self.buffer[self.pointer:] | |
| self.pointer = 0 | |
| while len(self.buffer) < length: | |
| if not self.eof: | |
| self.update_raw() | |
| if self.raw_decode is not None: | |
| try: | |
| data, converted = self.raw_decode(self.raw_buffer, | |
| 'strict', self.eof) | |
| except UnicodeDecodeError as exc: | |
| character = self.raw_buffer[exc.start] | |
| if self.stream is not None: | |
| position = self.stream_pointer-len(self.raw_buffer)+exc.start | |
| else: | |
| position = exc.start | |
| raise ReaderError(self.name, position, character, | |
| exc.encoding, exc.reason) | |
| else: | |
| data = self.raw_buffer | |
| converted = len(data) | |
| self.check_printable(data) | |
| self.buffer += data | |
| self.raw_buffer = self.raw_buffer[converted:] | |
| if self.eof: | |
| self.buffer += '\0' | |
| self.raw_buffer = None | |
| break | |
| def update_raw(self, size=4096): | |
| data = self.stream.read(size) | |
| if self.raw_buffer is None: | |
| self.raw_buffer = data | |
| else: | |
| self.raw_buffer += data | |
| self.stream_pointer += len(data) | |
| if not data: | |
| self.eof = True | |