Lib/encodings/utf_32.py

   1 """
   2 Python 'utf-32' Codec
   3 """
   4 import codecs, sys
   5
   6 ### Codec APIs
   7
   8 encode = codecs.utf_32_encode
   9
  10 def decode(input, errors='strict'):
  11     return codecs.utf_32_decode(input, errors, True)
  12
  13 class IncrementalEncoder(codecs.IncrementalEncoder):
  14     def __init__(self, errors='strict'):
  15         codecs.IncrementalEncoder.__init__(self, errors)
  16         self.encoder = None
  17
  18     def encode(self, input, final=False):
  19         if self.encoder is None:
  20             result = codecs.utf_32_encode(input, self.errors)[0]
  21             if sys.byteorder == 'little':
  22                 self.encoder = codecs.utf_32_le_encode
  23             else:
  24                 self.encoder = codecs.utf_32_be_encode
  25             return result
  26         return self.encoder(input, self.errors)[0]
  27
  28     def reset(self):
  29         codecs.IncrementalEncoder.reset(self)
  30         self.encoder = None
  31
  32     def getstate(self):
  33         # state info we return to the caller:
  34         # 0: stream is in natural order for this platform
  35         # 2: endianness hasn't been determined yet
  36         # (we're never writing in unnatural order)
  37         return (2 if self.encoder is None else 0)
  38
  39     def setstate(self, state):
  40         if state:
  41             self.encoder = None
  42         else:
  43             if sys.byteorder == 'little':
  44                 self.encoder = codecs.utf_32_le_encode
  45             else:
  46                 self.encoder = codecs.utf_32_be_encode
  47
  48 class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
  49     def __init__(self, errors='strict'):
  50         codecs.BufferedIncrementalDecoder.__init__(self, errors)
  51         self.decoder = None
  52
  53     def _buffer_decode(self, input, errors, final):
  54         if self.decoder is None:
  55             (output, consumed, byteorder) = \
  56                 codecs.utf_32_ex_decode(input, errors, 0, final)
  57             if byteorder == -1:
  58                 self.decoder = codecs.utf_32_le_decode
  59             elif byteorder == 1:
  60                 self.decoder = codecs.utf_32_be_decode
  61             elif consumed >= 4:
  62                 raise UnicodeError("UTF-32 stream does not start with BOM")
  63             return (output, consumed)
  64         return self.decoder(input, self.errors, final)
  65
  66     def reset(self):
  67         codecs.BufferedIncrementalDecoder.reset(self)
  68         self.decoder = None
  69
  70     def getstate(self):
  71         # additonal state info from the base class must be None here,
  72         # as it isn't passed along to the caller
  73         state = codecs.BufferedIncrementalDecoder.getstate(self)[0]
  74         # additional state info we pass to the caller:
  75         # 0: stream is in natural order for this platform
  76         # 1: stream is in unnatural order
  77         # 2: endianness hasn't been determined yet
  78         if self.decoder is None:
  79             return (state, 2)
  80         addstate = int((sys.byteorder == "big") !=
  81                        (self.decoder is codecs.utf_32_be_decode))
  82         return (state, addstate)
  83
  84     def setstate(self, state):
  85         # state[1] will be ignored by BufferedIncrementalDecoder.setstate()
  86         codecs.BufferedIncrementalDecoder.setstate(self, state)
  87         state = state[1]
  88         if state == 0:
  89             self.decoder = (codecs.utf_32_be_decode
  90                             if sys.byteorder == "big"
  91                             else codecs.utf_32_le_decode)
  92         elif state == 1:
  93             self.decoder = (codecs.utf_32_le_decode
  94                             if sys.byteorder == "big"
  95                             else codecs.utf_32_be_decode)
  96         else:
  97             self.decoder = None
  98
  99 class StreamWriter(codecs.StreamWriter):
 100     def __init__(self, stream, errors='strict'):
 101         self.bom_written = False
 102         codecs.StreamWriter.__init__(self, stream, errors)
 103
 104     def encode(self, input, errors='strict'):
 105         self.bom_written = True
 106         result = codecs.utf_32_encode(input, errors)
 107         if sys.byteorder == 'little':
 108             self.encode = codecs.utf_32_le_encode
 109         else:
 110             self.encode = codecs.utf_32_be_encode
 111         return result
 112
 113 class StreamReader(codecs.StreamReader):
 114
 115     def reset(self):
 116         codecs.StreamReader.reset(self)
 117         try:
 118             del self.decode
 119         except AttributeError:
 120             pass
 121
 122     def decode(self, input, errors='strict'):
 123         (object, consumed, byteorder) = \
 124             codecs.utf_32_ex_decode(input, errors, 0, False)
 125         if byteorder == -1:
 126             self.decode = codecs.utf_32_le_decode
 127         elif byteorder == 1:
 128             self.decode = codecs.utf_32_be_decode
 129         elif consumed>=4:
 130             raise UnicodeError,"UTF-32 stream does not start with BOM"
 131         return (object, consumed)
 132
 133 ### encodings module API
 134
 135 def getregentry():
 136     return codecs.CodecInfo(
 137         name='utf-32',
 138         encode=encode,
 139         decode=decode,
 140         incrementalencoder=IncrementalEncoder,
 141         incrementaldecoder=IncrementalDecoder,
 142         streamreader=StreamReader,
 143         streamwriter=StreamWriter,
 144     )