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