/*

    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, 2007 Apple Inc. All rights reserved.

    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., 51 Franklin Street, Fifth Floor,

    Boston, MA 02110-1301, USA.

*/

#include "config.h"

#include "HTMLParser.h"

#include "CharacterNames.h"

#include "CSSPropertyNames.h"

#include "CSSValueKeywords.h"

#include "Comment.h"

#include "DocumentFragment.h"

#include "Frame.h"

#include "HTMLBodyElement.h"

#include "HTMLDocument.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 "Page.h"

#include "Settings.h"

#include "Text.h"

namespace WebCore {

using namespace HTMLNames;

static const unsigned cMaxRedundantTagDepth = 20;

static const unsigned cResidualStyleMaxDepth = 200;

struct HTMLStackElem : Noncopyable {

    HTMLStackElem(const AtomicString& t, int lvl, Node* n, bool r, HTMLStackElem* nx)

        : tagName(t)

        , level(lvl)

        , strayTableContent(false)

        , node(n)

        , didRefNode(r)

        , next(nx)

    {

    }

    void derefNode()

    {

        if (didRefNode)

            node->deref();

    }

    AtomicString tagName;

    int level;

    bool strayTableContent;

    Node* node;

    bool didRefNode;

    HTMLStackElem* next;

};

/**

 * The parser parses tokenized input into the document, building up the

 * document tree. If the document is well-formed, parsing it is straightforward.

 *

 * Unfortunately, we have to handle many HTML documents that are not well-formed,

 * so the parser has to be tolerant about errors.

 *

 * We have to take care of at least 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 in between (or that the

 *    tag in between is optional). This could be the case with the following

 *    tags: HTML HEAD BODY TBODY TR TD LI (did I forget any?).

 *

 * 3. We want 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(HTMLDocument* doc, bool reportErrors)

    : document(doc)

    , current(doc)

    , didRefCurrent(false)

    , blockStack(0)

    , head(0)

    , inBody(false)

    , haveContent(false)

    , haveFrameSet(false)

    , m_isParsingFragment(false)

    , m_reportErrors(reportErrors)

    , m_handlingResidualStyleAcrossBlocks(false)

    , inStrayTableContent(0)

#if PLATFORM(SYMBIAN)

    ,m_scriptSupported(true)

#endif

{

}

HTMLParser::HTMLParser(DocumentFragment* frag)

    : document(frag->document())

    , current(frag)

    , didRefCurrent(true)

    , blockStack(0)

    , head(0)

    , inBody(true)

    , haveContent(false)

    , haveFrameSet(false)

    , m_isParsingFragment(true)

    , m_reportErrors(false)

    , m_handlingResidualStyleAcrossBlocks(false)

    , inStrayTableContent(0)

{

    if (frag)

        frag->ref();

}

HTMLParser::~HTMLParser()

{

    freeBlock();

    if (didRefCurrent) 

        current->deref(); 

}

void HTMLParser::reset()

{

    ASSERT(!m_isParsingFragment);

    setCurrent(document);

    freeBlock();

    inBody = false;

    haveFrameSet = false;

    haveContent = false;

    inStrayTableContent = 0;

    m_currentFormElement = 0;

    m_currentMapElement = 0;

    head = 0;

    m_isindexElement = 0;

    m_skipModeTag = nullAtom;

#if PLATFORM(SYMBIAN)

    m_scriptSupported = true;

#endif

}

void HTMLParser::setCurrent(Node* newCurrent) 

{

    bool didRefNewCurrent = newCurrent && newCurrent != document;

    if (didRefNewCurrent) 

        newCurrent->ref(); 

    if (didRefCurrent) 

        current->deref(); 

    current = newCurrent;

    didRefCurrent = didRefNewCurrent;

}

PassRefPtr<Node> HTMLParser::parseToken(Token* t)

{

    if (!m_skipModeTag.isNull()) {

        if (!t->beginTag && t->tagName == m_skipModeTag)

            // Found the end tag for the current skip mode, so we're done skipping.

            m_skipModeTag = nullAtom;

        else if (current->localName() == t->tagName)

            // Do not skip </iframe>.

            // FIXME: What does that comment mean? How can it be right to parse a token without clearing m_skipModeTag?

            ;

        else

            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) && document->inCompatMode()) {

        reportError(MalformedBRError);

        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;

        String text = t->text.get();

        unsigned charsLeft = text.length();

        while (charsLeft) {

            // split large blocks of text to nodes of manageable size

            n = Text::createWithLengthLimit(document, text, charsLeft);

            if (!insertNode(n.get(), t->flat))

                return 0;

        }

        return n;

    }

    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 the node does not have a forbidden end tag requirement, and if the broken XML self-closing

        // syntax was used, report an error.

        if (t->brokenXMLStyle && e->endTagRequirement() != TagStatusForbidden) {

            if (t->tagName == scriptTag)

                reportError(IncorrectXMLCloseScriptWarning);

            else

                reportError(IncorrectXMLSelfCloseError, &t->tagName);

        }

    }

    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 (m_currentMapElement == n)

            m_currentMapElement = 0;

        if (m_currentFormElement == n)

            m_currentFormElement = 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;

    // <table> is never allowed inside stray table content.  Always pop out of the stray table content

    // and close up the first table, and then start the second table as a sibling.

    if (inStrayTableContent && localName == tableTag)

        popBlock(tableTag);

    // 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)

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

    // don't push elements without end tags (e.g., <img>) on the stack

    bool parentAttached = current->attached();

    if (tagPriority > 0 && !flat) {

        if (newNode == current) {

            // This case should only be hit when a demoted <form> is placed inside a table.

            ASSERT(localName == formTag);

            reportError(FormInsideTablePartError, &current->localName());

        } else {

            // The pushBlock function transfers ownership of current to the block stack

            // so we're guaranteed that didRefCurrent is false. The code below is an

            // optimized version of setCurrent that takes advantage of that fact and also

            // assumes that newNode is neither 0 nor a pointer to the document.

            pushBlock(localName, tagPriority);

            ASSERT(!didRefCurrent);

            newNode->ref(); 

            current = newNode;

            didRefCurrent = true;

        }

        if (parentAttached && !n->attached() && !m_isParsingFragment)

            n->attach();

    } else {

        if (parentAttached && !n->attached() && !m_isParsingFragment)

            n->attach();

        n->finishedParsing();

    }

    return true;

}

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->isHTMLElement()) {

        HTMLElement* h = static_cast<HTMLElement*>(n);

        if (h->hasLocalName(trTag) || h->hasLocalName(thTag) || h->hasLocalName(tdTag)) {

            if (inStrayTableContent && !isTableRelated(current)) {

                reportError(MisplacedTablePartError, &localName, &current->localName());

                // 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)) {

                reportError(MisplacedHeadError);

                return false;

            }

        } else if (h->hasLocalName(metaTag) || h->hasLocalName(linkTag) || h->hasLocalName(baseTag)) {

            bool createdHead = false;

            if (!head) {

                createHead();

                createdHead = true;

            }

            if (head) {

                if (!createdHead)

                    reportError(MisplacedHeadContentError, &localName, &current->localName());

                if (head->addChild(n)) {

                    if (!n->attached() && !m_isParsingFragment)

                        n->attach();

                    return true;

                } else

                    return false;

            }

        } else if (h->hasLocalName(htmlTag)) {

            if (!current->isDocumentNode() ) {

                if (document->documentElement()->hasTagName(htmlTag)) {

                    reportError(RedundantHTMLBodyError, &localName);

                    // 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*>(document->documentElement());

                    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)) {

            bool createdHead = false;

            if (!head) {

                createHead();

                createdHead = true;

            }

            if (head) {

                Node* newNode = head->addChild(n);

                if (!newNode) {

                    setSkipMode(h->tagQName());

                    return false;

                }

                if (!createdHead)

                    reportError(MisplacedHeadContentError, &localName, &current->localName());

                pushBlock(localName, tagPriority);

                setCurrent(newNode);

                if (!n->attached() && !m_isParsingFragment)

                    n->attach();

                return true;

            }

            if (inBody) {

                setSkipMode(h->tagQName());

                return false;

            }

        } else if (h->hasLocalName(bodyTag)) {

            if (inBody && document->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>

                reportError(RedundantHTMLBodyError, &localName);

                NamedAttrMap* map = static_cast<Element*>(n)->attributes(true);

                Element* existingBody = document->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(areaTag)) {

            if (m_currentMapElement) {

                reportError(MisplacedAreaError, &current->localName());

                m_currentMapElement->addChild(n);

                if (!n->attached() && !m_isParsingFragment)

                    n->attach();

                handled = true;

                return true;

            }

            return false;

        } else if (h->hasLocalName(colgroupTag) || h->hasLocalName(captionTag)) {

            if (isTableRelated(current)) {

                while (blockStack && isTablePart(current))

                    popOneBlock();

                return insertNode(n);

            }

        }

    } else if (n->isCommentNode() && !head)

        return false;

    // 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 PLATFORM(SYMBIAN)

                || elt->hasLocalName(bgsoundTag) 

#endif                                

                )) {

                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

                    reportError(MisplacedFramesetContentError, &localName);

            }

        } 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

                    reportError(MisplacedFramesetContentError, &localName);

            }

        } else if (h->hasLocalName(addressTag) || h->hasLocalName(dlTag) || h->hasLocalName(dtTag)

                   || h->hasLocalName(fontTag) || h->hasLocalName(styleTag) || h->hasLocalName(titleTag)) {

            reportError(MisplacedContentRetryError, &localName, &currentTagName);

            popBlock(currentTagName);

            handled = true;

        } else if (h->hasLocalName(captionTag)) {

            // Illegal content in a caption. Close the caption and try again.

            reportError(MisplacedCaptionContentError, &localName);

            popBlock(currentTagName);

            if (isTablePart(n))

                return insertNode(n, flat);

        } else if (h->hasLocalName(tableTag) || h->hasLocalName(trTag) || isTableSection(h)) {

            if (n->hasTagName(tableTag)) {

                reportError(MisplacedTableError, &currentTagName);

                if (m_isParsingFragment && !h->hasLocalName(tableTag))

                    // fragment may contain table parts without <table> ancestor, pop them one by one