XLinfini/sousa-gecko
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
sousa-gecko/parser/html/nsHtml5TokenizerLoopPoliciesSIMD.h
T

650 lines
26 KiB
C
Raw Permalink Blame History

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef nsHtml5TokenizerLoopPoliciesSIMD_h
#define nsHtml5TokenizerLoopPoliciesSIMD_h
#include "mozilla/Attributes.h"
#include "mozilla/htmlaccel/htmlaccelNotInline.h"
#include "mozilla/Utf16.h"
/**
* This policy does not report tokenizer transitions anywhere and does not
* track line and column numbers. To be used for innerHTML.
*
* This the SIMD version for aarch64 and SSSE3-enabled x86/x86_64.
*/
struct nsHtml5FastestPolicySIMD {
static const bool reportErrors = false;
MOZ_ALWAYS_INLINE_EVEN_DEBUG static int32_t transition(
nsHtml5Highlighter* aHighlighter, int32_t aState, bool aReconsume,
int32_t aPos) {
return aState;
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static void completedNamedCharacterReference(
nsHtml5Highlighter* aHighlighter) {}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static int32_t accelerateAdvancementData(
nsHtml5Tokenizer* aTokenizer, char16_t* buf, int32_t pos,
int32_t endPos) {
// We need to check bounds for the `buf[pos]` access below to be OK.
// Instead of just checking that `pos` isn't equal to `endPos`, let's
// check that have at least one SIMD stride of data in the same branch,
// since if we don't have at least one SIMD stride of data, we don't
// need to proceed.
if (endPos - pos < 16) {
return 0;
}
if (buf[pos] == '<') {
// Quickly handle the case where there is one tag immediately
// after another and the very first thing in the data state is a
// less-than sign.
return 0;
}
return mozilla::htmlaccel::AccelerateDataFastest(buf + pos, buf + endPos);
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static int32_t accelerateAdvancementRawtext(
nsHtml5Tokenizer* aTokenizer, char16_t* buf, int32_t pos,
int32_t endPos) {
// We need to check bounds for the `buf[pos]` access below to be OK.
// Instead of just checking that `pos` isn't equal to `endPos`, let's
// check that have at least one SIMD stride of data in the same branch,
// since if we don't have at least one SIMD stride of data, we don't
// need to proceed.
if (endPos - pos < 16) {
return 0;
}
if (buf[pos] == '<') {
// Quickly handle the <iframe></iframe> case.
return 0;
}
return mozilla::htmlaccel::AccelerateRawtextFastest(buf + pos,
buf + endPos);
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static int32_t
accelerateAdvancementScriptDataEscaped(nsHtml5Tokenizer* aTokenizer,
char16_t* buf, int32_t pos,
int32_t endPos) {
// This state shares the SIMD part with the comment state, but this
// wrapper needs to differ!
return mozilla::htmlaccel::AccelerateCommentFastest(buf + pos,
buf + endPos);
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static int32_t accelerateAdvancementComment(
nsHtml5Tokenizer* aTokenizer, char16_t* buf, int32_t pos,
int32_t endPos) {
int32_t len = endPos - pos;
int32_t strBufAvailable = aTokenizer->strBuf.length - aTokenizer->strBufLen;
if (len > strBufAvailable) {
MOZ_DIAGNOSTIC_ASSERT(false, "strBuf has not been extended correctly.");
len = strBufAvailable;
}
int32_t advance = mozilla::htmlaccel::AccelerateCommentFastest(
buf + pos, buf + pos + len);
// States that on the non-SIMD path copy characters to strBuf also
// need to do that in the SIMD case.
nsHtml5ArrayCopy::arraycopy(buf, pos, aTokenizer->strBuf,
aTokenizer->strBufLen, advance);
aTokenizer->strBufLen += advance;
return advance;
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static int32_t
accelerateAdvancementAttributeValueSingleQuoted(nsHtml5Tokenizer* aTokenizer,
char16_t* buf, int32_t pos,
int32_t endPos) {
int32_t len = endPos - pos;
int32_t strBufAvailable = aTokenizer->strBuf.length - aTokenizer->strBufLen;
if (len > strBufAvailable) {
MOZ_DIAGNOSTIC_ASSERT(false, "strBuf has not been extended correctly.");
len = strBufAvailable;
}
int32_t advance =
mozilla::htmlaccel::AccelerateAttributeValueSingleQuotedFastest(
buf + pos, buf + pos + len);
// States that on the non-SIMD path copy characters to strBuf also
// need to do that in the SIMD case.
nsHtml5ArrayCopy::arraycopy(buf, pos, aTokenizer->strBuf,
aTokenizer->strBufLen, advance);
aTokenizer->strBufLen += advance;
return advance;
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static int32_t
accelerateAdvancementAttributeValueDoubleQuoted(nsHtml5Tokenizer* aTokenizer,
char16_t* buf, int32_t pos,
int32_t endPos) {
int32_t len = endPos - pos;
int32_t strBufAvailable = aTokenizer->strBuf.length - aTokenizer->strBufLen;
if (len > strBufAvailable) {
MOZ_DIAGNOSTIC_ASSERT(false, "strBuf has not been extended correctly.");
len = strBufAvailable;
}
int32_t advance =
mozilla::htmlaccel::AccelerateAttributeValueDoubleQuotedFastest(
buf + pos, buf + pos + len);
// States that on the non-SIMD path copy characters to strBuf also
// need to do that in the SIMD case.
nsHtml5ArrayCopy::arraycopy(buf, pos, aTokenizer->strBuf,
aTokenizer->strBufLen, advance);
aTokenizer->strBufLen += advance;
return advance;
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static int32_t accelerateAdvancementCdataSection(
nsHtml5Tokenizer* aTokenizer, char16_t* buf, int32_t pos,
int32_t endPos) {
return mozilla::htmlaccel::AccelerateCdataSectionFastest(buf + pos,
buf + endPos);
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static int32_t accelerateAdvancementPlaintext(
nsHtml5Tokenizer* aTokenizer, char16_t* buf, int32_t pos,
int32_t endPos) {
return mozilla::htmlaccel::AcceleratePlaintextFastest(buf + pos,
buf + endPos);
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static char16_t checkChar(
nsHtml5Tokenizer* aTokenizer, char16_t* buf, int32_t pos) {
return buf[pos];
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static void silentCarriageReturn(
nsHtml5Tokenizer* aTokenizer) {
aTokenizer->lastCR = true;
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static void silentLineFeed(
nsHtml5Tokenizer* aTokenizer) {}
};
/**
* This policy does not report tokenizer transitions anywhere. To be used
* when _not_ viewing source and when not parsing innerHTML (or other
* script execution-preventing fragment).
*/
struct nsHtml5LineColPolicySIMD {
static const bool reportErrors = false;
MOZ_ALWAYS_INLINE_EVEN_DEBUG static int32_t transition(
nsHtml5Highlighter* aHighlighter, int32_t aState, bool aReconsume,
int32_t aPos) {
return aState;
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static void completedNamedCharacterReference(
nsHtml5Highlighter* aHighlighter) {}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static int32_t accelerateAdvancementData(
nsHtml5Tokenizer* aTokenizer, char16_t* buf, int32_t pos,
int32_t endPos) {
// We need to check bounds for the `buf[pos]` access below to be OK.
// Instead of just checking that `pos` isn't equal to `endPos`, let's
// check that have at least one SIMD stride of data in the same branch,
// since if we don't have at least one SIMD stride of data, we don't
// need to proceed.
if (endPos - pos < 16) {
return 0;
}
char16_t c = buf[pos];
if (c == '<' || c == '\n') {
// Quickly handle the case where there is one tag immediately
// after another and the very first thing in the data state is a
// less-than sign and the case where a tag is immediately followed
// by a line feed.
return 0;
}
int32_t advance =
mozilla::htmlaccel::AccelerateDataLineCol(buf + pos, buf + endPos);
if (!advance) {
// When the SIMD advance is zero, don't touch the line and col tracking.
return 0;
}
if (MOZ_UNLIKELY(aTokenizer->nextCharOnNewLine)) {
// By changing the line and column here instead
// of doing so eagerly when seeing the line break
// causes the line break itself to be considered
// column-wise at the end of a line.
aTokenizer->line++;
aTokenizer->col = advance;
aTokenizer->nextCharOnNewLine = false;
} else {
aTokenizer->col += advance;
}
return advance;
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static int32_t accelerateAdvancementRawtext(
nsHtml5Tokenizer* aTokenizer, char16_t* buf, int32_t pos,
int32_t endPos) {
// We need to check bounds for the `buf[pos]` access below to be OK.
// Instead of just checking that `pos` isn't equal to `endPos`, let's
// check that have at least one SIMD stride of data in the same branch,
// since if we don't have at least one SIMD stride of data, we don't
// need to proceed.
if (endPos - pos < 16) {
return 0;
}
char16_t c = buf[pos];
if (c == '<' || c == '\n') {
// Quickly handle the case where there is one tag immediately
// after another and the very first thing in the data is a
// less-than sign and the case where a tag is immediately followed
// by a line feed.
return 0;
}
int32_t advance =
mozilla::htmlaccel::AccelerateRawtextLineCol(buf + pos, buf + endPos);
if (!advance) {
// When the SIMD advance is zero, don't touch the line and col tracking.
return 0;
}
if (MOZ_UNLIKELY(aTokenizer->nextCharOnNewLine)) {
// By changing the line and column here instead
// of doing so eagerly when seeing the line break
// causes the line break itself to be considered
// column-wise at the end of a line.
aTokenizer->line++;
aTokenizer->col = advance;
aTokenizer->nextCharOnNewLine = false;
} else {
aTokenizer->col += advance;
}
return advance;
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static int32_t
accelerateAdvancementScriptDataEscaped(nsHtml5Tokenizer* aTokenizer,
char16_t* buf, int32_t pos,
int32_t endPos) {
// This state shares the SIMD part with the comment state, but this
// wrapper needs to differ!
int32_t advance =
mozilla::htmlaccel::AccelerateCommentLineCol(buf + pos, buf + endPos);
if (!advance) {
// When the SIMD advance is zero, don't touch the line and col tracking.
return 0;
}
if (MOZ_UNLIKELY(aTokenizer->nextCharOnNewLine)) {
// By changing the line and column here instead
// of doing so eagerly when seeing the line break
// causes the line break itself to be considered
// column-wise at the end of a line.
aTokenizer->line++;
aTokenizer->col = advance;
aTokenizer->nextCharOnNewLine = false;
} else {
aTokenizer->col += advance;
}
return advance;
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static int32_t accelerateAdvancementComment(
nsHtml5Tokenizer* aTokenizer, char16_t* buf, int32_t pos,
int32_t endPos) {
int32_t len = endPos - pos;
int32_t strBufAvailable = aTokenizer->strBuf.length - aTokenizer->strBufLen;
if (len > strBufAvailable) {
MOZ_DIAGNOSTIC_ASSERT(false, "strBuf has not been extended correctly.");
len = strBufAvailable;
}
int32_t advance = mozilla::htmlaccel::AccelerateCommentLineCol(
buf + pos, buf + pos + len);
if (!advance) {
// When the SIMD advance is zero, don't touch the line and col tracking.
return 0;
}
if (MOZ_UNLIKELY(aTokenizer->nextCharOnNewLine)) {
// By changing the line and column here instead
// of doing so eagerly when seeing the line break
// causes the line break itself to be considered
// column-wise at the end of a line.
aTokenizer->line++;
aTokenizer->col = advance;
aTokenizer->nextCharOnNewLine = false;
} else {
aTokenizer->col += advance;
}
// States that on the non-SIMD path copy characters to strBuf also
// need to do that in the SIMD case.
nsHtml5ArrayCopy::arraycopy(buf, pos, aTokenizer->strBuf,
aTokenizer->strBufLen, advance);
aTokenizer->strBufLen += advance;
return advance;
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static int32_t
accelerateAdvancementAttributeValueSingleQuoted(nsHtml5Tokenizer* aTokenizer,
char16_t* buf, int32_t pos,
int32_t endPos) {
int32_t len = endPos - pos;
int32_t strBufAvailable = aTokenizer->strBuf.length - aTokenizer->strBufLen;
if (len > strBufAvailable) {
MOZ_DIAGNOSTIC_ASSERT(false, "strBuf has not been extended correctly.");
len = strBufAvailable;
}
int32_t advance =
mozilla::htmlaccel::AccelerateAttributeValueSingleQuotedLineCol(
buf + pos, buf + pos + len);
if (!advance) {
// When the SIMD advance is zero, don't touch the line and col tracking.
return 0;
}
if (MOZ_UNLIKELY(aTokenizer->nextCharOnNewLine)) {
// By changing the line and column here instead
// of doing so eagerly when seeing the line break
// causes the line break itself to be considered
// column-wise at the end of a line.
aTokenizer->line++;
aTokenizer->col = advance;
aTokenizer->nextCharOnNewLine = false;
} else {
aTokenizer->col += advance;
}
// States that on the non-SIMD path copy characters to strBuf also
// need to do that in the SIMD case.
nsHtml5ArrayCopy::arraycopy(buf, pos, aTokenizer->strBuf,
aTokenizer->strBufLen, advance);
aTokenizer->strBufLen += advance;
return advance;
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static int32_t
accelerateAdvancementAttributeValueDoubleQuoted(nsHtml5Tokenizer* aTokenizer,
char16_t* buf, int32_t pos,
int32_t endPos) {
int32_t len = endPos - pos;
int32_t strBufAvailable = aTokenizer->strBuf.length - aTokenizer->strBufLen;
if (len > strBufAvailable) {
MOZ_DIAGNOSTIC_ASSERT(false, "strBuf has not been extended correctly.");
len = strBufAvailable;
}
int32_t advance =
mozilla::htmlaccel::AccelerateAttributeValueDoubleQuotedLineCol(
buf + pos, buf + pos + len);
if (!advance) {
// When the SIMD advance is zero, don't touch the line and col tracking.
return 0;
}
if (MOZ_UNLIKELY(aTokenizer->nextCharOnNewLine)) {
// By changing the line and column here instead
// of doing so eagerly when seeing the line break
// causes the line break itself to be considered
// column-wise at the end of a line.
aTokenizer->line++;
aTokenizer->col = advance;
aTokenizer->nextCharOnNewLine = false;
} else {
aTokenizer->col += advance;
}
// States that on the non-SIMD path copy characters to strBuf also
// need to do that in the SIMD case.
nsHtml5ArrayCopy::arraycopy(buf, pos, aTokenizer->strBuf,
aTokenizer->strBufLen, advance);
aTokenizer->strBufLen += advance;
return advance;
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static int32_t accelerateAdvancementCdataSection(
nsHtml5Tokenizer* aTokenizer, char16_t* buf, int32_t pos,
int32_t endPos) {
int32_t advance = mozilla::htmlaccel::AccelerateCdataSectionLineCol(
buf + pos, buf + endPos);
if (!advance) {
// When the SIMD advance is zero, don't touch the line and col tracking.
return 0;
}
if (MOZ_UNLIKELY(aTokenizer->nextCharOnNewLine)) {
// By changing the line and column here instead
// of doing so eagerly when seeing the line break
// causes the line break itself to be considered
// column-wise at the end of a line.
aTokenizer->line++;
aTokenizer->col = advance;
aTokenizer->nextCharOnNewLine = false;
} else {
aTokenizer->col += advance;
}
return advance;
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static int32_t accelerateAdvancementPlaintext(
nsHtml5Tokenizer* aTokenizer, char16_t* buf, int32_t pos,
int32_t endPos) {
int32_t advance =
mozilla::htmlaccel::AcceleratePlaintextLineCol(buf + pos, buf + endPos);
if (!advance) {
// When the SIMD advance is zero, don't touch the line and col tracking.
return 0;
}
if (MOZ_UNLIKELY(aTokenizer->nextCharOnNewLine)) {
// By changing the line and column here instead
// of doing so eagerly when seeing the line break
// causes the line break itself to be considered
// column-wise at the end of a line.
aTokenizer->line++;
aTokenizer->col = advance;
aTokenizer->nextCharOnNewLine = false;
} else {
aTokenizer->col += advance;
}
return advance;
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static char16_t checkChar(
nsHtml5Tokenizer* aTokenizer, char16_t* buf, int32_t pos) {
// The name of this method comes from the validator.
// We aren't checking a char here. We read the next
// UTF-16 code unit and, before returning it, adjust
// the line and column numbers.
char16_t c = buf[pos];
if (MOZ_UNLIKELY(aTokenizer->nextCharOnNewLine)) {
// By changing the line and column here instead
// of doing so eagerly when seeing the line break
// causes the line break itself to be considered
// column-wise at the end of a line.
aTokenizer->line++;
aTokenizer->col = 1;
aTokenizer->nextCharOnNewLine = false;
} else if (MOZ_LIKELY(!mozilla::IsLowSurrogate(c))) {
// SpiderMonkey wants to count scalar values
// instead of UTF-16 code units. We omit low
// surrogates from the count so that only the
// high surrogate increments the count for
// two-code-unit scalar values.
//
// It's somewhat questionable from the performance
// perspective to make the human-perceivable column
// count correct for non-BMP characters in the case
// where there is a single scalar value per extended
// grapheme cluster when even on the BMP there are
// various cases where the scalar count doesn't make
// much sense as a human-perceived "column count" due
// to extended grapheme clusters consisting of more
// than one scalar value.
aTokenizer->col++;
}
return c;
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static void silentCarriageReturn(
nsHtml5Tokenizer* aTokenizer) {
aTokenizer->nextCharOnNewLine = true;
aTokenizer->lastCR = true;
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static void silentLineFeed(
nsHtml5Tokenizer* aTokenizer) {
aTokenizer->nextCharOnNewLine = true;
}
};
/**
* This policy reports the tokenizer transitions to a highlighter. To be used
* when viewing source.
*/
struct nsHtml5ViewSourcePolicySIMD {
static const bool reportErrors = true;
MOZ_ALWAYS_INLINE_EVEN_DEBUG static int32_t transition(
nsHtml5Highlighter* aHighlighter, int32_t aState, bool aReconsume,
int32_t aPos) {
return aHighlighter->Transition(aState, aReconsume, aPos);
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static void completedNamedCharacterReference(
nsHtml5Highlighter* aHighlighter) {
aHighlighter->CompletedNamedCharacterReference();
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static int32_t accelerateAdvancementData(
nsHtml5Tokenizer* aTokenizer, char16_t* buf, int32_t pos,
int32_t endPos) {
// We need to check bounds for the `buf[pos]` access below to be OK.
// Instead of just checking that `pos` isn't equal to `endPos`, let's
// check that have at least one SIMD stride of data in the same branch,
// since if we don't have at least one SIMD stride of data, we don't
// need to proceed.
if (endPos - pos < 16) {
return 0;
}
char16_t c = buf[pos];
if (c == '<' || c == '\n') {
// Quickly handle the case where there is one tag immediately
// after another and the very first thing in the data state is a
// less-than sign and the case where a tag is immediately followed
// by a line feed.
return 0;
}
return mozilla::htmlaccel::AccelerateDataViewSource(buf + pos,
buf + endPos);
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static int32_t accelerateAdvancementRawtext(
nsHtml5Tokenizer* aTokenizer, char16_t* buf, int32_t pos,
int32_t endPos) {
// We need to check bounds for the `buf[pos]` access below to be OK.
// Instead of just checking that `pos` isn't equal to `endPos`, let's
// check that have at least one SIMD stride of data in the same branch,
// since if we don't have at least one SIMD stride of data, we don't
// need to proceed.
if (endPos - pos < 16) {
return 0;
}
char16_t c = buf[pos];
if (c == '<' || c == '\n') {
// Quickly handle the case where there is one tag immediately
// after another and the very first thing in the state is a
// less-than sign and the case where a tag is immediately followed
// by a line feed.
return 0;
}
return mozilla::htmlaccel::AccelerateRawtextViewSource(buf + pos,
buf + endPos);
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static int32_t
accelerateAdvancementScriptDataEscaped(nsHtml5Tokenizer* aTokenizer,
char16_t* buf, int32_t pos,
int32_t endPos) {
// This state shares the SIMD part with the comment state, but this
// wrapper needs to differ!
return mozilla::htmlaccel::AccelerateCommentViewSource(buf + pos,
buf + endPos);
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static int32_t accelerateAdvancementComment(
nsHtml5Tokenizer* aTokenizer, char16_t* buf, int32_t pos,
int32_t endPos) {
int32_t len = endPos - pos;
int32_t strBufAvailable = aTokenizer->strBuf.length - aTokenizer->strBufLen;
if (len > strBufAvailable) {
MOZ_DIAGNOSTIC_ASSERT(false, "strBuf has not been extended correctly.");
len = strBufAvailable;
}
int32_t advance = mozilla::htmlaccel::AccelerateCommentViewSource(
buf + pos, buf + pos + len);
// States that on the non-SIMD path copy characters to strBuf also
// need to do that in the SIMD case.
nsHtml5ArrayCopy::arraycopy(buf, pos, aTokenizer->strBuf,
aTokenizer->strBufLen, advance);
aTokenizer->strBufLen += advance;
return advance;
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static int32_t
accelerateAdvancementAttributeValueSingleQuoted(nsHtml5Tokenizer* aTokenizer,
char16_t* buf, int32_t pos,
int32_t endPos) {
int32_t len = endPos - pos;
int32_t strBufAvailable = aTokenizer->strBuf.length - aTokenizer->strBufLen;
if (len > strBufAvailable) {
MOZ_DIAGNOSTIC_ASSERT(false, "strBuf has not been extended correctly.");
len = strBufAvailable;
}
int32_t advance =
mozilla::htmlaccel::AccelerateAttributeValueSingleQuotedViewSource(
buf + pos, buf + pos + len);
// States that on the non-SIMD path copy characters to strBuf also
// need to do that in the SIMD case.
nsHtml5ArrayCopy::arraycopy(buf, pos, aTokenizer->strBuf,
aTokenizer->strBufLen, advance);
aTokenizer->strBufLen += advance;
return advance;
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static int32_t
accelerateAdvancementAttributeValueDoubleQuoted(nsHtml5Tokenizer* aTokenizer,
char16_t* buf, int32_t pos,
int32_t endPos) {
int32_t len = endPos - pos;
int32_t strBufAvailable = aTokenizer->strBuf.length - aTokenizer->strBufLen;
if (len > strBufAvailable) {
MOZ_DIAGNOSTIC_ASSERT(false, "strBuf has not been extended correctly.");
len = strBufAvailable;
}
int32_t advance =
mozilla::htmlaccel::AccelerateAttributeValueDoubleQuotedViewSource(
buf + pos, buf + pos + len);
// States that on the non-SIMD path copy characters to strBuf also
// need to do that in the SIMD case.
nsHtml5ArrayCopy::arraycopy(buf, pos, aTokenizer->strBuf,
aTokenizer->strBufLen, advance);
aTokenizer->strBufLen += advance;
return advance;
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static int32_t accelerateAdvancementCdataSection(
nsHtml5Tokenizer* aTokenizer, char16_t* buf, int32_t pos,
int32_t endPos) {
return mozilla::htmlaccel::AccelerateCdataSectionViewSource(buf + pos,
buf + endPos);
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static int32_t accelerateAdvancementPlaintext(
nsHtml5Tokenizer* aTokenizer, char16_t* buf, int32_t pos,
int32_t endPos) {
return mozilla::htmlaccel::AcceleratePlaintextViewSource(buf + pos,
buf + endPos);
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static char16_t checkChar(
nsHtml5Tokenizer* aTokenizer, char16_t* buf, int32_t pos) {
return buf[pos];
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static void silentCarriageReturn(
nsHtml5Tokenizer* aTokenizer) {
aTokenizer->line++;
aTokenizer->lastCR = true;
}
MOZ_ALWAYS_INLINE_EVEN_DEBUG static void silentLineFeed(
nsHtml5Tokenizer* aTokenizer) {
aTokenizer->line++;
}
};
#endif // nsHtml5TokenizerLoopPoliciesSIMD_h
Reference in New Issue View Git Blame Copy Permalink