Reviewed by Maciej.
[WebKit-https.git] / WebCore / dom / Node.cpp
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  *           (C) 2001 Dirk Mueller (mueller@kde.org)
5  * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
6  * Copyright (C) 2007 Trolltech ASA
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public License
19  * along with this library; see the file COPYING.LIB.  If not, write to
20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21  * Boston, MA 02110-1301, USA.
22  */
23
24 #include "config.h"
25 #include "Node.h"
26
27 #include "CString.h"
28 #include "ChildNodeList.h"
29 #include "DOMImplementation.h"
30 #include "Document.h"
31 #include "Element.h"
32 #include "ExceptionCode.h"
33 #include "Frame.h"
34 #include "HTMLNames.h"
35 #include "KURL.h"
36 #include "Logging.h"
37 #include "NamedAttrMap.h"
38 #include "RenderObject.h"
39 #include "Text.h"
40 #include "TextStream.h"
41 #include "XMLNames.h"
42 #include "htmlediting.h"
43 #include "kjs_binding.h"
44
45 namespace WebCore {
46
47 using namespace HTMLNames;
48
49 typedef HashSet<NodeList*> NodeListSet;
50 struct NodeListsNodeData {
51     NodeListSet m_listsToNotify;
52     NodeList::Caches m_childNodeListCaches;
53 };
54
55 // NodeList that limits to a particular tag.
56 class TagNodeList : public NodeList {
57 public:
58     TagNodeList(PassRefPtr<Node> rootNode, const AtomicString& namespaceURI, const AtomicString& localName);
59
60     virtual unsigned length() const;
61     virtual Node* item(unsigned index) const;
62
63 private:
64     virtual bool nodeMatches(Node*) const;
65
66     AtomicString m_namespaceURI;
67     AtomicString m_localName;
68 };
69
70 inline TagNodeList::TagNodeList(PassRefPtr<Node> rootNode, const AtomicString& namespaceURI, const AtomicString& localName)
71     : NodeList(rootNode), m_namespaceURI(namespaceURI), m_localName(localName)
72 {
73     ASSERT(m_namespaceURI.isNull() || !m_namespaceURI.isEmpty());
74 }
75
76 unsigned TagNodeList::length() const
77 {
78     return recursiveLength();
79 }
80
81 Node* TagNodeList::item(unsigned index) const
82 {
83     return recursiveItem(index);
84 }
85
86 bool TagNodeList::nodeMatches(Node* testNode) const
87 {
88     if (!testNode->isElementNode())
89         return false;
90
91     if (m_namespaceURI != starAtom && m_namespaceURI != testNode->namespaceURI())
92         return false;
93
94     return m_localName == starAtom || m_localName == testNode->localName();
95 }
96
97
98 bool Node::isSupported(const String& feature, const String& version)
99 {
100     return DOMImplementation::instance()->hasFeature(feature, version);
101 }
102
103 #ifndef NDEBUG
104 WTFLogChannel LogWebCoreNodeLeaks =  { 0x00000000, "", WTFLogChannelOn };
105
106 struct NodeCounter {
107     static unsigned count; 
108
109     ~NodeCounter() 
110     { 
111         if (count) 
112             LOG(WebCoreNodeLeaks, "LEAK: %u Node\n", count); 
113     }
114 };
115 unsigned NodeCounter::count = 0;
116 static NodeCounter nodeCounter;
117
118 static bool shouldIgnoreLeaks = false;
119 static HashSet<Node*> ignoreSet;
120 #endif
121
122 void Node::startIgnoringLeaks()
123 {
124 #ifndef NDEBUG
125     shouldIgnoreLeaks = true;
126 #endif
127 }
128
129 void Node::stopIgnoringLeaks()
130 {
131 #ifndef NDEBUG
132     shouldIgnoreLeaks = false;
133 #endif
134 }
135
136 Node::Node(Document *doc)
137     : m_document(doc),
138       m_previous(0),
139       m_next(0),
140       m_renderer(0),
141       m_nodeLists(0),
142       m_tabIndex(0),
143       m_hasId(false),
144       m_hasClass(false),
145       m_attached(false),
146       m_styleChange(NoStyleChange),
147       m_hasChangedChild(false),
148       m_inDocument(false),
149       m_isLink(false),
150       m_attrWasSpecifiedOrElementHasRareData(false),
151       m_focused(false),
152       m_active(false),
153       m_hovered(false),
154       m_inActiveChain(false),
155       m_inDetach(false),
156       m_dispatchingSimulatedEvent(false),
157       m_inSubtreeMark(false)
158 {
159 #ifndef NDEBUG
160     if (shouldIgnoreLeaks)
161         ignoreSet.add(this);
162     else
163         ++NodeCounter::count;
164 #endif
165 }
166
167 void Node::setDocument(Document* doc)
168 {
169     if (inDocument() || m_document == doc)
170         return;
171
172     willMoveToNewOwnerDocument();
173
174     {
175         KJS::JSLock lock;
176         KJS::ScriptInterpreter::updateDOMNodeDocument(this, m_document.get(), doc);
177     }    
178     m_document = doc;
179
180     didMoveToNewOwnerDocument();
181 }
182
183 Node::~Node()
184 {
185 #ifndef NDEBUG
186     HashSet<Node*>::iterator it = ignoreSet.find(this);
187     if (it != ignoreSet.end())
188         ignoreSet.remove(it);
189     else
190         --NodeCounter::count;
191 #endif
192     if (renderer())
193         detach();
194     delete m_nodeLists;
195     if (m_previous)
196         m_previous->setNextSibling(0);
197     if (m_next)
198         m_next->setPreviousSibling(0);
199 }
200
201 String Node::nodeValue() const
202 {
203   return String();
204 }
205
206 void Node::setNodeValue(const String& /*nodeValue*/, ExceptionCode& ec)
207 {
208     // NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly
209     if (isReadOnlyNode()) {
210         ec = NO_MODIFICATION_ALLOWED_ERR;
211         return;
212     }
213
214     // by default nodeValue is null, so setting it has no effect
215 }
216
217 PassRefPtr<NodeList> Node::childNodes()
218 {
219     if (!m_nodeLists)
220         m_nodeLists = new NodeListsNodeData;
221
222     return new ChildNodeList(this, &m_nodeLists->m_childNodeListCaches);
223 }
224
225 Node* Node::virtualFirstChild() const
226 {
227     return 0;
228 }
229
230 Node* Node::virtualLastChild() const
231 {
232     return 0;
233 }
234
235 Node *Node::lastDescendant() const
236 {
237     Node *n = const_cast<Node *>(this);
238     while (n && n->lastChild())
239         n = n->lastChild();
240     return n;
241 }
242
243 Node* Node::firstDescendant() const
244 {
245     Node *n = const_cast<Node *>(this);
246     while (n && n->firstChild())
247         n = n->firstChild();
248     return n;
249 }
250
251 bool Node::insertBefore(PassRefPtr<Node>, Node*, ExceptionCode& ec)
252 {
253     ec = HIERARCHY_REQUEST_ERR;
254     return false;
255 }
256
257 bool Node::replaceChild(PassRefPtr<Node>, Node*, ExceptionCode& ec)
258 {
259     ec = HIERARCHY_REQUEST_ERR;
260     return false;
261 }
262
263 bool Node::removeChild(Node*, ExceptionCode& ec)
264 {
265     ec = NOT_FOUND_ERR;
266     return false;
267 }
268
269 bool Node::appendChild(PassRefPtr<Node>, ExceptionCode& ec)
270 {
271     ec = HIERARCHY_REQUEST_ERR;
272     return false;
273 }
274
275 void Node::remove(ExceptionCode& ec)
276 {
277     ref();
278     if (Node *p = parentNode())
279         p->removeChild(this, ec);
280     else
281         ec = HIERARCHY_REQUEST_ERR;
282     deref();
283 }
284
285 bool Node::hasChildNodes(  ) const
286 {
287   return false;
288 }
289
290 void Node::normalize ()
291 {
292     ExceptionCode ec = 0;
293     Node *child = firstChild();
294
295     if (isElementNode()) {
296         // Normalize any attribute children we might have 
297         Element *element = static_cast<Element *>(this);
298         NamedAttrMap *attrMap = element->attributes();
299         
300         if (attrMap) {
301             unsigned numAttrs = attrMap->length();
302             
303             for (unsigned i = 0; i < numAttrs; i++) {
304                 Attribute *attribute = attrMap->attributeItem(i);
305                 Attr *attr = attribute->attr();
306                 
307                 if (attr)
308                     attr->normalize();
309             }
310         }
311     }
312     
313     // Recursively go through the subtree beneath us, normalizing all nodes. In the case
314     // where there are two adjacent text nodes, they are merged together
315     while (child) {
316         Node *nextChild = child->nextSibling();
317
318         if (nextChild && child->nodeType() == TEXT_NODE && nextChild->nodeType() == TEXT_NODE) {
319             // Current child and the next one are both text nodes... merge them
320             Text *currentText = static_cast<Text*>(child);
321             Text *nextText = static_cast<Text*>(nextChild);
322
323             currentText->appendData(nextText->data(),ec);
324             if (ec)
325                 return;
326
327             nextChild->remove(ec);
328             if (ec)
329                 return;
330         }
331         else {
332             child->normalize();
333             child = nextChild;
334         }
335     }
336     
337     // Check if we have a single empty text node left and remove it if so
338     child = firstChild();
339     if (child && !child->nextSibling() && child->isTextNode()) {
340         Text *text = static_cast<Text*>(child);
341         if (text->data().isEmpty())
342             child->remove(ec);
343     }
344 }
345
346 const AtomicString& Node::prefix() const
347 {
348     // For nodes other than elements and attributes, the prefix is always null
349     return nullAtom;
350 }
351
352 void Node::setPrefix(const AtomicString& /*prefix*/, ExceptionCode& ec)
353 {
354     // The spec says that for nodes other than elements and attributes, prefix is always null.
355     // It does not say what to do when the user tries to set the prefix on another type of
356     // node, however Mozilla throws a NAMESPACE_ERR exception.
357     ec = NAMESPACE_ERR;
358 }
359
360 const AtomicString& Node::localName() const
361 {
362     return emptyAtom;
363 }
364
365 const AtomicString& Node::namespaceURI() const
366 {
367     return nullAtom;
368 }
369
370 ContainerNode* Node::addChild(PassRefPtr<Node>)
371 {
372     return 0;
373 }
374
375 bool Node::isContentEditable() const
376 {
377     return parent() && parent()->isContentEditable();
378 }
379
380 bool Node::isContentRichlyEditable() const
381 {
382     return parent() && parent()->isContentRichlyEditable();
383 }
384
385 bool Node::shouldUseInputMethod() const
386 {
387     return isContentEditable();
388 }
389
390 IntRect Node::getRect() const
391 {
392     int _x, _y;
393     if (renderer() && renderer()->absolutePosition(_x, _y))
394         return IntRect( _x, _y, renderer()->width(), renderer()->height() + renderer()->borderTopExtra() + renderer()->borderBottomExtra());
395
396     return IntRect();
397 }
398
399 void Node::setChanged(StyleChangeType changeType)
400 {
401     if ((changeType != NoStyleChange) && !attached()) // changed compared to what?
402         return;
403
404     if (!(changeType == InlineStyleChange && m_styleChange == FullStyleChange))
405         m_styleChange = changeType;
406
407     if (m_styleChange != NoStyleChange) {
408         for (Node* p = parentNode(); p; p = p->parentNode())
409             p->setHasChangedChild(true);
410         document()->setDocumentChanged(true);
411     }
412 }
413
414 bool Node::isFocusable() const
415 {
416     return false;
417 }
418
419 bool Node::isKeyboardFocusable(KeyboardEvent*) const
420 {
421     return isFocusable();
422 }
423
424 bool Node::isMouseFocusable() const
425 {
426     return isFocusable();
427 }
428
429 unsigned Node::nodeIndex() const
430 {
431     Node *_tempNode = previousSibling();
432     unsigned count=0;
433     for( count=0; _tempNode; count++ )
434         _tempNode = _tempNode->previousSibling();
435     return count;
436 }
437
438 void Node::registerNodeList(NodeList* list)
439 {
440     if (!m_nodeLists)
441         m_nodeLists = new NodeListsNodeData;
442     else if (!m_document->hasNodeLists())
443         // We haven't been receiving notifications while there were no registered lists, so the cache is invalid now.
444         m_nodeLists->m_childNodeListCaches.reset();
445
446     if (list->needsNotifications())
447         m_nodeLists->m_listsToNotify.add(list);
448     m_document->addNodeList();
449 }
450
451 void Node::unregisterNodeList(NodeList* list)
452 {
453     ASSERT(m_nodeLists);
454     m_document->removeNodeList();
455     if (list->needsNotifications())
456         m_nodeLists->m_listsToNotify.remove(list);
457 }
458
459 void Node::notifyLocalNodeListsAttributeChanged()
460 {
461     if (!m_nodeLists)
462         return;
463
464     NodeListSet::iterator end = m_nodeLists->m_listsToNotify.end();
465     for (NodeListSet::iterator i = m_nodeLists->m_listsToNotify.begin(); i != end; ++i)
466         (*i)->rootNodeAttributeChanged();
467 }
468
469 void Node::notifyNodeListsAttributeChanged()
470 {
471     for (Node *n = this; n; n = n->parentNode())
472         n->notifyLocalNodeListsAttributeChanged();
473 }
474
475 void Node::notifyLocalNodeListsChildrenChanged()
476 {
477     if (!m_nodeLists)
478         return;
479
480     m_nodeLists->m_childNodeListCaches.reset();
481
482     NodeListSet::iterator end = m_nodeLists->m_listsToNotify.end();
483     for (NodeListSet::iterator i = m_nodeLists->m_listsToNotify.begin(); i != end; ++i)
484         (*i)->rootNodeChildrenChanged();
485 }
486
487 void Node::notifyNodeListsChildrenChanged()
488 {
489     for (Node *n = this; n; n = n->parentNode())
490         n->notifyLocalNodeListsChildrenChanged();
491 }
492
493 unsigned Node::childNodeCount() const
494 {
495     return 0;
496 }
497
498 Node *Node::childNode(unsigned /*index*/) const
499 {
500     return 0;
501 }
502
503 Node *Node::traverseNextNode(const Node *stayWithin) const
504 {
505     if (firstChild()) {
506         ASSERT(!stayWithin || firstChild()->isDescendantOf(stayWithin));
507         return firstChild();
508     }
509     if (this == stayWithin)
510         return 0;
511     if (nextSibling()) {
512         ASSERT(!stayWithin || nextSibling()->isDescendantOf(stayWithin));
513         return nextSibling();
514     }
515     const Node *n = this;
516     while (n && !n->nextSibling() && (!stayWithin || n->parentNode() != stayWithin))
517         n = n->parentNode();
518     if (n) {
519         ASSERT(!stayWithin || !n->nextSibling() || n->nextSibling()->isDescendantOf(stayWithin));
520         return n->nextSibling();
521     }
522     return 0;
523 }
524
525 Node *Node::traverseNextSibling(const Node *stayWithin) const
526 {
527     if (this == stayWithin)
528         return 0;
529     if (nextSibling()) {
530         ASSERT(!stayWithin || nextSibling()->isDescendantOf(stayWithin));
531         return nextSibling();
532     }
533     const Node *n = this;
534     while (n && !n->nextSibling() && (!stayWithin || n->parentNode() != stayWithin))
535         n = n->parentNode();
536     if (n) {
537         ASSERT(!stayWithin || !n->nextSibling() || n->nextSibling()->isDescendantOf(stayWithin));
538         return n->nextSibling();
539     }
540     return 0;
541 }
542
543 Node *Node::traversePreviousNode(const Node *stayWithin) const
544 {
545     if (this == stayWithin)
546         return 0;
547     if (previousSibling()) {
548         Node *n = previousSibling();
549         while (n->lastChild())
550             n = n->lastChild();
551         return n;
552     }
553     return parentNode();
554 }
555
556 Node *Node::traversePreviousNodePostOrder(const Node *stayWithin) const
557 {
558     if (lastChild()) {
559         ASSERT(!stayWithin || lastChild()->isDescendantOf(stayWithin));
560         return lastChild();
561     }
562     if (this == stayWithin)
563         return 0;
564     if (previousSibling()) {
565         ASSERT(!stayWithin || previousSibling()->isDescendantOf(stayWithin));
566         return previousSibling();
567     }
568     const Node *n = this;
569     while (n && !n->previousSibling() && (!stayWithin || n->parentNode() != stayWithin))
570         n = n->parentNode();
571     if (n) {
572         ASSERT(!stayWithin || !n->previousSibling() || n->previousSibling()->isDescendantOf(stayWithin));
573         return n->previousSibling();
574     }
575     return 0;
576 }
577
578 void Node::checkSetPrefix(const AtomicString &_prefix, ExceptionCode& ec)
579 {
580     // Perform error checking as required by spec for setting Node.prefix. Used by
581     // Element::setPrefix() and Attr::setPrefix()
582
583     // FIXME: Implement support for INVALID_CHARACTER_ERR: Raised if the specified prefix contains an illegal character.
584     
585     // NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
586     if (isReadOnlyNode()) {
587         ec = NO_MODIFICATION_ALLOWED_ERR;
588         return;
589     }
590
591     // FIXME: Implement NAMESPACE_ERR: - Raised if the specified prefix is malformed
592     // We have to comment this out, since it's used for attributes and tag names, and we've only
593     // switched one over.
594     /*
595     // - if the namespaceURI of this node is null,
596     // - if the specified prefix is "xml" and the namespaceURI of this node is different from
597     //   "http://www.w3.org/XML/1998/namespace",
598     // - if this node is an attribute and the specified prefix is "xmlns" and
599     //   the namespaceURI of this node is different from "http://www.w3.org/2000/xmlns/",
600     // - or if this node is an attribute and the qualifiedName of this node is "xmlns" [Namespaces].
601     if ((namespacePart(id()) == noNamespace && id() > ID_LAST_TAG) ||
602         (_prefix == "xml" && String(document()->namespaceURI(id())) != "http://www.w3.org/XML/1998/namespace")) {
603         ec = NAMESPACE_ERR;
604         return;
605     }*/
606 }
607
608 bool Node::canReplaceChild(Node* newChild, Node* oldChild)
609 {
610     if (newChild->nodeType() != DOCUMENT_FRAGMENT_NODE) {
611         if (!childTypeAllowed(newChild->nodeType()))
612             return false;
613     }
614     else {
615         for (Node *n = newChild->firstChild(); n; n = n->nextSibling()) {
616             if (!childTypeAllowed(n->nodeType())) 
617                 return false;
618         }
619     }
620     
621     return true;
622 }
623
624 void Node::checkReplaceChild(Node* newChild, Node* oldChild, ExceptionCode& ec)
625 {
626     // Perform error checking as required by spec for adding a new child. Used by
627     // appendChild(), replaceChild() and insertBefore()
628     
629     // Not mentioned in spec: throw NOT_FOUND_ERR if newChild is null
630     if (!newChild) {
631         ec = NOT_FOUND_ERR;
632         return;
633     }
634     
635     // NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly
636     if (isReadOnlyNode()) {
637         ec = NO_MODIFICATION_ALLOWED_ERR;
638         return;
639     }
640     
641     bool shouldAdoptChild = false;
642     
643     // WRONG_DOCUMENT_ERR: Raised if newChild was created from a different document than the one that
644     // created this node.
645     // We assume that if newChild is a DocumentFragment, all children are created from the same document
646     // as the fragment itself (otherwise they could not have been added as children)
647     if (newChild->document() != document()) {
648         // but if the child is not in a document yet then loosen the
649         // restriction, so that e.g. creating an element with the Option()
650         // constructor and then adding it to a different document works,
651         // as it does in Mozilla and Mac IE.
652         if (!newChild->inDocument()) {
653             shouldAdoptChild = true;
654         } else {
655             ec = WRONG_DOCUMENT_ERR;
656             return;
657         }
658     }
659     
660     // HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not allow children of the type of the
661     // newChild node, or if the node to append is one of this node's ancestors.
662     
663     // check for ancestor/same node
664     if (newChild == this || isDescendantOf(newChild)) {
665         ec = HIERARCHY_REQUEST_ERR;
666         return;
667     }
668     
669     if (!canReplaceChild(newChild, oldChild)) {
670         ec = HIERARCHY_REQUEST_ERR;
671         return;
672     }
673        
674     // change the document pointer of newChild and all of its children to be the new document
675     if (shouldAdoptChild)
676         for (Node* node = newChild; node; node = node->traverseNextNode(newChild))
677             node->setDocument(document());
678 }
679
680 void Node::checkAddChild(Node *newChild, ExceptionCode& ec)
681 {
682     // Perform error checking as required by spec for adding a new child. Used by
683     // appendChild(), replaceChild() and insertBefore()
684
685     // Not mentioned in spec: throw NOT_FOUND_ERR if newChild is null
686     if (!newChild) {
687         ec = NOT_FOUND_ERR;
688         return;
689     }
690
691     // NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly
692     if (isReadOnlyNode()) {
693         ec = NO_MODIFICATION_ALLOWED_ERR;
694         return;
695     }
696
697     bool shouldAdoptChild = false;
698
699     // WRONG_DOCUMENT_ERR: Raised if newChild was created from a different document than the one that
700     // created this node.
701     // We assume that if newChild is a DocumentFragment, all children are created from the same document
702     // as the fragment itself (otherwise they could not have been added as children)
703     if (newChild->document() != document()) {
704         // but if the child is not in a document yet then loosen the
705         // restriction, so that e.g. creating an element with the Option()
706         // constructor and then adding it to a different document works,
707         // as it does in Mozilla and Mac IE.
708         if (!newChild->inDocument()) {
709             shouldAdoptChild = true;
710         } else {
711             ec = WRONG_DOCUMENT_ERR;
712             return;
713         }
714     }
715
716     // HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not allow children of the type of the
717     // newChild node, or if the node to append is one of this node's ancestors.
718
719     // check for ancestor/same node
720     if (newChild == this || isDescendantOf(newChild)) {
721         ec = HIERARCHY_REQUEST_ERR;
722         return;
723     }
724     
725     if (newChild->nodeType() != DOCUMENT_FRAGMENT_NODE) {
726         if (!childTypeAllowed(newChild->nodeType())) {
727             ec = HIERARCHY_REQUEST_ERR;
728             return;
729         }
730     }
731     else {
732         for (Node *n = newChild->firstChild(); n; n = n->nextSibling()) {
733             if (!childTypeAllowed(n->nodeType())) {
734                 ec = HIERARCHY_REQUEST_ERR;
735                 return;
736             }
737         }
738     }
739     
740     // change the document pointer of newChild and all of its children to be the new document
741     if (shouldAdoptChild)
742         for (Node* node = newChild; node; node = node->traverseNextNode(newChild))
743             node->setDocument(document());
744 }
745
746 bool Node::isDescendantOf(const Node *other) const
747 {
748     // Return true if other is an ancestor of this, otherwise false
749     if (!other)
750         return false;
751     for (const Node *n = parentNode(); n; n = n->parentNode()) {
752         if (n == other)
753             return true;
754     }
755     return false;
756 }
757
758 bool Node::childAllowed( Node *newChild )
759 {
760     return childTypeAllowed(newChild->nodeType());
761 }
762
763 Node::StyleChange Node::diff( RenderStyle *s1, RenderStyle *s2 ) const
764 {
765     // FIXME: The behavior of this function is just totally wrong.  It doesn't handle
766     // explicit inheritance of non-inherited properties and so you end up not re-resolving
767     // style in cases where you need to.
768     StyleChange ch = NoInherit;
769     EDisplay display1 = s1 ? s1->display() : NONE;
770     bool fl1 = s1 && s1->hasPseudoStyle(RenderStyle::FIRST_LETTER);
771     EDisplay display2 = s2 ? s2->display() : NONE;
772     bool fl2 = s2 && s2->hasPseudoStyle(RenderStyle::FIRST_LETTER);
773         
774     if (display1 != display2 || fl1 != fl2 || (s1 && s2 && !s1->contentDataEquivalent(s2)))
775         ch = Detach;
776     else if (!s1 || !s2)
777         ch = Inherit;
778     else if (*s1 == *s2)
779         ch = NoChange;
780     else if (s1->inheritedNotEqual(s2))
781         ch = Inherit;
782     
783     // If the pseudoStyles have changed, we want any StyleChange that is not NoChange
784     // because setStyle will do the right thing with anything else.
785     if (ch == NoChange && s1->hasPseudoStyle(RenderStyle::BEFORE)) {
786         RenderStyle* ps2 = s2->getPseudoStyle(RenderStyle::BEFORE);
787         if (!ps2)
788             ch = NoInherit;
789         else {
790             RenderStyle* ps1 = s1->getPseudoStyle(RenderStyle::BEFORE);
791             ch = ps1 && *ps1 == *ps2 ? NoChange : NoInherit;
792         }
793     }
794     if (ch == NoChange && s1->hasPseudoStyle(RenderStyle::AFTER)) {
795         RenderStyle* ps2 = s2->getPseudoStyle(RenderStyle::AFTER);
796         if (!ps2)
797             ch = NoInherit;
798         else {
799             RenderStyle* ps1 = s1->getPseudoStyle(RenderStyle::AFTER);
800             ch = ps2 && *ps1 == *ps2 ? NoChange : NoInherit;
801         }
802     }
803     
804     return ch;
805 }
806
807 #ifndef NDEBUG
808 void Node::dump(TextStream* stream, DeprecatedString ind) const
809 {
810     if (m_hasId) { *stream << " hasId"; }
811     if (m_hasClass) { *stream << " hasClass"; }
812     if (m_focused) { *stream << " focused"; }
813     if (m_active) { *stream << " active"; }
814
815     *stream << " tabIndex=" << m_tabIndex;
816     *stream << endl;
817
818     for (Node* child = firstChild(); child; child = child->nextSibling()) {
819         *stream << ind << child->nodeName() << ": ";
820         child->dump(stream, ind + "  ");
821     }
822 }
823 #endif
824
825 void Node::attach()
826 {
827     ASSERT(!attached());
828     ASSERT(!renderer() || (renderer()->style() && renderer()->parent()));
829     document()->incDOMTreeVersion();
830     m_attached = true;
831 }
832
833 void Node::willRemove()
834 {
835     // If the document is in the page cache, then we don't need to clear out the focused node.
836     if (!document()->inPageCache() && m_focused)
837         document()->focusedNodeRemoved(this);
838 }
839
840 void Node::detach()
841 {
842     m_inDetach = true;
843
844     if (renderer())
845         renderer()->destroy();
846     setRenderer(0);
847
848     Document* doc = document();
849     if (m_hovered)
850         doc->hoveredNodeDetached(this);
851     if (m_inActiveChain)
852         doc->activeChainNodeDetached(this);
853     doc->incDOMTreeVersion();
854
855     m_active = false;
856     m_hovered = false;
857     m_inActiveChain = false;
858     m_attached = false;
859     m_inDetach = false;
860 }
861
862 void Node::insertedIntoDocument()
863 {
864     setInDocument(true);
865     insertedIntoTree(false);
866 }
867
868 void Node::removedFromDocument()
869 {
870     setInDocument(false);
871     removedFromTree(false);
872 }
873
874 void Node::childrenChanged()
875 {
876 }
877
878 bool Node::isReadOnlyNode()
879 {
880     // Entity & Entity Reference nodes and their descendants are read-only
881     Node *n = this;
882     while (n) {
883         if (n->nodeType() == ENTITY_NODE || n->nodeType() == ENTITY_REFERENCE_NODE)
884             return true;
885         n = n->parentNode();
886     }
887     return false;
888 }
889
890 Node *Node::previousEditable() const
891 {
892     Node *node = previousLeafNode();
893     while (node) {
894         if (node->isContentEditable())
895             return node;
896         node = node->previousLeafNode();
897     }
898     return 0;
899 }
900
901 // Offset specifies the child node to start at.  If it is past
902 // the last child, it specifies to start at next sibling.
903 Node *Node::nextEditable(int offset) const
904 {
905     ASSERT(offset>=0);
906     Node *node;
907     if (hasChildNodes())
908         node = (offset >= (int)childNodeCount()) ? nextSibling() : childNode(offset)->nextLeafNode();
909     else
910         node = nextLeafNode();
911     while (node) {
912         if (node->isContentEditable())
913             return node;
914         node = node->nextLeafNode();
915     }
916     return 0;
917 }
918
919 Node *Node::nextEditable() const
920 {
921     Node *node = nextLeafNode();
922     while (node) {
923         if (node->isContentEditable())
924             return node;
925         node = node->nextLeafNode();
926     }
927     return 0;
928 }
929
930 RenderObject * Node::previousRenderer()
931 {
932     for (Node *n = previousSibling(); n; n = n->previousSibling()) {
933         if (n->renderer())
934             return n->renderer();
935     }
936     return 0;
937 }
938
939 RenderObject * Node::nextRenderer()
940 {
941     // Avoid an O(n^2) problem with this function by not checking for nextRenderer() when the parent element hasn't even 
942     // been attached yet.
943     if (parent() && !parent()->attached())
944         return 0;
945
946     for (Node *n = nextSibling(); n; n = n->nextSibling()) {
947         if (n->renderer())
948             return n->renderer();
949     }
950     return 0;
951 }
952
953 // FIXME: This code is used by editing.  Seems like it could move over there and not pollute Node.
954 Node *Node::previousNodeConsideringAtomicNodes() const
955 {
956     if (previousSibling()) {
957         Node *n = previousSibling();
958         while (!isAtomicNode(n) && n->lastChild())
959             n = n->lastChild();
960         return n;
961     }
962     else if (parentNode()) {
963         return parentNode();
964     }
965     else {
966         return 0;
967     }
968 }
969
970 Node *Node::nextNodeConsideringAtomicNodes() const
971 {
972     if (!isAtomicNode(this) && firstChild())
973         return firstChild();
974     if (nextSibling())
975         return nextSibling();
976     const Node *n = this;
977     while (n && !n->nextSibling())
978         n = n->parentNode();
979     if (n)
980         return n->nextSibling();
981     return 0;
982 }
983
984 Node *Node::previousLeafNode() const
985 {
986     Node *node = previousNodeConsideringAtomicNodes();
987     while (node) {
988         if (isAtomicNode(node))
989             return node;
990         node = node->previousNodeConsideringAtomicNodes();
991     }
992     return 0;
993 }
994
995 Node *Node::nextLeafNode() const
996 {
997     Node *node = nextNodeConsideringAtomicNodes();
998     while (node) {
999         if (isAtomicNode(node))
1000             return node;
1001         node = node->nextNodeConsideringAtomicNodes();
1002     }
1003     return 0;
1004 }
1005
1006 void Node::createRendererIfNeeded()
1007 {
1008     if (!document()->shouldCreateRenderers())
1009         return;
1010     
1011     ASSERT(!attached());
1012     ASSERT(!renderer());
1013     
1014     Node *parent = parentNode();    
1015     ASSERT(parent);
1016     
1017     RenderObject *parentRenderer = parent->renderer();
1018     if (parentRenderer && parentRenderer->canHaveChildren()
1019 #if ENABLE(SVG)
1020         && parent->childShouldCreateRenderer(this)
1021 #endif
1022         ) {
1023         RenderStyle* style = styleForRenderer(parentRenderer);
1024         if (rendererIsNeeded(style)) {
1025             if (RenderObject* r = createRenderer(document()->renderArena(), style)) {
1026                 if (!parentRenderer->isChildAllowed(r, style))
1027                     r->destroy();
1028                 else {
1029                     setRenderer(r);
1030                     renderer()->setAnimatableStyle(style);
1031                     parentRenderer->addChild(renderer(), nextRenderer());
1032                 }
1033             }
1034         }
1035         style->deref(document()->renderArena());
1036     }
1037 }
1038
1039 RenderStyle *Node::styleForRenderer(RenderObject *parent)
1040 {
1041     RenderStyle *style = parent->style();
1042     style->ref();
1043     return style;
1044 }
1045
1046 bool Node::rendererIsNeeded(RenderStyle *style)
1047 {
1048     return (document()->documentElement() == this) || (style->display() != NONE);
1049 }
1050
1051 RenderObject *Node::createRenderer(RenderArena *arena, RenderStyle *style)
1052 {
1053     ASSERT(false);
1054     return 0;
1055 }
1056
1057 RenderStyle* Node::renderStyle() const
1058
1059     return m_renderer ? m_renderer->style() : 0; 
1060 }
1061
1062 void Node::setRenderStyle(RenderStyle* s)
1063 {
1064     if (m_renderer)
1065         m_renderer->setAnimatableStyle(s); 
1066 }
1067
1068 RenderStyle* Node::computedStyle()
1069 {
1070     return parent() ? parent()->computedStyle() : 0;
1071 }
1072
1073 int Node::maxCharacterOffset() const
1074 {
1075     ASSERT_NOT_REACHED();
1076     return 0;
1077 }
1078
1079 // FIXME: Shouldn't these functions be in the editing code?  Code that asks questions about HTML in the core DOM class
1080 // is obviously misplaced.
1081 bool Node::canStartSelection() const
1082 {
1083     if (isContentEditable())
1084         return true;
1085     return parent() ? parent()->canStartSelection() : true;
1086 }
1087
1088 Node* Node::shadowAncestorNode()
1089 {
1090 #if ENABLE(SVG)
1091     // SVG elements living in a shadow tree only occour when <use> created them.
1092     // For these cases we do NOT want to return the shadowParentNode() here
1093     // but the actual shadow tree element - as main difference to the HTML forms
1094     // shadow tree concept. (This function _could_ be made virtual - opinions?)
1095     if (isSVGElement())
1096         return this;
1097 #endif
1098
1099     Node *n = this;    
1100     while (n) {
1101         if (n->isShadowNode())
1102             return n->shadowParentNode();
1103         n = n->parentNode();
1104     } 
1105     return this;
1106 }
1107
1108 bool Node::isBlockFlow() const
1109 {
1110     return renderer() && renderer()->isBlockFlow();
1111 }
1112
1113 bool Node::isBlockFlowOrBlockTable() const
1114 {
1115     return renderer() && (renderer()->isBlockFlow() || renderer()->isTable() && !renderer()->isInline());
1116 }
1117
1118 bool Node::isEditableBlock() const
1119 {
1120     return isContentEditable() && isBlockFlow();
1121 }
1122
1123 Element *Node::enclosingBlockFlowOrTableElement() const
1124 {
1125     Node *n = const_cast<Node *>(this);
1126     if (isBlockFlowOrBlockTable())
1127         return static_cast<Element *>(n);
1128
1129     while (1) {
1130         n = n->parentNode();
1131         if (!n)
1132             break;
1133         if (n->isBlockFlowOrBlockTable() || n->hasTagName(bodyTag))
1134             return static_cast<Element *>(n);
1135     }
1136     return 0;
1137 }
1138
1139 Element *Node::enclosingBlockFlowElement() const
1140 {
1141     Node *n = const_cast<Node *>(this);
1142     if (isBlockFlow())
1143         return static_cast<Element *>(n);
1144
1145     while (1) {
1146         n = n->parentNode();
1147         if (!n)
1148             break;
1149         if (n->isBlockFlow() || n->hasTagName(bodyTag))
1150             return static_cast<Element *>(n);
1151     }
1152     return 0;
1153 }
1154
1155 Element *Node::enclosingInlineElement() const
1156 {
1157     Node *n = const_cast<Node *>(this);
1158     Node *p;
1159
1160     while (1) {
1161         p = n->parentNode();
1162         if (!p || p->isBlockFlow() || p->hasTagName(bodyTag))
1163             return static_cast<Element *>(n);
1164         // Also stop if any previous sibling is a block
1165         for (Node *sibling = n->previousSibling(); sibling; sibling = sibling->previousSibling()) {
1166             if (sibling->isBlockFlow())
1167                 return static_cast<Element *>(n);
1168         }
1169         n = p;
1170     }
1171     ASSERT_NOT_REACHED();
1172     return 0;
1173 }
1174
1175 Element* Node::rootEditableElement() const
1176 {
1177     Element* result = 0;
1178     for (Node* n = const_cast<Node*>(this); n && n->isContentEditable(); n = n->parentNode()) {
1179         if (n->isElementNode())
1180             result = static_cast<Element*>(n);
1181         if (n->hasTagName(bodyTag))
1182             break;
1183     }
1184     return result;
1185 }
1186
1187 bool Node::inSameContainingBlockFlowElement(Node *n)
1188 {
1189     return n ? enclosingBlockFlowElement() == n->enclosingBlockFlowElement() : false;
1190 }
1191
1192 // FIXME: End of obviously misplaced HTML editing functions.  Try to move these out of Node.
1193
1194 PassRefPtr<NodeList> Node::getElementsByTagName(const String& name)
1195 {
1196     return getElementsByTagNameNS("*", name);
1197 }
1198  
1199 PassRefPtr<NodeList> Node::getElementsByTagNameNS(const String& namespaceURI, const String& localName)
1200 {
1201     if (localName.isNull())
1202         return 0;
1203
1204     String name = localName;
1205     if (document()->isHTMLDocument())
1206         name = localName.lower();
1207     return new TagNodeList(this, namespaceURI.isEmpty() ? nullAtom : AtomicString(namespaceURI), name);
1208 }
1209
1210 Document *Node::ownerDocument() const
1211 {
1212     Document *doc = document();
1213     return doc == this ? 0 : doc;
1214 }
1215
1216 bool Node::hasAttributes() const
1217 {
1218     return false;
1219 }
1220
1221 NamedAttrMap *Node::attributes() const
1222 {
1223     return 0;
1224 }
1225
1226 String Node::baseURI() const
1227 {
1228     Node* parent = parentNode();
1229     if (parent)
1230         return parent->baseURI();
1231
1232     return String();
1233 }
1234
1235 bool Node::isEqualNode(Node *other) const
1236 {
1237     if (!other)
1238         return false;
1239     
1240     if (nodeType() != other->nodeType())
1241         return false;
1242     
1243     if (nodeName() != other->nodeName())
1244         return false;
1245     
1246     if (localName() != other->localName())
1247         return false;
1248     
1249     if (namespaceURI() != other->namespaceURI())
1250         return false;
1251     
1252     if (prefix() != other->prefix())
1253         return false;
1254     
1255     if (nodeValue() != other->nodeValue())
1256         return false;
1257     
1258     NamedAttrMap *attrs = attributes();
1259     NamedAttrMap *otherAttrs = other->attributes();
1260     
1261     if (!attrs && otherAttrs)
1262         return false;
1263     
1264     if (attrs && !attrs->mapsEquivalent(otherAttrs))
1265         return false;
1266     
1267     Node *child = firstChild();
1268     Node *otherChild = other->firstChild();
1269     
1270     while (child) {
1271         if (!child->isEqualNode(otherChild))
1272             return false;
1273         
1274         child = child->nextSibling();
1275         otherChild = otherChild->nextSibling();
1276     }
1277     
1278     if (otherChild)
1279         return false;
1280     
1281     // FIXME: For DocumentType nodes we should check equality on
1282     // the entities and notations NamedNodeMaps as well.
1283     
1284     return true;
1285 }
1286
1287 bool Node::isDefaultNamespace(const String &namespaceURI) const
1288 {
1289     // Implemented according to
1290     // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms.html#isDefaultNamespaceAlgo
1291     
1292     switch (nodeType()) {
1293         case ELEMENT_NODE: {
1294             const Element *elem = static_cast<const Element *>(this);
1295             
1296             if (elem->prefix().isNull())
1297                 return elem->namespaceURI() == namespaceURI;
1298
1299             if (elem->hasAttributes()) {
1300                 NamedAttrMap *attrs = elem->attributes();
1301                 
1302                 for (unsigned i = 0; i < attrs->length(); i++) {
1303                     Attribute *attr = attrs->attributeItem(i);
1304                     
1305                     if (attr->localName() == "xmlns")
1306                         return attr->value() == namespaceURI;
1307                 }
1308             }
1309
1310             if (Element* ancestor = ancestorElement())
1311                 return ancestor->isDefaultNamespace(namespaceURI);
1312
1313             return false;
1314         }
1315         case DOCUMENT_NODE:
1316             return static_cast <const Document *>(this)->documentElement()->isDefaultNamespace(namespaceURI);
1317         case ENTITY_NODE:
1318         case NOTATION_NODE:
1319         case DOCUMENT_TYPE_NODE:
1320         case DOCUMENT_FRAGMENT_NODE:
1321             return false;
1322         case ATTRIBUTE_NODE: {
1323             const Attr *attr = static_cast<const Attr *>(this);
1324             if (attr->ownerElement())
1325                 return attr->ownerElement()->isDefaultNamespace(namespaceURI);
1326             return false;
1327         }
1328         default:
1329             if (Element* ancestor = ancestorElement())
1330                 return ancestor->isDefaultNamespace(namespaceURI);
1331             return false;
1332     }
1333 }
1334
1335 String Node::lookupPrefix(const String &namespaceURI) const
1336 {
1337     // Implemented according to
1338     // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms.html#lookupNamespacePrefixAlgo
1339     
1340     if (namespaceURI.isEmpty())
1341         return String();
1342     
1343     switch (nodeType()) {
1344         case ELEMENT_NODE:
1345             return lookupNamespacePrefix(namespaceURI, static_cast<const Element *>(this));
1346         case DOCUMENT_NODE:
1347             return static_cast<const Document *>(this)->documentElement()->lookupPrefix(namespaceURI);
1348         case ENTITY_NODE:
1349         case NOTATION_NODE:
1350         case DOCUMENT_FRAGMENT_NODE:
1351         case DOCUMENT_TYPE_NODE:
1352             return String();
1353         case ATTRIBUTE_NODE: {
1354             const Attr *attr = static_cast<const Attr *>(this);
1355             if (attr->ownerElement())
1356                 return attr->ownerElement()->lookupPrefix(namespaceURI);
1357             return String();
1358         }
1359         default:
1360             if (Element* ancestor = ancestorElement())
1361                 return ancestor->lookupPrefix(namespaceURI);
1362             return String();
1363     }
1364 }
1365
1366 String Node::lookupNamespaceURI(const String &prefix) const
1367 {
1368     // Implemented according to
1369     // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms.html#lookupNamespaceURIAlgo
1370     
1371     if (!prefix.isNull() && prefix.isEmpty())
1372         return String();
1373     
1374     switch (nodeType()) {
1375         case ELEMENT_NODE: {
1376             const Element *elem = static_cast<const Element *>(this);
1377             
1378             if (!elem->namespaceURI().isNull() && elem->prefix() == prefix)
1379                 return elem->namespaceURI();
1380             
1381             if (elem->hasAttributes()) {
1382                 NamedAttrMap *attrs = elem->attributes();
1383                 
1384                 for (unsigned i = 0; i < attrs->length(); i++) {
1385                     Attribute *attr = attrs->attributeItem(i);
1386                     
1387                     if (attr->prefix() == "xmlns" && attr->localName() == prefix) {
1388                         if (!attr->value().isEmpty())
1389                             return attr->value();
1390                         
1391                         return String();
1392                     } else if (attr->localName() == "xmlns" && prefix.isNull()) {
1393                         if (!attr->value().isEmpty())
1394                             return attr->value();
1395                         
1396                         return String();
1397                     }
1398                 }
1399             }
1400             if (Element* ancestor = ancestorElement())
1401                 return ancestor->lookupNamespaceURI(prefix);
1402             return String();
1403         }
1404         case DOCUMENT_NODE:
1405             return static_cast<const Document *>(this)->documentElement()->lookupNamespaceURI(prefix);
1406         case ENTITY_NODE:
1407         case NOTATION_NODE:
1408         case DOCUMENT_TYPE_NODE:
1409         case DOCUMENT_FRAGMENT_NODE:
1410             return String();
1411         case ATTRIBUTE_NODE: {
1412             const Attr *attr = static_cast<const Attr *>(this);
1413             
1414             if (attr->ownerElement())
1415                 return attr->ownerElement()->lookupNamespaceURI(prefix);
1416             else
1417                 return String();
1418         }
1419         default:
1420             if (Element* ancestor = ancestorElement())
1421                 return ancestor->lookupNamespaceURI(prefix);
1422             return String();
1423     }
1424 }
1425
1426 String Node::lookupNamespacePrefix(const String &_namespaceURI, const Element *originalElement) const
1427 {
1428     if (_namespaceURI.isNull())
1429         return String();
1430             
1431     if (originalElement->lookupNamespaceURI(prefix()) == _namespaceURI)
1432         return prefix();
1433     
1434     if (hasAttributes()) {
1435         NamedAttrMap *attrs = attributes();
1436         
1437         for (unsigned i = 0; i < attrs->length(); i++) {
1438             Attribute *attr = attrs->attributeItem(i);
1439             
1440             if (attr->prefix() == "xmlns" &&
1441                 attr->value() == _namespaceURI &&
1442                 originalElement->lookupNamespaceURI(attr->localName()) == _namespaceURI)
1443                 return attr->localName();
1444         }
1445     }
1446     
1447     if (Element* ancestor = ancestorElement())
1448         return ancestor->lookupNamespacePrefix(_namespaceURI, originalElement);
1449     return String();
1450 }
1451
1452 String Node::textContent(bool convertBRsToNewlines) const
1453 {
1454     switch (nodeType()) {
1455         case TEXT_NODE:
1456         case CDATA_SECTION_NODE:
1457         case COMMENT_NODE:
1458         case PROCESSING_INSTRUCTION_NODE:
1459             return nodeValue();
1460         
1461         case ELEMENT_NODE:
1462             if (hasTagName(brTag) && 
1463                 convertBRsToNewlines)
1464                 return "\n";
1465         case ATTRIBUTE_NODE:
1466         case ENTITY_NODE:
1467         case ENTITY_REFERENCE_NODE:
1468         case DOCUMENT_FRAGMENT_NODE: {
1469             String s = "";
1470         
1471             for (Node *child = firstChild(); child; child = child->nextSibling()) {
1472                 if (child->nodeType() == COMMENT_NODE || child->nodeType() == PROCESSING_INSTRUCTION_NODE)
1473                     continue;
1474             
1475                 s += child->textContent(convertBRsToNewlines);
1476             }
1477         
1478             return s;
1479         }
1480         
1481         case DOCUMENT_NODE:
1482         case DOCUMENT_TYPE_NODE:
1483         case NOTATION_NODE:
1484         default:
1485             return String();            
1486     }
1487 }
1488
1489 void Node::setTextContent(const String &text, ExceptionCode& ec)
1490 {           
1491     switch (nodeType()) {
1492         case TEXT_NODE:
1493         case CDATA_SECTION_NODE:
1494         case COMMENT_NODE:
1495         case PROCESSING_INSTRUCTION_NODE:
1496             setNodeValue(text, ec);
1497             break;
1498         case ELEMENT_NODE:
1499         case ATTRIBUTE_NODE:
1500         case ENTITY_NODE:
1501         case ENTITY_REFERENCE_NODE:
1502         case DOCUMENT_FRAGMENT_NODE: {
1503             ContainerNode *container = static_cast<ContainerNode *>(this);
1504             
1505             container->removeChildren();
1506             
1507             if (!text.isEmpty())
1508                 appendChild(document()->createTextNode(text), ec);
1509             break;
1510         }
1511         case DOCUMENT_NODE:
1512         case DOCUMENT_TYPE_NODE:
1513         case NOTATION_NODE:
1514         default:
1515             // Do nothing
1516             break;
1517     }
1518 }
1519
1520 Element* Node::ancestorElement() const
1521 {
1522     // In theory, there can be EntityReference nodes between elements, but this is currently not supported.
1523     for (Node* n = parentNode(); n; n = n->parentNode()) {
1524         if (n->isElementNode())
1525             return static_cast<Element*>(n);
1526     }
1527     return 0;
1528 }
1529
1530 bool Node::offsetInCharacters() const
1531 {
1532     return false;
1533 }
1534
1535 #ifndef NDEBUG
1536
1537 static void appendAttributeDesc(const Node* node, String& string, const QualifiedName& name, const char* attrDesc)
1538 {
1539     if (node->isElementNode()) {
1540         String attr = static_cast<const Element*>(node)->getAttribute(name);
1541         if (!attr.isEmpty()) {
1542             string += attrDesc;
1543             string += attr;
1544         }
1545     }
1546 }
1547
1548 void Node::showNode(const char* prefix) const
1549 {
1550     if (!prefix)
1551         prefix = "";
1552     if (isTextNode()) {
1553         String value = nodeValue();
1554         value.replace('\\', "\\\\");
1555         value.replace('\n', "\\n");
1556         fprintf(stderr, "%s%s\t%p \"%s\"\n", prefix, nodeName().utf8().data(), this, value.utf8().data());
1557     } else {
1558         String attrs = "";
1559         appendAttributeDesc(this, attrs, classAttr, " CLASS=");
1560         appendAttributeDesc(this, attrs, styleAttr, " STYLE=");
1561         fprintf(stderr, "%s%s\t%p%s\n", prefix, nodeName().utf8().data(), this, attrs.utf8().data());
1562     }
1563 }
1564
1565 void Node::showTreeForThis() const
1566 {
1567     showTreeAndMark(this, "*");
1568 }
1569
1570 void Node::showTreeAndMark(const Node* markedNode1, const char* markedLabel1, const Node* markedNode2, const char * markedLabel2) const
1571 {
1572     const Node* rootNode;
1573     const Node* node = this;
1574     while (node->parentNode() && !node->hasTagName(bodyTag))
1575         node = node->parentNode();
1576     rootNode = node;
1577         
1578     for (node = rootNode; node; node = node->traverseNextNode()) {
1579         if (node == markedNode1)
1580             fprintf(stderr, "%s", markedLabel1);
1581         if (node == markedNode2)
1582             fprintf(stderr, "%s", markedLabel2);
1583                         
1584         for (const Node* tmpNode = node; tmpNode && tmpNode != rootNode; tmpNode = tmpNode->parentNode())
1585             fprintf(stderr, "\t");
1586         node->showNode();
1587     }
1588 }
1589
1590 void Node::formatForDebugger(char* buffer, unsigned length) const
1591 {
1592     String result;
1593     String s;
1594     
1595     s = nodeName();
1596     if (s.length() == 0)
1597         result += "<none>";
1598     else
1599         result += s;
1600           
1601     strncpy(buffer, result.utf8().data(), length - 1);
1602 }
1603
1604 #endif
1605
1606 }
1607
1608 #ifndef NDEBUG
1609
1610 void showTree(const WebCore::Node* node)
1611 {
1612     if (node)
1613         node->showTreeForThis();
1614 }
1615
1616 #endif