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