3f798559b8268a2192c23215b26396f64b1925b7
[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_registeredLists;
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_nodeLists->m_registeredLists.isEmpty()) 
443         m_nodeLists->m_childNodeListCaches.reset();
444
445     m_nodeLists->m_registeredLists.add(list);
446     m_document->addNodeList();
447 }
448
449 void Node::unregisterNodeList(NodeList* list)
450 {
451     ASSERT(m_nodeLists);
452     m_document->removeNodeList();
453     m_nodeLists->m_registeredLists.remove(list);
454 }
455
456 void Node::notifyLocalNodeListsAttributeChanged()
457 {
458     if (!m_nodeLists)
459         return;
460
461     NodeListSet::iterator end = m_nodeLists->m_registeredLists.end();
462     for (NodeListSet::iterator i = m_nodeLists->m_registeredLists.begin(); i != end; ++i)
463         (*i)->rootNodeAttributeChanged();
464 }
465
466 void Node::notifyNodeListsAttributeChanged()
467 {
468     for (Node *n = this; n; n = n->parentNode())
469         n->notifyLocalNodeListsAttributeChanged();
470 }
471
472 void Node::notifyLocalNodeListsChildrenChanged()
473 {
474     if (!m_nodeLists)
475         return;
476
477     m_nodeLists->m_childNodeListCaches.reset();
478
479     NodeListSet::iterator end = m_nodeLists->m_registeredLists.end();
480     for (NodeListSet::iterator i = m_nodeLists->m_registeredLists.begin(); i != end; ++i)
481         (*i)->rootNodeChildrenChanged();
482 }
483
484 void Node::notifyNodeListsChildrenChanged()
485 {
486     for (Node *n = this; n; n = n->parentNode())
487         n->notifyLocalNodeListsChildrenChanged();
488 }
489
490 unsigned Node::childNodeCount() const
491 {
492     return 0;
493 }
494
495 Node *Node::childNode(unsigned /*index*/) const
496 {
497     return 0;
498 }
499
500 Node *Node::traverseNextNode(const Node *stayWithin) const
501 {
502     if (firstChild()) {
503         ASSERT(!stayWithin || firstChild()->isDescendantOf(stayWithin));
504         return firstChild();
505     }
506     if (this == stayWithin)
507         return 0;
508     if (nextSibling()) {
509         ASSERT(!stayWithin || nextSibling()->isDescendantOf(stayWithin));
510         return nextSibling();
511     }
512     const Node *n = this;
513     while (n && !n->nextSibling() && (!stayWithin || n->parentNode() != stayWithin))
514         n = n->parentNode();
515     if (n) {
516         ASSERT(!stayWithin || !n->nextSibling() || n->nextSibling()->isDescendantOf(stayWithin));
517         return n->nextSibling();
518     }
519     return 0;
520 }
521
522 Node *Node::traverseNextSibling(const Node *stayWithin) const
523 {
524     if (this == stayWithin)
525         return 0;
526     if (nextSibling()) {
527         ASSERT(!stayWithin || nextSibling()->isDescendantOf(stayWithin));
528         return nextSibling();
529     }
530     const Node *n = this;
531     while (n && !n->nextSibling() && (!stayWithin || n->parentNode() != stayWithin))
532         n = n->parentNode();
533     if (n) {
534         ASSERT(!stayWithin || !n->nextSibling() || n->nextSibling()->isDescendantOf(stayWithin));
535         return n->nextSibling();
536     }
537     return 0;
538 }
539
540 Node *Node::traversePreviousNode(const Node *stayWithin) const
541 {
542     if (this == stayWithin)
543         return 0;
544     if (previousSibling()) {
545         Node *n = previousSibling();
546         while (n->lastChild())
547             n = n->lastChild();
548         return n;
549     }
550     return parentNode();
551 }
552
553 Node *Node::traversePreviousNodePostOrder(const Node *stayWithin) const
554 {
555     if (lastChild()) {
556         ASSERT(!stayWithin || lastChild()->isDescendantOf(stayWithin));
557         return lastChild();
558     }
559     if (this == stayWithin)
560         return 0;
561     if (previousSibling()) {
562         ASSERT(!stayWithin || previousSibling()->isDescendantOf(stayWithin));
563         return previousSibling();
564     }
565     const Node *n = this;
566     while (n && !n->previousSibling() && (!stayWithin || n->parentNode() != stayWithin))
567         n = n->parentNode();
568     if (n) {
569         ASSERT(!stayWithin || !n->previousSibling() || n->previousSibling()->isDescendantOf(stayWithin));
570         return n->previousSibling();
571     }
572     return 0;
573 }
574
575 void Node::checkSetPrefix(const AtomicString &_prefix, ExceptionCode& ec)
576 {
577     // Perform error checking as required by spec for setting Node.prefix. Used by
578     // Element::setPrefix() and Attr::setPrefix()
579
580     // FIXME: Implement support for INVALID_CHARACTER_ERR: Raised if the specified prefix contains an illegal character.
581     
582     // NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
583     if (isReadOnlyNode()) {
584         ec = NO_MODIFICATION_ALLOWED_ERR;
585         return;
586     }
587
588     // FIXME: Implement NAMESPACE_ERR: - Raised if the specified prefix is malformed
589     // We have to comment this out, since it's used for attributes and tag names, and we've only
590     // switched one over.
591     /*
592     // - if the namespaceURI of this node is null,
593     // - if the specified prefix is "xml" and the namespaceURI of this node is different from
594     //   "http://www.w3.org/XML/1998/namespace",
595     // - if this node is an attribute and the specified prefix is "xmlns" and
596     //   the namespaceURI of this node is different from "http://www.w3.org/2000/xmlns/",
597     // - or if this node is an attribute and the qualifiedName of this node is "xmlns" [Namespaces].
598     if ((namespacePart(id()) == noNamespace && id() > ID_LAST_TAG) ||
599         (_prefix == "xml" && String(document()->namespaceURI(id())) != "http://www.w3.org/XML/1998/namespace")) {
600         ec = NAMESPACE_ERR;
601         return;
602     }*/
603 }
604
605 bool Node::canReplaceChild(Node* newChild, Node* oldChild)
606 {
607     if (newChild->nodeType() != DOCUMENT_FRAGMENT_NODE) {
608         if (!childTypeAllowed(newChild->nodeType()))
609             return false;
610     }
611     else {
612         for (Node *n = newChild->firstChild(); n; n = n->nextSibling()) {
613             if (!childTypeAllowed(n->nodeType())) 
614                 return false;
615         }
616     }
617     
618     return true;
619 }
620
621 void Node::checkReplaceChild(Node* newChild, Node* oldChild, ExceptionCode& ec)
622 {
623     // Perform error checking as required by spec for adding a new child. Used by
624     // appendChild(), replaceChild() and insertBefore()
625     
626     // Not mentioned in spec: throw NOT_FOUND_ERR if newChild is null
627     if (!newChild) {
628         ec = NOT_FOUND_ERR;
629         return;
630     }
631     
632     // NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly
633     if (isReadOnlyNode()) {
634         ec = NO_MODIFICATION_ALLOWED_ERR;
635         return;
636     }
637     
638     bool shouldAdoptChild = false;
639     
640     // WRONG_DOCUMENT_ERR: Raised if newChild was created from a different document than the one that
641     // created this node.
642     // We assume that if newChild is a DocumentFragment, all children are created from the same document
643     // as the fragment itself (otherwise they could not have been added as children)
644     if (newChild->document() != document()) {
645         // but if the child is not in a document yet then loosen the
646         // restriction, so that e.g. creating an element with the Option()
647         // constructor and then adding it to a different document works,
648         // as it does in Mozilla and Mac IE.
649         if (!newChild->inDocument()) {
650             shouldAdoptChild = true;
651         } else {
652             ec = WRONG_DOCUMENT_ERR;
653             return;
654         }
655     }
656     
657     // HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not allow children of the type of the
658     // newChild node, or if the node to append is one of this node's ancestors.
659     
660     // check for ancestor/same node
661     if (newChild == this || isDescendantOf(newChild)) {
662         ec = HIERARCHY_REQUEST_ERR;
663         return;
664     }
665     
666     if (!canReplaceChild(newChild, oldChild)) {
667         ec = HIERARCHY_REQUEST_ERR;
668         return;
669     }
670        
671     // change the document pointer of newChild and all of its children to be the new document
672     if (shouldAdoptChild)
673         for (Node* node = newChild; node; node = node->traverseNextNode(newChild))
674             node->setDocument(document());
675 }
676
677 void Node::checkAddChild(Node *newChild, ExceptionCode& ec)
678 {
679     // Perform error checking as required by spec for adding a new child. Used by
680     // appendChild(), replaceChild() and insertBefore()
681
682     // Not mentioned in spec: throw NOT_FOUND_ERR if newChild is null
683     if (!newChild) {
684         ec = NOT_FOUND_ERR;
685         return;
686     }
687
688     // NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly
689     if (isReadOnlyNode()) {
690         ec = NO_MODIFICATION_ALLOWED_ERR;
691         return;
692     }
693
694     bool shouldAdoptChild = false;
695
696     // WRONG_DOCUMENT_ERR: Raised if newChild was created from a different document than the one that
697     // created this node.
698     // We assume that if newChild is a DocumentFragment, all children are created from the same document
699     // as the fragment itself (otherwise they could not have been added as children)
700     if (newChild->document() != document()) {
701         // but if the child is not in a document yet then loosen the
702         // restriction, so that e.g. creating an element with the Option()
703         // constructor and then adding it to a different document works,
704         // as it does in Mozilla and Mac IE.
705         if (!newChild->inDocument()) {
706             shouldAdoptChild = true;
707         } else {
708             ec = WRONG_DOCUMENT_ERR;
709             return;
710         }
711     }
712
713     // HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not allow children of the type of the
714     // newChild node, or if the node to append is one of this node's ancestors.
715
716     // check for ancestor/same node
717     if (newChild == this || isDescendantOf(newChild)) {
718         ec = HIERARCHY_REQUEST_ERR;
719         return;
720     }
721     
722     if (newChild->nodeType() != DOCUMENT_FRAGMENT_NODE) {
723         if (!childTypeAllowed(newChild->nodeType())) {
724             ec = HIERARCHY_REQUEST_ERR;
725             return;
726         }
727     }
728     else {
729         for (Node *n = newChild->firstChild(); n; n = n->nextSibling()) {
730             if (!childTypeAllowed(n->nodeType())) {
731                 ec = HIERARCHY_REQUEST_ERR;
732                 return;
733             }
734         }
735     }
736     
737     // change the document pointer of newChild and all of its children to be the new document
738     if (shouldAdoptChild)
739         for (Node* node = newChild; node; node = node->traverseNextNode(newChild))
740             node->setDocument(document());
741 }
742
743 bool Node::isDescendantOf(const Node *other) const
744 {
745     // Return true if other is an ancestor of this, otherwise false
746     if (!other)
747         return false;
748     for (const Node *n = parentNode(); n; n = n->parentNode()) {
749         if (n == other)
750             return true;
751     }
752     return false;
753 }
754
755 bool Node::childAllowed( Node *newChild )
756 {
757     return childTypeAllowed(newChild->nodeType());
758 }
759
760 Node::StyleChange Node::diff( RenderStyle *s1, RenderStyle *s2 ) const
761 {
762     // FIXME: The behavior of this function is just totally wrong.  It doesn't handle
763     // explicit inheritance of non-inherited properties and so you end up not re-resolving
764     // style in cases where you need to.
765     StyleChange ch = NoInherit;
766     EDisplay display1 = s1 ? s1->display() : NONE;
767     bool fl1 = s1 && s1->hasPseudoStyle(RenderStyle::FIRST_LETTER);
768     EDisplay display2 = s2 ? s2->display() : NONE;
769     bool fl2 = s2 && s2->hasPseudoStyle(RenderStyle::FIRST_LETTER);
770         
771     if (display1 != display2 || fl1 != fl2 || (s1 && s2 && !s1->contentDataEquivalent(s2)))
772         ch = Detach;
773     else if (!s1 || !s2)
774         ch = Inherit;
775     else if (*s1 == *s2)
776         ch = NoChange;
777     else if (s1->inheritedNotEqual(s2))
778         ch = Inherit;
779     
780     // If the pseudoStyles have changed, we want any StyleChange that is not NoChange
781     // because setStyle will do the right thing with anything else.
782     if (ch == NoChange && s1->hasPseudoStyle(RenderStyle::BEFORE)) {
783         RenderStyle* ps2 = s2->getPseudoStyle(RenderStyle::BEFORE);
784         if (!ps2)
785             ch = NoInherit;
786         else {
787             RenderStyle* ps1 = s1->getPseudoStyle(RenderStyle::BEFORE);
788             ch = ps1 && *ps1 == *ps2 ? NoChange : NoInherit;
789         }
790     }
791     if (ch == NoChange && s1->hasPseudoStyle(RenderStyle::AFTER)) {
792         RenderStyle* ps2 = s2->getPseudoStyle(RenderStyle::AFTER);
793         if (!ps2)
794             ch = NoInherit;
795         else {
796             RenderStyle* ps1 = s1->getPseudoStyle(RenderStyle::AFTER);
797             ch = ps2 && *ps1 == *ps2 ? NoChange : NoInherit;
798         }
799     }
800     
801     return ch;
802 }
803
804 #ifndef NDEBUG
805 void Node::dump(TextStream* stream, DeprecatedString ind) const
806 {
807     if (m_hasId) { *stream << " hasId"; }
808     if (m_hasClass) { *stream << " hasClass"; }
809     if (m_focused) { *stream << " focused"; }
810     if (m_active) { *stream << " active"; }
811
812     *stream << " tabIndex=" << m_tabIndex;
813     *stream << endl;
814
815     for (Node* child = firstChild(); child; child = child->nextSibling()) {
816         *stream << ind << child->nodeName() << ": ";
817         child->dump(stream, ind + "  ");
818     }
819 }
820 #endif
821
822 void Node::attach()
823 {
824     ASSERT(!attached());
825     ASSERT(!renderer() || (renderer()->style() && renderer()->parent()));
826     document()->incDOMTreeVersion();
827     m_attached = true;
828 }
829
830 void Node::willRemove()
831 {
832     // If the document is in the page cache, then we don't need to clear out the focused node.
833     if (!document()->inPageCache() && m_focused)
834         document()->focusedNodeRemoved(this);
835 }
836
837 void Node::detach()
838 {
839     m_inDetach = true;
840
841     if (renderer())
842         renderer()->destroy();
843     setRenderer(0);
844
845     Document* doc = document();
846     if (m_hovered)
847         doc->hoveredNodeDetached(this);
848     if (m_inActiveChain)
849         doc->activeChainNodeDetached(this);
850     doc->incDOMTreeVersion();
851
852     m_active = false;
853     m_hovered = false;
854     m_inActiveChain = false;
855     m_attached = false;
856     m_inDetach = false;
857 }
858
859 void Node::insertedIntoDocument()
860 {
861     setInDocument(true);
862     insertedIntoTree(false);
863 }
864
865 void Node::removedFromDocument()
866 {
867     setInDocument(false);
868     removedFromTree(false);
869 }
870
871 void Node::childrenChanged()
872 {
873 }
874
875 bool Node::isReadOnlyNode()
876 {
877     // Entity & Entity Reference nodes and their descendants are read-only
878     Node *n = this;
879     while (n) {
880         if (n->nodeType() == ENTITY_NODE || n->nodeType() == ENTITY_REFERENCE_NODE)
881             return true;
882         n = n->parentNode();
883     }
884     return false;
885 }
886
887 Node *Node::previousEditable() const
888 {
889     Node *node = previousLeafNode();
890     while (node) {
891         if (node->isContentEditable())
892             return node;
893         node = node->previousLeafNode();
894     }
895     return 0;
896 }
897
898 // Offset specifies the child node to start at.  If it is past
899 // the last child, it specifies to start at next sibling.
900 Node *Node::nextEditable(int offset) const
901 {
902     ASSERT(offset>=0);
903     Node *node;
904     if (hasChildNodes())
905         node = (offset >= (int)childNodeCount()) ? nextSibling() : childNode(offset)->nextLeafNode();
906     else
907         node = nextLeafNode();
908     while (node) {
909         if (node->isContentEditable())
910             return node;
911         node = node->nextLeafNode();
912     }
913     return 0;
914 }
915
916 Node *Node::nextEditable() const
917 {
918     Node *node = nextLeafNode();
919     while (node) {
920         if (node->isContentEditable())
921             return node;
922         node = node->nextLeafNode();
923     }
924     return 0;
925 }
926
927 RenderObject * Node::previousRenderer()
928 {
929     for (Node *n = previousSibling(); n; n = n->previousSibling()) {
930         if (n->renderer())
931             return n->renderer();
932     }
933     return 0;
934 }
935
936 RenderObject * Node::nextRenderer()
937 {
938     // Avoid an O(n^2) problem with this function by not checking for nextRenderer() when the parent element hasn't even 
939     // been attached yet.
940     if (parent() && !parent()->attached())
941         return 0;
942
943     for (Node *n = nextSibling(); n; n = n->nextSibling()) {
944         if (n->renderer())
945             return n->renderer();
946     }
947     return 0;
948 }
949
950 // FIXME: This code is used by editing.  Seems like it could move over there and not pollute Node.
951 Node *Node::previousNodeConsideringAtomicNodes() const
952 {
953     if (previousSibling()) {
954         Node *n = previousSibling();
955         while (!isAtomicNode(n) && n->lastChild())
956             n = n->lastChild();
957         return n;
958     }
959     else if (parentNode()) {
960         return parentNode();
961     }
962     else {
963         return 0;
964     }
965 }
966
967 Node *Node::nextNodeConsideringAtomicNodes() const
968 {
969     if (!isAtomicNode(this) && firstChild())
970         return firstChild();
971     if (nextSibling())
972         return nextSibling();
973     const Node *n = this;
974     while (n && !n->nextSibling())
975         n = n->parentNode();
976     if (n)
977         return n->nextSibling();
978     return 0;
979 }
980
981 Node *Node::previousLeafNode() const
982 {
983     Node *node = previousNodeConsideringAtomicNodes();
984     while (node) {
985         if (isAtomicNode(node))
986             return node;
987         node = node->previousNodeConsideringAtomicNodes();
988     }
989     return 0;
990 }
991
992 Node *Node::nextLeafNode() const
993 {
994     Node *node = nextNodeConsideringAtomicNodes();
995     while (node) {
996         if (isAtomicNode(node))
997             return node;
998         node = node->nextNodeConsideringAtomicNodes();
999     }
1000     return 0;
1001 }
1002
1003 void Node::createRendererIfNeeded()
1004 {
1005     if (!document()->shouldCreateRenderers())
1006         return;
1007     
1008     ASSERT(!attached());
1009     ASSERT(!renderer());
1010     
1011     Node *parent = parentNode();    
1012     ASSERT(parent);
1013     
1014     RenderObject *parentRenderer = parent->renderer();
1015     if (parentRenderer && parentRenderer->canHaveChildren()
1016 #if ENABLE(SVG)
1017         && parent->childShouldCreateRenderer(this)
1018 #endif
1019         ) {
1020         RenderStyle* style = styleForRenderer(parentRenderer);
1021         if (rendererIsNeeded(style)) {
1022             if (RenderObject* r = createRenderer(document()->renderArena(), style)) {
1023                 if (!parentRenderer->isChildAllowed(r, style))
1024                     r->destroy();
1025                 else {
1026                     setRenderer(r);
1027                     renderer()->setAnimatableStyle(style);
1028                     parentRenderer->addChild(renderer(), nextRenderer());
1029                 }
1030             }
1031         }
1032         style->deref(document()->renderArena());
1033     }
1034 }
1035
1036 RenderStyle *Node::styleForRenderer(RenderObject *parent)
1037 {
1038     RenderStyle *style = parent->style();
1039     style->ref();
1040     return style;
1041 }
1042
1043 bool Node::rendererIsNeeded(RenderStyle *style)
1044 {
1045     return (document()->documentElement() == this) || (style->display() != NONE);
1046 }
1047
1048 RenderObject *Node::createRenderer(RenderArena *arena, RenderStyle *style)
1049 {
1050     ASSERT(false);
1051     return 0;
1052 }
1053
1054 RenderStyle* Node::renderStyle() const
1055
1056     return m_renderer ? m_renderer->style() : 0; 
1057 }
1058
1059 void Node::setRenderStyle(RenderStyle* s)
1060 {
1061     if (m_renderer)
1062         m_renderer->setAnimatableStyle(s); 
1063 }
1064
1065 RenderStyle* Node::computedStyle()
1066 {
1067     return parent() ? parent()->computedStyle() : 0;
1068 }
1069
1070 int Node::maxCharacterOffset() const
1071 {
1072     ASSERT_NOT_REACHED();
1073     return 0;
1074 }
1075
1076 // FIXME: Shouldn't these functions be in the editing code?  Code that asks questions about HTML in the core DOM class
1077 // is obviously misplaced.
1078 bool Node::canStartSelection() const
1079 {
1080     if (isContentEditable())
1081         return true;
1082     return parent() ? parent()->canStartSelection() : true;
1083 }
1084
1085 Node* Node::shadowAncestorNode()
1086 {
1087 #if ENABLE(SVG)
1088     // SVG elements living in a shadow tree only occour when <use> created them.
1089     // For these cases we do NOT want to return the shadowParentNode() here
1090     // but the actual shadow tree element - as main difference to the HTML forms
1091     // shadow tree concept. (This function _could_ be made virtual - opinions?)
1092     if (isSVGElement())
1093         return this;
1094 #endif
1095
1096     Node *n = this;    
1097     while (n) {
1098         if (n->isShadowNode())
1099             return n->shadowParentNode();
1100         n = n->parentNode();
1101     } 
1102     return this;
1103 }
1104
1105 bool Node::isBlockFlow() const
1106 {
1107     return renderer() && renderer()->isBlockFlow();
1108 }
1109
1110 bool Node::isBlockFlowOrBlockTable() const
1111 {
1112     return renderer() && (renderer()->isBlockFlow() || renderer()->isTable() && !renderer()->isInline());
1113 }
1114
1115 bool Node::isEditableBlock() const
1116 {
1117     return isContentEditable() && isBlockFlow();
1118 }
1119
1120 Element *Node::enclosingBlockFlowOrTableElement() const
1121 {
1122     Node *n = const_cast<Node *>(this);
1123     if (isBlockFlowOrBlockTable())
1124         return static_cast<Element *>(n);
1125
1126     while (1) {
1127         n = n->parentNode();
1128         if (!n)
1129             break;
1130         if (n->isBlockFlowOrBlockTable() || n->hasTagName(bodyTag))
1131             return static_cast<Element *>(n);
1132     }
1133     return 0;
1134 }
1135
1136 Element *Node::enclosingBlockFlowElement() const
1137 {
1138     Node *n = const_cast<Node *>(this);
1139     if (isBlockFlow())
1140         return static_cast<Element *>(n);
1141
1142     while (1) {
1143         n = n->parentNode();
1144         if (!n)
1145             break;
1146         if (n->isBlockFlow() || n->hasTagName(bodyTag))
1147             return static_cast<Element *>(n);
1148     }
1149     return 0;
1150 }
1151
1152 Element *Node::enclosingInlineElement() const
1153 {
1154     Node *n = const_cast<Node *>(this);
1155     Node *p;
1156
1157     while (1) {
1158         p = n->parentNode();
1159         if (!p || p->isBlockFlow() || p->hasTagName(bodyTag))
1160             return static_cast<Element *>(n);
1161         // Also stop if any previous sibling is a block
1162         for (Node *sibling = n->previousSibling(); sibling; sibling = sibling->previousSibling()) {
1163             if (sibling->isBlockFlow())
1164                 return static_cast<Element *>(n);
1165         }
1166         n = p;
1167     }
1168     ASSERT_NOT_REACHED();
1169     return 0;
1170 }
1171
1172 Element* Node::rootEditableElement() const
1173 {
1174     Element* result = 0;
1175     for (Node* n = const_cast<Node*>(this); n && n->isContentEditable(); n = n->parentNode()) {
1176         if (n->isElementNode())
1177             result = static_cast<Element*>(n);
1178         if (n->hasTagName(bodyTag))
1179             break;
1180     }
1181     return result;
1182 }
1183
1184 bool Node::inSameContainingBlockFlowElement(Node *n)
1185 {
1186     return n ? enclosingBlockFlowElement() == n->enclosingBlockFlowElement() : false;
1187 }
1188
1189 // FIXME: End of obviously misplaced HTML editing functions.  Try to move these out of Node.
1190
1191 PassRefPtr<NodeList> Node::getElementsByTagName(const String& name)
1192 {
1193     return getElementsByTagNameNS("*", name);
1194 }
1195  
1196 PassRefPtr<NodeList> Node::getElementsByTagNameNS(const String& namespaceURI, const String& localName)
1197 {
1198     if (localName.isNull())
1199         return 0;
1200
1201     String name = localName;
1202     if (document()->isHTMLDocument())
1203         name = localName.lower();
1204     return new TagNodeList(this, namespaceURI.isEmpty() ? nullAtom : AtomicString(namespaceURI), name);
1205 }
1206
1207 Document *Node::ownerDocument() const
1208 {
1209     Document *doc = document();
1210     return doc == this ? 0 : doc;
1211 }
1212
1213 bool Node::hasAttributes() const
1214 {
1215     return false;
1216 }
1217
1218 NamedAttrMap *Node::attributes() const
1219 {
1220     return 0;
1221 }
1222
1223 String Node::baseURI() const
1224 {
1225     Node* parent = parentNode();
1226     if (parent)
1227         return parent->baseURI();
1228
1229     return String();
1230 }
1231
1232 bool Node::isEqualNode(Node *other) const
1233 {
1234     if (!other)
1235         return false;
1236     
1237     if (nodeType() != other->nodeType())
1238         return false;
1239     
1240     if (nodeName() != other->nodeName())
1241         return false;
1242     
1243     if (localName() != other->localName())
1244         return false;
1245     
1246     if (namespaceURI() != other->namespaceURI())
1247         return false;
1248     
1249     if (prefix() != other->prefix())
1250         return false;
1251     
1252     if (nodeValue() != other->nodeValue())
1253         return false;
1254     
1255     NamedAttrMap *attrs = attributes();
1256     NamedAttrMap *otherAttrs = other->attributes();
1257     
1258     if (!attrs && otherAttrs)
1259         return false;
1260     
1261     if (attrs && !attrs->mapsEquivalent(otherAttrs))
1262         return false;
1263     
1264     Node *child = firstChild();
1265     Node *otherChild = other->firstChild();
1266     
1267     while (child) {
1268         if (!child->isEqualNode(otherChild))
1269             return false;
1270         
1271         child = child->nextSibling();
1272         otherChild = otherChild->nextSibling();
1273     }
1274     
1275     if (otherChild)
1276         return false;
1277     
1278     // FIXME: For DocumentType nodes we should check equality on
1279     // the entities and notations NamedNodeMaps as well.
1280     
1281     return true;
1282 }
1283
1284 bool Node::isDefaultNamespace(const String &namespaceURI) const
1285 {
1286     // Implemented according to
1287     // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms.html#isDefaultNamespaceAlgo
1288     
1289     switch (nodeType()) {
1290         case ELEMENT_NODE: {
1291             const Element *elem = static_cast<const Element *>(this);
1292             
1293             if (elem->prefix().isNull())
1294                 return elem->namespaceURI() == namespaceURI;
1295
1296             if (elem->hasAttributes()) {
1297                 NamedAttrMap *attrs = elem->attributes();
1298                 
1299                 for (unsigned i = 0; i < attrs->length(); i++) {
1300                     Attribute *attr = attrs->attributeItem(i);
1301                     
1302                     if (attr->localName() == "xmlns")
1303                         return attr->value() == namespaceURI;
1304                 }
1305             }
1306
1307             if (Element* ancestor = ancestorElement())
1308                 return ancestor->isDefaultNamespace(namespaceURI);
1309
1310             return false;
1311         }
1312         case DOCUMENT_NODE:
1313             return static_cast <const Document *>(this)->documentElement()->isDefaultNamespace(namespaceURI);
1314         case ENTITY_NODE:
1315         case NOTATION_NODE:
1316         case DOCUMENT_TYPE_NODE:
1317         case DOCUMENT_FRAGMENT_NODE:
1318             return false;
1319         case ATTRIBUTE_NODE: {
1320             const Attr *attr = static_cast<const Attr *>(this);
1321             if (attr->ownerElement())
1322                 return attr->ownerElement()->isDefaultNamespace(namespaceURI);
1323             return false;
1324         }
1325         default:
1326             if (Element* ancestor = ancestorElement())
1327                 return ancestor->isDefaultNamespace(namespaceURI);
1328             return false;
1329     }
1330 }
1331
1332 String Node::lookupPrefix(const String &namespaceURI) const
1333 {
1334     // Implemented according to
1335     // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms.html#lookupNamespacePrefixAlgo
1336     
1337     if (namespaceURI.isEmpty())
1338         return String();
1339     
1340     switch (nodeType()) {
1341         case ELEMENT_NODE:
1342             return lookupNamespacePrefix(namespaceURI, static_cast<const Element *>(this));
1343         case DOCUMENT_NODE:
1344             return static_cast<const Document *>(this)->documentElement()->lookupPrefix(namespaceURI);
1345         case ENTITY_NODE:
1346         case NOTATION_NODE:
1347         case DOCUMENT_FRAGMENT_NODE:
1348         case DOCUMENT_TYPE_NODE:
1349             return String();
1350         case ATTRIBUTE_NODE: {
1351             const Attr *attr = static_cast<const Attr *>(this);
1352             if (attr->ownerElement())
1353                 return attr->ownerElement()->lookupPrefix(namespaceURI);
1354             return String();
1355         }
1356         default:
1357             if (Element* ancestor = ancestorElement())
1358                 return ancestor->lookupPrefix(namespaceURI);
1359             return String();
1360     }
1361 }
1362
1363 String Node::lookupNamespaceURI(const String &prefix) const
1364 {
1365     // Implemented according to
1366     // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms.html#lookupNamespaceURIAlgo
1367     
1368     if (!prefix.isNull() && prefix.isEmpty())
1369         return String();
1370     
1371     switch (nodeType()) {
1372         case ELEMENT_NODE: {
1373             const Element *elem = static_cast<const Element *>(this);
1374             
1375             if (!elem->namespaceURI().isNull() && elem->prefix() == prefix)
1376                 return elem->namespaceURI();
1377             
1378             if (elem->hasAttributes()) {
1379                 NamedAttrMap *attrs = elem->attributes();
1380                 
1381                 for (unsigned i = 0; i < attrs->length(); i++) {
1382                     Attribute *attr = attrs->attributeItem(i);
1383                     
1384                     if (attr->prefix() == "xmlns" && attr->localName() == prefix) {
1385                         if (!attr->value().isEmpty())
1386                             return attr->value();
1387                         
1388                         return String();
1389                     } else if (attr->localName() == "xmlns" && prefix.isNull()) {
1390                         if (!attr->value().isEmpty())
1391                             return attr->value();
1392                         
1393                         return String();
1394                     }
1395                 }
1396             }
1397             if (Element* ancestor = ancestorElement())
1398                 return ancestor->lookupNamespaceURI(prefix);
1399             return String();
1400         }
1401         case DOCUMENT_NODE:
1402             return static_cast<const Document *>(this)->documentElement()->lookupNamespaceURI(prefix);
1403         case ENTITY_NODE:
1404         case NOTATION_NODE:
1405         case DOCUMENT_TYPE_NODE:
1406         case DOCUMENT_FRAGMENT_NODE:
1407             return String();
1408         case ATTRIBUTE_NODE: {
1409             const Attr *attr = static_cast<const Attr *>(this);
1410             
1411             if (attr->ownerElement())
1412                 return attr->ownerElement()->lookupNamespaceURI(prefix);
1413             else
1414                 return String();
1415         }
1416         default:
1417             if (Element* ancestor = ancestorElement())
1418                 return ancestor->lookupNamespaceURI(prefix);
1419             return String();
1420     }
1421 }
1422
1423 String Node::lookupNamespacePrefix(const String &_namespaceURI, const Element *originalElement) const
1424 {
1425     if (_namespaceURI.isNull())
1426         return String();
1427             
1428     if (originalElement->lookupNamespaceURI(prefix()) == _namespaceURI)
1429         return prefix();
1430     
1431     if (hasAttributes()) {
1432         NamedAttrMap *attrs = attributes();
1433         
1434         for (unsigned i = 0; i < attrs->length(); i++) {
1435             Attribute *attr = attrs->attributeItem(i);
1436             
1437             if (attr->prefix() == "xmlns" &&
1438                 attr->value() == _namespaceURI &&
1439                 originalElement->lookupNamespaceURI(attr->localName()) == _namespaceURI)
1440                 return attr->localName();
1441         }
1442     }
1443     
1444     if (Element* ancestor = ancestorElement())
1445         return ancestor->lookupNamespacePrefix(_namespaceURI, originalElement);
1446     return String();
1447 }
1448
1449 String Node::textContent(bool convertBRsToNewlines) const
1450 {
1451     switch (nodeType()) {
1452         case TEXT_NODE:
1453         case CDATA_SECTION_NODE:
1454         case COMMENT_NODE:
1455         case PROCESSING_INSTRUCTION_NODE:
1456             return nodeValue();
1457         
1458         case ELEMENT_NODE:
1459             if (hasTagName(brTag) && 
1460                 convertBRsToNewlines)
1461                 return "\n";
1462         case ATTRIBUTE_NODE:
1463         case ENTITY_NODE:
1464         case ENTITY_REFERENCE_NODE:
1465         case DOCUMENT_FRAGMENT_NODE: {
1466             String s = "";
1467         
1468             for (Node *child = firstChild(); child; child = child->nextSibling()) {
1469                 if (child->nodeType() == COMMENT_NODE || child->nodeType() == PROCESSING_INSTRUCTION_NODE)
1470                     continue;
1471             
1472                 s += child->textContent(convertBRsToNewlines);
1473             }
1474         
1475             return s;
1476         }
1477         
1478         case DOCUMENT_NODE:
1479         case DOCUMENT_TYPE_NODE:
1480         case NOTATION_NODE:
1481         default:
1482             return String();            
1483     }
1484 }
1485
1486 void Node::setTextContent(const String &text, ExceptionCode& ec)
1487 {           
1488     switch (nodeType()) {
1489         case TEXT_NODE:
1490         case CDATA_SECTION_NODE:
1491         case COMMENT_NODE:
1492         case PROCESSING_INSTRUCTION_NODE:
1493             setNodeValue(text, ec);
1494             break;
1495         case ELEMENT_NODE:
1496         case ATTRIBUTE_NODE:
1497         case ENTITY_NODE:
1498         case ENTITY_REFERENCE_NODE:
1499         case DOCUMENT_FRAGMENT_NODE: {
1500             ContainerNode *container = static_cast<ContainerNode *>(this);
1501             
1502             container->removeChildren();
1503             
1504             if (!text.isEmpty())
1505                 appendChild(document()->createTextNode(text), ec);
1506             break;
1507         }
1508         case DOCUMENT_NODE:
1509         case DOCUMENT_TYPE_NODE:
1510         case NOTATION_NODE:
1511         default:
1512             // Do nothing
1513             break;
1514     }
1515 }
1516
1517 Element* Node::ancestorElement() const
1518 {
1519     // In theory, there can be EntityReference nodes between elements, but this is currently not supported.
1520     for (Node* n = parentNode(); n; n = n->parentNode()) {
1521         if (n->isElementNode())
1522             return static_cast<Element*>(n);
1523     }
1524     return 0;
1525 }
1526
1527 bool Node::offsetInCharacters() const
1528 {
1529     return false;
1530 }
1531
1532 #ifndef NDEBUG
1533
1534 static void appendAttributeDesc(const Node* node, String& string, const QualifiedName& name, const char* attrDesc)
1535 {
1536     if (node->isElementNode()) {
1537         String attr = static_cast<const Element*>(node)->getAttribute(name);
1538         if (!attr.isEmpty()) {
1539             string += attrDesc;
1540             string += attr;
1541         }
1542     }
1543 }
1544
1545 void Node::showNode(const char* prefix) const
1546 {
1547     if (!prefix)
1548         prefix = "";
1549     if (isTextNode()) {
1550         String value = nodeValue();
1551         value.replace('\\', "\\\\");
1552         value.replace('\n', "\\n");
1553         fprintf(stderr, "%s%s\t%p \"%s\"\n", prefix, nodeName().utf8().data(), this, value.utf8().data());
1554     } else {
1555         String attrs = "";
1556         appendAttributeDesc(this, attrs, classAttr, " CLASS=");
1557         appendAttributeDesc(this, attrs, styleAttr, " STYLE=");
1558         fprintf(stderr, "%s%s\t%p%s\n", prefix, nodeName().utf8().data(), this, attrs.utf8().data());
1559     }
1560 }
1561
1562 void Node::showTreeForThis() const
1563 {
1564     showTreeAndMark(this, "*");
1565 }
1566
1567 void Node::showTreeAndMark(const Node* markedNode1, const char* markedLabel1, const Node* markedNode2, const char * markedLabel2) const
1568 {
1569     const Node* rootNode;
1570     const Node* node = this;
1571     while (node->parentNode() && !node->hasTagName(bodyTag))
1572         node = node->parentNode();
1573     rootNode = node;
1574         
1575     for (node = rootNode; node; node = node->traverseNextNode()) {
1576         if (node == markedNode1)
1577             fprintf(stderr, "%s", markedLabel1);
1578         if (node == markedNode2)
1579             fprintf(stderr, "%s", markedLabel2);
1580                         
1581         for (const Node* tmpNode = node; tmpNode && tmpNode != rootNode; tmpNode = tmpNode->parentNode())
1582             fprintf(stderr, "\t");
1583         node->showNode();
1584     }
1585 }
1586
1587 void Node::formatForDebugger(char* buffer, unsigned length) const
1588 {
1589     String result;
1590     String s;
1591     
1592     s = nodeName();
1593     if (s.length() == 0)
1594         result += "<none>";
1595     else
1596         result += s;
1597           
1598     strncpy(buffer, result.utf8().data(), length - 1);
1599 }
1600
1601 #endif
1602
1603 }
1604
1605 #ifndef NDEBUG
1606
1607 void showTree(const WebCore::Node* node)
1608 {
1609     if (node)
1610         node->showTreeForThis();
1611 }
1612
1613 #endif