JSValue regExpObjectSource(ExecState* exec, JSValue slotBase, PropertyName)
{
String pattern = asRegExpObject(slotBase)->regExp()->pattern();
if (pattern.is8Bit())
return regExpObjectSourceInternal(exec, pattern, pattern.characters8(), pattern.length());
return regExpObjectSourceInternal(exec, pattern, pattern.characters16(), pattern.length());
}
bool Blob::isNormalizedContentType(const String& contentType)
{
if (contentType.isNull())
return true;
size_t length = contentType.length();
if (contentType.is8Bit()) {
const LChar* characters = contentType.characters8();
for (size_t i = 0; i < length; ++i) {
if (characters[i] < 0x20 || characters[i] > 0x7e)
return false;
if (characters[i] >= 'A' && characters[i] <= 'Z')
return false;
}
} else {
const UChar* characters = contentType.characters16();
for (size_t i = 0; i < length; ++i) {
if (characters[i] < 0x20 || characters[i] > 0x7e)
return false;
if (characters[i] >= 'A' && characters[i] <= 'Z')
return false;
}
}
return true;
}
String SVGFontData::createStringWithMirroredCharacters(const String& string) const
{
if (string.isEmpty())
return emptyString();
unsigned length = string.length();
StringBuilder mirroredCharacters;
mirroredCharacters.reserveCapacity(length);
if (string.is8Bit()) {
const LChar* characters = string.characters8();
for (unsigned i = 0; i < length; ++i)
mirroredCharacters.append(mirroredChar(characters[i]));
} else {
const UChar* characters = string.characters16();
unsigned i = 0;
while (i < length) {
UChar32 character;
U16_NEXT(characters, i, length, character);
mirroredCharacters.append(mirroredChar(character));
}
}
return mirroredCharacters.toString();
}
// Does the same as ToASCIIOrEmpty, but also makes the chars lower.
std::string ToLowerASCIIOrEmpty(const String& str) {
if (str.isEmpty() || !str.containsOnlyASCII())
return std::string();
if (str.is8Bit())
return ToLowerASCIIInternal(str.characters8(), str.length());
return ToLowerASCIIInternal(str.characters16(), str.length());
}
ParsedURL::ParsedURL(const String& urlString, URLQueryCharsetConverter* queryCharsetConverter)
{
unsigned urlStringLength = urlString.length();
if (!urlStringLength)
return;
RawURLBuffer<char> outputBuffer;
String base;
const CString& baseStr = base.utf8();
bool isValid = false;
URLSegments baseSegments;
// FIXME: we should take shortcuts here! We do not have to resolve the relative part.
if (urlString.is8Bit())
isValid = URLUtilities::resolveRelative(baseStr.data(), baseSegments,
reinterpret_cast<const char*>(urlString.characters8()), urlStringLength,
queryCharsetConverter,
outputBuffer, &m_segments);
else
isValid = URLUtilities::resolveRelative(baseStr.data(), baseSegments,
urlString.characters16(), urlStringLength,
queryCharsetConverter,
outputBuffer, &m_segments);
if (isValid)
m_spec = URLString(String(outputBuffer.data(), outputBuffer.length()));
}
static String notAFunctionSourceAppender(const String& originalMessage, const String& sourceText, RuntimeType type, ErrorInstance::SourceTextWhereErrorOccurred occurrence)
{
ASSERT(type != TypeFunction);
if (occurrence == ErrorInstance::FoundApproximateSource)
return defaultApproximateSourceError(originalMessage, sourceText);
ASSERT(occurrence == ErrorInstance::FoundExactSource);
auto notAFunctionIndex = originalMessage.reverseFind("is not a function");
RELEASE_ASSERT(notAFunctionIndex != notFound);
StringView displayValue;
if (originalMessage.is8Bit())
displayValue = StringView(originalMessage.characters8(), notAFunctionIndex - 1);
else
displayValue = StringView(originalMessage.characters16(), notAFunctionIndex - 1);
String base = functionCallBase(sourceText);
StringBuilder builder;
builder.append(base);
builder.appendLiteral(" is not a function. (In '");
builder.append(sourceText);
builder.appendLiteral("', '");
builder.append(base);
builder.appendLiteral("' is ");
if (type == TypeObject)
builder.appendLiteral("an instance of ");
builder.append(displayValue);
builder.appendLiteral(")");
return builder.toString();
}
int nextBreakablePositionIgnoringNBSP(LazyLineBreakIterator& lazyBreakIterator, int pos)
{
String string = lazyBreakIterator.string();
if (string.is8Bit())
return nextBreakablePosition<LChar, false>(lazyBreakIterator, string.characters8(), string.length(), pos);
return nextBreakablePosition<UChar, false>(lazyBreakIterator, string.characters16(), string.length(), pos);
}
ParsedURL::ParsedURL(const String& urlString, ParsedURLStringTag)
{
unsigned urlStringLength = urlString.length();
if (!urlStringLength)
return; // FIXME: we should ASSERT on this, but people use KURL incorrectly with ParsedURLStringTag :(.
RawURLBuffer<char> outputBuffer;
String base;
const CString& baseStr = base.utf8();
bool isValid = false;
URLSegments baseSegments;
// FIXME: we should take shortcuts here! We do not have to resolve the relative part.
if (urlString.is8Bit())
isValid = URLUtilities::resolveRelative(baseStr.data(), baseSegments,
reinterpret_cast<const char*>(urlString.characters8()), urlStringLength,
/* charsetConverter */ 0,
outputBuffer, &m_segments);
else
isValid = URLUtilities::resolveRelative(baseStr.data(), baseSegments,
urlString.characters16(), urlStringLength,
/* charsetConverter */ 0,
outputBuffer, &m_segments);
// FIXME: we should ASSERT on isValid, but people use KURL incorrectly with ParsedURLStringTag :(.
if (isValid)
m_spec = URLString(String(outputBuffer.data(), outputBuffer.length()));
}
SVGParsingError SVGTransformList::setValueAsString(const String& value)
{
if (value.isEmpty()) {
clear();
return SVGParseStatus::NoError;
}
bool valid = false;
if (value.is8Bit()) {
const LChar* ptr = value.characters8();
const LChar* end = ptr + value.length();
valid = parse(ptr, end);
} else {
const UChar* ptr = value.characters16();
const UChar* end = ptr + value.length();
valid = parse(ptr, end);
}
if (!valid) {
clear();
return SVGParseStatus::ParsingFailed;
}
return SVGParseStatus::NoError;
}
static PassRefPtrWillBeRawPtr<CSSValue> parseSimpleLengthValue(CSSPropertyID propertyId, const String& string, CSSParserMode cssParserMode)
{
ASSERT(!string.isEmpty());
bool acceptsNegativeNumbers = false;
// In @viewport, width and height are shorthands, not simple length values.
if (isCSSViewportParsingEnabledForMode(cssParserMode) || !isSimpleLengthPropertyID(propertyId, acceptsNegativeNumbers))
return nullptr;
unsigned length = string.length();
double number;
CSSPrimitiveValue::UnitType unit = CSSPrimitiveValue::CSS_NUMBER;
if (string.is8Bit()) {
if (!parseSimpleLength(string.characters8(), length, unit, number))
return nullptr;
} else {
if (!parseSimpleLength(string.characters16(), length, unit, number))
return nullptr;
}
if (unit == CSSPrimitiveValue::CSS_NUMBER) {
bool quirksMode = isQuirksModeBehavior(cssParserMode);
if (number && !quirksMode)
return nullptr;
unit = CSSPrimitiveValue::CSS_PX;
}
if (number < 0 && !acceptsNegativeNumbers)
return nullptr;
return cssValuePool().createValue(number, unit);
}
SVGParsingError SVGNumberList::setValueAsString(const String& value)
{
if (value.isEmpty()) {
clear();
return NoError;
}
bool valid = false;
if (value.is8Bit()) {
const LChar* ptr = value.characters8();
const LChar* end = ptr + value.length();
valid = parse(ptr, end);
} else {
const UChar* ptr = value.characters16();
const UChar* end = ptr + value.length();
valid = parse(ptr, end);
}
if (!valid) {
// No call to |clear()| here. SVG policy is to use valid items before error.
// Spec: http://www.w3.org/TR/SVG/single-page.html#implnote-ErrorProcessing
return ParsingAttributeFailedError;
}
return NoError;
}
PassRefPtrWillBeRawPtr<CSSValue> CSSParserFastPaths::parseColor(const String& string, bool quirksMode)
{
ASSERT(!string.isEmpty());
CSSParserString cssString;
cssString.init(string);
CSSValueID valueID = cssValueKeywordID(cssString);
if (valueID == CSSValueWebkitText || valueID == CSSValueCurrentcolor || valueID == CSSValueGrey
|| (valueID >= CSSValueAqua && valueID <= CSSValueWindowtext) || valueID == CSSValueMenu
|| (quirksMode && valueID >= CSSValueWebkitFocusRingColor && valueID < CSSValueWebkitText))
return cssValuePool().createIdentifierValue(valueID);
RGBA32 color;
// Fast path for hex colors and rgb()/rgba() colors
bool parseResult;
if (string.is8Bit())
parseResult = fastParseColorInternal(color, string.characters8(), string.length(), quirksMode);
else
parseResult = fastParseColorInternal(color, string.characters16(), string.length(), quirksMode);
if (parseResult)
return cssValuePool().createColorValue(color);
Color namedColor;
if (!namedColor.setNamedColor(string))
return nullptr;
return cssValuePool().createColorValue(namedColor.rgb());
}
void MarkupFormatter::appendCharactersReplacingEntities(StringBuilder& result, const String& source, unsigned offset, unsigned length, EntityMask entityMask)
{
DEFINE_STATIC_LOCAL(const CString, ampReference, ("&"));
DEFINE_STATIC_LOCAL(const CString, ltReference, ("<"));
DEFINE_STATIC_LOCAL(const CString, gtReference, (">"));
DEFINE_STATIC_LOCAL(const CString, quotReference, ("""));
DEFINE_STATIC_LOCAL(const CString, nbspReference, (" "));
DEFINE_STATIC_LOCAL(const CString, tabReference, ("	"));
DEFINE_STATIC_LOCAL(const CString, lineFeedReference, (" "));
DEFINE_STATIC_LOCAL(const CString, carriageReturnReference, (" "));
static const EntityDescription entityMaps[] = {
{ '&', ampReference, EntityAmp },
{ '<', ltReference, EntityLt },
{ '>', gtReference, EntityGt },
{ '"', quotReference, EntityQuot },
{ noBreakSpaceCharacter, nbspReference, EntityNbsp },
{ '\t', tabReference, EntityTab },
{ '\n', lineFeedReference, EntityLineFeed },
{ '\r', carriageReturnReference, EntityCarriageReturn },
};
if (!(offset + length))
return;
DCHECK_LE(offset + length, source.length());
if (source.is8Bit())
appendCharactersReplacingEntitiesInternal(result, source.characters8() + offset, length, entityMaps, WTF_ARRAY_LENGTH(entityMaps), entityMask);
else
appendCharactersReplacingEntitiesInternal(result, source.characters16() + offset, length, entityMaps, WTF_ARRAY_LENGTH(entityMaps), entityMask);
}
void MarkupAccumulator::appendCharactersReplacingEntities(StringBuilder& result, const String& source, unsigned offset, unsigned length, EntityMask entityMask)
{
DEFINE_STATIC_LOCAL(const CString, ampReference, ("&"));
DEFINE_STATIC_LOCAL(const CString, ltReference, ("<"));
DEFINE_STATIC_LOCAL(const CString, gtReference, (">"));
DEFINE_STATIC_LOCAL(const CString, quotReference, ("""));
DEFINE_STATIC_LOCAL(const CString, nbspReference, (" "));
static const EntityDescription entityMaps[] = {
{ '&', ampReference, EntityAmp },
{ '<', ltReference, EntityLt },
{ '>', gtReference, EntityGt },
{ '"', quotReference, EntityQuot },
{ noBreakSpace, nbspReference, EntityNbsp },
};
if (!(offset + length))
return;
ASSERT(offset + length <= source.length());
if (source.is8Bit())
appendCharactersReplacingEntitiesInternal(result, source.characters8() + offset, length, entityMaps, WTF_ARRAY_LENGTH(entityMaps), entityMask);
else
appendCharactersReplacingEntitiesInternal(result, source.characters16() + offset, length, entityMaps, WTF_ARRAY_LENGTH(entityMaps), entityMask);
}
ParsedURL::ParsedURL(const ParsedURL& base, const String& relative, URLQueryCharsetConverter* queryCharsetConverter)
{
if (!base.isValid())
return;
unsigned relativeLength = relative.length();
if (!relativeLength) {
*this = base.withoutFragment();
return;
}
RawURLBuffer<char> outputBuffer;
const CString& baseStr = base.m_spec.m_string.utf8();
bool isValid = false;
if (relative.is8Bit())
isValid = URLUtilities::resolveRelative(baseStr.data(), base.m_segments,
reinterpret_cast<const char*>(relative.characters8()), relativeLength,
queryCharsetConverter,
outputBuffer, &m_segments);
else
isValid = URLUtilities::resolveRelative(baseStr.data(), base.m_segments,
relative.characters16(), relativeLength,
queryCharsetConverter,
outputBuffer, &m_segments);
if (isValid)
m_spec = URLString(String(outputBuffer.data(), outputBuffer.length()));
}
static bool parseDescriptors(const String& attribute, Vector<DescriptorToken>& descriptors, DescriptorParsingResult& result)
{
// FIXME: See if StringView can't be extended to replace DescriptorToken here.
if (attribute.is8Bit()) {
return parseDescriptors(attribute.characters8(), descriptors, result);
}
return parseDescriptors(attribute.characters16(), descriptors, result);
}
static inline void addCaseFoldedCharacters(StringHasher& hasher, const String& string)
{
if (string.isEmpty())
return;
if (string.is8Bit())
return hasher.addCharacters<LChar, CaseFoldingHash::foldCase<LChar>>(string.characters8(), string.length());
return hasher.addCharacters<UChar, CaseFoldingHash::foldCase<UChar>>(string.characters16(), string.length());
}
static inline bool hasNonASCIIOrUpper(const String& string)
{
unsigned length = string.length();
if (string.is8Bit())
return hasNonASCIIOrUpper(string.characters8(), length);
return hasNonASCIIOrUpper(string.characters16(), length);
}
bool Color::setFromString(const String& name)
{
if (name[0] != '#')
return setNamedColor(name);
if (name.is8Bit())
return parseHexColor(name.characters8() + 1, name.length() - 1, m_color);
return parseHexColor(name.characters16() + 1, name.length() - 1, m_color);
}
PassRefPtr<Value> parseJSON(const String& json)
{
if (json.isEmpty())
return nullptr;
if (json.is8Bit())
return parseJSONInternal(json.characters8(), json.length());
return parseJSONInternal(json.characters16(), json.length());
}
bool NetworkCacheKey::stringToHash(const String& string, HashType& hash)
{
if (string.length() != hashStringLength())
return false;
if (string.is8Bit())
return hexDigitsToHash(string.characters8(), hash);
return hexDigitsToHash(string.characters16(), hash);
}
void KURL::setPort(unsigned short i)
{
String portString = String::number(i);
ASSERT(portString.is8Bit());
url_canon::Replacements<char> replacements;
replacements.SetPort(reinterpret_cast<const char*>(portString.characters8()), url_parse::Component(0, portString.length()));
replaceComponents(replacements);
}
std::unique_ptr<protocol::Value> parseJSON(const String& string) {
if (string.isNull())
return nullptr;
if (string.is8Bit())
return parseJSON(reinterpret_cast<const uint8_t*>(string.characters8()),
string.length());
return parseJSON(reinterpret_cast<const uint16_t*>(string.characters16()),
string.length());
}
static bool propertyNameMatchesAttributeName(const String& propertyName, const String& attributeName)
{
if (!attributeName.startsWith("data-"))
return false;
unsigned propertyLength = propertyName.length();
unsigned attributeLength = attributeName.length();
if (propertyName.is8Bit()) {
if (attributeName.is8Bit())
return propertyNameMatchesAttributeName(propertyName.characters8(), attributeName.characters8(), propertyLength, attributeLength);
return propertyNameMatchesAttributeName(propertyName.characters8(), attributeName.characters16(), propertyLength, attributeLength);
}
if (attributeName.is8Bit())
return propertyNameMatchesAttributeName(propertyName.characters16(), attributeName.characters8(), propertyLength, attributeLength);
return propertyNameMatchesAttributeName(propertyName.characters16(), attributeName.characters16(), propertyLength, attributeLength);
}
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);
}
TextRun constructTextRun(RenderObject* context, const Font& font, const String& string, RenderStyle* style, TextDirection direction, TextRun::ExpansionBehavior expansion, TextRunFlags flags)
{
unsigned length = string.length();
if (!length)
return constructTextRunInternal(context, font, static_cast<const LChar*>(0), length, style, direction, expansion, flags);
if (string.is8Bit())
return constructTextRunInternal(context, font, string.characters8(), length, style, direction, expansion, flags);
return constructTextRunInternal(context, font, string.characters16(), length, style, direction, expansion, flags);
}
int nextBreakablePositionIgnoringNBSP(LazyLineBreakIterator& lazyBreakIterator, int pos, EWordBreak wordBreak)
{
String string = lazyBreakIterator.string();
switch (wordBreak) {
case KeepAllWordBreak:
if (string.is8Bit())
return nextBreakablePosition<LChar, false, KeepAll>(lazyBreakIterator, string.characters8(), string.length(), pos);
return nextBreakablePosition<UChar, false, KeepAll>(lazyBreakIterator, string.characters16(), string.length(), pos);
case KeepAllIfKoreanWordBreak:
if (string.is8Bit())
return nextBreakablePosition<LChar, false, KeepAllIfKorean>(lazyBreakIterator, string.characters8(), string.length(), pos);
return nextBreakablePosition<UChar, false, KeepAllIfKorean>(lazyBreakIterator, string.characters16(), string.length(), pos);
default:
if (string.is8Bit())
return nextBreakablePosition<LChar, false, Default>(lazyBreakIterator, string.characters8(), string.length(), pos);
return nextBreakablePosition<UChar, false, Default>(lazyBreakIterator, string.characters16(), string.length(), pos);
}
}
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);
}
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);
}
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);
}
