| """ | |
| Python 'utf-32' Codec | |
| """ | |
| import codecs, sys | |
| ### Codec APIs | |
| encode = codecs.utf_32_encode | |
| def decode(input, errors='strict'): | |
| return codecs.utf_32_decode(input, errors, True) | |
| class IncrementalEncoder(codecs.IncrementalEncoder): | |
| def __init__(self, errors='strict'): | |
| codecs.IncrementalEncoder.__init__(self, errors) | |
| self.encoder = None | |
| def encode(self, input, final=False): | |
| if self.encoder is None: | |
| result = codecs.utf_32_encode(input, self.errors)[0] | |
| if sys.byteorder == 'little': | |
| self.encoder = codecs.utf_32_le_encode | |
| else: | |
| self.encoder = codecs.utf_32_be_encode | |
| return result | |
| return self.encoder(input, self.errors)[0] | |
| def reset(self): | |
| codecs.IncrementalEncoder.reset(self) | |
| self.encoder = None | |
| def getstate(self): | |
| # state info we return to the caller: | |
| # 0: stream is in natural order for this platform | |
| # 2: endianness hasn't been determined yet | |
| # (we're never writing in unnatural order) | |
| return (2 if self.encoder is None else 0) | |
| def setstate(self, state): | |
| if state: | |
| self.encoder = None | |
| else: | |
| if sys.byteorder == 'little': | |
| self.encoder = codecs.utf_32_le_encode | |
| else: | |
| self.encoder = codecs.utf_32_be_encode | |
| class IncrementalDecoder(codecs.BufferedIncrementalDecoder): | |
| def __init__(self, errors='strict'): | |
| codecs.BufferedIncrementalDecoder.__init__(self, errors) | |
| self.decoder = None | |
| def _buffer_decode(self, input, errors, final): | |
| if self.decoder is None: | |
| (output, consumed, byteorder) = \ | |
| codecs.utf_32_ex_decode(input, errors, 0, final) | |
| if byteorder == -1: | |
| self.decoder = codecs.utf_32_le_decode | |
| elif byteorder == 1: | |
| self.decoder = codecs.utf_32_be_decode | |
| elif consumed >= 4: | |
| raise UnicodeError("UTF-32 stream does not start with BOM") | |
| return (output, consumed) | |
| return self.decoder(input, self.errors, final) | |
| def reset(self): | |
| codecs.BufferedIncrementalDecoder.reset(self) | |
| self.decoder = None | |
| def getstate(self): | |
| # additonal state info from the base class must be None here, | |
| # as it isn't passed along to the caller | |
| state = codecs.BufferedIncrementalDecoder.getstate(self)[0] | |
| # additional state info we pass to the caller: | |
| # 0: stream is in natural order for this platform | |
| # 1: stream is in unnatural order | |
| # 2: endianness hasn't been determined yet | |
| if self.decoder is None: | |
| return (state, 2) | |
| addstate = int((sys.byteorder == "big") != | |
| (self.decoder is codecs.utf_32_be_decode)) | |
| return (state, addstate) | |
| def setstate(self, state): | |
| # state[1] will be ignored by BufferedIncrementalDecoder.setstate() | |
| codecs.BufferedIncrementalDecoder.setstate(self, state) | |
| state = state[1] | |
| if state == 0: | |
| self.decoder = (codecs.utf_32_be_decode | |
| if sys.byteorder == "big" | |
| else codecs.utf_32_le_decode) | |
| elif state == 1: | |
| self.decoder = (codecs.utf_32_le_decode | |
| if sys.byteorder == "big" | |
| else codecs.utf_32_be_decode) | |
| else: | |
| self.decoder = None | |
| class StreamWriter(codecs.StreamWriter): | |
| def __init__(self, stream, errors='strict'): | |
| self.encoder = None | |
| codecs.StreamWriter.__init__(self, stream, errors) | |
| def reset(self): | |
| codecs.StreamWriter.reset(self) | |
| self.encoder = None | |
| def encode(self, input, errors='strict'): | |
| if self.encoder is None: | |
| result = codecs.utf_32_encode(input, errors) | |
| if sys.byteorder == 'little': | |
| self.encoder = codecs.utf_32_le_encode | |
| else: | |
| self.encoder = codecs.utf_32_be_encode | |
| return result | |
| else: | |
| return self.encoder(input, errors) | |
| class StreamReader(codecs.StreamReader): | |
| def reset(self): | |
| codecs.StreamReader.reset(self) | |
| try: | |
| del self.decode | |
| except AttributeError: | |
| pass | |
| def decode(self, input, errors='strict'): | |
| (object, consumed, byteorder) = \ | |
| codecs.utf_32_ex_decode(input, errors, 0, False) | |
| if byteorder == -1: | |
| self.decode = codecs.utf_32_le_decode | |
| elif byteorder == 1: | |
| self.decode = codecs.utf_32_be_decode | |
| elif consumed>=4: | |
| raise UnicodeError,"UTF-32 stream does not start with BOM" | |
| return (object, consumed) | |
| ### encodings module API | |
| def getregentry(): | |
| return codecs.CodecInfo( | |
| name='utf-32', | |
| encode=encode, | |
| decode=decode, | |
| incrementalencoder=IncrementalEncoder, | |
| incrementaldecoder=IncrementalDecoder, | |
| streamreader=StreamReader, | |
| streamwriter=StreamWriter, | |
| ) |