// 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); }