/*
* Copyright (C) 2008 Apple Inc. All Rights Reserved.
* Copyright (C) 2009 Torch Mobile, Inc. http://www.torchmobile.com/
* Copyright (C) 2010 Google, Inc. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "ios/third_party/blink/src/html_tokenizer.h"
#include "html_markup_tokenizer_inlines.h"
namespace WebCore {
#define HTML_BEGIN_STATE(stateName) BEGIN_STATE(HTMLTokenizer, stateName)
#define HTML_RECONSUME_IN(stateName) RECONSUME_IN(HTMLTokenizer, stateName)
#define HTML_ADVANCE_TO(stateName) ADVANCE_TO(HTMLTokenizer, stateName)
#define HTML_SWITCH_TO(stateName) SWITCH_TO(HTMLTokenizer, stateName)
HTMLTokenizer::HTMLTokenizer()
: m_state(HTMLTokenizer::DataState)
, m_token(nullptr)
, m_additionalAllowedCharacter('\0')
, m_inputStreamPreprocessor(this)
{
}
HTMLTokenizer::~HTMLTokenizer()
{
}
void HTMLTokenizer::reset()
{
m_state = HTMLTokenizer::DataState;
m_token = 0;
m_additionalAllowedCharacter = '\0';
}
bool HTMLTokenizer::flushBufferedEndTag(CharacterProvider& source)
{
ASSERT(m_token->type() == HTMLToken::Character || m_token->type() == HTMLToken::Uninitialized);
source.next();
if (m_token->type() == HTMLToken::Character)
return true;
return false;
}
#define FLUSH_AND_ADVANCE_TO(stateName) \
do { \
m_state = HTMLTokenizer::stateName; \
if (flushBufferedEndTag(source)) \
return true; \
if (source.isEmpty() \
|| !m_inputStreamPreprocessor.peek(source)) \
return haveBufferedCharacterToken(); \
cc = m_inputStreamPreprocessor.nextInputCharacter(); \
goto stateName; \
} while (false)
bool HTMLTokenizer::nextToken(CharacterProvider& source, HTMLToken& token)
{
// If we have a token in progress, then we're supposed to be called back
// with the same token so we can finish it.
ASSERT(!m_token || m_token == &token || token.type() == HTMLToken::Uninitialized);
m_token = &token;
if (source.isEmpty() || !m_inputStreamPreprocessor.peek(source))
return haveBufferedCharacterToken();
UChar cc = m_inputStreamPreprocessor.nextInputCharacter();
// Source: http://www.whatwg.org/specs/web-apps/current-work/#tokenisation0
switch (m_state) {
HTML_BEGIN_STATE(DataState) {
if (cc == '<') {
if (m_token->type() == HTMLToken::Character) {
// We have a bunch of character tokens queued up that we
// are emitting lazily here.
return true;
}
HTML_ADVANCE_TO(TagOpenState);
} else if (cc == kEndOfFileMarker)
return emitEndOfFile(source);
else {
m_token->ensureIsCharacterToken();
HTML_ADVANCE_TO(DataState);
}
}
END_STATE()
HTML_BEGIN_STATE(TagOpenState) {
if (cc == '!')
HTML_ADVANCE_TO(MarkupDeclarationOpenState);
else if (cc == '/')
HTML_ADVANCE_TO(EndTagOpenState);
else if (isASCIIUpper(cc)) {
m_token->beginStartTag(toLowerCase(cc));
HTML_ADVANCE_TO(TagNameState);
} else if (isASCIILower(cc)) {
m_token->beginStartTag(cc);
HTML_ADVANCE_TO(TagNameState);
} else if (cc == '?') {
parseError();
// The spec consumes the current character before switching
// to the bogus comment state, but it's easier to implement
// if we reconsume the current character.
HTML_RECONSUME_IN(BogusCommentState);
} else {
parseError();
m_token->ensureIsCharacterToken();
HTML_RECONSUME_IN(DataState);
}
}
END_STATE()
HTML_BEGIN_STATE(EndTagOpenState) {
if (isASCIIUpper(cc)) {
m_token->beginEndTag(static_cast<LChar>(toLowerCase(cc)));
HTML_ADVANCE_TO(TagNameState);
} else if (isASCIILower(cc)) {
m_token->beginEndTag(static_cast<LChar>(cc));
HTML_ADVANCE_TO(TagNameState);
} else if (cc == '>') {
parseError();
HTML_ADVANCE_TO(DataState);
} else if (cc == kEndOfFileMarker) {
parseError();
m_token->ensureIsCharacterToken();
HTML_RECONSUME_IN(DataState);
} else {
parseError();
HTML_RECONSUME_IN(BogusCommentState);
}
}
END_STATE()
HTML_BEGIN_STATE(TagNameState) {
if (isTokenizerWhitespace(cc))
HTML_ADVANCE_TO(BeforeAttributeNameState);
else if (cc == '/')
HTML_ADVANCE_TO(SelfClosingStartTagState);
else if (cc == '>')
return emitAndResumeIn(source, HTMLTokenizer::DataState);
else if (isASCIIUpper(cc)) {
m_token->appendToName(toLowerCase(cc));
HTML_ADVANCE_TO(TagNameState);
} else if (cc == kEndOfFileMarker) {
parseError();
HTML_RECONSUME_IN(DataState);
} else {
m_token->appendToName(cc);
HTML_ADVANCE_TO(TagNameState);
}
}
END_STATE()
HTML_BEGIN_STATE(BeforeAttributeNameState) {
if (isTokenizerWhitespace(cc))
HTML_ADVANCE_TO(BeforeAttributeNameState);
else if (cc == '/')
HTML_ADVANCE_TO(SelfClosingStartTagState);
else if (cc == '>')
return emitAndResumeIn(source, HTMLTokenizer::DataState);
else if (isASCIIUpper(cc)) {
HTML_ADVANCE_TO(AttributeNameState);
} else if (cc == kEndOfFileMarker) {
parseError();
HTML_RECONSUME_IN(DataState);
} else {
if (cc == '"' || cc == '\'' || cc == '<' || cc == '=')
parseError();
HTML_ADVANCE_TO(AttributeNameState);
}
}
END_STATE()
HTML_BEGIN_STATE(AttributeNameState) {
if (isTokenizerWhitespace(cc)) {
HTML_ADVANCE_TO(AfterAttributeNameState);
} else if (cc == '/') {
HTML_ADVANCE_TO(SelfClosingStartTagState);
} else if (cc == '=') {
HTML_ADVANCE_TO(BeforeAttributeValueState);
} else if (cc == '>') {
return emitAndResumeIn(source, HTMLTokenizer::DataState);
} else if (isASCIIUpper(cc)) {
HTML_ADVANCE_TO(AttributeNameState);
} else if (cc == kEndOfFileMarker) {
parseError();
HTML_RECONSUME_IN(DataState);
} else {
if (cc == '"' || cc == '\'' || cc == '<' || cc == '=')
parseError();
HTML_ADVANCE_TO(AttributeNameState);
}
}
END_STATE()
HTML_BEGIN_STATE(AfterAttributeNameState) {
if (isTokenizerWhitespace(cc))
HTML_ADVANCE_TO(AfterAttributeNameState);
else if (cc == '/')
HTML_ADVANCE_TO(SelfClosingStartTagState);
else if (cc == '=')
HTML_ADVANCE_TO(BeforeAttributeValueState);
else if (cc == '>')
return emitAndResumeIn(source, HTMLTokenizer::DataState);
else if (isASCIIUpper(cc)) {
HTML_ADVANCE_TO(AttributeNameState);
} else if (cc == kEndOfFileMarker) {
parseError();
HTML_RECONSUME_IN(DataState);
} else {
if (cc == '"' || cc == '\'' || cc == '<')
parseError();
HTML_ADVANCE_TO(AttributeNameState);
}
}
END_STATE()
HTML_BEGIN_STATE(BeforeAttributeValueState) {
if (isTokenizerWhitespace(cc))
HTML_ADVANCE_TO(BeforeAttributeValueState);
else if (cc == '"') {
HTML_ADVANCE_TO(AttributeValueDoubleQuotedState);
} else if (cc == '&') {
HTML_RECONSUME_IN(AttributeValueUnquotedState);
} else if (cc == '\'') {
HTML_ADVANCE_TO(AttributeValueSingleQuotedState);
} else if (cc == '>') {
parseError();
return emitAndResumeIn(source, HTMLTokenizer::DataState);
} else if (cc == kEndOfFileMarker) {
parseError();
HTML_RECONSUME_IN(DataState);
} else {
if (cc == '<' || cc == '=' || cc == '`')
parseError();
HTML_ADVANCE_TO(AttributeValueUnquotedState);
}
}
END_STATE()
HTML_BEGIN_STATE(AttributeValueDoubleQuotedState) {
if (cc == '"') {
HTML_ADVANCE_TO(AfterAttributeValueQuotedState);
} else if (cc == kEndOfFileMarker) {
parseError();
HTML_RECONSUME_IN(DataState);
} else {
HTML_ADVANCE_TO(AttributeValueDoubleQuotedState);
}
}
END_STATE()
HTML_BEGIN_STATE(AttributeValueSingleQuotedState) {
if (cc == '\'') {
HTML_ADVANCE_TO(AfterAttributeValueQuotedState);
} else if (cc == kEndOfFileMarker) {
parseError();
HTML_RECONSUME_IN(DataState);
} else {
HTML_ADVANCE_TO(AttributeValueSingleQuotedState);
}
}
END_STATE()
HTML_BEGIN_STATE(AttributeValueUnquotedState) {
if (isTokenizerWhitespace(cc)) {
HTML_ADVANCE_TO(BeforeAttributeNameState);
} else if (cc == '>') {
return emitAndResumeIn(source, HTMLTokenizer::DataState);
} else if (cc == kEndOfFileMarker) {
parseError();
HTML_RECONSUME_IN(DataState);
} else {
if (cc == '"' || cc == '\'' || cc == '<' || cc == '=' || cc == '`')
parseError();
HTML_ADVANCE_TO(AttributeValueUnquotedState);
}
}
END_STATE()
HTML_BEGIN_STATE(AfterAttributeValueQuotedState) {
if (isTokenizerWhitespace(cc))
HTML_ADVANCE_TO(BeforeAttributeNameState);
else if (cc == '/')
HTML_ADVANCE_TO(SelfClosingStartTagState);
else if (cc == '>')
return emitAndResumeIn(source, HTMLTokenizer::DataState);
else if (cc == kEndOfFileMarker) {
parseError();
HTML_RECONSUME_IN(DataState);
} else {
parseError();
HTML_RECONSUME_IN(BeforeAttributeNameState);
}
}
END_STATE()
HTML_BEGIN_STATE(SelfClosingStartTagState) {
if (cc == '>') {
return emitAndResumeIn(source, HTMLTokenizer::DataState);
} else if (cc == kEndOfFileMarker) {
parseError();
HTML_RECONSUME_IN(DataState);
} else {
parseError();
HTML_RECONSUME_IN(BeforeAttributeNameState);
}
}
END_STATE()
HTML_BEGIN_STATE(BogusCommentState) {
m_token->beginComment();
HTML_RECONSUME_IN(ContinueBogusCommentState);
}
END_STATE()
HTML_BEGIN_STATE(ContinueBogusCommentState) {
if (cc == '>')
return emitAndResumeIn(source, HTMLTokenizer::DataState);
else if (cc == kEndOfFileMarker)
return emitAndReconsumeIn(source, HTMLTokenizer::DataState);
else {
HTML_ADVANCE_TO(ContinueBogusCommentState);
}
}
END_STATE()
HTML_BEGIN_STATE(MarkupDeclarationOpenState) {
DEFINE_STATIC_LOCAL_STRING(dashDashString, "--");
DEFINE_STATIC_LOCAL_STRING(doctypeString, "doctype");
if (cc == '-') {
if (source.startsWith(dashDashString, dashDashStringLength)) {
advanceAndASSERT(source, '-');
advanceAndASSERT(source, '-');
m_token->beginComment();
HTML_SWITCH_TO(CommentStartState);
} else if (source.remainingBytes() < dashDashStringLength)
return haveBufferedCharacterToken();
} else if (cc == 'D' || cc == 'd') {
if (source.startsWith(doctypeString, doctypeStringLength, true)) {
advanceStringAndASSERTIgnoringCase(source, doctypeString);
HTML_SWITCH_TO(DOCTYPEState);
} else if (source.remainingBytes() < doctypeStringLength)
return haveBufferedCharacterToken();
}
parseError();
HTML_RECONSUME_IN(BogusCommentState);
}
END_STATE()
HTML_BEGIN_STATE(CommentStartState) {
if (cc == '-')
HTML_ADVANCE_TO(CommentStartDashState);
else if (cc == '>') {
parseError();
return emitAndResumeIn(source, HTMLTokenizer::DataState);
} else if (cc == kEndOfFileMarker) {
parseError();
return emitAndReconsumeIn(source, HTMLTokenizer::DataState);
} else {
HTML_ADVANCE_TO(CommentState);
}
}
END_STATE()
HTML_BEGIN_STATE(CommentStartDashState) {
if (cc == '-')
HTML_ADVANCE_TO(CommentEndState);
else if (cc == '>') {
parseError();
return emitAndResumeIn(source, HTMLTokenizer::DataState);
} else if (cc == kEndOfFileMarker) {
parseError();
return emitAndReconsumeIn(source, HTMLTokenizer::DataState);
} else {
HTML_ADVANCE_TO(CommentState);
}
}
END_STATE()
HTML_BEGIN_STATE(CommentState) {
if (cc == '-')
HTML_ADVANCE_TO(CommentEndDashState);
else if (cc == kEndOfFileMarker) {
parseError();
return emitAndReconsumeIn(source, HTMLTokenizer::DataState);
} else {
HTML_ADVANCE_TO(CommentState);
}
}
END_STATE()
HTML_BEGIN_STATE(CommentEndDashState) {
if (cc == '-')
HTML_ADVANCE_TO(CommentEndState);
else if (cc == kEndOfFileMarker) {
parseError();
return emitAndReconsumeIn(source, HTMLTokenizer::DataState);
} else {
HTML_ADVANCE_TO(CommentState);
}
}
END_STATE()
HTML_BEGIN_STATE(CommentEndState) {
if (cc == '>')
return emitAndResumeIn(source, HTMLTokenizer::DataState);
else if (cc == '!') {
parseError();
HTML_ADVANCE_TO(CommentEndBangState);
} else if (cc == '-') {
parseError();
HTML_ADVANCE_TO(CommentEndState);
} else if (cc == kEndOfFileMarker) {
parseError();
return emitAndReconsumeIn(source, HTMLTokenizer::DataState);
} else {
parseError();
HTML_ADVANCE_TO(CommentState);
}
}
END_STATE()
HTML_BEGIN_STATE(CommentEndBangState) {
if (cc == '-') {
HTML_ADVANCE_TO(CommentEndDashState);
} else if (cc == '>')
return emitAndResumeIn(source, HTMLTokenizer::DataState);
else if (cc == kEndOfFileMarker) {
parseError();
return emitAndReconsumeIn(source, HTMLTokenizer::DataState);
} else {
HTML_ADVANCE_TO(CommentState);
}
}
END_STATE()
HTML_BEGIN_STATE(DOCTYPEState) {
if (isTokenizerWhitespace(cc))
HTML_ADVANCE_TO(BeforeDOCTYPENameState);
else if (cc == kEndOfFileMarker) {
parseError();
m_token->beginDOCTYPE();
return emitAndReconsumeIn(source, HTMLTokenizer::DataState);
} else {
parseError();
HTML_RECONSUME_IN(BeforeDOCTYPENameState);
}
}
END_STATE()
HTML_BEGIN_STATE(BeforeDOCTYPENameState) {
if (isTokenizerWhitespace(cc))
HTML_ADVANCE_TO(BeforeDOCTYPENameState);
else if (cc == '>') {
parseError();
m_token->beginDOCTYPE();
return emitAndResumeIn(source, HTMLTokenizer::DataState);
} else if (cc == kEndOfFileMarker) {
parseError();
m_token->beginDOCTYPE();
return emitAndReconsumeIn(source, HTMLTokenizer::DataState);
} else {
m_token->beginDOCTYPE();
HTML_ADVANCE_TO(DOCTYPENameState);
}
}
END_STATE()
HTML_BEGIN_STATE(DOCTYPENameState) {
if (isTokenizerWhitespace(cc))
HTML_ADVANCE_TO(AfterDOCTYPENameState);
else if (cc == '>')
return emitAndResumeIn(source, HTMLTokenizer::DataState);
else if (cc == kEndOfFileMarker) {
parseError();
return emitAndReconsumeIn(source, HTMLTokenizer::DataState);
} else {
HTML_ADVANCE_TO(DOCTYPENameState);
}
}
END_STATE()
HTML_BEGIN_STATE(AfterDOCTYPENameState) {
if (isTokenizerWhitespace(cc))
HTML_ADVANCE_TO(AfterDOCTYPENameState);
if (cc == '>')
return emitAndResumeIn(source, HTMLTokenizer::DataState);
else if (cc == kEndOfFileMarker) {
parseError();
return emitAndReconsumeIn(source, HTMLTokenizer::DataState);
} else {
DEFINE_STATIC_LOCAL_STRING(publicString, "public");
DEFINE_STATIC_LOCAL_STRING(systemString, "system");
if (cc == 'P' || cc == 'p') {
if (source.startsWith(publicString, publicStringLength, true)) {
advanceStringAndASSERTIgnoringCase(source, publicString);
HTML_SWITCH_TO(AfterDOCTYPEPublicKeywordState);
} else if (source.remainingBytes() < publicStringLength)
return haveBufferedCharacterToken();
} else if (cc == 'S' || cc == 's') {
if (source.startsWith(systemString, systemStringLength, true)) {
advanceStringAndASSERTIgnoringCase(source, systemString);
HTML_SWITCH_TO(AfterDOCTYPESystemKeywordState);
} else if (source.remainingBytes() < systemStringLength)
return haveBufferedCharacterToken();
}
parseError();
HTML_ADVANCE_TO(BogusDOCTYPEState);
}
}
END_STATE()
HTML_BEGIN_STATE(AfterDOCTYPEPublicKeywordState) {
if (isTokenizerWhitespace(cc))
HTML_ADVANCE_TO(BeforeDOCTYPEPublicIdentifierState);
else if (cc == '"') {
parseError();
HTML_ADVANCE_TO(DOCTYPEPublicIdentifierDoubleQuotedState);
} else if (cc == '\'') {
parseError();
HTML_ADVANCE_TO(DOCTYPEPublicIdentifierSingleQuotedState);
} else if (cc == '>') {
parseError();
return emitAndResumeIn(source, HTMLTokenizer::DataState);
} else if (cc == kEndOfFileMarker) {
parseError();
return emitAndReconsumeIn(source, HTMLTokenizer::DataState);
} else {
parseError();
HTML_ADVANCE_TO(BogusDOCTYPEState);
}
}
END_STATE()
HTML_BEGIN_STATE(BeforeDOCTYPEPublicIdentifierState) {
if (isTokenizerWhitespace(cc))
HTML_ADVANCE_TO(BeforeDOCTYPEPublicIdentifierState);
else if (cc == '"') {
HTML_ADVANCE_TO(DOCTYPEPublicIdentifierDoubleQuotedState);
} else if (cc == '\'') {
HTML_ADVANCE_TO(DOCTYPEPublicIdentifierSingleQuotedState);
} else if (cc == '>') {
parseError();
return emitAndResumeIn(source, HTMLTokenizer::DataState);
} else if (cc == kEndOfFileMarker) {
parseError();
return emitAndReconsumeIn(source, HTMLTokenizer::DataState);
} else {
parseError();
HTML_ADVANCE_TO(BogusDOCTYPEState);
}
}
END_STATE()
HTML_BEGIN_STATE(DOCTYPEPublicIdentifierDoubleQuotedState) {
if (cc == '"')
HTML_ADVANCE_TO(AfterDOCTYPEPublicIdentifierState);
else if (cc == '>') {
parseError();
return emitAndResumeIn(source, HTMLTokenizer::DataState);
} else if (cc == kEndOfFileMarker) {
parseError();
return emitAndReconsumeIn(source, HTMLTokenizer::DataState);
} else {
HTML_ADVANCE_TO(DOCTYPEPublicIdentifierDoubleQuotedState);
}
}
END_STATE()
HTML_BEGIN_STATE(DOCTYPEPublicIdentifierSingleQuotedState) {
if (cc == '\'')
HTML_ADVANCE_TO(AfterDOCTYPEPublicIdentifierState);
else if (cc == '>') {
parseError();
return emitAndResumeIn(source, HTMLTokenizer::DataState);
} else if (cc == kEndOfFileMarker) {
parseError();
return emitAndReconsumeIn(source, HTMLTokenizer::DataState);
} else {
HTML_ADVANCE_TO(DOCTYPEPublicIdentifierSingleQuotedState);
}
}
END_STATE()
HTML_BEGIN_STATE(AfterDOCTYPEPublicIdentifierState) {
if (isTokenizerWhitespace(cc))
HTML_ADVANCE_TO(BetweenDOCTYPEPublicAndSystemIdentifiersState);
else if (cc == '>')
return emitAndResumeIn(source, HTMLTokenizer::DataState);
else if (cc == '"') {
parseError();
HTML_ADVANCE_TO(DOCTYPESystemIdentifierDoubleQuotedState);
} else if (cc == '\'') {
parseError();
HTML_ADVANCE_TO(DOCTYPESystemIdentifierSingleQuotedState);
} else if (cc == kEndOfFileMarker) {
parseError();
return emitAndReconsumeIn(source, HTMLTokenizer::DataState);
} else {
parseError();
HTML_ADVANCE_TO(BogusDOCTYPEState);
}
}
END_STATE()
HTML_BEGIN_STATE(BetweenDOCTYPEPublicAndSystemIdentifiersState) {
if (isTokenizerWhitespace(cc))
HTML_ADVANCE_TO(BetweenDOCTYPEPublicAndSystemIdentifiersState);
else if (cc == '>')
return emitAndResumeIn(source, HTMLTokenizer::DataState);
else if (cc == '"') {
HTML_ADVANCE_TO(DOCTYPESystemIdentifierDoubleQuotedState);
} else if (cc == '\'') {
HTML_ADVANCE_TO(DOCTYPESystemIdentifierSingleQuotedState);
} else if (cc == kEndOfFileMarker) {
parseError();
return emitAndReconsumeIn(source, HTMLTokenizer::DataState);
} else {
parseError();
HTML_ADVANCE_TO(BogusDOCTYPEState);
}
}
END_STATE()
HTML_BEGIN_STATE(AfterDOCTYPESystemKeywordState) {
if (isTokenizerWhitespace(cc))
HTML_ADVANCE_TO(BeforeDOCTYPESystemIdentifierState);
else if (cc == '"') {
parseError();
HTML_ADVANCE_TO(DOCTYPESystemIdentifierDoubleQuotedState);
} else if (cc == '\'') {
parseError();
HTML_ADVANCE_TO(DOCTYPESystemIdentifierSingleQuotedState);
} else if (cc == '>') {
parseError();
return emitAndResumeIn(source, HTMLTokenizer::DataState);
} else if (cc == kEndOfFileMarker) {
parseError();
return emitAndReconsumeIn(source, HTMLTokenizer::DataState);
} else {
parseError();
HTML_ADVANCE_TO(BogusDOCTYPEState);
}
}
END_STATE()
HTML_BEGIN_STATE(BeforeDOCTYPESystemIdentifierState) {
if (isTokenizerWhitespace(cc))
HTML_ADVANCE_TO(BeforeDOCTYPESystemIdentifierState);
if (cc == '"') {
HTML_ADVANCE_TO(DOCTYPESystemIdentifierDoubleQuotedState);
} else if (cc == '\'') {
HTML_ADVANCE_TO(DOCTYPESystemIdentifierSingleQuotedState);
} else if (cc == '>') {
parseError();
return emitAndResumeIn(source, HTMLTokenizer::DataState);
} else if (cc == kEndOfFileMarker) {
parseError();
return emitAndReconsumeIn(source, HTMLTokenizer::DataState);
} else {
parseError();
HTML_ADVANCE_TO(BogusDOCTYPEState);
}
}
END_STATE()
HTML_BEGIN_STATE(DOCTYPESystemIdentifierDoubleQuotedState) {
if (cc == '"')
HTML_ADVANCE_TO(AfterDOCTYPESystemIdentifierState);
else if (cc == '>') {
parseError();
return emitAndResumeIn(source, HTMLTokenizer::DataState);
} else if (cc == kEndOfFileMarker) {
parseError();
return emitAndReconsumeIn(source, HTMLTokenizer::DataState);
} else {
HTML_ADVANCE_TO(DOCTYPESystemIdentifierDoubleQuotedState);
}
}
END_STATE()
HTML_BEGIN_STATE(DOCTYPESystemIdentifierSingleQuotedState) {
if (cc == '\'')
HTML_ADVANCE_TO(AfterDOCTYPESystemIdentifierState);
else if (cc == '>') {
parseError();
return emitAndResumeIn(source, HTMLTokenizer::DataState);
} else if (cc == kEndOfFileMarker) {
parseError();
return emitAndReconsumeIn(source, HTMLTokenizer::DataState);
} else {
HTML_ADVANCE_TO(DOCTYPESystemIdentifierSingleQuotedState);
}
}
END_STATE()
HTML_BEGIN_STATE(AfterDOCTYPESystemIdentifierState) {
if (isTokenizerWhitespace(cc))
HTML_ADVANCE_TO(AfterDOCTYPESystemIdentifierState);
else if (cc == '>')
return emitAndResumeIn(source, HTMLTokenizer::DataState);
else if (cc == kEndOfFileMarker) {
parseError();
return emitAndReconsumeIn(source, HTMLTokenizer::DataState);
} else {
parseError();
HTML_ADVANCE_TO(BogusDOCTYPEState);
}
}
END_STATE()
HTML_BEGIN_STATE(BogusDOCTYPEState) {
if (cc == '>')
return emitAndResumeIn(source, HTMLTokenizer::DataState);
else if (cc == kEndOfFileMarker)
return emitAndReconsumeIn(source, HTMLTokenizer::DataState);
HTML_ADVANCE_TO(BogusDOCTYPEState);
}
END_STATE()
HTML_BEGIN_STATE(CDATASectionState) {
if (cc == ']')
HTML_ADVANCE_TO(CDATASectionRightSquareBracketState);
else if (cc == kEndOfFileMarker)
HTML_RECONSUME_IN(DataState);
else {
m_token->ensureIsCharacterToken();
HTML_ADVANCE_TO(CDATASectionState);
}
}
END_STATE()
HTML_BEGIN_STATE(CDATASectionRightSquareBracketState) {
if (cc == ']')
HTML_ADVANCE_TO(CDATASectionDoubleRightSquareBracketState);
else {
m_token->ensureIsCharacterToken();
HTML_RECONSUME_IN(CDATASectionState);
}
}
END_STATE()
HTML_BEGIN_STATE(CDATASectionDoubleRightSquareBracketState) {
if (cc == '>')
HTML_ADVANCE_TO(DataState);
else {
m_token->ensureIsCharacterToken();
HTML_RECONSUME_IN(CDATASectionState);
}
}
END_STATE()
}
ASSERT_NOT_REACHED();
return false;
}
inline void HTMLTokenizer::parseError()
{
notImplemented();
}
}
Codebase Browser
chromium