[WebKit-https.git] / WebCore / html / HTMLParser.cpp

/*
    This file is part of the KDE libraries

    Copyright (C) 1997 Martin Jones (mjones@kde.org)
              (C) 1997 Torben Weis (weis@kde.org)
              (C) 1999,2001 Lars Knoll (knoll@kde.org)
              (C) 2000,2001 Dirk Mueller (mueller@kde.org)
    Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.
*/

#include "config.h"
#include "HTMLParser.h"

#include "CSSPropertyNames.h"
#include "CSSValueKeywords.h"
#include "Comment.h"
#include "DocumentFragment.h"
#include "Frame.h"
#include "HTMLBodyElement.h"
#include "HTMLCanvasElement.h"
#include "HTMLDivElement.h"
#include "HTMLDListElement.h"
#include "HTMLElementFactory.h"
#include "HTMLFormElement.h"
#include "HTMLHeadElement.h"
#include "HTMLHRElement.h"
#include "HTMLHtmlElement.h"
#include "HTMLIsIndexElement.h"
#include "HTMLMapElement.h"
#include "HTMLNames.h"
#include "HTMLTableCellElement.h"
#include "HTMLTableRowElement.h"
#include "HTMLTableSectionElement.h"
#include "HTMLTokenizer.h"
#include "LocalizedStrings.h"
#include "Text.h"

namespace WebCore {

using namespace HTMLNames;

const UChar nonBreakingSpace = 0xa0;

/**
 * @internal
 */

    class RefNonDocNodePtr
    {
    public:
        RefNonDocNodePtr() : m_ptr(0) {}
        RefNonDocNodePtr(Node* ptr) : m_ptr(ptr), m_isDoc(ptr->isDocumentNode()) { if (!m_isDoc && ptr) ptr->ref(); }
        RefNonDocNodePtr(const RefNonDocNodePtr& o) : m_ptr(o.m_ptr), m_isDoc(o.m_isDoc) { if (!m_isDoc && m_ptr) m_ptr->ref(); }

        ~RefNonDocNodePtr() { if (!m_isDoc && m_ptr) m_ptr->deref(); }
        
        Node *get() const { return m_ptr; }
        
        Node& operator*() const { return *m_ptr; }
        Node *operator->() const { return m_ptr; }
        
        bool operator!() const { return !m_ptr; }
    
        // This conversion operator allows implicit conversion to bool but not to other integer types.
        typedef Node* (RefNonDocNodePtr::*UnspecifiedBoolType)() const;
        operator UnspecifiedBoolType() const { return m_ptr ? &RefNonDocNodePtr::get : 0; }
        
        RefNonDocNodePtr& operator=(const RefNonDocNodePtr&);
        RefNonDocNodePtr& operator=(Node*);
        RefNonDocNodePtr& operator=(RefPtr<Node>&);

    private:
        Node* m_ptr;
        bool m_isDoc;
    };
    
    inline RefNonDocNodePtr& RefNonDocNodePtr::operator=(const RefNonDocNodePtr& o)
    {
        Node* optr = o.get();
        if (!o.m_isDoc && optr)
            optr->ref();
        Node* ptr = m_ptr;
        m_ptr = optr;
        if (!m_isDoc && ptr)
            ptr->deref();
        m_isDoc = o.m_isDoc;
        return *this;
    }
    
    inline RefNonDocNodePtr& RefNonDocNodePtr::operator=(Node* optr)
    {
        bool o_isDoc = optr->isDocumentNode();
        if (!o_isDoc && optr)
            optr->ref();
        Node* ptr = m_ptr;
        m_ptr = optr;
        if (!m_isDoc && ptr)
            ptr->deref();
        m_isDoc = o_isDoc;
        return *this;
    }

    inline RefNonDocNodePtr& RefNonDocNodePtr::operator=(RefPtr<Node>& o)
    {
        Node* optr = o.get();
        bool o_isDoc = optr->isDocumentNode();
        if (!o_isDoc && optr)
            optr->ref();
        Node* ptr = m_ptr;
        m_ptr = optr;
        if (!m_isDoc && ptr)
            ptr->deref();
        m_isDoc = o_isDoc;
        return *this;
    }

    inline bool operator==(const RefNonDocNodePtr& a, const RefNonDocNodePtr& b)
    { 
        return a.get() == b.get(); 
    }

    inline bool operator==(const RefNonDocNodePtr& a, Node* b)
    { 
        return a.get() == b; 
    }
    
    inline bool operator==(Node* a, const RefNonDocNodePtr& b) 
    {
        return a == b.get(); 
    }
    
    inline bool operator!=(const RefNonDocNodePtr& a, const RefNonDocNodePtr& b)
    { 
        return a.get() != b.get(); 
    }

    inline bool operator!=(const RefNonDocNodePtr& a, Node* b)
    {
        return a.get() != b; 
    }

    inline bool operator!=(Node* a, const RefNonDocNodePtr& b)
    { 
        return a != b.get(); 
    }
    


class HTMLStackElem
{
public:
    HTMLStackElem(const AtomicString& _tagName,
                  int _level,
                  Node *_node,
                  HTMLStackElem * _next
        )
        :
        tagName(_tagName),
        level(_level),
        strayTableContent(false),
        node(_node),
        next(_next)
        { }

