| """ Python 'utf-16' Codec |
| |
| |
| Written by Marc-Andre Lemburg (mal@lemburg.com). |
| |
| (c) Copyright CNRI, All Rights Reserved. NO WARRANTY. |
| |
| """ |
| import codecs, sys |
| |
| ### Codec APIs |
| |
| encode = codecs.utf_16_encode |
| |
| def decode(input, errors='strict'): |
| return codecs.utf_16_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_16_encode(input, self.errors)[0] |
| if sys.byteorder == 'little': |
| self.encoder = codecs.utf_16_le_encode |
| else: |
| self.encoder = codecs.utf_16_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_16_le_encode |
| else: |
| self.encoder = codecs.utf_16_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_16_ex_decode(input, errors, 0, final) |
| if byteorder == -1: |
| self.decoder = codecs.utf_16_le_decode |
| elif byteorder == 1: |
| self.decoder = codecs.utf_16_be_decode |
| elif consumed >= 2: |
| raise UnicodeError("UTF-16 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 |
| |
| class StreamWriter(codecs.StreamWriter): |
| def __init__(self, stream, errors='strict'): |
| codecs.StreamWriter.__init__(self, stream, errors) |
| self.encoder = None |
| |
| def reset(self): |
| codecs.StreamWriter.reset(self) |
| self.encoder = None |
| |
| def encode(self, input, errors='strict'): |
| if self.encoder is None: |
| result = codecs.utf_16_encode(input, errors) |
| if sys.byteorder == 'little': |
| self.encoder = codecs.utf_16_le_encode |
| else: |
| self.encoder = codecs.utf_16_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_16_ex_decode(input, errors, 0, False) |
| if byteorder == -1: |
| self.decode = codecs.utf_16_le_decode |
| elif byteorder == 1: |
| self.decode = codecs.utf_16_be_decode |
| elif consumed>=2: |
| raise UnicodeError,"UTF-16 stream does not start with BOM" |
| return (object, consumed) |
| |
| ### encodings module API |
| |
| def getregentry(): |
| return codecs.CodecInfo( |
| name='utf-16', |
| encode=encode, |
| decode=decode, |
| incrementalencoder=IncrementalEncoder, |
| incrementaldecoder=IncrementalDecoder, |
| streamreader=StreamReader, |
| streamwriter=StreamWriter, |
| ) |
