python模块：xml.dom.minidom

1 """Simple implementation of the Level 1 DOM.
2
3 Namespaces and other minor Level 2 features are also supported.
4
5 parse("foo.xml")
6
7 parseString("<foo><bar/></foo>")
8
9 Todo:
10 =====
11  * convenience methods for getting elements and text.
12  * more testing
13  * bring some of the writer and linearizer code into conformance with this
14         interface
15  * SAX 2 namespaces
16 """
17
18 import io
19 import xml.dom
20
21 from xml.dom import EMPTY_NAMESPACE, EMPTY_PREFIX, XMLNS_NAMESPACE, domreg
22 from xml.dom.minicompat import *
23 from xml.dom.xmlbuilder import DOMImplementationLS, DocumentLS
24
25 # This is used by the ID-cache invalidation checks; the list isn't
26 # actually complete, since the nodes being checked will never be the
27 # DOCUMENT_NODE or DOCUMENT_FRAGMENT_NODE.  (The node being checked is
28 # the node being added or removed, not the node being modified.)
29 #
30 _nodeTypes_with_children = (xml.dom.Node.ELEMENT_NODE,
31                             xml.dom.Node.ENTITY_REFERENCE_NODE)
32
33
34 class Node(xml.dom.Node):
35     namespaceURI = None # this is non-null only for elements and attributes
36     parentNode = None
37     ownerDocument = None
38     nextSibling = None
39     previousSibling = None
40
41     prefix = EMPTY_PREFIX # non-null only for NS elements and attributes
42
43     def __bool__(self):
44         return True
45
46     def toxml(self, encoding=None):
47         return self.toprettyxml("", "", encoding)
48
49     def toprettyxml(self, indent="\t", newl="\n", encoding=None):
50         if encoding is None:
51             writer = io.StringIO()
52         else:
53             writer = io.TextIOWrapper(io.BytesIO(),
54                                       encoding=encoding,
55                                       errors="xmlcharrefreplace",
56                                       newline='\n')
57         if self.nodeType == Node.DOCUMENT_NODE:
58             # Can pass encoding only to document, to put it into XML header
59             self.writexml(writer, "", indent, newl, encoding)
60         else:
61             self.writexml(writer, "", indent, newl)
62         if encoding is None:
63             return writer.getvalue()
64         else:
65             return writer.detach().getvalue()
66
67     def hasChildNodes(self):
68         return bool(self.childNodes)
69
70     def _get_childNodes(self):
71         return self.childNodes
72
73     def _get_firstChild(self):
74         if self.childNodes:
75             return self.childNodes[0]
76
77     def _get_lastChild(self):
78         if self.childNodes:
79             return self.childNodes[-1]
80
81     def insertBefore(self, newChild, refChild):
82         if newChild.nodeType == self.DOCUMENT_FRAGMENT_NODE:
83             for c in tuple(newChild.childNodes):
84                 self.insertBefore(c, refChild)
85             ### The DOM does not clearly specify what to return in this case
86             return newChild
87         if newChild.nodeType not in self._child_node_types:
88             raise xml.dom.HierarchyRequestErr(
89                 "%s cannot be child of %s" % (repr(newChild), repr(self)))
90         if newChild.parentNode is not None:
91             newChild.parentNode.removeChild(newChild)
92         if refChild is None:
93             self.appendChild(newChild)
94         else:
95             try:
96                 index = self.childNodes.index(refChild)
97             except ValueError:
98                 raise xml.dom.NotFoundErr()
99             if newChild.nodeType in _nodeTypes_with_children:
100                 _clear_id_cache(self)
101             self.childNodes.insert(index, newChild)
102             newChild.nextSibling = refChild
103             refChild.previousSibling = newChild
104             if index:
105                 node = self.childNodes[index-1]
106                 node.nextSibling = newChild
107                 newChild.previousSibling = node
108             else:
109                 newChild.previousSibling = None
110             newChild.parentNode = self
111         return newChild
112
113     def appendChild(self, node):
114         if node.nodeType == self.DOCUMENT_FRAGMENT_NODE:
115             for c in tuple(node.childNodes):
116                 self.appendChild(c)
117             ### The DOM does not clearly specify what to return in this case
118             return node
119         if node.nodeType not in self._child_node_types:
120             raise xml.dom.HierarchyRequestErr(
121                 "%s cannot be child of %s" % (repr(node), repr(self)))
122         elif node.nodeType in _nodeTypes_with_children:
123             _clear_id_cache(self)
124         if node.parentNode is not None:
125             node.parentNode.removeChild(node)
126         _append_child(self, node)
127         node.nextSibling = None
128         return node
129
130     def replaceChild(self, newChild, oldChild):
131         if newChild.nodeType == self.DOCUMENT_FRAGMENT_NODE:
132             refChild = oldChild.nextSibling
133             self.removeChild(oldChild)
134             return self.insertBefore(newChild, refChild)
135         if newChild.nodeType not in self._child_node_types:
136             raise xml.dom.HierarchyRequestErr(
137                 "%s cannot be child of %s" % (repr(newChild), repr(self)))
138         if newChild is oldChild:
139             return
140         if newChild.parentNode is not None:
141             newChild.parentNode.removeChild(newChild)
142         try:
143             index = self.childNodes.index(oldChild)
144         except ValueError:
145             raise xml.dom.NotFoundErr()
146         self.childNodes[index] = newChild
147         newChild.parentNode = self
148         oldChild.parentNode = None
149         if (newChild.nodeType in _nodeTypes_with_children
150             or oldChild.nodeType in _nodeTypes_with_children):
151             _clear_id_cache(self)
152         newChild.nextSibling = oldChild.nextSibling
153         newChild.previousSibling = oldChild.previousSibling
154         oldChild.nextSibling = None
155         oldChild.previousSibling = None
156         if newChild.previousSibling:
157             newChild.previousSibling.nextSibling = newChild
158         if newChild.nextSibling:
159             newChild.nextSibling.previousSibling = newChild
160         return oldChild
161
162     def removeChild(self, oldChild):
163         try:
164             self.childNodes.remove(oldChild)
165         except ValueError:
166             raise xml.dom.NotFoundErr()
167         if oldChild.nextSibling is not None:
168             oldChild.nextSibling.previousSibling = oldChild.previousSibling
169         if oldChild.previousSibling is not None:
170             oldChild.previousSibling.nextSibling = oldChild.nextSibling
171         oldChild.nextSibling = oldChild.previousSibling = None
172         if oldChild.nodeType in _nodeTypes_with_children:
173             _clear_id_cache(self)
174
175         oldChild.parentNode = None
176         return oldChild
177
178     def normalize(self):
179         L = []
180         for child in self.childNodes:
181             if child.nodeType == Node.TEXT_NODE:
182                 if not child.data:
183                     # empty text node; discard
184                     if L:
185                         L[-1].nextSibling = child.nextSibling
186                     if child.nextSibling:
187                         child.nextSibling.previousSibling = child.previousSibling
188                     child.unlink()
189                 elif L and L[-1].nodeType == child.nodeType:
190                     # collapse text node
191                     node = L[-1]
192                     node.data = node.data + child.data
193                     node.nextSibling = child.nextSibling
194                     if child.nextSibling:
195                         child.nextSibling.previousSibling = node
196                     child.unlink()
197                 else:
198                     L.append(child)
199             else:
200                 L.append(child)
201                 if child.nodeType == Node.ELEMENT_NODE:
202                     child.normalize()
203         self.childNodes[:] = L
204
205     def cloneNode(self, deep):
206         return _clone_node(self, deep, self.ownerDocument or self)
207
208     def isSupported(self, feature, version):
209         return self.ownerDocument.implementation.hasFeature(feature, version)
210
211     def _get_localName(self):
212         # Overridden in Element and Attr where localName can be Non-Null
213         return None
214
215     # Node interfaces from Level 3 (WD 9 April 2002)
216
217     def isSameNode(self, other):
218         return self is other
219
220     def getInterface(self, feature):
221         if self.isSupported(feature, None):
222             return self
223         else:
224             return None
225
226     # The "user data" functions use a dictionary that is only present
227     # if some user data has been set, so be careful not to assume it
228     # exists.
229
230     def getUserData(self, key):
231         try:
232             return self._user_data[key][0]
233         except (AttributeError, KeyError):
234             return None
235
236     def setUserData(self, key, data, handler):
237         old = None
238         try:
239             d = self._user_data
240         except AttributeError:
241             d = {}
242             self._user_data = d
243         if key in d:
244             old = d[key][0]
245         if data is None:
246             # ignore handlers passed for None
247             handler = None
248             if old is not None:
249                 del d[key]
250         else:
251             d[key] = (data, handler)
252         return old
253
254     def _call_user_data_handler(self, operation, src, dst):
255         if hasattr(self, "_user_data"):
256             for key, (data, handler) in list(self._user_data.items()):
257                 if handler is not None:
258                     handler.handle(operation, key, data, src, dst)
259
260     # minidom-specific API:
261
262     def unlink(self):
263         self.parentNode = self.ownerDocument = None
264         if self.childNodes:
265             for child in self.childNodes:
266                 child.unlink()
267             self.childNodes = NodeList()
268         self.previousSibling = None
269         self.nextSibling = None
270
271     # A Node is its own context manager, to ensure that an unlink() call occurs.
272     # This is similar to how a file object works.
273     def __enter__(self):
274         return self
275
276     def __exit__(self, et, ev, tb):
277         self.unlink()
278
279 defproperty(Node, "firstChild", doc="First child node, or None.")
280 defproperty(Node, "lastChild",  doc="Last child node, or None.")
281 defproperty(Node, "localName",  doc="Namespace-local name of this node.")
282
283
284 def _append_child(self, node):
285     # fast path with less checks; usable by DOM builders if careful
286     childNodes = self.childNodes
287     if childNodes:
288         last = childNodes[-1]
289         node.previousSibling = last
290         last.nextSibling = node
291     childNodes.append(node)
292     node.parentNode = self
293
294 def _in_document(node):
295     # return True iff node is part of a document tree
296     while node is not None:
297         if node.nodeType == Node.DOCUMENT_NODE:
298             return True
299         node = node.parentNode
300     return False
301
302 def _write_data(writer, data):
303     "Writes datachars to writer."
304     if data:
305         data = data.replace("&", "&").replace("<", "<"). \
306                     replace("\"", """).replace(">", ">")
307         writer.write(data)
308
309 def _get_elements_by_tagName_helper(parent, name, rc):
310     for node in parent.childNodes:
311         if node.nodeType == Node.ELEMENT_NODE and \
312             (name == "*" or node.tagName == name):
313             rc.append(node)
314         _get_elements_by_tagName_helper(node, name, rc)
315     return rc
316
317 def _get_elements_by_tagName_ns_helper(parent, nsURI, localName, rc):
318     for node in parent.childNodes:
319         if node.nodeType == Node.ELEMENT_NODE:
320             if ((localName == "*" or node.localName == localName) and
321                 (nsURI == "*" or node.namespaceURI == nsURI)):
322                 rc.append(node)
323             _get_elements_by_tagName_ns_helper(node, nsURI, localName, rc)
324     return rc
325
326 class DocumentFragment(Node):
327     nodeType = Node.DOCUMENT_FRAGMENT_NODE
328     nodeName = "#document-fragment"
329     nodeValue = None
330     attributes = None
331     parentNode = None
332     _child_node_types = (Node.ELEMENT_NODE,
333                          Node.TEXT_NODE,
334                          Node.CDATA_SECTION_NODE,
335                          Node.ENTITY_REFERENCE_NODE,
336                          Node.PROCESSING_INSTRUCTION_NODE,
337                          Node.COMMENT_NODE,
338                          Node.NOTATION_NODE)
339
340     def __init__(self):
341         self.childNodes = NodeList()
342
343
344 class Attr(Node):
345     __slots__=('_name', '_value', 'namespaceURI',
346                '_prefix', 'childNodes', '_localName', 'ownerDocument', 'ownerElement')
347     nodeType = Node.ATTRIBUTE_NODE
348     attributes = None
349     specified = False
350     _is_id = False
351
352     _child_node_types = (Node.TEXT_NODE, Node.ENTITY_REFERENCE_NODE)
353
354     def __init__(self, qName, namespaceURI=EMPTY_NAMESPACE, localName=None,
355                  prefix=None):
356         self.ownerElement = None
357         self._name = qName
358         self.namespaceURI = namespaceURI
359         self._prefix = prefix
360         self.childNodes = NodeList()
361
362         # Add the single child node that represents the value of the attr
363         self.childNodes.append(Text())
364
365         # nodeValue and value are set elsewhere
366
367     def _get_localName(self):
368         try:
369             return self._localName
370         except AttributeError:
371             return self.nodeName.split(":", 1)[-1]
372
373     def _get_specified(self):
374         return self.specified
375
376     def _get_name(self):
377         return self._name
378
379     def _set_name(self, value):
380         self._name = value
381         if self.ownerElement is not None:
382             _clear_id_cache(self.ownerElement)
383
384     nodeName = name = property(_get_name, _set_name)
385
386     def _get_value(self):
387         return self._value
388
389     def _set_value(self, value):
390         self._value = value
391         self.childNodes[0].data = value
392         if self.ownerElement is not None:
393             _clear_id_cache(self.ownerElement)
394         self.childNodes[0].data = value
395
396     nodeValue = value = property(_get_value, _set_value)
397
398     def _get_prefix(self):
399         return self._prefix
400
401     def _set_prefix(self, prefix):
402         nsuri = self.namespaceURI
403         if prefix == "xmlns":
404             if nsuri and nsuri != XMLNS_NAMESPACE:
405                 raise xml.dom.NamespaceErr(
406                     "illegal use of 'xmlns' prefix for the wrong namespace")
407         self._prefix = prefix
408         if prefix is None:
409             newName = self.localName
410         else:
411             newName = "%s:%s" % (prefix, self.localName)
412         if self.ownerElement:
413             _clear_id_cache(self.ownerElement)
414         self.name = newName
415
416     prefix = property(_get_prefix, _set_prefix)
417
418     def unlink(self):
419         # This implementation does not call the base implementation
420         # since most of that is not needed, and the expense of the
421         # method call is not warranted.  We duplicate the removal of
422         # children, but that's all we needed from the base class.
423         elem = self.ownerElement
424         if elem is not None:
425             del elem._attrs[self.nodeName]
426             del elem._attrsNS[(self.namespaceURI, self.localName)]
427             if self._is_id:
428                 self._is_id = False
429                 elem._magic_id_nodes -= 1
430                 self.ownerDocument._magic_id_count -= 1
431         for child in self.childNodes:
432             child.unlink()
433         del self.childNodes[:]
434
435     def _get_isId(self):
436         if self._is_id:
437             return True
438         doc = self.ownerDocument
439         elem = self.ownerElement
440         if doc is None or elem is None:
441             return False
442
443         info = doc._get_elem_info(elem)
444         if info is None:
445             return False
446         if self.namespaceURI:
447             return info.isIdNS(self.namespaceURI, self.localName)
448         else:
449             return info.isId(self.nodeName)
450
451     def _get_schemaType(self):
452         doc = self.ownerDocument
453         elem = self.ownerElement
454         if doc is None or elem is None:
455             return _no_type
456
457         info = doc._get_elem_info(elem)
458         if info is None:
459             return _no_type
460         if self.namespaceURI:
461             return info.getAttributeTypeNS(self.namespaceURI, self.localName)
462         else:
463             return info.getAttributeType(self.nodeName)
464
465 defproperty(Attr, "isId",       doc="True if this attribute is an ID.")
466 defproperty(Attr, "localName",  doc="Namespace-local name of this attribute.")
467 defproperty(Attr, "schemaType", doc="Schema type for this attribute.")
468
469
470 class NamedNodeMap(object):
471     """The attribute list is a transient interface to the underlying
472     dictionaries.  Mutations here will change the underlying element's
473     dictionary.
474
475     Ordering is imposed artificially and does not reflect the order of
476     attributes as found in an input document.
477     """
478
479     __slots__ = ('_attrs', '_attrsNS', '_ownerElement')
480
481     def __init__(self, attrs, attrsNS, ownerElement):
482         self._attrs = attrs
483         self._attrsNS = attrsNS
484         self._ownerElement = ownerElement
485
486     def _get_length(self):
487         return len(self._attrs)
488
489     def item(self, index):
490         try:
491             return self[list(self._attrs.keys())[index]]
492         except IndexError:
493             return None
494
495     def items(self):
496         L = []
497         for node in self._attrs.values():
498             L.append((node.nodeName, node.value))
499         return L
500
501     def itemsNS(self):
502         L = []
503         for node in self._attrs.values():
504             L.append(((node.namespaceURI, node.localName), node.value))
505         return L
506
507     def __contains__(self, key):
508         if isinstance(key, str):
509             return key in self._attrs
510         else:
511             return key in self._attrsNS
512
513     def keys(self):
514         return self._attrs.keys()
515
516     def keysNS(self):
517         return self._attrsNS.keys()
518
519     def values(self):
520         return self._attrs.values()
521
522     def get(self, name, value=None):
523         return self._attrs.get(name, value)
524
525     __len__ = _get_length
526
527     def _cmp(self, other):
528         if self._attrs is getattr(other, "_attrs", None):
529             return 0
530         else:
531             return (id(self) > id(other)) - (id(self) < id(other))
532
533     def __eq__(self, other):
534         return self._cmp(other) == 0
535
536     def __ge__(self, other):
537         return self._cmp(other) >= 0
538
539     def __gt__(self, other):
540         return self._cmp(other) > 0
541
542     def __le__(self, other):
543         return self._cmp(other) <= 0
544
545     def __lt__(self, other):
546         return self._cmp(other) < 0
547
548     def __getitem__(self, attname_or_tuple):
549         if isinstance(attname_or_tuple, tuple):
550             return self._attrsNS[attname_or_tuple]
551         else:
552             return self._attrs[attname_or_tuple]
553
554     # same as set
555     def __setitem__(self, attname, value):
556         if isinstance(value, str):
557             try:
558                 node = self._attrs[attname]
559             except KeyError:
560                 node = Attr(attname)
561                 node.ownerDocument = self._ownerElement.ownerDocument
562                 self.setNamedItem(node)
563             node.value = value
564         else:
565             if not isinstance(value, Attr):
566                 raise TypeError("value must be a string or Attr object")
567             node = value
568             self.setNamedItem(node)
569
570     def getNamedItem(self, name):
571         try:
572             return self._attrs[name]
573         except KeyError:
574             return None
575
576     def getNamedItemNS(self, namespaceURI, localName):
577         try:
578             return self._attrsNS[(namespaceURI, localName)]
579         except KeyError:
580             return None
581
582     def removeNamedItem(self, name):
583         n = self.getNamedItem(name)
584         if n is not None:
585             _clear_id_cache(self._ownerElement)
586             del self._attrs[n.nodeName]
587             del self._attrsNS[(n.namespaceURI, n.localName)]
588             if hasattr(n, 'ownerElement'):
589                 n.ownerElement = None
590             return n
591         else:
592             raise xml.dom.NotFoundErr()
593
594     def removeNamedItemNS(self, namespaceURI, localName):
595         n = self.getNamedItemNS(namespaceURI, localName)
596         if n is not None:
597             _clear_id_cache(self._ownerElement)
598             del self._attrsNS[(n.namespaceURI, n.localName)]
599             del self._attrs[n.nodeName]
600             if hasattr(n, 'ownerElement'):
601                 n.ownerElement = None
602             return n
603         else:
604             raise xml.dom.NotFoundErr()
605
606     def setNamedItem(self, node):
607         if not isinstance(node, Attr):
608             raise xml.dom.HierarchyRequestErr(
609                 "%s cannot be child of %s" % (repr(node), repr(self)))
610         old = self._attrs.get(node.name)
611         if old:
612             old.unlink()
613         self._attrs[node.name] = node
614         self._attrsNS[(node.namespaceURI, node.localName)] = node
615         node.ownerElement = self._ownerElement
616         _clear_id_cache(node.ownerElement)
617         return old
618
619     def setNamedItemNS(self, node):
620         return self.setNamedItem(node)
621
622     def __delitem__(self, attname_or_tuple):
623         node = self[attname_or_tuple]
624         _clear_id_cache(node.ownerElement)
625         node.unlink()
626
627     def __getstate__(self):
628         return self._attrs, self._attrsNS, self._ownerElement
629
630     def __setstate__(self, state):
631         self._attrs, self._attrsNS, self._ownerElement = state
632
633 defproperty(NamedNodeMap, "length",
634             doc="Number of nodes in the NamedNodeMap.")
635
636 AttributeList = NamedNodeMap
637
638
639 class TypeInfo(object):
640     __slots__ = 'namespace', 'name'
641
642     def __init__(self, namespace, name):
643         self.namespace = namespace
644         self.name = name
645
646     def __repr__(self):
647         if self.namespace:
648             return "<%s %r (from %r)>" % (self.__class__.__name__, self.name,
649                                           self.namespace)
650         else:
651             return "<%s %r>" % (self.__class__.__name__, self.name)
652
653     def _get_name(self):
654         return self.name
655
656     def _get_namespace(self):
657         return self.namespace
658
659 _no_type = TypeInfo(None, None)
660
661 class Element(Node):
662     __slots__=('ownerDocument', 'parentNode', 'tagName', 'nodeName', 'prefix',
663                'namespaceURI', '_localName', 'childNodes', '_attrs', '_attrsNS',
664                'nextSibling', 'previousSibling')
665     nodeType = Node.ELEMENT_NODE
666     nodeValue = None
667     schemaType = _no_type
668
669     _magic_id_nodes = 0
670
671     _child_node_types = (Node.ELEMENT_NODE,
672                          Node.PROCESSING_INSTRUCTION_NODE,
673                          Node.COMMENT_NODE,
674                          Node.TEXT_NODE,
675                          Node.CDATA_SECTION_NODE,
676                          Node.ENTITY_REFERENCE_NODE)
677
678     def __init__(self, tagName, namespaceURI=EMPTY_NAMESPACE, prefix=None,
679                  localName=None):
680         self.parentNode = None
681         self.tagName = self.nodeName = tagName
682         self.prefix = prefix
683         self.namespaceURI = namespaceURI
684         self.childNodes = NodeList()
685         self.nextSibling = self.previousSibling = None
686
687         # Attribute dictionaries are lazily created
688         # attributes are double-indexed:
689         #    tagName -> Attribute
690         #    URI,localName -> Attribute
691         # in the future: consider lazy generation
692         # of attribute objects this is too tricky
693         # for now because of headaches with
694         # namespaces.
695         self._attrs = None
696         self._attrsNS = None
697
698     def _ensure_attributes(self):
699         if self._attrs is None:
700             self._attrs = {}
701             self._attrsNS = {}
702
703     def _get_localName(self):
704         try:
705             return self._localName
706         except AttributeError:
707             return self.tagName.split(":", 1)[-1]
708
709     def _get_tagName(self):
710         return self.tagName
711
712     def unlink(self):
713         if self._attrs is not None:
714             for attr in list(self._attrs.values()):
715                 attr.unlink()
716         self._attrs = None
717         self._attrsNS = None
718         Node.unlink(self)
719
720     def getAttribute(self, attname):
721         if self._attrs is None:
722             return ""
723         try:
724             return self._attrs[attname].value
725         except KeyError:
726             return ""
727
728     def getAttributeNS(self, namespaceURI, localName):
729         if self._attrsNS is None:
730             return ""
731         try:
732             return self._attrsNS[(namespaceURI, localName)].value
733         except KeyError:
734             return ""
735
736     def setAttribute(self, attname, value):
737         attr = self.getAttributeNode(attname)
738         if attr is None:
739             attr = Attr(attname)
740             attr.value = value # also sets nodeValue
741             attr.ownerDocument = self.ownerDocument
742             self.setAttributeNode(attr)
743         elif value != attr.value:
744             attr.value = value
745             if attr.isId:
746                 _clear_id_cache(self)
747
748     def setAttributeNS(self, namespaceURI, qualifiedName, value):
749         prefix, localname = _nssplit(qualifiedName)
750         attr = self.getAttributeNodeNS(namespaceURI, localname)
751         if attr is None:
752             attr = Attr(qualifiedName, namespaceURI, localname, prefix)
753             attr.value = value
754             attr.ownerDocument = self.ownerDocument
755             self.setAttributeNode(attr)
756         else:
757             if value != attr.value:
758                 attr.value = value
759                 if attr.isId:
760                     _clear_id_cache(self)
761             if attr.prefix != prefix:
762                 attr.prefix = prefix
763                 attr.nodeName = qualifiedName
764
765     def getAttributeNode(self, attrname):
766         if self._attrs is None:
767             return None
768         return self._attrs.get(attrname)
769
770     def getAttributeNodeNS(self, namespaceURI, localName):
771         if self._attrsNS is None:
772             return None
773         return self._attrsNS.get((namespaceURI, localName))
774
775     def setAttributeNode(self, attr):
776         if attr.ownerElement not in (None, self):
777             raise xml.dom.InuseAttributeErr("attribute node already owned")
778         self._ensure_attributes()
779         old1 = self._attrs.get(attr.name, None)
780         if old1 is not None:
781             self.removeAttributeNode(old1)
782         old2 = self._attrsNS.get((attr.namespaceURI, attr.localName), None)
783         if old2 is not None and old2 is not old1:
784             self.removeAttributeNode(old2)
785         _set_attribute_node(self, attr)
786
787         if old1 is not attr:
788             # It might have already been part of this node, in which case
789             # it doesn't represent a change, and should not be returned.
790             return old1
791         if old2 is not attr:
792             return old2
793
794     setAttributeNodeNS = setAttributeNode
795
796     def removeAttribute(self, name):
797         if self._attrsNS is None:
798             raise xml.dom.NotFoundErr()
799         try:
800             attr = self._attrs[name]
801         except KeyError:
802             raise xml.dom.NotFoundErr()
803         self.removeAttributeNode(attr)
804
805     def removeAttributeNS(self, namespaceURI, localName):
806         if self._attrsNS is None:
807             raise xml.dom.NotFoundErr()
808         try:
809             attr = self._attrsNS[(namespaceURI, localName)]
810         except KeyError:
811             raise xml.dom.NotFoundErr()
812         self.removeAttributeNode(attr)
813
814     def removeAttributeNode(self, node):
815         if node is None:
816             raise xml.dom.NotFoundErr()
817         try:
818             self._attrs[node.name]
819         except KeyError:
820             raise xml.dom.NotFoundErr()
821         _clear_id_cache(self)
822         node.unlink()
823         # Restore this since the node is still useful and otherwise
824         # unlinked
825         node.ownerDocument = self.ownerDocument
826
827     removeAttributeNodeNS = removeAttributeNode
828
829     def hasAttribute(self, name):
830         if self._attrs is None:
831             return False
832         return name in self._attrs
833
834     def hasAttributeNS(self, namespaceURI, localName):
835         if self._attrsNS is None:
836             return False
837         return (namespaceURI, localName) in self._attrsNS
838
839     def getElementsByTagName(self, name):
840         return _get_elements_by_tagName_helper(self, name, NodeList())
841
842     def getElementsByTagNameNS(self, namespaceURI, localName):
843         return _get_elements_by_tagName_ns_helper(
844             self, namespaceURI, localName, NodeList())
845
846     def __repr__(self):
847         return "<DOM Element: %s at %#x>" % (self.tagName, id(self))
848
849     def writexml(self, writer, indent="", addindent="", newl=""):
850         # indent = current indentation
851         # addindent = indentation to add to higher levels
852         # newl = newline string
853         writer.write(indent+"<" + self.tagName)
854
855         attrs = self._get_attributes()
856         a_names = sorted(attrs.keys())
857
858         for a_name in a_names:
859             writer.write(" %s=\"" % a_name)
860             _write_data(writer, attrs[a_name].value)
861             writer.write("\"")
862         if self.childNodes:
863             writer.write(">")
864             if (len(self.childNodes) == 1 and
865                 self.childNodes[0].nodeType == Node.TEXT_NODE):
866                 self.childNodes[0].writexml(writer, '', '', '')
867             else:
868                 writer.write(newl)
869                 for node in self.childNodes:
870                     node.writexml(writer, indent+addindent, addindent, newl)
871                 writer.write(indent)
872             writer.write("</%s>%s" % (self.tagName, newl))
873         else:
874             writer.write("/>%s"%(newl))
875
876     def _get_attributes(self):
877         self._ensure_attributes()
878         return NamedNodeMap(self._attrs, self._attrsNS, self)
879
880     def hasAttributes(self):
881         if self._attrs:
882             return True
883         else:
884             return False
885
886     # DOM Level 3 attributes, based on the 22 Oct 2002 draft
887
888     def setIdAttribute(self, name):
889         idAttr = self.getAttributeNode(name)
890         self.setIdAttributeNode(idAttr)
891
892     def setIdAttributeNS(self, namespaceURI, localName):
893         idAttr = self.getAttributeNodeNS(namespaceURI, localName)
894         self.setIdAttributeNode(idAttr)
895
896     def setIdAttributeNode(self, idAttr):
897         if idAttr is None or not self.isSameNode(idAttr.ownerElement):
898             raise xml.dom.NotFoundErr()
899         if _get_containing_entref(self) is not None:
900             raise xml.dom.NoModificationAllowedErr()
901         if not idAttr._is_id:
902             idAttr._is_id = True
903             self._magic_id_nodes += 1
904             self.ownerDocument._magic_id_count += 1
905             _clear_id_cache(self)
906
907 defproperty(Element, "attributes",
908             doc="NamedNodeMap of attributes on the element.")
909 defproperty(Element, "localName",
910             doc="Namespace-local name of this element.")
911
912
913 def _set_attribute_node(element, attr):
914     _clear_id_cache(element)
915     element._ensure_attributes()
916     element._attrs[attr.name] = attr
917     element._attrsNS[(attr.namespaceURI, attr.localName)] = attr
918
919     # This creates a circular reference, but Element.unlink()
920     # breaks the cycle since the references to the attribute
921     # dictionaries are tossed.
922     attr.ownerElement = element
923
924 class Childless:
925     """Mixin that makes childless-ness easy to implement and avoids
926     the complexity of the Node methods that deal with children.
927     """
928     __slots__ = ()
929
930     attributes = None
931     childNodes = EmptyNodeList()
932     firstChild = None
933     lastChild = None
934
935     def _get_firstChild(self):
936         return None
937
938     def _get_lastChild(self):
939         return None
940
941     def appendChild(self, node):
942         raise xml.dom.HierarchyRequestErr(
943             self.nodeName + " nodes cannot have children")
944
945     def hasChildNodes(self):
946         return False
947
948     def insertBefore(self, newChild, refChild):
949         raise xml.dom.HierarchyRequestErr(
950             self.nodeName + " nodes do not have children")
951
952     def removeChild(self, oldChild):
953         raise xml.dom.NotFoundErr(
954             self.nodeName + " nodes do not have children")
955
956     def normalize(self):
957         # For childless nodes, normalize() has nothing to do.
958         pass
959
960     def replaceChild(self, newChild, oldChild):
961         raise xml.dom.HierarchyRequestErr(
962             self.nodeName + " nodes do not have children")
963
964
965 class ProcessingInstruction(Childless, Node):
966     nodeType = Node.PROCESSING_INSTRUCTION_NODE
967     __slots__ = ('target', 'data')
968
969     def __init__(self, target, data):
970         self.target = target
971         self.data = data
972
973     # nodeValue is an alias for data
974     def _get_nodeValue(self):
975         return self.data
976     def _set_nodeValue(self, value):
977         self.data = value
978     nodeValue = property(_get_nodeValue, _set_nodeValue)
979
980     # nodeName is an alias for target
981     def _get_nodeName(self):
982         return self.target
983     def _set_nodeName(self, value):
984         self.target = value
985     nodeName = property(_get_nodeName, _set_nodeName)
986
987     def writexml(self, writer, indent="", addindent="", newl=""):
988         writer.write("%s<?%s %s?>%s" % (indent,self.target, self.data, newl))
989
990
991 class CharacterData(Childless, Node):
992     __slots__=('_data', 'ownerDocument','parentNode', 'previousSibling', 'nextSibling')
993
994     def __init__(self):
995         self.ownerDocument = self.parentNode = None
996         self.previousSibling = self.nextSibling = None
997         self._data = ''
998         Node.__init__(self)
999
1000     def _get_length(self):
1001         return len(self.data)
1002     __len__ = _get_length
1003
1004     def _get_data(self):
1005         return self._data
1006     def _set_data(self, data):
1007         self._data = data
1008
1009     data = nodeValue = property(_get_data, _set_data)
1010
1011     def __repr__(self):
1012         data = self.data
1013         if len(data) > 10:
1014             dotdotdot = "..."
1015         else:
1016             dotdotdot = ""
1017         return '<DOM %s node "%r%s">' % (
1018             self.__class__.__name__, data[0:10], dotdotdot)
1019
1020     def substringData(self, offset, count):
1021         if offset < 0:
1022             raise xml.dom.IndexSizeErr("offset cannot be negative")
1023         if offset >= len(self.data):
1024             raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")
1025         if count < 0:
1026             raise xml.dom.IndexSizeErr("count cannot be negative")
1027         return self.data[offset:offset+count]
1028
1029     def appendData(self, arg):
1030         self.data = self.data + arg
1031
1032     def insertData(self, offset, arg):
1033         if offset < 0:
1034             raise xml.dom.IndexSizeErr("offset cannot be negative")
1035         if offset >= len(self.data):
1036             raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")
1037         if arg:
1038             self.data = "%s%s%s" % (
1039                 self.data[:offset], arg, self.data[offset:])
1040
1041     def deleteData(self, offset, count):
1042         if offset < 0:
1043             raise xml.dom.IndexSizeErr("offset cannot be negative")
1044         if offset >= len(self.data):
1045             raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")
1046         if count < 0:
1047             raise xml.dom.IndexSizeErr("count cannot be negative")
1048         if count:
1049             self.data = self.data[:offset] + self.data[offset+count:]
1050
1051     def replaceData(self, offset, count, arg):
1052         if offset < 0:
1053             raise xml.dom.IndexSizeErr("offset cannot be negative")
1054         if offset >= len(self.data):
1055             raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")
1056         if count < 0:
1057             raise xml.dom.IndexSizeErr("count cannot be negative")
1058         if count:
1059             self.data = "%s%s%s" % (
1060                 self.data[:offset], arg, self.data[offset+count:])
1061
1062 defproperty(CharacterData, "length", doc="Length of the string data.")
1063
1064
1065 class Text(CharacterData):
1066     __slots__ = ()
1067
1068     nodeType = Node.TEXT_NODE
1069     nodeName = "#text"
1070     attributes = None
1071
1072     def splitText(self, offset):
1073         if offset < 0 or offset > len(self.data):
1074             raise xml.dom.IndexSizeErr("illegal offset value")
1075         newText = self.__class__()
1076         newText.data = self.data[offset:]
1077         newText.ownerDocument = self.ownerDocument
1078         next = self.nextSibling
1079         if self.parentNode and self in self.parentNode.childNodes:
1080             if next is None:
1081                 self.parentNode.appendChild(newText)
1082             else:
1083                 self.parentNode.insertBefore(newText, next)
1084         self.data = self.data[:offset]
1085         return newText
1086
1087     def writexml(self, writer, indent="", addindent="", newl=""):
1088         _write_data(writer, "%s%s%s" % (indent, self.data, newl))
1089
1090     # DOM Level 3 (WD 9 April 2002)
1091
1092     def _get_wholeText(self):
1093         L = [self.data]
1094         n = self.previousSibling
1095         while n is not None:
1096             if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):
1097                 L.insert(0, n.data)
1098                 n = n.previousSibling
1099             else:
1100                 break
1101         n = self.nextSibling
1102         while n is not None:
1103             if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):
1104                 L.append(n.data)
1105                 n = n.nextSibling
1106             else:
1107                 break
1108         return ''.join(L)
1109
1110     def replaceWholeText(self, content):
1111         # XXX This needs to be seriously changed if minidom ever
1112         # supports EntityReference nodes.
1113         parent = self.parentNode
1114         n = self.previousSibling
1115         while n is not None:
1116             if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):
1117                 next = n.previousSibling
1118                 parent.removeChild(n)
1119                 n = next
1120             else:
1121                 break
1122         n = self.nextSibling
1123         if not content:
1124             parent.removeChild(self)
1125         while n is not None:
1126             if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):
1127                 next = n.nextSibling
1128                 parent.removeChild(n)
1129                 n = next
1130             else:
1131                 break
1132         if content:
1133             self.data = content
1134             return self
1135         else:
1136             return None
1137
1138     def _get_isWhitespaceInElementContent(self):
1139         if self.data.strip():
1140             return False
1141         elem = _get_containing_element(self)
1142         if elem is None:
1143             return False
1144         info = self.ownerDocument._get_elem_info(elem)
1145         if info is None:
1146             return False
1147         else:
1148             return info.isElementContent()
1149
1150 defproperty(Text, "isWhitespaceInElementContent",
1151             doc="True iff this text node contains only whitespace"
1152                 " and is in element content.")
1153 defproperty(Text, "wholeText",
1154             doc="The text of all logically-adjacent text nodes.")
1155
1156
1157 def _get_containing_element(node):
1158     c = node.parentNode
1159     while c is not None:
1160         if c.nodeType == Node.ELEMENT_NODE:
1161             return c
1162         c = c.parentNode
1163     return None
1164
1165 def _get_containing_entref(node):
1166     c = node.parentNode
1167     while c is not None:
1168         if c.nodeType == Node.ENTITY_REFERENCE_NODE:
1169             return c
1170         c = c.parentNode
1171     return None
1172
1173
1174 class Comment(CharacterData):
1175     nodeType = Node.COMMENT_NODE
1176     nodeName = "#comment"
1177
1178     def __init__(self, data):
1179         CharacterData.__init__(self)
1180         self._data = data
1181
1182     def writexml(self, writer, indent="", addindent="", newl=""):
1183         if "--" in self.data:
1184             raise ValueError("'--' is not allowed in a comment node")
1185         writer.write("%s<!--%s-->%s" % (indent, self.data, newl))
1186
1187
1188 class CDATASection(Text):
1189     __slots__ = ()
1190
1191     nodeType = Node.CDATA_SECTION_NODE
1192     nodeName = "#cdata-section"
1193
1194     def writexml(self, writer, indent="", addindent="", newl=""):
1195         if self.data.find("]]>") >= 0:
1196             raise ValueError("']]>' not allowed in a CDATA section")
1197         writer.write("<![CDATA[%s]]>" % self.data)
1198
1199
1200 class ReadOnlySequentialNamedNodeMap(object):
1201     __slots__ = '_seq',
1202
1203     def __init__(self, seq=()):
1204         # seq should be a list or tuple
1205         self._seq = seq
1206
1207     def __len__(self):
1208         return len(self._seq)
1209
1210     def _get_length(self):
1211         return len(self._seq)
1212
1213     def getNamedItem(self, name):
1214         for n in self._seq:
1215             if n.nodeName == name:
1216                 return n
1217
1218     def getNamedItemNS(self, namespaceURI, localName):
1219         for n in self._seq:
1220             if n.namespaceURI == namespaceURI and n.localName == localName:
1221                 return n
1222
1223     def __getitem__(self, name_or_tuple):
1224         if isinstance(name_or_tuple, tuple):
1225             node = self.getNamedItemNS(*name_or_tuple)
1226         else:
1227             node = self.getNamedItem(name_or_tuple)
1228         if node is None:
1229             raise KeyError(name_or_tuple)
1230         return node
1231
1232     def item(self, index):
1233         if index < 0:
1234             return None
1235         try:
1236             return self._seq[index]
1237         except IndexError:
1238             return None
1239
1240     def removeNamedItem(self, name):
1241         raise xml.dom.NoModificationAllowedErr(
1242             "NamedNodeMap instance is read-only")
1243
1244     def removeNamedItemNS(self, namespaceURI, localName):
1245         raise xml.dom.NoModificationAllowedErr(
1246             "NamedNodeMap instance is read-only")
1247
1248     def setNamedItem(self, node):
1249         raise xml.dom.NoModificationAllowedErr(
1250             "NamedNodeMap instance is read-only")
1251
1252     def setNamedItemNS(self, node):
1253         raise xml.dom.NoModificationAllowedErr(
1254             "NamedNodeMap instance is read-only")
1255
1256     def __getstate__(self):
1257         return [self._seq]
1258
1259     def __setstate__(self, state):
1260         self._seq = state[0]
1261
1262 defproperty(ReadOnlySequentialNamedNodeMap, "length",
1263             doc="Number of entries in the NamedNodeMap.")
1264
1265
1266 class Identified:
1267     """Mix-in class that supports the publicId and systemId attributes."""
1268
1269     __slots__ = 'publicId', 'systemId'
1270
1271     def _identified_mixin_init(self, publicId, systemId):
1272         self.publicId = publicId
1273         self.systemId = systemId
1274
1275     def _get_publicId(self):
1276         return self.publicId
1277
1278     def _get_systemId(self):
1279         return self.systemId
1280
1281 class DocumentType(Identified, Childless, Node):
1282     nodeType = Node.DOCUMENT_TYPE_NODE
1283     nodeValue = None
1284     name = None
1285     publicId = None
1286     systemId = None
1287     internalSubset = None
1288
1289     def __init__(self, qualifiedName):
1290         self.entities = ReadOnlySequentialNamedNodeMap()
1291         self.notations = ReadOnlySequentialNamedNodeMap()
1292         if qualifiedName:
1293             prefix, localname = _nssplit(qualifiedName)
1294             self.name = localname
1295         self.nodeName = self.name
1296
1297     def _get_internalSubset(self):
1298         return self.internalSubset
1299
1300     def cloneNode(self, deep):
1301         if self.ownerDocument is None:
1302             # it's ok
1303             clone = DocumentType(None)
1304             clone.name = self.name
1305             clone.nodeName = self.name
1306             operation = xml.dom.UserDataHandler.NODE_CLONED
1307             if deep:
1308                 clone.entities._seq = []
1309                 clone.notations._seq = []
1310                 for n in self.notations._seq:
1311                     notation = Notation(n.nodeName, n.publicId, n.systemId)
1312                     clone.notations._seq.append(notation)
1313                     n._call_user_data_handler(operation, n, notation)
1314                 for e in self.entities._seq:
1315                     entity = Entity(e.nodeName, e.publicId, e.systemId,
1316                                     e.notationName)
1317                     entity.actualEncoding = e.actualEncoding
1318                     entity.encoding = e.encoding
1319                     entity.version = e.version
1320                     clone.entities._seq.append(entity)
1321                     e._call_user_data_handler(operation, n, entity)
1322             self._call_user_data_handler(operation, self, clone)
1323             return clone
1324         else:
1325             return None
1326
1327     def writexml(self, writer, indent="", addindent="", newl=""):
1328         writer.write("<!DOCTYPE ")
1329         writer.write(self.name)
1330         if self.publicId:
1331             writer.write("%s  PUBLIC '%s'%s  '%s'"
1332                          % (newl, self.publicId, newl, self.systemId))
1333         elif self.systemId:
1334             writer.write("%s  SYSTEM '%s'" % (newl, self.systemId))
1335         if self.internalSubset is not None:
1336             writer.write(" [")
1337             writer.write(self.internalSubset)
1338             writer.write("]")
1339         writer.write(">"+newl)
1340
1341 class Entity(Identified, Node):
1342     attributes = None
1343     nodeType = Node.ENTITY_NODE
1344     nodeValue = None
1345
1346     actualEncoding = None
1347     encoding = None
1348     version = None
1349
1350     def __init__(self, name, publicId, systemId, notation):
1351         self.nodeName = name
1352         self.notationName = notation
1353         self.childNodes = NodeList()
1354         self._identified_mixin_init(publicId, systemId)
1355
1356     def _get_actualEncoding(self):
1357         return self.actualEncoding
1358
1359     def _get_encoding(self):
1360         return self.encoding
1361
1362     def _get_version(self):
1363         return self.version
1364
1365     def appendChild(self, newChild):
1366         raise xml.dom.HierarchyRequestErr(
1367             "cannot append children to an entity node")
1368
1369     def insertBefore(self, newChild, refChild):
1370         raise xml.dom.HierarchyRequestErr(
1371             "cannot insert children below an entity node")
1372
1373     def removeChild(self, oldChild):
1374         raise xml.dom.HierarchyRequestErr(
1375             "cannot remove children from an entity node")
1376
1377     def replaceChild(self, newChild, oldChild):
1378         raise xml.dom.HierarchyRequestErr(
1379             "cannot replace children of an entity node")
1380
1381 class Notation(Identified, Childless, Node):
1382     nodeType = Node.NOTATION_NODE
1383     nodeValue = None
1384
1385     def __init__(self, name, publicId, systemId):
1386         self.nodeName = name
1387         self._identified_mixin_init(publicId, systemId)
1388
1389
1390 class DOMImplementation(DOMImplementationLS):
1391     _features = [("core", "1.0"),
1392                  ("core", "2.0"),
1393                  ("core", None),
1394                  ("xml", "1.0"),
1395                  ("xml", "2.0"),
1396                  ("xml", None),
1397                  ("ls-load", "3.0"),
1398                  ("ls-load", None),
1399                  ]
1400
1401     def hasFeature(self, feature, version):
1402         if version == "":
1403             version = None
1404         return (feature.lower(), version) in self._features
1405
1406     def createDocument(self, namespaceURI, qualifiedName, doctype):
1407         if doctype and doctype.parentNode is not None:
1408             raise xml.dom.WrongDocumentErr(
1409                 "doctype object owned by another DOM tree")
1410         doc = self._create_document()
1411
1412         add_root_element = not (namespaceURI is None
1413                                 and qualifiedName is None
1414                                 and doctype is None)
1415
1416         if not qualifiedName and add_root_element:
1417             # The spec is unclear what to raise here; SyntaxErr
1418             # would be the other obvious candidate. Since Xerces raises
1419             # InvalidCharacterErr, and since SyntaxErr is not listed
1420             # for createDocument, that seems to be the better choice.
1421             # XXX: need to check for illegal characters here and in
1422             # createElement.
1423
1424             # DOM Level III clears this up when talking about the return value
1425             # of this function.  If namespaceURI, qName and DocType are
1426             # Null the document is returned without a document element
1427             # Otherwise if doctype or namespaceURI are not None
1428             # Then we go back to the above problem
1429             raise xml.dom.InvalidCharacterErr("Element with no name")
1430
1431         if add_root_element:
1432             prefix, localname = _nssplit(qualifiedName)
1433             if prefix == "xml" \
1434                and namespaceURI != "http://www.w3.org/XML/1998/namespace":
1435                 raise xml.dom.NamespaceErr("illegal use of 'xml' prefix")
1436             if prefix and not namespaceURI:
1437                 raise xml.dom.NamespaceErr(
1438                     "illegal use of prefix without namespaces")
1439             element = doc.createElementNS(namespaceURI, qualifiedName)
1440             if doctype:
1441                 doc.appendChild(doctype)
1442             doc.appendChild(element)
1443
1444         if doctype:
1445             doctype.parentNode = doctype.ownerDocument = doc
1446
1447         doc.doctype = doctype
1448         doc.implementation = self
1449         return doc
1450
1451     def createDocumentType(self, qualifiedName, publicId, systemId):
1452         doctype = DocumentType(qualifiedName)
1453         doctype.publicId = publicId
1454         doctype.systemId = systemId
1455         return doctype
1456
1457     # DOM Level 3 (WD 9 April 2002)
1458
1459     def getInterface(self, feature):
1460         if self.hasFeature(feature, None):
1461             return self
1462         else:
1463             return None
1464
1465     # internal
1466     def _create_document(self):
1467         return Document()
1468
1469 class ElementInfo(object):
1470     """Object that represents content-model information for an element.
1471
1472     This implementation is not expected to be used in practice; DOM
1473     builders should provide implementations which do the right thing
1474     using information available to it.
1475
1476     """
1477
1478     __slots__ = 'tagName',
1479
1480     def __init__(self, name):
1481         self.tagName = name
1482
1483     def getAttributeType(self, aname):
1484         return _no_type
1485
1486     def getAttributeTypeNS(self, namespaceURI, localName):
1487         return _no_type
1488
1489     def isElementContent(self):
1490         return False
1491
1492     def isEmpty(self):
1493         """Returns true iff this element is declared to have an EMPTY
1494         content model."""
1495         return False
1496
1497     def isId(self, aname):
1498         """Returns true iff the named attribute is a DTD-style ID."""
1499         return False
1500
1501     def isIdNS(self, namespaceURI, localName):
1502         """Returns true iff the identified attribute is a DTD-style ID."""
1503         return False
1504
1505     def __getstate__(self):
1506         return self.tagName
1507
1508     def __setstate__(self, state):
1509         self.tagName = state
1510
1511 def _clear_id_cache(node):
1512     if node.nodeType == Node.DOCUMENT_NODE:
1513         node._id_cache.clear()
1514         node._id_search_stack = None
1515     elif _in_document(node):
1516         node.ownerDocument._id_cache.clear()
1517         node.ownerDocument._id_search_stack= None
1518
1519 class Document(Node, DocumentLS):
1520     __slots__ = ('_elem_info', 'doctype',
1521                  '_id_search_stack', 'childNodes', '_id_cache')
1522     _child_node_types = (Node.ELEMENT_NODE, Node.PROCESSING_INSTRUCTION_NODE,
1523                          Node.COMMENT_NODE, Node.DOCUMENT_TYPE_NODE)
1524
1525     implementation = DOMImplementation()
1526     nodeType = Node.DOCUMENT_NODE
1527     nodeName = "#document"
1528     nodeValue = None
1529     attributes = None
1530     parentNode = None
1531     previousSibling = nextSibling = None
1532
1533
1534     # Document attributes from Level 3 (WD 9 April 2002)
1535
1536     actualEncoding = None
1537     encoding = None
1538     standalone = None
1539     version = None
1540     strictErrorChecking = False
1541     errorHandler = None
1542     documentURI = None
1543
1544     _magic_id_count = 0
1545
1546     def __init__(self):
1547         self.doctype = None
1548         self.childNodes = NodeList()
1549         # mapping of (namespaceURI, localName) -> ElementInfo
1550         #        and tagName -> ElementInfo
1551         self._elem_info = {}
1552         self._id_cache = {}
1553         self._id_search_stack = None
1554
1555     def _get_elem_info(self, element):
1556         if element.namespaceURI:
1557             key = element.namespaceURI, element.localName
1558         else:
1559             key = element.tagName
1560         return self._elem_info.get(key)
1561
1562     def _get_actualEncoding(self):
1563         return self.actualEncoding
1564
1565     def _get_doctype(self):
1566         return self.doctype
1567
1568     def _get_documentURI(self):
1569         return self.documentURI
1570
1571     def _get_encoding(self):
1572         return self.encoding
1573
1574     def _get_errorHandler(self):
1575         return self.errorHandler
1576
1577     def _get_standalone(self):
1578         return self.standalone
1579
1580     def _get_strictErrorChecking(self):
1581         return self.strictErrorChecking
1582
1583     def _get_version(self):
1584         return self.version
1585
1586     def appendChild(self, node):
1587         if node.nodeType not in self._child_node_types:
1588             raise xml.dom.HierarchyRequestErr(
1589                 "%s cannot be child of %s" % (repr(node), repr(self)))
1590         if node.parentNode is not None:
1591             # This needs to be done before the next test since this
1592             # may *be* the document element, in which case it should
1593             # end up re-ordered to the end.
1594             node.parentNode.removeChild(node)
1595
1596         if node.nodeType == Node.ELEMENT_NODE \
1597            and self._get_documentElement():
1598             raise xml.dom.HierarchyRequestErr(
1599                 "two document elements disallowed")
1600         return Node.appendChild(self, node)
1601
1602     def removeChild(self, oldChild):
1603         try:
1604             self.childNodes.remove(oldChild)
1605         except ValueError:
1606             raise xml.dom.NotFoundErr()
1607         oldChild.nextSibling = oldChild.previousSibling = None
1608         oldChild.parentNode = None
1609         if self.documentElement is oldChild:
1610             self.documentElement = None
1611
1612         return oldChild
1613
1614     def _get_documentElement(self):
1615         for node in self.childNodes:
1616             if node.nodeType == Node.ELEMENT_NODE:
1617                 return node
1618
1619     def unlink(self):
1620         if self.doctype is not None:
1621             self.doctype.unlink()
1622             self.doctype = None
1623         Node.unlink(self)
1624
1625     def cloneNode(self, deep):
1626         if not deep:
1627             return None
1628         clone = self.implementation.createDocument(None, None, None)
1629         clone.encoding = self.encoding
1630         clone.standalone = self.standalone
1631         clone.version = self.version
1632         for n in self.childNodes:
1633             childclone = _clone_node(n, deep, clone)
1634             assert childclone.ownerDocument.isSameNode(clone)
1635             clone.childNodes.append(childclone)
1636             if childclone.nodeType == Node.DOCUMENT_NODE:
1637                 assert clone.documentElement is None
1638             elif childclone.nodeType == Node.DOCUMENT_TYPE_NODE:
1639                 assert clone.doctype is None
1640                 clone.doctype = childclone
1641             childclone.parentNode = clone
1642         self._call_user_data_handler(xml.dom.UserDataHandler.NODE_CLONED,
1643                                      self, clone)
1644         return clone
1645
1646     def createDocumentFragment(self):
1647         d = DocumentFragment()
1648         d.ownerDocument = self
1649         return d
1650
1651     def createElement(self, tagName):
1652         e = Element(tagName)
1653         e.ownerDocument = self
1654         return e
1655
1656     def createTextNode(self, data):
1657         if not isinstance(data, str):
1658             raise TypeError("node contents must be a string")
1659         t = Text()
1660         t.data = data
1661         t.ownerDocument = self
1662         return t
1663
1664     def createCDATASection(self, data):
1665         if not isinstance(data, str):
1666             raise TypeError("node contents must be a string")
1667         c = CDATASection()
1668         c.data = data
1669         c.ownerDocument = self
1670         return c
1671
1672     def createComment(self, data):
1673         c = Comment(data)
1674         c.ownerDocument = self
1675         return c
1676
1677     def createProcessingInstruction(self, target, data):
1678         p = ProcessingInstruction(target, data)
1679         p.ownerDocument = self
1680         return p
1681
1682     def createAttribute(self, qName):
1683         a = Attr(qName)
1684         a.ownerDocument = self
1685         a.value = ""
1686         return a
1687
1688     def createElementNS(self, namespaceURI, qualifiedName):
1689         prefix, localName = _nssplit(qualifiedName)
1690         e = Element(qualifiedName, namespaceURI, prefix)
1691         e.ownerDocument = self
1692         return e
1693
1694     def createAttributeNS(self, namespaceURI, qualifiedName):
1695         prefix, localName = _nssplit(qualifiedName)
1696         a = Attr(qualifiedName, namespaceURI, localName, prefix)
1697         a.ownerDocument = self
1698         a.value = ""
1699         return a
1700
1701     # A couple of implementation-specific helpers to create node types
1702     # not supported by the W3C DOM specs:
1703
1704     def _create_entity(self, name, publicId, systemId, notationName):
1705         e = Entity(name, publicId, systemId, notationName)
1706         e.ownerDocument = self
1707         return e
1708
1709     def _create_notation(self, name, publicId, systemId):
1710         n = Notation(name, publicId, systemId)
1711         n.ownerDocument = self
1712         return n
1713
1714     def getElementById(self, id):
1715         if id in self._id_cache:
1716             return self._id_cache[id]
1717         if not (self._elem_info or self._magic_id_count):
1718             return None
1719
1720         stack = self._id_search_stack
1721         if stack is None:
1722             # we never searched before, or the cache has been cleared
1723             stack = [self.documentElement]
1724             self._id_search_stack = stack
1725         elif not stack:
1726             # Previous search was completed and cache is still valid;
1727             # no matching node.
1728             return None
1729
1730         result = None
1731         while stack:
1732             node = stack.pop()
1733             # add child elements to stack for continued searching
1734             stack.extend([child for child in node.childNodes
1735                           if child.nodeType in _nodeTypes_with_children])
1736             # check this node
1737             info = self._get_elem_info(node)
1738             if info:
1739                 # We have to process all ID attributes before
1740                 # returning in order to get all the attributes set to
1741                 # be IDs using Element.setIdAttribute*().
1742                 for attr in node.attributes.values():
1743                     if attr.namespaceURI:
1744                         if info.isIdNS(attr.namespaceURI, attr.localName):
1745                             self._id_cache[attr.value] = node
1746                             if attr.value == id:
1747                                 result = node
1748                             elif not node._magic_id_nodes:
1749                                 break
1750                     elif info.isId(attr.name):
1751                         self._id_cache[attr.value] = node
1752                         if attr.value == id:
1753                             result = node
1754                         elif not node._magic_id_nodes:
1755                             break
1756                     elif attr._is_id:
1757                         self._id_cache[attr.value] = node
1758                         if attr.value == id:
1759                             result = node
1760                         elif node._magic_id_nodes == 1:
1761                             break
1762             elif node._magic_id_nodes:
1763                 for attr in node.attributes.values():
1764                     if attr._is_id:
1765                         self._id_cache[attr.value] = node
1766                         if attr.value == id:
1767                             result = node
1768             if result is not None:
1769                 break
1770         return result
1771
1772     def getElementsByTagName(self, name):
1773         return _get_elements_by_tagName_helper(self, name, NodeList())
1774
1775     def getElementsByTagNameNS(self, namespaceURI, localName):
1776         return _get_elements_by_tagName_ns_helper(
1777             self, namespaceURI, localName, NodeList())
1778
1779     def isSupported(self, feature, version):
1780         return self.implementation.hasFeature(feature, version)
1781
1782     def importNode(self, node, deep):
1783         if node.nodeType == Node.DOCUMENT_NODE:
1784             raise xml.dom.NotSupportedErr("cannot import document nodes")
1785         elif node.nodeType == Node.DOCUMENT_TYPE_NODE:
1786             raise xml.dom.NotSupportedErr("cannot import document type nodes")
1787         return _clone_node(node, deep, self)
1788
1789     def writexml(self, writer, indent="", addindent="", newl="", encoding=None):
1790         if encoding is None:
1791             writer.write('<?xml version="1.0" ?>'+newl)
1792         else:
1793             writer.write('<?xml version="1.0" encoding="%s"?>%s' % (
1794                 encoding, newl))
1795         for node in self.childNodes:
1796             node.writexml(writer, indent, addindent, newl)
1797
1798     # DOM Level 3 (WD 9 April 2002)
1799
1800     def renameNode(self, n, namespaceURI, name):
1801         if n.ownerDocument is not self:
1802             raise xml.dom.WrongDocumentErr(
1803                 "cannot rename nodes from other documents;\n"
1804                 "expected %s,\nfound %s" % (self, n.ownerDocument))
1805         if n.nodeType not in (Node.ELEMENT_NODE, Node.ATTRIBUTE_NODE):
1806             raise xml.dom.NotSupportedErr(
1807                 "renameNode() only applies to element and attribute nodes")
1808         if namespaceURI != EMPTY_NAMESPACE:
1809             if ':' in name:
1810                 prefix, localName = name.split(':', 1)
1811                 if (  prefix == "xmlns"
1812                       and namespaceURI != xml.dom.XMLNS_NAMESPACE):
1813                     raise xml.dom.NamespaceErr(
1814                         "illegal use of 'xmlns' prefix")
1815             else:
1816                 if (  name == "xmlns"
1817                       and namespaceURI != xml.dom.XMLNS_NAMESPACE
1818                       and n.nodeType == Node.ATTRIBUTE_NODE):
1819                     raise xml.dom.NamespaceErr(
1820                         "illegal use of the 'xmlns' attribute")
1821                 prefix = None
1822                 localName = name
1823         else:
1824             prefix = None
1825             localName = None
1826         if n.nodeType == Node.ATTRIBUTE_NODE:
1827             element = n.ownerElement
1828             if element is not None:
1829                 is_id = n._is_id
1830                 element.removeAttributeNode(n)
1831         else:
1832             element = None
1833         n.prefix = prefix
1834         n._localName = localName
1835         n.namespaceURI = namespaceURI
1836         n.nodeName = name
1837         if n.nodeType == Node.ELEMENT_NODE:
1838             n.tagName = name
1839         else:
1840             # attribute node
1841             n.name = name
1842             if element is not None:
1843                 element.setAttributeNode(n)
1844                 if is_id:
1845                     element.setIdAttributeNode(n)
1846         # It's not clear from a semantic perspective whether we should
1847         # call the user data handlers for the NODE_RENAMED event since
1848         # we're re-using the existing node.  The draft spec has been
1849         # interpreted as meaning "no, don't call the handler unless a
1850         # new node is created."
1851         return n
1852
1853 defproperty(Document, "documentElement",
1854             doc="Top-level element of this document.")
1855
1856
1857 def _clone_node(node, deep, newOwnerDocument):
1858     """
1859     Clone a node and give it the new owner document.
1860     Called by Node.cloneNode and Document.importNode
1861     """
1862     if node.ownerDocument.isSameNode(newOwnerDocument):
1863         operation = xml.dom.UserDataHandler.NODE_CLONED
1864     else:
1865         operation = xml.dom.UserDataHandler.NODE_IMPORTED
1866     if node.nodeType == Node.ELEMENT_NODE:
1867         clone = newOwnerDocument.createElementNS(node.namespaceURI,
1868                                                  node.nodeName)
1869         for attr in node.attributes.values():
1870             clone.setAttributeNS(attr.namespaceURI, attr.nodeName, attr.value)
1871             a = clone.getAttributeNodeNS(attr.namespaceURI, attr.localName)
1872             a.specified = attr.specified
1873
1874         if deep:
1875             for child in node.childNodes:
1876                 c = _clone_node(child, deep, newOwnerDocument)
1877                 clone.appendChild(c)
1878
1879     elif node.nodeType == Node.DOCUMENT_FRAGMENT_NODE:
1880         clone = newOwnerDocument.createDocumentFragment()
1881         if deep:
1882             for child in node.childNodes:
1883                 c = _clone_node(child, deep, newOwnerDocument)
1884                 clone.appendChild(c)
1885
1886     elif node.nodeType == Node.TEXT_NODE:
1887         clone = newOwnerDocument.createTextNode(node.data)
1888     elif node.nodeType == Node.CDATA_SECTION_NODE:
1889         clone = newOwnerDocument.createCDATASection(node.data)
1890     elif node.nodeType == Node.PROCESSING_INSTRUCTION_NODE:
1891         clone = newOwnerDocument.createProcessingInstruction(node.target,
1892                                                              node.data)
1893     elif node.nodeType == Node.COMMENT_NODE:
1894         clone = newOwnerDocument.createComment(node.data)
1895     elif node.nodeType == Node.ATTRIBUTE_NODE:
1896         clone = newOwnerDocument.createAttributeNS(node.namespaceURI,
1897                                                    node.nodeName)
1898         clone.specified = True
1899         clone.value = node.value
1900     elif node.nodeType == Node.DOCUMENT_TYPE_NODE:
1901         assert node.ownerDocument is not newOwnerDocument
1902         operation = xml.dom.UserDataHandler.NODE_IMPORTED
1903         clone = newOwnerDocument.implementation.createDocumentType(
1904             node.name, node.publicId, node.systemId)
1905         clone.ownerDocument = newOwnerDocument
1906         if deep:
1907             clone.entities._seq = []
1908             clone.notations._seq = []
1909             for n in node.notations._seq:
1910                 notation = Notation(n.nodeName, n.publicId, n.systemId)
1911                 notation.ownerDocument = newOwnerDocument
1912                 clone.notations._seq.append(notation)
1913                 if hasattr(n, '_call_user_data_handler'):
1914                     n._call_user_data_handler(operation, n, notation)
1915             for e in node.entities._seq:
1916                 entity = Entity(e.nodeName, e.publicId, e.systemId,
1917                                 e.notationName)
1918                 entity.actualEncoding = e.actualEncoding
1919                 entity.encoding = e.encoding
1920                 entity.version = e.version
1921                 entity.ownerDocument = newOwnerDocument
1922                 clone.entities._seq.append(entity)
1923                 if hasattr(e, '_call_user_data_handler'):
1924                     e._call_user_data_handler(operation, n, entity)
1925     else:
1926         # Note the cloning of Document and DocumentType nodes is
1927         # implementation specific.  minidom handles those cases
1928         # directly in the cloneNode() methods.
1929         raise xml.dom.NotSupportedErr("Cannot clone node %s" % repr(node))
1930
1931     # Check for _call_user_data_handler() since this could conceivably
1932     # used with other DOM implementations (one of the FourThought
1933     # DOMs, perhaps?).
1934     if hasattr(node, '_call_user_data_handler'):
1935         node._call_user_data_handler(operation, node, clone)
1936     return clone
1937
1938
1939 def _nssplit(qualifiedName):
1940     fields = qualifiedName.split(':', 1)
1941     if len(fields) == 2:
1942         return fields
1943     else:
1944         return (None, fields[0])
1945
1946
1947 def _do_pulldom_parse(func, args, kwargs):
1948     events = func(*args, **kwargs)
1949     toktype, rootNode = events.getEvent()
1950     events.expandNode(rootNode)
1951     events.clear()
1952     return rootNode
1953
1954 def parse(file, parser=None, bufsize=None):
1955     """Parse a file into a DOM by filename or file object."""
1956     if parser is None and not bufsize:
1957         from xml.dom import expatbuilder
1958         return expatbuilder.parse(file)
1959     else:
1960         from xml.dom import pulldom
1961         return _do_pulldom_parse(pulldom.parse, (file,),
1962             {'parser': parser, 'bufsize': bufsize})
1963
1964 def parseString(string, parser=None):
1965     """Parse a file into a DOM from a string."""
1966     if parser is None:
1967         from xml.dom import expatbuilder
1968         return expatbuilder.parseString(string)
1969     else:
1970         from xml.dom import pulldom
1971         return _do_pulldom_parse(pulldom.parseString, (string,),
1972                                  {'parser': parser})
1973
1974 def getDOMImplementation(features=None):
1975     if features:
1976         if isinstance(features, str):
1977             features = domreg._parse_feature_string(features)
1978         for f, v in features:
1979             if not Document.implementation.hasFeature(f, v):
1980                 return None
1981     return Document.implementation