NovaBryan/EVE_Dump
Log | Files | 📦 下载最新源码 (.zip) | Refs | README

utf_32.py (4344B)

      1 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\carbon\common\stdlib\encodings\utf_32.py
      2 import codecs, sys
      3 encode = codecs.utf_32_encode
      4 
      5 def decode(input, errors = 'strict'):
      6     return codecs.utf_32_decode(input, errors, True)
      7 
      8 
      9 class IncrementalEncoder(codecs.IncrementalEncoder):
     10 
     11     def __init__(self, errors = 'strict'):
     12         codecs.IncrementalEncoder.__init__(self, errors)
     13         self.encoder = None
     14 
     15     def encode(self, input, final = False):
     16         if self.encoder is None:
     17             result = codecs.utf_32_encode(input, self.errors)[0]
     18             if sys.byteorder == 'little':
     19                 self.encoder = codecs.utf_32_le_encode
     20             else:
     21                 self.encoder = codecs.utf_32_be_encode
     22             return result
     23         return self.encoder(input, self.errors)[0]
     24 
     25     def reset(self):
     26         codecs.IncrementalEncoder.reset(self)
     27         self.encoder = None
     28 
     29     def getstate(self):
     30         if self.encoder is None:
     31             return 2
     32         return 0
     33 
     34     def setstate(self, state):
     35         if state:
     36             self.encoder = None
     37         elif sys.byteorder == 'little':
     38             self.encoder = codecs.utf_32_le_encode
     39         else:
     40             self.encoder = codecs.utf_32_be_encode
     41 
     42 
     43 class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
     44 
     45     def __init__(self, errors = 'strict'):
     46         codecs.BufferedIncrementalDecoder.__init__(self, errors)
     47         self.decoder = None
     48 
     49     def _buffer_decode(self, input, errors, final):
     50         if self.decoder is None:
     51             output, consumed, byteorder = codecs.utf_32_ex_decode(input, errors, 0, final)
     52             if byteorder == -1:
     53                 self.decoder = codecs.utf_32_le_decode
     54             elif byteorder == 1:
     55                 self.decoder = codecs.utf_32_be_decode
     56             elif consumed >= 4:
     57                 raise UnicodeError('UTF-32 stream does not start with BOM')
     58             return (output, consumed)
     59         return self.decoder(input, self.errors, final)
     60 
     61     def reset(self):
     62         codecs.BufferedIncrementalDecoder.reset(self)
     63         self.decoder = None
     64 
     65     def getstate(self):
     66         state = codecs.BufferedIncrementalDecoder.getstate(self)[0]
     67         if self.decoder is None:
     68             return (state, 2)
     69         addstate = int((sys.byteorder == 'big') != (self.decoder is codecs.utf_32_be_decode))
     70         return (state, addstate)
     71 
     72     def setstate(self, state):
     73         codecs.BufferedIncrementalDecoder.setstate(self, state)
     74         state = state[1]
     75         if state == 0:
     76             self.decoder = codecs.utf_32_be_decode if sys.byteorder == 'big' else codecs.utf_32_le_decode
     77         elif state == 1:
     78             self.decoder = codecs.utf_32_le_decode if sys.byteorder == 'big' else codecs.utf_32_be_decode
     79         else:
     80             self.decoder = None
     81 
     82 
     83 class StreamWriter(codecs.StreamWriter):
     84 
     85     def __init__(self, stream, errors = 'strict'):
     86         self.encoder = None
     87         codecs.StreamWriter.__init__(self, stream, errors)
     88 
     89     def reset(self):
     90         codecs.StreamWriter.reset(self)
     91         self.encoder = None
     92 
     93     def encode(self, input, errors = 'strict'):
     94         if self.encoder is None:
     95             result = codecs.utf_32_encode(input, errors)
     96             if sys.byteorder == 'little':
     97                 self.encoder = codecs.utf_32_le_encode
     98             else:
     99                 self.encoder = codecs.utf_32_be_encode
    100             return result
    101         else:
    102             return self.encoder(input, errors)
    103 
    104 
    105 class StreamReader(codecs.StreamReader):
    106 
    107     def reset(self):
    108         codecs.StreamReader.reset(self)
    109         try:
    110             del self.decode
    111         except AttributeError:
    112             pass
    113 
    114     def decode(self, input, errors = 'strict'):
    115         object, consumed, byteorder = codecs.utf_32_ex_decode(input, errors, 0, False)
    116         if byteorder == -1:
    117             self.decode = codecs.utf_32_le_decode
    118         elif byteorder == 1:
    119             self.decode = codecs.utf_32_be_decode
    120         elif consumed >= 4:
    121             raise UnicodeError, 'UTF-32 stream does not start with BOM'
    122         return (object, consumed)
    123 
    124 
    125 def getregentry():
    126     return codecs.CodecInfo(name='utf-32', encode=encode, decode=decode, incrementalencoder=IncrementalEncoder, incrementaldecoder=IncrementalDecoder, streamreader=StreamReader, streamwriter=StreamWriter)