home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_1097 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  10.2 KB  |  330 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import sys
  5. import os
  6. import tempfile
  7. import re
  8. from calibre.ebooks.rtf2xml import field_strings, copy
  9.  
  10. class FieldsSmall:
  11.     
  12.     def __init__(self, in_file, bug_handler, copy = None, run_level = 1):
  13.         self._FieldsSmall__file = in_file
  14.         self._FieldsSmall__bug_handler = bug_handler
  15.         self._FieldsSmall__copy = copy
  16.         self._FieldsSmall__write_to = tempfile.mktemp()
  17.         self._FieldsSmall__run_level = run_level
  18.  
  19.     
  20.     def __initiate_values(self):
  21.         self._FieldsSmall__string_obj = field_strings.FieldStrings(bug_handler = self._FieldsSmall__bug_handler)
  22.         self._FieldsSmall__state = 'before_body'
  23.         self._FieldsSmall__text_string = ''
  24.         self._FieldsSmall__marker = 'mi<mk<inline-fld\n'
  25.         self._FieldsSmall__state_dict = {
  26.             'before_body': self._FieldsSmall__before_body_func,
  27.             'body': self._FieldsSmall__body_func,
  28.             'bookmark': self._FieldsSmall__bookmark_func,
  29.             'toc_index': self._FieldsSmall__toc_index_func }
  30.         self._FieldsSmall__body_dict = {
  31.             'cw<an<book-mk-st': (self._FieldsSmall__found_bookmark_func, 'start'),
  32.             'cw<an<book-mk-en': (self._FieldsSmall__found_bookmark_func, 'end'),
  33.             'cw<an<toc_______': (self._FieldsSmall__found_toc_index_func, 'toc'),
  34.             'cw<an<index-mark': (self._FieldsSmall__found_toc_index_func, 'index') }
  35.         ob = 'ob<nu<open-brack.....'
  36.         cb = 'cb<nu<clos-brack'
  37.         bk_st = 'cw<an<book-mk-st<nu<true'
  38.         tx = 'tx<nu<__________<(.*?)'
  39.         reg_st = ob + bk_st + tx + cb
  40.         self._FieldsSmall__book_start = re.compile('%s' % reg_st)
  41.  
  42.     
  43.     def __before_body_func(self, line):
  44.         if self._FieldsSmall__token_info == 'mi<mk<body-open_':
  45.             self._FieldsSmall__state = 'body'
  46.         
  47.         self._FieldsSmall__write_obj.write(line)
  48.  
  49.     
  50.     def __body_func(self, line):
  51.         (action, tag) = self._FieldsSmall__body_dict.get(self._FieldsSmall__token_info, (None, None))
  52.         if action:
  53.             action(line, tag)
  54.         else:
  55.             self._FieldsSmall__write_obj.write(line)
  56.  
  57.     
  58.     def __found_bookmark_func(self, line, tag):
  59.         self._FieldsSmall__beg_bracket_count = self._FieldsSmall__ob_count
  60.         self._FieldsSmall__cb_count = 0
  61.         self._FieldsSmall__state = 'bookmark'
  62.         self._FieldsSmall__type_of_bookmark = tag
  63.  
  64.     
  65.     def __bookmark_func(self, line):
  66.         if self._FieldsSmall__beg_bracket_count == self._FieldsSmall__cb_count:
  67.             self._FieldsSmall__state = 'body'
  68.             type = 'bookmark-%s' % self._FieldsSmall__type_of_bookmark
  69.             my_string = self._FieldsSmall__parse_bookmark_func(self._FieldsSmall__text_string, type)
  70.             self._FieldsSmall__write_obj.write(self._FieldsSmall__marker)
  71.             self._FieldsSmall__write_obj.write(my_string)
  72.             self._FieldsSmall__text_string = ''
  73.             self._FieldsSmall__write_obj.write(line)
  74.         elif line[0:2] == 'tx':
  75.             self._FieldsSmall__text_string += line[17:-1]
  76.         
  77.  
  78.     
  79.     def __parse_index_func(self, my_string):
  80.         (my_string, see_string) = self._FieldsSmall__index_see_func(my_string)
  81.         (my_string, bookmark_string) = self._FieldsSmall__index_bookmark_func(my_string)
  82.         (italics, bold) = self._FieldsSmall__index__format_func(my_string)
  83.         found_sub = 0
  84.         my_changed_string = 'mi<tg<empty-att_<field<type>index-entry'
  85.         my_changed_string += '<update>static'
  86.         if see_string:
  87.             my_changed_string += '<additional-text>%s' % see_string
  88.         
  89.         if bookmark_string:
  90.             my_changed_string += '<bookmark>%s' % bookmark_string
  91.         
  92.         if italics:
  93.             my_changed_string += '<italics>true'
  94.         
  95.         if bold:
  96.             my_changed_string += '<bold>true'
  97.         
  98.         main_entry = ''
  99.         sub_entry = ''
  100.         lines = my_string.split('\n')
  101.         for line in lines:
  102.             token_info = line[:16]
  103.             if token_info == 'cw<ml<colon_____':
  104.                 found_sub = 1
  105.                 continue
  106.             if token_info[0:2] == 'tx':
  107.                 if found_sub:
  108.                     sub_entry += line[17:]
  109.                 else:
  110.                     main_entry += line[17:]
  111.             found_sub
  112.         
  113.         my_changed_string += '<main-entry>%s' % main_entry
  114.         if found_sub:
  115.             my_changed_string += '<sub-entry>%s' % sub_entry
  116.         
  117.         my_changed_string += '\n'
  118.         return my_changed_string
  119.  
  120.     
  121.     def __index_see_func(self, my_string):
  122.         in_see = 0
  123.         bracket_count = 0
  124.         see_string = ''
  125.         changed_string = ''
  126.         lines = my_string.split('\n')
  127.         end_bracket_count = sys.maxint
  128.         for line in lines:
  129.             token_info = line[:16]
  130.             if token_info == 'ob<nu<open-brack':
  131.                 bracket_count += 1
  132.             
  133.             if token_info == 'cb<nu<clos-brack':
  134.                 bracket_count -= 1
  135.             
  136.             if in_see:
  137.                 if bracket_count == end_bracket_count and token_info == 'cb<nu<clos-brack':
  138.                     in_see = 0
  139.                 elif token_info == 'tx<nu<__________':
  140.                     see_string += line[17:]
  141.                 
  142.             token_info == 'cb<nu<clos-brack'
  143.             if token_info == 'cw<in<index-see_':
  144.                 end_bracket_count = bracket_count - 1
  145.                 in_see = 1
  146.             
  147.             changed_string += '%s\n' % line
  148.         
  149.         return (changed_string, see_string)
  150.  
  151.     
  152.     def __index_bookmark_func(self, my_string):
  153.         in_bookmark = 0
  154.         bracket_count = 0
  155.         bookmark_string = ''
  156.         index_string = ''
  157.         lines = my_string.split('\n')
  158.         end_bracket_count = sys.maxint
  159.         for line in lines:
  160.             token_info = line[:16]
  161.             if token_info == 'ob<nu<open-brack':
  162.                 bracket_count += 1
  163.             
  164.             if token_info == 'cb<nu<clos-brack':
  165.                 bracket_count -= 1
  166.             
  167.             if in_bookmark:
  168.                 if bracket_count == end_bracket_count and token_info == 'cb<nu<clos-brack':
  169.                     in_bookmark = 0
  170.                     index_string += '%s\n' % line
  171.                 elif token_info == 'tx<nu<__________':
  172.                     bookmark_string += line[17:]
  173.                 else:
  174.                     index_string += '%s\n' % line
  175.             token_info == 'cb<nu<clos-brack'
  176.             if token_info == 'cw<an<place_____':
  177.                 end_bracket_count = bracket_count - 1
  178.                 in_bookmark = 1
  179.             
  180.             index_string += '%s\n' % line
  181.         
  182.         return (index_string, bookmark_string)
  183.  
  184.     
  185.     def __index__format_func(self, my_string):
  186.         italics = 0
  187.         bold = 0
  188.         lines = my_string.split('\n')
  189.         for line in lines:
  190.             token_info = line[:16]
  191.             if token_info == 'cw<in<index-bold':
  192.                 bold = 1
  193.             
  194.             if token_info == 'cw<in<index-ital':
  195.                 italics = 1
  196.                 continue
  197.         
  198.         return (italics, bold)
  199.  
  200.     
  201.     def __parse_toc_func(self, my_string):
  202.         toc_level = 0
  203.         toc_suppress = 0
  204.         (my_string, book_start_string, book_end_string) = self._FieldsSmall__parse_bookmark_for_toc(my_string)
  205.         main_entry = ''
  206.         my_changed_string = 'mi<tg<empty-att_<field<type>toc-entry'
  207.         my_changed_string += '<update>static'
  208.         if book_start_string:
  209.             my_changed_string += '<bookmark-start>%s' % book_start_string
  210.         
  211.         if book_end_string:
  212.             my_changed_string += '<bookmark-end>%s' % book_end_string
  213.         
  214.         lines = my_string.split('\n')
  215.         for line in lines:
  216.             token_info = line[:16]
  217.             if token_info[0:2] == 'tx':
  218.                 main_entry += line[17:]
  219.             
  220.             if token_info == 'cw<tc<toc-level_':
  221.                 toc_level = line[20:]
  222.             
  223.             if token_info == 'cw<tc<toc-sup-nu':
  224.                 toc_suppress = 1
  225.                 continue
  226.         
  227.         if toc_level:
  228.             my_changed_string += '<toc-level>%s' % toc_level
  229.         
  230.         if toc_suppress:
  231.             my_changed_string += '<toc-suppress-number>true'
  232.         
  233.         my_changed_string += '<main-entry>%s' % main_entry
  234.         my_changed_string += '\n'
  235.         return my_changed_string
  236.  
  237.     
  238.     def __parse_bookmark_for_toc(self, my_string):
  239.         in_bookmark = 0
  240.         bracket_count = 0
  241.         book_start_string = ''
  242.         book_end_string = ''
  243.         book_type = 0
  244.         toc_string = ''
  245.         lines = my_string.split('\n')
  246.         end_bracket_count = sys.maxint
  247.         for line in lines:
  248.             token_info = line[:16]
  249.             if token_info == 'ob<nu<open-brack':
  250.                 bracket_count += 1
  251.             
  252.             if token_info == 'cb<nu<clos-brack':
  253.                 bracket_count -= 1
  254.             
  255.             if in_bookmark:
  256.                 if bracket_count == end_bracket_count and token_info == 'cb<nu<clos-brack':
  257.                     in_bookmark = 0
  258.                     toc_string += '%s\n' % line
  259.                 elif token_info == 'tx<nu<__________':
  260.                     if book_type == 'start':
  261.                         book_start_string += line[17:]
  262.                     elif book_type == 'end':
  263.                         book_end_string += line[17:]
  264.                     
  265.                 else:
  266.                     toc_string += '%s\n' % line
  267.             token_info == 'cb<nu<clos-brack'
  268.             if token_info == 'cw<an<book-mk-st' or token_info == 'cw<an<book-mk-en':
  269.                 if token_info == 'cw<an<book-mk-st':
  270.                     book_type = 'start'
  271.                 
  272.                 if token_info == 'cw<an<book-mk-en':
  273.                     book_type = 'end'
  274.                 
  275.                 end_bracket_count = bracket_count - 1
  276.                 in_bookmark = 1
  277.             
  278.             toc_string += '%s\n' % line
  279.         
  280.         return (toc_string, book_start_string, book_end_string)
  281.  
  282.     
  283.     def __parse_bookmark_func(self, my_string, type):
  284.         my_changed_string = 'mi<tg<empty-att_<field<type>%s<number>%s<update>none\n' % (type, my_string)
  285.         return my_changed_string
  286.  
  287.     
  288.     def __found_toc_index_func(self, line, tag):
  289.         self._FieldsSmall__beg_bracket_count = self._FieldsSmall__ob_count
  290.         self._FieldsSmall__cb_count = 0
  291.         self._FieldsSmall__state = 'toc_index'
  292.         self._FieldsSmall__tag = tag
  293.  
  294.     
  295.     def __toc_index_func(self, line):
  296.         pass
  297.  
  298.     
  299.     def fix_fields(self):
  300.         self._FieldsSmall__initiate_values()
  301.         read_obj = open(self._FieldsSmall__file)
  302.         self._FieldsSmall__write_obj = open(self._FieldsSmall__write_to, 'w')
  303.         line_to_read = '1'
  304.         while line_to_read:
  305.             line_to_read = read_obj.readline()
  306.             line = line_to_read
  307.             self._FieldsSmall__token_info = line[:16]
  308.             if self._FieldsSmall__token_info == 'ob<nu<open-brack':
  309.                 self._FieldsSmall__ob_count = line[-5:-1]
  310.             
  311.             if self._FieldsSmall__token_info == 'cb<nu<clos-brack':
  312.                 self._FieldsSmall__cb_count = line[-5:-1]
  313.             
  314.             action = self._FieldsSmall__state_dict.get(self._FieldsSmall__state)
  315.             if action == None:
  316.                 sys.stderr.write('no no matching state in module fields_small.py\n')
  317.                 sys.stderr.write(self._FieldsSmall__state + '\n')
  318.             
  319.             action(line)
  320.         read_obj.close()
  321.         self._FieldsSmall__write_obj.close()
  322.         copy_obj = copy.Copy(bug_handler = self._FieldsSmall__bug_handler)
  323.         if self._FieldsSmall__copy:
  324.             copy_obj.copy_file(self._FieldsSmall__write_to, 'fields_small.data')
  325.         
  326.         copy_obj.rename(self._FieldsSmall__write_to, self._FieldsSmall__file)
  327.         os.remove(self._FieldsSmall__write_to)
  328.  
  329.  
  330.