    AtomicString tagName;
    int level;
    bool strayTableContent;
    RefNonDocNodePtr node;
    HTMLStackElem* next;
};

/**
 * @internal
 *
 * The parser parses tokenized input into the document, building up the
 * document tree. If the document is wellformed, parsing it is
 * straightforward.
 * Unfortunately, people can't write wellformed HTML documents, so the parser
 * has to be tolerant about errors.
 *
 * We have to take care of the following error conditions:
 * 1. The element being added is explicitly forbidden inside some outer tag.
 *    In this case we should close all tags up to the one, which forbids
 *    the element, and add it afterwards.
 * 2. We are not allowed to add the element directly. It could be, that
 *    the person writing the document forgot some tag inbetween (or that the
 *    tag inbetween is optional...) This could be the case with the following
 *    tags: HTML HEAD BODY TBODY TR TD LI (did I forget any?)
 * 3. We wan't to add a block element inside to an inline element. Close all
 *    inline elements up to the next higher block element.
 * 4. If this doesn't help close elements, until we are allowed to add the
 *    element or ignore the tag.
 *
 */
HTMLParser::HTMLParser(Document* doc) 
    : document(doc)
    , current(0)
    , currentIsReferenced(false)
    , blockStack(0)
    , m_fragment(false)
{
    reset();
}

HTMLParser::HTMLParser(DocumentFragment* frag)
    : document(frag->document())
    , current(0)
    , currentIsReferenced(false)
    , blockStack(0)
    , m_fragment(true)
{
    reset();
    setCurrent(frag);
    inBody = true;
}

HTMLParser::~HTMLParser()
{
    freeBlock();

    setCurrent(0);
}

void HTMLParser::reset()
{
    setCurrent(doc());

    freeBlock();

    inBody = false;
    haveFrameSet = false;
    haveContent = false;
    inSelect = false;
    inStrayTableContent = 0;
    
    form = 0;
    map = 0;
    head = 0;
    end = false;
    isindex = 0;
    
    discard_until = nullAtom;
}

void HTMLParser::setCurrent(Node *newCurrent) 
{
    bool newCurrentIsReferenced = newCurrent && newCurrent != doc();
    if (newCurrentIsReferenced) 
        newCurrent->ref(); 
    if (currentIsReferenced) 
        current->deref(); 
    current = newCurrent;
    currentIsReferenced = newCurrentIsReferenced;
}

PassRefPtr<Node> HTMLParser::parseToken(Token *t)
{
    if (!discard_until.isNull()) {
        if (t->tagName == discard_until && !t->beginTag)
            discard_until = nullAtom;

        // do not skip </iframe>
        if (!discard_until.isNull() || (current->localName() != t->tagName))
            return 0;
    }

    // Apparently some sites use </br> instead of <br>.  Be compatible with IE and Firefox and treat this like <br>.
    if (t->isCloseTag(brTag) && doc()->inCompatMode())
        t->beginTag = true;

    if (!t->beginTag) {
        processCloseTag(t);
        return 0;
    }

    // ignore spaces, if we're not inside a paragraph or other inline code
    if (t->tagName == textAtom && t->text) {
        if (inBody && !skipMode() && current->localName() != styleTag && current->localName() != titleTag && 
            current->localName() != scriptTag && !t->text->containsOnlyWhitespace()) 
            haveContent = true;
    }

    RefPtr<Node> n = getNode(t);
    // just to be sure, and to catch currently unimplemented stuff
    if (!n)
        return 0;

    // set attributes
    if (n->isHTMLElement()) {
        HTMLElement* e = static_cast<HTMLElement*>(n.get());
        e->setAttributeMap(t->attrs.get());

        // take care of optional close tags
        if (e->endTagRequirement() == TagStatusOptional)
            popBlock(t->tagName);
            
        if (isHeaderTag(t->tagName))
            // Do not allow two header tags to be nested if the intervening tags are inlines.
            popNestedHeaderTag();
    }

    if (!insertNode(n.get(), t->flat)) {
        // we couldn't insert the node

        if (n->isElementNode()) {
            Element* e = static_cast<Element*>(n.get());
            e->setAttributeMap(0);
        }

        if (map == n)
            map = 0;

        if (form == n)
            form = 0;

        if (head == n)
            head = 0;

        return 0;
    }
    return n;
}

static bool isTableSection(Node* n)
{
    return n->hasTagName(tbodyTag) || n->hasTagName(tfootTag) || n->hasTagName(theadTag);
}

static bool isTablePart(Node* n)
{
    return n->hasTagName(trTag) || n->hasTagName(tdTag) || n->hasTagName(thTag) ||
           isTableSection(n);
}

static bool isTableRelated(Node* n)
{
    return n->hasTagName(tableTag) || isTablePart(n);
}

bool HTMLParser::insertNode(Node *n, bool flat)
{
    RefPtr<Node> protectNode(n);

    const AtomicString& localName = n->localName();
    int tagPriority = n->isHTMLElement() ? static_cast<HTMLElement*>(n)->tagPriority() : 0;
        
    // let's be stupid and just try to insert it.
    // this should work if the document is well-formed
    Node *newNode = current->addChild(n);
    if (newNode) {
        // don't push elements without end tags (e.g., <img>) on the stack
        bool parentAttached = current->attached();
        if (tagPriority > 0 && !flat) {
            pushBlock(localName, tagPriority);
            if (newNode == current)
                popBlock(localName);
            else
                setCurrent(newNode);
            if (parentAttached && !n->attached() && !m_fragment)
                n->attach();
        } else {
            if (parentAttached && !n->attached() && !m_fragment)
                n->attach();
            n->closeRenderer();
        }

        return true;
    } else
        return handleError(n, flat, localName, tagPriority); // Try to handle the error.
}

bool HTMLParser::handleError(Node* n, bool flat, const AtomicString& localName, int tagPriority)
{
    // Error handling code.  This is just ad hoc handling of specific parent/child combinations.
    HTMLElement *e;
    bool handled = false;

    // 1. Check out the element's tag name to decide how to deal with errors.
    if (n->isTextNode()) {
        if (current->hasTagName(selectTag))
            return false;
    } else if (n->isHTMLElement()) {
        HTMLElement* h = static_cast<HTMLElement*>(n);
        if (h->hasLocalName(trTag) || h->hasLocalName(thTag) || h->hasLocalName(tdTag)) {
            if (inStrayTableContent && !isTableRelated(current)) {
                // pop out to the nearest enclosing table-related tag.
                while (blockStack && !isTableRelated(current))
                    popOneBlock();
                return insertNode(n);
            }
        } else if (h->hasLocalName(headTag)) {
            if (!current->isDocumentNode() && !current->hasTagName(htmlTag))
                return false;
        } else if (h->hasLocalName(metaTag) || h->hasLocalName(linkTag) || h->hasLocalName(baseTag)) {
            if (!head)
                createHead();
            if (head) {
                if (head->addChild(n)) {
                    if (!n->attached() && !m_fragment)
                        n->attach();
                    return true;
                } else
                    return false;
            }
        } else if (h->hasLocalName(htmlTag)) {
            if (!current->isDocumentNode() ) {
                if (doc()->firstChild()->hasTagName(htmlTag)) {
                    // we have another <HTML> element.... apply attributes to existing one
                    // make sure we don't overwrite already existing attributes
                    NamedAttrMap *map = static_cast<Element*>(n)->attributes(true);
                    Element *existingHTML = static_cast<Element*>(doc()->firstChild());
                    NamedAttrMap *bmap = existingHTML->attributes(false);
                    for (unsigned l = 0; map && l < map->length(); ++l) {
                        Attribute* it = map->attributeItem(l);
                        if (!bmap->getAttributeItem(it->name()))
                            existingHTML->setAttribute(it->name(), it->value());
                    }
                }
                return false;
            }
        } else if (h->hasLocalName(titleTag) || h->hasLocalName(styleTag)) {
            if (!head)
                createHead();
            if (head) {
                Node* newNode = head->addChild(n);
                if (!newNode) {
                    setSkipMode(h->tagQName());
                    return false;
                }
                pushBlock(localName, tagPriority);
                setCurrent(newNode);
                if (!n->attached() && !m_fragment)
                    n->attach();
                return true;
            }
            if (inBody) {
                setSkipMode(h->tagQName());
                return false;
            }
        } else if (h->hasLocalName(bodyTag)) {
            if (inBody && doc()->body()) {
                // we have another <BODY> element.... apply attributes to existing one
                // make sure we don't overwrite already existing attributes
                // some sites use <body bgcolor=rightcolor>...<body bgcolor=wrongcolor>
                NamedAttrMap *map = static_cast<Element*>(n)->attributes(true);
                Element *existingBody = doc()->body();
                NamedAttrMap *bmap = existingBody->attributes(false);
                for (unsigned l = 0; map && l < map->length(); ++l) {
                    Attribute* it = map->attributeItem(l);
                    if (!bmap->getAttributeItem(it->name()))
                        existingBody->setAttribute(it->name(), it->value());
                }
                return false;
            }
            else if (!current->isDocumentNode())
                return false;
        } else if (h->hasLocalName(inputTag)) {
            if (equalIgnoringCase(h->getAttribute(typeAttr), "hidden") && form) {
                form->addChild(n);
                if (!n->attached() && !m_fragment)
                    n->attach();
                return true;
            }
        } else if (h->hasLocalName(ddTag) || h->hasLocalName(dtTag)) {
            e = new HTMLDListElement(document);
            if (insertNode(e)) {
                insertNode(n);
                return true;
            }
        } else if (h->hasLocalName(areaTag)) {
            if (map) {
                map->addChild(n);
                if (!n->attached() && !m_fragment)
                    n->attach();
                handled = true;
                return true;
            }
            return false;
        } else if (h->hasLocalName(captionTag)) {
            if (isTablePart(current)) {
                Node* tsection = current;
                if (current->hasTagName(trTag))
                    tsection = current->parent();
                else if (current->hasTagName(tdTag) || current->hasTagName(thTag))
                    tsection = current->parent()->parent();
                Node* table = tsection->parent();
                ExceptionCode ec = 0;
                table->insertBefore(n, tsection, ec);
                pushBlock(localName, tagPriority);
                setCurrent(n);
                inStrayTableContent++;
                blockStack->strayTableContent = true;
                return true;
            }
        } else if (h->hasLocalName(theadTag) || h->hasLocalName(tbodyTag) ||
                   h->hasLocalName(tfootTag) || h->hasLocalName(colgroupTag)) {
            if (isTableRelated(current)) {
                while (blockStack && isTablePart(current))
                    popOneBlock();
                return insertNode(n);
            }
        }
    }
    
    // 2. Next we examine our currently active element to do some further error handling.
    if (current->isHTMLElement()) {
        HTMLElement* h = static_cast<HTMLElement*>(current);
        const AtomicString& currentTagName = current->localName();
        if (h->hasLocalName(htmlTag)) {
            HTMLElement* elt = n->isHTMLElement() ? static_cast<HTMLElement*>(n) : 0;
            if (elt && (elt->hasLocalName(scriptTag) || elt->hasLocalName(styleTag) ||
                elt->hasLocalName(metaTag) || elt->hasLocalName(linkTag) ||
                elt->hasLocalName(objectTag) || elt->hasLocalName(embedTag) ||
                elt->hasLocalName(titleTag) || elt->hasLocalName(isindexTag) ||
                elt->hasLocalName(baseTag))) {
                if (!head) {
                    head = new HTMLHeadElement(document);
                    e = head;
                    insertNode(e);
                    handled = true;
                }
            } else {
                if (n->isTextNode()) {
                    Text *t = static_cast<Text *>(n);
                    if (t->containsOnlyWhitespace())
                        return false;
                }
                if (!haveFrameSet) {
                    e = new HTMLBodyElement(document);
                    startBody();
                    insertNode(e);
                    handled = true;
                }
            }
        } else if (h->hasLocalName(headTag)) {
            if (n->hasTagName(htmlTag))
                return false;
            else {
                // This means the body starts here...
                if (!haveFrameSet) {
                    popBlock(currentTagName);
                    e = new HTMLBodyElement(document);
                    startBody();
                    insertNode(e);
                    handled = true;
                }
            }
        } else if (h->hasLocalName(addressTag) || h->hasLocalName(dlTag) || h->hasLocalName(dtTag)
                   || h->hasLocalName(fontTag) || h->hasLocalName(styleTag) || h->hasLocalName(titleTag)) {
            popBlock(currentTagName);
            handled = true;
        } else if (h->hasLocalName(captionTag)) {
            // Illegal content in a caption. Close the caption and try again.
            popBlock(currentTagName);
            if (isTablePart(n))
                return insertNode(n, flat);
        } else if (h->hasLocalName(tableTag) || h->hasLocalName(trTag) || isTableSection(h)) {
            if (n->hasTagName(tableTag)) {
                popBlock(localName); // end the table
                handled = true;      // ...and start a new one
            } else {
                bool possiblyMoveStrayContent = true;
                ExceptionCode ec = 0;
                if (n->isTextNode()) {
                    Text *t = static_cast<Text *>(n);
                    if (t->containsOnlyWhitespace())
                        return false;
                    StringImpl *i = t->string();
                    unsigned int pos = 0;
                    while (pos < i->length() && ((*i)[pos] == ' ' || (*i)[pos] == nonBreakingSpace))
                        pos++;
                    if (pos == i->length())
                        possiblyMoveStrayContent = false;
                }
                if (possiblyMoveStrayContent) {
                    Node *node = current;
                    Node *parent = node->parentNode();
                    // A script may have removed the current node's parent from the DOM
                    // http://bugzilla.opendarwin.org/show_bug.cgi?id=7137
                    // FIXME: we should do real recovery here and re-parent with the correct node.
                    if (!parent)
                        return false;
                    Node *grandparent = parent->parentNode();

                    if (n->isTextNode() ||
                        (h->hasLocalName(trTag) &&
                         isTableSection(parent) && grandparent->hasTagName(tableTag)) ||
                         ((!n->hasTagName(tdTag) && !n->hasTagName(thTag) &&
                           !n->hasTagName(formTag) && !n->hasTagName(scriptTag)) && isTableSection(node) &&
                         parent->hasTagName(tableTag))) {
                        node = (node->hasTagName(tableTag)) ? node :
                                ((node->hasTagName(trTag)) ? grandparent : parent);
                        Node *parent = node->parentNode();
                        if (!parent)
                            return false;
                        parent->insertBefore(n, node, ec);
                        if (!ec) {
                            if (n->isHTMLElement() && tagPriority > 0 && 
                                !flat && static_cast<HTMLElement*>(n)->endTagRequirement() != TagStatusForbidden)
                            {
                                pushBlock(localName, tagPriority);
                                setCurrent(n);
                                inStrayTableContent++;
                                blockStack->strayTableContent = true;
                            }
                            return true;
                        }
                    }

                    if (!ec) {
                        if (current->hasTagName(trTag))
                            e = new HTMLTableCellElement(tdTag, document);
                        else if (current->hasTagName(tableTag))
                            e = new HTMLTableSectionElement(tbodyTag, document, true); // implicit 
                        else
                            e = new HTMLTableRowElement(document);
                        
                        insertNode(e);
                        handled = true;
                    }
                }
            }
        } else if (h->hasLocalName(objectTag)) {
            setSkipMode(objectTag);
            return false;
        } else if (h->hasLocalName(ulTag) || h->hasLocalName(olTag) ||
                 h->hasLocalName(dirTag) || h->hasLocalName(menuTag)) {
            e = new HTMLDivElement(document);
            insertNode(e);
            handled = true;
        } else if (h->hasLocalName(selectTag)) {
            if (isInline(n))
                return false;
        } else if (h->hasLocalName(pTag) || isHeaderTag(currentTagName)) {
            if (!isInline(n)) {
                popBlock(currentTagName);
                handled = true;
            }
        } else if (h->hasLocalName(optionTag) || h->hasLocalName(optgroupTag)) {
            if (localName == optgroupTag) {
                popBlock(currentTagName);
                handled = true;
            } else if (localName == selectTag) {
                // IE treats a nested select as </select>. Let's do the same
                popBlock(localName);
            }
        } else if (h->hasLocalName(colgroupTag)) {
            if (!n->isTextNode()) {
                popBlock(currentTagName);
                handled = true;
            }
        } else if (!h->hasLocalName(bodyTag)) {
            if (isInline(current)) {
                popInlineBlocks();
                handled = true;
            }
        }
    } else if (current->isDocumentNode()) {
        if (current->firstChild() == 0 || !current->firstChild()->isHTMLElement()) {
            e = new HTMLHtmlElement(document);
            insertNode(e);
            handled = true;
        }
    }

    // 3. If we couldn't handle the error, just return false and attempt to error-correct again.
    if (!handled)
        return false;
    return insertNode(n);
}

typedef bool (HTMLParser::*CreateErrorCheckFunc)(Token* t, RefPtr<Node>&);
typedef HashMap<AtomicStringImpl*, CreateErrorCheckFunc> FunctionMap;

bool HTMLParser::textCreateErrorCheck(Token* t, RefPtr<Node>& result)
{
    result = new Text(document, t->text.get());
    return false;
}

bool HTMLParser::commentCreateErrorCheck(Token* t, RefPtr<Node>& result)
{
    result = new Comment(document, t->text.get());
    return false;
}

bool HTMLParser::headCreateErrorCheck(Token* t, RefPtr<Node>& result)
{
    if (!head || current->localName() == htmlTag) {
        head = new HTMLHeadElement(document);
        result = head;
    }
    return false;
}

bool HTMLParser::bodyCreateErrorCheck(Token* t, RefPtr<Node>& result)
{
    // body no longer allowed if we have a frameset
    if (haveFrameSet)
        return false;
    popBlock(headTag);
    startBody();
    return true;
}

bool HTMLParser::framesetCreateErrorCheck(Token* t, RefPtr<Node>& result)
{
    popBlock(headTag);
    if (inBody && !haveFrameSet && !haveContent) {
        popBlock(bodyTag);
        // ### actually for IE document.body returns the now hidden "body" element
        // we can't implement that behaviour now because it could cause too many
        // regressions and the headaches are not worth the work as long as there is
        // no site actually relying on that detail (Dirk)
        if (doc()->body())
            doc()->body()->setAttribute(styleAttr, "display:none");
        inBody = false;
    }
    if ((haveContent || haveFrameSet) && current->localName() == htmlTag)
        return false;
    haveFrameSet = true;
    startBody();
    return true;
}

bool HTMLParser::iframeCreateErrorCheck(Token* t, RefPtr<Node>& result)
{
    // a bit of a special case, since the frame is inlined
    setSkipMode(iframeTag);
    return true;
}

bool HTMLParser::formCreateErrorCheck(Token* t, RefPtr<Node>& result)
{
    // Only create a new form if we're not already inside one.
    // This is consistent with other browsers' behavior.
    if (!form) {
        form = new HTMLFormElement(document);
        result = form;
    }
    return false;
}

bool HTMLParser::isindexCreateErrorCheck(Token* t, RefPtr<Node>& result)
{
    Node *n = handleIsindex(t);
    if (!inBody) {
        isindex = n;
    } else {
        t->flat = true;
        result = n;
    }
    return false;
}

bool HTMLParser::selectCreateErrorCheck(Token* t, RefPtr<Node>& result)
{
    inSelect = true;
    return true;
}

bool HTMLParser::ddCreateErrorCheck(Token* t, RefPtr<Node>& result)
{
    popBlock(dtTag);
    popBlock(ddTag);
    return true;
}

bool HTMLParser::dtCreateErrorCheck(Token* t, RefPtr<Node>& result)
{
    popBlock(ddTag);
    popBlock(dtTag);
    return true;
}

bool HTMLParser::nestedCreateErrorCheck(Token* t, RefPtr<Node>& result)
{
    popBlock(t->tagName);
    return true;
}

bool HTMLParser::nestedStyleCreateErrorCheck(Token* t, RefPtr<Node>& result)
{
    return allowNestedRedundantTag(t->tagName);
}

bool HTMLParser::tableCellCreateErrorCheck(Token* t, RefPtr<Node>& result)
{
    popBlock(tdTag);
    popBlock(thTag);
    return true;
}

bool HTMLParser::tableSectionCreateErrorCheck(Token* t, RefPtr<Node>& result)
{
    popBlock(theadTag);
    popBlock(tbodyTag);
    popBlock(tfootTag);
    return true;
}

bool HTMLParser::noembedCreateErrorCheck(Token* t, RefPtr<Node>& result)
{
    setSkipMode(noembedTag);
    return true;
}

bool HTMLParser::noframesCreateErrorCheck(Token* t, RefPtr<Node>& result)
{
    setSkipMode(noframesTag);
    return true;
}

bool HTMLParser::noscriptCreateErrorCheck(Token* t, RefPtr<Node>& result)
{
    if (!m_fragment && document->frame() && document->frame()->jScriptEnabled())
        setSkipMode(noscriptTag);
    return true;
}

bool HTMLParser::mapCreateErrorCheck(Token* t, RefPtr<Node>& result)
{
    map = new HTMLMapElement(document);
    result = map;
    return false;
}

bool HTMLParser::canvasCreateErrorCheck(Token* t, RefPtr<Node>& result)
{
    if (!m_fragment && document->frame() && document->frame()->jScriptEnabled())
        setSkipMode(canvasTag);
    return true;
}

PassRefPtr<Node> HTMLParser::getNode(Token* t)
{
    // Init our error handling table.
    static FunctionMap gFunctionMap;
    if (gFunctionMap.isEmpty()) {
        gFunctionMap.set(aTag.localName().impl(), &HTMLParser::nestedCreateErrorCheck);
        gFunctionMap.set(bTag.localName().impl(), &HTMLParser::nestedStyleCreateErrorCheck);
        gFunctionMap.set(bigTag.localName().impl(), &HTMLParser::nestedStyleCreateErrorCheck);
        gFunctionMap.set(bodyTag.localName().impl(), &HTMLParser::bodyCreateErrorCheck);
        gFunctionMap.set(buttonTag.localName().impl(), &HTMLParser::nestedCreateErrorCheck);
        gFunctionMap.set(canvasTag.localName().impl(), &HTMLParser::canvasCreateErrorCheck);
        gFunctionMap.set(commentAtom.impl(), &HTMLParser::commentCreateErrorCheck);
        gFunctionMap.set(ddTag.localName().impl(), &HTMLParser::ddCreateErrorCheck);
        gFunctionMap.set(dtTag.localName().impl(), &HTMLParser::dtCreateErrorCheck);
        gFunctionMap.set(formTag.localName().impl(), &HTMLParser::formCreateErrorCheck);
        gFunctionMap.set(framesetTag.localName().impl(), &HTMLParser::framesetCreateErrorCheck);
        gFunctionMap.set(headTag.localName().impl(), &HTMLParser::headCreateErrorCheck);
        gFunctionMap.set(iTag.localName().impl(), &HTMLParser::nestedStyleCreateErrorCheck);
        gFunctionMap.set(iframeTag.localName().impl(), &HTMLParser::iframeCreateErrorCheck);
        gFunctionMap.set(isindexTag.localName().impl(), &HTMLParser::isindexCreateErrorCheck);
        gFunctionMap.set(liTag.localName().impl(), &HTMLParser::nestedCreateErrorCheck);
        gFunctionMap.set(mapTag.localName().impl(), &HTMLParser::mapCreateErrorCheck);
        gFunctionMap.set(nobrTag.localName().impl(), &HTMLParser::nestedCreateErrorCheck);
        gFunctionMap.set(noembedTag.localName().impl(), &HTMLParser::noembedCreateErrorCheck);
        gFunctionMap.set(noframesTag.localName().impl(), &HTMLParser::noframesCreateErrorCheck);
        gFunctionMap.set(noscriptTag.localName().impl(), &HTMLParser::noscriptCreateErrorCheck);
        gFunctionMap.set(sTag.localName().impl(), &HTMLParser::nestedStyleCreateErrorCheck);
        gFunctionMap.set(selectTag.localName().impl(), &HTMLParser::selectCreateErrorCheck);
        gFunctionMap.set(smallTag.localName().impl(), &HTMLParser::nestedStyleCreateErrorCheck);
        gFunctionMap.set(strikeTag.localName().impl(), &HTMLParser::nestedStyleCreateErrorCheck);
        gFunctionMap.set(tbodyTag.localName().impl(), &HTMLParser::tableSectionCreateErrorCheck);
        gFunctionMap.set(tdTag.localName().impl(), &HTMLParser::tableCellCreateErrorCheck);
        gFunctionMap.set(textAtom.impl(), &HTMLParser::textCreateErrorCheck);
        gFunctionMap.set(tfootTag.localName().impl(), &HTMLParser::tableSectionCreateErrorCheck);
        gFunctionMap.set(thTag.localName().impl(), &HTMLParser::tableCellCreateErrorCheck);
        gFunctionMap.set(theadTag.localName().impl(), &HTMLParser::tableSectionCreateErrorCheck);
        gFunctionMap.set(trTag.localName().impl(), &HTMLParser::nestedCreateErrorCheck);
        gFunctionMap.set(ttTag.localName().impl(), &HTMLParser::nestedStyleCreateErrorCheck);
        gFunctionMap.set(uTag.localName().impl(), &HTMLParser::nestedStyleCreateErrorCheck);
        gFunctionMap.set(wbrTag.localName().impl(), &HTMLParser::nestedCreateErrorCheck);
    }

    bool proceed = true;
    RefPtr<Node> result;
    if (CreateErrorCheckFunc errorCheckFunc = gFunctionMap.get(t->tagName.impl()))
        proceed = (this->*errorCheckFunc)(t, result);
    if (proceed)
        result = HTMLElementFactory::createHTMLElement(t->tagName, doc(), form);
    return result.release();
}

#define MAX_REDUNDANT 20

bool HTMLParser::allowNestedRedundantTag(const AtomicString& _tagName)
{
    // www.liceo.edu.mx is an example of a site that achieves a level of nesting of
    // about 1500 tags, all from a bunch of <b>s.  We will only allow at most 20
    // nested tags of the same type before just ignoring them all together.
    int i = 0;
    for (HTMLStackElem* curr = blockStack;
         i < MAX_REDUNDANT && curr && curr->tagName == _tagName;
         curr = curr->next, i++);
    return i != MAX_REDUNDANT;
}

void HTMLParser::processCloseTag(Token *t)
{
    // Support for really broken html.
    // we never close the body tag, since some stupid web pages close it before the actual end of the doc.
    // let's rely on the end() call to close things.
    if (t->tagName == htmlTag || t->tagName == bodyTag)
        return;
    
    if (t->tagName == formTag)
        form = 0;
    else if (t->tagName == mapTag)
        map = 0;
    else if (t->tagName == selectTag)
        inSelect = false;
        
    HTMLStackElem* oldElem = blockStack;
    popBlock(t->tagName);
    if (oldElem == blockStack && t->tagName == pTag) {
        // We encountered a stray </p>.  Amazingly Gecko, WinIE, and MacIE all treat
        // this as a valid break, i.e., <p></p>.  So go ahead and make the empty
        // paragraph.
        t->beginTag = true;
        parseToken(t);
        popBlock(t->tagName);
    }
}

bool HTMLParser::isHeaderTag(const AtomicString& tagName)
{
    static HashSet<AtomicStringImpl*> headerTags;
    if (headerTags.isEmpty()) {
        headerTags.add(h1Tag.localName().impl());
        headerTags.add(h2Tag.localName().impl());
        headerTags.add(h3Tag.localName().impl());
        headerTags.add(h4Tag.localName().impl());
        headerTags.add(h5Tag.localName().impl());
        headerTags.add(h6Tag.localName().impl());
    }
    
    return headerTags.contains(tagName.impl());
}

void HTMLParser::popNestedHeaderTag()
{
    // This function only cares about checking for nested headers that have only inlines in between them.
    Node* currNode = current;
    for (HTMLStackElem* curr = blockStack; curr; curr = curr->next) {
        if (isHeaderTag(curr->tagName)) {
            popBlock(curr->tagName);
            return;
        }
        if (currNode && !isInline(currNode))
            return;
        currNode = curr->node.get();
    }
}

bool HTMLParser::isInline(Node* node) const
{
    if (node->isTextNode())
        return true;

    if (node->isHTMLElement()) {
        HTMLElement* e = static_cast<HTMLElement*>(node);
        if (e->hasLocalName(aTag) || e->hasLocalName(fontTag) || e->hasLocalName(ttTag) ||
            e->hasLocalName(uTag) || e->hasLocalName(bTag) || e->hasLocalName(iTag) ||
            e->hasLocalName(sTag) || e->hasLocalName(strikeTag) || e->hasLocalName(bigTag) ||
            e->hasLocalName(smallTag) || e->hasLocalName(emTag) || e->hasLocalName(strongTag) ||
            e->hasLocalName(dfnTag) || e->hasLocalName(codeTag) || e->hasLocalName(sampTag) ||
            e->hasLocalName(kbdTag) || e->hasLocalName(varTag) || e->hasLocalName(citeTag) ||
            e->hasLocalName(abbrTag) || e->hasLocalName(acronymTag) || e->hasLocalName(subTag) ||
            e->hasLocalName(supTag) || e->hasLocalName(spanTag) || e->hasLocalName(nobrTag) ||
            e->hasLocalName(wbrTag) || e->hasLocalName(noframesTag) || e->hasLocalName(nolayerTag) ||
            e->hasLocalName(noembedTag) || (e->hasLocalName(noscriptTag) && !m_fragment && document->frame() && document->frame()->jScriptEnabled()))
            return true;
    }
    
    return false;
}

bool HTMLParser::isResidualStyleTag(const AtomicString& tagName)
{
    static HashSet<AtomicStringImpl*> residualStyleTags;
    if (residualStyleTags.isEmpty()) {
        residualStyleTags.add(aTag.localName().impl());
        residualStyleTags.add(fontTag.localName().impl());
        residualStyleTags.add(ttTag.localName().impl());
        residualStyleTags.add(uTag.localName().impl());
        residualStyleTags.add(bTag.localName().impl());
        residualStyleTags.add(iTag.localName().impl());
        residualStyleTags.add(sTag.localName().impl());
        residualStyleTags.add(strikeTag.localName().impl());
        residualStyleTags.add(bigTag.localName().impl());
        residualStyleTags.add(smallTag.localName().impl());
        residualStyleTags.add(emTag.localName().impl());
        residualStyleTags.add(strongTag.localName().impl());
        residualStyleTags.add(dfnTag.localName().impl());
        residualStyleTags.add(codeTag.localName().impl());
        residualStyleTags.add(sampTag.localName().impl());
        residualStyleTags.add(kbdTag.localName().impl());
        residualStyleTags.add(varTag.localName().impl());
        residualStyleTags.add(nobrTag.localName().impl());
        residualStyleTags.add(wbrTag.localName().impl());
    }
    
    return residualStyleTags.contains(tagName.impl());
}

bool HTMLParser::isAffectedByResidualStyle(const AtomicString& tagName)
{
    if (isResidualStyleTag(tagName))
        return true;

    static HashSet<AtomicStringImpl*> affectedBlockTags;
    if (affectedBlockTags.isEmpty()) {
        affectedBlockTags.add(addressTag.localName().impl());
        affectedBlockTags.add(blockquoteTag.localName().impl());
        affectedBlockTags.add(centerTag.localName().impl());
        affectedBlockTags.add(ddTag.localName().impl());
        affectedBlockTags.add(divTag.localName().impl());
        affectedBlockTags.add(dlTag.localName().impl());
        affectedBlockTags.add(dtTag.localName().impl());
        affectedBlockTags.add(formTag.localName().impl());
        affectedBlockTags.add(h1Tag.localName().impl());
        affectedBlockTags.add(h2Tag.localName().impl());
        affectedBlockTags.add(h3Tag.localName().impl());
        affectedBlockTags.add(h4Tag.localName().impl());
        affectedBlockTags.add(h5Tag.localName().impl());
        affectedBlockTags.add(h6Tag.localName().impl());
        affectedBlockTags.add(liTag.localName().impl());
        affectedBlockTags.add(listingTag.localName().impl());
        affectedBlockTags.add(olTag.localName().impl());
        affectedBlockTags.add(pTag.localName().impl());
        affectedBlockTags.add(preTag.localName().impl());
        affectedBlockTags.add(ulTag.localName().impl());
    }
    
    return affectedBlockTags.contains(tagName.impl());
}

void HTMLParser::handleResidualStyleCloseTagAcrossBlocks(HTMLStackElem* elem)
{
    // Find the element that crosses over to a higher level.   For now, if there is more than
    // one, we will just give up and not attempt any sort of correction.  It's highly unlikely that
    // there will be more than one, since <p> tags aren't allowed to be nested.
    ExceptionCode ec = 0;
    HTMLStackElem* curr = blockStack;
    HTMLStackElem* maxElem = 0;
    HTMLStackElem* prev = 0;
    HTMLStackElem* prevMaxElem = 0;
    while (curr && curr != elem) {
        if (curr->level > elem->level) {
            if (maxElem)
                return;
            maxElem = curr;
            prevMaxElem = prev;
        }

        prev = curr;
        curr = curr->next;
    }

    if (!curr || !maxElem || !isAffectedByResidualStyle(maxElem->tagName)) return;

    Node* residualElem = prev->node.get();
    Node* blockElem = prevMaxElem ? prevMaxElem->node.get() : current;
    Node* parentElem = elem->node.get();

    // Check to see if the reparenting that is going to occur is allowed according to the DOM.
    // FIXME: We should either always allow it or perform an additional fixup instead of
    // just bailing here.
    // Example: <p><font><center>blah</font></center></p> isn't doing a fixup right now.
    if (!parentElem->childAllowed(blockElem))
        return;
    
    if (maxElem->node->parentNode() != elem->node) {
        // Walk the stack and remove any elements that aren't residual style tags.  These
        // are basically just being closed up.  Example:
        // <font><span>Moo<p>Goo</font></p>.
        // In the above example, the <span> doesn't need to be reopened.  It can just close.
        HTMLStackElem* currElem = maxElem->next;
        HTMLStackElem* prevElem = maxElem;
        while (currElem != elem) {
            HTMLStackElem* nextElem = currElem->next;
            if (!isResidualStyleTag(currElem->tagName)) {
                prevElem->next = nextElem;
                prevElem->node = currElem->node;
                delete currElem;
            }
            else
                prevElem = currElem;
            currElem = nextElem;
        }
        
        // We have to reopen residual tags in between maxElem and elem.  An example of this case is:
        // <font><i>Moo<p>Foo</font>.
        // In this case, we need to transform the part before the <p> into:
        // <font><i>Moo</i></font><i>
        // so that the <i> will remain open.  This involves the modification of elements
        // in the block stack.
        // This will also affect how we ultimately reparent the block, since we want it to end up
        // under the reopened residual tags (e.g., the <i> in the above example.)
        RefPtr<Node> prevNode = 0;
        currElem = maxElem;
        while (currElem->node != residualElem) {
            if (isResidualStyleTag(currElem->node->localName())) {
                // Create a clone of this element.
                RefPtr<Node> currNode = currElem->node->cloneNode(false);

                // Change the stack element's node to point to the clone.
                currElem->node = currNode;
                
                // Attach the previous node as a child of this new node.
                if (prevNode)
                    currNode->appendChild(prevNode, ec);
                else // The new parent for the block element is going to be the innermost clone.
                    parentElem = currNode.get();
                                
                prevNode = currNode.get();
            }
            
            currElem = currElem->next;
        }

        // Now append the chain of new residual style elements if one exists.
        if (prevNode)
            elem->node->appendChild(prevNode, ec);
    }
         
    // Check if the block is still in the tree. If it isn't, then we don't
    // want to remove it from its parent (that would crash) or insert it into
    // a new parent later. See http://bugzilla.opendarwin.org/show_bug.cgi?id=6778
    bool isBlockStillInTree = blockElem->parentNode();

    // We need to make a clone of |residualElem| and place it just inside |blockElem|.
    // All content of |blockElem| is reparented to be under this clone.  We then
    // reparent |blockElem| using real DOM calls so that attachment/detachment will
    // be performed to fix up the rendering tree.
    // So for this example: <b>...<p>Foo</b>Goo</p>
    // The end result will be: <b>...</b><p><b>Foo</b>Goo</p>
    //
    // Step 1: Remove |blockElem| from its parent, doing a batch detach of all the kids.
    if (form)
        form->setPreserveAcrossRemove(true);
    if (isBlockStillInTree)
        blockElem->parentNode()->removeChild(blockElem, ec);

    // Step 2: Clone |residualElem|.
    RefPtr<Node> newNode = residualElem->cloneNode(false); // Shallow clone. We don't pick up the same kids.

    // Step 3: Place |blockElem|'s children under |newNode|.  Remove all of the children of |blockElem|
    // before we've put |newElem| into the document.  That way we'll only do one attachment of all
    // the new content (instead of a bunch of individual attachments).
    Node* currNode = blockElem->firstChild();
    while (currNode) {
        Node* nextNode = currNode->nextSibling();
        newNode->appendChild(currNode, ec);
        currNode = nextNode;
    }

    // Step 4: Place |newNode| under |blockElem|.  |blockElem| is still out of the document, so no
    // attachment can occur yet.
    blockElem->appendChild(newNode.release(), ec);
    
    // Step 5: Reparent |blockElem|.  Now the full attachment of the fixed up tree takes place.
    if (isBlockStillInTree)
        parentElem->appendChild(blockElem, ec);
        
    // Step 6: Elide |elem|, since it is effectively no longer open.  Also update
    // the node associated with the previous stack element so that when it gets popped,
    // it doesn't make the residual element the next current node.
    HTMLStackElem* currElem = maxElem;
    HTMLStackElem* prevElem = 0;
    while (currElem != elem) {
        prevElem = currElem;
        currElem = currElem->next;
    }
    prevElem->next = elem->next;
    prevElem->node = elem->node;
    delete elem;
    
    // Step 7: Reopen intermediate inlines, e.g., <b><p><i>Foo</b>Goo</p>.
    // In the above example, Goo should stay italic.
    curr = blockStack;
    HTMLStackElem* residualStyleStack = 0;
    while (curr && curr != maxElem) {
        // We will actually schedule this tag for reopening
        // after we complete the close of this entire block.
        Node* currNode = current;
        if (isResidualStyleTag(curr->tagName)) {
            // We've overloaded the use of stack elements and are just reusing the
            // struct with a slightly different meaning to the variables.  Instead of chaining
            // from innermost to outermost, we build up a list of all the tags we need to reopen
            // from the outermost to the innermost, i.e., residualStyleStack will end up pointing
            // to the outermost tag we need to reopen.
            // We also set curr->node to be the actual element that corresponds to the ID stored in
            // curr->id rather than the node that you should pop to when the element gets pulled off
            // the stack.
            popOneBlock(false);
            curr->node = currNode;
            curr->next = residualStyleStack;
            residualStyleStack = curr;
        }
        else
            popOneBlock();

        curr = blockStack;
    }

    reopenResidualStyleTags(residualStyleStack, 0); // FIXME: Deal with stray table content some day
                                                    // if it becomes necessary to do so.
                                                    
    if (form)
        form->setPreserveAcrossRemove(false);
}

void HTMLParser::reopenResidualStyleTags(HTMLStackElem* elem, Node* malformedTableParent)
{
    // Loop for each tag that needs to be reopened.
    while (elem) {
        // Create a shallow clone of the DOM node for this element.
        RefPtr<Node> newNode = elem->node->cloneNode(false); 

        // Append the new node. In the malformed table case, we need to insert before the table,
        // which will be the last child.
        ExceptionCode ec = 0;
        if (malformedTableParent)
            malformedTableParent->insertBefore(newNode, malformedTableParent->lastChild(), ec);
        else
            current->appendChild(newNode, ec);
        // FIXME: Is it really OK to ignore the exceptions here?

        // Now push a new stack element for this node we just created.
        pushBlock(elem->tagName, elem->level);

        // Set our strayTableContent boolean if needed, so that the reopened tag also knows
        // that it is inside a malformed table.
        blockStack->strayTableContent = malformedTableParent != 0;
        if (blockStack->strayTableContent)
            inStrayTableContent++;

        // Clear our malformed table parent variable.
        malformedTableParent = 0;

        // Update |current| manually to point to the new node.
        setCurrent(newNode.get());
        
        // Advance to the next tag that needs to be reopened.
        HTMLStackElem* next = elem->next;
        delete elem;
        elem = next;
    }
}

void HTMLParser::pushBlock(const AtomicString& tagName, int _level)
{
    HTMLStackElem *Elem = new HTMLStackElem(tagName, _level, current, blockStack);
    blockStack = Elem;
}

void HTMLParser::popBlock(const AtomicString& _tagName)
{
    HTMLStackElem *Elem = blockStack;
    
    int maxLevel = 0;

    while (Elem && (Elem->tagName != _tagName)) {
        if (maxLevel < Elem->level)
            maxLevel = Elem->level;
        Elem = Elem->next;
    }

    if (!Elem)
        return;

    if (maxLevel > Elem->level) {
        // We didn't match because the tag is in a different scope, e.g.,
        // <b><p>Foo</b>.  Try to correct the problem.
        if (!isResidualStyleTag(_tagName))
            return;
        return handleResidualStyleCloseTagAcrossBlocks(Elem);
    }

    bool isAffectedByStyle = isAffectedByResidualStyle(Elem->tagName);
    HTMLStackElem* residualStyleStack = 0;
    Node* malformedTableParent = 0;
    
    Elem = blockStack;
    while (Elem) {
        if (Elem->tagName == _tagName) {
            int strayTable = inStrayTableContent;
            popOneBlock();
            Elem = 0;

            // This element was the root of some malformed content just inside an implicit or
            // explicit <tbody> or <tr>.
            // If we end up needing to reopen residual style tags, the root of the reopened chain
            // must also know that it is the root of malformed content inside a <tbody>/<tr>.
            if (strayTable && (inStrayTableContent < strayTable) && residualStyleStack) {
                Node* curr = current;
                while (curr && !curr->hasTagName(tableTag))
                    curr = curr->parentNode();
                malformedTableParent = curr ? curr->parentNode() : 0;
            }
        }
        else {
            if (form && Elem->tagName == formTag)
                // A <form> is being closed prematurely (and this is
                // malformed HTML).  Set an attribute on the form to clear out its
                // bottom margin.
                form->setMalformed(true);

            // Schedule this tag for reopening
            // after we complete the close of this entire block.
            Node* currNode = current;
            if (isAffectedByStyle && isResidualStyleTag(Elem->tagName)) {
                // We've overloaded the use of stack elements and are just reusing the
                // struct with a slightly different meaning to the variables.  Instead of chaining
                // from innermost to outermost, we build up a list of all the tags we need to reopen
                // from the outermost to the innermost, i.e., residualStyleStack will end up pointing
                // to the outermost tag we need to reopen.
                // We also set Elem->node to be the actual element that corresponds to the ID stored in
                // Elem->id rather than the node that you should pop to when the element gets pulled off
                // the stack.
                popOneBlock(false);
                Elem->next = residualStyleStack;
                Elem->node = currNode;
                residualStyleStack = Elem;
            }
            else
                popOneBlock();
            Elem = blockStack;
        }
    }

    reopenResidualStyleTags(residualStyleStack, malformedTableParent);
}

void HTMLParser::popOneBlock(bool delBlock)
{
    HTMLStackElem* elem = blockStack;

    // Form elements restore their state during the parsing process.
    // Also, a few elements (<applet>, <object>) need to know when all child elements (<param>s) are available.
    if (current && elem->node != current)
        current->closeRenderer();

    blockStack = elem->next;
    setCurrent(elem->node.get());

    if (elem->strayTableContent)
        inStrayTableContent--;
    
    if (delBlock)
        delete elem;
}

void HTMLParser::popInlineBlocks()
{
    while (blockStack && isInline(current))
        popOneBlock();
}

void HTMLParser::freeBlock()
{
    while (blockStack)
        popOneBlock();
}

void HTMLParser::createHead()
{
    if (head || !doc()->firstChild())
        return;

    head = new HTMLHeadElement(document);
    HTMLElement* body = doc()->body();
    ExceptionCode ec = 0;
    doc()->firstChild()->insertBefore(head, body, ec);
    if (ec)
        head = 0;
}

Node* HTMLParser::handleIsindex(Token* t)
{
    Node* n = new HTMLDivElement(document);

    NamedMappedAttrMap* attrs = t->attrs.get();

    RefPtr<HTMLIsIndexElement> isIndex = new HTMLIsIndexElement(document, form);
    isIndex->setAttributeMap(attrs);
    isIndex->setAttribute(typeAttr, "khtml_isindex");

    String text = searchableIndexIntroduction();
    if (attrs) {
        if (Attribute *a = attrs->getAttributeItem(promptAttr))
            text = a->value().domString() + " ";
        t->attrs = 0;
    }

    n->addChild(new HTMLHRElement(document));
    n->addChild(new Text(document, text));
    n->addChild(isIndex.get());
    n->addChild(new HTMLHRElement(document));

    return n;
}

void HTMLParser::startBody()
{
    if(inBody) return;

    inBody = true;

    if (isindex) {
        insertNode(isindex.get(), true /* don't decend into this node */);
        isindex = 0;
    }
}

void HTMLParser::finished()
{
    // In the case of a completely empty document, here's the place to create the HTML element.
    if (current && current->isDocumentNode() && !current->firstChild())
        insertNode(new HTMLHtmlElement(document));

    // This ensures that "current" is not left pointing to a node when the document is destroyed.
    freeBlock();
    setCurrent(0);

    // Warning, this may delete the tokenizer and parser, so don't try to do anything else after this.
    if (!m_fragment)
        document->finishedParsing();
}

}