home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_623 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  8.3 KB  |  317 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import re
  5. _declname_match = re.compile('[a-zA-Z][-_.a-zA-Z0-9]*\\s*').match
  6. _declstringlit_match = re.compile('(\\\'[^\\\']*\\\'|"[^"]*")\\s*').match
  7. _commentclose = re.compile('--\\s*>')
  8. _markedsectionclose = re.compile(']\\s*]\\s*>')
  9. _msmarkedsectionclose = re.compile(']\\s*>')
  10. del re
  11.  
  12. class ParserBase:
  13.     
  14.     def __init__(self):
  15.         if self.__class__ is ParserBase:
  16.             raise RuntimeError('markupbase.ParserBase must be subclassed')
  17.         self.__class__ is ParserBase
  18.  
  19.     
  20.     def error(self, message):
  21.         raise NotImplementedError('subclasses of ParserBase must override error()')
  22.  
  23.     
  24.     def reset(self):
  25.         self.lineno = 1
  26.         self.offset = 0
  27.  
  28.     
  29.     def getpos(self):
  30.         return (self.lineno, self.offset)
  31.  
  32.     
  33.     def updatepos(self, i, j):
  34.         if i >= j:
  35.             return j
  36.         rawdata = self.rawdata
  37.         nlines = rawdata.count('\n', i, j)
  38.         if nlines:
  39.             self.lineno = self.lineno + nlines
  40.             pos = rawdata.rindex('\n', i, j)
  41.             self.offset = j - (pos + 1)
  42.         else:
  43.             self.offset = self.offset + j - i
  44.         return j
  45.  
  46.     _decl_otherchars = ''
  47.     
  48.     def parse_declaration(self, i):
  49.         rawdata = self.rawdata
  50.         j = i + 2
  51.         if rawdata[j:j + 1] == '>':
  52.             return j + 1
  53.         if rawdata[j:j + 1] in ('-', ''):
  54.             return -1
  55.         n = len(rawdata)
  56.         if rawdata[j:j + 2] == '--':
  57.             return self.parse_comment(i)
  58.         if rawdata[j] == '[':
  59.             return self.parse_marked_section(i)
  60.         (decltype, j) = self._scan_name(j, i)
  61.         if j < 0:
  62.             return j
  63.         while j < n:
  64.             c = rawdata[j]
  65.             if c == '>':
  66.                 data = rawdata[i + 2:j]
  67.                 return j + 1
  68.             if c in '"\'':
  69.                 m = _declstringlit_match(rawdata, j)
  70.                 if not m:
  71.                     return -1
  72.                 j = m.end()
  73.             elif c in 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ':
  74.                 (name, j) = self._scan_name(j, i)
  75.             elif c in self._decl_otherchars:
  76.                 j = j + 1
  77.             elif c == '[':
  78.                 if decltype == 'doctype':
  79.                     j = self._parse_doctype_subset(j + 1, i)
  80.                 elif decltype in ('attlist', 'linktype', 'link', 'element'):
  81.                     self.error("unsupported '[' char in %s declaration" % decltype)
  82.                 else:
  83.                     self.error("unexpected '[' char in declaration")
  84.             else:
  85.                 self.error('unexpected %r char in declaration' % rawdata[j])
  86.             if j < 0:
  87.                 return j
  88.             continue
  89.             j < 0
  90.         return -1
  91.  
  92.     
  93.     def parse_marked_section(self, i, report = 1):
  94.         rawdata = self.rawdata
  95.         (sectName, j) = self._scan_name(i + 3, i)
  96.         if j < 0:
  97.             return j
  98.         if sectName in ('temp', 'cdata', 'ignore', 'include', 'rcdata'):
  99.             match = _markedsectionclose.search(rawdata, i + 3)
  100.         elif sectName in ('if', 'else', 'endif'):
  101.             match = _msmarkedsectionclose.search(rawdata, i + 3)
  102.         else:
  103.             self.error('unknown status keyword %r in marked section' % rawdata[i + 3:j])
  104.         if not match:
  105.             return -1
  106.         if report:
  107.             j = match.start(0)
  108.             self.unknown_decl(rawdata[i + 3:j])
  109.         
  110.         return match.end(0)
  111.  
  112.     
  113.     def parse_comment(self, i, report = 1):
  114.         rawdata = self.rawdata
  115.         if rawdata[i:i + 4] != '<!--':
  116.             self.error('unexpected call to parse_comment()')
  117.         
  118.         match = _commentclose.search(rawdata, i + 4)
  119.         if not match:
  120.             return -1
  121.         if report:
  122.             j = match.start(0)
  123.             self.handle_comment(rawdata[i + 4:j])
  124.         
  125.         return match.end(0)
  126.  
  127.     
  128.     def _parse_doctype_subset(self, i, declstartpos):
  129.         rawdata = self.rawdata
  130.         n = len(rawdata)
  131.         j = i
  132.         while j < n:
  133.             c = rawdata[j]
  134.             if c == '<':
  135.                 s = rawdata[j:j + 2]
  136.                 if s == '<':
  137.                     return -1
  138.                 if s != '<!':
  139.                     self.updatepos(declstartpos, j + 1)
  140.                     self.error('unexpected char in internal subset (in %r)' % s)
  141.                 
  142.                 if j + 2 == n:
  143.                     return -1
  144.                 if j + 4 > n:
  145.                     return -1
  146.                 (name, j) = self._scan_name(j + 2, declstartpos)
  147.                 if j == -1:
  148.                     return -1
  149.                 meth = getattr(self, '_parse_doctype_' + name)
  150.                 j = meth(j, declstartpos)
  151.                 if j < 0:
  152.                     return j
  153.                 continue
  154.             j < 0
  155.             if c == '%':
  156.                 if j + 1 == n:
  157.                     return -1
  158.                 (s, j) = self._scan_name(j + 1, declstartpos)
  159.                 if j < 0:
  160.                     return j
  161.                 if rawdata[j] == ';':
  162.                     j = j + 1
  163.                 
  164.             rawdata[j] == ';'
  165.             if c == ']':
  166.                 j = j + 1
  167.                 while j < n and rawdata[j].isspace():
  168.                     j = j + 1
  169.                     continue
  170.                     j < 0
  171.                 if j < n:
  172.                     if rawdata[j] == '>':
  173.                         return j
  174.                     self.updatepos(declstartpos, j)
  175.                     self.error('unexpected char after internal subset')
  176.                 else:
  177.                     return -1
  178.             j < n
  179.             if c.isspace():
  180.                 j = j + 1
  181.                 continue
  182.             j + 1 == n
  183.             self.updatepos(declstartpos, j)
  184.             self.error('unexpected char %r in internal subset' % c)
  185.             continue
  186.             None if name not in ('attlist', 'element', 'entity', 'notation') else j + 2 == n if rawdata[j:j + 4] == '<!--' else j + 4 > n
  187.         return -1
  188.  
  189.     
  190.     def _parse_doctype_element(self, i, declstartpos):
  191.         (name, j) = self._scan_name(i, declstartpos)
  192.         if j == -1:
  193.             return -1
  194.         rawdata = self.rawdata
  195.         if '>' in rawdata[j:]:
  196.             return rawdata.find('>', j) + 1
  197.         return -1
  198.  
  199.     
  200.     def _parse_doctype_attlist(self, i, declstartpos):
  201.         rawdata = self.rawdata
  202.         (name, j) = self._scan_name(i, declstartpos)
  203.         c = rawdata[j:j + 1]
  204.         if c == '':
  205.             return -1
  206.         if c == '>':
  207.             return j + 1
  208.         while None:
  209.             (name, j) = self._scan_name(j, declstartpos)
  210.             if j < 0:
  211.                 return j
  212.             c = rawdata[j:j + 1]
  213.             if c == '':
  214.                 return -1
  215.             if c == '(':
  216.                 if ')' in rawdata[j:]:
  217.                     j = rawdata.find(')', j) + 1
  218.                 else:
  219.                     return -1
  220.                 if rawdata[j:j + 1].isspace():
  221.                     j = j + 1
  222.                     continue
  223.                 c == ''
  224.             if not rawdata[j:]:
  225.                 return -1
  226.         rawdata[j:]
  227.         (name, j) = self._scan_name(j, declstartpos)
  228.         c = rawdata[j:j + 1]
  229.         if not c:
  230.             return -1
  231.         if c == '>':
  232.             return j + 1
  233.         continue
  234.  
  235.     
  236.     def _parse_doctype_notation(self, i, declstartpos):
  237.         (name, j) = self._scan_name(i, declstartpos)
  238.         if j < 0:
  239.             return j
  240.         rawdata = self.rawdata
  241.         while None:
  242.             c = rawdata[j:j + 1]
  243.             if not c:
  244.                 return -1
  245.             if c == '>':
  246.                 return j + 1
  247.             if c in '\'"':
  248.                 m = _declstringlit_match(rawdata, j)
  249.                 if not m:
  250.                     return -1
  251.                 j = m.end()
  252.                 continue
  253.             (name, j) = self._scan_name(j, declstartpos)
  254.             if j < 0:
  255.                 return j
  256.             continue
  257.             return None
  258.  
  259.     
  260.     def _parse_doctype_entity(self, i, declstartpos):
  261.         rawdata = self.rawdata
  262.         if rawdata[i:i + 1] == '%':
  263.             j = i + 1
  264.             while None:
  265.                 c = rawdata[j:j + 1]
  266.                 if not c:
  267.                     return -1
  268.                 if c.isspace():
  269.                     j = j + 1
  270.                     continue
  271.                 break
  272.                 continue
  273.         rawdata[i:i + 1] == '%'
  274.         j = i
  275.         (name, j) = self._scan_name(j, declstartpos)
  276.         if j < 0:
  277.             return j
  278.         while None:
  279.             c = self.rawdata[j:j + 1]
  280.             if not c:
  281.                 return -1
  282.             if c in '\'"':
  283.                 m = _declstringlit_match(rawdata, j)
  284.                 if m:
  285.                     j = m.end()
  286.                 else:
  287.                     return -1
  288.             if c == '>':
  289.                 return j + 1
  290.             (name, j) = self._scan_name(j, declstartpos)
  291.             if j < 0:
  292.                 return j
  293.             continue
  294.             return None
  295.  
  296.     
  297.     def _scan_name(self, i, declstartpos):
  298.         rawdata = self.rawdata
  299.         n = len(rawdata)
  300.         if i == n:
  301.             return (None, -1)
  302.         m = _declname_match(rawdata, i)
  303.         if m:
  304.             s = m.group()
  305.             name = s.strip()
  306.             if i + len(s) == n:
  307.                 return (None, -1)
  308.             return (name.lower(), m.end())
  309.         self.updatepos(declstartpos, i)
  310.         self.error('expected name token at %r' % rawdata[declstartpos:declstartpos + 20])
  311.  
  312.     
  313.     def unknown_decl(self, data):
  314.         pass
  315.  
  316.  
  317.