// port = ":" ( 1*DIGIT / "*" )
//
bool CSPSourceList::parsePort(const UChar* begin, const UChar* end, int& port, bool& portHasWildcard)
{
ASSERT(begin <= end);
ASSERT(!port);
ASSERT(!portHasWildcard);
if (begin == end)
return false;
if (end - begin == 1 && *begin == '*') {
port = 0;
portHasWildcard = true;
return true;
}
const UChar* position = begin;
skipWhile<isASCIIDigit>(position, end);
if (position != end)
return false;
bool ok;
port = charactersToIntStrict(begin, end - begin, &ok);
return ok;
}
// port = ":" ( 1*DIGIT / "*" )
//
bool ContentSecurityPolicySourceList::parsePort(const UChar* begin, const UChar* end, std::optional<uint16_t>& port, bool& portHasWildcard)
{
ASSERT(begin <= end);
ASSERT(!port);
ASSERT(!portHasWildcard);
if (!skipExactly<UChar>(begin, end, ':'))
ASSERT_NOT_REACHED();
if (begin == end)
return false;
if (end - begin == 1 && *begin == '*') {
port = std::nullopt;
portHasWildcard = true;
return true;
}
const UChar* position = begin;
skipWhile<UChar, isASCIIDigit>(position, end);
if (position != end)
return false;
bool ok;
int portInt = charactersToIntStrict(begin, end - begin, &ok);
if (portInt < 0 || portInt > std::numeric_limits<uint16_t>::max())
return false;
port = portInt;
return ok;
}
// port = ":" ( 1*DIGIT / "*" )
//
bool CSPSourceList::parsePort(const UChar* begin, const UChar* end, int& port, CSPSource::WildcardDisposition& portWildcard)
{
ASSERT(begin <= end);
ASSERT(!port);
ASSERT(portWildcard == CSPSource::NoWildcard);
if (!skipExactly<UChar>(begin, end, ':'))
ASSERT_NOT_REACHED();
if (begin == end)
return false;
if (end - begin == 1 && *begin == '*') {
port = 0;
portWildcard = CSPSource::HasWildcard;
return true;
}
const UChar* position = begin;
skipWhile<UChar, isASCIIDigit>(position, end);
if (position != end)
return false;
bool ok;
port = charactersToIntStrict(begin, end - begin, &ok);
return ok;
}
static bool parseHTMLIntegerInternal(const CharacterType* position, const CharacterType* end, int& value)
{
// Step 3
int sign = 1;
// Step 4
while (position < end) {
if (!isHTMLSpace<CharacterType>(*position))
break;
++position;
}
// Step 5
if (position == end)
return false;
ASSERT(position < end);
// Step 6
if (*position == '-') {
sign = -1;
++position;
} else if (*position == '+')
++position;
if (position == end)
return false;
ASSERT(position < end);
// Step 7
if (!isASCIIDigit(*position))
return false;
// Step 8
StringBuilder digits;
while (position < end) {
if (!isASCIIDigit(*position))
break;
digits.append(*position++);
}
// Step 9
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 String::percentage(int& result) const
{
if (!m_impl || !m_impl->length())
return false;
if ((*m_impl)[m_impl->length() - 1] != '%')
return false;
result = charactersToIntStrict(m_impl->characters(), m_impl->length() - 1);
return true;
}
// http://www.whatwg.org/specs/web-apps/current-work/#rules-for-parsing-integers
bool parseHTMLInteger(const String& input, int& value)
{
// Step 1
// Step 2
const UChar* position = input.characters();
const UChar* end = position + input.length();
// Step 3
int sign = 1;
// Step 4
while (position < end) {
if (!isHTMLSpace(*position))
break;
++position;
}
// Step 5
if (position == end)
return false;
ASSERT(position < end);
// Step 6
if (*position == '-') {
sign = -1;
++position;
} else if (*position == '+')
++position;
if (position == end)
return false;
ASSERT(position < end);
// Step 7
if (!isASCIIDigit(*position))
return false;
// Step 8
StringBuilder digits;
while (position < end) {
if (!isASCIIDigit(*position))
break;
digits.append(*position++);
}
// Step 9
bool ok;
value = sign * charactersToIntStrict(digits.characters(), digits.length(), &ok);
return ok;
}
unsigned VTTScanner::scanDigits(int& number)
{
Run runOfDigits = collectWhile<isASCIIDigit>();
if (runOfDigits.isEmpty()) {
number = 0;
return 0;
}
bool validNumber;
size_t numDigits = runOfDigits.length();
if (m_is8Bit)
number = charactersToIntStrict(m_data.characters8, numDigits, &validNumber);
else
number = charactersToIntStrict(m_data.characters16, numDigits, &validNumber);
// Since we know that scanDigits only scanned valid (ASCII) digits (and
// hence that's what got passed to charactersToInt()), the remaining
// failure mode for charactersToInt() is overflow, so if |validNumber| is
// not true, then set |number| to the maximum int value.
if (!validNumber)
number = std::numeric_limits<int>::max();
// Consume the digits.
seekTo(runOfDigits.end());
return numDigits;
}
int toInt(const CharType* attribute, bool& isValid)
{
unsigned position = 0;
// Make sure the integer is a valid non-negative integer
// https://html.spec.whatwg.org/multipage/infrastructure.html#valid-non-negative-integer
unsigned lengthExcludingDescriptor = length - 1;
while (position < lengthExcludingDescriptor) {
if (!isASCIIDigit(*(attribute + start + position))) {
isValid = false;
return 0;
}
++position;
}
return charactersToIntStrict(attribute + start, lengthExcludingDescriptor, &isValid);
}
static Length parseLength(const UChar* data, unsigned length)
{
if (length == 0)
return Length(1, Relative);
unsigned i = 0;
while (i < length && isSpaceOrNewline(data[i]))
++i;
if (i < length && (data[i] == '+' || data[i] == '-'))
++i;
while (i < length && Unicode::isDigit(data[i]))
++i;
bool ok;
int r = charactersToIntStrict(data, i, &ok);
/* Skip over any remaining digits, we are not that accurate (5.5% => 5%) */
while (i < length && (Unicode::isDigit(data[i]) || data[i] == '.'))
++i;
/* IE Quirk: Skip any whitespace (20 % => 20%) */
while (i < length && isSpaceOrNewline(data[i]))
++i;
if (ok) {
if (i < length) {
UChar next = data[i];
if (next == '%')
return Length(static_cast<double>(r), Percent);
if (next == '*')
return Length(r, Relative);
}
return Length(r, Fixed);
} else {
if (i < length) {
UChar next = data[i];
if (next == '*')
return Length(1, Relative);
if (next == '%')
return Length(1, Relative);
}
}
return Length(0, Relative);
}
static Length parseLength(const UChar* data, unsigned length)
{
if (length == 0)
return Length(1, Relative);
unsigned i = 0;
while (i < length && isSpaceOrNewline(data[i]))
++i;
if (i < length && (data[i] == '+' || data[i] == '-'))
++i;
while (i < length && isASCIIDigit(data[i]))
++i;
unsigned intLength = i;
while (i < length && (isASCIIDigit(data[i]) || data[i] == '.'))
++i;
unsigned doubleLength = i;
// IE quirk: Skip whitespace between the number and the % character (20 % => 20%).
while (i < length && isSpaceOrNewline(data[i]))
++i;
bool ok;
UChar next = (i < length) ? data[i] : ' ';
if (next == '%') {
// IE quirk: accept decimal fractions for percentages.
double r = charactersToDouble(data, doubleLength, &ok);
if (ok)
return Length(r, Percent);
return Length(1, Relative);
}
int r = charactersToIntStrict(data, intLength, &ok);
if (next == '*') {
if (ok)
return Length(r, Relative);
return Length(1, Relative);
}
if (ok)
return Length(r, Fixed);
return Length(0, Relative);
}
int toInt(const CharType* attribute, bool& isValid)
{
return charactersToIntStrict(attribute + start, length - 1, &isValid);
}
int StringImpl::toIntStrict(bool* ok, int base)
{
return charactersToIntStrict(m_data, m_length, ok, base);
}