| import HTMLParser as _HTMLParser |
| import re |
| import sys |
| |
| current_version = sys.version_info |
| |
| use_workaround = ( |
| (current_version < (2, 7, 3)) or |
| (current_version >= (3, 0) and current_version < (3, 2, 3)) |
| ) |
| |
| if not use_workaround: |
| HTMLParser = _HTMLParser.HTMLParser |
| else: |
| class HTMLParser(_HTMLParser.HTMLParser): |
| """ |
| Patched version of stdlib's HTMLParser with patch from: |
| http://bugs.python.org/issue670664 |
| """ |
| def __init__(self): |
| _HTMLParser.HTMLParser.__init__(self) |
| self.cdata_tag = None |
| |
| def set_cdata_mode(self, tag): |
| try: |
| self.interesting = _HTMLParser.interesting_cdata |
| except AttributeError: |
| self.interesting = re.compile(r'</\s*%s\s*>' % tag.lower(), re.I) |
| self.cdata_tag = tag.lower() |
| |
| def clear_cdata_mode(self): |
| self.interesting = _HTMLParser.interesting_normal |
| self.cdata_tag = None |
| |
| # Internal -- handle starttag, return end or -1 if not terminated |
| def parse_starttag(self, i): |
| self.__starttag_text = None |
| endpos = self.check_for_whole_start_tag(i) |
| if endpos < 0: |
| return endpos |
| rawdata = self.rawdata |
| self.__starttag_text = rawdata[i:endpos] |
| |
| # Now parse the data between i+1 and j into a tag and attrs |
| attrs = [] |
| match = _HTMLParser.tagfind.match(rawdata, i + 1) |
| assert match, 'unexpected call to parse_starttag()' |
| k = match.end() |
| self.lasttag = tag = rawdata[i + 1:k].lower() |
| |
| while k < endpos: |
| m = _HTMLParser.attrfind.match(rawdata, k) |
| if not m: |
| break |
| attrname, rest, attrvalue = m.group(1, 2, 3) |
| if not rest: |
| attrvalue = None |
| elif attrvalue[:1] == '\'' == attrvalue[-1:] or \ |
| attrvalue[:1] == '"' == attrvalue[-1:]: |
| attrvalue = attrvalue[1:-1] |
| attrvalue = self.unescape(attrvalue) |
| attrs.append((attrname.lower(), attrvalue)) |
| k = m.end() |
| |
| end = rawdata[k:endpos].strip() |
| if end not in (">", "/>"): |
| lineno, offset = self.getpos() |
| if "\n" in self.__starttag_text: |
| lineno = lineno + self.__starttag_text.count("\n") |
| offset = len(self.__starttag_text) \ |
| - self.__starttag_text.rfind("\n") |
| else: |
| offset = offset + len(self.__starttag_text) |
| self.error("junk characters in start tag: %r" |
| % (rawdata[k:endpos][:20],)) |
| if end.endswith('/>'): |
| # XHTML-style empty tag: <span attr="value" /> |
| self.handle_startendtag(tag, attrs) |
| else: |
| self.handle_starttag(tag, attrs) |
| if tag in self.CDATA_CONTENT_ELEMENTS: |
| self.set_cdata_mode(tag) # <--------------------------- Changed |
| return endpos |
| |
| # Internal -- parse endtag, return end or -1 if incomplete |
| def parse_endtag(self, i): |
| rawdata = self.rawdata |
| assert rawdata[i:i + 2] == "</", "unexpected call to parse_endtag" |
| match = _HTMLParser.endendtag.search(rawdata, i + 1) # > |
| if not match: |
| return -1 |
| j = match.end() |
| match = _HTMLParser.endtagfind.match(rawdata, i) # </ + tag + > |
| if not match: |
| if self.cdata_tag is not None: # *** add *** |
| self.handle_data(rawdata[i:j]) # *** add *** |
| return j # *** add *** |
| self.error("bad end tag: %r" % (rawdata[i:j],)) |
| # --- changed start --------------------------------------------------- |
| tag = match.group(1).strip() |
| if self.cdata_tag is not None: |
| if tag.lower() != self.cdata_tag: |
| self.handle_data(rawdata[i:j]) |
| return j |
| # --- changed end ----------------------------------------------------- |
| self.handle_endtag(tag.lower()) |
| self.clear_cdata_mode() |
| return j |
