home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_1079 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  13.0 KB  |  423 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. from __future__ import with_statement
  5. __license__ = 'GPL v3'
  6. __copyright__ = '2010, Gerendi Sandor Attila'
  7. __docformat__ = 'restructuredtext en'
  8.  
  9. class tokenDelimitatorStart:
  10.     
  11.     def __init__(self):
  12.         pass
  13.  
  14.     
  15.     def toRTF(self):
  16.         return '{'
  17.  
  18.     
  19.     def __repr__(self):
  20.         return '{'
  21.  
  22.  
  23.  
  24. class tokenDelimitatorEnd:
  25.     
  26.     def __init__(self):
  27.         pass
  28.  
  29.     
  30.     def toRTF(self):
  31.         return '}'
  32.  
  33.     
  34.     def __repr__(self):
  35.         return '}'
  36.  
  37.  
  38.  
  39. class tokenControlWord:
  40.     
  41.     def __init__(self, name, separator = ''):
  42.         self.name = name
  43.         self.separator = separator
  44.  
  45.     
  46.     def toRTF(self):
  47.         return self.name + self.separator
  48.  
  49.     
  50.     def __repr__(self):
  51.         return self.name + self.separator
  52.  
  53.  
  54.  
  55. class tokenControlWordWithNumericArgument:
  56.     
  57.     def __init__(self, name, argument, separator = ''):
  58.         self.name = name
  59.         self.argument = argument
  60.         self.separator = separator
  61.  
  62.     
  63.     def toRTF(self):
  64.         return self.name + repr(self.argument) + self.separator
  65.  
  66.     
  67.     def __repr__(self):
  68.         return self.name + repr(self.argument) + self.separator
  69.  
  70.  
  71.  
  72. class tokenControlSymbol:
  73.     
  74.     def __init__(self, name):
  75.         self.name = name
  76.  
  77.     
  78.     def toRTF(self):
  79.         return self.name
  80.  
  81.     
  82.     def __repr__(self):
  83.         return self.name
  84.  
  85.  
  86.  
  87. class tokenData:
  88.     
  89.     def __init__(self, data):
  90.         self.data = data
  91.  
  92.     
  93.     def toRTF(self):
  94.         return self.data
  95.  
  96.     
  97.     def __repr__(self):
  98.         return self.data
  99.  
  100.  
  101.  
  102. class tokenBinN:
  103.     
  104.     def __init__(self, data, separator = ''):
  105.         self.data = data
  106.         self.separator = separator
  107.  
  108.     
  109.     def toRTF(self):
  110.         return '\\bin' + repr(len(self.data)) + self.separator + self.data
  111.  
  112.     
  113.     def __repr__(self):
  114.         return '\\bin' + repr(len(self.data)) + self.separator + self.data
  115.  
  116.  
  117.  
  118. class token8bitChar:
  119.     
  120.     def __init__(self, data):
  121.         self.data = data
  122.  
  123.     
  124.     def toRTF(self):
  125.         return "\\'" + self.data
  126.  
  127.     
  128.     def __repr__(self):
  129.         return "\\'" + self.data
  130.  
  131.  
  132.  
  133. class tokenUnicode:
  134.     
  135.     def __init__(self, data, separator = '', current_ucn = 1, eqList = []):
  136.         self.data = data
  137.         self.separator = separator
  138.         self.current_ucn = current_ucn
  139.         self.eqList = eqList
  140.  
  141.     
  142.     def toRTF(self):
  143.         result = '\\u' + repr(self.data) + ' '
  144.         ucn = self.current_ucn
  145.         if len(self.eqList) < ucn:
  146.             ucn = len(self.eqList)
  147.             result = tokenControlWordWithNumericArgument('\\uc', ucn).toRTF() + result
  148.         
  149.         i = 0
  150.         for eq in self.eqList:
  151.             if i >= ucn:
  152.                 break
  153.             
  154.             result = result + eq.toRTF()
  155.         
  156.         return result
  157.  
  158.     
  159.     def __repr__(self):
  160.         return '\\u' + repr(self.data)
  161.  
  162.  
  163.  
  164. def isAsciiLetter(value):
  165.     if (value >= 'a' or value <= 'z') and value >= 'A':
  166.         pass
  167.     return value <= 'Z'
  168.  
  169.  
  170. def isDigit(value):
  171.     if value >= '0':
  172.         pass
  173.     return value <= '9'
  174.  
  175.  
  176. def isChar(value, char):
  177.     return value == char
  178.  
  179.  
  180. def isString(buffer, string):
  181.     return buffer == string
  182.  
  183.  
  184. class RtfTokenParser:
  185.     
  186.     def __init__(self, tokens):
  187.         self.tokens = tokens
  188.         self.process()
  189.         self.processUnicode()
  190.  
  191.     
  192.     def process(self):
  193.         i = 0
  194.         newTokens = []
  195.         while i < len(self.tokens):
  196.             if isinstance(self.tokens[i], tokenControlSymbol):
  197.                 if isString(self.tokens[i].name, "\\'"):
  198.                     i = i + 1
  199.                     if not isinstance(self.tokens[i], tokenData):
  200.                         raise Exception('Error: token8bitChar without data.')
  201.                     isinstance(self.tokens[i], tokenData)
  202.                     if len(self.tokens[i].data) < 2:
  203.                         raise Exception('Error: token8bitChar without data.')
  204.                     len(self.tokens[i].data) < 2
  205.                     newTokens.append(token8bitChar(self.tokens[i].data[0:2]))
  206.                     if len(self.tokens[i].data) > 2:
  207.                         newTokens.append(tokenData(self.tokens[i].data[2:]))
  208.                     
  209.                     i = i + 1
  210.                     continue
  211.                 
  212.             
  213.             newTokens.append(self.tokens[i])
  214.             i = i + 1
  215.         self.tokens = list(newTokens)
  216.  
  217.     
  218.     def processUnicode(self):
  219.         i = 0
  220.         newTokens = []
  221.         ucNbStack = [
  222.             1]
  223.         while i < len(self.tokens):
  224.             if isinstance(self.tokens[i], tokenDelimitatorStart):
  225.                 ucNbStack.append(ucNbStack[len(ucNbStack) - 1])
  226.                 newTokens.append(self.tokens[i])
  227.                 i = i + 1
  228.                 continue
  229.             
  230.             if isinstance(self.tokens[i], tokenDelimitatorEnd):
  231.                 ucNbStack.pop()
  232.                 newTokens.append(self.tokens[i])
  233.                 i = i + 1
  234.                 continue
  235.             
  236.             if isinstance(self.tokens[i], tokenControlWordWithNumericArgument):
  237.                 if isString(self.tokens[i].name, '\\uc'):
  238.                     ucNbStack[len(ucNbStack) - 1] = self.tokens[i].argument
  239.                     newTokens.append(self.tokens[i])
  240.                     i = i + 1
  241.                     continue
  242.                 
  243.                 if isString(self.tokens[i].name, '\\u'):
  244.                     x = i
  245.                     j = 0
  246.                     i = i + 1
  247.                     replace = []
  248.                     partialData = None
  249.                     ucn = ucNbStack[len(ucNbStack) - 1]
  250.                     while i < len(self.tokens) and j < ucn:
  251.                         if isinstance(self.tokens[i], tokenDelimitatorStart):
  252.                             break
  253.                         
  254.                         if isinstance(self.tokens[i], tokenDelimitatorEnd):
  255.                             break
  256.                         
  257.                         if isinstance(self.tokens[i], tokenData):
  258.                             if len(self.tokens[i].data) >= ucn - j:
  259.                                 replace.append(tokenData(self.tokens[i].data[0:ucn - j]))
  260.                                 if len(self.tokens[i].data) > ucn - j:
  261.                                     partialData = tokenData(self.tokens[i].data[ucn - j:])
  262.                                 
  263.                                 i = i + 1
  264.                                 break
  265.                             else:
  266.                                 replace.append(self.tokens[i])
  267.                                 j = j + len(self.tokens[i].data)
  268.                                 i = i + 1
  269.                         
  270.                         if isinstance(self.tokens[i], token8bitChar) or isinstance(self.tokens[i], tokenBinN):
  271.                             replace.append(self.tokens[i])
  272.                             i = i + 1
  273.                             j = j + 1
  274.                             continue
  275.                         
  276.                         raise Exception('Error: incorect utf replacement.')
  277.                     replace = []
  278.                     newTokens.append(tokenUnicode(self.tokens[x].argument, self.tokens[x].separator, ucNbStack[len(ucNbStack) - 1], replace))
  279.                     if partialData != None:
  280.                         newTokens.append(partialData)
  281.                         continue
  282.                     continue
  283.                 
  284.             
  285.             newTokens.append(self.tokens[i])
  286.             i = i + 1
  287.         self.tokens = list(newTokens)
  288.  
  289.     
  290.     def toRTF(self):
  291.         result = []
  292.         for token in self.tokens:
  293.             result.append(token.toRTF())
  294.         
  295.         return ''.join(result)
  296.  
  297.  
  298.  
  299. class RtfTokenizer:
  300.     
  301.     def __init__(self, rtfData):
  302.         self.rtfData = []
  303.         self.tokens = []
  304.         self.rtfData = rtfData
  305.         self.tokenize()
  306.  
  307.     
  308.     def tokenize(self):
  309.         i = 0
  310.         lastDataStart = -1
  311.         while i < len(self.rtfData):
  312.             if isChar(self.rtfData[i], '{'):
  313.                 if lastDataStart > -1:
  314.                     self.tokens.append(tokenData(self.rtfData[lastDataStart:i]))
  315.                     lastDataStart = -1
  316.                 
  317.                 self.tokens.append(tokenDelimitatorStart())
  318.                 i = i + 1
  319.                 continue
  320.             
  321.             if isChar(self.rtfData[i], '}'):
  322.                 if lastDataStart > -1:
  323.                     self.tokens.append(tokenData(self.rtfData[lastDataStart:i]))
  324.                     lastDataStart = -1
  325.                 
  326.                 self.tokens.append(tokenDelimitatorEnd())
  327.                 i = i + 1
  328.                 continue
  329.             
  330.             if isChar(self.rtfData[i], '\\'):
  331.                 if i + 1 >= len(self.rtfData):
  332.                     raise Exception('Error: Control character found at the end of the document.')
  333.                 i + 1 >= len(self.rtfData)
  334.                 if lastDataStart > -1:
  335.                     self.tokens.append(tokenData(self.rtfData[lastDataStart:i]))
  336.                     lastDataStart = -1
  337.                 
  338.                 tokenStart = i
  339.                 i = i + 1
  340.                 if isAsciiLetter(self.rtfData[i]):
  341.                     consumed = False
  342.                     while i < len(self.rtfData):
  343.                         if not isAsciiLetter(self.rtfData[i]):
  344.                             tokenEnd = i
  345.                             consumed = True
  346.                             break
  347.                         
  348.                         i = i + 1
  349.                     if not consumed:
  350.                         raise Exception('Error (at:%d): Control Word without end.' % tokenStart)
  351.                     consumed
  352.                     if isChar(self.rtfData[i], '-') or isDigit(self.rtfData[i]):
  353.                         consumed = False
  354.                         l = 0
  355.                         while i < len(self.rtfData):
  356.                             if not isDigit(self.rtfData[i]):
  357.                                 consumed = True
  358.                                 break
  359.                             
  360.                             l = l + 1
  361.                             i = i + 1
  362.                             if l > 10:
  363.                                 raise Exception('Error (at:%d): Too many digits in control word numeric argument.' % [
  364.                                     tokenStart])
  365.                             l > 10
  366.                         if not consumed:
  367.                             raise Exception('Error (at:%d): Control Word without numeric argument end.' % [
  368.                                 tokenStart])
  369.                         consumed
  370.                     
  371.                     separator = ''
  372.                     if isChar(self.rtfData[i], ' '):
  373.                         separator = ' '
  374.                     
  375.                     controlWord = self.rtfData[tokenStart:tokenEnd]
  376.                     if tokenEnd < i:
  377.                         value = int(self.rtfData[tokenEnd:i])
  378.                         if isString(controlWord, '\\bin'):
  379.                             i = i + value
  380.                             self.tokens.append(tokenBinN(self.rtfData[tokenStart:i], separator))
  381.                         else:
  382.                             self.tokens.append(tokenControlWordWithNumericArgument(controlWord, value, separator))
  383.                     else:
  384.                         self.tokens.append(tokenControlWord(controlWord, separator))
  385.                     if self.rtfData[i] == ' ':
  386.                         i = i + 1
  387.                     
  388.                 self.rtfData[i] == ' '
  389.                 self.tokens.append(tokenControlSymbol(self.rtfData[tokenStart:i + 1]))
  390.                 i = i + 1
  391.                 continue
  392.             
  393.             if lastDataStart < 0:
  394.                 lastDataStart = i
  395.             
  396.             i = i + 1
  397.  
  398.     
  399.     def toRTF(self):
  400.         result = []
  401.         for token in self.tokens:
  402.             result.append(token.toRTF())
  403.         
  404.         return ''.join(result)
  405.  
  406.  
  407. if __name__ == '__main__':
  408.     import sys
  409.     if len(sys.argv) < 2:
  410.         print 'Usage %prog rtfFileToConvert'
  411.         sys.exit()
  412.     
  413.     f = open(sys.argv[1], 'rb')
  414.     data = f.read()
  415.     f.close()
  416.     tokenizer = RtfTokenizer(data)
  417.     parsedTokens = RtfTokenParser(tokenizer.tokens)
  418.     data = parsedTokens.toRTF()
  419.     f = open(sys.argv[1], 'w')
  420.     f.write(data)
  421.     f.close()
  422.  
  423.