HTMLParserIdioms.cpp [plain text]
#include "config.h"
#include "HTMLParserIdioms.h"
#include "Decimal.h"
#include "HTMLIdentifier.h"
#include "QualifiedName.h"
#include <limits>
#include <wtf/MathExtras.h>
#include <wtf/text/AtomicString.h>
#include <wtf/text/StringBuilder.h>
#include <wtf/text/StringHash.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.characters(), 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 bool parseHTMLIntegerInternal(const CharacterType* position, const CharacterType* end, int& value)
{
int sign = 1;
while (position < end) {
if (!isHTMLSpace(*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.characters();
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(*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.characters();
return parseHTMLNonNegativeIntegerInternal(start, start + length, value);
}
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());
}
#if ENABLE(THREADED_HTML_PARSER)
bool threadSafeMatch(const HTMLIdentifier& localName, const QualifiedName& qName)
{
return threadSafeEqual(localName.asStringImpl(), qName.localName().impl());
}
#endif
}