home *** CD-ROM | disk | FTP | other *** search
/ Chip 2011 November / CHIP_2011_11.iso / Programy / Narzedzia / Inkscape / Inkscape-0.48.2-1-win32.exe / python / Lib / encodings / utf_32.py < prev    next >
Encoding:
Python Source  |  2010-05-29  |  5.0 KB  |  145 lines
  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.     )
  145.