static void parseImageCandidatesFromSrcsetAttribute(const String& attribute, Vector<ImageCandidate>& imageCandidates) { if (attribute.isNull()) return; if (attribute.is8Bit()) parseImageCandidatesFromSrcsetAttribute<LChar>(attribute, attribute.characters8(), attribute.length(), imageCandidates); else parseImageCandidatesFromSrcsetAttribute<UChar>(attribute, attribute.characters16(), attribute.length(), imageCandidates); }
VTTScanner::VTTScanner(const String& line) : m_is8Bit(line.is8Bit()) { if (m_is8Bit) { m_data.characters8 = line.characters8(); m_end.characters8 = m_data.characters8 + line.length(); } else { m_data.characters16 = line.characters16(); m_end.characters16 = m_data.characters16 + line.length(); } }
void CSSPreloadScanner::scan(const String& data, PreloadRequestStream& requests) { if (data.is8Bit()) { const LChar* begin = data.characters8(); scanCommon(begin, begin + data.length(), requests); return; } const UChar* begin = data.characters16(); scanCommon(begin, begin + data.length(), requests); }
static void parseKeySplines(const String& string, Vector<UnitBezier>& result) { result.clear(); if (string.isEmpty()) return; if (string.is8Bit()) parseKeySplinesInternal<LChar>(string, result); else parseKeySplinesInternal<UChar>(string, result); }
static inline void addCaseFoldedCharacters(StringHasher& hasher, const String& string) { if (string.isEmpty()) return; if (string.is8Bit()) { hasher.addCharacters<LChar, CaseFoldingHash::foldCase<LChar>>(string.characters8(), string.length()); return; } hasher.addCharacters<UChar, CaseFoldingHash::foldCase<UChar>>(string.characters16(), string.length()); }
static bool parseFontSize(const String& input, int& size) { if (input.isEmpty()) return false; if (input.is8Bit()) return parseFontSize(input.characters8(), input.length(), size); return parseFontSize(input.characters16(), input.length(), size); }
bool RegExp::matchConcurrently(VM& vm, const String& s, unsigned startOffset, MatchResult& result) { ConcurrentJSLocker locker(m_lock); if (!hasMatchOnlyCodeFor(s.is8Bit() ? Yarr::Char8 : Yarr::Char16)) return false; result = match(vm, s, startOffset); return true; }
LinkHeaderSet::LinkHeaderSet(const String& header) { if (header.isNull()) return; if (header.is8Bit()) init(header.characters8(), header.length()); else init(header.characters16(), header.length()); }
bool Color::parseHexColor(const String& name, RGBA32& rgb) { unsigned length = name.length(); if (!length) return false; if (name.is8Bit()) return parseHexColor(name.characters8(), name.length(), rgb); return parseHexColor(name.characters16(), name.length(), rgb); }
Color::Color(const String& name) { if (name[0] == '#') { if (name.is8Bit()) m_valid = parseHexColor(name.characters8() + 1, name.length() - 1, m_color); else m_valid = parseHexColor(name.characters() + 1, name.length() - 1, m_color); } else setNamedColor(name); }
bool protocolIs(const String& url, const char* protocol) { assertProtocolIsGood(protocol); if (url.isNull()) return false; if (url.is8Bit()) return url::FindAndCompareScheme(asURLChar8Subtle(url), url.length(), protocol, 0); return url::FindAndCompareScheme(url.characters16(), url.length(), protocol, 0); }
void KURL::init(const KURL& base, const String& relative, const WTF::TextEncoding* queryEncoding) { if (!relative.isNull() && relative.is8Bit()) { StringUTF8Adaptor relativeUTF8(relative); init(base, relativeUTF8.data(), relativeUTF8.length(), queryEncoding); } else init(base, relative.characters16(), relative.length(), queryEncoding); initProtocolIsInHTTPFamily(); initInnerURL(); }
TextRun constructTextRun(const Font& font, const String& string, const ComputedStyle& style, TextRunFlags flags) { return constructTextRun(font, string, style, string.isEmpty() || string.is8Bit() ? LTR : determineDirectionality(string), flags); }
MatchResult RegExp::match(VM& vm, const String& s, unsigned startOffset) { #if ENABLE(REGEXP_TRACING) m_rtMatchOnlyCallCount++; m_rtMatchOnlyTotalSubjectStringLen += (double)(s.length() - startOffset); #endif ASSERT(m_state != ParseError); compileIfNecessaryMatchOnly(vm, s.is8Bit() ? Yarr::Char8 : Yarr::Char16); #if ENABLE(YARR_JIT) if (m_state == JITCode) { MatchResult result = s.is8Bit() ? m_regExpJITCode.execute(s.characters8(), startOffset, s.length()) : m_regExpJITCode.execute(s.characters16(), startOffset, s.length()); #if ENABLE(REGEXP_TRACING) if (!result) m_rtMatchOnlyFoundCount++; #endif return result; } #endif int offsetVectorSize = (m_numSubpatterns + 1) * 2; int* offsetVector; Vector<int, 32> nonReturnedOvector; nonReturnedOvector.resize(offsetVectorSize); offsetVector = nonReturnedOvector.data(); int r = Yarr::interpret(m_regExpBytecode.get(), s, startOffset, reinterpret_cast<unsigned*>(offsetVector)); #if REGEXP_FUNC_TEST_DATA_GEN RegExpFunctionalTestCollector::get()->outputOneTest(this, s, startOffset, offsetVector, result); #endif if (r >= 0) { #if ENABLE(REGEXP_TRACING) m_rtMatchOnlyFoundCount++; #endif return MatchResult(r, reinterpret_cast<unsigned*>(offsetVector)[1]); } return MatchResult::failed(); }
EncodedJSValue JSC_HOST_CALL regExpProtoGetterSource(ExecState* exec) { JSValue thisValue = exec->thisValue(); if (!thisValue.inherits(RegExpObject::info())) return throwVMTypeError(exec); String pattern = asRegExpObject(thisValue)->regExp()->pattern(); if (pattern.is8Bit()) return JSValue::encode(regExpProtoGetterSourceInternal(exec, pattern, pattern.characters8(), pattern.length())); return JSValue::encode(regExpProtoGetterSourceInternal(exec, pattern, pattern.characters16(), pattern.length())); }
std::unique_ptr<JSONValue> parseJSON(const String& json, int maxDepth) { if (json.isEmpty()) return nullptr; if (maxDepth < 0) maxDepth = 0; if (maxDepth > kMaxStackLimit) maxDepth = kMaxStackLimit; if (json.is8Bit()) return parseJSONInternal(json.characters8(), json.length(), maxDepth); return parseJSONInternal(json.characters16(), json.length(), maxDepth); }
void SpaceSplitString::Data::createVector(const String& string) { unsigned length = string.length(); if (string.is8Bit()) { createVector(string.characters8(), length); return; } createVector(string.characters16(), length); }
bool RegExp::matchConcurrently( VM& vm, const String& s, unsigned startOffset, int& position, Vector<int>& ovector) { ConcurrentJSLocker locker(m_lock); if (!hasCodeFor(s.is8Bit() ? Yarr::Char8 : Yarr::Char16)) return false; position = match(vm, s, startOffset, ovector); return true; }
// "url" from the CSS tokenizer, minus backslash-escape sequences static bool isCSSTokenizerURL(const String& string) { unsigned length = string.length(); if (!length) return true; if (string.is8Bit()) return isCSSTokenizerURL(string.characters8(), length); return isCSSTokenizerURL(string.characters16(), length); }
// "ident" from the CSS tokenizer, minus backslash-escape sequences static bool isCSSTokenizerIdentifier(const String& string) { unsigned length = string.length(); if (!length) return false; if (string.is8Bit()) return isCSSTokenizerIdentifier(string.characters8(), length); return isCSSTokenizerIdentifier(string.characters16(), length); }
static bool resolveRelative(const KURL& base, const String& relative, url_canon::RawCanonOutput<2048>* buffer) { // We use these low-level GURL functions to avoid converting back and forth from UTF-8 unnecessarily. url_parse::Parsed parsed; StringUTF8Adaptor baseUTF8(base.string()); if (relative.is8Bit()) { StringUTF8Adaptor relativeUTF8(relative); return url_util::ResolveRelative(baseUTF8.data(), baseUTF8.length(), base.parsed(), relativeUTF8.data(), relativeUTF8.length(), 0, buffer, &parsed); } return url_util::ResolveRelative(baseUTF8.data(), baseUTF8.length(), base.parsed(), relative.characters16(), relative.length(), 0, buffer, &parsed); }
void MarkupAccumulator::appendCharactersReplacingEntities(StringBuilder& result, const String& source, unsigned offset, unsigned length, EntityMask entityMask) { if (!(offset + length)) return; ASSERT(offset + length <= source.length()); if (source.is8Bit()) appendCharactersReplacingEntitiesInternal<LChar>(result, source, offset, length, entityMask); else appendCharactersReplacingEntitiesInternal<UChar>(result, source, offset, length, entityMask); }
bool SVGViewSpec::parseViewSpec(const String& spec) { if (spec.isEmpty() || !m_contextElement) return false; if (spec.is8Bit()) { const LChar* ptr = spec.characters8(); const LChar* end = ptr + spec.length(); return parseViewSpecInternal(ptr, end); } const UChar* ptr = spec.characters16(); const UChar* end = ptr + spec.length(); return parseViewSpecInternal(ptr, end); }
JSValueRef JSValueMakeFromJSONString(JSContextRef ctx, JSStringRef string) { ExecState* exec = toJS(ctx); APIEntryShim entryShim(exec); String str = string->string(); if (str.is8Bit()) { LiteralParser<LChar> parser(exec, str.characters8(), str.length(), StrictJSON); return toRef(exec, parser.tryLiteralParse()); } LiteralParser<UChar> parser(exec, str.characters16(), str.length(), StrictJSON); return toRef(exec, parser.tryLiteralParse()); }
void SpaceSplitStringData::createVector(const String& string) { unsigned length = string.length(); AppendTokenToVectorTokenProcessor tokenProcessor(m_vector); if (string.is8Bit()) { tokenizeSpaceSplitString(tokenProcessor, string.characters8(), length); return; } tokenizeSpaceSplitString(tokenProcessor, string.characters16(), length); }
static void hashString(MD5& md5, const String& string) { const uint8_t zero = 0; if (string.is8Bit() && string.containsOnlyASCII()) { md5.addBytes(string.characters8(), string.length()); md5.addBytes(&zero, 1); return; } auto cString = string.utf8(); md5.addBytes(reinterpret_cast<const uint8_t*>(cString.data()), cString.length()); md5.addBytes(&zero, 1); }
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); }
unsigned CharacterData::parserAppendData(const String& string, unsigned offset, unsigned lengthLimit) { unsigned oldLength = m_data.length(); ASSERT(lengthLimit >= oldLength); unsigned characterLength = string.length() - offset; unsigned characterLengthLimit = min(characterLength, lengthLimit - oldLength); // Check that we are not on an unbreakable boundary. // Some text break iterator implementations work best if the passed buffer is as small as possible, // see <https://bugs.webkit.org/show_bug.cgi?id=29092>. // We need at least two characters look-ahead to account for UTF-16 surrogates. ASSERT(!string.is8Bit() || string.containsOnlyLatin1()); // Latin-1 doesn't have unbreakable boundaries. if (characterLengthLimit < characterLength && !string.is8Bit()) { NonSharedCharacterBreakIterator it(string.characters16() + offset, (characterLengthLimit + 2 > characterLength) ? characterLength : characterLengthLimit + 2); if (!isTextBreak(it, characterLengthLimit)) characterLengthLimit = textBreakPreceding(it, characterLengthLimit); } if (!characterLengthLimit) return 0; if (string.is8Bit()) m_data.append(string.characters8() + offset, characterLengthLimit); else m_data.append(string.characters16() + offset, characterLengthLimit); ASSERT(!renderer() || isTextNode()); if (isTextNode()) toText(this)->updateTextRenderer(oldLength, 0); document()->incDOMTreeVersion(); // We don't call dispatchModifiedEvent here because we don't want the // parser to dispatch DOM mutation events. if (parentNode()) parentNode()->childrenChanged(); return characterLengthLimit; }
Vector<String> parseDelimitedString(const String& input, const char seperator) { if (input.isEmpty()) return Vector<String>(); if (input.is8Bit()) { const LChar* ptr = input.characters8(); const LChar* end = ptr + input.length(); return genericParseDelimitedString(ptr, end, seperator); } const UChar* ptr = input.characters16(); const UChar* end = ptr + input.length(); return genericParseDelimitedString(ptr, end, seperator); }
// http://www.whatwg.org/specs/web-apps/current-work/#rules-for-parsing-non-negative-integers bool parseHTMLNonNegativeInteger(const String& input, unsigned& value) { // Step 1 // Step 2 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); }