HTMLParserIdioms.cpp [plain text]
#include "config.h"
#include "HTMLParserIdioms.h"
#include "Decimal.h"
#include "QualifiedName.h"
#include "URL.h"
#include <limits>
#include <wtf/MathExtras.h>
#include <wtf/NeverDestroyed.h>
#include <wtf/dtoa.h>
#include <wtf/text/StringBuilder.h>
namespace WebCore {
template <typename CharType>
static String stripLeadingAndTrailingHTMLSpaces(String string, CharType characters, unsigned length)
{
unsigned numLeadingSpaces = 0;
unsigned numTrailingSpaces = 0;
for (; numLeadingSpaces < length; ++numLeadingSpaces) {
if (isNotHTMLSpace(characters[numLeadingSpaces]))
break;
}
if (numLeadingSpaces == length)
return string.isNull() ? string : emptyAtom.string();
for (; numTrailingSpaces < length; ++numTrailingSpaces) {
if (isNotHTMLSpace(characters[length - numTrailingSpaces - 1]))
break;
}
ASSERT(numLeadingSpaces + numTrailingSpaces < length);
if (!(numLeadingSpaces | numTrailingSpaces))
return string;
return string.substring(numLeadingSpaces, length - (numLeadingSpaces + numTrailingSpaces));
}
String stripLeadingAndTrailingHTMLSpaces(const String& string)
{
unsigned length = string.length();
if (!length)
return string.isNull() ? string : emptyAtom.string();
if (string.is8Bit())
return stripLeadingAndTrailingHTMLSpaces(string, string.characters8(), length);
return stripLeadingAndTrailingHTMLSpaces(string, string.characters16(), length);
}
String serializeForNumberType(const Decimal& number)
{
if (number.isZero()) {
return number.isNegative() ? "-0" : "0";
}
return number.toString();
}
String serializeForNumberType(double number)
{
return String::numberToStringECMAScript(number);
}
Decimal parseToDecimalForNumberType(const String& string, const Decimal& fallbackValue)
{
const UChar firstCharacter = string[0];
if (firstCharacter != '-' && firstCharacter != '.' && !isASCIIDigit(firstCharacter))
return fallbackValue;
const Decimal value = Decimal::fromString(string);
if (!value.isFinite())
return fallbackValue;
const Decimal floatMax = Decimal::fromDouble(std::numeric_limits<float>::max());
if (value < -floatMax || value > floatMax)
return fallbackValue;
return value.isZero() ? Decimal(0) : value;
}
Decimal parseToDecimalForNumberType(const String& string)
{
return parseToDecimalForNumberType(string, Decimal::nan());
}
double parseToDoubleForNumberType(const String& string, double fallbackValue)
{
UChar firstCharacter = string[0];
if (firstCharacter != '-' && firstCharacter != '.' && !isASCIIDigit(firstCharacter))
return fallbackValue;
bool valid = false;
double value = string.toDouble(&valid);
if (!valid)
return fallbackValue;
if (!std::isfinite(value))
return fallbackValue;
if (-std::numeric_limits<float>::max() > value || value > std::numeric_limits<float>::max())
return fallbackValue;
return value ? value : 0;
}
double parseToDoubleForNumberType(const String& string)
{
return parseToDoubleForNumberType(string, std::numeric_limits<double>::quiet_NaN());
}
template <typename CharacterType>
static std::optional<int> parseHTMLIntegerInternal(const CharacterType* position, const CharacterType* end)
{
while (position < end && isHTMLSpace(*position))
++position;
if (position == end)
return std::nullopt;
bool isNegative = false;
if (*position == '-') {
isNegative = true;
++position;
} else if (*position == '+')
++position;
if (position == end || !isASCIIDigit(*position))
return std::nullopt;
constexpr int intMax = std::numeric_limits<int>::max();
constexpr int base = 10;
constexpr int maxMultiplier = intMax / base;
unsigned result = 0;
do {
int digitValue = *position - '0';
if (result > maxMultiplier || (result == maxMultiplier && digitValue > (intMax % base) + isNegative))
return std::nullopt;
result = base * result + digitValue;
++position;
} while (position < end && isASCIIDigit(*position));
return isNegative ? -result : result;
}
std::optional<int> parseHTMLInteger(StringView input)
{
unsigned length = input.length();
if (!length)
return std::nullopt;
if (LIKELY(input.is8Bit())) {
auto* start = input.characters8();
return parseHTMLIntegerInternal(start, start + length);
}
auto* start = input.characters16();
return parseHTMLIntegerInternal(start, start + length);
}
std::optional<unsigned> parseHTMLNonNegativeInteger(StringView input)
{
std::optional<int> signedValue = parseHTMLInteger(input);
if (!signedValue || signedValue.value() < 0)
return std::nullopt;
return static_cast<unsigned>(signedValue.value());
}
template <typename CharacterType>
static std::optional<int> parseValidHTMLNonNegativeIntegerInternal(const CharacterType* position, const CharacterType* end)
{
for (auto* c = position; c < end; ++c) {
if (!isASCIIDigit(*c))
return std::nullopt;
}
std::optional<int> signedValue = parseHTMLIntegerInternal(position, end);
if (!signedValue || signedValue.value() < 0)
return std::nullopt;
return signedValue;
}
std::optional<int> parseValidHTMLNonNegativeInteger(StringView input)
{
if (input.isEmpty())
return std::nullopt;
if (LIKELY(input.is8Bit())) {
auto* start = input.characters8();
return parseValidHTMLNonNegativeIntegerInternal(start, start + input.length());
}
auto* start = input.characters16();
return parseValidHTMLNonNegativeIntegerInternal(start, start + input.length());
}
template <typename CharacterType>
static std::optional<double> parseValidHTMLFloatingPointNumberInternal(const CharacterType* position, size_t length)
{
ASSERT(length > 0);
if (*position == '+' || *(position + length - 1) == '.')
return std::nullopt;
size_t parsedLength = 0;
double number = parseDouble(position, length, parsedLength);
return parsedLength == length && std::isfinite(number) ? number : std::optional<double>();
}
std::optional<double> parseValidHTMLFloatingPointNumber(StringView input)
{
if (input.isEmpty())
return std::nullopt;
if (LIKELY(input.is8Bit())) {
auto* start = input.characters8();
return parseValidHTMLFloatingPointNumberInternal(start, input.length());
}
auto* start = input.characters16();
return parseValidHTMLFloatingPointNumberInternal(start, input.length());
}
static inline bool isHTMLSpaceOrDelimiter(UChar character)
{
return isHTMLSpace(character) || character == ',' || character == ';';
}
static inline bool isNumberStart(UChar character)
{
return isASCIIDigit(character) || character == '.' || character == '-';
}
template <typename CharacterType>
static Vector<double> parseHTMLListOfOfFloatingPointNumberValuesInternal(const CharacterType* position, const CharacterType* end)
{
Vector<double> numbers;
while (position < end && isHTMLSpaceOrDelimiter(*position))
++position;
while (position < end) {
while (position < end && !(isHTMLSpaceOrDelimiter(*position) || isNumberStart(*position)))
++position;
const CharacterType* numberStart = position;
while (position < end && !isHTMLSpaceOrDelimiter(*position))
++position;
size_t parsedLength = 0;
double number = parseDouble(numberStart, position - numberStart, parsedLength);
numbers.append(parsedLength > 0 && std::isfinite(number) ? number : 0);
while (position < end && isHTMLSpaceOrDelimiter(*position))
++position;
}
return numbers;
}
Vector<double> parseHTMLListOfOfFloatingPointNumberValues(StringView input)
{
if (LIKELY(input.is8Bit())) {
auto* start = input.characters8();
return parseHTMLListOfOfFloatingPointNumberValuesInternal(start, start + input.length());
}
auto* start = input.characters16();
return parseHTMLListOfOfFloatingPointNumberValuesInternal(start, start + input.length());
}
static bool threadSafeEqual(const StringImpl& a, const StringImpl& b)
{
if (&a == &b)
return true;
if (a.hash() != b.hash())
return false;
return equal(a, b);
}
bool threadSafeMatch(const QualifiedName& a, const QualifiedName& b)
{
return threadSafeEqual(*a.localName().impl(), *b.localName().impl());
}
String parseCORSSettingsAttribute(const AtomicString& value)
{
if (value.isNull())
return String();
if (equalIgnoringASCIICase(value, "use-credentials"))
return ASCIILiteral("use-credentials");
return ASCIILiteral("anonymous");
}
template <typename CharacterType>
static bool parseHTTPRefreshInternal(const CharacterType* position, const CharacterType* end, double& parsedDelay, String& parsedURL)
{
while (position < end && isHTMLSpace(*position))
++position;
const CharacterType* numberStart = position;
while (position < end && isASCIIDigit(*position))
++position;
std::optional<unsigned> number = parseHTMLNonNegativeInteger(StringView(numberStart, position - numberStart));
if (!number)
return false;
while (position < end && (isASCIIDigit(*position) || *position == '.'))
++position;
if (position == end) {
parsedDelay = number.value();
return true;
}
if (*position != ';' && *position != ',' && !isHTMLSpace(*position))
return false;
parsedDelay = number.value();
while (position < end && isHTMLSpace(*position))
++position;
if (position < end && (*position == ';' || *position == ','))
++position;
while (position < end && isHTMLSpace(*position))
++position;
if (position == end)
return true;
if (*position == 'U' || *position == 'u') {
StringView url(position, end - position);
++position;
if (position < end && (*position == 'R' || *position == 'r'))
++position;
else {
parsedURL = url.toString();
return true;
}
if (position < end && (*position == 'L' || *position == 'l'))
++position;
else {
parsedURL = url.toString();
return true;
}
while (position < end && isHTMLSpace(*position))
++position;
if (position < end && *position == '=')
++position;
else {
parsedURL = url.toString();
return true;
}
while (position < end && isHTMLSpace(*position))
++position;
}
CharacterType quote;
if (position < end && (*position == '\'' || *position == '"')) {
quote = *position;
++position;
} else
quote = '\0';
StringView url(position, end - position);
if (quote != '\0') {
size_t index = url.find(quote);
if (index != notFound)
url = url.substring(0, index);
}
parsedURL = url.toString();
return true;
}
bool parseMetaHTTPEquivRefresh(const StringView& input, double& delay, String& url)
{
if (LIKELY(input.is8Bit())) {
auto* start = input.characters8();
return parseHTTPRefreshInternal(start, start + input.length(), delay, url);
}
auto* start = input.characters16();
return parseHTTPRefreshInternal(start, start + input.length(), delay, url);
}
AtomicString parseHTMLHashNameReference(StringView usemap)
{
size_t numberSignIndex = usemap.find('#');
if (numberSignIndex == notFound)
return nullAtom;
return usemap.substring(numberSignIndex + 1).toAtomicString();
}
}