home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_1507 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  17.9 KB  |  563 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __docformat__ = 'restructuredtext'
  5. __author__ = 'Walter Doerwald'
  6. __version__ = '$Id: util.py 1114 2008-03-05 13:22:59Z cthedot $'
  7. import codecs
  8. import marshal
  9.  
  10. def detectencoding_str(input, final = False):
  11.     CANDIDATE_UTF_8_SIG = 1
  12.     CANDIDATE_UTF_16_AS_LE = 2
  13.     CANDIDATE_UTF_16_AS_BE = 4
  14.     CANDIDATE_UTF_16_LE = 8
  15.     CANDIDATE_UTF_16_BE = 16
  16.     CANDIDATE_UTF_32_AS_LE = 32
  17.     CANDIDATE_UTF_32_AS_BE = 64
  18.     CANDIDATE_UTF_32_LE = 128
  19.     CANDIDATE_UTF_32_BE = 256
  20.     CANDIDATE_CHARSET = 512
  21.     candidates = 1023
  22.     li = len(input)
  23.     if li >= 1:
  24.         c = input[0]
  25.         if c != '\xef':
  26.             candidates &= ~CANDIDATE_UTF_8_SIG
  27.         
  28.         if c != '\xff':
  29.             candidates &= ~(CANDIDATE_UTF_32_AS_LE | CANDIDATE_UTF_16_AS_LE)
  30.         
  31.         if c != '\xfe':
  32.             candidates &= ~CANDIDATE_UTF_16_AS_BE
  33.         
  34.         if c != '@':
  35.             candidates &= ~(CANDIDATE_UTF_32_LE | CANDIDATE_UTF_16_LE | CANDIDATE_CHARSET)
  36.         
  37.         if c != '\x00':
  38.             candidates &= ~(CANDIDATE_UTF_32_AS_BE | CANDIDATE_UTF_32_BE | CANDIDATE_UTF_16_BE)
  39.         
  40.         if li >= 2:
  41.             c = input[1]
  42.             if c != '\xbb':
  43.                 candidates &= ~CANDIDATE_UTF_8_SIG
  44.             
  45.             if c != '\xfe':
  46.                 candidates &= ~(CANDIDATE_UTF_16_AS_LE | CANDIDATE_UTF_32_AS_LE)
  47.             
  48.             if c != '\xff':
  49.                 candidates &= ~CANDIDATE_UTF_16_AS_BE
  50.             
  51.             if c != '\x00':
  52.                 candidates &= ~(CANDIDATE_UTF_16_LE | CANDIDATE_UTF_32_AS_BE | CANDIDATE_UTF_32_LE | CANDIDATE_UTF_32_BE)
  53.             
  54.             if c != '@':
  55.                 candidates &= ~CANDIDATE_UTF_16_BE
  56.             
  57.             if c != 'c':
  58.                 candidates &= ~CANDIDATE_CHARSET
  59.             
  60.             if li >= 3:
  61.                 c = input[2]
  62.                 if c != '\xbf':
  63.                     candidates &= ~CANDIDATE_UTF_8_SIG
  64.                 
  65.                 if c != 'c':
  66.                     candidates &= ~CANDIDATE_UTF_16_LE
  67.                 
  68.                 if c != '\x00':
  69.                     candidates &= ~(CANDIDATE_UTF_32_AS_LE | CANDIDATE_UTF_32_LE | CANDIDATE_UTF_32_BE)
  70.                 
  71.                 if c != '\xfe':
  72.                     candidates &= ~CANDIDATE_UTF_32_AS_BE
  73.                 
  74.                 if c != 'h':
  75.                     candidates &= ~CANDIDATE_CHARSET
  76.                 
  77.                 if li >= 4:
  78.                     c = input[3]
  79.                     if input[2:4] == '\x00\x00':
  80.                         candidates &= ~CANDIDATE_UTF_16_AS_LE
  81.                     
  82.                     if c != '\x00':
  83.                         candidates &= ~(CANDIDATE_UTF_16_LE | CANDIDATE_UTF_32_AS_LE | CANDIDATE_UTF_32_LE)
  84.                     
  85.                     if c != '\xff':
  86.                         candidates &= ~CANDIDATE_UTF_32_AS_BE
  87.                     
  88.                     if c != '@':
  89.                         candidates &= ~CANDIDATE_UTF_32_BE
  90.                     
  91.                     if c != 'a':
  92.                         candidates &= ~CANDIDATE_CHARSET
  93.                     
  94.                 
  95.             
  96.         
  97.     
  98.     if candidates == 0:
  99.         return ('utf-8', False)
  100.     if final:
  101.         return ('utf-8', False)
  102.     return (None, False)
  103.  
  104.  
  105. def detectencoding_unicode(input, final = False):
  106.     prefix = u'@charset "'
  107.     if input.startswith(prefix):
  108.         pos = input.find(u'"', len(prefix))
  109.         if pos >= 0:
  110.             return (input[len(prefix):pos], True)
  111.     elif final or not prefix.startswith(input):
  112.         return ('utf-8', False)
  113.     return (None, False)
  114.  
  115.  
  116. def _fixencoding(input, encoding, final = False):
  117.     prefix = u'@charset "'
  118.     if len(input) > len(prefix):
  119.         if input.startswith(prefix):
  120.             pos = input.find(u'"', len(prefix))
  121.             if pos >= 0:
  122.                 if encoding.replace('_', '-').lower() == 'utf-8-sig':
  123.                     encoding = u'utf-8'
  124.                 
  125.                 return prefix + encoding + input[pos:]
  126.         else:
  127.             return input
  128.     input.startswith(prefix)
  129.     if not prefix.startswith(input) or final:
  130.         return input
  131.     if final:
  132.         return input
  133.  
  134.  
  135. def decode(input, errors = 'strict', encoding = None, force = True):
  136.     if encoding is None or not force:
  137.         (_encoding, explicit) = detectencoding_str(input, True)
  138.         if _encoding == 'css':
  139.             raise ValueError('css not allowed as encoding name')
  140.         _encoding == 'css'
  141.         if explicit or not force or encoding is None:
  142.             encoding = _encoding
  143.         
  144.     
  145.     (input, consumed) = codecs.getdecoder(encoding)(input, errors)
  146.     return (_fixencoding(input, unicode(encoding), True), consumed)
  147.  
  148.  
  149. def encode(input, errors = 'strict', encoding = None):
  150.     consumed = len(input)
  151.     if encoding is None:
  152.         encoding = detectencoding_unicode(input, True)[0]
  153.         if encoding.replace('_', '-').lower() == 'utf-8-sig':
  154.             input = _fixencoding(input, u'utf-8', True)
  155.         
  156.     else:
  157.         input = _fixencoding(input, unicode(encoding), True)
  158.     if encoding == 'css':
  159.         raise ValueError('css not allowed as encoding name')
  160.     encoding == 'css'
  161.     encoder = codecs.getencoder(encoding)
  162.     return (encoder(input, errors)[0], consumed)
  163.  
  164.  
  165. def _bytes2int(bytes):
  166.     i = 0
  167.     for byte in bytes:
  168.         i = (i << 8) + ord(byte)
  169.     
  170.     return i
  171.  
  172.  
  173. def _int2bytes(i):
  174.     v = []
  175.     while i:
  176.         v.insert(0, chr(i & 255))
  177.         i >>= 8
  178.     return ''.join(v)
  179.  
  180. if hasattr(codecs, 'IncrementalDecoder'):
  181.     
  182.     class IncrementalDecoder(codecs.IncrementalDecoder):
  183.         
  184.         def __init__(self, errors = 'strict', encoding = None, force = True):
  185.             self.decoder = None
  186.             self.encoding = encoding
  187.             self.force = force
  188.             codecs.IncrementalDecoder.__init__(self, errors)
  189.             self._errors = errors
  190.             self.buffer = ''
  191.             self.headerfixed = False
  192.  
  193.         
  194.         def iterdecode(self, input):
  195.             for part in input:
  196.                 result = self.decode(part, False)
  197.                 if result:
  198.                     yield result
  199.                     continue
  200.             
  201.             result = self.decode('', True)
  202.             if result:
  203.                 yield result
  204.             
  205.  
  206.         
  207.         def decode(self, input, final = False):
  208.             if self.decoder is None:
  209.                 input = self.buffer + input
  210.                 if self.encoding is None or not (self.force):
  211.                     (encoding, explicit) = detectencoding_str(input, final)
  212.                     if encoding is None:
  213.                         self.buffer = input
  214.                         return u''
  215.                     if encoding == 'css':
  216.                         raise ValueError('css not allowed as encoding name')
  217.                     encoding == 'css'
  218.                     if explicit or not (self.force) or self.encoding is None:
  219.                         self.encoding = encoding
  220.                     
  221.                 
  222.                 self.buffer = ''
  223.                 decoder = codecs.getincrementaldecoder(self.encoding)
  224.                 self.decoder = decoder(self._errors)
  225.             
  226.             if self.headerfixed:
  227.                 return self.decoder.decode(input, final)
  228.             output = self.buffer + self.decoder.decode(input, final)
  229.             encoding = self.encoding
  230.             if encoding.replace('_', '-').lower() == 'utf-8-sig':
  231.                 encoding = 'utf-8'
  232.             
  233.             newoutput = _fixencoding(output, unicode(encoding), final)
  234.             if newoutput is None:
  235.                 self.buffer = output
  236.                 return u''
  237.             self.headerfixed = True
  238.             return newoutput
  239.  
  240.         
  241.         def reset(self):
  242.             codecs.IncrementalDecoder.reset(self)
  243.             self.decoder = None
  244.             self.buffer = ''
  245.             self.headerfixed = False
  246.  
  247.         
  248.         def _geterrors(self):
  249.             return self._errors
  250.  
  251.         
  252.         def _seterrors(self, errors):
  253.             if self.decoder is not None:
  254.                 self.decoder.errors = errors
  255.             
  256.             self._errors = errors
  257.  
  258.         errors = property(_geterrors, _seterrors)
  259.         
  260.         def getstate(self):
  261.             if self.decoder is not None:
  262.                 state = (self.encoding, self.buffer, self.headerfixed, True, self.decoder.getstate())
  263.             else:
  264.                 state = (self.encoding, self.buffer, self.headerfixed, False, None)
  265.             return ('', _bytes2int(marshal.dumps(state)))
  266.  
  267.         
  268.         def setstate(self, state):
  269.             state = _int2bytes(marshal.loads(state[1]))
  270.             self.encoding = state[0]
  271.             self.buffer = state[1]
  272.             self.headerfixed = state[2]
  273.             if state[3] is not None:
  274.                 self.decoder = codecs.getincrementaldecoder(self.encoding)(self._errors)
  275.                 self.decoder.setstate(state[4])
  276.             else:
  277.                 self.decoder = None
  278.  
  279.  
  280.  
  281. if hasattr(codecs, 'IncrementalEncoder'):
  282.     
  283.     class IncrementalEncoder(codecs.IncrementalEncoder):
  284.         
  285.         def __init__(self, errors = 'strict', encoding = None):
  286.             self.encoder = None
  287.             self.encoding = encoding
  288.             codecs.IncrementalEncoder.__init__(self, errors)
  289.             self._errors = errors
  290.             self.buffer = u''
  291.  
  292.         
  293.         def iterencode(self, input):
  294.             for part in input:
  295.                 result = self.encode(part, False)
  296.                 if result:
  297.                     yield result
  298.                     continue
  299.             
  300.             result = self.encode(u'', True)
  301.             if result:
  302.                 yield result
  303.             
  304.  
  305.         
  306.         def encode(self, input, final = False):
  307.             if self.encoder is None:
  308.                 input = self.buffer + input
  309.                 if self.encoding is not None:
  310.                     encoding = self.encoding
  311.                     if encoding.replace('_', '-').lower() == 'utf-8-sig':
  312.                         encoding = 'utf-8'
  313.                     
  314.                     newinput = _fixencoding(input, unicode(encoding), final)
  315.                     if newinput is None:
  316.                         self.buffer = input
  317.                         return ''
  318.                     input = newinput
  319.                 else:
  320.                     self.encoding = detectencoding_unicode(input, final)[0]
  321.                 if self.encoding is not None:
  322.                     if self.encoding == 'css':
  323.                         raise ValueError('css not allowed as encoding name')
  324.                     self.encoding == 'css'
  325.                     info = codecs.lookup(self.encoding)
  326.                     encoding = self.encoding
  327.                     if self.encoding.replace('_', '-').lower() == 'utf-8-sig':
  328.                         input = _fixencoding(input, u'utf-8', True)
  329.                     
  330.                     self.encoder = info.incrementalencoder(self._errors)
  331.                     self.buffer = u''
  332.                 else:
  333.                     self.buffer = input
  334.                     return ''
  335.             self.encoding is not None
  336.             return self.encoder.encode(input, final)
  337.  
  338.         
  339.         def reset(self):
  340.             codecs.IncrementalEncoder.reset(self)
  341.             self.encoder = None
  342.             self.buffer = u''
  343.  
  344.         
  345.         def _geterrors(self):
  346.             return self._errors
  347.  
  348.         
  349.         def _seterrors(self, errors):
  350.             if self.encoder is not None:
  351.                 self.encoder.errors = errors
  352.             
  353.             self._errors = errors
  354.  
  355.         errors = property(_geterrors, _seterrors)
  356.         
  357.         def getstate(self):
  358.             if self.encoder is not None:
  359.                 state = (self.encoding, self.buffer, True, self.encoder.getstate())
  360.             else:
  361.                 state = (self.encoding, self.buffer, False, None)
  362.             return _bytes2int(marshal.dumps(state))
  363.  
  364.         
  365.         def setstate(self, state):
  366.             state = _int2bytes(marshal.loads(state))
  367.             self.encoding = state[0]
  368.             self.buffer = state[1]
  369.             if state[2] is not None:
  370.                 self.encoder = codecs.getincrementalencoder(self.encoding)(self._errors)
  371.                 self.encoder.setstate(state[4])
  372.             else:
  373.                 self.encoder = None
  374.  
  375.  
  376.  
  377.  
  378. class StreamWriter(codecs.StreamWriter):
  379.     
  380.     def __init__(self, stream, errors = 'strict', encoding = None, header = False):
  381.         codecs.StreamWriter.__init__(self, stream, errors)
  382.         self.streamwriter = None
  383.         self.encoding = encoding
  384.         self._errors = errors
  385.         self.buffer = u''
  386.  
  387.     
  388.     def encode(self, input, errors = 'strict'):
  389.         li = len(input)
  390.         if self.streamwriter is None:
  391.             input = self.buffer + input
  392.             li = len(input)
  393.             if self.encoding is not None:
  394.                 encoding = self.encoding
  395.                 if encoding.replace('_', '-').lower() == 'utf-8-sig':
  396.                     encoding = 'utf-8'
  397.                 
  398.                 newinput = _fixencoding(input, unicode(encoding), False)
  399.                 if newinput is None:
  400.                     self.buffer = input
  401.                     return ('', 0)
  402.                 input = newinput
  403.             else:
  404.                 self.encoding = detectencoding_unicode(input, False)[0]
  405.             if self.encoding is not None:
  406.                 if self.encoding == 'css':
  407.                     raise ValueError('css not allowed as encoding name')
  408.                 self.encoding == 'css'
  409.                 self.streamwriter = codecs.getwriter(self.encoding)(self.stream, self._errors)
  410.                 encoding = self.encoding
  411.                 if self.encoding.replace('_', '-').lower() == 'utf-8-sig':
  412.                     input = _fixencoding(input, u'utf-8', True)
  413.                 
  414.                 self.buffer = u''
  415.             else:
  416.                 self.buffer = input
  417.                 return ('', 0)
  418.         self.encoding is not None
  419.         return (self.streamwriter.encode(input, errors)[0], li)
  420.  
  421.     
  422.     def _geterrors(self):
  423.         return self._errors
  424.  
  425.     
  426.     def _seterrors(self, errors):
  427.         if self.streamwriter is not None:
  428.             self.streamwriter.errors = errors
  429.         
  430.         self._errors = errors
  431.  
  432.     errors = property(_geterrors, _seterrors)
  433.  
  434.  
  435. class StreamReader(codecs.StreamReader):
  436.     
  437.     def __init__(self, stream, errors = 'strict', encoding = None, force = True):
  438.         codecs.StreamReader.__init__(self, stream, errors)
  439.         self.streamreader = None
  440.         self.encoding = encoding
  441.         self.force = force
  442.         self._errors = errors
  443.  
  444.     
  445.     def decode(self, input, errors = 'strict'):
  446.         if self.streamreader is None:
  447.             if self.encoding is None or not (self.force):
  448.                 (encoding, explicit) = detectencoding_str(input, False)
  449.                 if encoding is None:
  450.                     return (u'', 0)
  451.                 if encoding == 'css':
  452.                     raise ValueError('css not allowed as encoding name')
  453.                 encoding == 'css'
  454.                 if explicit or not (self.force) or self.encoding is None:
  455.                     self.encoding = encoding
  456.                 
  457.             
  458.             streamreader = codecs.getreader(self.encoding)
  459.             streamreader = streamreader(self.stream, self._errors)
  460.             (output, consumed) = streamreader.decode(input, errors)
  461.             encoding = self.encoding
  462.             if encoding.replace('_', '-').lower() == 'utf-8-sig':
  463.                 encoding = 'utf-8'
  464.             
  465.             newoutput = _fixencoding(output, unicode(encoding), False)
  466.             if newoutput is not None:
  467.                 self.streamreader = streamreader
  468.                 return (newoutput, consumed)
  469.             return (u'', 0)
  470.         return self.streamreader.decode(input, errors)
  471.  
  472.     
  473.     def _geterrors(self):
  474.         return self._errors
  475.  
  476.     
  477.     def _seterrors(self, errors):
  478.         if self.streamreader is not None:
  479.             self.streamreader.errors = errors
  480.         
  481.         self._errors = errors
  482.  
  483.     errors = property(_geterrors, _seterrors)
  484.  
  485. if hasattr(codecs, 'CodecInfo'):
  486.     
  487.     def search_function(name):
  488.         if name == 'css':
  489.             return codecs.CodecInfo(name = 'css', encode = encode, decode = decode, incrementalencoder = IncrementalEncoder, incrementaldecoder = IncrementalDecoder, streamwriter = StreamWriter, streamreader = StreamReader)
  490.  
  491. else:
  492.     
  493.     def utf8sig_encode(input, errors = 'strict'):
  494.         return (codecs.BOM_UTF8 + codecs.utf_8_encode(input, errors)[0], len(input))
  495.  
  496.     
  497.     def utf8sig_decode(input, errors = 'strict'):
  498.         prefix = 0
  499.         if input[:3] == codecs.BOM_UTF8:
  500.             input = input[3:]
  501.             prefix = 3
  502.         
  503.         (output, consumed) = codecs.utf_8_decode(input, errors, True)
  504.         return (output, consumed + prefix)
  505.  
  506.     
  507.     class UTF8SigStreamWriter(codecs.StreamWriter):
  508.         
  509.         def reset(self):
  510.             codecs.StreamWriter.reset(self)
  511.             
  512.             try:
  513.                 del self.encode
  514.             except AttributeError:
  515.                 pass
  516.  
  517.  
  518.         
  519.         def encode(self, input, errors = 'strict'):
  520.             self.encode = codecs.utf_8_encode
  521.             return utf8sig_encode(input, errors)
  522.  
  523.  
  524.     
  525.     class UTF8SigStreamReader(codecs.StreamReader):
  526.         
  527.         def reset(self):
  528.             codecs.StreamReader.reset(self)
  529.             
  530.             try:
  531.                 del self.decode
  532.             except AttributeError:
  533.                 pass
  534.  
  535.  
  536.         
  537.         def decode(self, input, errors = 'strict'):
  538.             if len(input) < 3 and codecs.BOM_UTF8.startswith(input):
  539.                 return (u'', 0)
  540.             self.decode = codecs.utf_8_decode
  541.             return utf8sig_decode(input, errors)
  542.  
  543.  
  544.     
  545.     def search_function(name):
  546.         import encodings
  547.         name = encodings.normalize_encoding(name)
  548.         if name == 'css':
  549.             return (encode, decode, StreamReader, StreamWriter)
  550.         if name == 'utf_8_sig':
  551.             return (utf8sig_encode, utf8sig_decode, UTF8SigStreamReader, UTF8SigStreamWriter)
  552.  
  553. codecs.register(search_function)
  554.  
  555. def cssescape(exc):
  556.     if not isinstance(exc, UnicodeEncodeError):
  557.         raise TypeError("don't know how to handle %r" % exc)
  558.     isinstance(exc, UnicodeEncodeError)
  559.     return (u''.join((lambda .0: for c in .0:
  560. u'\\%06x' % ord(c))(exc.object[exc.start:exc.end])), exc.end)
  561.  
  562. codecs.register_error('cssescape', cssescape)
  563.