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 }