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