1 /*

     2  * Copyright (C) 2010 Google, Inc. All Rights Reserved.

     3  *

     4  * Redistribution and use in source and binary forms, with or without

     5  * modification, are permitted provided that the following conditions

     6  * are met:

     7  * 1. Redistributions of source code must retain the above copyright

     8  *    notice, this list of conditions and the following disclaimer.

     9  * 2. Redistributions in binary form must reproduce the above copyright

    10  *    notice, this list of conditions and the following disclaimer in the

    11  *    documentation and/or other materials provided with the distribution.

    12  *

    13  * THIS SOFTWARE IS PROVIDED BY GOOGLE INC. ``AS IS'' AND ANY

    14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

    15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

    16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL GOOGLE INC. OR

    17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

    18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

    19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

    20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

    21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

    23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    24  */

    25 

    26 #include "config.h"

    27 #include "HTMLTreeBuilder.h"

    28 

    29 #include "Comment.h"

    30 #include "DocumentFragment.h"

    31 #include "DocumentType.h"

    32 #include "Element.h"

    33 #include "Frame.h"

    34 #include "HTMLDocument.h"

    35 #include "HTMLElementFactory.h"

    36 #include "HTMLFormElement.h"

    37 #include "HTMLHtmlElement.h"

    38 #include "HTMLNames.h"

    39 #include "HTMLScriptElement.h"

    40 #include "HTMLToken.h"

    41 #include "HTMLTokenizer.h"

    42 #include "LegacyHTMLDocumentParser.h"

    43 #include "LegacyHTMLTreeBuilder.h"

    44 #include "LocalizedStrings.h"

    45 #include "MathMLNames.h"

    46 #include "NotImplemented.h"

    47 #include "SVGNames.h"

    48 #include "ScriptController.h"

    49 #include "Settings.h"

    50 #include "Text.h"

    51 #include "XLinkNames.h"

    52 #include "XMLNSNames.h"

    53 #include "XMLNames.h"

    54 #include <wtf/UnusedParam.h>

    55 

    56 namespace WebCore {

    57 

    58 using namespace HTMLNames;

    59 

    60 static const int uninitializedLineNumberValue = -1;

    61 

    62 namespace {

    63 

    64 inline bool isTreeBuilderWhitepace(UChar cc)

    65 {

    66     return cc == '\t' || cc == '\x0A' || cc == '\x0C' || cc == '\x0D' || cc == ' ';

    67 }

    68 

    69 inline bool hasNonWhitespace(const String& string)

    70 {

    71     const UChar* characters = string.characters();

    72     const unsigned length = string.length();

    73     for (unsigned i = 0; i < length; ++i) {

    74         if (!isTreeBuilderWhitepace(characters[i]))

    75             return true;

    76     }

    77     return false;

    78 }

    79 

    80 bool shouldUseLegacyTreeBuilder(Document* document)

    81 {

    82     return !document->settings() || !document->settings()->html5TreeBuilderEnabled();

    83 }

    84 

    85 bool isNumberedHeaderTag(const AtomicString& tagName)

    86 {

    87     return tagName == h1Tag

    88         || tagName == h2Tag

    89         || tagName == h3Tag

    90         || tagName == h4Tag

    91         || tagName == h5Tag

    92         || tagName == h6Tag;

    93 }

    94 

    95 bool isCaptionColOrColgroupTag(const AtomicString& tagName)

    96 {

    97     return tagName == captionTag

    98         || tagName == colTag

    99         || tagName == colgroupTag;

   100 }

   101 

   102 bool isTableCellContextTag(const AtomicString& tagName)

   103 {

   104     return tagName == thTag || tagName == tdTag;

   105 }

   106 

   107 bool isTableBodyContextTag(const AtomicString& tagName)

   108 {

   109     return tagName == tbodyTag

   110         || tagName == tfootTag

   111         || tagName == theadTag;

   112 }

   113 

   114 // http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#special

   115 bool isSpecialTag(const AtomicString& tagName)

   116 {

   117     return tagName == addressTag

   118         || tagName == articleTag

   119         || tagName == asideTag

   120         || tagName == baseTag

   121         || tagName == basefontTag

   122         || tagName == "bgsound"

   123         || tagName == blockquoteTag

   124         || tagName == bodyTag

   125         || tagName == brTag

   126         || tagName == buttonTag

   127         || tagName == centerTag

   128         || tagName == colTag

   129         || tagName == colgroupTag

   130         || tagName == "command"

   131         || tagName == ddTag

   132         || tagName == "details"

   133         || tagName == dirTag

   134         || tagName == divTag

   135         || tagName == dlTag

   136         || tagName == dtTag

   137         || tagName == embedTag

   138         || tagName == fieldsetTag

   139         || tagName == "figure"

   140         || tagName == footerTag

   141         || tagName == formTag

   142         || tagName == frameTag

   143         || tagName == framesetTag

   144         || isNumberedHeaderTag(tagName)

   145         || tagName == headTag

   146         || tagName == headerTag

   147         || tagName == hgroupTag

   148         || tagName == hrTag

   149         || tagName == iframeTag

   150         || tagName == imgTag

   151         || tagName == inputTag

   152         || tagName == isindexTag

   153         || tagName == liTag

   154         || tagName == linkTag

   155         || tagName == listingTag

   156         || tagName == menuTag

   157         || tagName == metaTag

   158         || tagName == navTag

   159         || tagName == noembedTag

   160         || tagName == noframesTag

   161         || tagName == noscriptTag

   162         || tagName == olTag

   163         || tagName == pTag

   164         || tagName == paramTag

   165         || tagName == plaintextTag

   166         || tagName == preTag

   167         || tagName == scriptTag

   168         || tagName == sectionTag

   169         || tagName == selectTag

   170         || tagName == styleTag

   171         || isTableBodyContextTag(tagName)

   172         || tagName == textareaTag

   173         || tagName == titleTag

   174         || tagName == trTag

   175         || tagName == ulTag

   176         || tagName == wbrTag

   177         || tagName == xmpTag;

   178 }

   179 

   180 // http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#scoping

   181 // Same as isScopingTag in LegacyHTMLTreeBuilder.cpp

   182 // and isScopeMarker in HTMLElementStack.cpp

   183 bool isScopingTag(const AtomicString& tagName)

   184 {

   185     return tagName == appletTag

   186         || tagName == captionTag

   187         || tagName == SVGNames::foreignObjectTag

   188         || tagName == htmlTag

   189         || tagName == marqueeTag

   190         || tagName == objectTag

   191         || tagName == tableTag

   192         || isTableCellContextTag(tagName);

   193 }

   194 

   195 bool isNonAnchorNonNobrFormattingTag(const AtomicString& tagName)

   196 {

   197     return tagName == bTag

   198         || tagName == bigTag

   199         || tagName == codeTag

   200         || tagName == emTag

   201         || tagName == fontTag

   202         || tagName == iTag

   203         || tagName == sTag

   204         || tagName == smallTag

   205         || tagName == strikeTag

   206         || tagName == strongTag

   207         || tagName == ttTag

   208         || tagName == uTag;

   209 }

   210 

   211 bool isNonAnchorFormattingTag(const AtomicString& tagName)

   212 {

   213     return tagName == nobrTag

   214         || isNonAnchorNonNobrFormattingTag(tagName);

   215 }

   216 

   217 // http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#formatting

   218 bool isFormattingTag(const AtomicString& tagName)

   219 {

   220     return tagName == aTag || isNonAnchorFormattingTag(tagName);

   221 }

   222 

   223 // http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#phrasing

   224 bool isPhrasingTag(const AtomicString& tagName)

   225 {

   226     return !isSpecialTag(tagName) && !isScopingTag(tagName) && !isFormattingTag(tagName);

   227 }

   228 

   229 bool isNotFormattingAndNotPhrasing(const Element* element)

   230 {

   231     // The spec often says "node is not in the formatting category, and is not

   232     // in the phrasing category". !phrasing && !formatting == scoping || special

   233     // scoping || special is easier to compute.

   234     // FIXME: localName() is wrong for non-html content.

   235     const AtomicString& tagName = element->localName();

   236     return isScopingTag(tagName) || isSpecialTag(tagName);

   237 }

   238 

   239 } // namespace

   240 

   241 class HTMLTreeBuilder::ExternalCharacterTokenBuffer : public Noncopyable {

   242 public:

   243     explicit ExternalCharacterTokenBuffer(AtomicHTMLToken& token)

   244         : m_current(token.characters().data())

   245         , m_end(m_current + token.characters().size())

   246     {

   247         ASSERT(!isEmpty());

   248     }

   249 

   250     explicit ExternalCharacterTokenBuffer(const String& string)

   251         : m_current(string.characters())

   252         , m_end(m_current + string.length())

   253     {

   254         ASSERT(!isEmpty());

   255     }

   256 

   257     ~ExternalCharacterTokenBuffer()

   258     {

   259         ASSERT(isEmpty());

   260     }

   261 

   262     bool isEmpty() const { return m_current == m_end; }

   263 

   264     void skipLeadingWhitespace()

   265     {

   266         ASSERT(!isEmpty());

   267         while (isTreeBuilderWhitepace(*m_current)) {

   268             if (++m_current == m_end)

   269                 return;

   270         }

   271     }

   272 

   273     String takeLeadingWhitespace()

   274     {

   275         ASSERT(!isEmpty());

   276         const UChar* start = m_current;

   277         skipLeadingWhitespace();

   278         if (start == m_current)

   279             return String();

   280         return String(start, m_current - start);

   281     }

   282 

   283     String takeRemaining()

   284     {

   285         ASSERT(!isEmpty());

   286         const UChar* start = m_current;

   287         m_current = m_end;

   288         return String(start, m_current - start);

   289     }

   290 

   291     void giveRemainingTo(Vector<UChar>& recipient)

   292     {

   293         recipient.append(m_current, m_end - m_current);

   294         m_current = m_end;

   295     }

   296 

   297     String takeRemainingWhitespace()

   298     {

   299         ASSERT(!isEmpty());

   300         Vector<UChar> whitespace;

   301         do {

   302             UChar cc = *m_current++;

   303             if (isTreeBuilderWhitepace(cc))

   304                 whitespace.append(cc);

   305         } while (m_current < m_end);

   306         // Returning the null string when there aren't any whitespace

   307         // characters is slightly cleaner semantically because we don't want

   308         // to insert a text node (as opposed to inserting an empty text node).

   309         if (whitespace.isEmpty())

   310             return String();

   311         return String::adopt(whitespace);

   312     }

   313 

   314 private:

   315     const UChar* m_current;

   316     const UChar* m_end;

   317 };

   318 

   319 

   320 HTMLTreeBuilder::HTMLTreeBuilder(HTMLTokenizer* tokenizer, HTMLDocument* document, bool reportErrors)

   321     : m_framesetOk(true)

   322     , m_document(document)

   323     , m_tree(document, FragmentScriptingAllowed, false)

   324     , m_reportErrors(reportErrors)

   325     , m_isPaused(false)

   326     , m_insertionMode(InitialMode)

   327     , m_originalInsertionMode(InitialMode)

   328     , m_secondaryInsertionMode(InitialMode)

   329     , m_tokenizer(tokenizer)

   330     , m_legacyTreeBuilder(shouldUseLegacyTreeBuilder(document) ? new LegacyHTMLTreeBuilder(document, reportErrors) : 0)

   331     , m_lastScriptElementStartLine(uninitializedLineNumberValue)

   332     , m_scriptToProcessStartLine(uninitializedLineNumberValue)

   333     , m_fragmentScriptingPermission(FragmentScriptingAllowed)

   334     , m_isParsingFragment(false)

   335 {

   336 }

   337 

   338 // FIXME: Member variables should be grouped into self-initializing structs to

   339 // minimize code duplication between these constructors.

   340 HTMLTreeBuilder::HTMLTreeBuilder(HTMLTokenizer* tokenizer, DocumentFragment* fragment, FragmentScriptingPermission scriptingPermission)

   341     : m_framesetOk(true)

   342     , m_document(fragment->document())

   343     , m_tree(fragment->document(), scriptingPermission, true)

   344     , m_reportErrors(false) // FIXME: Why not report errors in fragments?

   345     , m_isPaused(false)

   346     , m_insertionMode(InitialMode)

   347     , m_originalInsertionMode(InitialMode)

   348     , m_secondaryInsertionMode(InitialMode)

   349     , m_tokenizer(tokenizer)

   350     , m_legacyTreeBuilder(new LegacyHTMLTreeBuilder(fragment, scriptingPermission))

   351     , m_lastScriptElementStartLine(uninitializedLineNumberValue)

   352     , m_scriptToProcessStartLine(uninitializedLineNumberValue)

   353     , m_fragmentScriptingPermission(scriptingPermission)

   354     , m_isParsingFragment(true)

   355 {

   356 }

   357 

   358 HTMLTreeBuilder::~HTMLTreeBuilder()

   359 {

   360 }

   361 

   362 static void convertToOldStyle(AtomicHTMLToken& token, Token& oldStyleToken)

   363 {

   364     switch (token.type()) {

   365     case HTMLToken::Uninitialized:

   366     case HTMLToken::DOCTYPE:

   367         ASSERT_NOT_REACHED();

   368         break;

   369     case HTMLToken::EndOfFile:

   370         ASSERT_NOT_REACHED();

   371         notImplemented();

   372         break;

   373     case HTMLToken::StartTag:

   374     case HTMLToken::EndTag: {

   375         oldStyleToken.beginTag = (token.type() == HTMLToken::StartTag);

   376         // The LegacyHTMLTreeBuilder seems to work better if we lie here and

   377         // say that tags are never self closing.  As a wise man once said:

   378         // "You can't handle the truth!"

   379         oldStyleToken.selfClosingTag = false;

   380         oldStyleToken.tagName = token.name();

   381         oldStyleToken.attrs = token.takeAtributes();

   382         break;

   383     }

   384     case HTMLToken::Comment:

   385         oldStyleToken.tagName = commentAtom;

   386         oldStyleToken.text = token.comment().impl();

   387         break;

   388     case HTMLToken::Character:

   389         oldStyleToken.tagName = textAtom;

   390         oldStyleToken.text = StringImpl::create(token.characters().data(), token.characters().size());

   391         break;

   392     }

   393 }

   394 

   395 void HTMLTreeBuilder::handleScriptStartTag()

   396 {

   397     notImplemented(); // The HTML frgment case?

   398     m_tokenizer->setState(HTMLTokenizer::ScriptDataState);

   399     notImplemented(); // Save insertion mode.

   400 }

   401 

   402 void HTMLTreeBuilder::handleScriptEndTag(Element* scriptElement, int scriptStartLine)

   403 {

   404     ASSERT(!m_scriptToProcess); // Caller never called takeScriptToProcess!

   405     ASSERT(m_scriptToProcessStartLine == uninitializedLineNumberValue); // Caller never called takeScriptToProcess!

   406     notImplemented(); // Save insertion mode and insertion point?

   407 

   408     // Pause ourselves so that parsing stops until the script can be processed by the caller.

   409     m_isPaused = true;

   410     m_scriptToProcess = scriptElement;

   411     // Lexer line numbers are 0-based, ScriptSourceCode expects 1-based lines,

   412     // so we convert here before passing the line number off to HTMLScriptRunner.

   413     m_scriptToProcessStartLine = scriptStartLine + 1;

   414 }

   415 

   416 PassRefPtr<Element> HTMLTreeBuilder::takeScriptToProcess(int& scriptStartLine)

   417 {

   418     // Unpause ourselves, callers may pause us again when processing the script.

   419     // The HTML5 spec is written as though scripts are executed inside the tree

   420     // builder.  We pause the parser to exit the tree builder, and then resume

   421     // before running scripts.

   422     m_isPaused = false;

   423     scriptStartLine = m_scriptToProcessStartLine;

   424     m_scriptToProcessStartLine = uninitializedLineNumberValue;

   425     return m_scriptToProcess.release();

   426 }

   427 

   428 HTMLTokenizer::State HTMLTreeBuilder::adjustedLexerState(HTMLTokenizer::State state, const AtomicString& tagName, Frame* frame)

   429 {

   430     if (tagName == textareaTag || tagName == titleTag)

   431         return HTMLTokenizer::RCDATAState;

   432 

   433     if (tagName == styleTag

   434         || tagName == iframeTag

   435         || tagName == xmpTag

   436         || tagName == noembedTag

   437         || tagName == noframesTag

   438         || (tagName == noscriptTag && isScriptingFlagEnabled(frame)))

   439         return HTMLTokenizer::RAWTEXTState;

   440 

   441     if (tagName == plaintextTag)

   442         return HTMLTokenizer::PLAINTEXTState;

   443 

   444     return state;

   445 }

   446 

   447 void HTMLTreeBuilder::passTokenToLegacyParser(HTMLToken& token)

   448 {

   449     if (token.type() == HTMLToken::DOCTYPE) {

   450         DoctypeToken doctypeToken;

   451         doctypeToken.m_name.append(token.name().data(), token.name().size());

   452         doctypeToken.m_publicID = token.publicIdentifier();

   453         doctypeToken.m_systemID = token.systemIdentifier();

   454         doctypeToken.m_forceQuirks = token.forceQuirks();

   455 

   456         m_legacyTreeBuilder->parseDoctypeToken(&doctypeToken);

   457         return;

   458     }

   459 

   460     if (token.type() == HTMLToken::EndOfFile)

   461         return;

   462 

   463     // For now, we translate into an old-style token for testing.

   464     Token oldStyleToken;

   465     AtomicHTMLToken atomicToken(token);

   466     convertToOldStyle(atomicToken, oldStyleToken);

   467 

   468     RefPtr<Node> result =  m_legacyTreeBuilder->parseToken(&oldStyleToken);

   469     if (token.type() == HTMLToken::StartTag) {

   470         // This work is supposed to be done by the parser, but

   471         // when using the old parser for we have to do this manually.

   472         if (oldStyleToken.tagName == scriptTag) {

   473             handleScriptStartTag();

   474             m_lastScriptElement = static_pointer_cast<Element>(result);

   475             m_lastScriptElementStartLine = m_tokenizer->lineNumber();

   476         } else if (oldStyleToken.tagName == preTag || oldStyleToken.tagName == listingTag)

   477             m_tokenizer->skipLeadingNewLineForListing();

   478         else

   479             m_tokenizer->setState(adjustedLexerState(m_tokenizer->state(), oldStyleToken.tagName, m_document->frame()));

   480     } else if (token.type() == HTMLToken::EndTag) {

   481         if (oldStyleToken.tagName == scriptTag) {

   482             if (m_lastScriptElement) {

   483                 ASSERT(m_lastScriptElementStartLine != uninitializedLineNumberValue);

   484                 if (m_fragmentScriptingPermission == FragmentScriptingNotAllowed) {

   485                     // FIXME: This is a horrible hack for platform/Pasteboard.

   486                     // Clear the <script> tag when using the Parser to create

   487                     // a DocumentFragment for pasting so that javascript content

   488                     // does not show up in pasted HTML.

   489                     m_lastScriptElement->removeChildren();

   490                 } else if (insertionMode() != AfterFramesetMode)

   491                     handleScriptEndTag(m_lastScriptElement.get(), m_lastScriptElementStartLine);

   492                 m_lastScriptElement = 0;

   493                 m_lastScriptElementStartLine = uninitializedLineNumberValue;

   494             }

   495         } else if (oldStyleToken.tagName == framesetTag)

   496             setInsertionMode(AfterFramesetMode);

   497     }

   498 }

   499 

   500 void HTMLTreeBuilder::constructTreeFromToken(HTMLToken& rawToken)

   501 {

   502     if (m_legacyTreeBuilder) {

   503         passTokenToLegacyParser(rawToken);

   504         return;

   505     }

   506 

   507     AtomicHTMLToken token(rawToken);

   508     processToken(token);

   509 }

   510 

   511 void HTMLTreeBuilder::processToken(AtomicHTMLToken& token)

   512 {

   513     switch (token.type()) {

   514     case HTMLToken::Uninitialized:

   515         ASSERT_NOT_REACHED();

   516         break;

   517     case HTMLToken::DOCTYPE:

   518         processDoctypeToken(token);

   519         break;

   520     case HTMLToken::StartTag:

   521         processStartTag(token);

   522         break;

   523     case HTMLToken::EndTag:

   524         processEndTag(token);

   525         break;

   526     case HTMLToken::Comment:

   527         processComment(token);

   528         return;

   529     case HTMLToken::Character:

   530         processCharacter(token);

   531         break;

   532     case HTMLToken::EndOfFile:

   533         processEndOfFile(token);

   534         break;

   535     }

   536 }

   537 

   538 void HTMLTreeBuilder::processDoctypeToken(AtomicHTMLToken& token)

   539 {

   540     ASSERT(token.type() == HTMLToken::DOCTYPE);

   541     if (m_insertionMode == InitialMode) {

   542         m_tree.insertDoctype(token);

   543         return;

   544     }

   545     if (m_insertionMode == InTableTextMode) {

   546         defaultForInTableText();

   547         processDoctypeToken(token);

   548         return;

   549     }

   550     parseError(token);

   551 }

   552 

   553 void HTMLTreeBuilder::processFakeStartTag(const QualifiedName& tagName, PassRefPtr<NamedNodeMap> attributes)

   554 {

   555     // FIXME: We'll need a fancier conversion than just "localName" for SVG/MathML tags.

   556     AtomicHTMLToken fakeToken(HTMLToken::StartTag, tagName.localName(), attributes);

   557     processStartTag(fakeToken);

   558 }

   559 

   560 void HTMLTreeBuilder::processFakeEndTag(const QualifiedName& tagName)

   561 {

   562     // FIXME: We'll need a fancier conversion than just "localName" for SVG/MathML tags.

   563     AtomicHTMLToken fakeToken(HTMLToken::EndTag, tagName.localName());

   564     processEndTag(fakeToken);

   565 }

   566 

   567 void HTMLTreeBuilder::processFakeCharacters(const String& characters)

   568 {

   569     ASSERT(!characters.isEmpty());

   570     ExternalCharacterTokenBuffer buffer(characters);

   571     processCharacterBuffer(buffer);

   572 }

   573 

   574 void HTMLTreeBuilder::processFakePEndTagIfPInButtonScope()

   575 {

   576     if (!m_tree.openElements()->inButtonScope(pTag.localName()))

   577         return;

   578     AtomicHTMLToken endP(HTMLToken::EndTag, pTag.localName());

   579     processEndTag(endP);

   580 }

   581 

   582 PassRefPtr<NamedNodeMap> HTMLTreeBuilder::attributesForIsindexInput(AtomicHTMLToken& token)

   583 {

   584     RefPtr<NamedNodeMap> attributes = token.takeAtributes();

   585     if (!attributes)

   586         attributes = NamedNodeMap::create();

   587     else {

   588         attributes->removeAttribute(nameAttr);

   589         attributes->removeAttribute(actionAttr);

   590         attributes->removeAttribute(promptAttr);

   591     }

   592 

   593     RefPtr<Attribute> mappedAttribute = Attribute::createMapped(nameAttr, isindexTag.localName());

   594     attributes->insertAttribute(mappedAttribute.release(), false);

   595     return attributes.release();

   596 }

   597 

   598 void HTMLTreeBuilder::processIsindexStartTagForInBody(AtomicHTMLToken& token)

   599 {

   600     ASSERT(token.type() == HTMLToken::StartTag);

   601     ASSERT(token.name() == isindexTag);

   602     parseError(token);

   603     if (m_tree.form())

   604         return;

   605     notImplemented(); // Acknowledge self-closing flag

   606     processFakeStartTag(formTag);

   607     Attribute* actionAttribute = token.getAttributeItem(actionAttr);

   608     if (actionAttribute) {

   609         ASSERT(m_tree.currentElement()->hasTagName(formTag));

   610         m_tree.currentElement()->setAttribute(actionAttr, actionAttribute->value());

   611     }

   612     processFakeStartTag(hrTag);

   613     processFakeStartTag(labelTag);

   614     Attribute* promptAttribute = token.getAttributeItem(promptAttr);

   615     if (promptAttribute)

   616         processFakeCharacters(promptAttribute->value());

   617     else

   618         processFakeCharacters(searchableIndexIntroduction());

   619     processFakeStartTag(inputTag, attributesForIsindexInput(token));

   620     notImplemented(); // This second set of characters may be needed by non-english locales.

   621     processFakeEndTag(labelTag);

   622     processFakeStartTag(hrTag);

   623     processFakeEndTag(formTag);

   624 }

   625 

   626 namespace {

   627 

   628 bool isLi(const Element* element)

   629 {

   630     return element->hasTagName(liTag);

   631 }

   632 

   633 bool isDdOrDt(const Element* element)

   634 {

   635     return element->hasTagName(ddTag)

   636         || element->hasTagName(dtTag);

   637 }

   638 

   639 }

   640 

   641 template <bool shouldClose(const Element*)>

   642 void HTMLTreeBuilder::processCloseWhenNestedTag(AtomicHTMLToken& token)

   643 {

   644     m_framesetOk = false;

   645     HTMLElementStack::ElementRecord* nodeRecord = m_tree.openElements()->topRecord();

   646     while (1) {

   647         Element* node = nodeRecord->element();

   648         if (shouldClose(node)) {

   649             processFakeEndTag(node->tagQName());

   650             break;

   651         }

   652         if (isNotFormattingAndNotPhrasing(node) && !node->hasTagName(addressTag) && !node->hasTagName(divTag) && !node->hasTagName(pTag))

   653             break;

   654         nodeRecord = nodeRecord->next();

   655     }

   656     processFakePEndTagIfPInButtonScope();

   657     m_tree.insertHTMLElement(token);

   658 }

   659 

   660 namespace {

   661 

   662 typedef HashMap<AtomicString, QualifiedName> PrefixedNameToQualifiedNameMap;

   663 

   664 void mapLoweredLocalNameToName(PrefixedNameToQualifiedNameMap* map, QualifiedName** names, size_t length)

   665 {

   666     for (size_t i = 0; i < length; ++i) {

   667         const QualifiedName& name = *names[i];

   668         const AtomicString& localName = name.localName();

   669         AtomicString loweredLocalName = localName.lower();

   670         if (loweredLocalName != localName)

   671             map->add(loweredLocalName, name);

   672     }

   673 }

   674 

   675 void addName(PrefixedNameToQualifiedNameMap* map, const QualifiedName& name)

   676 {

   677     map->add(name.localName().lower(), name);

   678 }

   679 

   680 void adjustSVGTagNameCase(AtomicHTMLToken& token)

   681 {

   682     static PrefixedNameToQualifiedNameMap* caseMap = 0;

   683     if (!caseMap) {

   684         caseMap = new PrefixedNameToQualifiedNameMap;

   685         size_t length = 0;

   686         QualifiedName** svgTags = SVGNames::getSVGTags(&length);

   687         mapLoweredLocalNameToName(caseMap, svgTags, length);

   688     }

   689 

   690     const QualifiedName& casedName = caseMap->get(token.name());

   691     if (casedName.localName().isNull())

   692         return;

   693     token.setName(casedName.localName());

   694 }

   695 

   696 void adjustSVGAttributes(AtomicHTMLToken& token)

   697 {

   698     static PrefixedNameToQualifiedNameMap* caseMap = 0;

   699     if (!caseMap) {

   700         caseMap = new PrefixedNameToQualifiedNameMap;

   701         size_t length = 0;

   702         QualifiedName** svgAttrs = SVGNames::getSVGAttrs(&length);

   703         mapLoweredLocalNameToName(caseMap, svgAttrs, length);

   704     }

   705 

   706     NamedNodeMap* attributes = token.attributes();

   707     if (!attributes)

   708         return;

   709 

   710     for (unsigned x = 0; x < attributes->length(); ++x) {

   711         Attribute* attribute = attributes->attributeItem(x);

   712         const QualifiedName& casedName = caseMap->get(attribute->localName());

   713         if (!casedName.localName().isNull())

   714             attribute->parserSetName(casedName);

   715     }

   716 }

   717 

   718 void adjustMathMLAttributes(AtomicHTMLToken&)

   719 {

   720     notImplemented();

   721 }

   722 

   723 void addNamesWithPrefix(PrefixedNameToQualifiedNameMap* map, const AtomicString& prefix, QualifiedName** names, size_t length)

   724 {

   725     for (size_t i = 0; i < length; ++i) {

   726         QualifiedName* name = names[i];

   727         const AtomicString& localName = name->localName();

   728         AtomicString prefixColonLocalName(prefix + ":" + localName);

   729         QualifiedName nameWithPrefix(prefix, localName, name->namespaceURI());

   730         map->add(prefixColonLocalName, nameWithPrefix);

   731     }

   732 }

   733 

   734 void adjustForeignAttributes(AtomicHTMLToken& token)

   735 {

   736     static PrefixedNameToQualifiedNameMap* map = 0;

   737     if (!map) {

   738         map = new PrefixedNameToQualifiedNameMap;

   739         size_t length = 0;

   740         QualifiedName** attrs = XLinkNames::getXLinkAttrs(&length);

   741         addNamesWithPrefix(map, "xlink", attrs, length);

   742 

   743         attrs = XMLNames::getXMLAttrs(&length);

   744         addNamesWithPrefix(map, "xml", attrs, length);

   745 

   746         map->add("xmlns", XMLNSNames::xmlnsAttr);

   747         map->add("xmlns:xlink", QualifiedName("xmlns", "xlink", XMLNSNames::xmlnsNamespaceURI));

   748     }

   749 

   750     NamedNodeMap* attributes = token.attributes();

   751     if (!attributes)

   752         return;

   753 

   754     for (unsigned x = 0; x < attributes->length(); ++x) {

   755         Attribute* attribute = attributes->attributeItem(x);

   756         const QualifiedName& name = map->get(attribute->localName());

   757         if (!name.localName().isNull())

   758             attribute->parserSetName(name);

   759     }

   760 }

   761 

   762 }

   763 

   764 void HTMLTreeBuilder::processStartTagForInBody(AtomicHTMLToken& token)

   765 {

   766     ASSERT(token.type() == HTMLToken::StartTag);

   767     if (token.name() == htmlTag) {

   768         m_tree.insertHTMLHtmlStartTagInBody(token);

   769         return;

   770     }

   771     if (token.name() == baseTag

   772         || token.name() == basefontTag

   773         || token.name() == "bgsound"

   774         || token.name() == "command"

   775         || token.name() == linkTag

   776         || token.name() == metaTag

   777         || token.name() == noframesTag

   778         || token.name() == scriptTag

   779         || token.name() == styleTag

   780         || token.name() == titleTag) {

   781         bool didProcess = processStartTagForInHead(token);

   782         ASSERT_UNUSED(didProcess, didProcess);

   783         return;

   784     }

   785     if (token.name() == bodyTag) {

   786         m_tree.insertHTMLBodyStartTagInBody(token);

   787         return;

   788     }

   789     if (token.name() == framesetTag) {

   790         parseError(token);

   791         notImplemented(); // fragment case

   792         if (!m_framesetOk)

   793             return;

   794         ExceptionCode ec = 0;

   795         m_tree.openElements()->bodyElement()->remove(ec);

   796         ASSERT(!ec);

   797         m_tree.openElements()->popUntil(m_tree.openElements()->bodyElement());

   798         m_tree.openElements()->popHTMLBodyElement();

   799         ASSERT(m_tree.openElements()->top() == m_tree.openElements()->htmlElement());

   800         m_tree.insertHTMLElement(token);

   801         setInsertionMode(InFramesetMode);

   802         return;

   803     }

   804     if (token.name() == addressTag

   805         || token.name() == articleTag

   806         || token.name() == asideTag

   807         || token.name() == blockquoteTag

   808         || token.name() == centerTag

   809         || token.name() == "details"

   810         || token.name() == dirTag

   811         || token.name() == divTag

   812         || token.name() == dlTag

   813         || token.name() == fieldsetTag

   814         || token.name() == "figcaption"

   815         || token.name() == "figure"

   816         || token.name() == footerTag

   817         || token.name() == headerTag

   818         || token.name() == hgroupTag

   819         || token.name() == menuTag

   820         || token.name() == navTag

   821         || token.name() == olTag

   822         || token.name() == pTag

   823         || token.name() == sectionTag

   824         || token.name() == "summary"

   825         || token.name() == ulTag) {

   826         processFakePEndTagIfPInButtonScope();

   827         m_tree.insertHTMLElement(token);

   828         return;

   829     }

   830     if (isNumberedHeaderTag(token.name())) {

   831         processFakePEndTagIfPInButtonScope();

   832         if (isNumberedHeaderTag(m_tree.currentElement()->localName())) {

   833             parseError(token);

   834             m_tree.openElements()->pop();

   835         }

   836         m_tree.insertHTMLElement(token);

   837         return;

   838     }

   839     if (token.name() == preTag || token.name() == listingTag) {

   840         processFakePEndTagIfPInButtonScope();

   841         m_tree.insertHTMLElement(token);

   842         m_tokenizer->skipLeadingNewLineForListing();

   843         m_framesetOk = false;

   844         return;

   845     }

   846     if (token.name() == formTag) {

   847         if (m_tree.form()) {

   848             parseError(token);

   849             return;

   850         }

   851         processFakePEndTagIfPInButtonScope();

   852         m_tree.insertHTMLFormElement(token);

   853         return;

   854     }

   855     if (token.name() == liTag) {

   856         processCloseWhenNestedTag<isLi>(token);

   857         return;

   858     }

   859     if (token.name() == ddTag || token.name() == dtTag) {

   860         processCloseWhenNestedTag<isDdOrDt>(token);

   861         return;

   862     }

   863     if (token.name() == plaintextTag) {

   864         processFakePEndTagIfPInButtonScope();

   865         m_tree.insertHTMLElement(token);

   866         m_tokenizer->setState(HTMLTokenizer::PLAINTEXTState);

   867         return;

   868     }

   869     if (token.name() == buttonTag) {

   870         if (m_tree.openElements()->inScope(buttonTag)) {

   871             parseError(token);

   872             processFakeEndTag(buttonTag);

   873             processStartTag(token); // FIXME: Could we just fall through here?

   874             return;

   875         }

   876         m_tree.reconstructTheActiveFormattingElements();

   877         m_tree.insertHTMLElement(token);

   878         m_framesetOk = false;

   879         return;

   880     }

   881     if (token.name() == aTag) {

   882         Element* activeATag = m_tree.activeFormattingElements()->closestElementInScopeWithName(aTag.localName());

   883         if (activeATag) {

   884             parseError(token);

   885             processFakeEndTag(aTag);

   886             m_tree.activeFormattingElements()->remove(activeATag);

   887             if (m_tree.openElements()->contains(activeATag))

   888                 m_tree.openElements()->remove(activeATag);

   889         }

   890         m_tree.reconstructTheActiveFormattingElements();

   891         m_tree.insertFormattingElement(token);

   892         return;

   893     }

   894     if (isNonAnchorNonNobrFormattingTag(token.name())) {

   895         m_tree.reconstructTheActiveFormattingElements();

   896         m_tree.insertFormattingElement(token);

   897         return;

   898     }

   899     if (token.name() == nobrTag) {

   900         m_tree.reconstructTheActiveFormattingElements();

   901         if (m_tree.openElements()->inScope(nobrTag)) {

   902             parseError(token);

   903             processFakeEndTag(nobrTag);

   904             m_tree.reconstructTheActiveFormattingElements();

   905         }

   906         m_tree.insertFormattingElement(token);

   907         return;

   908     }

   909     if (token.name() == appletTag

   910         || token.name() == marqueeTag

   911         || token.name() == objectTag) {

   912         m_tree.reconstructTheActiveFormattingElements();

   913         m_tree.insertHTMLElement(token);

   914         m_tree.activeFormattingElements()->appendMarker();

   915         m_framesetOk = false;

   916         return;

   917     }

   918     if (token.name() == tableTag) {

   919         if (m_document->parseMode() != Document::Compat && m_tree.openElements()->inScope(pTag))

   920             processFakeEndTag(pTag);

   921         m_tree.insertHTMLElement(token);

   922         m_framesetOk = false;

   923         setInsertionMode(InTableMode);

   924         return;

   925     }

   926     if (token.name() == imageTag) {

   927         parseError(token);

   928         // Apparently we're not supposed to ask.

   929         token.setName(imgTag.localName());

   930         // Note the fall through to the imgTag handling below!

   931     }

   932     if (token.name() == areaTag

   933         || token.name() == brTag

   934         || token.name() == embedTag

   935         || token.name() == imgTag

   936         || token.name() == inputTag

   937         || token.name() == keygenTag

   938         || token.name() == wbrTag) {

   939         m_tree.reconstructTheActiveFormattingElements();

   940         m_tree.insertSelfClosingHTMLElement(token);

   941         m_framesetOk = false;

   942         return;

   943     }

   944     if (token.name() == paramTag

   945         || token.name() == sourceTag

   946         || token.name() == "track") {

   947         m_tree.insertSelfClosingHTMLElement(token);

   948         return;

   949     }

   950     if (token.name() == hrTag) {

   951         processFakePEndTagIfPInButtonScope();

   952         m_tree.insertSelfClosingHTMLElement(token);

   953         m_framesetOk = false;

   954         return;

   955     }

   956     if (token.name() == isindexTag) {

   957         processIsindexStartTagForInBody(token);

   958         return;

   959     }

   960     if (token.name() == textareaTag) {

   961         m_tree.insertHTMLElement(token);

   962         m_tokenizer->skipLeadingNewLineForListing();

   963         m_tokenizer->setState(HTMLTokenizer::RCDATAState);

   964         m_originalInsertionMode = m_insertionMode;

   965         m_framesetOk = false;

   966         setInsertionMode(TextMode);

   967         return;

   968     }

   969     if (token.name() == xmpTag) {

   970         processFakePEndTagIfPInButtonScope();

   971         m_tree.reconstructTheActiveFormattingElements();

   972         m_framesetOk = false;

   973         processGenericRawTextStartTag(token);

   974         return;

   975     }

   976     if (token.name() == iframeTag) {

   977         m_framesetOk = false;

   978         processGenericRawTextStartTag(token);

   979         return;

   980     }

   981     if (token.name() == noembedTag) {

   982         processGenericRawTextStartTag(token);

   983         return;

   984     }

   985     if (token.name() == noscriptTag && isScriptingFlagEnabled(m_document->frame())) {

   986         processGenericRawTextStartTag(token);

   987         return;

   988     }

   989     if (token.name() == selectTag) {

   990         m_tree.reconstructTheActiveFormattingElements();

   991         m_tree.insertHTMLElement(token);

   992         m_framesetOk = false;

   993         if (m_insertionMode == InTableMode

   994              || m_insertionMode == InCaptionMode

   995              || m_insertionMode == InColumnGroupMode

   996              || m_insertionMode == InTableBodyMode

   997              || m_insertionMode == InRowMode

   998              || m_insertionMode == InCellMode)

   999             setInsertionMode(InSelectInTableMode);

  1000         else

  1001             setInsertionMode(InSelectMode);

  1002         return;

  1003     }

  1004     if (token.name() == optgroupTag || token.name() == optionTag) {

  1005         if (m_tree.openElements()->inScope(optionTag.localName())) {

  1006             AtomicHTMLToken endOption(HTMLToken::EndTag, optionTag.localName());

  1007             processEndTag(endOption);

  1008         }

  1009         m_tree.reconstructTheActiveFormattingElements();

  1010         m_tree.insertHTMLElement(token);

  1011         return;

  1012     }

  1013     if (token.name() == rpTag || token.name() == rtTag) {

  1014         if (m_tree.openElements()->inScope(rubyTag.localName())) {

  1015             m_tree.generateImpliedEndTags();

  1016             if (!m_tree.currentElement()->hasTagName(rubyTag)) {

  1017                 parseError(token);

  1018                 m_tree.openElements()->popUntil(rubyTag.localName());

  1019             }

  1020         }

  1021         m_tree.insertHTMLElement(token);

  1022         return;

  1023     }

  1024     if (token.name() == MathMLNames::mathTag.localName()) {

  1025         m_tree.reconstructTheActiveFormattingElements();

  1026         adjustMathMLAttributes(token);

  1027         adjustForeignAttributes(token);

  1028         m_tree.insertForeignElement(token, MathMLNames::mathmlNamespaceURI);

  1029         if (m_insertionMode != InForeignContentMode) {

  1030             setSecondaryInsertionMode(m_insertionMode);

  1031             setInsertionMode(InForeignContentMode);

  1032         }

  1033         return;

  1034     }

  1035     if (token.name() == SVGNames::svgTag.localName()) {

  1036         m_tree.reconstructTheActiveFormattingElements();

  1037         adjustSVGAttributes(token);

  1038         adjustForeignAttributes(token);

  1039         m_tree.insertForeignElement(token, SVGNames::svgNamespaceURI);

  1040         if (m_insertionMode != InForeignContentMode) {

  1041             setSecondaryInsertionMode(m_insertionMode);

  1042             setInsertionMode(InForeignContentMode);

  1043         }

  1044         return;

  1045     }

  1046     if (isCaptionColOrColgroupTag(token.name())

  1047         || token.name() == frameTag

  1048         || token.name() == headTag

  1049         || isTableBodyContextTag(token.name())

  1050         || isTableCellContextTag(token.name())

  1051         || token.name() == trTag) {

  1052         parseError(token);

  1053         return;

  1054     }

  1055     m_tree.reconstructTheActiveFormattingElements();

  1056     m_tree.insertHTMLElement(token);

  1057 }

  1058 

  1059 bool HTMLTreeBuilder::processColgroupEndTagForInColumnGroup()

  1060 {

  1061     if (m_tree.currentElement() == m_tree.openElements()->htmlElement()) {

  1062         ASSERT(m_isParsingFragment);

  1063         // FIXME: parse error

  1064         return false;

  1065     }

  1066     m_tree.openElements()->pop();

  1067     setInsertionMode(InTableMode);

  1068     return true;

  1069 }

  1070 

  1071 // http://www.whatwg.org/specs/web-apps/current-work/multipage/tokenization.html#close-the-cell

  1072 void HTMLTreeBuilder::closeTheCell()

  1073 {

  1074     ASSERT(insertionMode() == InCellMode);

  1075     if (m_tree.openElements()->inTableScope(tdTag)) {

  1076         ASSERT(!m_tree.openElements()->inTableScope(thTag));

  1077         processFakeEndTag(tdTag);

  1078         return;

  1079     }

  1080     ASSERT(m_tree.openElements()->inTableScope(thTag));

  1081     processFakeEndTag(thTag);

  1082     ASSERT(insertionMode() == InRowMode);

  1083 }

  1084 

  1085 void HTMLTreeBuilder::processStartTagForInTable(AtomicHTMLToken& token)

  1086 {

  1087     ASSERT(token.type() == HTMLToken::StartTag);

  1088     if (token.name() == captionTag) {

  1089         m_tree.openElements()->popUntilTableScopeMarker();

  1090         m_tree.activeFormattingElements()->appendMarker();

  1091         m_tree.insertHTMLElement(token);

  1092         setInsertionMode(InCaptionMode);

  1093         return;

  1094     }

  1095     if (token.name() == colgroupTag) {

  1096         m_tree.openElements()->popUntilTableScopeMarker();

  1097         m_tree.insertHTMLElement(token);

  1098         setInsertionMode(InColumnGroupMode);

  1099         return;

  1100     }

  1101     if (token.name() == colTag) {

  1102         processFakeStartTag(colgroupTag);

  1103         ASSERT(InColumnGroupMode);

  1104         processStartTag(token);

  1105         return;

  1106     }

  1107     if (isTableBodyContextTag(token.name())) {

  1108         m_tree.openElements()->popUntilTableScopeMarker();

  1109         m_tree.insertHTMLElement(token);

  1110         setInsertionMode(InTableBodyMode);

  1111         return;

  1112     }

  1113     if (isTableCellContextTag(token.name())

  1114         || token.name() == trTag) {

  1115         processFakeStartTag(tbodyTag);

  1116         ASSERT(insertionMode() == InTableBodyMode);

  1117         processStartTag(token);

  1118         return;

  1119     }

  1120     if (token.name() == tableTag) {

  1121         parseError(token);

  1122         if (!processTableEndTagForInTable()) {

  1123             ASSERT(m_isParsingFragment);

  1124             return;

  1125         }

  1126         processStartTag(token);

  1127         return;

  1128     }

  1129     if (token.name() == styleTag || token.name() == scriptTag) {

  1130         processStartTagForInHead(token);

  1131         return;

  1132     }

  1133     if (token.name() == inputTag) {

  1134         Attribute* typeAttribute = token.getAttributeItem(typeAttr);

  1135         if (typeAttribute && equalIgnoringCase(typeAttribute->value(), "hidden")) {