This source file includes following definitions.
- stripLeadingAndTrailingHTMLSpaces
- stripLeadingAndTrailingHTMLSpaces
- serializeForNumberType
- serializeForNumberType
- parseToDecimalForNumberType
- parseToDoubleForNumberType
- parseHTMLIntegerInternal
- parseHTMLInteger
- parseHTMLNonNegativeIntegerInternal
- parseHTMLNonNegativeInteger
- extractCharset
- encodingFromMetaAttributes
- threadSafeEqual
- threadSafeMatch
- threadSafeMatch
- findStringIfStatic
- attemptStaticStringCreation
- attemptStaticStringCreation
#include "config.h"
#include "core/html/parser/HTMLParserIdioms.h"
#include "HTMLNames.h"
#include <limits>
#include "wtf/MathExtras.h"
#include "wtf/text/AtomicString.h"
#include "wtf/text/StringBuilder.h"
#include "wtf/text/StringHash.h"
#include "wtf/text/TextEncoding.h"
namespace WebCore {
using namespace HTMLNames;
template <typename CharType>
static String stripLeadingAndTrailingHTMLSpaces(String string, const CharType* characters, unsigned length)
{
unsigned numLeadingSpaces = 0;
unsigned numTrailingSpaces = 0;
for (; numLeadingSpaces < length; ++numLeadingSpaces) {
if (isNotHTMLSpace<CharType>(characters[numLeadingSpaces]))
break;
}
if (numLeadingSpaces == length)
return string.isNull() ? string : emptyAtom.string();
for (; numTrailingSpaces < length; ++numTrailingSpaces) {
if (isNotHTMLSpace<CharType>(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<LChar>(string, string.characters8(), length);
return stripLeadingAndTrailingHTMLSpaces<UChar>(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 doubleMax = Decimal::fromDouble(std::numeric_limits<double>::max());
if (value < -doubleMax || value > doubleMax)
return fallbackValue;
return value.isZero() ? Decimal(0) : value;
}
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<double>::max() > value || value > std::numeric_limits<double>::max())
return fallbackValue;
return value ? value : 0;
}
template <typename CharacterType>
static bool parseHTMLIntegerInternal(const CharacterType* position, const CharacterType* end, int& value)
{
int sign = 1;
while (position < end) {
if (!isHTMLSpace<CharacterType>(*position))
break;
++position;
}
if (position == end)
return false;
ASSERT(position < end);
if (*position == '-') {
sign = -1;
++position;
} else if (*position == '+')
++position;
if (position == end)
return false;
ASSERT(position < end);
if (!isASCIIDigit(*position))
return false;
StringBuilder digits;
while (position < end) {
if (!isASCIIDigit(*position))
break;
digits.append(*position++);
}
bool ok;
if (digits.is8Bit())
value = sign * charactersToIntStrict(digits.characters8(), digits.length(), &ok);
else
value = sign * charactersToIntStrict(digits.characters16(), digits.length(), &ok);
return ok;
}
bool parseHTMLInteger(const String& input, int& value)
{
unsigned length = input.length();
if (!length || input.is8Bit()) {
const LChar* start = input.characters8();
return parseHTMLIntegerInternal(start, start + length, value);
}
const UChar* start = input.characters16();
return parseHTMLIntegerInternal(start, start + length, value);
}
template <typename CharacterType>
static bool parseHTMLNonNegativeIntegerInternal(const CharacterType* position, const CharacterType* end, unsigned& value)
{
while (position < end) {
if (!isHTMLSpace<CharacterType>(*position))
break;
++position;
}
if (position == end)
return false;
ASSERT(position < end);
if (*position == '+')
++position;
if (position == end)
return false;
ASSERT(position < end);
if (!isASCIIDigit(*position))
return false;
StringBuilder digits;
while (position < end) {
if (!isASCIIDigit(*position))
break;
digits.append(*position++);
}
bool ok;
if (digits.is8Bit())
value = charactersToUIntStrict(digits.characters8(), digits.length(), &ok);
else
value = charactersToUIntStrict(digits.characters16(), digits.length(), &ok);
return ok;
}
bool parseHTMLNonNegativeInteger(const String& input, unsigned& value)
{
unsigned length = input.length();
if (length && input.is8Bit()) {
const LChar* start = input.characters8();
return parseHTMLNonNegativeIntegerInternal(start, start + length, value);
}
const UChar* start = input.characters16();
return parseHTMLNonNegativeIntegerInternal(start, start + length, value);
}
static const char charsetString[] = "charset";
static const size_t charsetLength = sizeof("charset") - 1;
String extractCharset(const String& value)
{
size_t pos = 0;
unsigned length = value.length();
while (pos < length) {
pos = value.find(charsetString, pos, false);
if (pos == kNotFound)
break;
pos += charsetLength;
while (pos < length && value[pos] <= ' ')
++pos;
if (value[pos] != '=')
continue;
++pos;
while (pos < length && value[pos] <= ' ')
++pos;
char quoteMark = 0;
if (pos < length && (value[pos] == '"' || value[pos] == '\'')) {
quoteMark = static_cast<char>(value[pos++]);
ASSERT(!(quoteMark & 0x80));
}
if (pos == length)
break;
unsigned end = pos;
while (end < length && ((quoteMark && value[end] != quoteMark) || (!quoteMark && value[end] > ' ' && value[end] != '"' && value[end] != '\'' && value[end] != ';')))
++end;
if (quoteMark && (end == length))
break;
return value.substring(pos, end - pos);
}
return "";
}
enum Mode {
None,
Charset,
Pragma,
};
WTF::TextEncoding encodingFromMetaAttributes(const HTMLAttributeList& attributes)
{
bool gotPragma = false;
Mode mode = None;
String charset;
for (HTMLAttributeList::const_iterator iter = attributes.begin(); iter != attributes.end(); ++iter) {
const String& attributeName = iter->first;
const String& attributeValue = AtomicString(iter->second);
if (threadSafeMatch(attributeName, http_equivAttr)) {
if (equalIgnoringCase(attributeValue, "content-type"))
gotPragma = true;
} else if (charset.isEmpty()) {
if (threadSafeMatch(attributeName, charsetAttr)) {
charset = attributeValue;
mode = Charset;
} else if (threadSafeMatch(attributeName, contentAttr)) {
charset = extractCharset(attributeValue);
if (charset.length())
mode = Pragma;
}
}
}
if (mode == Charset || (mode == Pragma && gotPragma))
return WTF::TextEncoding(stripLeadingAndTrailingHTMLSpaces(charset));
return WTF::TextEncoding();
}
static bool threadSafeEqual(const StringImpl* a, const StringImpl* b)
{
if (a == b)
return true;
if (a->hash() != b->hash())
return false;
return equalNonNull(a, b);
}
bool threadSafeMatch(const QualifiedName& a, const QualifiedName& b)
{
return threadSafeEqual(a.localName().impl(), b.localName().impl());
}
bool threadSafeMatch(const String& localName, const QualifiedName& qName)
{
return threadSafeEqual(localName.impl(), qName.localName().impl());
}
template<typename CharType>
inline StringImpl* findStringIfStatic(const CharType* characters, unsigned length)
{
if (length > StringImpl::highestStaticStringLength())
return 0;
unsigned hash = StringHasher::computeHashAndMaskTop8Bits(characters, length);
const WTF::StaticStringsTable& table = StringImpl::allStaticStrings();
ASSERT(!table.isEmpty());
WTF::StaticStringsTable::const_iterator it = table.find(hash);
if (it == table.end())
return 0;
if (!equal(it->value, characters, length))
return 0;
return it->value;
}
String attemptStaticStringCreation(const LChar* characters, size_t size)
{
String string(findStringIfStatic(characters, size));
if (string.impl())
return string;
return String(characters, size);
}
String attemptStaticStringCreation(const UChar* characters, size_t size, CharacterWidth width)
{
String string(findStringIfStatic(characters, size));
if (string.impl())
return string;
if (width == Likely8Bit)
string = StringImpl::create8BitIfPossible(characters, size);
else if (width == Force8Bit)
string = String::make8BitFrom16BitSource(characters, size);
else
string = String(characters, size);
return string;
}
}