Example #1
0
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());
}
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);
}
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);
}
Example #4
0
LinkHeaderSet::LinkHeaderSet(const String& header)
{
    if (header.isNull())
        return;

    if (header.is8Bit())
        init(header.characters8(), header.length());
    else
        init(header.characters16(), header.length());
}
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();
    }
}
Example #6
0
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();
}
Example #8
0
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);
}
Example #9
0
// "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);
}
Example #10
0
void SpaceSplitString::Data::createVector(const String& string)
{
    unsigned length = string.length();

    if (string.is8Bit()) {
        createVector(string.characters8(), length);
        return;
    }

    createVector(string.characters16(), length);
}
Example #11
0
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()));
}
Example #12
0
// "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);
}
Example #13
0
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.characters16() + 1, name.length() - 1, m_color);
    } else {
        setNamedColor(name);
    }
}
Example #14
0
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());
}
Example #15
0
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);
}
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);
}
Example #17
0
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);
}
Example #18
0
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;
}
Example #19
0
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);
}
Example #20
0
bool parseNumberOptionalNumber(const String& string, float& x, float& y)
{
    if (string.isEmpty())
        return false;
    if (string.is8Bit()) {
        const LChar* ptr = string.characters8();
        const LChar* end = ptr + string.length();
        return genericParseNumberOptionalNumber(ptr, end, x, y);
    }
    const UChar* ptr = string.characters16();
    const UChar* end = ptr + string.length();
    return genericParseNumberOptionalNumber(ptr, end, x, y);
}
Example #21
0
bool parseNumberFromString(const String& string, float& number, bool skip)
{
    if (string.isEmpty())
        return false;
    if (string.is8Bit()) {
        const LChar* ptr = string.characters8();
        const LChar* end = ptr + string.length();
        return genericParseNumber(ptr, end, number, skip) && ptr == end;
    }
    const UChar* ptr = string.characters16();
    const UChar* end = ptr + string.length();
    return genericParseNumber(ptr, end, number, skip) && ptr == end;
}
bool parseRect(const String& string, FloatRect& rect)
{
    if (string.isEmpty())
        return false;
    if (string.is8Bit()) {
        const LChar* ptr = string.characters8();
        const LChar* end = ptr + string.length();
        return genericParseRect(ptr, end, rect);
    }
    const UChar* ptr = string.characters16();
    const UChar* end = ptr + string.length();
    return genericParseRect(ptr, end, rect);
}
// FIXME: Why is the out parameter first?
bool pointsListFromSVGData(SVGPointList& pointsList, const String& points)
{
    if (points.isEmpty())
        return true;
    if (points.is8Bit()) {
        const LChar* ptr = points.characters8();
        const LChar* end = ptr + points.length();
        return genericParsePointsList(pointsList, ptr, end);
    }
    const UChar* ptr = points.characters16();
    const UChar* end = ptr + points.length();
    return genericParsePointsList(pointsList, ptr, end);
}
Example #24
0
void TextRun::setText(const String& string) {
  m_len = string.length();
  if (!m_len) {
    m_data.characters8 = 0;
    m_is8Bit = true;
    return;
  }
  m_is8Bit = string.is8Bit();
  if (m_is8Bit)
    m_data.characters8 = string.characters8();
  else
    m_data.characters16 = string.characters16();
}
Example #25
0
// 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);
}
bool parseNumberOrPercentage(const String& string, float& number)
{
    if (string.isEmpty())
        return false;

    if (string.is8Bit()) {
        const LChar* ptr = string.characters8();
        const LChar* end = ptr + string.length();
        return genericParseNumberOrPercentage(ptr, end, number);
    }
    const UChar* ptr = string.characters16();
    const UChar* end = ptr + string.length();
    return genericParseNumberOrPercentage(ptr, end, number);
}
Example #27
0
ParsedURL::ParsedURL(const String& urlString)
{
    if (urlString.isEmpty()) {
        m_spec = URLString();
        return;
    }

    // FIXME: handle invalid urlString.
    m_spec = URLString(urlString);
    if (urlString.is8Bit())
        URLParser<LChar>::parseStandardURL(urlString.characters8(), urlString.length(), m_segments);
    else
        URLParser<UChar>::parseStandardURL(urlString.characters16(), urlString.length(), m_segments);
}
SVGPathStringSource::SVGPathStringSource(const String& string)
    : m_string(string)
    , m_is8BitSource(string.is8Bit())
{
    ASSERT(!string.isEmpty());

    if (m_is8BitSource) {
        m_current.m_character8 = string.characters8();
        m_end.m_character8 = m_current.m_character8 + string.length();
    } else {
        m_current.m_character16 = string.characters16();
        m_end.m_character16 = m_current.m_character16 + string.length();
    }
}
Example #29
0
bool parseKerningUnicodeString(const String& input, UnicodeRanges& rangeList, HashSet<String>& stringList)
{
    // FIXME: Parsing error detection is missing.
    if (input.isEmpty())
        return true;
    if (input.is8Bit()) {
        const LChar* ptr = input.characters8();
        const LChar* end = ptr + input.length();
        return genericParseKerningUnicodeString(ptr, end, rangeList, stringList);
    }
    const UChar* ptr = input.characters16();
    const UChar* end = ptr + input.length();
    return genericParseKerningUnicodeString(ptr, end, rangeList, stringList);
}
Example #30
0
// Check if there's any unpaird surrogate code point.
// Non-character code points are not checked.
static bool isValidUTF16(const String& s) {
  if (s.is8Bit())
    return true;
  const UChar* ustr = s.characters16();
  size_t length = s.length();
  size_t position = 0;
  while (position < length) {
    UChar32 character;
    U16_NEXT(ustr, position, length, character);
    if (U_IS_SURROGATE(character))
      return false;
  }
  return true;
}