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