summaryrefslogtreecommitdiffstats
path: root/parser/html/nsHtml5Tokenizer.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
commit26a029d407be480d791972afb5975cf62c9360a6 (patch)
treef435a8308119effd964b339f76abb83a57c29483 /parser/html/nsHtml5Tokenizer.cpp
parentInitial commit. (diff)
downloadfirefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz
firefox-26a029d407be480d791972afb5975cf62c9360a6.zip
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'parser/html/nsHtml5Tokenizer.cpp')
-rw-r--r--parser/html/nsHtml5Tokenizer.cpp5176
1 files changed, 5176 insertions, 0 deletions
diff --git a/parser/html/nsHtml5Tokenizer.cpp b/parser/html/nsHtml5Tokenizer.cpp
new file mode 100644
index 0000000000..5092bf4bf6
--- /dev/null
+++ b/parser/html/nsHtml5Tokenizer.cpp
@@ -0,0 +1,5176 @@
+/*
+ * Copyright (c) 2005-2007 Henri Sivonen
+ * Copyright (c) 2007-2017 Mozilla Foundation
+ * Portions of comments Copyright 2004-2010 Apple Computer, Inc., Mozilla
+ * Foundation, and Opera Software ASA.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+/*
+ * THIS IS A GENERATED FILE. PLEASE DO NOT EDIT.
+ * Please edit Tokenizer.java instead and regenerate.
+ */
+
+#define nsHtml5Tokenizer_cpp__
+
+#include "nsHtml5AttributeName.h"
+#include "nsHtml5ElementName.h"
+#include "nsHtml5TreeBuilder.h"
+#include "nsHtml5StackNode.h"
+#include "nsHtml5UTF16Buffer.h"
+#include "nsHtml5StateSnapshot.h"
+#include "nsHtml5Portability.h"
+
+#include "nsHtml5Tokenizer.h"
+
+#include "nsHtml5TokenizerLoopPolicies.h"
+
+char16_t nsHtml5Tokenizer::LT_GT[] = {'<', '>'};
+char16_t nsHtml5Tokenizer::LT_SOLIDUS[] = {'<', '/'};
+char16_t nsHtml5Tokenizer::RSQB_RSQB[] = {']', ']'};
+char16_t nsHtml5Tokenizer::REPLACEMENT_CHARACTER[] = {0xfffd};
+char16_t nsHtml5Tokenizer::LF[] = {'\n'};
+char16_t nsHtml5Tokenizer::CDATA_LSQB[] = {'C', 'D', 'A', 'T', 'A', '['};
+char16_t nsHtml5Tokenizer::OCTYPE[] = {'o', 'c', 't', 'y', 'p', 'e'};
+char16_t nsHtml5Tokenizer::UBLIC[] = {'u', 'b', 'l', 'i', 'c'};
+char16_t nsHtml5Tokenizer::YSTEM[] = {'y', 's', 't', 'e', 'm'};
+static char16_t const TITLE_ARR_DATA[] = {'t', 'i', 't', 'l', 'e'};
+staticJArray<char16_t, int32_t> nsHtml5Tokenizer::TITLE_ARR = {
+ TITLE_ARR_DATA, MOZ_ARRAY_LENGTH(TITLE_ARR_DATA)};
+static char16_t const SCRIPT_ARR_DATA[] = {'s', 'c', 'r', 'i', 'p', 't'};
+staticJArray<char16_t, int32_t> nsHtml5Tokenizer::SCRIPT_ARR = {
+ SCRIPT_ARR_DATA, MOZ_ARRAY_LENGTH(SCRIPT_ARR_DATA)};
+static char16_t const STYLE_ARR_DATA[] = {'s', 't', 'y', 'l', 'e'};
+staticJArray<char16_t, int32_t> nsHtml5Tokenizer::STYLE_ARR = {
+ STYLE_ARR_DATA, MOZ_ARRAY_LENGTH(STYLE_ARR_DATA)};
+static char16_t const PLAINTEXT_ARR_DATA[] = {'p', 'l', 'a', 'i', 'n',
+ 't', 'e', 'x', 't'};
+staticJArray<char16_t, int32_t> nsHtml5Tokenizer::PLAINTEXT_ARR = {
+ PLAINTEXT_ARR_DATA, MOZ_ARRAY_LENGTH(PLAINTEXT_ARR_DATA)};
+static char16_t const XMP_ARR_DATA[] = {'x', 'm', 'p'};
+staticJArray<char16_t, int32_t> nsHtml5Tokenizer::XMP_ARR = {
+ XMP_ARR_DATA, MOZ_ARRAY_LENGTH(XMP_ARR_DATA)};
+static char16_t const TEXTAREA_ARR_DATA[] = {'t', 'e', 'x', 't',
+ 'a', 'r', 'e', 'a'};
+staticJArray<char16_t, int32_t> nsHtml5Tokenizer::TEXTAREA_ARR = {
+ TEXTAREA_ARR_DATA, MOZ_ARRAY_LENGTH(TEXTAREA_ARR_DATA)};
+static char16_t const IFRAME_ARR_DATA[] = {'i', 'f', 'r', 'a', 'm', 'e'};
+staticJArray<char16_t, int32_t> nsHtml5Tokenizer::IFRAME_ARR = {
+ IFRAME_ARR_DATA, MOZ_ARRAY_LENGTH(IFRAME_ARR_DATA)};
+static char16_t const NOEMBED_ARR_DATA[] = {'n', 'o', 'e', 'm', 'b', 'e', 'd'};
+staticJArray<char16_t, int32_t> nsHtml5Tokenizer::NOEMBED_ARR = {
+ NOEMBED_ARR_DATA, MOZ_ARRAY_LENGTH(NOEMBED_ARR_DATA)};
+static char16_t const NOSCRIPT_ARR_DATA[] = {'n', 'o', 's', 'c',
+ 'r', 'i', 'p', 't'};
+staticJArray<char16_t, int32_t> nsHtml5Tokenizer::NOSCRIPT_ARR = {
+ NOSCRIPT_ARR_DATA, MOZ_ARRAY_LENGTH(NOSCRIPT_ARR_DATA)};
+static char16_t const NOFRAMES_ARR_DATA[] = {'n', 'o', 'f', 'r',
+ 'a', 'm', 'e', 's'};
+staticJArray<char16_t, int32_t> nsHtml5Tokenizer::NOFRAMES_ARR = {
+ NOFRAMES_ARR_DATA, MOZ_ARRAY_LENGTH(NOFRAMES_ARR_DATA)};
+
+nsHtml5Tokenizer::nsHtml5Tokenizer(nsHtml5TreeBuilder* tokenHandler,
+ bool viewingXmlSource)
+ : tokenHandler(tokenHandler),
+ encodingDeclarationHandler(nullptr),
+ lastCR(false),
+ stateSave(0),
+ returnStateSave(0),
+ index(0),
+ forceQuirks(false),
+ additional('\0'),
+ entCol(0),
+ firstCharKey(0),
+ lo(0),
+ hi(0),
+ candidate(0),
+ charRefBufMark(0),
+ value(0),
+ seenDigits(false),
+ suspendAfterCurrentNonTextToken(false),
+ cstart(0),
+ strBufLen(0),
+ charRefBuf(jArray<char16_t, int32_t>::newJArray(32)),
+ charRefBufLen(0),
+ bmpChar(jArray<char16_t, int32_t>::newJArray(1)),
+ astralChar(jArray<char16_t, int32_t>::newJArray(2)),
+ endTagExpectation(nullptr),
+ endTagExpectationAsArray(nullptr),
+ endTag(false),
+ containsHyphen(false),
+ tagName(nullptr),
+ nonInternedTagName(new nsHtml5ElementName()),
+ attributeName(nullptr),
+ nonInternedAttributeName(new nsHtml5AttributeName()),
+ doctypeName(nullptr),
+ publicIdentifier(nullptr),
+ systemIdentifier(nullptr),
+ attributes(tokenHandler->HasBuilder() ? new nsHtml5HtmlAttributes(0)
+ : nullptr),
+ newAttributesEachTime(!tokenHandler->HasBuilder()),
+ shouldSuspend(false),
+ confident(false),
+ line(0),
+ attributeLine(0),
+ interner(nullptr),
+ viewingXmlSource(viewingXmlSource) {
+ MOZ_COUNT_CTOR(nsHtml5Tokenizer);
+}
+
+void nsHtml5Tokenizer::setInterner(nsHtml5AtomTable* interner) {
+ this->interner = interner;
+}
+
+void nsHtml5Tokenizer::initLocation(nsHtml5String newPublicId,
+ nsHtml5String newSystemId) {
+ this->systemId = newSystemId;
+ this->publicId = newPublicId;
+}
+
+bool nsHtml5Tokenizer::isViewingXmlSource() { return viewingXmlSource; }
+
+void nsHtml5Tokenizer::setState(int32_t specialTokenizerState) {
+ this->stateSave = specialTokenizerState;
+ this->endTagExpectation = nullptr;
+ this->endTagExpectationAsArray = nullptr;
+}
+
+void nsHtml5Tokenizer::setStateAndEndTagExpectation(
+ int32_t specialTokenizerState, nsHtml5ElementName* endTagExpectation) {
+ this->stateSave = specialTokenizerState;
+ this->endTagExpectation = endTagExpectation;
+ endTagExpectationToArray();
+}
+
+void nsHtml5Tokenizer::endTagExpectationToArray() {
+ switch (endTagExpectation->getGroup()) {
+ case nsHtml5TreeBuilder::TITLE: {
+ endTagExpectationAsArray = TITLE_ARR;
+ return;
+ }
+ case nsHtml5TreeBuilder::SCRIPT: {
+ endTagExpectationAsArray = SCRIPT_ARR;
+ return;
+ }
+ case nsHtml5TreeBuilder::STYLE: {
+ endTagExpectationAsArray = STYLE_ARR;
+ return;
+ }
+ case nsHtml5TreeBuilder::PLAINTEXT: {
+ endTagExpectationAsArray = PLAINTEXT_ARR;
+ return;
+ }
+ case nsHtml5TreeBuilder::XMP: {
+ endTagExpectationAsArray = XMP_ARR;
+ return;
+ }
+ case nsHtml5TreeBuilder::TEXTAREA: {
+ endTagExpectationAsArray = TEXTAREA_ARR;
+ return;
+ }
+ case nsHtml5TreeBuilder::IFRAME: {
+ endTagExpectationAsArray = IFRAME_ARR;
+ return;
+ }
+ case nsHtml5TreeBuilder::NOEMBED: {
+ endTagExpectationAsArray = NOEMBED_ARR;
+ return;
+ }
+ case nsHtml5TreeBuilder::NOSCRIPT: {
+ endTagExpectationAsArray = NOSCRIPT_ARR;
+ return;
+ }
+ case nsHtml5TreeBuilder::NOFRAMES: {
+ endTagExpectationAsArray = NOFRAMES_ARR;
+ return;
+ }
+ default: {
+ MOZ_ASSERT(false, "Bad end tag expectation.");
+ return;
+ }
+ }
+}
+
+void nsHtml5Tokenizer::setLineNumber(int32_t line) {
+ this->attributeLine = line;
+ this->line = line;
+}
+
+nsHtml5HtmlAttributes* nsHtml5Tokenizer::emptyAttributes() {
+ return nsHtml5HtmlAttributes::EMPTY_ATTRIBUTES;
+}
+
+void nsHtml5Tokenizer::emitOrAppendCharRefBuf(int32_t returnState) {
+ if ((returnState & DATA_AND_RCDATA_MASK)) {
+ appendCharRefBufToStrBuf();
+ } else {
+ if (charRefBufLen > 0) {
+ tokenHandler->characters(charRefBuf, 0, charRefBufLen);
+ charRefBufLen = 0;
+ }
+ }
+}
+
+nsHtml5String nsHtml5Tokenizer::strBufToString() {
+ nsHtml5String str = nsHtml5Portability::newStringFromBuffer(
+ strBuf, 0, strBufLen, tokenHandler,
+ !newAttributesEachTime &&
+ attributeName == nsHtml5AttributeName::ATTR_CLASS);
+ clearStrBufAfterUse();
+ return str;
+}
+
+void nsHtml5Tokenizer::strBufToDoctypeName() {
+ doctypeName =
+ nsHtml5Portability::newLocalNameFromBuffer(strBuf, strBufLen, interner);
+ clearStrBufAfterUse();
+}
+
+void nsHtml5Tokenizer::emitStrBuf() {
+ if (strBufLen > 0) {
+ tokenHandler->characters(strBuf, 0, strBufLen);
+ clearStrBufAfterUse();
+ }
+}
+
+void nsHtml5Tokenizer::appendStrBuf(char16_t* buffer, int32_t offset,
+ int32_t length) {
+ int32_t newLen = nsHtml5Portability::checkedAdd(strBufLen, length);
+ MOZ_ASSERT(newLen <= strBuf.length, "Previous buffer length insufficient.");
+ if (MOZ_UNLIKELY(strBuf.length < newLen)) {
+ if (MOZ_UNLIKELY(!EnsureBufferSpace(length))) {
+ MOZ_CRASH("Unable to recover from buffer reallocation failure");
+ }
+ }
+ nsHtml5ArrayCopy::arraycopy(buffer, offset, strBuf, strBufLen, length);
+ strBufLen = newLen;
+}
+
+void nsHtml5Tokenizer::emitComment(int32_t provisionalHyphens, int32_t pos) {
+ RememberGt(pos);
+ tokenHandler->comment(strBuf, 0, strBufLen - provisionalHyphens);
+ clearStrBufAfterUse();
+ cstart = pos + 1;
+ suspendIfRequestedAfterCurrentNonTextToken();
+}
+
+void nsHtml5Tokenizer::flushChars(char16_t* buf, int32_t pos) {
+ if (pos > cstart) {
+ tokenHandler->characters(buf, cstart, pos - cstart);
+ }
+ cstart = INT32_MAX;
+}
+
+void nsHtml5Tokenizer::strBufToElementNameString() {
+ if (containsHyphen) {
+ nsAtom* annotationName = nsHtml5ElementName::ELT_ANNOTATION_XML->getName();
+ if (nsHtml5Portability::localEqualsBuffer(annotationName, strBuf,
+ strBufLen)) {
+ tagName = nsHtml5ElementName::ELT_ANNOTATION_XML;
+ } else {
+ nonInternedTagName->setNameForNonInterned(
+ nsHtml5Portability::newLocalNameFromBuffer(strBuf, strBufLen,
+ interner),
+ true);
+ tagName = nonInternedTagName;
+ }
+ } else {
+ tagName = nsHtml5ElementName::elementNameByBuffer(strBuf, strBufLen);
+ if (!tagName) {
+ nonInternedTagName->setNameForNonInterned(
+ nsHtml5Portability::newLocalNameFromBuffer(strBuf, strBufLen,
+ interner),
+ false);
+ tagName = nonInternedTagName;
+ }
+ }
+ containsHyphen = false;
+ clearStrBufAfterUse();
+}
+
+int32_t nsHtml5Tokenizer::emitCurrentTagToken(bool selfClosing, int32_t pos) {
+ RememberGt(pos);
+ cstart = pos + 1;
+ maybeErrSlashInEndTag(selfClosing);
+ stateSave = nsHtml5Tokenizer::DATA;
+ nsHtml5HtmlAttributes* attrs =
+ (!attributes ? nsHtml5HtmlAttributes::EMPTY_ATTRIBUTES : attributes);
+ if (endTag) {
+ maybeErrAttributesOnEndTag(attrs);
+ if (!viewingXmlSource) {
+ tokenHandler->endTag(tagName);
+ }
+ if (newAttributesEachTime) {
+ delete attributes;
+ attributes = nullptr;
+ }
+ } else {
+ if (viewingXmlSource) {
+ MOZ_ASSERT(newAttributesEachTime);
+ delete attributes;
+ attributes = nullptr;
+ } else {
+ tokenHandler->startTag(tagName, attrs, selfClosing);
+ }
+ }
+ tagName = nullptr;
+ if (newAttributesEachTime) {
+ attributes = nullptr;
+ } else {
+ attributes->clear(0);
+ }
+ suspendIfRequestedAfterCurrentNonTextToken();
+ return stateSave;
+}
+
+void nsHtml5Tokenizer::attributeNameComplete() {
+ attributeName =
+ nsHtml5AttributeName::nameByBuffer(strBuf, strBufLen, interner);
+ if (!attributeName) {
+ nonInternedAttributeName->setNameForNonInterned(
+ nsHtml5Portability::newLocalNameFromBuffer(strBuf, strBufLen,
+ interner));
+ attributeName = nonInternedAttributeName;
+ }
+ clearStrBufAfterUse();
+ if (!attributes) {
+ attributes = new nsHtml5HtmlAttributes(0);
+ }
+ if (attributes->contains(attributeName)) {
+ errDuplicateAttribute();
+ attributeName = nullptr;
+ }
+}
+
+void nsHtml5Tokenizer::addAttributeWithoutValue() {
+ if (attributeName) {
+ attributes->addAttribute(
+ attributeName, nsHtml5Portability::newEmptyString(), attributeLine);
+ attributeName = nullptr;
+ } else {
+ clearStrBufAfterUse();
+ }
+}
+
+void nsHtml5Tokenizer::addAttributeWithValue() {
+ if (attributeName) {
+ nsHtml5String val = strBufToString();
+ if (mViewSource) {
+ mViewSource->MaybeLinkifyAttributeValue(attributeName, val);
+ }
+ attributes->addAttribute(attributeName, val, attributeLine);
+ attributeName = nullptr;
+ } else {
+ clearStrBufAfterUse();
+ }
+}
+
+void nsHtml5Tokenizer::start() {
+ initializeWithoutStarting();
+ tokenHandler->startTokenization(this);
+ if (mViewSource) {
+ line = 1;
+ col = -1;
+ nextCharOnNewLine = false;
+ } else if (tokenHandler->WantsLineAndColumn()) {
+ line = 0;
+ col = 1;
+ nextCharOnNewLine = true;
+ } else {
+ line = -1;
+ col = -1;
+ nextCharOnNewLine = false;
+ }
+}
+
+bool nsHtml5Tokenizer::tokenizeBuffer(nsHtml5UTF16Buffer* buffer) {
+ int32_t state = stateSave;
+ int32_t returnState = returnStateSave;
+ char16_t c = '\0';
+ shouldSuspend = false;
+ lastCR = false;
+ int32_t start = buffer->getStart();
+ int32_t end = buffer->getEnd();
+ int32_t pos = start - 1;
+ switch (state) {
+ case DATA:
+ case RCDATA:
+ case SCRIPT_DATA:
+ case PLAINTEXT:
+ case RAWTEXT:
+ case CDATA_SECTION:
+ case SCRIPT_DATA_ESCAPED:
+ case SCRIPT_DATA_ESCAPE_START:
+ case SCRIPT_DATA_ESCAPE_START_DASH:
+ case SCRIPT_DATA_ESCAPED_DASH:
+ case SCRIPT_DATA_ESCAPED_DASH_DASH:
+ case SCRIPT_DATA_DOUBLE_ESCAPE_START:
+ case SCRIPT_DATA_DOUBLE_ESCAPED:
+ case SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN:
+ case SCRIPT_DATA_DOUBLE_ESCAPED_DASH:
+ case SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH:
+ case SCRIPT_DATA_DOUBLE_ESCAPE_END: {
+ cstart = start;
+ break;
+ }
+ default: {
+ cstart = INT32_MAX;
+ break;
+ }
+ }
+ if (mViewSource) {
+ mViewSource->SetBuffer(buffer);
+ pos = stateLoop<nsHtml5ViewSourcePolicy>(state, c, pos, buffer->getBuffer(),
+ false, returnState,
+ buffer->getEnd());
+ mViewSource->DropBuffer((pos == buffer->getEnd()) ? pos : pos + 1);
+ } else if (tokenHandler->WantsLineAndColumn()) {
+ pos = stateLoop<nsHtml5LineColPolicy>(state, c, pos, buffer->getBuffer(),
+ false, returnState, buffer->getEnd());
+ } else {
+ pos = stateLoop<nsHtml5FastestPolicy>(state, c, pos, buffer->getBuffer(),
+ false, returnState, buffer->getEnd());
+ }
+ if (pos == end) {
+ buffer->setStart(pos);
+ } else {
+ buffer->setStart(pos + 1);
+ }
+ return lastCR;
+}
+
+template <class P>
+int32_t nsHtml5Tokenizer::stateLoop(int32_t state, char16_t c, int32_t pos,
+ char16_t* buf, bool reconsume,
+ int32_t returnState, int32_t endPos) {
+ bool reportedConsecutiveHyphens = false;
+stateloop:
+ for (;;) {
+ switch (state) {
+ case DATA: {
+ for (;;) {
+ if (reconsume) {
+ reconsume = false;
+ } else {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ }
+ switch (c) {
+ case '&': {
+ flushChars(buf, pos);
+ MOZ_ASSERT(!charRefBufLen,
+ "charRefBufLen not reset after previous use!");
+ appendCharRefBuf(c);
+ setAdditionalAndRememberAmpersandLocation('\0');
+ returnState = state;
+ state =
+ P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::CONSUME_CHARACTER_REFERENCE,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '<': {
+ flushChars(buf, pos);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::TAG_OPEN, reconsume, pos);
+ NS_HTML5_BREAK(dataloop);
+ }
+ case '\0': {
+ maybeEmitReplacementCharacter(buf, pos);
+ continue;
+ }
+ case '\r': {
+ emitCarriageReturn<P>(buf, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ default: {
+ continue;
+ }
+ }
+ }
+ dataloop_end:;
+ [[fallthrough]];
+ }
+ case TAG_OPEN: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ if (c >= 'A' && c <= 'Z') {
+ endTag = false;
+ clearStrBufBeforeUse();
+ appendStrBuf((char16_t)(c + 0x20));
+ containsHyphen = false;
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::TAG_NAME,
+ reconsume, pos);
+ NS_HTML5_BREAK(tagopenloop);
+ } else if (c >= 'a' && c <= 'z') {
+ endTag = false;
+ clearStrBufBeforeUse();
+ appendStrBuf(c);
+ containsHyphen = false;
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::TAG_NAME,
+ reconsume, pos);
+ NS_HTML5_BREAK(tagopenloop);
+ }
+ switch (c) {
+ case '!': {
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::MARKUP_DECLARATION_OPEN,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '/': {
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::CLOSE_TAG_OPEN, reconsume,
+ pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\?': {
+ if (viewingXmlSource) {
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::PROCESSING_INSTRUCTION,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ if (P::reportErrors) {
+ errProcessingInstruction();
+ }
+ clearStrBufBeforeUse();
+ appendStrBuf(c);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BOGUS_COMMENT, reconsume,
+ pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '>': {
+ if (P::reportErrors) {
+ errLtGt();
+ }
+ tokenHandler->characters(nsHtml5Tokenizer::LT_GT, 0, 2);
+ cstart = pos + 1;
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::DATA,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ default: {
+ if (P::reportErrors) {
+ errBadCharAfterLt(c);
+ }
+ tokenHandler->characters(nsHtml5Tokenizer::LT_GT, 0, 1);
+ cstart = pos;
+ reconsume = true;
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::DATA,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ tagopenloop_end:;
+ [[fallthrough]];
+ }
+ case TAG_NAME: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '\r': {
+ P::silentCarriageReturn(this);
+ strBufToElementNameString();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BEFORE_ATTRIBUTE_NAME,
+ reconsume, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ case ' ':
+ case '\t':
+ case '\f': {
+ strBufToElementNameString();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BEFORE_ATTRIBUTE_NAME,
+ reconsume, pos);
+ NS_HTML5_BREAK(tagnameloop);
+ }
+ case '/': {
+ strBufToElementNameString();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::SELF_CLOSING_START_TAG,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '>': {
+ strBufToElementNameString();
+ state = P::transition(mViewSource.get(),
+ emitCurrentTagToken(false, pos), reconsume,
+ pos);
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\0': {
+ c = 0xfffd;
+ [[fallthrough]];
+ }
+ default: {
+ if (c >= 'A' && c <= 'Z') {
+ c += 0x20;
+ } else if (c == '-') {
+ containsHyphen = true;
+ }
+ appendStrBuf(c);
+ continue;
+ }
+ }
+ }
+ tagnameloop_end:;
+ [[fallthrough]];
+ }
+ case BEFORE_ATTRIBUTE_NAME: {
+ for (;;) {
+ if (reconsume) {
+ reconsume = false;
+ } else {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ }
+ switch (c) {
+ case '\r': {
+ P::silentCarriageReturn(this);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ case ' ':
+ case '\t':
+ case '\f': {
+ continue;
+ }
+ case '/': {
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::SELF_CLOSING_START_TAG,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '>': {
+ state = P::transition(mViewSource.get(),
+ emitCurrentTagToken(false, pos), reconsume,
+ pos);
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\0': {
+ c = 0xfffd;
+ [[fallthrough]];
+ }
+ case '\"':
+ case '\'':
+ case '<':
+ case '=': {
+ if (P::reportErrors) {
+ errBadCharBeforeAttributeNameOrNull(c);
+ }
+ [[fallthrough]];
+ }
+ default: {
+ if (c >= 'A' && c <= 'Z') {
+ c += 0x20;
+ }
+ attributeLine = line;
+ clearStrBufBeforeUse();
+ appendStrBuf(c);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::ATTRIBUTE_NAME, reconsume,
+ pos);
+ NS_HTML5_BREAK(beforeattributenameloop);
+ }
+ }
+ }
+ beforeattributenameloop_end:;
+ [[fallthrough]];
+ }
+ case ATTRIBUTE_NAME: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '\r': {
+ P::silentCarriageReturn(this);
+ attributeNameComplete();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::AFTER_ATTRIBUTE_NAME,
+ reconsume, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ case ' ':
+ case '\t':
+ case '\f': {
+ attributeNameComplete();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::AFTER_ATTRIBUTE_NAME,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '/': {
+ attributeNameComplete();
+ addAttributeWithoutValue();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::SELF_CLOSING_START_TAG,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '=': {
+ attributeNameComplete();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BEFORE_ATTRIBUTE_VALUE,
+ reconsume, pos);
+ NS_HTML5_BREAK(attributenameloop);
+ }
+ case '>': {
+ attributeNameComplete();
+ addAttributeWithoutValue();
+ state = P::transition(mViewSource.get(),
+ emitCurrentTagToken(false, pos), reconsume,
+ pos);
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\0': {
+ c = 0xfffd;
+ [[fallthrough]];
+ }
+ case '\"':
+ case '\'':
+ case '<': {
+ if (P::reportErrors) {
+ errQuoteOrLtInAttributeNameOrNull(c);
+ }
+ [[fallthrough]];
+ }
+ default: {
+ if (c >= 'A' && c <= 'Z') {
+ c += 0x20;
+ }
+ appendStrBuf(c);
+ continue;
+ }
+ }
+ }
+ attributenameloop_end:;
+ [[fallthrough]];
+ }
+ case BEFORE_ATTRIBUTE_VALUE: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '\r': {
+ P::silentCarriageReturn(this);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ case ' ':
+ case '\t':
+ case '\f': {
+ continue;
+ }
+ case '\"': {
+ attributeLine = line;
+ clearStrBufBeforeUse();
+ state =
+ P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::ATTRIBUTE_VALUE_DOUBLE_QUOTED,
+ reconsume, pos);
+ NS_HTML5_BREAK(beforeattributevalueloop);
+ }
+ case '&': {
+ attributeLine = line;
+ clearStrBufBeforeUse();
+ reconsume = true;
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::ATTRIBUTE_VALUE_UNQUOTED,
+ reconsume, pos);
+
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\'': {
+ attributeLine = line;
+ clearStrBufBeforeUse();
+ state =
+ P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::ATTRIBUTE_VALUE_SINGLE_QUOTED,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '>': {
+ if (P::reportErrors) {
+ errAttributeValueMissing();
+ }
+ addAttributeWithoutValue();
+ state = P::transition(mViewSource.get(),
+ emitCurrentTagToken(false, pos), reconsume,
+ pos);
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\0': {
+ c = 0xfffd;
+ [[fallthrough]];
+ }
+ case '<':
+ case '=':
+ case '`': {
+ if (P::reportErrors) {
+ errLtOrEqualsOrGraveInUnquotedAttributeOrNull(c);
+ }
+ [[fallthrough]];
+ }
+ default: {
+ attributeLine = line;
+ clearStrBufBeforeUse();
+ appendStrBuf(c);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::ATTRIBUTE_VALUE_UNQUOTED,
+ reconsume, pos);
+
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ beforeattributevalueloop_end:;
+ [[fallthrough]];
+ }
+ case ATTRIBUTE_VALUE_DOUBLE_QUOTED: {
+ for (;;) {
+ if (reconsume) {
+ reconsume = false;
+ } else {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ }
+ switch (c) {
+ case '\"': {
+ addAttributeWithValue();
+ state =
+ P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::AFTER_ATTRIBUTE_VALUE_QUOTED,
+ reconsume, pos);
+ NS_HTML5_BREAK(attributevaluedoublequotedloop);
+ }
+ case '&': {
+ MOZ_ASSERT(!charRefBufLen,
+ "charRefBufLen not reset after previous use!");
+ appendCharRefBuf(c);
+ setAdditionalAndRememberAmpersandLocation('\"');
+ returnState = state;
+ state =
+ P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::CONSUME_CHARACTER_REFERENCE,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\r': {
+ appendStrBufCarriageReturn<P>();
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ appendStrBufLineFeed<P>();
+ continue;
+ }
+ case '\0': {
+ c = 0xfffd;
+ [[fallthrough]];
+ }
+ default: {
+ appendStrBuf(c);
+ continue;
+ }
+ }
+ }
+ attributevaluedoublequotedloop_end:;
+ [[fallthrough]];
+ }
+ case AFTER_ATTRIBUTE_VALUE_QUOTED: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '\r': {
+ P::silentCarriageReturn(this);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BEFORE_ATTRIBUTE_NAME,
+ reconsume, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ case ' ':
+ case '\t':
+ case '\f': {
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BEFORE_ATTRIBUTE_NAME,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '/': {
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::SELF_CLOSING_START_TAG,
+ reconsume, pos);
+ NS_HTML5_BREAK(afterattributevaluequotedloop);
+ }
+ case '>': {
+ state = P::transition(mViewSource.get(),
+ emitCurrentTagToken(false, pos), reconsume,
+ pos);
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ default: {
+ if (P::reportErrors) {
+ errNoSpaceBetweenAttributes();
+ }
+ reconsume = true;
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BEFORE_ATTRIBUTE_NAME,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ afterattributevaluequotedloop_end:;
+ [[fallthrough]];
+ }
+ case SELF_CLOSING_START_TAG: {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '>': {
+ state =
+ P::transition(mViewSource.get(), emitCurrentTagToken(true, pos),
+ reconsume, pos);
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ default: {
+ if (P::reportErrors) {
+ errSlashNotFollowedByGt();
+ }
+ reconsume = true;
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BEFORE_ATTRIBUTE_NAME,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ case ATTRIBUTE_VALUE_UNQUOTED: {
+ for (;;) {
+ if (reconsume) {
+ reconsume = false;
+ } else {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ }
+ switch (c) {
+ case '\r': {
+ P::silentCarriageReturn(this);
+ addAttributeWithValue();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BEFORE_ATTRIBUTE_NAME,
+ reconsume, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ case ' ':
+ case '\t':
+ case '\f': {
+ addAttributeWithValue();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BEFORE_ATTRIBUTE_NAME,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '&': {
+ MOZ_ASSERT(!charRefBufLen,
+ "charRefBufLen not reset after previous use!");
+ appendCharRefBuf(c);
+ setAdditionalAndRememberAmpersandLocation('>');
+ returnState = state;
+ state =
+ P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::CONSUME_CHARACTER_REFERENCE,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '>': {
+ addAttributeWithValue();
+ state = P::transition(mViewSource.get(),
+ emitCurrentTagToken(false, pos), reconsume,
+ pos);
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\0': {
+ c = 0xfffd;
+ [[fallthrough]];
+ }
+ case '<':
+ case '\"':
+ case '\'':
+ case '=':
+ case '`': {
+ if (P::reportErrors) {
+ errUnquotedAttributeValOrNull(c);
+ }
+ [[fallthrough]];
+ }
+ default: {
+ appendStrBuf(c);
+ continue;
+ }
+ }
+ }
+ }
+ case AFTER_ATTRIBUTE_NAME: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '\r': {
+ P::silentCarriageReturn(this);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ case ' ':
+ case '\t':
+ case '\f': {
+ continue;
+ }
+ case '/': {
+ addAttributeWithoutValue();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::SELF_CLOSING_START_TAG,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '=': {
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BEFORE_ATTRIBUTE_VALUE,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '>': {
+ addAttributeWithoutValue();
+ state = P::transition(mViewSource.get(),
+ emitCurrentTagToken(false, pos), reconsume,
+ pos);
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\0': {
+ c = 0xfffd;
+ [[fallthrough]];
+ }
+ case '\"':
+ case '\'':
+ case '<': {
+ if (P::reportErrors) {
+ errQuoteOrLtInAttributeNameOrNull(c);
+ }
+ [[fallthrough]];
+ }
+ default: {
+ addAttributeWithoutValue();
+ if (c >= 'A' && c <= 'Z') {
+ c += 0x20;
+ }
+ clearStrBufBeforeUse();
+ appendStrBuf(c);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::ATTRIBUTE_NAME, reconsume,
+ pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ }
+ case MARKUP_DECLARATION_OPEN: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '-': {
+ clearStrBufBeforeUse();
+ appendStrBuf(c);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::MARKUP_DECLARATION_HYPHEN,
+ reconsume, pos);
+ NS_HTML5_BREAK(markupdeclarationopenloop);
+ }
+ case 'd':
+ case 'D': {
+ clearStrBufBeforeUse();
+ appendStrBuf(c);
+ index = 0;
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::MARKUP_DECLARATION_OCTYPE,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '[': {
+ if (tokenHandler->cdataSectionAllowed()) {
+ clearStrBufBeforeUse();
+ appendStrBuf(c);
+ index = 0;
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::CDATA_START, reconsume,
+ pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ [[fallthrough]];
+ }
+ default: {
+ if (P::reportErrors) {
+ errBogusComment();
+ }
+ clearStrBufBeforeUse();
+ reconsume = true;
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BOGUS_COMMENT, reconsume,
+ pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ markupdeclarationopenloop_end:;
+ [[fallthrough]];
+ }
+ case MARKUP_DECLARATION_HYPHEN: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '-': {
+ clearStrBufAfterOneHyphen();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT_START, reconsume,
+ pos);
+ NS_HTML5_BREAK(markupdeclarationhyphenloop);
+ }
+ default: {
+ if (P::reportErrors) {
+ errBogusComment();
+ }
+ reconsume = true;
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BOGUS_COMMENT, reconsume,
+ pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ markupdeclarationhyphenloop_end:;
+ [[fallthrough]];
+ }
+ case COMMENT_START: {
+ reportedConsecutiveHyphens = false;
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '-': {
+ appendStrBuf(c);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT_START_DASH,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '>': {
+ if (P::reportErrors) {
+ errPrematureEndOfComment();
+ }
+ emitComment(0, pos);
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::DATA,
+ reconsume, pos);
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '<': {
+ appendStrBuf(c);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT_LESSTHAN,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\r': {
+ appendStrBufCarriageReturn<P>();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT, reconsume, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ appendStrBufLineFeed<P>();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT, reconsume, pos);
+ NS_HTML5_BREAK(commentstartloop);
+ }
+ case '\0': {
+ c = 0xfffd;
+ [[fallthrough]];
+ }
+ default: {
+ appendStrBuf(c);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT, reconsume, pos);
+ NS_HTML5_BREAK(commentstartloop);
+ }
+ }
+ }
+ commentstartloop_end:;
+ [[fallthrough]];
+ }
+ case COMMENT: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '-': {
+ appendStrBuf(c);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT_END_DASH,
+ reconsume, pos);
+ NS_HTML5_BREAK(commentloop);
+ }
+ case '<': {
+ appendStrBuf(c);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT_LESSTHAN,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\r': {
+ appendStrBufCarriageReturn<P>();
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ appendStrBufLineFeed<P>();
+ continue;
+ }
+ case '\0': {
+ c = 0xfffd;
+ [[fallthrough]];
+ }
+ default: {
+ appendStrBuf(c);
+ continue;
+ }
+ }
+ }
+ commentloop_end:;
+ [[fallthrough]];
+ }
+ case COMMENT_END_DASH: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '-': {
+ appendStrBuf(c);
+ state =
+ P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT_END, reconsume, pos);
+ NS_HTML5_BREAK(commentenddashloop);
+ }
+ case '<': {
+ appendStrBuf(c);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT_LESSTHAN,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\r': {
+ appendStrBufCarriageReturn<P>();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT, reconsume, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ appendStrBufLineFeed<P>();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\0': {
+ c = 0xfffd;
+ [[fallthrough]];
+ }
+ default: {
+ appendStrBuf(c);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ commentenddashloop_end:;
+ [[fallthrough]];
+ }
+ case COMMENT_END: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '>': {
+ emitComment(2, pos);
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::DATA,
+ reconsume, pos);
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '-': {
+ adjustDoubleHyphenAndAppendToStrBufAndErr(
+ c, reportedConsecutiveHyphens);
+ reportedConsecutiveHyphens = true;
+ continue;
+ }
+ case '<': {
+ appendStrBuf(c);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT_LESSTHAN,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\r': {
+ adjustDoubleHyphenAndAppendToStrBufCarriageReturn<P>();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT, reconsume, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ adjustDoubleHyphenAndAppendToStrBufLineFeed<P>();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '!': {
+ appendStrBuf(c);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT_END_BANG,
+ reconsume, pos);
+ NS_HTML5_BREAK(commentendloop);
+ }
+ case '\0': {
+ c = 0xfffd;
+ [[fallthrough]];
+ }
+ default: {
+ adjustDoubleHyphenAndAppendToStrBufAndErr(
+ c, reportedConsecutiveHyphens);
+ reportedConsecutiveHyphens = true;
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ commentendloop_end:;
+ [[fallthrough]];
+ }
+ case COMMENT_END_BANG: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '>': {
+ emitComment(3, pos);
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::DATA,
+ reconsume, pos);
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '-': {
+ appendStrBuf(c);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT_END_DASH,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\r': {
+ appendStrBufCarriageReturn<P>();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT, reconsume, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ appendStrBufLineFeed<P>();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\0': {
+ c = 0xfffd;
+ [[fallthrough]];
+ }
+ default: {
+ appendStrBuf(c);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ }
+ case COMMENT_LESSTHAN: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '!': {
+ appendStrBuf(c);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT_LESSTHAN_BANG,
+ reconsume, pos);
+ NS_HTML5_BREAK(commentlessthanloop);
+ }
+ case '<': {
+ appendStrBuf(c);
+ continue;
+ }
+ case '-': {
+ appendStrBuf(c);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT_END_DASH,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\r': {
+ appendStrBufCarriageReturn<P>();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT, reconsume, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ appendStrBufLineFeed<P>();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\0': {
+ c = 0xfffd;
+ [[fallthrough]];
+ }
+ default: {
+ appendStrBuf(c);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ commentlessthanloop_end:;
+ [[fallthrough]];
+ }
+ case COMMENT_LESSTHAN_BANG: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '-': {
+ appendStrBuf(c);
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT_LESSTHAN_BANG_DASH, reconsume, pos);
+ NS_HTML5_BREAK(commentlessthanbangloop);
+ }
+ case '<': {
+ appendStrBuf(c);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT_LESSTHAN,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\r': {
+ appendStrBufCarriageReturn<P>();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT, reconsume, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ appendStrBufLineFeed<P>();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\0': {
+ c = 0xfffd;
+ [[fallthrough]];
+ }
+ default: {
+ appendStrBuf(c);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ commentlessthanbangloop_end:;
+ [[fallthrough]];
+ }
+ case COMMENT_LESSTHAN_BANG_DASH: {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '-': {
+ appendStrBuf(c);
+ state =
+ P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT_LESSTHAN_BANG_DASH_DASH,
+ reconsume, pos);
+ break;
+ }
+ case '<': {
+ appendStrBuf(c);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT_LESSTHAN, reconsume,
+ pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\r': {
+ appendStrBufCarriageReturn<P>();
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::COMMENT,
+ reconsume, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ appendStrBufLineFeed<P>();
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::COMMENT,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\0': {
+ c = 0xfffd;
+ [[fallthrough]];
+ }
+ default: {
+ appendStrBuf(c);
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::COMMENT,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ [[fallthrough]];
+ }
+ case COMMENT_LESSTHAN_BANG_DASH_DASH: {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '>': {
+ appendStrBuf(c);
+ emitComment(3, pos);
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::DATA,
+ reconsume, pos);
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '-': {
+ if (P::reportErrors) {
+ errNestedComment();
+ }
+ adjustDoubleHyphenAndAppendToStrBufAndErr(
+ c, reportedConsecutiveHyphens);
+ reportedConsecutiveHyphens = true;
+ state =
+ P::transition(mViewSource.get(), nsHtml5Tokenizer::COMMENT_END,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\r': {
+ c = '\n';
+ P::silentCarriageReturn(this);
+ if (P::reportErrors) {
+ errNestedComment();
+ }
+ adjustDoubleHyphenAndAppendToStrBufAndErr(
+ c, reportedConsecutiveHyphens);
+ reportedConsecutiveHyphens = true;
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::COMMENT,
+ reconsume, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ if (P::reportErrors) {
+ errNestedComment();
+ }
+ adjustDoubleHyphenAndAppendToStrBufAndErr(
+ c, reportedConsecutiveHyphens);
+ reportedConsecutiveHyphens = true;
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::COMMENT,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '!': {
+ if (P::reportErrors) {
+ errNestedComment();
+ }
+ adjustDoubleHyphenAndAppendToStrBufAndErr(
+ c, reportedConsecutiveHyphens);
+ reportedConsecutiveHyphens = true;
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT_END_BANG, reconsume,
+ pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\0': {
+ c = 0xfffd;
+ [[fallthrough]];
+ }
+ default: {
+ if (P::reportErrors) {
+ errNestedComment();
+ }
+ adjustDoubleHyphenAndAppendToStrBufAndErr(
+ c, reportedConsecutiveHyphens);
+ reportedConsecutiveHyphens = true;
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::COMMENT,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ case COMMENT_START_DASH: {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '-': {
+ appendStrBuf(c);
+ state =
+ P::transition(mViewSource.get(), nsHtml5Tokenizer::COMMENT_END,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '>': {
+ if (P::reportErrors) {
+ errPrematureEndOfComment();
+ }
+ emitComment(1, pos);
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::DATA,
+ reconsume, pos);
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '<': {
+ appendStrBuf(c);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::COMMENT_LESSTHAN, reconsume,
+ pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\r': {
+ appendStrBufCarriageReturn<P>();
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::COMMENT,
+ reconsume, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ appendStrBufLineFeed<P>();
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::COMMENT,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\0': {
+ c = 0xfffd;
+ [[fallthrough]];
+ }
+ default: {
+ appendStrBuf(c);
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::COMMENT,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ case CDATA_START: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ if (index < 6) {
+ if (c == nsHtml5Tokenizer::CDATA_LSQB[index]) {
+ appendStrBuf(c);
+ } else {
+ if (P::reportErrors) {
+ errBogusComment();
+ }
+ reconsume = true;
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BOGUS_COMMENT, reconsume,
+ pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ index++;
+ continue;
+ } else {
+ clearStrBufAfterUse();
+ cstart = pos;
+ reconsume = true;
+ state =
+ P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::CDATA_SECTION, reconsume, pos);
+ break;
+ }
+ }
+ [[fallthrough]];
+ }
+ case CDATA_SECTION: {
+ for (;;) {
+ if (reconsume) {
+ reconsume = false;
+ } else {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ }
+ switch (c) {
+ case ']': {
+ flushChars(buf, pos);
+ state =
+ P::transition(mViewSource.get(), nsHtml5Tokenizer::CDATA_RSQB,
+ reconsume, pos);
+ NS_HTML5_BREAK(cdatasectionloop);
+ }
+ case '\0': {
+ maybeEmitReplacementCharacter(buf, pos);
+ continue;
+ }
+ case '\r': {
+ emitCarriageReturn<P>(buf, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ default: {
+ continue;
+ }
+ }
+ }
+ cdatasectionloop_end:;
+ [[fallthrough]];
+ }
+ case CDATA_RSQB: {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case ']': {
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::CDATA_RSQB_RSQB, reconsume,
+ pos);
+ break;
+ }
+ default: {
+ tokenHandler->characters(nsHtml5Tokenizer::RSQB_RSQB, 0, 1);
+ cstart = pos;
+ reconsume = true;
+ state =
+ P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::CDATA_SECTION, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ [[fallthrough]];
+ }
+ case CDATA_RSQB_RSQB: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case ']': {
+ tokenHandler->characters(nsHtml5Tokenizer::RSQB_RSQB, 0, 1);
+ continue;
+ }
+ case '>': {
+ cstart = pos + 1;
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::DATA,
+ reconsume, pos);
+ suspendIfRequestedAfterCurrentNonTextToken();
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ default: {
+ tokenHandler->characters(nsHtml5Tokenizer::RSQB_RSQB, 0, 2);
+ cstart = pos;
+ reconsume = true;
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::CDATA_SECTION, reconsume,
+ pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ }
+ case ATTRIBUTE_VALUE_SINGLE_QUOTED: {
+ for (;;) {
+ if (reconsume) {
+ reconsume = false;
+ } else {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ }
+ switch (c) {
+ case '\'': {
+ addAttributeWithValue();
+ state =
+ P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::AFTER_ATTRIBUTE_VALUE_QUOTED,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '&': {
+ MOZ_ASSERT(!charRefBufLen,
+ "charRefBufLen not reset after previous use!");
+ appendCharRefBuf(c);
+ setAdditionalAndRememberAmpersandLocation('\'');
+ returnState = state;
+ state =
+ P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::CONSUME_CHARACTER_REFERENCE,
+ reconsume, pos);
+ NS_HTML5_BREAK(attributevaluesinglequotedloop);
+ }
+ case '\r': {
+ appendStrBufCarriageReturn<P>();
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ appendStrBufLineFeed<P>();
+ continue;
+ }
+ case '\0': {
+ c = 0xfffd;
+ [[fallthrough]];
+ }
+ default: {
+ appendStrBuf(c);
+ continue;
+ }
+ }
+ }
+ attributevaluesinglequotedloop_end:;
+ [[fallthrough]];
+ }
+ case CONSUME_CHARACTER_REFERENCE: {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case ' ':
+ case '\t':
+ case '\n':
+ case '\r':
+ case '\f':
+ case '<':
+ case '&':
+ case '\0':
+ case ';': {
+ emitOrAppendCharRefBuf(returnState);
+ if (!(returnState & DATA_AND_RCDATA_MASK)) {
+ cstart = pos;
+ }
+ reconsume = true;
+ state =
+ P::transition(mViewSource.get(), returnState, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '#': {
+ appendCharRefBuf('#');
+ state =
+ P::transition(mViewSource.get(), nsHtml5Tokenizer::CONSUME_NCR,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ default: {
+ if (c == additional) {
+ emitOrAppendCharRefBuf(returnState);
+ reconsume = true;
+ state =
+ P::transition(mViewSource.get(), returnState, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ if (c >= 'a' && c <= 'z') {
+ firstCharKey = c - 'a' + 26;
+ } else if (c >= 'A' && c <= 'Z') {
+ firstCharKey = c - 'A';
+ } else {
+ if (c == ';') {
+ if (P::reportErrors) {
+ errNoNamedCharacterMatch();
+ }
+ }
+ emitOrAppendCharRefBuf(returnState);
+ if (!(returnState & DATA_AND_RCDATA_MASK)) {
+ cstart = pos;
+ }
+ reconsume = true;
+ state =
+ P::transition(mViewSource.get(), returnState, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ appendCharRefBuf(c);
+ state =
+ P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::CHARACTER_REFERENCE_HILO_LOOKUP,
+ reconsume, pos);
+ break;
+ }
+ }
+ [[fallthrough]];
+ }
+ case CHARACTER_REFERENCE_HILO_LOOKUP: {
+ {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ int32_t hilo = 0;
+ if (c <= 'z') {
+ const int32_t* row = nsHtml5NamedCharactersAccel::HILO_ACCEL[c];
+ if (row) {
+ hilo = row[firstCharKey];
+ }
+ }
+ if (!hilo) {
+ if (c == ';') {
+ if (P::reportErrors) {
+ errNoNamedCharacterMatch();
+ }
+ }
+ emitOrAppendCharRefBuf(returnState);
+ if (!(returnState & DATA_AND_RCDATA_MASK)) {
+ cstart = pos;
+ }
+ reconsume = true;
+ state =
+ P::transition(mViewSource.get(), returnState, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ appendCharRefBuf(c);
+ lo = hilo & 0xFFFF;
+ hi = hilo >> 16;
+ entCol = -1;
+ candidate = -1;
+ charRefBufMark = 0;
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::CHARACTER_REFERENCE_TAIL,
+ reconsume, pos);
+ }
+ [[fallthrough]];
+ }
+ case CHARACTER_REFERENCE_TAIL: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ entCol++;
+ for (;;) {
+ if (hi < lo) {
+ NS_HTML5_BREAK(outer);
+ }
+ if (entCol == nsHtml5NamedCharacters::NAMES[lo].length()) {
+ candidate = lo;
+ charRefBufMark = charRefBufLen;
+ lo++;
+ } else if (entCol > nsHtml5NamedCharacters::NAMES[lo].length()) {
+ NS_HTML5_BREAK(outer);
+ } else if (c > nsHtml5NamedCharacters::NAMES[lo].charAt(entCol)) {
+ lo++;
+ } else {
+ NS_HTML5_BREAK(loloop);
+ }
+ }
+ loloop_end:;
+ for (;;) {
+ if (hi < lo) {
+ NS_HTML5_BREAK(outer);
+ }
+ if (entCol == nsHtml5NamedCharacters::NAMES[hi].length()) {
+ NS_HTML5_BREAK(hiloop);
+ }
+ if (entCol > nsHtml5NamedCharacters::NAMES[hi].length()) {
+ NS_HTML5_BREAK(outer);
+ } else if (c < nsHtml5NamedCharacters::NAMES[hi].charAt(entCol)) {
+ hi--;
+ } else {
+ NS_HTML5_BREAK(hiloop);
+ }
+ }
+ hiloop_end:;
+ if (c == ';') {
+ if (entCol + 1 == nsHtml5NamedCharacters::NAMES[lo].length()) {
+ candidate = lo;
+ charRefBufMark = charRefBufLen;
+ }
+ NS_HTML5_BREAK(outer);
+ }
+ if (hi < lo) {
+ NS_HTML5_BREAK(outer);
+ }
+ appendCharRefBuf(c);
+ continue;
+ }
+ outer_end:;
+ if (candidate == -1) {
+ if (c == ';') {
+ if (P::reportErrors) {
+ errNoNamedCharacterMatch();
+ }
+ }
+ emitOrAppendCharRefBuf(returnState);
+ if (!(returnState & DATA_AND_RCDATA_MASK)) {
+ cstart = pos;
+ }
+ reconsume = true;
+ state = P::transition(mViewSource.get(), returnState, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ } else {
+ const nsHtml5CharacterName& candidateName =
+ nsHtml5NamedCharacters::NAMES[candidate];
+ if (!candidateName.length() ||
+ candidateName.charAt(candidateName.length() - 1) != ';') {
+ if ((returnState & DATA_AND_RCDATA_MASK)) {
+ char16_t ch;
+ if (charRefBufMark == charRefBufLen) {
+ ch = c;
+ } else {
+ ch = charRefBuf[charRefBufMark];
+ }
+ if (ch == '=' || (ch >= '0' && ch <= '9') ||
+ (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z')) {
+ if (c == ';') {
+ if (P::reportErrors) {
+ errNoNamedCharacterMatch();
+ }
+ }
+ appendCharRefBufToStrBuf();
+ reconsume = true;
+ state = P::transition(mViewSource.get(), returnState, reconsume,
+ pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ if ((returnState & DATA_AND_RCDATA_MASK)) {
+ if (P::reportErrors) {
+ errUnescapedAmpersandInterpretedAsCharacterReference();
+ }
+ } else {
+ if (P::reportErrors) {
+ errNotSemicolonTerminated();
+ }
+ }
+ }
+ P::completedNamedCharacterReference(mViewSource.get());
+ const char16_t* val = nsHtml5NamedCharacters::VALUES[candidate];
+ if (!val[1]) {
+ emitOrAppendOne(val, returnState);
+ } else {
+ emitOrAppendTwo(val, returnState);
+ }
+ if (charRefBufMark < charRefBufLen) {
+ if ((returnState & DATA_AND_RCDATA_MASK)) {
+ appendStrBuf(charRefBuf, charRefBufMark,
+ charRefBufLen - charRefBufMark);
+ } else {
+ tokenHandler->characters(charRefBuf, charRefBufMark,
+ charRefBufLen - charRefBufMark);
+ }
+ }
+ bool earlyBreak = (c == ';' && charRefBufMark == charRefBufLen);
+ charRefBufLen = 0;
+ if (!(returnState & DATA_AND_RCDATA_MASK)) {
+ cstart = earlyBreak ? pos + 1 : pos;
+ }
+ reconsume = !earlyBreak;
+ state = P::transition(mViewSource.get(), returnState, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ case CONSUME_NCR: {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ value = 0;
+ seenDigits = false;
+ switch (c) {
+ case 'x':
+ case 'X': {
+ appendCharRefBuf(c);
+ state =
+ P::transition(mViewSource.get(), nsHtml5Tokenizer::HEX_NCR_LOOP,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ default: {
+ reconsume = true;
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::DECIMAL_NRC_LOOP, reconsume,
+ pos);
+ break;
+ }
+ }
+ [[fallthrough]];
+ }
+ case DECIMAL_NRC_LOOP: {
+ for (;;) {
+ if (reconsume) {
+ reconsume = false;
+ } else {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ }
+ MOZ_ASSERT(value >= 0, "value must not become negative.");
+ if (c >= '0' && c <= '9') {
+ seenDigits = true;
+ if (value <= 0x10FFFF) {
+ value *= 10;
+ value += c - '0';
+ }
+ continue;
+ } else if (c == ';') {
+ if (seenDigits) {
+ if (!(returnState & DATA_AND_RCDATA_MASK)) {
+ cstart = pos + 1;
+ }
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::HANDLE_NCR_VALUE,
+ reconsume, pos);
+ NS_HTML5_BREAK(decimalloop);
+ } else {
+ if (P::reportErrors) {
+ errNoDigitsInNCR();
+ }
+ appendCharRefBuf(';');
+ emitOrAppendCharRefBuf(returnState);
+ if (!(returnState & DATA_AND_RCDATA_MASK)) {
+ cstart = pos + 1;
+ }
+ state =
+ P::transition(mViewSource.get(), returnState, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ } else {
+ if (!seenDigits) {
+ if (P::reportErrors) {
+ errNoDigitsInNCR();
+ }
+ emitOrAppendCharRefBuf(returnState);
+ if (!(returnState & DATA_AND_RCDATA_MASK)) {
+ cstart = pos;
+ }
+ reconsume = true;
+ state =
+ P::transition(mViewSource.get(), returnState, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ } else {
+ if (P::reportErrors) {
+ errCharRefLacksSemicolon();
+ }
+ if (!(returnState & DATA_AND_RCDATA_MASK)) {
+ cstart = pos;
+ }
+ reconsume = true;
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::HANDLE_NCR_VALUE,
+ reconsume, pos);
+ NS_HTML5_BREAK(decimalloop);
+ }
+ }
+ }
+ decimalloop_end:;
+ [[fallthrough]];
+ }
+ case HANDLE_NCR_VALUE: {
+ charRefBufLen = 0;
+ handleNcrValue(returnState);
+ state = P::transition(mViewSource.get(), returnState, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case HEX_NCR_LOOP: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ MOZ_ASSERT(value >= 0, "value must not become negative.");
+ if (c >= '0' && c <= '9') {
+ seenDigits = true;
+ if (value <= 0x10FFFF) {
+ value *= 16;
+ value += c - '0';
+ }
+ continue;
+ } else if (c >= 'A' && c <= 'F') {
+ seenDigits = true;
+ if (value <= 0x10FFFF) {
+ value *= 16;
+ value += c - 'A' + 10;
+ }
+ continue;
+ } else if (c >= 'a' && c <= 'f') {
+ seenDigits = true;
+ if (value <= 0x10FFFF) {
+ value *= 16;
+ value += c - 'a' + 10;
+ }
+ continue;
+ } else if (c == ';') {
+ if (seenDigits) {
+ if (!(returnState & DATA_AND_RCDATA_MASK)) {
+ cstart = pos + 1;
+ }
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::HANDLE_NCR_VALUE,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ } else {
+ if (P::reportErrors) {
+ errNoDigitsInNCR();
+ }
+ appendCharRefBuf(';');
+ emitOrAppendCharRefBuf(returnState);
+ if (!(returnState & DATA_AND_RCDATA_MASK)) {
+ cstart = pos + 1;
+ }
+ state =
+ P::transition(mViewSource.get(), returnState, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ } else {
+ if (!seenDigits) {
+ if (P::reportErrors) {
+ errNoDigitsInNCR();
+ }
+ emitOrAppendCharRefBuf(returnState);
+ if (!(returnState & DATA_AND_RCDATA_MASK)) {
+ cstart = pos;
+ }
+ reconsume = true;
+ state =
+ P::transition(mViewSource.get(), returnState, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ } else {
+ if (P::reportErrors) {
+ errCharRefLacksSemicolon();
+ }
+ if (!(returnState & DATA_AND_RCDATA_MASK)) {
+ cstart = pos;
+ }
+ reconsume = true;
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::HANDLE_NCR_VALUE,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ }
+ case PLAINTEXT: {
+ for (;;) {
+ if (reconsume) {
+ reconsume = false;
+ } else {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ }
+ switch (c) {
+ case '\0': {
+ emitPlaintextReplacementCharacter(buf, pos);
+ continue;
+ }
+ case '\r': {
+ emitCarriageReturn<P>(buf, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ default: {
+ continue;
+ }
+ }
+ }
+ }
+ case CLOSE_TAG_OPEN: {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '>': {
+ if (P::reportErrors) {
+ errLtSlashGt();
+ }
+ cstart = pos + 1;
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::DATA,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\r': {
+ P::silentCarriageReturn(this);
+ if (P::reportErrors) {
+ errGarbageAfterLtSlash();
+ }
+ clearStrBufBeforeUse();
+ appendStrBuf('\n');
+ state =
+ P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BOGUS_COMMENT, reconsume, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ if (P::reportErrors) {
+ errGarbageAfterLtSlash();
+ }
+ clearStrBufBeforeUse();
+ appendStrBuf(c);
+ state =
+ P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BOGUS_COMMENT, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\0': {
+ c = 0xfffd;
+ [[fallthrough]];
+ }
+ default: {
+ if (c >= 'A' && c <= 'Z') {
+ c += 0x20;
+ }
+ if (c >= 'a' && c <= 'z') {
+ endTag = true;
+ clearStrBufBeforeUse();
+ appendStrBuf(c);
+ containsHyphen = false;
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::TAG_NAME, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ } else {
+ if (P::reportErrors) {
+ errGarbageAfterLtSlash();
+ }
+ clearStrBufBeforeUse();
+ appendStrBuf(c);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BOGUS_COMMENT, reconsume,
+ pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ }
+ case RCDATA: {
+ for (;;) {
+ if (reconsume) {
+ reconsume = false;
+ } else {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ }
+ switch (c) {
+ case '&': {
+ flushChars(buf, pos);
+ MOZ_ASSERT(!charRefBufLen,
+ "charRefBufLen not reset after previous use!");
+ appendCharRefBuf(c);
+ setAdditionalAndRememberAmpersandLocation('\0');
+ returnState = state;
+ state =
+ P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::CONSUME_CHARACTER_REFERENCE,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '<': {
+ flushChars(buf, pos);
+ returnState = state;
+ state =
+ P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::RAWTEXT_RCDATA_LESS_THAN_SIGN,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\0': {
+ emitReplacementCharacter(buf, pos);
+ continue;
+ }
+ case '\r': {
+ emitCarriageReturn<P>(buf, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ default: {
+ continue;
+ }
+ }
+ }
+ }
+ case RAWTEXT: {
+ for (;;) {
+ if (reconsume) {
+ reconsume = false;
+ } else {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ }
+ switch (c) {
+ case '<': {
+ flushChars(buf, pos);
+ returnState = state;
+ state =
+ P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::RAWTEXT_RCDATA_LESS_THAN_SIGN,
+ reconsume, pos);
+ NS_HTML5_BREAK(rawtextloop);
+ }
+ case '\0': {
+ emitReplacementCharacter(buf, pos);
+ continue;
+ }
+ case '\r': {
+ emitCarriageReturn<P>(buf, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ default: {
+ continue;
+ }
+ }
+ }
+ rawtextloop_end:;
+ [[fallthrough]];
+ }
+ case RAWTEXT_RCDATA_LESS_THAN_SIGN: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '/': {
+ index = 0;
+ clearStrBufBeforeUse();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::NON_DATA_END_TAG_NAME,
+ reconsume, pos);
+ NS_HTML5_BREAK(rawtextrcdatalessthansignloop);
+ }
+ default: {
+ tokenHandler->characters(nsHtml5Tokenizer::LT_GT, 0, 1);
+ cstart = pos;
+ reconsume = true;
+ state =
+ P::transition(mViewSource.get(), returnState, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ rawtextrcdatalessthansignloop_end:;
+ [[fallthrough]];
+ }
+ case NON_DATA_END_TAG_NAME: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ if (!endTagExpectationAsArray) {
+ tokenHandler->characters(nsHtml5Tokenizer::LT_SOLIDUS, 0, 2);
+ cstart = pos;
+ reconsume = true;
+ state =
+ P::transition(mViewSource.get(), returnState, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ } else if (index < endTagExpectationAsArray.length) {
+ char16_t e = endTagExpectationAsArray[index];
+ char16_t folded = c;
+ if (c >= 'A' && c <= 'Z') {
+ folded += 0x20;
+ }
+ if (folded != e) {
+ tokenHandler->characters(nsHtml5Tokenizer::LT_SOLIDUS, 0, 2);
+ emitStrBuf();
+ cstart = pos;
+ reconsume = true;
+ state =
+ P::transition(mViewSource.get(), returnState, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ appendStrBuf(c);
+ index++;
+ continue;
+ } else {
+ endTag = true;
+ tagName = endTagExpectation;
+ switch (c) {
+ case '\r': {
+ P::silentCarriageReturn(this);
+ clearStrBufAfterUse();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BEFORE_ATTRIBUTE_NAME,
+ reconsume, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ case ' ':
+ case '\t':
+ case '\f': {
+ clearStrBufAfterUse();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BEFORE_ATTRIBUTE_NAME,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '/': {
+ clearStrBufAfterUse();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::SELF_CLOSING_START_TAG,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '>': {
+ clearStrBufAfterUse();
+ state = P::transition(mViewSource.get(),
+ emitCurrentTagToken(false, pos),
+ reconsume, pos);
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ default: {
+ tokenHandler->characters(nsHtml5Tokenizer::LT_SOLIDUS, 0, 2);
+ emitStrBuf();
+ cstart = pos;
+ reconsume = true;
+ state = P::transition(mViewSource.get(), returnState, reconsume,
+ pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ }
+ }
+ case BOGUS_COMMENT: {
+ for (;;) {
+ if (reconsume) {
+ reconsume = false;
+ } else {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ }
+ switch (c) {
+ case '>': {
+ emitComment(0, pos);
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::DATA,
+ reconsume, pos);
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '-': {
+ appendStrBuf(c);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BOGUS_COMMENT_HYPHEN,
+ reconsume, pos);
+ NS_HTML5_BREAK(boguscommentloop);
+ }
+ case '\r': {
+ appendStrBufCarriageReturn<P>();
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ appendStrBufLineFeed<P>();
+ continue;
+ }
+ case '\0': {
+ c = 0xfffd;
+ [[fallthrough]];
+ }
+ default: {
+ appendStrBuf(c);
+ continue;
+ }
+ }
+ }
+ boguscommentloop_end:;
+ [[fallthrough]];
+ }
+ case BOGUS_COMMENT_HYPHEN: {
+ boguscommenthyphenloop:
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '>': {
+ emitComment(0, pos);
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::DATA,
+ reconsume, pos);
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '-': {
+ appendSecondHyphenToBogusComment();
+ NS_HTML5_CONTINUE(boguscommenthyphenloop);
+ }
+ case '\r': {
+ appendStrBufCarriageReturn<P>();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BOGUS_COMMENT, reconsume,
+ pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ appendStrBufLineFeed<P>();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BOGUS_COMMENT, reconsume,
+ pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\0': {
+ c = 0xfffd;
+ [[fallthrough]];
+ }
+ default: {
+ appendStrBuf(c);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BOGUS_COMMENT, reconsume,
+ pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ }
+ case SCRIPT_DATA: {
+ for (;;) {
+ if (reconsume) {
+ reconsume = false;
+ } else {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ }
+ switch (c) {
+ case '<': {
+ flushChars(buf, pos);
+ returnState = state;
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_LESS_THAN_SIGN, reconsume, pos);
+ NS_HTML5_BREAK(scriptdataloop);
+ }
+ case '\0': {
+ emitReplacementCharacter(buf, pos);
+ continue;
+ }
+ case '\r': {
+ emitCarriageReturn<P>(buf, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ default: {
+ continue;
+ }
+ }
+ }
+ scriptdataloop_end:;
+ [[fallthrough]];
+ }
+ case SCRIPT_DATA_LESS_THAN_SIGN: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '/': {
+ index = 0;
+ clearStrBufBeforeUse();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::NON_DATA_END_TAG_NAME,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '!': {
+ tokenHandler->characters(nsHtml5Tokenizer::LT_GT, 0, 1);
+ cstart = pos;
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_ESCAPE_START,
+ reconsume, pos);
+ NS_HTML5_BREAK(scriptdatalessthansignloop);
+ }
+ default: {
+ tokenHandler->characters(nsHtml5Tokenizer::LT_GT, 0, 1);
+ cstart = pos;
+ reconsume = true;
+ state =
+ P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ scriptdatalessthansignloop_end:;
+ [[fallthrough]];
+ }
+ case SCRIPT_DATA_ESCAPE_START: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '-': {
+ state =
+ P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_ESCAPE_START_DASH,
+ reconsume, pos);
+ NS_HTML5_BREAK(scriptdataescapestartloop);
+ }
+ default: {
+ reconsume = true;
+ state =
+ P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ scriptdataescapestartloop_end:;
+ [[fallthrough]];
+ }
+ case SCRIPT_DATA_ESCAPE_START_DASH: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '-': {
+ state =
+ P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED_DASH_DASH,
+ reconsume, pos);
+ NS_HTML5_BREAK(scriptdataescapestartdashloop);
+ }
+ default: {
+ reconsume = true;
+ state =
+ P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ scriptdataescapestartdashloop_end:;
+ [[fallthrough]];
+ }
+ case SCRIPT_DATA_ESCAPED_DASH_DASH: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '-': {
+ continue;
+ }
+ case '<': {
+ flushChars(buf, pos);
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '>': {
+ state =
+ P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\0': {
+ emitReplacementCharacter(buf, pos);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED,
+ reconsume, pos);
+ NS_HTML5_BREAK(scriptdataescapeddashdashloop);
+ }
+ case '\r': {
+ emitCarriageReturn<P>(buf, pos);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED,
+ reconsume, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ default: {
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED,
+ reconsume, pos);
+ NS_HTML5_BREAK(scriptdataescapeddashdashloop);
+ }
+ }
+ }
+ scriptdataescapeddashdashloop_end:;
+ [[fallthrough]];
+ }
+ case SCRIPT_DATA_ESCAPED: {
+ for (;;) {
+ if (reconsume) {
+ reconsume = false;
+ } else {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ }
+ switch (c) {
+ case '-': {
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED_DASH,
+ reconsume, pos);
+ NS_HTML5_BREAK(scriptdataescapedloop);
+ }
+ case '<': {
+ flushChars(buf, pos);
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\0': {
+ emitReplacementCharacter(buf, pos);
+ continue;
+ }
+ case '\r': {
+ emitCarriageReturn<P>(buf, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ default: {
+ continue;
+ }
+ }
+ }
+ scriptdataescapedloop_end:;
+ [[fallthrough]];
+ }
+ case SCRIPT_DATA_ESCAPED_DASH: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '-': {
+ state =
+ P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED_DASH_DASH,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '<': {
+ flushChars(buf, pos);
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN,
+ reconsume, pos);
+ NS_HTML5_BREAK(scriptdataescapeddashloop);
+ }
+ case '\0': {
+ emitReplacementCharacter(buf, pos);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\r': {
+ emitCarriageReturn<P>(buf, pos);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED,
+ reconsume, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ default: {
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ scriptdataescapeddashloop_end:;
+ [[fallthrough]];
+ }
+ case SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '/': {
+ index = 0;
+ clearStrBufBeforeUse();
+ returnState = nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED;
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::NON_DATA_END_TAG_NAME,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case 'S':
+ case 's': {
+ tokenHandler->characters(nsHtml5Tokenizer::LT_GT, 0, 1);
+ cstart = pos;
+ index = 1;
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPE_START, reconsume,
+ pos);
+ NS_HTML5_BREAK(scriptdataescapedlessthanloop);
+ }
+ default: {
+ tokenHandler->characters(nsHtml5Tokenizer::LT_GT, 0, 1);
+ cstart = pos;
+ reconsume = true;
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ scriptdataescapedlessthanloop_end:;
+ [[fallthrough]];
+ }
+ case SCRIPT_DATA_DOUBLE_ESCAPE_START: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ MOZ_ASSERT(index > 0);
+ if (index < 6) {
+ char16_t folded = c;
+ if (c >= 'A' && c <= 'Z') {
+ folded += 0x20;
+ }
+ if (folded != nsHtml5Tokenizer::SCRIPT_ARR[index]) {
+ reconsume = true;
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ index++;
+ continue;
+ }
+ switch (c) {
+ case '\r': {
+ emitCarriageReturn<P>(buf, pos);
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED, reconsume, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ case ' ':
+ case '\t':
+ case '\f':
+ case '/':
+ case '>': {
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED, reconsume, pos);
+ NS_HTML5_BREAK(scriptdatadoubleescapestartloop);
+ }
+ default: {
+ reconsume = true;
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ scriptdatadoubleescapestartloop_end:;
+ [[fallthrough]];
+ }
+ case SCRIPT_DATA_DOUBLE_ESCAPED: {
+ for (;;) {
+ if (reconsume) {
+ reconsume = false;
+ } else {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ }
+ switch (c) {
+ case '-': {
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED_DASH, reconsume,
+ pos);
+ NS_HTML5_BREAK(scriptdatadoubleescapedloop);
+ }
+ case '<': {
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\0': {
+ emitReplacementCharacter(buf, pos);
+ continue;
+ }
+ case '\r': {
+ emitCarriageReturn<P>(buf, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ default: {
+ continue;
+ }
+ }
+ }
+ scriptdatadoubleescapedloop_end:;
+ [[fallthrough]];
+ }
+ case SCRIPT_DATA_DOUBLE_ESCAPED_DASH: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '-': {
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH,
+ reconsume, pos);
+ NS_HTML5_BREAK(scriptdatadoubleescapeddashloop);
+ }
+ case '<': {
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\0': {
+ emitReplacementCharacter(buf, pos);
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\r': {
+ emitCarriageReturn<P>(buf, pos);
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED, reconsume, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ default: {
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ scriptdatadoubleescapeddashloop_end:;
+ [[fallthrough]];
+ }
+ case SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '-': {
+ continue;
+ }
+ case '<': {
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN,
+ reconsume, pos);
+ NS_HTML5_BREAK(scriptdatadoubleescapeddashdashloop);
+ }
+ case '>': {
+ state =
+ P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\0': {
+ emitReplacementCharacter(buf, pos);
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\r': {
+ emitCarriageReturn<P>(buf, pos);
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED, reconsume, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ default: {
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ scriptdatadoubleescapeddashdashloop_end:;
+ [[fallthrough]];
+ }
+ case SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '/': {
+ index = 0;
+ state =
+ P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPE_END,
+ reconsume, pos);
+ NS_HTML5_BREAK(scriptdatadoubleescapedlessthanloop);
+ }
+ default: {
+ reconsume = true;
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ scriptdatadoubleescapedlessthanloop_end:;
+ [[fallthrough]];
+ }
+ case SCRIPT_DATA_DOUBLE_ESCAPE_END: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ if (index < 6) {
+ char16_t folded = c;
+ if (c >= 'A' && c <= 'Z') {
+ folded += 0x20;
+ }
+ if (folded != nsHtml5Tokenizer::SCRIPT_ARR[index]) {
+ reconsume = true;
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ index++;
+ continue;
+ }
+ switch (c) {
+ case '\r': {
+ emitCarriageReturn<P>(buf, pos);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED,
+ reconsume, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ case ' ':
+ case '\t':
+ case '\f':
+ case '/':
+ case '>': {
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ default: {
+ reconsume = true;
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED, reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ }
+ case MARKUP_DECLARATION_OCTYPE: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ if (index < 6) {
+ char16_t folded = c;
+ if (c >= 'A' && c <= 'Z') {
+ folded += 0x20;
+ }
+ if (folded == nsHtml5Tokenizer::OCTYPE[index]) {
+ appendStrBuf(c);
+ } else {
+ if (P::reportErrors) {
+ errBogusComment();
+ }
+ reconsume = true;
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BOGUS_COMMENT, reconsume,
+ pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ index++;
+ continue;
+ } else {
+ reconsume = true;
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::DOCTYPE,
+ reconsume, pos);
+ NS_HTML5_BREAK(markupdeclarationdoctypeloop);
+ }
+ }
+ markupdeclarationdoctypeloop_end:;
+ [[fallthrough]];
+ }
+ case DOCTYPE: {
+ for (;;) {
+ if (reconsume) {
+ reconsume = false;
+ } else {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ }
+ initDoctypeFields();
+ switch (c) {
+ case '\r': {
+ P::silentCarriageReturn(this);
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BEFORE_DOCTYPE_NAME,
+ reconsume, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ case ' ':
+ case '\t':
+ case '\f': {
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BEFORE_DOCTYPE_NAME,
+ reconsume, pos);
+ NS_HTML5_BREAK(doctypeloop);
+ }
+ default: {
+ if (P::reportErrors) {
+ errMissingSpaceBeforeDoctypeName();
+ }
+ reconsume = true;
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BEFORE_DOCTYPE_NAME,
+ reconsume, pos);
+ NS_HTML5_BREAK(doctypeloop);
+ }
+ }
+ }
+ doctypeloop_end:;
+ [[fallthrough]];
+ }
+ case BEFORE_DOCTYPE_NAME: {
+ for (;;) {
+ if (reconsume) {
+ reconsume = false;
+ } else {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ }
+ switch (c) {
+ case '\r': {
+ P::silentCarriageReturn(this);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ case ' ':
+ case '\t':
+ case '\f': {
+ continue;
+ }
+ case '>': {
+ if (P::reportErrors) {
+ errNamelessDoctype();
+ }
+ forceQuirks = true;
+ emitDoctypeToken(pos);
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::DATA,
+ reconsume, pos);
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\0': {
+ c = 0xfffd;
+ [[fallthrough]];
+ }
+ default: {
+ if (c >= 'A' && c <= 'Z') {
+ c += 0x20;
+ }
+ clearStrBufBeforeUse();
+ appendStrBuf(c);
+ state =
+ P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::DOCTYPE_NAME, reconsume, pos);
+ NS_HTML5_BREAK(beforedoctypenameloop);
+ }
+ }
+ }
+ beforedoctypenameloop_end:;
+ [[fallthrough]];
+ }
+ case DOCTYPE_NAME: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '\r': {
+ P::silentCarriageReturn(this);
+ strBufToDoctypeName();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::AFTER_DOCTYPE_NAME,
+ reconsume, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ case ' ':
+ case '\t':
+ case '\f': {
+ strBufToDoctypeName();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::AFTER_DOCTYPE_NAME,
+ reconsume, pos);
+ NS_HTML5_BREAK(doctypenameloop);
+ }
+ case '>': {
+ strBufToDoctypeName();
+ emitDoctypeToken(pos);
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::DATA,
+ reconsume, pos);
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\0': {
+ c = 0xfffd;
+ [[fallthrough]];
+ }
+ default: {
+ if (c >= 'A' && c <= 'Z') {
+ c += 0x0020;
+ }
+ appendStrBuf(c);
+ continue;
+ }
+ }
+ }
+ doctypenameloop_end:;
+ [[fallthrough]];
+ }
+ case AFTER_DOCTYPE_NAME: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '\r': {
+ P::silentCarriageReturn(this);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ case ' ':
+ case '\t':
+ case '\f': {
+ continue;
+ }
+ case '>': {
+ emitDoctypeToken(pos);
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::DATA,
+ reconsume, pos);
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case 'p':
+ case 'P': {
+ index = 0;
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::DOCTYPE_UBLIC, reconsume,
+ pos);
+ NS_HTML5_BREAK(afterdoctypenameloop);
+ }
+ case 's':
+ case 'S': {
+ index = 0;
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::DOCTYPE_YSTEM, reconsume,
+ pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ default: {
+ bogusDoctype();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BOGUS_DOCTYPE, reconsume,
+ pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ afterdoctypenameloop_end:;
+ [[fallthrough]];
+ }
+ case DOCTYPE_UBLIC: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ if (index < 5) {
+ char16_t folded = c;
+ if (c >= 'A' && c <= 'Z') {
+ folded += 0x20;
+ }
+ if (folded != nsHtml5Tokenizer::UBLIC[index]) {
+ bogusDoctype();
+ reconsume = true;
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BOGUS_DOCTYPE, reconsume,
+ pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ index++;
+ continue;
+ } else {
+ reconsume = true;
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::AFTER_DOCTYPE_PUBLIC_KEYWORD, reconsume, pos);
+ NS_HTML5_BREAK(doctypeublicloop);
+ }
+ }
+ doctypeublicloop_end:;
+ [[fallthrough]];
+ }
+ case AFTER_DOCTYPE_PUBLIC_KEYWORD: {
+ for (;;) {
+ if (reconsume) {
+ reconsume = false;
+ } else {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ }
+ switch (c) {
+ case '\r': {
+ P::silentCarriageReturn(this);
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::BEFORE_DOCTYPE_PUBLIC_IDENTIFIER, reconsume,
+ pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ case ' ':
+ case '\t':
+ case '\f': {
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::BEFORE_DOCTYPE_PUBLIC_IDENTIFIER, reconsume,
+ pos);
+ NS_HTML5_BREAK(afterdoctypepublickeywordloop);
+ }
+ case '\"': {
+ if (P::reportErrors) {
+ errNoSpaceBetweenDoctypePublicKeywordAndQuote();
+ }
+ clearStrBufBeforeUse();
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\'': {
+ if (P::reportErrors) {
+ errNoSpaceBetweenDoctypePublicKeywordAndQuote();
+ }
+ clearStrBufBeforeUse();
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '>': {
+ if (P::reportErrors) {
+ errExpectedPublicId();
+ }
+ forceQuirks = true;
+ emitDoctypeToken(pos);
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::DATA,
+ reconsume, pos);
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ default: {
+ bogusDoctype();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BOGUS_DOCTYPE, reconsume,
+ pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ afterdoctypepublickeywordloop_end:;
+ [[fallthrough]];
+ }
+ case BEFORE_DOCTYPE_PUBLIC_IDENTIFIER: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '\r': {
+ P::silentCarriageReturn(this);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ case ' ':
+ case '\t':
+ case '\f': {
+ continue;
+ }
+ case '\"': {
+ clearStrBufBeforeUse();
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED,
+ reconsume, pos);
+ NS_HTML5_BREAK(beforedoctypepublicidentifierloop);
+ }
+ case '\'': {
+ clearStrBufBeforeUse();
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '>': {
+ if (P::reportErrors) {
+ errExpectedPublicId();
+ }
+ forceQuirks = true;
+ emitDoctypeToken(pos);
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::DATA,
+ reconsume, pos);
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ default: {
+ bogusDoctype();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BOGUS_DOCTYPE, reconsume,
+ pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ beforedoctypepublicidentifierloop_end:;
+ [[fallthrough]];
+ }
+ case DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '\"': {
+ publicIdentifier = strBufToString();
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::AFTER_DOCTYPE_PUBLIC_IDENTIFIER, reconsume,
+ pos);
+ NS_HTML5_BREAK(doctypepublicidentifierdoublequotedloop);
+ }
+ case '>': {
+ if (P::reportErrors) {
+ errGtInPublicId();
+ }
+ forceQuirks = true;
+ publicIdentifier = strBufToString();
+ emitDoctypeToken(pos);
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::DATA,
+ reconsume, pos);
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\r': {
+ appendStrBufCarriageReturn<P>();
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ appendStrBufLineFeed<P>();
+ continue;
+ }
+ case '\0': {
+ c = 0xfffd;
+ [[fallthrough]];
+ }
+ default: {
+ appendStrBuf(c);
+ continue;
+ }
+ }
+ }
+ doctypepublicidentifierdoublequotedloop_end:;
+ [[fallthrough]];
+ }
+ case AFTER_DOCTYPE_PUBLIC_IDENTIFIER: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '\r': {
+ P::silentCarriageReturn(this);
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::
+ BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS,
+ reconsume, pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ case ' ':
+ case '\t':
+ case '\f': {
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::
+ BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS,
+ reconsume, pos);
+ NS_HTML5_BREAK(afterdoctypepublicidentifierloop);
+ }
+ case '>': {
+ emitDoctypeToken(pos);
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::DATA,
+ reconsume, pos);
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\"': {
+ if (P::reportErrors) {
+ errNoSpaceBetweenPublicAndSystemIds();
+ }
+ clearStrBufBeforeUse();
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\'': {
+ if (P::reportErrors) {
+ errNoSpaceBetweenPublicAndSystemIds();
+ }
+ clearStrBufBeforeUse();
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ default: {
+ bogusDoctype();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BOGUS_DOCTYPE, reconsume,
+ pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ afterdoctypepublicidentifierloop_end:;
+ [[fallthrough]];
+ }
+ case BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '\r': {
+ P::silentCarriageReturn(this);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ case ' ':
+ case '\t':
+ case '\f': {
+ continue;
+ }
+ case '>': {
+ emitDoctypeToken(pos);
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::DATA,
+ reconsume, pos);
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\"': {
+ clearStrBufBeforeUse();
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED,
+ reconsume, pos);
+ NS_HTML5_BREAK(betweendoctypepublicandsystemidentifiersloop);
+ }
+ case '\'': {
+ clearStrBufBeforeUse();
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ default: {
+ bogusDoctype();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BOGUS_DOCTYPE, reconsume,
+ pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ betweendoctypepublicandsystemidentifiersloop_end:;
+ [[fallthrough]];
+ }
+ case DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '\"': {
+ systemIdentifier = strBufToString();
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::AFTER_DOCTYPE_SYSTEM_IDENTIFIER, reconsume,
+ pos);
+ NS_HTML5_BREAK(doctypesystemidentifierdoublequotedloop);
+ }
+ case '>': {
+ if (P::reportErrors) {
+ errGtInSystemId();
+ }
+ forceQuirks = true;
+ systemIdentifier = strBufToString();
+ emitDoctypeToken(pos);
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::DATA,
+ reconsume, pos);
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\r': {
+ appendStrBufCarriageReturn<P>();
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ appendStrBufLineFeed<P>();
+ continue;
+ }
+ case '\0': {
+ c = 0xfffd;
+ [[fallthrough]];
+ }
+ default: {
+ appendStrBuf(c);
+ continue;
+ }
+ }
+ }
+ doctypesystemidentifierdoublequotedloop_end:;
+ [[fallthrough]];
+ }
+ case AFTER_DOCTYPE_SYSTEM_IDENTIFIER: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '\r': {
+ P::silentCarriageReturn(this);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ case ' ':
+ case '\t':
+ case '\f': {
+ continue;
+ }
+ case '>': {
+ emitDoctypeToken(pos);
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::DATA,
+ reconsume, pos);
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ default: {
+ bogusDoctypeWithoutQuirks();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BOGUS_DOCTYPE, reconsume,
+ pos);
+ NS_HTML5_BREAK(afterdoctypesystemidentifierloop);
+ }
+ }
+ }
+ afterdoctypesystemidentifierloop_end:;
+ [[fallthrough]];
+ }
+ case BOGUS_DOCTYPE: {
+ for (;;) {
+ if (reconsume) {
+ reconsume = false;
+ } else {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ }
+ switch (c) {
+ case '>': {
+ emitDoctypeToken(pos);
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::DATA,
+ reconsume, pos);
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\r': {
+ P::silentCarriageReturn(this);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ default: {
+ continue;
+ }
+ }
+ }
+ }
+ case DOCTYPE_YSTEM: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ if (index < 5) {
+ char16_t folded = c;
+ if (c >= 'A' && c <= 'Z') {
+ folded += 0x20;
+ }
+ if (folded != nsHtml5Tokenizer::YSTEM[index]) {
+ bogusDoctype();
+ reconsume = true;
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BOGUS_DOCTYPE, reconsume,
+ pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ index++;
+ NS_HTML5_CONTINUE(stateloop);
+ } else {
+ reconsume = true;
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::AFTER_DOCTYPE_SYSTEM_KEYWORD, reconsume, pos);
+ NS_HTML5_BREAK(doctypeystemloop);
+ }
+ }
+ doctypeystemloop_end:;
+ [[fallthrough]];
+ }
+ case AFTER_DOCTYPE_SYSTEM_KEYWORD: {
+ for (;;) {
+ if (reconsume) {
+ reconsume = false;
+ } else {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ }
+ switch (c) {
+ case '\r': {
+ P::silentCarriageReturn(this);
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::BEFORE_DOCTYPE_SYSTEM_IDENTIFIER, reconsume,
+ pos);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ case ' ':
+ case '\t':
+ case '\f': {
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::BEFORE_DOCTYPE_SYSTEM_IDENTIFIER, reconsume,
+ pos);
+ NS_HTML5_BREAK(afterdoctypesystemkeywordloop);
+ }
+ case '\"': {
+ if (P::reportErrors) {
+ errNoSpaceBetweenDoctypeSystemKeywordAndQuote();
+ }
+ clearStrBufBeforeUse();
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\'': {
+ if (P::reportErrors) {
+ errNoSpaceBetweenDoctypeSystemKeywordAndQuote();
+ }
+ clearStrBufBeforeUse();
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '>': {
+ if (P::reportErrors) {
+ errExpectedPublicId();
+ }
+ forceQuirks = true;
+ emitDoctypeToken(pos);
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::DATA,
+ reconsume, pos);
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ default: {
+ bogusDoctype();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BOGUS_DOCTYPE, reconsume,
+ pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ afterdoctypesystemkeywordloop_end:;
+ [[fallthrough]];
+ }
+ case BEFORE_DOCTYPE_SYSTEM_IDENTIFIER: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '\r': {
+ P::silentCarriageReturn(this);
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ P::silentLineFeed(this);
+ [[fallthrough]];
+ }
+ case ' ':
+ case '\t':
+ case '\f': {
+ continue;
+ }
+ case '\"': {
+ clearStrBufBeforeUse();
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\'': {
+ clearStrBufBeforeUse();
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED,
+ reconsume, pos);
+ NS_HTML5_BREAK(beforedoctypesystemidentifierloop);
+ }
+ case '>': {
+ if (P::reportErrors) {
+ errExpectedSystemId();
+ }
+ forceQuirks = true;
+ emitDoctypeToken(pos);
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::DATA,
+ reconsume, pos);
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ default: {
+ bogusDoctype();
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::BOGUS_DOCTYPE, reconsume,
+ pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ beforedoctypesystemidentifierloop_end:;
+ [[fallthrough]];
+ }
+ case DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '\'': {
+ systemIdentifier = strBufToString();
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::AFTER_DOCTYPE_SYSTEM_IDENTIFIER, reconsume,
+ pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '>': {
+ if (P::reportErrors) {
+ errGtInSystemId();
+ }
+ forceQuirks = true;
+ systemIdentifier = strBufToString();
+ emitDoctypeToken(pos);
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::DATA,
+ reconsume, pos);
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\r': {
+ appendStrBufCarriageReturn<P>();
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ appendStrBufLineFeed<P>();
+ continue;
+ }
+ case '\0': {
+ c = 0xfffd;
+ [[fallthrough]];
+ }
+ default: {
+ appendStrBuf(c);
+ continue;
+ }
+ }
+ }
+ }
+ case DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '\'': {
+ publicIdentifier = strBufToString();
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::AFTER_DOCTYPE_PUBLIC_IDENTIFIER, reconsume,
+ pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '>': {
+ if (P::reportErrors) {
+ errGtInPublicId();
+ }
+ forceQuirks = true;
+ publicIdentifier = strBufToString();
+ emitDoctypeToken(pos);
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::DATA,
+ reconsume, pos);
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ case '\r': {
+ appendStrBufCarriageReturn<P>();
+ NS_HTML5_BREAK(stateloop);
+ }
+ case '\n': {
+ appendStrBufLineFeed<P>();
+ continue;
+ }
+ case '\0': {
+ c = 0xfffd;
+ [[fallthrough]];
+ }
+ default: {
+ appendStrBuf(c);
+ continue;
+ }
+ }
+ }
+ }
+ case PROCESSING_INSTRUCTION: {
+ for (;;) {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '\?': {
+ state = P::transition(
+ mViewSource.get(),
+ nsHtml5Tokenizer::PROCESSING_INSTRUCTION_QUESTION_MARK,
+ reconsume, pos);
+ NS_HTML5_BREAK(processinginstructionloop);
+ }
+ default: {
+ continue;
+ }
+ }
+ }
+ processinginstructionloop_end:;
+ [[fallthrough]];
+ }
+ case PROCESSING_INSTRUCTION_QUESTION_MARK: {
+ if (++pos == endPos) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ c = P::checkChar(this, buf, pos);
+ switch (c) {
+ case '>': {
+ state = P::transition(mViewSource.get(), nsHtml5Tokenizer::DATA,
+ reconsume, pos);
+ suspendIfRequestedAfterCurrentNonTextToken();
+ if (shouldSuspend) {
+ NS_HTML5_BREAK(stateloop);
+ }
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ default: {
+ state = P::transition(mViewSource.get(),
+ nsHtml5Tokenizer::PROCESSING_INSTRUCTION,
+ reconsume, pos);
+ NS_HTML5_CONTINUE(stateloop);
+ }
+ }
+ }
+ }
+ }
+stateloop_end:;
+ flushChars(buf, pos);
+ stateSave = state;
+ returnStateSave = returnState;
+ return pos;
+}
+
+void nsHtml5Tokenizer::initDoctypeFields() {
+ clearStrBufAfterUse();
+ doctypeName = nullptr;
+ if (systemIdentifier) {
+ systemIdentifier.Release();
+ systemIdentifier = nullptr;
+ }
+ if (publicIdentifier) {
+ publicIdentifier.Release();
+ publicIdentifier = nullptr;
+ }
+ forceQuirks = false;
+}
+
+template <class P>
+void nsHtml5Tokenizer::adjustDoubleHyphenAndAppendToStrBufCarriageReturn() {
+ P::silentCarriageReturn(this);
+ adjustDoubleHyphenAndAppendToStrBufAndErr('\n', false);
+}
+
+template <class P>
+void nsHtml5Tokenizer::adjustDoubleHyphenAndAppendToStrBufLineFeed() {
+ P::silentLineFeed(this);
+ adjustDoubleHyphenAndAppendToStrBufAndErr('\n', false);
+}
+
+template <class P>
+void nsHtml5Tokenizer::appendStrBufLineFeed() {
+ P::silentLineFeed(this);
+ appendStrBuf('\n');
+}
+
+template <class P>
+void nsHtml5Tokenizer::appendStrBufCarriageReturn() {
+ P::silentCarriageReturn(this);
+ appendStrBuf('\n');
+}
+
+template <class P>
+void nsHtml5Tokenizer::emitCarriageReturn(char16_t* buf, int32_t pos) {
+ P::silentCarriageReturn(this);
+ flushChars(buf, pos);
+ tokenHandler->characters(nsHtml5Tokenizer::LF, 0, 1);
+ cstart = INT32_MAX;
+}
+
+void nsHtml5Tokenizer::emitReplacementCharacter(char16_t* buf, int32_t pos) {
+ flushChars(buf, pos);
+ tokenHandler->zeroOriginatingReplacementCharacter();
+ cstart = pos + 1;
+}
+
+void nsHtml5Tokenizer::maybeEmitReplacementCharacter(char16_t* buf,
+ int32_t pos) {
+ flushChars(buf, pos);
+ tokenHandler->zeroOrReplacementCharacter();
+ cstart = pos + 1;
+}
+
+void nsHtml5Tokenizer::emitPlaintextReplacementCharacter(char16_t* buf,
+ int32_t pos) {
+ flushChars(buf, pos);
+ tokenHandler->characters(REPLACEMENT_CHARACTER, 0, 1);
+ cstart = pos + 1;
+}
+
+void nsHtml5Tokenizer::setAdditionalAndRememberAmpersandLocation(char16_t add) {
+ additional = add;
+}
+
+void nsHtml5Tokenizer::bogusDoctype() {
+ errBogusDoctype();
+ forceQuirks = true;
+}
+
+void nsHtml5Tokenizer::bogusDoctypeWithoutQuirks() {
+ errBogusDoctype();
+ forceQuirks = false;
+}
+
+void nsHtml5Tokenizer::handleNcrValue(int32_t returnState) {
+ if (value <= 0xFFFF) {
+ if (value >= 0x80 && value <= 0x9f) {
+ errNcrInC1Range();
+ char16_t* val = nsHtml5NamedCharacters::WINDOWS_1252[value - 0x80];
+ emitOrAppendOne(val, returnState);
+ } else if (value == 0x0) {
+ errNcrZero();
+ emitOrAppendOne(nsHtml5Tokenizer::REPLACEMENT_CHARACTER, returnState);
+ } else if ((value & 0xF800) == 0xD800) {
+ errNcrSurrogate();
+ emitOrAppendOne(nsHtml5Tokenizer::REPLACEMENT_CHARACTER, returnState);
+ } else {
+ char16_t ch = (char16_t)value;
+ bmpChar[0] = ch;
+ emitOrAppendOne(bmpChar, returnState);
+ }
+ } else if (value <= 0x10FFFF) {
+ astralChar[0] = (char16_t)(nsHtml5Tokenizer::LEAD_OFFSET + (value >> 10));
+ astralChar[1] = (char16_t)(0xDC00 + (value & 0x3FF));
+ emitOrAppendTwo(astralChar, returnState);
+ } else {
+ errNcrOutOfRange();
+ emitOrAppendOne(nsHtml5Tokenizer::REPLACEMENT_CHARACTER, returnState);
+ }
+}
+
+void nsHtml5Tokenizer::eof() {
+ int32_t state = stateSave;
+ int32_t returnState = returnStateSave;
+eofloop:
+ for (;;) {
+ switch (state) {
+ case SCRIPT_DATA_LESS_THAN_SIGN:
+ case SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN: {
+ tokenHandler->characters(nsHtml5Tokenizer::LT_GT, 0, 1);
+ NS_HTML5_BREAK(eofloop);
+ }
+ case TAG_OPEN: {
+ errEofAfterLt();
+ tokenHandler->characters(nsHtml5Tokenizer::LT_GT, 0, 1);
+ NS_HTML5_BREAK(eofloop);
+ }
+ case RAWTEXT_RCDATA_LESS_THAN_SIGN: {
+ tokenHandler->characters(nsHtml5Tokenizer::LT_GT, 0, 1);
+ NS_HTML5_BREAK(eofloop);
+ }
+ case NON_DATA_END_TAG_NAME: {
+ tokenHandler->characters(nsHtml5Tokenizer::LT_SOLIDUS, 0, 2);
+ emitStrBuf();
+ NS_HTML5_BREAK(eofloop);
+ }
+ case CLOSE_TAG_OPEN: {
+ errEofAfterLt();
+ tokenHandler->characters(nsHtml5Tokenizer::LT_SOLIDUS, 0, 2);
+ NS_HTML5_BREAK(eofloop);
+ }
+ case TAG_NAME: {
+ errEofInTagName();
+ NS_HTML5_BREAK(eofloop);
+ }
+ case BEFORE_ATTRIBUTE_NAME:
+ case AFTER_ATTRIBUTE_VALUE_QUOTED:
+ case SELF_CLOSING_START_TAG: {
+ errEofWithoutGt();
+ NS_HTML5_BREAK(eofloop);
+ }
+ case ATTRIBUTE_NAME: {
+ errEofInAttributeName();
+ NS_HTML5_BREAK(eofloop);
+ }
+ case AFTER_ATTRIBUTE_NAME:
+ case BEFORE_ATTRIBUTE_VALUE: {
+ errEofWithoutGt();
+ NS_HTML5_BREAK(eofloop);
+ }
+ case ATTRIBUTE_VALUE_DOUBLE_QUOTED:
+ case ATTRIBUTE_VALUE_SINGLE_QUOTED:
+ case ATTRIBUTE_VALUE_UNQUOTED: {
+ errEofInAttributeValue();
+ NS_HTML5_BREAK(eofloop);
+ }
+ case BOGUS_COMMENT: {
+ emitComment(0, 0);
+ NS_HTML5_BREAK(eofloop);
+ }
+ case BOGUS_COMMENT_HYPHEN: {
+ emitComment(0, 0);
+ NS_HTML5_BREAK(eofloop);
+ }
+ case MARKUP_DECLARATION_OPEN: {
+ errBogusComment();
+ emitComment(0, 0);
+ NS_HTML5_BREAK(eofloop);
+ }
+ case MARKUP_DECLARATION_HYPHEN: {
+ errBogusComment();
+ emitComment(0, 0);
+ NS_HTML5_BREAK(eofloop);
+ }
+ case MARKUP_DECLARATION_OCTYPE: {
+ if (index < 6) {
+ errBogusComment();
+ emitComment(0, 0);
+ } else {
+ errEofInDoctype();
+ doctypeName = nullptr;
+ if (systemIdentifier) {
+ systemIdentifier.Release();
+ systemIdentifier = nullptr;
+ }
+ if (publicIdentifier) {
+ publicIdentifier.Release();
+ publicIdentifier = nullptr;
+ }
+ forceQuirks = true;
+ emitDoctypeToken(0);
+ NS_HTML5_BREAK(eofloop);
+ }
+ NS_HTML5_BREAK(eofloop);
+ }
+ case COMMENT_START:
+ case COMMENT:
+ case COMMENT_LESSTHAN:
+ case COMMENT_LESSTHAN_BANG: {
+ errEofInComment();
+ emitComment(0, 0);
+ NS_HTML5_BREAK(eofloop);
+ }
+ case COMMENT_END:
+ case COMMENT_LESSTHAN_BANG_DASH_DASH: {
+ errEofInComment();
+ emitComment(2, 0);
+ NS_HTML5_BREAK(eofloop);
+ }
+ case COMMENT_END_DASH:
+ case COMMENT_START_DASH:
+ case COMMENT_LESSTHAN_BANG_DASH: {
+ errEofInComment();
+ emitComment(1, 0);
+ NS_HTML5_BREAK(eofloop);
+ }
+ case COMMENT_END_BANG: {
+ errEofInComment();
+ emitComment(3, 0);
+ NS_HTML5_BREAK(eofloop);
+ }
+ case DOCTYPE:
+ case BEFORE_DOCTYPE_NAME: {
+ errEofInDoctype();
+ forceQuirks = true;
+ emitDoctypeToken(0);
+ NS_HTML5_BREAK(eofloop);
+ }
+ case DOCTYPE_NAME: {
+ errEofInDoctype();
+ strBufToDoctypeName();
+ forceQuirks = true;
+ emitDoctypeToken(0);
+ NS_HTML5_BREAK(eofloop);
+ }
+ case DOCTYPE_UBLIC:
+ case DOCTYPE_YSTEM:
+ case AFTER_DOCTYPE_NAME:
+ case AFTER_DOCTYPE_PUBLIC_KEYWORD:
+ case AFTER_DOCTYPE_SYSTEM_KEYWORD:
+ case BEFORE_DOCTYPE_PUBLIC_IDENTIFIER: {
+ errEofInDoctype();
+ forceQuirks = true;
+ emitDoctypeToken(0);
+ NS_HTML5_BREAK(eofloop);
+ }
+ case DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED:
+ case DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED: {
+ errEofInPublicId();
+ forceQuirks = true;
+ publicIdentifier = strBufToString();
+ emitDoctypeToken(0);
+ NS_HTML5_BREAK(eofloop);
+ }
+ case AFTER_DOCTYPE_PUBLIC_IDENTIFIER:
+ case BEFORE_DOCTYPE_SYSTEM_IDENTIFIER:
+ case BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS: {
+ errEofInDoctype();
+ forceQuirks = true;
+ emitDoctypeToken(0);
+ NS_HTML5_BREAK(eofloop);
+ }
+ case DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED:
+ case DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED: {
+ errEofInSystemId();
+ forceQuirks = true;
+ systemIdentifier = strBufToString();
+ emitDoctypeToken(0);
+ NS_HTML5_BREAK(eofloop);
+ }
+ case AFTER_DOCTYPE_SYSTEM_IDENTIFIER: {
+ errEofInDoctype();
+ forceQuirks = true;
+ emitDoctypeToken(0);
+ NS_HTML5_BREAK(eofloop);
+ }
+ case BOGUS_DOCTYPE: {
+ emitDoctypeToken(0);
+ NS_HTML5_BREAK(eofloop);
+ }
+ case CONSUME_CHARACTER_REFERENCE: {
+ emitOrAppendCharRefBuf(returnState);
+ state = returnState;
+ continue;
+ }
+ case CHARACTER_REFERENCE_HILO_LOOKUP: {
+ emitOrAppendCharRefBuf(returnState);
+ state = returnState;
+ continue;
+ }
+ case CHARACTER_REFERENCE_TAIL: {
+ for (;;) {
+ char16_t c = '\0';
+ entCol++;
+ for (;;) {
+ if (hi == -1) {
+ NS_HTML5_BREAK(hiloop);
+ }
+ if (entCol == nsHtml5NamedCharacters::NAMES[hi].length()) {
+ NS_HTML5_BREAK(hiloop);
+ }
+ if (entCol > nsHtml5NamedCharacters::NAMES[hi].length()) {
+ NS_HTML5_BREAK(outer);
+ } else if (c < nsHtml5NamedCharacters::NAMES[hi].charAt(entCol)) {
+ hi--;
+ } else {
+ NS_HTML5_BREAK(hiloop);
+ }
+ }
+ hiloop_end:;
+ for (;;) {
+ if (hi < lo) {
+ NS_HTML5_BREAK(outer);
+ }
+ if (entCol == nsHtml5NamedCharacters::NAMES[lo].length()) {
+ candidate = lo;
+ charRefBufMark = charRefBufLen;
+ lo++;
+ } else if (entCol > nsHtml5NamedCharacters::NAMES[lo].length()) {
+ NS_HTML5_BREAK(outer);
+ } else if (c > nsHtml5NamedCharacters::NAMES[lo].charAt(entCol)) {
+ lo++;
+ } else {
+ NS_HTML5_BREAK(loloop);
+ }
+ }
+ loloop_end:;
+ if (hi < lo) {
+ NS_HTML5_BREAK(outer);
+ }
+ continue;
+ }
+ outer_end:;
+ if (candidate == -1) {
+ emitOrAppendCharRefBuf(returnState);
+ state = returnState;
+ NS_HTML5_CONTINUE(eofloop);
+ } else {
+ const nsHtml5CharacterName& candidateName =
+ nsHtml5NamedCharacters::NAMES[candidate];
+ if (!candidateName.length() ||
+ candidateName.charAt(candidateName.length() - 1) != ';') {
+ if ((returnState & DATA_AND_RCDATA_MASK)) {
+ char16_t ch;
+ if (charRefBufMark == charRefBufLen) {
+ ch = '\0';
+ } else {
+ ch = charRefBuf[charRefBufMark];
+ }
+ if ((ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'Z') ||
+ (ch >= 'a' && ch <= 'z')) {
+ appendCharRefBufToStrBuf();
+ state = returnState;
+ NS_HTML5_CONTINUE(eofloop);
+ }
+ }
+ if ((returnState & DATA_AND_RCDATA_MASK)) {
+ errUnescapedAmpersandInterpretedAsCharacterReference();
+ } else {
+ errNotSemicolonTerminated();
+ }
+ }
+ const char16_t* val = nsHtml5NamedCharacters::VALUES[candidate];
+ if (!val[1]) {
+ emitOrAppendOne(val, returnState);
+ } else {
+ emitOrAppendTwo(val, returnState);
+ }
+ if (charRefBufMark < charRefBufLen) {
+ if ((returnState & DATA_AND_RCDATA_MASK)) {
+ appendStrBuf(charRefBuf, charRefBufMark,
+ charRefBufLen - charRefBufMark);
+ } else {
+ tokenHandler->characters(charRefBuf, charRefBufMark,
+ charRefBufLen - charRefBufMark);
+ }
+ }
+ charRefBufLen = 0;
+ state = returnState;
+ NS_HTML5_CONTINUE(eofloop);
+ }
+ }
+ case CONSUME_NCR:
+ case DECIMAL_NRC_LOOP:
+ case HEX_NCR_LOOP: {
+ if (!seenDigits) {
+ errNoDigitsInNCR();
+ emitOrAppendCharRefBuf(returnState);
+ state = returnState;
+ continue;
+ } else {
+ errCharRefLacksSemicolon();
+ }
+ handleNcrValue(returnState);
+ state = returnState;
+ continue;
+ }
+ case CDATA_RSQB: {
+ tokenHandler->characters(nsHtml5Tokenizer::RSQB_RSQB, 0, 1);
+ NS_HTML5_BREAK(eofloop);
+ }
+ case CDATA_RSQB_RSQB: {
+ tokenHandler->characters(nsHtml5Tokenizer::RSQB_RSQB, 0, 2);
+ NS_HTML5_BREAK(eofloop);
+ }
+ case DATA:
+ default: {
+ NS_HTML5_BREAK(eofloop);
+ }
+ }
+ }
+eofloop_end:;
+ tokenHandler->eof();
+ return;
+}
+
+void nsHtml5Tokenizer::emitDoctypeToken(int32_t pos) {
+ RememberGt(pos);
+ cstart = pos + 1;
+ tokenHandler->doctype(doctypeName, publicIdentifier, systemIdentifier,
+ forceQuirks);
+ doctypeName = nullptr;
+ publicIdentifier.Release();
+ publicIdentifier = nullptr;
+ systemIdentifier.Release();
+ systemIdentifier = nullptr;
+ suspendIfRequestedAfterCurrentNonTextToken();
+}
+
+void nsHtml5Tokenizer::suspendIfRequestedAfterCurrentNonTextToken() {
+ if (suspendAfterCurrentNonTextToken) {
+ suspendAfterCurrentNonTextToken = false;
+ shouldSuspend = true;
+ }
+}
+
+void nsHtml5Tokenizer::suspendAfterCurrentTokenIfNotInText() {
+ switch (stateSave) {
+ case DATA:
+ case RCDATA:
+ case SCRIPT_DATA:
+ case RAWTEXT:
+ case SCRIPT_DATA_ESCAPED:
+ case PLAINTEXT:
+ case NON_DATA_END_TAG_NAME:
+ case SCRIPT_DATA_LESS_THAN_SIGN:
+ case SCRIPT_DATA_ESCAPE_START:
+ case SCRIPT_DATA_ESCAPE_START_DASH:
+ case SCRIPT_DATA_ESCAPED_DASH:
+ case SCRIPT_DATA_ESCAPED_DASH_DASH:
+ case RAWTEXT_RCDATA_LESS_THAN_SIGN:
+ case SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN:
+ case SCRIPT_DATA_DOUBLE_ESCAPE_START:
+ case SCRIPT_DATA_DOUBLE_ESCAPED:
+ case SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN:
+ case SCRIPT_DATA_DOUBLE_ESCAPED_DASH:
+ case SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH:
+ case SCRIPT_DATA_DOUBLE_ESCAPE_END: {
+ return;
+ }
+ case TAG_NAME:
+ case BEFORE_ATTRIBUTE_NAME:
+ case ATTRIBUTE_NAME:
+ case AFTER_ATTRIBUTE_NAME:
+ case BEFORE_ATTRIBUTE_VALUE:
+ case AFTER_ATTRIBUTE_VALUE_QUOTED:
+ case BOGUS_COMMENT:
+ case MARKUP_DECLARATION_OPEN:
+ case DOCTYPE:
+ case BEFORE_DOCTYPE_NAME:
+ case DOCTYPE_NAME:
+ case AFTER_DOCTYPE_NAME:
+ case BEFORE_DOCTYPE_PUBLIC_IDENTIFIER:
+ case DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED:
+ case DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED:
+ case AFTER_DOCTYPE_PUBLIC_IDENTIFIER:
+ case BEFORE_DOCTYPE_SYSTEM_IDENTIFIER:
+ case DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED:
+ case DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED:
+ case AFTER_DOCTYPE_SYSTEM_IDENTIFIER:
+ case BOGUS_DOCTYPE:
+ case COMMENT_START:
+ case COMMENT_START_DASH:
+ case COMMENT:
+ case COMMENT_END_DASH:
+ case COMMENT_END:
+ case COMMENT_END_BANG:
+ case TAG_OPEN:
+ case CLOSE_TAG_OPEN:
+ case MARKUP_DECLARATION_HYPHEN:
+ case MARKUP_DECLARATION_OCTYPE:
+ case DOCTYPE_UBLIC:
+ case DOCTYPE_YSTEM:
+ case AFTER_DOCTYPE_PUBLIC_KEYWORD:
+ case BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS:
+ case AFTER_DOCTYPE_SYSTEM_KEYWORD:
+ case SELF_CLOSING_START_TAG:
+ case ATTRIBUTE_VALUE_DOUBLE_QUOTED:
+ case ATTRIBUTE_VALUE_SINGLE_QUOTED:
+ case ATTRIBUTE_VALUE_UNQUOTED:
+ case BOGUS_COMMENT_HYPHEN:
+ case COMMENT_LESSTHAN:
+ case COMMENT_LESSTHAN_BANG:
+ case COMMENT_LESSTHAN_BANG_DASH:
+ case COMMENT_LESSTHAN_BANG_DASH_DASH:
+ case CDATA_START:
+ case CDATA_SECTION:
+ case CDATA_RSQB:
+ case CDATA_RSQB_RSQB:
+ case PROCESSING_INSTRUCTION:
+ case PROCESSING_INSTRUCTION_QUESTION_MARK: {
+ break;
+ }
+ case CONSUME_CHARACTER_REFERENCE:
+ case CONSUME_NCR:
+ case CHARACTER_REFERENCE_TAIL:
+ case HEX_NCR_LOOP:
+ case DECIMAL_NRC_LOOP:
+ case HANDLE_NCR_VALUE:
+ case HANDLE_NCR_VALUE_RECONSUME:
+ case CHARACTER_REFERENCE_HILO_LOOKUP: {
+ if (returnStateSave == DATA || returnStateSave == RCDATA) {
+ return;
+ }
+ break;
+ }
+ default: {
+ MOZ_ASSERT(false, "Incomplete switch");
+ return;
+ }
+ }
+ suspendAfterCurrentNonTextToken = true;
+}
+
+bool nsHtml5Tokenizer::suspensionAfterCurrentNonTextTokenPending() {
+ return suspendAfterCurrentNonTextToken;
+}
+
+bool nsHtml5Tokenizer::internalEncodingDeclaration(
+ nsHtml5String internalCharset) {
+ if (encodingDeclarationHandler) {
+ return encodingDeclarationHandler->internalEncodingDeclaration(
+ internalCharset);
+ }
+ return false;
+}
+
+void nsHtml5Tokenizer::emitOrAppendTwo(const char16_t* val,
+ int32_t returnState) {
+ if ((returnState & DATA_AND_RCDATA_MASK)) {
+ appendStrBuf(val[0]);
+ appendStrBuf(val[1]);
+ } else {
+ tokenHandler->characters(val, 0, 2);
+ }
+}
+
+void nsHtml5Tokenizer::emitOrAppendOne(const char16_t* val,
+ int32_t returnState) {
+ if ((returnState & DATA_AND_RCDATA_MASK)) {
+ appendStrBuf(val[0]);
+ } else {
+ tokenHandler->characters(val, 0, 1);
+ }
+}
+
+void nsHtml5Tokenizer::end() {
+ strBuf = nullptr;
+ doctypeName = nullptr;
+ if (systemIdentifier) {
+ systemIdentifier.Release();
+ systemIdentifier = nullptr;
+ }
+ if (publicIdentifier) {
+ publicIdentifier.Release();
+ publicIdentifier = nullptr;
+ }
+ tagName = nullptr;
+ nonInternedTagName->setNameForNonInterned(nullptr, false);
+ attributeName = nullptr;
+ nonInternedAttributeName->setNameForNonInterned(nullptr);
+ tokenHandler->endTokenization();
+ if (attributes) {
+ attributes->clear(0);
+ }
+}
+
+void nsHtml5Tokenizer::requestSuspension() { shouldSuspend = true; }
+
+bool nsHtml5Tokenizer::isInDataState() { return (stateSave == DATA); }
+
+void nsHtml5Tokenizer::resetToDataState() {
+ clearStrBufAfterUse();
+ charRefBufLen = 0;
+ stateSave = nsHtml5Tokenizer::DATA;
+ lastCR = false;
+ index = 0;
+ forceQuirks = false;
+ additional = '\0';
+ entCol = -1;
+ firstCharKey = -1;
+ lo = 0;
+ hi = 0;
+ candidate = -1;
+ charRefBufMark = 0;
+ value = 0;
+ seenDigits = false;
+ suspendAfterCurrentNonTextToken = false;
+ endTag = false;
+ shouldSuspend = false;
+ initDoctypeFields();
+ containsHyphen = false;
+ tagName = nullptr;
+ attributeName = nullptr;
+ if (newAttributesEachTime) {
+ if (attributes) {
+ delete attributes;
+ attributes = nullptr;
+ }
+ }
+}
+
+void nsHtml5Tokenizer::loadState(nsHtml5Tokenizer* other) {
+ strBufLen = other->strBufLen;
+ if (strBufLen > strBuf.length) {
+ strBuf = jArray<char16_t, int32_t>::newJArray(strBufLen);
+ }
+ nsHtml5ArrayCopy::arraycopy(other->strBuf, strBuf, strBufLen);
+ charRefBufLen = other->charRefBufLen;
+ nsHtml5ArrayCopy::arraycopy(other->charRefBuf, charRefBuf, charRefBufLen);
+ stateSave = other->stateSave;
+ returnStateSave = other->returnStateSave;
+ endTagExpectation = other->endTagExpectation;
+ endTagExpectationAsArray = other->endTagExpectationAsArray;
+ lastCR = other->lastCR;
+ index = other->index;
+ forceQuirks = other->forceQuirks;
+ additional = other->additional;
+ entCol = other->entCol;
+ firstCharKey = other->firstCharKey;
+ lo = other->lo;
+ hi = other->hi;
+ candidate = other->candidate;
+ charRefBufMark = other->charRefBufMark;
+ value = other->value;
+ seenDigits = other->seenDigits;
+ endTag = other->endTag;
+ shouldSuspend = false;
+ suspendAfterCurrentNonTextToken = false;
+ doctypeName = other->doctypeName;
+ systemIdentifier.Release();
+ if (!other->systemIdentifier) {
+ systemIdentifier = nullptr;
+ } else {
+ systemIdentifier =
+ nsHtml5Portability::newStringFromString(other->systemIdentifier);
+ }
+ publicIdentifier.Release();
+ if (!other->publicIdentifier) {
+ publicIdentifier = nullptr;
+ } else {
+ publicIdentifier =
+ nsHtml5Portability::newStringFromString(other->publicIdentifier);
+ }
+ containsHyphen = other->containsHyphen;
+ if (!other->tagName) {
+ tagName = nullptr;
+ } else if (other->tagName->isInterned()) {
+ tagName = other->tagName;
+ } else {
+ nonInternedTagName->setNameForNonInterned(other->tagName->getName(),
+ other->tagName->isCustom());
+ tagName = nonInternedTagName;
+ }
+ if (!other->attributeName) {
+ attributeName = nullptr;
+ } else if (other->attributeName->isInterned()) {
+ attributeName = other->attributeName;
+ } else {
+ nonInternedAttributeName->setNameForNonInterned(
+ other->attributeName->getLocal(nsHtml5AttributeName::HTML));
+ attributeName = nonInternedAttributeName;
+ }
+ delete attributes;
+ if (!other->attributes) {
+ attributes = nullptr;
+ } else {
+ attributes = other->attributes->cloneAttributes();
+ }
+}
+
+void nsHtml5Tokenizer::initializeWithoutStarting() {
+ confident = false;
+ strBuf = nullptr;
+ line = 1;
+ attributeLine = 1;
+ resetToDataState();
+}
+
+void nsHtml5Tokenizer::setEncodingDeclarationHandler(
+ nsHtml5StreamParser* encodingDeclarationHandler) {
+ this->encodingDeclarationHandler = encodingDeclarationHandler;
+}
+
+nsHtml5Tokenizer::~nsHtml5Tokenizer() {
+ MOZ_COUNT_DTOR(nsHtml5Tokenizer);
+ delete nonInternedTagName;
+ nonInternedTagName = nullptr;
+ delete nonInternedAttributeName;
+ nonInternedAttributeName = nullptr;
+ delete attributes;
+ attributes = nullptr;
+}
+
+void nsHtml5Tokenizer::initializeStatics() {}
+
+void nsHtml5Tokenizer::releaseStatics() {}
+
+#include "nsHtml5TokenizerCppSupplement.h"