LayoutTests:
[WebKit-https.git] / WebCore / html / HTMLParser.cpp
1 /*
2     This file is part of the KDE libraries
3
4     Copyright (C) 1997 Martin Jones (mjones@kde.org)
5               (C) 1997 Torben Weis (weis@kde.org)
6               (C) 1999,2001 Lars Knoll (knoll@kde.org)
7               (C) 2000,2001 Dirk Mueller (mueller@kde.org)
8     Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.
9
10     This library is free software; you can redistribute it and/or
11     modify it under the terms of the GNU Library General Public
12     License as published by the Free Software Foundation; either
13     version 2 of the License, or (at your option) any later version.
14
15     This library is distributed in the hope that it will be useful,
16     but WITHOUT ANY WARRANTY; without even the implied warranty of
17     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18     Library General Public License for more details.
19
20     You should have received a copy of the GNU Library General Public License
21     along with this library; see the file COPYING.LIB.  If not, write to
22     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
23     Boston, MA 02111-1307, USA.
24 */
25
26 #include "config.h"
27 #include "HTMLParser.h"
28
29 #include "CSSPropertyNames.h"
30 #include "CSSValueKeywords.h"
31 #include "Comment.h"
32 #include "DocumentFragment.h"
33 #include "Frame.h"
34 #include "HTMLBodyElement.h"
35 #include "HTMLCanvasElement.h"
36 #include "HTMLDivElement.h"
37 #include "HTMLDListElement.h"
38 #include "HTMLElementFactory.h"
39 #include "HTMLFormElement.h"
40 #include "HTMLHeadElement.h"
41 #include "HTMLHRElement.h"
42 #include "HTMLHtmlElement.h"
43 #include "HTMLIsIndexElement.h"
44 #include "HTMLMapElement.h"
45 #include "HTMLNames.h"
46 #include "HTMLTableCellElement.h"
47 #include "HTMLTableRowElement.h"
48 #include "HTMLTableSectionElement.h"
49 #include "HTMLTokenizer.h"
50 #include "LocalizedStrings.h"
51 #include "Text.h"
52
53 namespace WebCore {
54
55 using namespace HTMLNames;
56
57 const UChar nonBreakingSpace = 0xa0;
58
59 /**
60  * @internal
61  */
62
63 class HTMLStackElem
64 {
65 public:
66     HTMLStackElem(const AtomicString& t, int lvl, Node* n, bool r, HTMLStackElem* nx)
67         : tagName(t)
68         , level(lvl)
69         , strayTableContent(false)
70         , node(n)
71         , didRefNode(r)
72         , next(nx)
73     {
74     }
75
76     void derefNode()
77     {
78         if (didRefNode)
79             node->deref();
80     }
81
82     AtomicString tagName;
83     int level;
84     bool strayTableContent;
85     Node* node;
86     bool didRefNode;
87     HTMLStackElem* next;
88 };
89
90 /**
91  * @internal
92  *
93  * The parser parses tokenized input into the document, building up the
94  * document tree. If the document is wellformed, parsing it is
95  * straightforward.
96  * Unfortunately, people can't write wellformed HTML documents, so the parser
97  * has to be tolerant about errors.
98  *
99  * We have to take care of the following error conditions:
100  * 1. The element being added is explicitly forbidden inside some outer tag.
101  *    In this case we should close all tags up to the one, which forbids
102  *    the element, and add it afterwards.
103  * 2. We are not allowed to add the element directly. It could be, that
104  *    the person writing the document forgot some tag inbetween (or that the
105  *    tag inbetween is optional...) This could be the case with the following
106  *    tags: HTML HEAD BODY TBODY TR TD LI (did I forget any?)
107  * 3. We wan't to add a block element inside to an inline element. Close all
108  *    inline elements up to the next higher block element.
109  * 4. If this doesn't help close elements, until we are allowed to add the
110  *    element or ignore the tag.
111  *
112  */
113 HTMLParser::HTMLParser(Document* doc) 
114     : document(doc)
115     , current(0)
116     , didRefCurrent(false)
117     , blockStack(0)
118     , m_fragment(false)
119 {
120     reset();
121 }
122
123 HTMLParser::HTMLParser(DocumentFragment* frag)
124     : document(frag->document())
125     , current(0)
126     , didRefCurrent(false)
127     , blockStack(0)
128     , m_fragment(true)
129 {
130     reset();
131     setCurrent(frag);
132     inBody = true;
133 }
134
135 HTMLParser::~HTMLParser()
136 {
137     freeBlock();
138
139     setCurrent(0);
140 }
141
142 void HTMLParser::reset()
143 {
144     setCurrent(doc());
145
146     freeBlock();
147
148     inBody = false;
149     haveFrameSet = false;
150     haveContent = false;
151     inSelect = false;
152     inStrayTableContent = 0;
153     
154     form = 0;
155     map = 0;
156     head = 0;
157     end = false;
158     isindex = 0;
159     
160     discard_until = nullAtom;
161 }
162
163 void HTMLParser::setCurrent(Node* newCurrent) 
164 {
165     bool didRefNewCurrent = newCurrent && newCurrent != doc();
166     if (didRefNewCurrent) 
167         newCurrent->ref(); 
168     if (didRefCurrent) 
169         current->deref(); 
170     current = newCurrent;
171     didRefCurrent = didRefNewCurrent;
172 }
173
174 PassRefPtr<Node> HTMLParser::parseToken(Token *t)
175 {
176     if (!discard_until.isNull()) {
177         if (t->tagName == discard_until && !t->beginTag)
178             discard_until = nullAtom;
179
180         // do not skip </iframe>
181         if (!discard_until.isNull() || (current->localName() != t->tagName))
182             return 0;
183     }
184
185     // Apparently some sites use </br> instead of <br>.  Be compatible with IE and Firefox and treat this like <br>.
186     if (t->isCloseTag(brTag) && doc()->inCompatMode())
187         t->beginTag = true;
188
189     if (!t->beginTag) {
190         processCloseTag(t);
191         return 0;
192     }
193
194     // ignore spaces, if we're not inside a paragraph or other inline code
195     if (t->tagName == textAtom && t->text) {
196         if (inBody && !skipMode() && current->localName() != styleTag && current->localName() != titleTag && 
197             current->localName() != scriptTag && !t->text->containsOnlyWhitespace()) 
198             haveContent = true;
199     }
200
201     RefPtr<Node> n = getNode(t);
202     // just to be sure, and to catch currently unimplemented stuff
203     if (!n)
204         return 0;
205
206     // set attributes
207     if (n->isHTMLElement()) {
208         HTMLElement* e = static_cast<HTMLElement*>(n.get());
209         e->setAttributeMap(t->attrs.get());
210
211         // take care of optional close tags
212         if (e->endTagRequirement() == TagStatusOptional)
213             popBlock(t->tagName);
214             
215         if (isHeaderTag(t->tagName))
216             // Do not allow two header tags to be nested if the intervening tags are inlines.
217             popNestedHeaderTag();
218     }
219
220     if (!insertNode(n.get(), t->flat)) {
221         // we couldn't insert the node
222
223         if (n->isElementNode()) {
224             Element* e = static_cast<Element*>(n.get());
225             e->setAttributeMap(0);
226         }
227
228         if (map == n)
229             map = 0;
230
231         if (form == n)
232             form = 0;
233
234         if (head == n)
235             head = 0;
236
237         return 0;
238     }
239     return n;
240 }
241
242 static bool isTableSection(Node* n)
243 {
244     return n->hasTagName(tbodyTag) || n->hasTagName(tfootTag) || n->hasTagName(theadTag);
245 }
246
247 static bool isTablePart(Node* n)
248 {
249     return n->hasTagName(trTag) || n->hasTagName(tdTag) || n->hasTagName(thTag) ||
250            isTableSection(n);
251 }
252
253 static bool isTableRelated(Node* n)
254 {
255     return n->hasTagName(tableTag) || isTablePart(n);
256 }
257
258 bool HTMLParser::insertNode(Node *n, bool flat)
259 {
260     RefPtr<Node> protectNode(n);
261
262     const AtomicString& localName = n->localName();
263     int tagPriority = n->isHTMLElement() ? static_cast<HTMLElement*>(n)->tagPriority() : 0;
264         
265     // let's be stupid and just try to insert it.
266     // this should work if the document is well-formed
267     Node* newNode = current->addChild(n);
268     if (!newNode)
269         return handleError(n, flat, localName, tagPriority); // Try to handle the error.
270
271     // don't push elements without end tags (e.g., <img>) on the stack
272     bool parentAttached = current->attached();
273     if (tagPriority > 0 && !flat) {
274         pushBlock(localName, tagPriority);
275         if (newNode == current)
276             popBlock(localName);
277         else {
278             // The pushBlock function transfers ownership of current to the block stack
279             // so we're guaranteed that didRefCurrent is false. The code below is an
280             // optimized version of setCurrent that takes advantage of that fact and also
281             // assumes that newNode is neither 0 nor a pointer to the document.
282             ASSERT(!didRefCurrent);
283             newNode->ref(); 
284             current = newNode;
285             didRefCurrent = true;
286         }
287         if (parentAttached && !n->attached() && !m_fragment)
288             n->attach();
289     } else {
290         if (parentAttached && !n->attached() && !m_fragment)
291             n->attach();
292         n->closeRenderer();
293     }
294
295     return true;
296 }
297
298 bool HTMLParser::handleError(Node* n, bool flat, const AtomicString& localName, int tagPriority)
299 {
300     // Error handling code.  This is just ad hoc handling of specific parent/child combinations.
301     HTMLElement *e;
302     bool handled = false;
303
304     // 1. Check out the element's tag name to decide how to deal with errors.
305     if (n->isTextNode()) {
306         if (current->hasTagName(selectTag))
307             return false;
308     } else if (n->isHTMLElement()) {
309         HTMLElement* h = static_cast<HTMLElement*>(n);
310         if (h->hasLocalName(trTag) || h->hasLocalName(thTag) || h->hasLocalName(tdTag)) {
311             if (inStrayTableContent && !isTableRelated(current)) {
312                 // pop out to the nearest enclosing table-related tag.
313                 while (blockStack && !isTableRelated(current))
314                     popOneBlock();
315                 return insertNode(n);
316             }
317         } else if (h->hasLocalName(headTag)) {
318             if (!current->isDocumentNode() && !current->hasTagName(htmlTag))
319                 return false;
320         } else if (h->hasLocalName(metaTag) || h->hasLocalName(linkTag) || h->hasLocalName(baseTag)) {
321             if (!head)
322                 createHead();
323             if (head) {
324                 if (head->addChild(n)) {
325                     if (!n->attached() && !m_fragment)
326                         n->attach();
327                     return true;
328                 } else
329                     return false;
330             }
331         } else if (h->hasLocalName(htmlTag)) {
332             if (!current->isDocumentNode() ) {
333                 if (doc()->firstChild()->hasTagName(htmlTag)) {
334                     // we have another <HTML> element.... apply attributes to existing one
335                     // make sure we don't overwrite already existing attributes
336                     NamedAttrMap *map = static_cast<Element*>(n)->attributes(true);
337                     Element *existingHTML = static_cast<Element*>(doc()->firstChild());
338                     NamedAttrMap *bmap = existingHTML->attributes(false);
339                     for (unsigned l = 0; map && l < map->length(); ++l) {
340                         Attribute* it = map->attributeItem(l);
341                         if (!bmap->getAttributeItem(it->name()))
342                             existingHTML->setAttribute(it->name(), it->value());
343                     }
344                 }
345                 return false;
346             }
347         } else if (h->hasLocalName(titleTag) || h->hasLocalName(styleTag)) {
348             if (!head)
349                 createHead();
350             if (head) {
351                 Node* newNode = head->addChild(n);
352                 if (!newNode) {
353                     setSkipMode(h->tagQName());
354                     return false;
355                 }
356                 pushBlock(localName, tagPriority);
357                 setCurrent(newNode);
358                 if (!n->attached() && !m_fragment)
359                     n->attach();
360                 return true;
361             }
362             if (inBody) {
363                 setSkipMode(h->tagQName());
364                 return false;
365             }
366         } else if (h->hasLocalName(bodyTag)) {
367             if (inBody && doc()->body()) {
368                 // we have another <BODY> element.... apply attributes to existing one
369                 // make sure we don't overwrite already existing attributes
370                 // some sites use <body bgcolor=rightcolor>...<body bgcolor=wrongcolor>
371                 NamedAttrMap *map = static_cast<Element*>(n)->attributes(true);
372                 Element *existingBody = doc()->body();
373                 NamedAttrMap *bmap = existingBody->attributes(false);
374                 for (unsigned l = 0; map && l < map->length(); ++l) {
375                     Attribute* it = map->attributeItem(l);
376                     if (!bmap->getAttributeItem(it->name()))
377                         existingBody->setAttribute(it->name(), it->value());
378                 }
379                 return false;
380             }
381             else if (!current->isDocumentNode())
382                 return false;
383         } else if (h->hasLocalName(inputTag)) {
384             if (equalIgnoringCase(h->getAttribute(typeAttr), "hidden") && form) {
385                 form->addChild(n);
386                 if (!n->attached() && !m_fragment)
387                     n->attach();
388                 return true;
389             }
390         } else if (h->hasLocalName(ddTag) || h->hasLocalName(dtTag)) {
391             e = new HTMLDListElement(document);
392             if (insertNode(e)) {
393                 insertNode(n);
394                 return true;
395             }
396         } else if (h->hasLocalName(areaTag)) {
397             if (map) {
398                 map->addChild(n);
399                 if (!n->attached() && !m_fragment)
400                     n->attach();
401                 handled = true;
402                 return true;
403             }
404             return false;
405         } else if (h->hasLocalName(captionTag)) {
406             if (isTablePart(current)) {
407                 Node* tsection = current;
408                 if (current->hasTagName(trTag))
409                     tsection = current->parent();
410                 else if (current->hasTagName(tdTag) || current->hasTagName(thTag))
411                     tsection = current->parent()->parent();
412                 Node* table = tsection->parent();
413                 ExceptionCode ec = 0;
414                 table->insertBefore(n, tsection, ec);
415                 pushBlock(localName, tagPriority);
416                 setCurrent(n);
417                 inStrayTableContent++;
418                 blockStack->strayTableContent = true;
419                 return true;
420             }
421         } else if (h->hasLocalName(theadTag) || h->hasLocalName(tbodyTag) ||
422                    h->hasLocalName(tfootTag) || h->hasLocalName(colgroupTag)) {
423             if (isTableRelated(current)) {
424                 while (blockStack && isTablePart(current))
425                     popOneBlock();
426                 return insertNode(n);
427             }
428         }
429     }
430     
431     // 2. Next we examine our currently active element to do some further error handling.
432     if (current->isHTMLElement()) {
433         HTMLElement* h = static_cast<HTMLElement*>(current);
434         const AtomicString& currentTagName = current->localName();
435         if (h->hasLocalName(htmlTag)) {
436             HTMLElement* elt = n->isHTMLElement() ? static_cast<HTMLElement*>(n) : 0;
437             if (elt && (elt->hasLocalName(scriptTag) || elt->hasLocalName(styleTag) ||
438                 elt->hasLocalName(metaTag) || elt->hasLocalName(linkTag) ||
439                 elt->hasLocalName(objectTag) || elt->hasLocalName(embedTag) ||
440                 elt->hasLocalName(titleTag) || elt->hasLocalName(isindexTag) ||
441                 elt->hasLocalName(baseTag))) {
442                 if (!head) {
443                     head = new HTMLHeadElement(document);
444                     e = head;
445                     insertNode(e);
446                     handled = true;
447                 }
448             } else {
449                 if (n->isTextNode()) {
450                     Text *t = static_cast<Text *>(n);
451                     if (t->containsOnlyWhitespace())
452                         return false;
453                 }
454                 if (!haveFrameSet) {
455                     e = new HTMLBodyElement(document);
456                     startBody();
457                     insertNode(e);
458                     handled = true;
459                 }
460             }
461         } else if (h->hasLocalName(headTag)) {
462             if (n->hasTagName(htmlTag))
463                 return false;
464             else {
465                 // This means the body starts here...
466                 if (!haveFrameSet) {
467                     popBlock(currentTagName);
468                     e = new HTMLBodyElement(document);
469                     startBody();
470                     insertNode(e);
471                     handled = true;
472                 }
473             }
474         } else if (h->hasLocalName(addressTag) || h->hasLocalName(dlTag) || h->hasLocalName(dtTag)
475                    || h->hasLocalName(fontTag) || h->hasLocalName(styleTag) || h->hasLocalName(titleTag)) {
476             popBlock(currentTagName);
477             handled = true;
478         } else if (h->hasLocalName(captionTag)) {
479             // Illegal content in a caption. Close the caption and try again.
480             popBlock(currentTagName);
481             if (isTablePart(n))
482                 return insertNode(n, flat);
483         } else if (h->hasLocalName(tableTag) || h->hasLocalName(trTag) || isTableSection(h)) {
484             if (n->hasTagName(tableTag)) {
485                 popBlock(localName); // end the table
486                 handled = true;      // ...and start a new one
487             } else {
488                 bool possiblyMoveStrayContent = true;
489                 ExceptionCode ec = 0;
490                 if (n->isTextNode()) {
491                     Text *t = static_cast<Text *>(n);
492                     if (t->containsOnlyWhitespace())
493                         return false;
494                     StringImpl *i = t->string();
495                     unsigned int pos = 0;
496                     while (pos < i->length() && ((*i)[pos] == ' ' || (*i)[pos] == nonBreakingSpace))
497                         pos++;
498                     if (pos == i->length())
499                         possiblyMoveStrayContent = false;
500                 }
501                 if (possiblyMoveStrayContent) {
502                     Node *node = current;
503                     Node *parent = node->parentNode();
504                     // A script may have removed the current node's parent from the DOM
505                     // http://bugzilla.opendarwin.org/show_bug.cgi?id=7137
506                     // FIXME: we should do real recovery here and re-parent with the correct node.
507                     if (!parent)
508                         return false;
509                     Node *grandparent = parent->parentNode();
510
511                     if (n->isTextNode() ||
512                         (h->hasLocalName(trTag) &&
513                          isTableSection(parent) && grandparent->hasTagName(tableTag)) ||
514                          ((!n->hasTagName(tdTag) && !n->hasTagName(thTag) &&
515                            !n->hasTagName(formTag) && !n->hasTagName(scriptTag)) && isTableSection(node) &&
516                          parent->hasTagName(tableTag))) {
517                         node = (node->hasTagName(tableTag)) ? node :
518                                 ((node->hasTagName(trTag)) ? grandparent : parent);
519                         Node *parent = node->parentNode();
520                         if (!parent)
521                             return false;
522                         parent->insertBefore(n, node, ec);
523                         if (!ec) {
524                             if (n->isHTMLElement() && tagPriority > 0 && 
525                                 !flat && static_cast<HTMLElement*>(n)->endTagRequirement() != TagStatusForbidden)
526                             {
527                                 pushBlock(localName, tagPriority);
528                                 setCurrent(n);
529                                 inStrayTableContent++;
530                                 blockStack->strayTableContent = true;
531                             }
532                             return true;
533                         }
534                     }
535
536                     if (!ec) {
537                         if (current->hasTagName(trTag))
538                             e = new HTMLTableCellElement(tdTag, document);
539                         else if (current->hasTagName(tableTag))
540                             e = new HTMLTableSectionElement(tbodyTag, document, true); // implicit 
541                         else
542                             e = new HTMLTableRowElement(document);
543                         
544                         insertNode(e);
545                         handled = true;
546                     }
547                 }
548             }
549         } else if (h->hasLocalName(objectTag)) {
550             setSkipMode(objectTag);
551             return false;
552         } else if (h->hasLocalName(ulTag) || h->hasLocalName(olTag) ||
553                  h->hasLocalName(dirTag) || h->hasLocalName(menuTag)) {
554             e = new HTMLDivElement(document);
555             insertNode(e);
556             handled = true;
557         } else if (h->hasLocalName(selectTag)) {
558             if (isInline(n))
559                 return false;
560         } else if (h->hasLocalName(pTag) || isHeaderTag(currentTagName)) {
561             if (!isInline(n)) {
562                 popBlock(currentTagName);
563                 handled = true;
564             }
565         } else if (h->hasLocalName(optionTag) || h->hasLocalName(optgroupTag)) {
566             if (localName == optgroupTag) {
567                 popBlock(currentTagName);
568                 handled = true;
569             } else if (localName == selectTag) {
570                 // IE treats a nested select as </select>. Let's do the same
571                 popBlock(localName);
572             }
573         } else if (h->hasLocalName(colgroupTag)) {
574             if (!n->isTextNode()) {
575                 popBlock(currentTagName);
576                 handled = true;
577             }
578         } else if (!h->hasLocalName(bodyTag)) {
579             if (isInline(current)) {
580                 popInlineBlocks();
581                 handled = true;
582             }
583         }
584     } else if (current->isDocumentNode()) {
585         if (current->firstChild() == 0 || !current->firstChild()->isHTMLElement()) {
586             e = new HTMLHtmlElement(document);
587             insertNode(e);
588             handled = true;
589         }
590     }
591
592     // 3. If we couldn't handle the error, just return false and attempt to error-correct again.
593     if (!handled)
594         return false;
595     return insertNode(n);
596 }
597
598 typedef bool (HTMLParser::*CreateErrorCheckFunc)(Token* t, RefPtr<Node>&);
599 typedef HashMap<AtomicStringImpl*, CreateErrorCheckFunc> FunctionMap;
600
601 bool HTMLParser::textCreateErrorCheck(Token* t, RefPtr<Node>& result)
602 {
603     result = new Text(document, t->text.get());
604     return false;
605 }
606
607 bool HTMLParser::commentCreateErrorCheck(Token* t, RefPtr<Node>& result)
608 {
609     result = new Comment(document, t->text.get());
610     return false;
611 }
612
613 bool HTMLParser::headCreateErrorCheck(Token* t, RefPtr<Node>& result)
614 {
615     if (!head || current->localName() == htmlTag) {
616         head = new HTMLHeadElement(document);
617         result = head;
618     }
619     return false;
620 }
621
622 bool HTMLParser::bodyCreateErrorCheck(Token* t, RefPtr<Node>& result)
623 {
624     // body no longer allowed if we have a frameset
625     if (haveFrameSet)
626         return false;
627     popBlock(headTag);
628     startBody();
629     return true;
630 }
631
632 bool HTMLParser::framesetCreateErrorCheck(Token* t, RefPtr<Node>& result)
633 {
634     popBlock(headTag);
635     if (inBody && !haveFrameSet && !haveContent) {
636         popBlock(bodyTag);
637         // ### actually for IE document.body returns the now hidden "body" element
638         // we can't implement that behaviour now because it could cause too many
639         // regressions and the headaches are not worth the work as long as there is
640         // no site actually relying on that detail (Dirk)
641         if (doc()->body())
642             doc()->body()->setAttribute(styleAttr, "display:none");
643         inBody = false;
644     }
645     if ((haveContent || haveFrameSet) && current->localName() == htmlTag)
646         return false;
647     haveFrameSet = true;
648     startBody();
649     return true;
650 }
651
652 bool HTMLParser::iframeCreateErrorCheck(Token* t, RefPtr<Node>& result)
653 {
654     // a bit of a special case, since the frame is inlined
655     setSkipMode(iframeTag);
656     return true;
657 }
658
659 bool HTMLParser::formCreateErrorCheck(Token* t, RefPtr<Node>& result)
660 {
661     // Only create a new form if we're not already inside one.
662     // This is consistent with other browsers' behavior.
663     if (!form) {
664         form = new HTMLFormElement(document);
665         result = form;
666     }
667     return false;
668 }
669
670 bool HTMLParser::isindexCreateErrorCheck(Token* t, RefPtr<Node>& result)
671 {
672     Node *n = handleIsindex(t);
673     if (!inBody) {
674         isindex = n;
675     } else {
676         t->flat = true;
677         result = n;
678     }
679     return false;
680 }
681
682 bool HTMLParser::selectCreateErrorCheck(Token* t, RefPtr<Node>& result)
683 {
684     inSelect = true;
685     return true;
686 }
687
688 bool HTMLParser::ddCreateErrorCheck(Token* t, RefPtr<Node>& result)
689 {
690     popBlock(dtTag);
691     popBlock(ddTag);
692     return true;
693 }
694
695 bool HTMLParser::dtCreateErrorCheck(Token* t, RefPtr<Node>& result)
696 {
697     popBlock(ddTag);
698     popBlock(dtTag);
699     return true;
700 }
701
702 bool HTMLParser::nestedCreateErrorCheck(Token* t, RefPtr<Node>& result)
703 {
704     popBlock(t->tagName);
705     return true;
706 }
707
708 bool HTMLParser::nestedStyleCreateErrorCheck(Token* t, RefPtr<Node>& result)
709 {
710     return allowNestedRedundantTag(t->tagName);
711 }
712
713 bool HTMLParser::tableCellCreateErrorCheck(Token* t, RefPtr<Node>& result)
714 {
715     popBlock(tdTag);
716     popBlock(thTag);
717     return true;
718 }
719
720 bool HTMLParser::tableSectionCreateErrorCheck(Token* t, RefPtr<Node>& result)
721 {
722     popBlock(theadTag);
723     popBlock(tbodyTag);
724     popBlock(tfootTag);
725     return true;
726 }
727
728 bool HTMLParser::noembedCreateErrorCheck(Token* t, RefPtr<Node>& result)
729 {
730     setSkipMode(noembedTag);
731     return true;
732 }
733
734 bool HTMLParser::noframesCreateErrorCheck(Token* t, RefPtr<Node>& result)
735 {
736     setSkipMode(noframesTag);
737     return true;
738 }
739
740 bool HTMLParser::noscriptCreateErrorCheck(Token* t, RefPtr<Node>& result)
741 {
742     if (!m_fragment && document->frame() && document->frame()->jScriptEnabled())
743         setSkipMode(noscriptTag);
744     return true;
745 }
746
747 bool HTMLParser::mapCreateErrorCheck(Token* t, RefPtr<Node>& result)
748 {
749     map = new HTMLMapElement(document);
750     result = map;
751     return false;
752 }
753
754 bool HTMLParser::canvasCreateErrorCheck(Token* t, RefPtr<Node>& result)
755 {
756     if (!m_fragment && document->frame() && document->frame()->jScriptEnabled())
757         setSkipMode(canvasTag);
758     return true;
759 }
760
761 PassRefPtr<Node> HTMLParser::getNode(Token* t)
762 {
763     // Init our error handling table.
764     static FunctionMap gFunctionMap;
765     if (gFunctionMap.isEmpty()) {
766         gFunctionMap.set(aTag.localName().impl(), &HTMLParser::nestedCreateErrorCheck);
767         gFunctionMap.set(bTag.localName().impl(), &HTMLParser::nestedStyleCreateErrorCheck);
768         gFunctionMap.set(bigTag.localName().impl(), &HTMLParser::nestedStyleCreateErrorCheck);
769         gFunctionMap.set(bodyTag.localName().impl(), &HTMLParser::bodyCreateErrorCheck);
770         gFunctionMap.set(buttonTag.localName().impl(), &HTMLParser::nestedCreateErrorCheck);
771         gFunctionMap.set(canvasTag.localName().impl(), &HTMLParser::canvasCreateErrorCheck);
772         gFunctionMap.set(commentAtom.impl(), &HTMLParser::commentCreateErrorCheck);
773         gFunctionMap.set(ddTag.localName().impl(), &HTMLParser::ddCreateErrorCheck);
774         gFunctionMap.set(dtTag.localName().impl(), &HTMLParser::dtCreateErrorCheck);
775         gFunctionMap.set(formTag.localName().impl(), &HTMLParser::formCreateErrorCheck);
776         gFunctionMap.set(framesetTag.localName().impl(), &HTMLParser::framesetCreateErrorCheck);
777         gFunctionMap.set(headTag.localName().impl(), &HTMLParser::headCreateErrorCheck);
778         gFunctionMap.set(iTag.localName().impl(), &HTMLParser::nestedStyleCreateErrorCheck);
779         gFunctionMap.set(iframeTag.localName().impl(), &HTMLParser::iframeCreateErrorCheck);
780         gFunctionMap.set(isindexTag.localName().impl(), &HTMLParser::isindexCreateErrorCheck);
781         gFunctionMap.set(liTag.localName().impl(), &HTMLParser::nestedCreateErrorCheck);
782         gFunctionMap.set(mapTag.localName().impl(), &HTMLParser::mapCreateErrorCheck);
783         gFunctionMap.set(nobrTag.localName().impl(), &HTMLParser::nestedCreateErrorCheck);
784         gFunctionMap.set(noembedTag.localName().impl(), &HTMLParser::noembedCreateErrorCheck);
785         gFunctionMap.set(noframesTag.localName().impl(), &HTMLParser::noframesCreateErrorCheck);
786         gFunctionMap.set(noscriptTag.localName().impl(), &HTMLParser::noscriptCreateErrorCheck);
787         gFunctionMap.set(sTag.localName().impl(), &HTMLParser::nestedStyleCreateErrorCheck);
788         gFunctionMap.set(selectTag.localName().impl(), &HTMLParser::selectCreateErrorCheck);
789         gFunctionMap.set(smallTag.localName().impl(), &HTMLParser::nestedStyleCreateErrorCheck);
790         gFunctionMap.set(strikeTag.localName().impl(), &HTMLParser::nestedStyleCreateErrorCheck);
791         gFunctionMap.set(tbodyTag.localName().impl(), &HTMLParser::tableSectionCreateErrorCheck);
792         gFunctionMap.set(tdTag.localName().impl(), &HTMLParser::tableCellCreateErrorCheck);
793         gFunctionMap.set(textAtom.impl(), &HTMLParser::textCreateErrorCheck);
794         gFunctionMap.set(tfootTag.localName().impl(), &HTMLParser::tableSectionCreateErrorCheck);
795         gFunctionMap.set(thTag.localName().impl(), &HTMLParser::tableCellCreateErrorCheck);
796         gFunctionMap.set(theadTag.localName().impl(), &HTMLParser::tableSectionCreateErrorCheck);
797         gFunctionMap.set(trTag.localName().impl(), &HTMLParser::nestedCreateErrorCheck);
798         gFunctionMap.set(ttTag.localName().impl(), &HTMLParser::nestedStyleCreateErrorCheck);
799         gFunctionMap.set(uTag.localName().impl(), &HTMLParser::nestedStyleCreateErrorCheck);
800         gFunctionMap.set(wbrTag.localName().impl(), &HTMLParser::nestedCreateErrorCheck);
801     }
802
803     bool proceed = true;
804     RefPtr<Node> result;
805     if (CreateErrorCheckFunc errorCheckFunc = gFunctionMap.get(t->tagName.impl()))
806         proceed = (this->*errorCheckFunc)(t, result);
807     if (proceed)
808         result = HTMLElementFactory::createHTMLElement(t->tagName, doc(), form);
809     return result.release();
810 }
811
812 #define MAX_REDUNDANT 20
813
814 bool HTMLParser::allowNestedRedundantTag(const AtomicString& _tagName)
815 {
816     // www.liceo.edu.mx is an example of a site that achieves a level of nesting of
817     // about 1500 tags, all from a bunch of <b>s.  We will only allow at most 20
818     // nested tags of the same type before just ignoring them all together.
819     int i = 0;
820     for (HTMLStackElem* curr = blockStack;
821          i < MAX_REDUNDANT && curr && curr->tagName == _tagName;
822          curr = curr->next, i++);
823     return i != MAX_REDUNDANT;
824 }
825
826 void HTMLParser::processCloseTag(Token *t)
827 {
828     // Support for really broken html.
829     // we never close the body tag, since some stupid web pages close it before the actual end of the doc.
830     // let's rely on the end() call to close things.
831     if (t->tagName == htmlTag || t->tagName == bodyTag)
832         return;
833     
834     if (t->tagName == formTag)
835         form = 0;
836     else if (t->tagName == mapTag)
837         map = 0;
838     else if (t->tagName == selectTag)
839         inSelect = false;
840         
841     HTMLStackElem* oldElem = blockStack;
842     popBlock(t->tagName);
843     if (oldElem == blockStack && t->tagName == pTag) {
844         // We encountered a stray </p>.  Amazingly Gecko, WinIE, and MacIE all treat
845         // this as a valid break, i.e., <p></p>.  So go ahead and make the empty
846         // paragraph.
847         t->beginTag = true;
848         parseToken(t);
849         popBlock(t->tagName);
850     }
851 }
852
853 bool HTMLParser::isHeaderTag(const AtomicString& tagName)
854 {
855     static HashSet<AtomicStringImpl*> headerTags;
856     if (headerTags.isEmpty()) {
857         headerTags.add(h1Tag.localName().impl());
858         headerTags.add(h2Tag.localName().impl());
859         headerTags.add(h3Tag.localName().impl());
860         headerTags.add(h4Tag.localName().impl());
861         headerTags.add(h5Tag.localName().impl());
862         headerTags.add(h6Tag.localName().impl());
863     }
864     
865     return headerTags.contains(tagName.impl());
866 }
867
868 void HTMLParser::popNestedHeaderTag()
869 {
870     // This function only cares about checking for nested headers that have only inlines in between them.
871     Node* currNode = current;
872     for (HTMLStackElem* curr = blockStack; curr; curr = curr->next) {
873         if (isHeaderTag(curr->tagName)) {
874             popBlock(curr->tagName);
875             return;
876         }
877         if (currNode && !isInline(currNode))
878             return;
879         currNode = curr->node;
880     }
881 }
882
883 bool HTMLParser::isInline(Node* node) const
884 {
885     if (node->isTextNode())
886         return true;
887
888     if (node->isHTMLElement()) {
889         HTMLElement* e = static_cast<HTMLElement*>(node);
890         if (e->hasLocalName(aTag) || e->hasLocalName(fontTag) || e->hasLocalName(ttTag) ||
891             e->hasLocalName(uTag) || e->hasLocalName(bTag) || e->hasLocalName(iTag) ||
892             e->hasLocalName(sTag) || e->hasLocalName(strikeTag) || e->hasLocalName(bigTag) ||
893             e->hasLocalName(smallTag) || e->hasLocalName(emTag) || e->hasLocalName(strongTag) ||
894             e->hasLocalName(dfnTag) || e->hasLocalName(codeTag) || e->hasLocalName(sampTag) ||
895             e->hasLocalName(kbdTag) || e->hasLocalName(varTag) || e->hasLocalName(citeTag) ||
896             e->hasLocalName(abbrTag) || e->hasLocalName(acronymTag) || e->hasLocalName(subTag) ||
897             e->hasLocalName(supTag) || e->hasLocalName(spanTag) || e->hasLocalName(nobrTag) ||
898             e->hasLocalName(wbrTag) || e->hasLocalName(noframesTag) || e->hasLocalName(nolayerTag) ||
899             e->hasLocalName(noembedTag) || (e->hasLocalName(noscriptTag) && !m_fragment && document->frame() && document->frame()->jScriptEnabled()))
900             return true;
901     }
902     
903     return false;
904 }
905
906 bool HTMLParser::isResidualStyleTag(const AtomicString& tagName)
907 {
908     static HashSet<AtomicStringImpl*> residualStyleTags;
909     if (residualStyleTags.isEmpty()) {
910         residualStyleTags.add(aTag.localName().impl());
911         residualStyleTags.add(fontTag.localName().impl());
912         residualStyleTags.add(ttTag.localName().impl());
913         residualStyleTags.add(uTag.localName().impl());
914         residualStyleTags.add(bTag.localName().impl());
915         residualStyleTags.add(iTag.localName().impl());
916         residualStyleTags.add(sTag.localName().impl());
917         residualStyleTags.add(strikeTag.localName().impl());
918         residualStyleTags.add(bigTag.localName().impl());
919         residualStyleTags.add(smallTag.localName().impl());
920         residualStyleTags.add(emTag.localName().impl());
921         residualStyleTags.add(strongTag.localName().impl());
922         residualStyleTags.add(dfnTag.localName().impl());
923         residualStyleTags.add(codeTag.localName().impl());
924         residualStyleTags.add(sampTag.localName().impl());
925         residualStyleTags.add(kbdTag.localName().impl());
926         residualStyleTags.add(varTag.localName().impl());
927         residualStyleTags.add(nobrTag.localName().impl());
928         residualStyleTags.add(wbrTag.localName().impl());
929     }
930     
931     return residualStyleTags.contains(tagName.impl());
932 }
933
934 bool HTMLParser::isAffectedByResidualStyle(const AtomicString& tagName)
935 {
936     if (isResidualStyleTag(tagName))
937         return true;
938
939     static HashSet<AtomicStringImpl*> affectedBlockTags;
940     if (affectedBlockTags.isEmpty()) {
941         affectedBlockTags.add(addressTag.localName().impl());
942         affectedBlockTags.add(blockquoteTag.localName().impl());
943         affectedBlockTags.add(centerTag.localName().impl());
944         affectedBlockTags.add(ddTag.localName().impl());
945         affectedBlockTags.add(divTag.localName().impl());
946         affectedBlockTags.add(dlTag.localName().impl());
947         affectedBlockTags.add(dtTag.localName().impl());
948         affectedBlockTags.add(formTag.localName().impl());
949         affectedBlockTags.add(h1Tag.localName().impl());
950         affectedBlockTags.add(h2Tag.localName().impl());
951         affectedBlockTags.add(h3Tag.localName().impl());
952         affectedBlockTags.add(h4Tag.localName().impl());
953         affectedBlockTags.add(h5Tag.localName().impl());
954         affectedBlockTags.add(h6Tag.localName().impl());
955         affectedBlockTags.add(liTag.localName().impl());
956         affectedBlockTags.add(listingTag.localName().impl());
957         affectedBlockTags.add(olTag.localName().impl());
958         affectedBlockTags.add(pTag.localName().impl());
959         affectedBlockTags.add(preTag.localName().impl());
960         affectedBlockTags.add(ulTag.localName().impl());
961     }
962     
963     return affectedBlockTags.contains(tagName.impl());
964 }
965
966 void HTMLParser::handleResidualStyleCloseTagAcrossBlocks(HTMLStackElem* elem)
967 {
968     // Find the element that crosses over to a higher level.   For now, if there is more than
969     // one, we will just give up and not attempt any sort of correction.  It's highly unlikely that
970     // there will be more than one, since <p> tags aren't allowed to be nested.
971     ExceptionCode ec = 0;
972     HTMLStackElem* curr = blockStack;
973     HTMLStackElem* maxElem = 0;
974     HTMLStackElem* prev = 0;
975     HTMLStackElem* prevMaxElem = 0;
976     while (curr && curr != elem) {
977         if (curr->level > elem->level) {
978             if (maxElem)
979                 return;
980             maxElem = curr;
981             prevMaxElem = prev;
982         }
983
984         prev = curr;
985         curr = curr->next;
986     }
987
988     if (!curr || !maxElem || !isAffectedByResidualStyle(maxElem->tagName)) return;
989
990     Node* residualElem = prev->node;
991     Node* blockElem = prevMaxElem ? prevMaxElem->node : current;
992     Node* parentElem = elem->node;
993
994     // Check to see if the reparenting that is going to occur is allowed according to the DOM.
995     // FIXME: We should either always allow it or perform an additional fixup instead of
996     // just bailing here.
997     // Example: <p><font><center>blah</font></center></p> isn't doing a fixup right now.
998     if (!parentElem->childAllowed(blockElem))
999         return;
1000     
1001     if (maxElem->node->parentNode() != elem->node) {
1002         // Walk the stack and remove any elements that aren't residual style tags.  These
1003         // are basically just being closed up.  Example:
1004         // <font><span>Moo<p>Goo</font></p>.
1005         // In the above example, the <span> doesn't need to be reopened.  It can just close.
1006         HTMLStackElem* currElem = maxElem->next;
1007         HTMLStackElem* prevElem = maxElem;
1008         while (currElem != elem) {
1009             HTMLStackElem* nextElem = currElem->next;
1010             if (!isResidualStyleTag(currElem->tagName)) {
1011                 prevElem->next = nextElem;
1012                 prevElem->derefNode();
1013                 prevElem->node = currElem->node;
1014                 prevElem->didRefNode = currElem->didRefNode;
1015                 delete currElem;
1016             }
1017             else
1018                 prevElem = currElem;
1019             currElem = nextElem;
1020         }
1021         
1022         // We have to reopen residual tags in between maxElem and elem.  An example of this case is:
1023         // <font><i>Moo<p>Foo</font>.
1024         // In this case, we need to transform the part before the <p> into:
1025         // <font><i>Moo</i></font><i>
1026         // so that the <i> will remain open.  This involves the modification of elements
1027         // in the block stack.
1028         // This will also affect how we ultimately reparent the block, since we want it to end up
1029         // under the reopened residual tags (e.g., the <i> in the above example.)
1030         RefPtr<Node> prevNode = 0;
1031         currElem = maxElem;
1032         while (currElem->node != residualElem) {
1033             if (isResidualStyleTag(currElem->node->localName())) {
1034                 // Create a clone of this element.
1035                 // We call release to get a raw pointer since we plan to hand over ownership to currElem.
1036                 Node* currNode = currElem->node->cloneNode(false).release();
1037
1038                 // Change the stack element's node to point to the clone.
1039                 // The stack element adopts the reference we obtained above by calling release().
1040                 currElem->derefNode();
1041                 currElem->node = currNode;
1042                 currElem->didRefNode = true;
1043                 
1044                 // Attach the previous node as a child of this new node.
1045                 if (prevNode)
1046                     currNode->appendChild(prevNode, ec);
1047                 else // The new parent for the block element is going to be the innermost clone.
1048                     parentElem = currNode;
1049                                 
1050                 prevNode = currNode;
1051             }
1052             
1053             currElem = currElem->next;
1054         }
1055
1056         // Now append the chain of new residual style elements if one exists.
1057         if (prevNode)
1058             elem->node->appendChild(prevNode, ec);
1059     }
1060          
1061     // Check if the block is still in the tree. If it isn't, then we don't
1062     // want to remove it from its parent (that would crash) or insert it into
1063     // a new parent later. See http://bugzilla.opendarwin.org/show_bug.cgi?id=6778
1064     bool isBlockStillInTree = blockElem->parentNode();
1065
1066     // We need to make a clone of |residualElem| and place it just inside |blockElem|.
1067     // All content of |blockElem| is reparented to be under this clone.  We then
1068     // reparent |blockElem| using real DOM calls so that attachment/detachment will
1069     // be performed to fix up the rendering tree.
1070     // So for this example: <b>...<p>Foo</b>Goo</p>
1071     // The end result will be: <b>...</b><p><b>Foo</b>Goo</p>
1072     //
1073     // Step 1: Remove |blockElem| from its parent, doing a batch detach of all the kids.
1074     if (form)
1075         form->setPreserveAcrossRemove(true);
1076     if (isBlockStillInTree)
1077         blockElem->parentNode()->removeChild(blockElem, ec);
1078
1079     // Step 2: Clone |residualElem|.
1080     RefPtr<Node> newNode = residualElem->cloneNode(false); // Shallow clone. We don't pick up the same kids.
1081
1082     // Step 3: Place |blockElem|'s children under |newNode|.  Remove all of the children of |blockElem|
1083     // before we've put |newElem| into the document.  That way we'll only do one attachment of all
1084     // the new content (instead of a bunch of individual attachments).
1085     Node* currNode = blockElem->firstChild();
1086     while (currNode) {
1087         Node* nextNode = currNode->nextSibling();
1088         newNode->appendChild(currNode, ec);
1089         currNode = nextNode;
1090     }
1091
1092     // Step 4: Place |newNode| under |blockElem|.  |blockElem| is still out of the document, so no
1093     // attachment can occur yet.
1094     blockElem->appendChild(newNode.release(), ec);
1095     
1096     // Step 5: Reparent |blockElem|.  Now the full attachment of the fixed up tree takes place.
1097     if (isBlockStillInTree)
1098         parentElem->appendChild(blockElem, ec);
1099         
1100     // Step 6: Elide |elem|, since it is effectively no longer open.  Also update
1101     // the node associated with the previous stack element so that when it gets popped,
1102     // it doesn't make the residual element the next current node.
1103     HTMLStackElem* currElem = maxElem;
1104     HTMLStackElem* prevElem = 0;
1105     while (currElem != elem) {
1106         prevElem = currElem;
1107         currElem = currElem->next;
1108     }
1109     prevElem->next = elem->next;
1110     prevElem->derefNode();
1111     prevElem->node = elem->node;
1112     prevElem->didRefNode = elem->didRefNode;
1113     delete elem;
1114     
1115     // Step 7: Reopen intermediate inlines, e.g., <b><p><i>Foo</b>Goo</p>.
1116     // In the above example, Goo should stay italic.
1117     curr = blockStack;
1118     HTMLStackElem* residualStyleStack = 0;
1119     while (curr && curr != maxElem) {
1120         // We will actually schedule this tag for reopening
1121         // after we complete the close of this entire block.
1122         if (isResidualStyleTag(curr->tagName))
1123             // We've overloaded the use of stack elements and are just reusing the
1124             // struct with a slightly different meaning to the variables.  Instead of chaining
1125             // from innermost to outermost, we build up a list of all the tags we need to reopen
1126             // from the outermost to the innermost, i.e., residualStyleStack will end up pointing
1127             // to the outermost tag we need to reopen.
1128             // We also set curr->node to be the actual element that corresponds to the ID stored in
1129             // curr->id rather than the node that you should pop to when the element gets pulled off
1130             // the stack.
1131             moveOneBlockToStack(residualStyleStack);
1132         else
1133             popOneBlock();
1134
1135         curr = blockStack;
1136     }
1137
1138     reopenResidualStyleTags(residualStyleStack, 0); // FIXME: Deal with stray table content some day
1139                                                     // if it becomes necessary to do so.
1140                                                     
1141     if (form)
1142         form->setPreserveAcrossRemove(false);
1143 }
1144
1145 void HTMLParser::reopenResidualStyleTags(HTMLStackElem* elem, Node* malformedTableParent)
1146 {
1147     // Loop for each tag that needs to be reopened.
1148     while (elem) {
1149         // Create a shallow clone of the DOM node for this element.
1150         RefPtr<Node> newNode = elem->node->cloneNode(false); 
1151
1152         // Append the new node. In the malformed table case, we need to insert before the table,
1153         // which will be the last child.
1154         ExceptionCode ec = 0;
1155         if (malformedTableParent)
1156             malformedTableParent->insertBefore(newNode, malformedTableParent->lastChild(), ec);
1157         else
1158             current->appendChild(newNode, ec);
1159         // FIXME: Is it really OK to ignore the exceptions here?
1160
1161         // Now push a new stack element for this node we just created.
1162         pushBlock(elem->tagName, elem->level);
1163
1164         // Set our strayTableContent boolean if needed, so that the reopened tag also knows
1165         // that it is inside a malformed table.
1166         blockStack->strayTableContent = malformedTableParent != 0;
1167         if (blockStack->strayTableContent)
1168             inStrayTableContent++;
1169
1170         // Clear our malformed table parent variable.
1171         malformedTableParent = 0;
1172
1173         // Update |current| manually to point to the new node.
1174         setCurrent(newNode.get());
1175         
1176         // Advance to the next tag that needs to be reopened.
1177         HTMLStackElem* next = elem->next;
1178         elem->derefNode();
1179         delete elem;
1180         elem = next;
1181     }
1182 }
1183
1184 void HTMLParser::pushBlock(const AtomicString& tagName, int level)
1185 {
1186     blockStack = new HTMLStackElem(tagName, level, current, didRefCurrent, blockStack);
1187     didRefCurrent = false;
1188 }
1189
1190 void HTMLParser::popBlock(const AtomicString& _tagName)
1191 {
1192     HTMLStackElem *Elem = blockStack;
1193     
1194     int maxLevel = 0;
1195
1196     while (Elem && (Elem->tagName != _tagName)) {
1197         if (maxLevel < Elem->level)
1198             maxLevel = Elem->level;
1199         Elem = Elem->next;
1200     }
1201
1202     if (!Elem)
1203         return;
1204
1205     if (maxLevel > Elem->level) {
1206         // We didn't match because the tag is in a different scope, e.g.,
1207         // <b><p>Foo</b>.  Try to correct the problem.
1208         if (!isResidualStyleTag(_tagName))
1209             return;
1210         return handleResidualStyleCloseTagAcrossBlocks(Elem);
1211     }
1212
1213     bool isAffectedByStyle = isAffectedByResidualStyle(Elem->tagName);
1214     HTMLStackElem* residualStyleStack = 0;
1215     Node* malformedTableParent = 0;
1216     
1217     Elem = blockStack;
1218     while (Elem) {
1219         if (Elem->tagName == _tagName) {
1220             int strayTable = inStrayTableContent;
1221             popOneBlock();
1222             Elem = 0;
1223
1224             // This element was the root of some malformed content just inside an implicit or
1225             // explicit <tbody> or <tr>.
1226             // If we end up needing to reopen residual style tags, the root of the reopened chain
1227             // must also know that it is the root of malformed content inside a <tbody>/<tr>.
1228             if (strayTable && (inStrayTableContent < strayTable) && residualStyleStack) {
1229                 Node* curr = current;
1230                 while (curr && !curr->hasTagName(tableTag))
1231                     curr = curr->parentNode();
1232                 malformedTableParent = curr ? curr->parentNode() : 0;
1233             }
1234         }
1235         else {
1236             if (form && Elem->tagName == formTag)
1237                 // A <form> is being closed prematurely (and this is
1238                 // malformed HTML).  Set an attribute on the form to clear out its
1239                 // bottom margin.
1240                 form->setMalformed(true);
1241
1242             // Schedule this tag for reopening
1243             // after we complete the close of this entire block.
1244             if (isAffectedByStyle && isResidualStyleTag(Elem->tagName))
1245                 // We've overloaded the use of stack elements and are just reusing the
1246                 // struct with a slightly different meaning to the variables.  Instead of chaining
1247                 // from innermost to outermost, we build up a list of all the tags we need to reopen
1248                 // from the outermost to the innermost, i.e., residualStyleStack will end up pointing
1249                 // to the outermost tag we need to reopen.
1250                 // We also set Elem->node to be the actual element that corresponds to the ID stored in
1251                 // Elem->id rather than the node that you should pop to when the element gets pulled off
1252                 // the stack.
1253                 moveOneBlockToStack(residualStyleStack);
1254             else
1255                 popOneBlock();
1256             Elem = blockStack;
1257         }
1258     }
1259
1260     reopenResidualStyleTags(residualStyleStack, malformedTableParent);
1261 }
1262
1263 inline HTMLStackElem* HTMLParser::popOneBlockCommon()
1264 {
1265     HTMLStackElem* elem = blockStack;
1266
1267     // Form elements restore their state during the parsing process.
1268     // Also, a few elements (<applet>, <object>) need to know when all child elements (<param>s) are available.
1269     if (current && elem->node != current)
1270         current->closeRenderer();
1271
1272     blockStack = elem->next;
1273     current = elem->node;
1274     didRefCurrent = elem->didRefNode;
1275
1276     if (elem->strayTableContent)
1277         inStrayTableContent--;
1278
1279     return elem;
1280 }
1281
1282 void HTMLParser::popOneBlock()
1283 {
1284     // Store the current node before popOneBlockCommon overwrites it.
1285     Node* lastCurrent = current;
1286     bool didRefLastCurrent = didRefCurrent;
1287
1288     delete popOneBlockCommon();
1289
1290     if (didRefLastCurrent)
1291         lastCurrent->deref();
1292 }
1293
1294 void HTMLParser::moveOneBlockToStack(HTMLStackElem*& head)
1295 {
1296     // We'll be using the stack element we're popping, but for the current node.
1297     // See the two callers for details.
1298
1299     // Store the current node before popOneBlockCommon overwrites it.
1300     Node* lastCurrent = current;
1301     bool didRefLastCurrent = didRefCurrent;
1302
1303     // Pop the block, but don't deref the current node as popOneBlock does because
1304     // we'll be using the pointer in the new stack element.
1305     HTMLStackElem* elem = popOneBlockCommon();
1306
1307     // Transfer the current node into the stack element.
1308     // No need to deref the old elem->node because popOneBlockCommon transferred
1309     // it into the current/didRefCurrent fields.
1310     elem->node = lastCurrent;
1311     elem->didRefNode = didRefLastCurrent;
1312     elem->next = head;
1313     head = elem;
1314 }
1315
1316 void HTMLParser::popInlineBlocks()
1317 {
1318     while (blockStack && isInline(current))
1319         popOneBlock();
1320 }
1321
1322 void HTMLParser::freeBlock()
1323 {
1324     while (blockStack)
1325         popOneBlock();
1326 }
1327
1328 void HTMLParser::createHead()
1329 {
1330     if (head || !doc()->firstChild())
1331         return;
1332
1333     head = new HTMLHeadElement(document);
1334     HTMLElement* body = doc()->body();
1335     ExceptionCode ec = 0;
1336     doc()->firstChild()->insertBefore(head, body, ec);
1337     if (ec)
1338         head = 0;
1339 }
1340
1341 Node* HTMLParser::handleIsindex(Token* t)
1342 {
1343     Node* n = new HTMLDivElement(document);
1344
1345     NamedMappedAttrMap* attrs = t->attrs.get();
1346
1347     RefPtr<HTMLIsIndexElement> isIndex = new HTMLIsIndexElement(document, form);
1348     isIndex->setAttributeMap(attrs);
1349     isIndex->setAttribute(typeAttr, "khtml_isindex");
1350
1351     String text = searchableIndexIntroduction();
1352     if (attrs) {
1353         if (Attribute *a = attrs->getAttributeItem(promptAttr))
1354             text = a->value().domString() + " ";
1355         t->attrs = 0;
1356     }
1357
1358     n->addChild(new HTMLHRElement(document));
1359     n->addChild(new Text(document, text));
1360     n->addChild(isIndex.get());
1361     n->addChild(new HTMLHRElement(document));
1362
1363     return n;
1364 }
1365
1366 void HTMLParser::startBody()
1367 {
1368     if(inBody) return;
1369
1370     inBody = true;
1371
1372     if (isindex) {
1373         insertNode(isindex.get(), true /* don't decend into this node */);
1374         isindex = 0;
1375     }
1376 }
1377
1378 void HTMLParser::finished()
1379 {
1380     // In the case of a completely empty document, here's the place to create the HTML element.
1381     if (current && current->isDocumentNode() && !current->firstChild())
1382         insertNode(new HTMLHtmlElement(document));
1383
1384     // This ensures that "current" is not left pointing to a node when the document is destroyed.
1385     freeBlock();
1386     setCurrent(0);
1387
1388     // Warning, this may delete the tokenizer and parser, so don't try to do anything else after this.
1389     if (!m_fragment)
1390         document->finishedParsing();
1391 }
1392
1393 }