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