home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / lib / python2.6 / encodings / utf_32.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-04-20  |  5.4 KB  |  146 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. """
  5. Python 'utf-32' Codec
  6. """
  7. import codecs
  8. import sys
  9. encode = codecs.utf_32_encode
  10.  
  11. def decode(input, errors = 'strict'):
  12.     return codecs.utf_32_decode(input, errors, True)
  13.  
  14.  
  15. class IncrementalEncoder(codecs.IncrementalEncoder):
  16.     
  17.     def __init__(self, errors = 'strict'):
  18.         codecs.IncrementalEncoder.__init__(self, errors)
  19.         self.encoder = None
  20.  
  21.     
  22.     def encode(self, input, final = False):
  23.         if self.encoder is None:
  24.             result = codecs.utf_32_encode(input, self.errors)[0]
  25.             if sys.byteorder == 'little':
  26.                 self.encoder = codecs.utf_32_le_encode
  27.             else:
  28.                 self.encoder = codecs.utf_32_be_encode
  29.             return result
  30.         return self.encoder(input, self.errors)[0]
  31.  
  32.     
  33.     def reset(self):
  34.         codecs.IncrementalEncoder.reset(self)
  35.         self.encoder = None
  36.  
  37.     
  38.     def getstate(self):
  39.         if self.encoder is None:
  40.             return 2
  41.         return 0
  42.  
  43.     
  44.     def setstate(self, state):
  45.         if state:
  46.             self.encoder = None
  47.         elif sys.byteorder == 'little':
  48.             self.encoder = codecs.utf_32_le_encode
  49.         else:
  50.             self.encoder = codecs.utf_32_be_encode
  51.  
  52.  
  53.  
  54. class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
  55.     
  56.     def __init__(self, errors = 'strict'):
  57.         codecs.BufferedIncrementalDecoder.__init__(self, errors)
  58.         self.decoder = None
  59.  
  60.     
  61.     def _buffer_decode(self, input, errors, final):
  62.         if self.decoder is None:
  63.             (output, consumed, byteorder) = codecs.utf_32_ex_decode(input, errors, 0, final)
  64.             if byteorder == -1:
  65.                 self.decoder = codecs.utf_32_le_decode
  66.             elif byteorder == 1:
  67.                 self.decoder = codecs.utf_32_be_decode
  68.             elif consumed >= 4:
  69.                 raise UnicodeError('UTF-32 stream does not start with BOM')
  70.             
  71.             return (output, consumed)
  72.         return self.decoder(input, self.errors, final)
  73.  
  74.     
  75.     def reset(self):
  76.         codecs.BufferedIncrementalDecoder.reset(self)
  77.         self.decoder = None
  78.  
  79.     
  80.     def getstate(self):
  81.         state = codecs.BufferedIncrementalDecoder.getstate(self)[0]
  82.         if self.decoder is None:
  83.             return (state, 2)
  84.         addstate = int(sys.byteorder == 'big' != (self.decoder is codecs.utf_32_be_decode))
  85.         return (state, addstate)
  86.  
  87.     
  88.     def setstate(self, state):
  89.         codecs.BufferedIncrementalDecoder.setstate(self, state)
  90.         state = state[1]
  91.         if state == 0:
  92.             self.decoder = None if sys.byteorder == 'big' else codecs.utf_32_le_decode
  93.         elif state == 1:
  94.             self.decoder = None if sys.byteorder == 'big' else codecs.utf_32_be_decode
  95.         else:
  96.             self.decoder = None
  97.  
  98.  
  99.  
  100. class StreamWriter(codecs.StreamWriter):
  101.     
  102.     def __init__(self, stream, errors = 'strict'):
  103.         self.bom_written = False
  104.         codecs.StreamWriter.__init__(self, stream, errors)
  105.  
  106.     
  107.     def encode(self, input, errors = 'strict'):
  108.         self.bom_written = True
  109.         result = codecs.utf_32_encode(input, errors)
  110.         if sys.byteorder == 'little':
  111.             self.encode = codecs.utf_32_le_encode
  112.         else:
  113.             self.encode = codecs.utf_32_be_encode
  114.         return result
  115.  
  116.  
  117.  
  118. class StreamReader(codecs.StreamReader):
  119.     
  120.     def reset(self):
  121.         codecs.StreamReader.reset(self)
  122.         
  123.         try:
  124.             del self.decode
  125.         except AttributeError:
  126.             pass
  127.  
  128.  
  129.     
  130.     def decode(self, input, errors = 'strict'):
  131.         (object, consumed, byteorder) = codecs.utf_32_ex_decode(input, errors, 0, False)
  132.         if byteorder == -1:
  133.             self.decode = codecs.utf_32_le_decode
  134.         elif byteorder == 1:
  135.             self.decode = codecs.utf_32_be_decode
  136.         elif consumed >= 4:
  137.             raise UnicodeError, 'UTF-32 stream does not start with BOM'
  138.         
  139.         return (object, consumed)
  140.  
  141.  
  142.  
  143. def getregentry():
  144.     return codecs.CodecInfo(name = 'utf-32', encode = encode, decode = decode, incrementalencoder = IncrementalEncoder, incrementaldecoder = IncrementalDecoder, streamreader = StreamReader, streamwriter = StreamWriter)
  145.  
  146.