home *** CD-ROM | disk | FTP | other *** search
/ Freelog 125 / Freelog_MarsAvril2015_No125.iso / Bureautique / LibreOffice / LibreOffice_4.3.5_Win_x86.msi / parser1.py < prev    next >
Text File  |  2014-12-12  |  20KB  |  536 lines
  1. """A parser for HTML and XHTML."""
  2.  
  3. # This file is based on sgmllib.py, but the API is slightly different.
  4.  
  5. # XXX There should be a way to distinguish between PCDATA (parsed
  6. # character data -- the normal case), RCDATA (replaceable character
  7. # data -- only char and entity references and end tags are special)
  8. # and CDATA (character data -- only end tags are special).
  9.  
  10.  
  11. import _markupbase
  12. import re
  13. import warnings
  14.  
  15. # Regular expressions used for parsing
  16.  
  17. interesting_normal = re.compile('[&<]')
  18. incomplete = re.compile('&[a-zA-Z#]')
  19.  
  20. entityref = re.compile('&([a-zA-Z][-.a-zA-Z0-9]*)[^a-zA-Z0-9]')
  21. charref = re.compile('&#(?:[0-9]+|[xX][0-9a-fA-F]+)[^0-9a-fA-F]')
  22.  
  23. starttagopen = re.compile('<[a-zA-Z]')
  24. piclose = re.compile('>')
  25. commentclose = re.compile(r'--\s*>')
  26. # Note:
  27. #  1) the strict attrfind isn't really strict, but we can't make it
  28. #     correctly strict without breaking backward compatibility;
  29. #  2) if you change tagfind/attrfind remember to update locatestarttagend too;
  30. #  3) if you change tagfind/attrfind and/or locatestarttagend the parser will
  31. #     explode, so don't do it.
  32. tagfind = re.compile('([a-zA-Z][-.a-zA-Z0-9:_]*)(?:\s|/(?!>))*')
  33. # see http://www.w3.org/TR/html5/tokenization.html#tag-open-state
  34. # and http://www.w3.org/TR/html5/tokenization.html#tag-name-state
  35. tagfind_tolerant = re.compile('([a-zA-Z][^\t\n\r\f />\x00]*)(?:\s|/(?!>))*')
  36. attrfind = re.compile(
  37.     r'\s*([a-zA-Z_][-.:a-zA-Z_0-9]*)(\s*=\s*'
  38.     r'(\'[^\']*\'|"[^"]*"|[^\s"\'=<>`]*))?')
  39. attrfind_tolerant = re.compile(
  40.     r'((?<=[\'"\s/])[^\s/>][^\s/=>]*)(\s*=+\s*'
  41.     r'(\'[^\']*\'|"[^"]*"|(?![\'"])[^>\s]*))?(?:\s|/(?!>))*')
  42. locatestarttagend = re.compile(r"""
  43.   <[a-zA-Z][-.a-zA-Z0-9:_]*          # tag name
  44.   (?:\s+                             # whitespace before attribute name
  45.     (?:[a-zA-Z_][-.:a-zA-Z0-9_]*     # attribute name
  46.       (?:\s*=\s*                     # value indicator
  47.         (?:'[^']*'                   # LITA-enclosed value
  48.           |\"[^\"]*\"                # LIT-enclosed value
  49.           |[^'\">\s]+                # bare value
  50.          )
  51.        )?
  52.      )
  53.    )*
  54.   \s*                                # trailing whitespace
  55. """, re.VERBOSE)
  56. locatestarttagend_tolerant = re.compile(r"""
  57.   <[a-zA-Z][^\t\n\r\f />\x00]*       # tag name
  58.   (?:[\s/]*                          # optional whitespace before attribute name
  59.     (?:(?<=['"\s/])[^\s/>][^\s/=>]*  # attribute name
  60.       (?:\s*=+\s*                    # value indicator
  61.         (?:'[^']*'                   # LITA-enclosed value
  62.           |"[^"]*"                   # LIT-enclosed value
  63.           |(?!['"])[^>\s]*           # bare value
  64.          )
  65.          (?:\s*,)*                   # possibly followed by a comma
  66.        )?(?:\s|/(?!>))*
  67.      )*
  68.    )?
  69.   \s*                                # trailing whitespace
  70. """, re.VERBOSE)
  71. endendtag = re.compile('>')
  72. # the HTML 5 spec, section 8.1.2.2, doesn't allow spaces between
  73. # </ and the tag name, so maybe this should be fixed
  74. endtagfind = re.compile('</\s*([a-zA-Z][-.a-zA-Z0-9:_]*)\s*>')
  75.  
  76.  
  77. class HTMLParseError(Exception):
  78.     """Exception raised for all parse errors."""
  79.  
  80.     def __init__(self, msg, position=(None, None)):
  81.         assert msg
  82.         self.msg = msg
  83.         self.lineno = position[0]
  84.         self.offset = position[1]
  85.  
  86.     def __str__(self):
  87.         result = self.msg
  88.         if self.lineno is not None:
  89.             result = result + ", at line %d" % self.lineno
  90.         if self.offset is not None:
  91.             result = result + ", column %d" % (self.offset + 1)
  92.         return result
  93.  
  94.  
  95. class HTMLParser(_markupbase.ParserBase):
  96.     """Find tags and other markup and call handler functions.
  97.  
  98.     Usage:
  99.         p = HTMLParser()
  100.         p.feed(data)
  101.         ...
  102.         p.close()
  103.  
  104.     Start tags are handled by calling self.handle_starttag() or
  105.     self.handle_startendtag(); end tags by self.handle_endtag().  The
  106.     data between tags is passed from the parser to the derived class
  107.     by calling self.handle_data() with the data as argument (the data
  108.     may be split up in arbitrary chunks).  Entity references are
  109.     passed by calling self.handle_entityref() with the entity
  110.     reference as the argument.  Numeric character references are
  111.     passed to self.handle_charref() with the string containing the
  112.     reference as the argument.
  113.     """
  114.  
  115.     CDATA_CONTENT_ELEMENTS = ("script", "style")
  116.  
  117.     def __init__(self, strict=False):
  118.         """Initialize and reset this instance.
  119.  
  120.         If strict is set to False (the default) the parser will parse invalid
  121.         markup, otherwise it will raise an error.  Note that the strict mode
  122.         is deprecated.
  123.         """
  124.         if strict:
  125.             warnings.warn("The strict mode is deprecated.",
  126.                           DeprecationWarning, stacklevel=2)
  127.         self.strict = strict
  128.         self.reset()
  129.  
  130.     def reset(self):
  131.         """Reset this instance.  Loses all unprocessed data."""
  132.         self.rawdata = ''
  133.         self.lasttag = '???'
  134.         self.interesting = interesting_normal
  135.         self.cdata_elem = None
  136.         _markupbase.ParserBase.reset(self)
  137.  
  138.     def feed(self, data):
  139.         r"""Feed data to the parser.
  140.  
  141.         Call this as often as you want, with as little or as much text
  142.         as you want (may include '\n').
  143.         """
  144.         self.rawdata = self.rawdata + data
  145.         self.goahead(0)
  146.  
  147.     def close(self):
  148.         """Handle any buffered data."""
  149.         self.goahead(1)
  150.  
  151.     def error(self, message):
  152.         raise HTMLParseError(message, self.getpos())
  153.  
  154.     __starttag_text = None
  155.  
  156.     def get_starttag_text(self):
  157.         """Return full source of start tag: '<...>'."""
  158.         return self.__starttag_text
  159.  
  160.     def set_cdata_mode(self, elem):
  161.         self.cdata_elem = elem.lower()
  162.         self.interesting = re.compile(r'</\s*%s\s*>' % self.cdata_elem, re.I)
  163.  
  164.     def clear_cdata_mode(self):
  165.         self.interesting = interesting_normal
  166.         self.cdata_elem = None
  167.  
  168.     # Internal -- handle data as far as reasonable.  May leave state
  169.     # and data to be processed by a subsequent call.  If 'end' is
  170.     # true, force handling all data as if followed by EOF marker.
  171.     def goahead(self, end):
  172.         rawdata = self.rawdata
  173.         i = 0
  174.         n = len(rawdata)
  175.         while i < n:
  176.             match = self.interesting.search(rawdata, i) # < or &
  177.             if match:
  178.                 j = match.start()
  179.             else:
  180.                 if self.cdata_elem:
  181.                     break
  182.                 j = n
  183.             if i < j: self.handle_data(rawdata[i:j])
  184.             i = self.updatepos(i, j)
  185.             if i == n: break
  186.             startswith = rawdata.startswith
  187.             if startswith('<', i):
  188.                 if starttagopen.match(rawdata, i): # < + letter
  189.                     k = self.parse_starttag(i)
  190.                 elif startswith("</", i):
  191.                     k = self.parse_endtag(i)
  192.                 elif startswith("<!--", i):
  193.                     k = self.parse_comment(i)
  194.                 elif startswith("<?", i):
  195.                     k = self.parse_pi(i)
  196.                 elif startswith("<!", i):
  197.                     if self.strict:
  198.                         k = self.parse_declaration(i)
  199.                     else:
  200.                         k = self.parse_html_declaration(i)
  201.                 elif (i + 1) < n:
  202.                     self.handle_data("<")
  203.                     k = i + 1
  204.                 else:
  205.                     break
  206.                 if k < 0:
  207.                     if not end:
  208.                         break
  209.                     if self.strict:
  210.                         self.error("EOF in middle of construct")
  211.                     k = rawdata.find('>', i + 1)
  212.                     if k < 0:
  213.                         k = rawdata.find('<', i + 1)
  214.                         if k < 0:
  215.                             k = i + 1
  216.                     else:
  217.                         k += 1
  218.                     self.handle_data(rawdata[i:k])
  219.                 i = self.updatepos(i, k)
  220.             elif startswith("&#", i):
  221.                 match = charref.match(rawdata, i)
  222.                 if match:
  223.                     name = match.group()[2:-1]
  224.                     self.handle_charref(name)
  225.                     k = match.end()
  226.                     if not startswith(';', k-1):
  227.                         k = k - 1
  228.                     i = self.updatepos(i, k)
  229.                     continue
  230.                 else:
  231.                     if ";" in rawdata[i:]:  # bail by consuming &#
  232.                         self.handle_data(rawdata[i:i+2])
  233.                         i = self.updatepos(i, i+2)
  234.                     break
  235.             elif startswith('&', i):
  236.                 match = entityref.match(rawdata, i)
  237.                 if match:
  238.                     name = match.group(1)
  239.                     self.handle_entityref(name)
  240.                     k = match.end()
  241.                     if not startswith(';', k-1):
  242.                         k = k - 1
  243.                     i = self.updatepos(i, k)
  244.                     continue
  245.                 match = incomplete.match(rawdata, i)
  246.                 if match:
  247.                     # match.group() will contain at least 2 chars
  248.                     if end and match.group() == rawdata[i:]:
  249.                         if self.strict:
  250.                             self.error("EOF in middle of entity or char ref")
  251.                         else:
  252.                             k = match.end()
  253.                             if k <= i:
  254.                                 k = n
  255.                             i = self.updatepos(i, i + 1)
  256.                     # incomplete
  257.                     break
  258.                 elif (i + 1) < n:
  259.                     # not the end of the buffer, and can't be confused
  260.                     # with some other construct
  261.                     self.handle_data("&")
  262.                     i = self.updatepos(i, i + 1)
  263.                 else:
  264.                     break
  265.             else:
  266.                 assert 0, "interesting.search() lied"
  267.         # end while
  268.         if end and i < n and not self.cdata_elem:
  269.             self.handle_data(rawdata[i:n])
  270.             i = self.updatepos(i, n)
  271.         self.rawdata = rawdata[i:]
  272.  
  273.     # Internal -- parse html declarations, return length or -1 if not terminated
  274.     # See w3.org/TR/html5/tokenization.html#markup-declaration-open-state
  275.     # See also parse_declaration in _markupbase
  276.     def parse_html_declaration(self, i):
  277.         rawdata = self.rawdata
  278.         assert rawdata[i:i+2] == '<!', ('unexpected call to '
  279.                                         'parse_html_declaration()')
  280.         if rawdata[i:i+4] == '<!--':
  281.             # this case is actually already handled in goahead()
  282.             return self.parse_comment(i)
  283.         elif rawdata[i:i+3] == '<![':
  284.             return self.parse_marked_section(i)
  285.         elif rawdata[i:i+9].lower() == '<!doctype':
  286.             # find the closing >
  287.             gtpos = rawdata.find('>', i+9)
  288.             if gtpos == -1:
  289.                 return -1
  290.             self.handle_decl(rawdata[i+2:gtpos])
  291.             return gtpos+1
  292.         else:
  293.             return self.parse_bogus_comment(i)
  294.  
  295.     # Internal -- parse bogus comment, return length or -1 if not terminated
  296.     # see http://www.w3.org/TR/html5/tokenization.html#bogus-comment-state
  297.     def parse_bogus_comment(self, i, report=1):
  298.         rawdata = self.rawdata
  299.         assert rawdata[i:i+2] in ('<!', '</'), ('unexpected call to '
  300.                                                 'parse_comment()')
  301.         pos = rawdata.find('>', i+2)
  302.         if pos == -1:
  303.             return -1
  304.         if report:
  305.             self.handle_comment(rawdata[i+2:pos])
  306.         return pos + 1
  307.  
  308.     # Internal -- parse processing instr, return end or -1 if not terminated
  309.     def parse_pi(self, i):
  310.         rawdata = self.rawdata
  311.         assert rawdata[i:i+2] == '<?', 'unexpected call to parse_pi()'
  312.         match = piclose.search(rawdata, i+2) # >
  313.         if not match:
  314.             return -1
  315.         j = match.start()
  316.         self.handle_pi(rawdata[i+2: j])
  317.         j = match.end()
  318.         return j
  319.  
  320.     # Internal -- handle starttag, return end or -1 if not terminated
  321.     def parse_starttag(self, i):
  322.         self.__starttag_text = None
  323.         endpos = self.check_for_whole_start_tag(i)
  324.         if endpos < 0:
  325.             return endpos
  326.         rawdata = self.rawdata
  327.         self.__starttag_text = rawdata[i:endpos]
  328.  
  329.         # Now parse the data between i+1 and j into a tag and attrs
  330.         attrs = []
  331.         if self.strict:
  332.             match = tagfind.match(rawdata, i+1)
  333.         else:
  334.             match = tagfind_tolerant.match(rawdata, i+1)
  335.         assert match, 'unexpected call to parse_starttag()'
  336.         k = match.end()
  337.         self.lasttag = tag = match.group(1).lower()
  338.         while k < endpos:
  339.             if self.strict:
  340.                 m = attrfind.match(rawdata, k)
  341.             else:
  342.                 m = attrfind_tolerant.match(rawdata, k)
  343.             if not m:
  344.                 break
  345.             attrname, rest, attrvalue = m.group(1, 2, 3)
  346.             if not rest:
  347.                 attrvalue = None
  348.             elif attrvalue[:1] == '\'' == attrvalue[-1:] or \
  349.                  attrvalue[:1] == '"' == attrvalue[-1:]:
  350.                 attrvalue = attrvalue[1:-1]
  351.             if attrvalue:
  352.                 attrvalue = self.unescape(attrvalue)
  353.             attrs.append((attrname.lower(), attrvalue))
  354.             k = m.end()
  355.  
  356.         end = rawdata[k:endpos].strip()
  357.         if end not in (">", "/>"):
  358.             lineno, offset = self.getpos()
  359.             if "\n" in self.__starttag_text:
  360.                 lineno = lineno + self.__starttag_text.count("\n")
  361.                 offset = len(self.__starttag_text) \
  362.                          - self.__starttag_text.rfind("\n")
  363.             else:
  364.                 offset = offset + len(self.__starttag_text)
  365.             if self.strict:
  366.                 self.error("junk characters in start tag: %r"
  367.                            % (rawdata[k:endpos][:20],))
  368.             self.handle_data(rawdata[i:endpos])
  369.             return endpos
  370.         if end.endswith('/>'):
  371.             # XHTML-style empty tag: <span attr="value" />
  372.             self.handle_startendtag(tag, attrs)
  373.         else:
  374.             self.handle_starttag(tag, attrs)
  375.             if tag in self.CDATA_CONTENT_ELEMENTS:
  376.                 self.set_cdata_mode(tag)
  377.         return endpos
  378.  
  379.     # Internal -- check to see if we have a complete starttag; return end
  380.     # or -1 if incomplete.
  381.     def check_for_whole_start_tag(self, i):
  382.         rawdata = self.rawdata
  383.         if self.strict:
  384.             m = locatestarttagend.match(rawdata, i)
  385.         else:
  386.             m = locatestarttagend_tolerant.match(rawdata, i)
  387.         if m:
  388.             j = m.end()
  389.             next = rawdata[j:j+1]
  390.             if next == ">":
  391.                 return j + 1
  392.             if next == "/":
  393.                 if rawdata.startswith("/>", j):
  394.                     return j + 2
  395.                 if rawdata.startswith("/", j):
  396.                     # buffer boundary
  397.                     return -1
  398.                 # else bogus input
  399.                 if self.strict:
  400.                     self.updatepos(i, j + 1)
  401.                     self.error("malformed empty start tag")
  402.                 if j > i:
  403.                     return j
  404.                 else:
  405.                     return i + 1
  406.             if next == "":
  407.                 # end of input
  408.                 return -1
  409.             if next in ("abcdefghijklmnopqrstuvwxyz=/"
  410.                         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"):
  411.                 # end of input in or before attribute value, or we have the
  412.                 # '/' from a '/>' ending
  413.                 return -1
  414.             if self.strict:
  415.                 self.updatepos(i, j)
  416.                 self.error("malformed start tag")
  417.             if j > i:
  418.                 return j
  419.             else:
  420.                 return i + 1
  421.         raise AssertionError("we should not get here!")
  422.  
  423.     # Internal -- parse endtag, return end or -1 if incomplete
  424.     def parse_endtag(self, i):
  425.         rawdata = self.rawdata
  426.         assert rawdata[i:i+2] == "</", "unexpected call to parse_endtag"
  427.         match = endendtag.search(rawdata, i+1) # >
  428.         if not match:
  429.             return -1
  430.         gtpos = match.end()
  431.         match = endtagfind.match(rawdata, i) # </ + tag + >
  432.         if not match:
  433.             if self.cdata_elem is not None:
  434.                 self.handle_data(rawdata[i:gtpos])
  435.                 return gtpos
  436.             if self.strict:
  437.                 self.error("bad end tag: %r" % (rawdata[i:gtpos],))
  438.             # find the name: w3.org/TR/html5/tokenization.html#tag-name-state
  439.             namematch = tagfind_tolerant.match(rawdata, i+2)
  440.             if not namematch:
  441.                 # w3.org/TR/html5/tokenization.html#end-tag-open-state
  442.                 if rawdata[i:i+3] == '</>':
  443.                     return i+3
  444.                 else:
  445.                     return self.parse_bogus_comment(i)
  446.             tagname = namematch.group(1).lower()
  447.             # consume and ignore other stuff between the name and the >
  448.             # Note: this is not 100% correct, since we might have things like
  449.             # </tag attr=">">, but looking for > after tha name should cover
  450.             # most of the cases and is much simpler
  451.             gtpos = rawdata.find('>', namematch.end())
  452.             self.handle_endtag(tagname)
  453.             return gtpos+1
  454.  
  455.         elem = match.group(1).lower() # script or style
  456.         if self.cdata_elem is not None:
  457.             if elem != self.cdata_elem:
  458.                 self.handle_data(rawdata[i:gtpos])
  459.                 return gtpos
  460.  
  461.         self.handle_endtag(elem.lower())
  462.         self.clear_cdata_mode()
  463.         return gtpos
  464.  
  465.     # Overridable -- finish processing of start+end tag: <tag.../>
  466.     def handle_startendtag(self, tag, attrs):
  467.         self.handle_starttag(tag, attrs)
  468.         self.handle_endtag(tag)
  469.  
  470.     # Overridable -- handle start tag
  471.     def handle_starttag(self, tag, attrs):
  472.         pass
  473.  
  474.     # Overridable -- handle end tag
  475.     def handle_endtag(self, tag):
  476.         pass
  477.  
  478.     # Overridable -- handle character reference
  479.     def handle_charref(self, name):
  480.         pass
  481.  
  482.     # Overridable -- handle entity reference
  483.     def handle_entityref(self, name):
  484.         pass
  485.  
  486.     # Overridable -- handle data
  487.     def handle_data(self, data):
  488.         pass
  489.  
  490.     # Overridable -- handle comment
  491.     def handle_comment(self, data):
  492.         pass
  493.  
  494.     # Overridable -- handle declaration
  495.     def handle_decl(self, decl):
  496.         pass
  497.  
  498.     # Overridable -- handle processing instruction
  499.     def handle_pi(self, data):
  500.         pass
  501.  
  502.     def unknown_decl(self, data):
  503.         if self.strict:
  504.             self.error("unknown declaration: %r" % (data,))
  505.  
  506.     # Internal -- helper to remove special character quoting
  507.     def unescape(self, s):
  508.         if '&' not in s:
  509.             return s
  510.         def replaceEntities(s):
  511.             s = s.groups()[0]
  512.             try:
  513.                 if s[0] == "#":
  514.                     s = s[1:]
  515.                     if s[0] in ['x','X']:
  516.                         c = int(s[1:].rstrip(';'), 16)
  517.                     else:
  518.                         c = int(s.rstrip(';'))
  519.                     return chr(c)
  520.             except ValueError:
  521.                 return '&#' + s
  522.             else:
  523.                 from html.entities import html5
  524.                 if s in html5:
  525.                     return html5[s]
  526.                 elif s.endswith(';'):
  527.                     return '&' + s
  528.                 for x in range(2, len(s)):
  529.                     if s[:x] in html5:
  530.                         return html5[s[:x]] + s[x:]
  531.                 else:
  532.                     return '&' + s
  533.  
  534.         return re.sub(r"&(#?[xX]?(?:[0-9a-fA-F]+;|\w{1,32};?))",
  535.                       replaceEntities, s, flags=re.ASCII)
  536.