/*
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 "Console.h"
#include "DOMWindow.h"
#include "DocumentFragment.h"
#include "DocumentType.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 "Settings.h"
#include "Text.h"
#include <wtf/StdLibExtras.h>
namespace WebCore {
using namespace HTMLNames;
static const unsigned cMaxRedundantTagDepth = 20;
static const unsigned cResidualStyleMaxDepth = 200;
static const int minBlockLevelTagPriority = 3;
// A cap on the number of tags with priority minBlockLevelTagPriority or higher
// allowed in blockStack. The cap is enforced by adding such new elements as
// siblings instead of children once it is reached.
static const size_t cMaxBlockDepth = 4096;
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)
, m_blocksInStack(0)
, m_hasPElementInScope(NotInScope)
, head(0)
, inBody(false)
, haveContent(false)
, haveFrameSet(false)
, m_isParsingFragment(false)
, m_reportErrors(reportErrors)
, m_handlingResidualStyleAcrossBlocks(false)
, inStrayTableContent(0)
{
}
HTMLParser::HTMLParser(DocumentFragment* frag)
: document(frag->document())
, current(frag)
, didRefCurrent(true)
, blockStack(0)
, m_blocksInStack(0)
, m_hasPElementInScope(NotInScope)
, 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;
}
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.
// Do not alter the text if it is part of a scriptTag.
if (t->tagName == textAtom && t->text && current->localName() != scriptTag) {
if (inBody && !skipMode() && current->localName() != styleTag &&
current->localName() != titleTag && !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->selfClosingTag))
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->selfClosingTag)) {
// 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;
}
void HTMLParser::parseDoctypeToken(DoctypeToken* t)
{
// Ignore any doctype after the first. Ignore doctypes in fragments.
if (document->doctype() || m_isParsingFragment || current != document)
return;
// Make a new doctype node and set it as our doctype.
document->addChild(DocumentType::create(document, String::adopt(t->m_name), String::adopt(t->m_publicID), String::adopt(t->m_systemID)));
}
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);
}
static bool isScopingTag(const AtomicString& tagName)
{
return tagName == appletTag || tagName == captionTag || tagName == tdTag || tagName == thTag || tagName == buttonTag || tagName == marqueeTag || tagName == objectTag || tagName == tableTag || tagName == htmlTag;
}
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);
if (tagPriority >= minBlockLevelTagPriority) {
while (m_blocksInStack >= cMaxBlockDepth)
popBlock(blockStack->tagName);
}
// 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, ¤t->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);
newNode->beginParsingChildren();
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->finishParsingChildren();
}
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, ¤t->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, ¤t->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() && 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, ¤t->localName());
pushBlock(localName, tagPriority);
newNode->beginParsingChildren();
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, ¤t->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 = h->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(headTag, 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(bodyTag, 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(bodyTag, document);
startBody();
insertNode(e);
handled = true;
} else
reportError(MisplacedFramesetContentError, &localName);
}
} else if (h->hasLocalName(addressTag) || h->hasLocalName(fontTag)
|| h->hasLocalName(styleTag) || h->hasLocalName(titleTag)) {
reportError(MisplacedContentRetryError, &localName, ¤tTagName);
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, ¤tTagName);
if (m_isParsingFragment && !h->hasLocalName(tableTag))
// fragment may contain table parts without <table> ancestor, pop them one by one
popBlock(h->localName());
popBlock(localName); // end the table
handled = true; // ...and start a new one
} else {
ExceptionCode ec = 0;
Node* node = current;
Node* parent = node->parentNode();
// A script may have removed the current node's parent from the DOM
// http://bugs.webkit.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 && 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);
// This can happen with fragments
if (!node)
return false;
Node* parent = node->parentNode();
if (!parent)
return false;
parent->insertBefore(n, node, ec);
if (!ec) {
reportError(StrayTableContentError, &localName, ¤tTagName);
if (n->isHTMLElement() && tagPriority > 0 &&
!flat && static_cast<HTMLElement*>(n)->endTagRequirement() != TagStatusForbidden)
{
pushBlock(localName, tagPriority);
n->beginParsingChildren();
setCurrent(n);
inStrayTableContent++;
blockStack->strayTableContent = true;
}
return true;
}
}
if (!ec) {
if (current->hasTagName(trTag)) {
reportError(TablePartRequiredError, &localName, &tdTag.localName());
e = new HTMLTableCellElement(tdTag, document);
} else if (current->hasTagName(tableTag)) {
// Don't report an error in this case, since making a <tbody> happens all the time when you have <table><tr>,
// and it isn't really a parse error per se.
e = new HTMLTableSectionElement(tbodyTag, document);
} else {
reportError(TablePartRequiredError, &localName, &trTag.localName());
e = new HTMLTableRowElement(trTag, document);
}
insertNode(e);
handled = true;
}
}
} else if (h->hasLocalName(objectTag)) {
reportError(MisplacedContentRetryError, &localName, ¤tTagName);
popBlock(objectTag);
handled = true;
} 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(selectTag)) {
if (localName == inputTag || localName == textareaTag) {
reportError(MisplacedContentRetryError, &localName, ¤tTagName);
popBlock(currentTagName);
handled = true;
}
} else if (h->hasLocalName(colgroupTag)) {
popBlock(currentTagName);
handled = true;
} else if (!h->hasLocalName(bodyTag)) {
if (isInline(current)) {
popInlineBlocks();
handled = true;
}
}
} else if (current->isDocumentNode()) {
if (n->isTextNode()) {
Text* t = static_cast<Text*>(n);
if (t->containsOnlyWhitespace())
return false;
}
if (!document->documentElement()) {
e = new HTMLHtmlElement(htmlTag, document);
insertNode(e);
handled = true;
}
}
// 3. If we couldn't handle the error, just return false and attempt to error-correct again.
if (!handled) {
reportError(IgnoredContentError, &localName, ¤t->localName());
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*, RefPtr<Node>& result)
{
if (!head || current->localName() == htmlTag) {
head = new HTMLHeadElement(headTag, document);
result = head;
} else
reportError(MisplacedHeadError);
return false;
}
bool HTMLParser::bodyCreateErrorCheck(Token*, RefPtr<Node>&)
{
// body no longer allowed if we have a frameset
if (haveFrameSet)
return false;
popBlock(headTag);
startBody();
return true;
}
bool HTMLParser::framesetCreateErrorCheck(Token*, RefPtr<Node>&)
{
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 (document->body())
document->body()->setAttribute(styleAttr, "display:none");
inBody = false;
}
if ((haveContent || haveFrameSet) && current->localName() == htmlTag)
return false;
haveFrameSet = true;
startBody();
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 (!m_currentFormElement) {
m_currentFormElement = new HTMLFormElement(formTag, document);
result = m_currentFormElement;
pCloserCreateErrorCheck(t, result);
}
return false;
}
bool HTMLParser::isindexCreateErrorCheck(Token* t, RefPtr<Node>& result)
{
RefPtr<Node> n = handleIsindex(t);
if (!inBody)
m_isindexElement = n.release();
else {
t->selfClosingTag = true;
result = n.release();
}
return false;
}
bool HTMLParser::selectCreateErrorCheck(Token*, RefPtr<Node>&)
{
return true;
}
bool HTMLParser::ddCreateErrorCheck(Token* t, RefPtr<Node>& result)
{
pCloserCreateErrorCheck(t, result);
popBlock(dtTag);
popBlock(ddTag);
return true;
}
bool HTMLParser::dtCreateErrorCheck(Token* t, RefPtr<Node>& result)
{
pCloserCreateErrorCheck(t, result);
popBlock(ddTag);
popBlock(dtTag);
return true;
}
bool HTMLParser::nestedCreateErrorCheck(Token* t, RefPtr<Node>&)
{
popBlock(t->tagName);
return true;
}
bool HTMLParser::nestedPCloserCreateErrorCheck(Token* t, RefPtr<Node>& result)
{
pCloserCreateErrorCheck(t, result);
popBlock(t->tagName);
return true;
}
bool HTMLParser::nestedStyleCreateErrorCheck(Token* t, RefPtr<Node>&)
{
return allowNestedRedundantTag(t->tagName);
}
bool HTMLParser::tableCellCreateErrorCheck(Token*, RefPtr<Node>&)
{
popBlock(tdTag);
popBlock(thTag);
return true;
}
bool HTMLParser::tableSectionCreateErrorCheck(Token*, RefPtr<Node>&)
{
popBlock(theadTag);
popBlock(tbodyTag);
popBlock(tfootTag);
return true;
}
bool HTMLParser::noembedCreateErrorCheck(Token*, RefPtr<Node>&)
{
setSkipMode(noembedTag);
return true;
}
bool HTMLParser::noframesCreateErrorCheck(Token*, RefPtr<Node>&)
{
setSkipMode(noframesTag);
return true;
}
bool HTMLParser::noscriptCreateErrorCheck(Token*, RefPtr<Node>&)
{
if (!m_isParsingFragment) {
Settings* settings = document->settings();
if (settings && settings->isJavaScriptEnabled())
setSkipMode(noscriptTag);
}
return true;
}
bool HTMLParser::pCloserCreateErrorCheck(Token*, RefPtr<Node>&)
{
if (hasPElementInScope())
popBlock(pTag);
return true;
}
bool HTMLParser::pCloserStrictCreateErrorCheck(Token*, RefPtr<Node>&)
{
if (document->inCompatMode())
return true;
if (hasPElementInScope())
popBlock(pTag);
return true;
}
bool HTMLParser::mapCreateErrorCheck(Token*, RefPtr<Node>& result)
{
m_currentMapElement = new HTMLMapElement(mapTag, document);
result = m_currentMapElement;
return false;
}
PassRefPtr<Node> HTMLParser::getNode(Token* t)
{
// Init our error handling table.
DEFINE_STATIC_LOCAL(FunctionMap, gFunctionMap, ());
if (gFunctionMap.isEmpty()) {
gFunctionMap.set(aTag.localName().impl(), &HTMLParser::nestedCreateErrorCheck);
gFunctionMap.set(addressTag.localName().impl(), &HTMLParser::pCloserCreateErrorCheck);
gFunctionMap.set(bTag.localName().impl(), &HTMLParser::nestedStyleCreateErrorCheck);
gFunctionMap.set(bigTag.localName().impl(), &HTMLParser::nestedStyleCreateErrorCheck);
gFunctionMap.set(blockquoteTag.localName().impl(), &HTMLParser::pCloserCreateErrorCheck);
gFunctionMap.set(bodyTag.localName().impl(), &HTMLParser::bodyCreateErrorCheck);
gFunctionMap.set(buttonTag.localName().impl(), &HTMLParser::nestedCreateErrorCheck);
gFunctionMap.set(centerTag.localName().impl(), &HTMLParser::pCloserCreateErrorCheck);
gFunctionMap.set(commentAtom.impl(), &HTMLParser::commentCreateErrorCheck);
gFunctionMap.set(ddTag.localName().impl(), &HTMLParser::ddCreateErrorCheck);
gFunctionMap.set(dirTag.localName().impl(), &HTMLParser::pCloserCreateErrorCheck);
gFunctionMap.set(divTag.localName().impl(), &HTMLParser::pCloserCreateErrorCheck);
gFunctionMap.set(dlTag.localName().impl(), &HTMLParser::pCloserCreateErrorCheck);
gFunctionMap.set(dtTag.localName().impl(), &HTMLParser::dtCreateErrorCheck);
gFunctionMap.set(formTag.localName().impl(), &HTMLParser::formCreateErrorCheck);
gFunctionMap.set(fieldsetTag.localName().impl(), &HTMLParser::pCloserCreateErrorCheck);
gFunctionMap.set(framesetTag.localName().impl(), &HTMLParser::framesetCreateErrorCheck);
gFunctionMap.set(h1Tag.localName().impl(), &HTMLParser::pCloserCreateErrorCheck);
gFunctionMap.set(h2Tag.localName().impl(), &HTMLParser::pCloserCreateErrorCheck);
gFunctionMap.set(h3Tag.localName().impl(), &HTMLParser::pCloserCreateErrorCheck);
gFunctionMap.set(h4Tag.localName().impl(), &HTMLParser::pCloserCreateErrorCheck);
gFunctionMap.set(h5Tag.localName().impl(), &HTMLParser::pCloserCreateErrorCheck);
gFunctionMap.set(h6Tag.localName().impl(), &HTMLParser::pCloserCreateErrorCheck);
gFunctionMap.set(headTag.localName().impl(), &HTMLParser::headCreateErrorCheck);
gFunctionMap.set(hrTag.localName().impl(), &HTMLParser::pCloserCreateErrorCheck);
gFunctionMap.set(iTag.localName().impl(), &HTMLParser::nestedStyleCreateErrorCheck);
gFunctionMap.set(isindexTag.localName().impl(), &HTMLParser::isindexCreateErrorCheck);
gFunctionMap.set(liTag.localName().impl(), &HTMLParser::nestedPCloserCreateErrorCheck);
gFunctionMap.set(listingTag.localName().impl(), &HTMLParser::pCloserCreateErrorCheck);
gFunctionMap.set(mapTag.localName().impl(), &HTMLParser::mapCreateErrorCheck);
gFunctionMap.set(menuTag.localName().impl(), &HTMLParser::pCloserCreateErrorCheck);
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(olTag.localName().impl(), &HTMLParser::pCloserCreateErrorCheck);
gFunctionMap.set(pTag.localName().impl(), &HTMLParser::pCloserCreateErrorCheck);
gFunctionMap.set(plaintextTag.localName().impl(), &HTMLParser::pCloserCreateErrorCheck);
gFunctionMap.set(preTag.localName().impl(), &HTMLParser::pCloserCreateErrorCheck);
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(tableTag.localName().impl(), &HTMLParser::pCloserStrictCreateErrorCheck);
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(ulTag.localName().impl(), &HTMLParser::pCloserCreateErrorCheck);
}
bool proceed = true;
RefPtr<Node> result;
if (CreateErrorCheckFunc errorCheckFunc = gFunctionMap.get(t->tagName.impl()))
proceed = (this->*errorCheckFunc)(t, result);
if (proceed)
result = HTMLElementFactory::createHTMLElement(QualifiedName(nullAtom, t->tagName, xhtmlNamespaceURI), document, m_currentFormElement.get());
return result.release();
}
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.
unsigned i = 0;
for (HTMLStackElem* curr = blockStack;
i < cMaxRedundantTagDepth && curr && curr->tagName == tagName;
curr = curr->next, i++) { }
return i != cMaxRedundantTagDepth;
}
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 || t->tagName == commentAtom)
return;
bool checkForCloseTagErrors = true;
if (t->tagName == formTag && m_currentFormElement) {
m_currentFormElement = 0;
checkForCloseTagErrors = false;
} else if (t->tagName == mapTag)
m_currentMapElement = 0;
else if (t->tagName == pTag)
checkForCloseTagErrors = false;
HTMLStackElem* oldElem = blockStack;
popBlock(t->tagName, checkForCloseTagErrors);
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);
reportError(StrayParagraphCloseError);
}
}
bool HTMLParser::isHeaderTag(const AtomicString& tagName)
{
DEFINE_STATIC_LOCAL(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());
}
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(noframesTag) || e->hasLocalName(nolayerTag) ||
e->hasLocalName(noembedTag))
return true;
if (e->hasLocalName(noscriptTag) && !m_isParsingFragment) {
Settings* settings = document->settings();
if (settings && settings->isJavaScriptEnabled())
return true;
}
}
return false;
}
bool HTMLParser::isResidualStyleTag(const AtomicString& tagName)
{
DEFINE_STATIC_LOCAL(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());
}
return residualStyleTags.contains(tagName.impl());
}
bool HTMLParser::isAffectedByResidualStyle(const AtomicString& tagName)
{
DEFINE_STATIC_LOCAL(HashSet<AtomicStringImpl*>, unaffectedTags, ());
if (unaffectedTags.isEmpty()) {
unaffectedTags.add(bodyTag.localName().impl());
unaffectedTags.add(tableTag.localName().impl());
unaffectedTags.add(theadTag.localName().impl());
unaffectedTags.add(tbodyTag.localName().impl());
unaffectedTags.add(tfootTag.localName().impl());
unaffectedTags.add(trTag.localName().impl());
unaffectedTags.add(thTag.localName().impl());
unaffectedTags.add(tdTag.localName().impl());
unaffectedTags.add(captionTag.localName().impl());
unaffectedTags.add(colgroupTag.localName().impl());
unaffectedTags.add(colTag.localName().impl());
unaffectedTags.add(optionTag.localName().impl());
unaffectedTags.add(optgroupTag.localName().impl());
unaffectedTags.add(selectTag.localName().impl());
unaffectedTags.add(objectTag.localName().impl());
}
return !unaffectedTags.contains(tagName.impl());
}
void HTMLParser::handleResidualStyleCloseTagAcrossBlocks(HTMLStackElem* elem)
{
HTMLStackElem* maxElem = 0;
bool finished = false;
bool strayTableContent = elem->strayTableContent;
m_handlingResidualStyleAcrossBlocks = true;
while (!finished) {
// Find the outermost element that crosses over to a higher level. If there exists another higher-level
// element, we will do another pass, until we have corrected the innermost one.
ExceptionCode ec = 0;
HTMLStackElem* curr = blockStack;
HTMLStackElem* prev = 0;
HTMLStackElem* prevMaxElem = 0;
maxElem = 0;
finished = true;
while (curr && curr != elem) {
if (curr->level > elem->level) {
if (!isAffectedByResidualStyle(curr->tagName))
return;
if (maxElem)
// We will need another pass.
finished = false;
maxElem = curr;
prevMaxElem = prev;
}
prev = curr;
curr = curr->next;
}
if (!curr || !maxElem)
return;
Node* residualElem = prev->node;
Node* blockElem = prevMaxElem ? prevMaxElem->node : current;
Node* parentElem = elem->node;
// 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;
m_hasPElementInScope = Unknown;
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->derefNode();
prevElem->node = currElem->node;
prevElem->didRefNode = currElem->didRefNode;
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.
// We call releaseRef to get a raw pointer since we plan to hand over ownership to currElem.
Node* currNode = currElem->node->cloneNode(false).releaseRef();
reportError(ResidualStyleError, &currNode->localName());
// Change the stack element's node to point to the clone.
// The stack element adopts the reference we obtained above by calling release().
currElem->derefNode();
currElem->node = currNode;
currElem->didRefNode = true;
// 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; // FIXME: We shifted parentElem to be a residual inline. We never checked to see if blockElem could be legally placed inside the inline though.
prevNode = currNode;
}
currElem = currElem->next;
}
// Now append the chain of new residual style elements if one exists.
if (prevNode)
elem->node->appendChild(prevNode, ec); // FIXME: This append can result in weird stuff happening, like an inline chain being put into a table section.
}
// 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://bugs.webkit.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 (isBlockStillInTree)
blockElem->parentNode()->removeChild(blockElem, ec);
Node* newNodePtr = 0;
if (blockElem->firstChild()) {
// Step 2: Clone |residualElem|.
RefPtr<Node> newNode = residualElem->cloneNode(false); // Shallow clone. We don't pick up the same kids.
newNodePtr = newNode.get();
reportError(ResidualStyleError, &newNode->localName());
// 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);
} else
finished = true;
// Step 5: Reparent |blockElem|. Now the full attachment of the fixed up tree takes place.
if (isBlockStillInTree)
parentElem->appendChild(blockElem, ec);
// Step 6: Pull |elem| out of the stack, since it is no longer enclosing us. 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->derefNode();
prevElem->node = elem->node;
prevElem->didRefNode = elem->didRefNode;
if (!finished) {
// Repurpose |elem| to represent |newNode| and insert it at the appropriate position
// in the stack. We do not do this for the innermost block, because in that case the new
// node is effectively no longer open.
elem->next = maxElem;
elem->node = prevMaxElem->node;
elem->didRefNode = prevMaxElem->didRefNode;
elem->strayTableContent = false;
prevMaxElem->next = elem;
ASSERT(newNodePtr);
prevMaxElem->node = newNodePtr;
prevMaxElem->didRefNode = false;
} else
delete elem;
}
// FIXME: If we ever make a case like this work:
// <table><b><i><form></b></form></i></table>
// Then this check will be too simplistic. Right now the <i><form> chain will end up inside the <tbody>, which is pretty crazy.
if (strayTableContent)
inStrayTableContent--;
// Step 7: Reopen intermediate inlines, e.g., <b><p><i>Foo</b>Goo</p>.
// In the above example, Goo should stay italic.
// We cap the number of tags we're willing to reopen based off cResidualStyleMaxDepth.
HTMLStackElem* curr = blockStack;
HTMLStackElem* residualStyleStack = 0;
unsigned stackDepth = 1;
unsigned redundantStyleCount = 0;
while (curr && curr != maxElem) {
// We will actually schedule this tag for reopening
// after we complete the close of this entire block.
if (isResidualStyleTag(curr->tagName) && stackDepth++ < cResidualStyleMaxDepth) {
// 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.
if (residualStyleStack && curr->tagName == residualStyleStack->tagName && curr->node->attributes()->mapsEquivalent(residualStyleStack->node->attributes()))
redundantStyleCount++;
else
redundantStyleCount = 0;
if (redundantStyleCount < cMaxRedundantTagDepth)
moveOneBlockToStack(residualStyleStack);
else
popOneBlock();
} else
popOneBlock();
curr = blockStack;
}
reopenResidualStyleTags(residualStyleStack, 0); // Stray table content can't be an issue here, since some element above will always become the root of new stray table content.
m_handlingResidualStyleAcrossBlocks = 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);
reportError(ResidualStyleError, &newNode->localName());
// 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);
newNode->beginParsingChildren();
// 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;
elem->derefNode();
delete elem;
elem = next;
}
}
void HTMLParser::pushBlock(const AtomicString& tagName, int level)
{
blockStack = new HTMLStackElem(tagName, level, current, didRefCurrent, blockStack);
if (level >= minBlockLevelTagPriority)
m_blocksInStack++;
didRefCurrent = false;
if (tagName == pTag)
m_hasPElementInScope = InScope;
else if (isScopingTag(tagName))
m_hasPElementInScope = NotInScope;
}
void HTMLParser::popBlock(const AtomicString& tagName, bool reportErrors)
{
HTMLStackElem* elem = blockStack;
int maxLevel = 0;
while (elem && (elem->tagName != tagName)) {
if (maxLevel < elem->level)
maxLevel = elem->level;
elem = elem->next;
}
if (!elem) {
if (reportErrors)
reportError(StrayCloseTagError, &tagName, 0, true);
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;
unsigned stackDepth = 1;
unsigned redundantStyleCount = 0;
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 (m_currentFormElement && 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.
m_currentFormElement->setMalformed(true);
// Schedule this tag for reopening
// after we complete the close of this entire block.
if (isAffectedByStyle && isResidualStyleTag(elem->tagName) && stackDepth++ < cResidualStyleMaxDepth) {
// 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.
if (residualStyleStack && elem->tagName == residualStyleStack->tagName && elem->node->attributes()->mapsEquivalent(residualStyleStack->node->attributes()))
redundantStyleCount++;
else
redundantStyleCount = 0;
if (redundantStyleCount < cMaxRedundantTagDepth)
moveOneBlockToStack(residualStyleStack);
else
popOneBlock();
} else
popOneBlock();
elem = blockStack;
}
}
reopenResidualStyleTags(residualStyleStack, malformedTableParent);
}
inline HTMLStackElem* HTMLParser::popOneBlockCommon()
{
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->finishParsingChildren();
if (blockStack->level >= minBlockLevelTagPriority) {
ASSERT(m_blocksInStack > 0);
m_blocksInStack--;
}
blockStack = elem->next;
current = elem->node;
didRefCurrent = elem->didRefNode;
if (elem->strayTableContent)
inStrayTableContent--;
if (elem->tagName == pTag)
m_hasPElementInScope = NotInScope;
else if (isScopingTag(elem->tagName))
m_hasPElementInScope = Unknown;
return elem;
}
void HTMLParser::popOneBlock()
{
// Store the current node before popOneBlockCommon overwrites it.
Node* lastCurrent = current;
bool didRefLastCurrent = didRefCurrent;
delete popOneBlockCommon();
if (didRefLastCurrent)
lastCurrent->deref();
}
void HTMLParser::moveOneBlockToStack(HTMLStackElem*& head)
{
// We'll be using the stack element we're popping, but for the current node.
// See the two callers for details.
// Store the current node before popOneBlockCommon overwrites it.
Node* lastCurrent = current;
bool didRefLastCurrent = didRefCurrent;
// Pop the block, but don't deref the current node as popOneBlock does because
// we'll be using the pointer in the new stack element.
HTMLStackElem* elem = popOneBlockCommon();
// Transfer the current node into the stack element.
// No need to deref the old elem->node because popOneBlockCommon transferred
// it into the current/didRefCurrent fields.
elem->node = lastCurrent;
elem->didRefNode = didRefLastCurrent;
elem->next = head;
head = elem;
}
void HTMLParser::checkIfHasPElementInScope()
{
m_hasPElementInScope = NotInScope;
HTMLStackElem* elem = blockStack;
while (elem) {
const AtomicString& tagName = elem->tagName;
if (tagName == pTag) {
m_hasPElementInScope = InScope;
return;
} else if (isScopingTag(tagName))
return;
elem = elem->next;
}
}
void HTMLParser::popInlineBlocks()
{
while (blockStack && isInline(current))
popOneBlock();
}
void HTMLParser::freeBlock()
{
while (blockStack)
popOneBlock();
ASSERT(!m_blocksInStack);
}
void HTMLParser::createHead()
{
if (head || !document->documentElement())
return;
head = new HTMLHeadElement(headTag, document);
HTMLElement* body = document->body();
ExceptionCode ec = 0;
document->documentElement()->insertBefore(head, body, ec);
if (ec)
head = 0;
// If the body does not exist yet, then the <head> should be pushed as the current block.
if (head && !body) {
pushBlock(head->localName(), head->tagPriority());
setCurrent(head);
}
}
PassRefPtr<Node> HTMLParser::handleIsindex(Token* t)
{
RefPtr<Node> n = new HTMLDivElement(divTag, document);
NamedMappedAttrMap* attrs = t->attrs.get();
RefPtr<HTMLIsIndexElement> isIndex = new HTMLIsIndexElement(isindexTag, document, m_currentFormElement.get());
isIndex->setAttributeMap(attrs);
isIndex->setAttribute(typeAttr, "khtml_isindex");
String text = searchableIndexIntroduction();
if (attrs) {
if (Attribute* a = attrs->getAttributeItem(promptAttr))
text = a->value().string() + " ";
t->attrs = 0;
}
n->addChild(new HTMLHRElement(hrTag, document));
n->addChild(new Text(document, text));
n->addChild(isIndex.release());
n->addChild(new HTMLHRElement(hrTag, document));
return n.release();
}
void HTMLParser::startBody()
{
if (inBody)
return;
inBody = true;
if (m_isindexElement) {
insertNode(m_isindexElement.get(), true /* don't descend into this node */);
m_isindexElement = 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() && !document->documentElement())
insertNode(new HTMLHtmlElement(htmlTag, 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_isParsingFragment)
document->finishedParsing();
}
void HTMLParser::reportErrorToConsole(HTMLParserErrorCode errorCode, const AtomicString* tagName1, const AtomicString* tagName2, bool closeTags)
{
Frame* frame = document->frame();
if (!frame)
return;
HTMLTokenizer* htmlTokenizer = static_cast<HTMLTokenizer*>(document->tokenizer());
int lineNumber = htmlTokenizer->lineNumber() + 1;
AtomicString tag1;
AtomicString tag2;
if (tagName1) {
if (*tagName1 == "#text")
tag1 = "Text";
else if (*tagName1 == "#comment")
tag1 = "<!-- comment -->";
else
tag1 = (closeTags ? "</" : "<") + *tagName1 + ">";
}
if (tagName2) {
if (*tagName2 == "#text")
tag2 = "Text";
else if (*tagName2 == "#comment")
tag2 = "<!-- comment -->";
else
tag2 = (closeTags ? "</" : "<") + *tagName2 + ">";
}
const char* errorMsg = htmlParserErrorMessageTemplate(errorCode);
if (!errorMsg)
return;
String message;
if (htmlTokenizer->processingContentWrittenByScript())
message += htmlParserDocumentWriteMessage();
message += errorMsg;
message.replace("%tag1", tag1);
message.replace("%tag2", tag2);
frame->domWindow()->console()->addMessage(HTMLMessageSource,
isWarning(errorCode) ? WarningMessageLevel : ErrorMessageLevel,
message, lineNumber, document->url().string());
}
}