Commit | Line | Data |
---|---|---|
920dae64 AT |
1 | """A parser for XML, using the derived class as static DTD.""" |
2 | ||
3 | # Author: Sjoerd Mullender. | |
4 | ||
5 | import re | |
6 | import string | |
7 | ||
8 | import warnings | |
9 | warnings.warn("The xmllib module is obsolete. Use xml.sax instead.", DeprecationWarning) | |
10 | del warnings | |
11 | ||
12 | version = '0.3' | |
13 | ||
14 | class Error(RuntimeError): | |
15 | pass | |
16 | ||
17 | # Regular expressions used for parsing | |
18 | ||
19 | _S = '[ \t\r\n]+' # white space | |
20 | _opS = '[ \t\r\n]*' # optional white space | |
21 | _Name = '[a-zA-Z_:][-a-zA-Z0-9._:]*' # valid XML name | |
22 | _QStr = "(?:'[^']*'|\"[^\"]*\")" # quoted XML string | |
23 | illegal = re.compile('[^\t\r\n -\176\240-\377]') # illegal chars in content | |
24 | interesting = re.compile('[]&<]') | |
25 | ||
26 | amp = re.compile('&') | |
27 | ref = re.compile('&(' + _Name + '|#[0-9]+|#x[0-9a-fA-F]+)[^-a-zA-Z0-9._:]') | |
28 | entityref = re.compile('&(?P<name>' + _Name + ')[^-a-zA-Z0-9._:]') | |
29 | charref = re.compile('&#(?P<char>[0-9]+[^0-9]|x[0-9a-fA-F]+[^0-9a-fA-F])') | |
30 | space = re.compile(_S + '$') | |
31 | newline = re.compile('\n') | |
32 | ||
33 | attrfind = re.compile( | |
34 | _S + '(?P<name>' + _Name + ')' | |
35 | '(' + _opS + '=' + _opS + | |
36 | '(?P<value>'+_QStr+'|[-a-zA-Z0-9.:+*%?!\(\)_#=~]+))?') | |
37 | starttagopen = re.compile('<' + _Name) | |
38 | starttagend = re.compile(_opS + '(?P<slash>/?)>') | |
39 | starttagmatch = re.compile('<(?P<tagname>'+_Name+')' | |
40 | '(?P<attrs>(?:'+attrfind.pattern+')*)'+ | |
41 | starttagend.pattern) | |
42 | endtagopen = re.compile('</') | |
43 | endbracket = re.compile(_opS + '>') | |
44 | endbracketfind = re.compile('(?:[^>\'"]|'+_QStr+')*>') | |
45 | tagfind = re.compile(_Name) | |
46 | cdataopen = re.compile(r'<!\[CDATA\[') | |
47 | cdataclose = re.compile(r'\]\]>') | |
48 | # this matches one of the following: | |
49 | # SYSTEM SystemLiteral | |
50 | # PUBLIC PubidLiteral SystemLiteral | |
51 | _SystemLiteral = '(?P<%s>'+_QStr+')' | |
52 | _PublicLiteral = '(?P<%s>"[-\'\(\)+,./:=?;!*#@$_%% \n\ra-zA-Z0-9]*"|' \ | |
53 | "'[-\(\)+,./:=?;!*#@$_%% \n\ra-zA-Z0-9]*')" | |
54 | _ExternalId = '(?:SYSTEM|' \ | |
55 | 'PUBLIC'+_S+_PublicLiteral%'pubid'+ \ | |
56 | ')'+_S+_SystemLiteral%'syslit' | |
57 | doctype = re.compile('<!DOCTYPE'+_S+'(?P<name>'+_Name+')' | |
58 | '(?:'+_S+_ExternalId+')?'+_opS) | |
59 | xmldecl = re.compile('<\?xml'+_S+ | |
60 | 'version'+_opS+'='+_opS+'(?P<version>'+_QStr+')'+ | |
61 | '(?:'+_S+'encoding'+_opS+'='+_opS+ | |
62 | "(?P<encoding>'[A-Za-z][-A-Za-z0-9._]*'|" | |
63 | '"[A-Za-z][-A-Za-z0-9._]*"))?' | |
64 | '(?:'+_S+'standalone'+_opS+'='+_opS+ | |
65 | '(?P<standalone>\'(?:yes|no)\'|"(?:yes|no)"))?'+ | |
66 | _opS+'\?>') | |
67 | procopen = re.compile(r'<\?(?P<proc>' + _Name + ')' + _opS) | |
68 | procclose = re.compile(_opS + r'\?>') | |
69 | commentopen = re.compile('<!--') | |
70 | commentclose = re.compile('-->') | |
71 | doubledash = re.compile('--') | |
72 | attrtrans = string.maketrans(' \r\n\t', ' ') | |
73 | ||
74 | # definitions for XML namespaces | |
75 | _NCName = '[a-zA-Z_][-a-zA-Z0-9._]*' # XML Name, minus the ":" | |
76 | ncname = re.compile(_NCName + '$') | |
77 | qname = re.compile('(?:(?P<prefix>' + _NCName + '):)?' # optional prefix | |
78 | '(?P<local>' + _NCName + ')$') | |
79 | ||
80 | xmlns = re.compile('xmlns(?::(?P<ncname>'+_NCName+'))?$') | |
81 | ||
82 | # XML parser base class -- find tags and call handler functions. | |
83 | # Usage: p = XMLParser(); p.feed(data); ...; p.close(). | |
84 | # The dtd is defined by deriving a class which defines methods with | |
85 | # special names to handle tags: start_foo and end_foo to handle <foo> | |
86 | # and </foo>, respectively. The data between tags is passed to the | |
87 | # parser by calling self.handle_data() with some data as argument (the | |
88 | # data may be split up in arbitrary chunks). | |
89 | ||
90 | class XMLParser: | |
91 | attributes = {} # default, to be overridden | |
92 | elements = {} # default, to be overridden | |
93 | ||
94 | # parsing options, settable using keyword args in __init__ | |
95 | __accept_unquoted_attributes = 0 | |
96 | __accept_missing_endtag_name = 0 | |
97 | __map_case = 0 | |
98 | __accept_utf8 = 0 | |
99 | __translate_attribute_references = 1 | |
100 | ||
101 | # Interface -- initialize and reset this instance | |
102 | def __init__(self, **kw): | |
103 | self.__fixed = 0 | |
104 | if 'accept_unquoted_attributes' in kw: | |
105 | self.__accept_unquoted_attributes = kw['accept_unquoted_attributes'] | |
106 | if 'accept_missing_endtag_name' in kw: | |
107 | self.__accept_missing_endtag_name = kw['accept_missing_endtag_name'] | |
108 | if 'map_case' in kw: | |
109 | self.__map_case = kw['map_case'] | |
110 | if 'accept_utf8' in kw: | |
111 | self.__accept_utf8 = kw['accept_utf8'] | |
112 | if 'translate_attribute_references' in kw: | |
113 | self.__translate_attribute_references = kw['translate_attribute_references'] | |
114 | self.reset() | |
115 | ||
116 | def __fixelements(self): | |
117 | self.__fixed = 1 | |
118 | self.elements = {} | |
119 | self.__fixdict(self.__dict__) | |
120 | self.__fixclass(self.__class__) | |
121 | ||
122 | def __fixclass(self, kl): | |
123 | self.__fixdict(kl.__dict__) | |
124 | for k in kl.__bases__: | |
125 | self.__fixclass(k) | |
126 | ||
127 | def __fixdict(self, dict): | |
128 | for key in dict.keys(): | |
129 | if key[:6] == 'start_': | |
130 | tag = key[6:] | |
131 | start, end = self.elements.get(tag, (None, None)) | |
132 | if start is None: | |
133 | self.elements[tag] = getattr(self, key), end | |
134 | elif key[:4] == 'end_': | |
135 | tag = key[4:] | |
136 | start, end = self.elements.get(tag, (None, None)) | |
137 | if end is None: | |
138 | self.elements[tag] = start, getattr(self, key) | |
139 | ||
140 | # Interface -- reset this instance. Loses all unprocessed data | |
141 | def reset(self): | |
142 | self.rawdata = '' | |
143 | self.stack = [] | |
144 | self.nomoretags = 0 | |
145 | self.literal = 0 | |
146 | self.lineno = 1 | |
147 | self.__at_start = 1 | |
148 | self.__seen_doctype = None | |
149 | self.__seen_starttag = 0 | |
150 | self.__use_namespaces = 0 | |
151 | self.__namespaces = {'xml':None} # xml is implicitly declared | |
152 | # backward compatibility hack: if elements not overridden, | |
153 | # fill it in ourselves | |
154 | if self.elements is XMLParser.elements: | |
155 | self.__fixelements() | |
156 | ||
157 | # For derived classes only -- enter literal mode (CDATA) till EOF | |
158 | def setnomoretags(self): | |
159 | self.nomoretags = self.literal = 1 | |
160 | ||
161 | # For derived classes only -- enter literal mode (CDATA) | |
162 | def setliteral(self, *args): | |
163 | self.literal = 1 | |
164 | ||
165 | # Interface -- feed some data to the parser. Call this as | |
166 | # often as you want, with as little or as much text as you | |
167 | # want (may include '\n'). (This just saves the text, all the | |
168 | # processing is done by goahead().) | |
169 | def feed(self, data): | |
170 | self.rawdata = self.rawdata + data | |
171 | self.goahead(0) | |
172 | ||
173 | # Interface -- handle the remaining data | |
174 | def close(self): | |
175 | self.goahead(1) | |
176 | if self.__fixed: | |
177 | self.__fixed = 0 | |
178 | # remove self.elements so that we don't leak | |
179 | del self.elements | |
180 | ||
181 | # Interface -- translate references | |
182 | def translate_references(self, data, all = 1): | |
183 | if not self.__translate_attribute_references: | |
184 | return data | |
185 | i = 0 | |
186 | while 1: | |
187 | res = amp.search(data, i) | |
188 | if res is None: | |
189 | return data | |
190 | s = res.start(0) | |
191 | res = ref.match(data, s) | |
192 | if res is None: | |
193 | self.syntax_error("bogus `&'") | |
194 | i = s+1 | |
195 | continue | |
196 | i = res.end(0) | |
197 | str = res.group(1) | |
198 | rescan = 0 | |
199 | if str[0] == '#': | |
200 | if str[1] == 'x': | |
201 | str = chr(int(str[2:], 16)) | |
202 | else: | |
203 | str = chr(int(str[1:])) | |
204 | if data[i - 1] != ';': | |
205 | self.syntax_error("`;' missing after char reference") | |
206 | i = i-1 | |
207 | elif all: | |
208 | if str in self.entitydefs: | |
209 | str = self.entitydefs[str] | |
210 | rescan = 1 | |
211 | elif data[i - 1] != ';': | |
212 | self.syntax_error("bogus `&'") | |
213 | i = s + 1 # just past the & | |
214 | continue | |
215 | else: | |
216 | self.syntax_error("reference to unknown entity `&%s;'" % str) | |
217 | str = '&' + str + ';' | |
218 | elif data[i - 1] != ';': | |
219 | self.syntax_error("bogus `&'") | |
220 | i = s + 1 # just past the & | |
221 | continue | |
222 | ||
223 | # when we get here, str contains the translated text and i points | |
224 | # to the end of the string that is to be replaced | |
225 | data = data[:s] + str + data[i:] | |
226 | if rescan: | |
227 | i = s | |
228 | else: | |
229 | i = s + len(str) | |
230 | ||
231 | # Interface - return a dictionary of all namespaces currently valid | |
232 | def getnamespace(self): | |
233 | nsdict = {} | |
234 | for t, d, nst in self.stack: | |
235 | nsdict.update(d) | |
236 | return nsdict | |
237 | ||
238 | # Internal -- handle data as far as reasonable. May leave state | |
239 | # and data to be processed by a subsequent call. If 'end' is | |
240 | # true, force handling all data as if followed by EOF marker. | |
241 | def goahead(self, end): | |
242 | rawdata = self.rawdata | |
243 | i = 0 | |
244 | n = len(rawdata) | |
245 | while i < n: | |
246 | if i > 0: | |
247 | self.__at_start = 0 | |
248 | if self.nomoretags: | |
249 | data = rawdata[i:n] | |
250 | self.handle_data(data) | |
251 | self.lineno = self.lineno + data.count('\n') | |
252 | i = n | |
253 | break | |
254 | res = interesting.search(rawdata, i) | |
255 | if res: | |
256 | j = res.start(0) | |
257 | else: | |
258 | j = n | |
259 | if i < j: | |
260 | data = rawdata[i:j] | |
261 | if self.__at_start and space.match(data) is None: | |
262 | self.syntax_error('illegal data at start of file') | |
263 | self.__at_start = 0 | |
264 | if not self.stack and space.match(data) is None: | |
265 | self.syntax_error('data not in content') | |
266 | if not self.__accept_utf8 and illegal.search(data): | |
267 | self.syntax_error('illegal character in content') | |
268 | self.handle_data(data) | |
269 | self.lineno = self.lineno + data.count('\n') | |
270 | i = j | |
271 | if i == n: break | |
272 | if rawdata[i] == '<': | |
273 | if starttagopen.match(rawdata, i): | |
274 | if self.literal: | |
275 | data = rawdata[i] | |
276 | self.handle_data(data) | |
277 | self.lineno = self.lineno + data.count('\n') | |
278 | i = i+1 | |
279 | continue | |
280 | k = self.parse_starttag(i) | |
281 | if k < 0: break | |
282 | self.__seen_starttag = 1 | |
283 | self.lineno = self.lineno + rawdata[i:k].count('\n') | |
284 | i = k | |
285 | continue | |
286 | if endtagopen.match(rawdata, i): | |
287 | k = self.parse_endtag(i) | |
288 | if k < 0: break | |
289 | self.lineno = self.lineno + rawdata[i:k].count('\n') | |
290 | i = k | |
291 | continue | |
292 | if commentopen.match(rawdata, i): | |
293 | if self.literal: | |
294 | data = rawdata[i] | |
295 | self.handle_data(data) | |
296 | self.lineno = self.lineno + data.count('\n') | |
297 | i = i+1 | |
298 | continue | |
299 | k = self.parse_comment(i) | |
300 | if k < 0: break | |
301 | self.lineno = self.lineno + rawdata[i:k].count('\n') | |
302 | i = k | |
303 | continue | |
304 | if cdataopen.match(rawdata, i): | |
305 | k = self.parse_cdata(i) | |
306 | if k < 0: break | |
307 | self.lineno = self.lineno + rawdata[i:k].count('\n') | |
308 | i = k | |
309 | continue | |
310 | res = xmldecl.match(rawdata, i) | |
311 | if res: | |
312 | if not self.__at_start: | |
313 | self.syntax_error("<?xml?> declaration not at start of document") | |
314 | version, encoding, standalone = res.group('version', | |
315 | 'encoding', | |
316 | 'standalone') | |
317 | if version[1:-1] != '1.0': | |
318 | raise Error('only XML version 1.0 supported') | |
319 | if encoding: encoding = encoding[1:-1] | |
320 | if standalone: standalone = standalone[1:-1] | |
321 | self.handle_xml(encoding, standalone) | |
322 | i = res.end(0) | |
323 | continue | |
324 | res = procopen.match(rawdata, i) | |
325 | if res: | |
326 | k = self.parse_proc(i) | |
327 | if k < 0: break | |
328 | self.lineno = self.lineno + rawdata[i:k].count('\n') | |
329 | i = k | |
330 | continue | |
331 | res = doctype.match(rawdata, i) | |
332 | if res: | |
333 | if self.literal: | |
334 | data = rawdata[i] | |
335 | self.handle_data(data) | |
336 | self.lineno = self.lineno + data.count('\n') | |
337 | i = i+1 | |
338 | continue | |
339 | if self.__seen_doctype: | |
340 | self.syntax_error('multiple DOCTYPE elements') | |
341 | if self.__seen_starttag: | |
342 | self.syntax_error('DOCTYPE not at beginning of document') | |
343 | k = self.parse_doctype(res) | |
344 | if k < 0: break | |
345 | self.__seen_doctype = res.group('name') | |
346 | if self.__map_case: | |
347 | self.__seen_doctype = self.__seen_doctype.lower() | |
348 | self.lineno = self.lineno + rawdata[i:k].count('\n') | |
349 | i = k | |
350 | continue | |
351 | elif rawdata[i] == '&': | |
352 | if self.literal: | |
353 | data = rawdata[i] | |
354 | self.handle_data(data) | |
355 | i = i+1 | |
356 | continue | |
357 | res = charref.match(rawdata, i) | |
358 | if res is not None: | |
359 | i = res.end(0) | |
360 | if rawdata[i-1] != ';': | |
361 | self.syntax_error("`;' missing in charref") | |
362 | i = i-1 | |
363 | if not self.stack: | |
364 | self.syntax_error('data not in content') | |
365 | self.handle_charref(res.group('char')[:-1]) | |
366 | self.lineno = self.lineno + res.group(0).count('\n') | |
367 | continue | |
368 | res = entityref.match(rawdata, i) | |
369 | if res is not None: | |
370 | i = res.end(0) | |
371 | if rawdata[i-1] != ';': | |
372 | self.syntax_error("`;' missing in entityref") | |
373 | i = i-1 | |
374 | name = res.group('name') | |
375 | if self.__map_case: | |
376 | name = name.lower() | |
377 | if name in self.entitydefs: | |
378 | self.rawdata = rawdata = rawdata[:res.start(0)] + self.entitydefs[name] + rawdata[i:] | |
379 | n = len(rawdata) | |
380 | i = res.start(0) | |
381 | else: | |
382 | self.unknown_entityref(name) | |
383 | self.lineno = self.lineno + res.group(0).count('\n') | |
384 | continue | |
385 | elif rawdata[i] == ']': | |
386 | if self.literal: | |
387 | data = rawdata[i] | |
388 | self.handle_data(data) | |
389 | i = i+1 | |
390 | continue | |
391 | if n-i < 3: | |
392 | break | |
393 | if cdataclose.match(rawdata, i): | |
394 | self.syntax_error("bogus `]]>'") | |
395 | self.handle_data(rawdata[i]) | |
396 | i = i+1 | |
397 | continue | |
398 | else: | |
399 | raise Error('neither < nor & ??') | |
400 | # We get here only if incomplete matches but | |
401 | # nothing else | |
402 | break | |
403 | # end while | |
404 | if i > 0: | |
405 | self.__at_start = 0 | |
406 | if end and i < n: | |
407 | data = rawdata[i] | |
408 | self.syntax_error("bogus `%s'" % data) | |
409 | if not self.__accept_utf8 and illegal.search(data): | |
410 | self.syntax_error('illegal character in content') | |
411 | self.handle_data(data) | |
412 | self.lineno = self.lineno + data.count('\n') | |
413 | self.rawdata = rawdata[i+1:] | |
414 | return self.goahead(end) | |
415 | self.rawdata = rawdata[i:] | |
416 | if end: | |
417 | if not self.__seen_starttag: | |
418 | self.syntax_error('no elements in file') | |
419 | if self.stack: | |
420 | self.syntax_error('missing end tags') | |
421 | while self.stack: | |
422 | self.finish_endtag(self.stack[-1][0]) | |
423 | ||
424 | # Internal -- parse comment, return length or -1 if not terminated | |
425 | def parse_comment(self, i): | |
426 | rawdata = self.rawdata | |
427 | if rawdata[i:i+4] != '<!--': | |
428 | raise Error('unexpected call to handle_comment') | |
429 | res = commentclose.search(rawdata, i+4) | |
430 | if res is None: | |
431 | return -1 | |
432 | if doubledash.search(rawdata, i+4, res.start(0)): | |
433 | self.syntax_error("`--' inside comment") | |
434 | if rawdata[res.start(0)-1] == '-': | |
435 | self.syntax_error('comment cannot end in three dashes') | |
436 | if not self.__accept_utf8 and \ | |
437 | illegal.search(rawdata, i+4, res.start(0)): | |
438 | self.syntax_error('illegal character in comment') | |
439 | self.handle_comment(rawdata[i+4: res.start(0)]) | |
440 | return res.end(0) | |
441 | ||
442 | # Internal -- handle DOCTYPE tag, return length or -1 if not terminated | |
443 | def parse_doctype(self, res): | |
444 | rawdata = self.rawdata | |
445 | n = len(rawdata) | |
446 | name = res.group('name') | |
447 | if self.__map_case: | |
448 | name = name.lower() | |
449 | pubid, syslit = res.group('pubid', 'syslit') | |
450 | if pubid is not None: | |
451 | pubid = pubid[1:-1] # remove quotes | |
452 | pubid = ' '.join(pubid.split()) # normalize | |
453 | if syslit is not None: syslit = syslit[1:-1] # remove quotes | |
454 | j = k = res.end(0) | |
455 | if k >= n: | |
456 | return -1 | |
457 | if rawdata[k] == '[': | |
458 | level = 0 | |
459 | k = k+1 | |
460 | dq = sq = 0 | |
461 | while k < n: | |
462 | c = rawdata[k] | |
463 | if not sq and c == '"': | |
464 | dq = not dq | |
465 | elif not dq and c == "'": | |
466 | sq = not sq | |
467 | elif sq or dq: | |
468 | pass | |
469 | elif level <= 0 and c == ']': | |
470 | res = endbracket.match(rawdata, k+1) | |
471 | if res is None: | |
472 | return -1 | |
473 | self.handle_doctype(name, pubid, syslit, rawdata[j+1:k]) | |
474 | return res.end(0) | |
475 | elif c == '<': | |
476 | level = level + 1 | |
477 | elif c == '>': | |
478 | level = level - 1 | |
479 | if level < 0: | |
480 | self.syntax_error("bogus `>' in DOCTYPE") | |
481 | k = k+1 | |
482 | res = endbracketfind.match(rawdata, k) | |
483 | if res is None: | |
484 | return -1 | |
485 | if endbracket.match(rawdata, k) is None: | |
486 | self.syntax_error('garbage in DOCTYPE') | |
487 | self.handle_doctype(name, pubid, syslit, None) | |
488 | return res.end(0) | |
489 | ||
490 | # Internal -- handle CDATA tag, return length or -1 if not terminated | |
491 | def parse_cdata(self, i): | |
492 | rawdata = self.rawdata | |
493 | if rawdata[i:i+9] != '<![CDATA[': | |
494 | raise Error('unexpected call to parse_cdata') | |
495 | res = cdataclose.search(rawdata, i+9) | |
496 | if res is None: | |
497 | return -1 | |
498 | if not self.__accept_utf8 and \ | |
499 | illegal.search(rawdata, i+9, res.start(0)): | |
500 | self.syntax_error('illegal character in CDATA') | |
501 | if not self.stack: | |
502 | self.syntax_error('CDATA not in content') | |
503 | self.handle_cdata(rawdata[i+9:res.start(0)]) | |
504 | return res.end(0) | |
505 | ||
506 | __xml_namespace_attributes = {'ns':None, 'src':None, 'prefix':None} | |
507 | # Internal -- handle a processing instruction tag | |
508 | def parse_proc(self, i): | |
509 | rawdata = self.rawdata | |
510 | end = procclose.search(rawdata, i) | |
511 | if end is None: | |
512 | return -1 | |
513 | j = end.start(0) | |
514 | if not self.__accept_utf8 and illegal.search(rawdata, i+2, j): | |
515 | self.syntax_error('illegal character in processing instruction') | |
516 | res = tagfind.match(rawdata, i+2) | |
517 | if res is None: | |
518 | raise Error('unexpected call to parse_proc') | |
519 | k = res.end(0) | |
520 | name = res.group(0) | |
521 | if self.__map_case: | |
522 | name = name.lower() | |
523 | if name == 'xml:namespace': | |
524 | self.syntax_error('old-fashioned namespace declaration') | |
525 | self.__use_namespaces = -1 | |
526 | # namespace declaration | |
527 | # this must come after the <?xml?> declaration (if any) | |
528 | # and before the <!DOCTYPE> (if any). | |
529 | if self.__seen_doctype or self.__seen_starttag: | |
530 | self.syntax_error('xml:namespace declaration too late in document') | |
531 | attrdict, namespace, k = self.parse_attributes(name, k, j) | |
532 | if namespace: | |
533 | self.syntax_error('namespace declaration inside namespace declaration') | |
534 | for attrname in attrdict.keys(): | |
535 | if not attrname in self.__xml_namespace_attributes: | |
536 | self.syntax_error("unknown attribute `%s' in xml:namespace tag" % attrname) | |
537 | if not 'ns' in attrdict or not 'prefix' in attrdict: | |
538 | self.syntax_error('xml:namespace without required attributes') | |
539 | prefix = attrdict.get('prefix') | |
540 | if ncname.match(prefix) is None: | |
541 | self.syntax_error('xml:namespace illegal prefix value') | |
542 | return end.end(0) | |
543 | if prefix in self.__namespaces: | |
544 | self.syntax_error('xml:namespace prefix not unique') | |
545 | self.__namespaces[prefix] = attrdict['ns'] | |
546 | else: | |
547 | if name.lower() == 'xml': | |
548 | self.syntax_error('illegal processing instruction target name') | |
549 | self.handle_proc(name, rawdata[k:j]) | |
550 | return end.end(0) | |
551 | ||
552 | # Internal -- parse attributes between i and j | |
553 | def parse_attributes(self, tag, i, j): | |
554 | rawdata = self.rawdata | |
555 | attrdict = {} | |
556 | namespace = {} | |
557 | while i < j: | |
558 | res = attrfind.match(rawdata, i) | |
559 | if res is None: | |
560 | break | |
561 | attrname, attrvalue = res.group('name', 'value') | |
562 | if self.__map_case: | |
563 | attrname = attrname.lower() | |
564 | i = res.end(0) | |
565 | if attrvalue is None: | |
566 | self.syntax_error("no value specified for attribute `%s'" % attrname) | |
567 | attrvalue = attrname | |
568 | elif attrvalue[:1] == "'" == attrvalue[-1:] or \ | |
569 | attrvalue[:1] == '"' == attrvalue[-1:]: | |
570 | attrvalue = attrvalue[1:-1] | |
571 | elif not self.__accept_unquoted_attributes: | |
572 | self.syntax_error("attribute `%s' value not quoted" % attrname) | |
573 | res = xmlns.match(attrname) | |
574 | if res is not None: | |
575 | # namespace declaration | |
576 | ncname = res.group('ncname') | |
577 | namespace[ncname or ''] = attrvalue or None | |
578 | if not self.__use_namespaces: | |
579 | self.__use_namespaces = len(self.stack)+1 | |
580 | continue | |
581 | if '<' in attrvalue: | |
582 | self.syntax_error("`<' illegal in attribute value") | |
583 | if attrname in attrdict: | |
584 | self.syntax_error("attribute `%s' specified twice" % attrname) | |
585 | attrvalue = attrvalue.translate(attrtrans) | |
586 | attrdict[attrname] = self.translate_references(attrvalue) | |
587 | return attrdict, namespace, i | |
588 | ||
589 | # Internal -- handle starttag, return length or -1 if not terminated | |
590 | def parse_starttag(self, i): | |
591 | rawdata = self.rawdata | |
592 | # i points to start of tag | |
593 | end = endbracketfind.match(rawdata, i+1) | |
594 | if end is None: | |
595 | return -1 | |
596 | tag = starttagmatch.match(rawdata, i) | |
597 | if tag is None or tag.end(0) != end.end(0): | |
598 | self.syntax_error('garbage in starttag') | |
599 | return end.end(0) | |
600 | nstag = tagname = tag.group('tagname') | |
601 | if self.__map_case: | |
602 | nstag = tagname = nstag.lower() | |
603 | if not self.__seen_starttag and self.__seen_doctype and \ | |
604 | tagname != self.__seen_doctype: | |
605 | self.syntax_error('starttag does not match DOCTYPE') | |
606 | if self.__seen_starttag and not self.stack: | |
607 | self.syntax_error('multiple elements on top level') | |
608 | k, j = tag.span('attrs') | |
609 | attrdict, nsdict, k = self.parse_attributes(tagname, k, j) | |
610 | self.stack.append((tagname, nsdict, nstag)) | |
611 | if self.__use_namespaces: | |
612 | res = qname.match(tagname) | |
613 | else: | |
614 | res = None | |
615 | if res is not None: | |
616 | prefix, nstag = res.group('prefix', 'local') | |
617 | if prefix is None: | |
618 | prefix = '' | |
619 | ns = None | |
620 | for t, d, nst in self.stack: | |
621 | if prefix in d: | |
622 | ns = d[prefix] | |
623 | if ns is None and prefix != '': | |
624 | ns = self.__namespaces.get(prefix) | |
625 | if ns is not None: | |
626 | nstag = ns + ' ' + nstag | |
627 | elif prefix != '': | |
628 | nstag = prefix + ':' + nstag # undo split | |
629 | self.stack[-1] = tagname, nsdict, nstag | |
630 | # translate namespace of attributes | |
631 | attrnamemap = {} # map from new name to old name (used for error reporting) | |
632 | for key in attrdict.keys(): | |
633 | attrnamemap[key] = key | |
634 | if self.__use_namespaces: | |
635 | nattrdict = {} | |
636 | for key, val in attrdict.items(): | |
637 | okey = key | |
638 | res = qname.match(key) | |
639 | if res is not None: | |
640 | aprefix, key = res.group('prefix', 'local') | |
641 | if self.__map_case: | |
642 | key = key.lower() | |
643 | if aprefix is not None: | |
644 | ans = None | |
645 | for t, d, nst in self.stack: | |
646 | if aprefix in d: | |
647 | ans = d[aprefix] | |
648 | if ans is None: | |
649 | ans = self.__namespaces.get(aprefix) | |
650 | if ans is not None: | |
651 | key = ans + ' ' + key | |
652 | else: | |
653 | key = aprefix + ':' + key | |
654 | nattrdict[key] = val | |
655 | attrnamemap[key] = okey | |
656 | attrdict = nattrdict | |
657 | attributes = self.attributes.get(nstag) | |
658 | if attributes is not None: | |
659 | for key in attrdict.keys(): | |
660 | if not key in attributes: | |
661 | self.syntax_error("unknown attribute `%s' in tag `%s'" % (attrnamemap[key], tagname)) | |
662 | for key, val in attributes.items(): | |
663 | if val is not None and not key in attrdict: | |
664 | attrdict[key] = val | |
665 | method = self.elements.get(nstag, (None, None))[0] | |
666 | self.finish_starttag(nstag, attrdict, method) | |
667 | if tag.group('slash') == '/': | |
668 | self.finish_endtag(tagname) | |
669 | return tag.end(0) | |
670 | ||
671 | # Internal -- parse endtag | |
672 | def parse_endtag(self, i): | |
673 | rawdata = self.rawdata | |
674 | end = endbracketfind.match(rawdata, i+1) | |
675 | if end is None: | |
676 | return -1 | |
677 | res = tagfind.match(rawdata, i+2) | |
678 | if res is None: | |
679 | if self.literal: | |
680 | self.handle_data(rawdata[i]) | |
681 | return i+1 | |
682 | if not self.__accept_missing_endtag_name: | |
683 | self.syntax_error('no name specified in end tag') | |
684 | tag = self.stack[-1][0] | |
685 | k = i+2 | |
686 | else: | |
687 | tag = res.group(0) | |
688 | if self.__map_case: | |
689 | tag = tag.lower() | |
690 | if self.literal: | |
691 | if not self.stack or tag != self.stack[-1][0]: | |
692 | self.handle_data(rawdata[i]) | |
693 | return i+1 | |
694 | k = res.end(0) | |
695 | if endbracket.match(rawdata, k) is None: | |
696 | self.syntax_error('garbage in end tag') | |
697 | self.finish_endtag(tag) | |
698 | return end.end(0) | |
699 | ||
700 | # Internal -- finish processing of start tag | |
701 | def finish_starttag(self, tagname, attrdict, method): | |
702 | if method is not None: | |
703 | self.handle_starttag(tagname, method, attrdict) | |
704 | else: | |
705 | self.unknown_starttag(tagname, attrdict) | |
706 | ||
707 | # Internal -- finish processing of end tag | |
708 | def finish_endtag(self, tag): | |
709 | self.literal = 0 | |
710 | if not tag: | |
711 | self.syntax_error('name-less end tag') | |
712 | found = len(self.stack) - 1 | |
713 | if found < 0: | |
714 | self.unknown_endtag(tag) | |
715 | return | |
716 | else: | |
717 | found = -1 | |
718 | for i in range(len(self.stack)): | |
719 | if tag == self.stack[i][0]: | |
720 | found = i | |
721 | if found == -1: | |
722 | self.syntax_error('unopened end tag') | |
723 | return | |
724 | while len(self.stack) > found: | |
725 | if found < len(self.stack) - 1: | |
726 | self.syntax_error('missing close tag for %s' % self.stack[-1][2]) | |
727 | nstag = self.stack[-1][2] | |
728 | method = self.elements.get(nstag, (None, None))[1] | |
729 | if method is not None: | |
730 | self.handle_endtag(nstag, method) | |
731 | else: | |
732 | self.unknown_endtag(nstag) | |
733 | if self.__use_namespaces == len(self.stack): | |
734 | self.__use_namespaces = 0 | |
735 | del self.stack[-1] | |
736 | ||
737 | # Overridable -- handle xml processing instruction | |
738 | def handle_xml(self, encoding, standalone): | |
739 | pass | |
740 | ||
741 | # Overridable -- handle DOCTYPE | |
742 | def handle_doctype(self, tag, pubid, syslit, data): | |
743 | pass | |
744 | ||
745 | # Overridable -- handle start tag | |
746 | def handle_starttag(self, tag, method, attrs): | |
747 | method(attrs) | |
748 | ||
749 | # Overridable -- handle end tag | |
750 | def handle_endtag(self, tag, method): | |
751 | method() | |
752 | ||
753 | # Example -- handle character reference, no need to override | |
754 | def handle_charref(self, name): | |
755 | try: | |
756 | if name[0] == 'x': | |
757 | n = int(name[1:], 16) | |
758 | else: | |
759 | n = int(name) | |
760 | except ValueError: | |
761 | self.unknown_charref(name) | |
762 | return | |
763 | if not 0 <= n <= 255: | |
764 | self.unknown_charref(name) | |
765 | return | |
766 | self.handle_data(chr(n)) | |
767 | ||
768 | # Definition of entities -- derived classes may override | |
769 | entitydefs = {'lt': '<', # must use charref | |
770 | 'gt': '>', | |
771 | 'amp': '&', # must use charref | |
772 | 'quot': '"', | |
773 | 'apos': ''', | |
774 | } | |
775 | ||
776 | # Example -- handle data, should be overridden | |
777 | def handle_data(self, data): | |
778 | pass | |
779 | ||
780 | # Example -- handle cdata, could be overridden | |
781 | def handle_cdata(self, data): | |
782 | pass | |
783 | ||
784 | # Example -- handle comment, could be overridden | |
785 | def handle_comment(self, data): | |
786 | pass | |
787 | ||
788 | # Example -- handle processing instructions, could be overridden | |
789 | def handle_proc(self, name, data): | |
790 | pass | |
791 | ||
792 | # Example -- handle relatively harmless syntax errors, could be overridden | |
793 | def syntax_error(self, message): | |
794 | raise Error('Syntax error at line %d: %s' % (self.lineno, message)) | |
795 | ||
796 | # To be overridden -- handlers for unknown objects | |
797 | def unknown_starttag(self, tag, attrs): pass | |
798 | def unknown_endtag(self, tag): pass | |
799 | def unknown_charref(self, ref): pass | |
800 | def unknown_entityref(self, name): | |
801 | self.syntax_error("reference to unknown entity `&%s;'" % name) | |
802 | ||
803 | ||
804 | class TestXMLParser(XMLParser): | |
805 | ||
806 | def __init__(self, **kw): | |
807 | self.testdata = "" | |
808 | XMLParser.__init__(self, **kw) | |
809 | ||
810 | def handle_xml(self, encoding, standalone): | |
811 | self.flush() | |
812 | print 'xml: encoding =',encoding,'standalone =',standalone | |
813 | ||
814 | def handle_doctype(self, tag, pubid, syslit, data): | |
815 | self.flush() | |
816 | print 'DOCTYPE:',tag, repr(data) | |
817 | ||
818 | def handle_data(self, data): | |
819 | self.testdata = self.testdata + data | |
820 | if len(repr(self.testdata)) >= 70: | |
821 | self.flush() | |
822 | ||
823 | def flush(self): | |
824 | data = self.testdata | |
825 | if data: | |
826 | self.testdata = "" | |
827 | print 'data:', repr(data) | |
828 | ||
829 | def handle_cdata(self, data): | |
830 | self.flush() | |
831 | print 'cdata:', repr(data) | |
832 | ||
833 | def handle_proc(self, name, data): | |
834 | self.flush() | |
835 | print 'processing:',name,repr(data) | |
836 | ||
837 | def handle_comment(self, data): | |
838 | self.flush() | |
839 | r = repr(data) | |
840 | if len(r) > 68: | |
841 | r = r[:32] + '...' + r[-32:] | |
842 | print 'comment:', r | |
843 | ||
844 | def syntax_error(self, message): | |
845 | print 'error at line %d:' % self.lineno, message | |
846 | ||
847 | def unknown_starttag(self, tag, attrs): | |
848 | self.flush() | |
849 | if not attrs: | |
850 | print 'start tag: <' + tag + '>' | |
851 | else: | |
852 | print 'start tag: <' + tag, | |
853 | for name, value in attrs.items(): | |
854 | print name + '=' + '"' + value + '"', | |
855 | print '>' | |
856 | ||
857 | def unknown_endtag(self, tag): | |
858 | self.flush() | |
859 | print 'end tag: </' + tag + '>' | |
860 | ||
861 | def unknown_entityref(self, ref): | |
862 | self.flush() | |
863 | print '*** unknown entity ref: &' + ref + ';' | |
864 | ||
865 | def unknown_charref(self, ref): | |
866 | self.flush() | |
867 | print '*** unknown char ref: &#' + ref + ';' | |
868 | ||
869 | def close(self): | |
870 | XMLParser.close(self) | |
871 | self.flush() | |
872 | ||
873 | def test(args = None): | |
874 | import sys, getopt | |
875 | from time import time | |
876 | ||
877 | if not args: | |
878 | args = sys.argv[1:] | |
879 | ||
880 | opts, args = getopt.getopt(args, 'st') | |
881 | klass = TestXMLParser | |
882 | do_time = 0 | |
883 | for o, a in opts: | |
884 | if o == '-s': | |
885 | klass = XMLParser | |
886 | elif o == '-t': | |
887 | do_time = 1 | |
888 | ||
889 | if args: | |
890 | file = args[0] | |
891 | else: | |
892 | file = 'test.xml' | |
893 | ||
894 | if file == '-': | |
895 | f = sys.stdin | |
896 | else: | |
897 | try: | |
898 | f = open(file, 'r') | |
899 | except IOError, msg: | |
900 | print file, ":", msg | |
901 | sys.exit(1) | |
902 | ||
903 | data = f.read() | |
904 | if f is not sys.stdin: | |
905 | f.close() | |
906 | ||
907 | x = klass() | |
908 | t0 = time() | |
909 | try: | |
910 | if do_time: | |
911 | x.feed(data) | |
912 | x.close() | |
913 | else: | |
914 | for c in data: | |
915 | x.feed(c) | |
916 | x.close() | |
917 | except Error, msg: | |
918 | t1 = time() | |
919 | print msg | |
920 | if do_time: | |
921 | print 'total time: %g' % (t1-t0) | |
922 | sys.exit(1) | |
923 | t1 = time() | |
924 | if do_time: | |
925 | print 'total time: %g' % (t1-t0) | |
926 | ||
927 | ||
928 | if __name__ == '__main__': | |
929 | test() |