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