Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(184)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: third_party/WebKit/Source/wtf/text/UTF8.cpp

Issue 1611343002: wtf reformat test Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: pydent Created 4 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « third_party/WebKit/Source/wtf/text/UTF8.h ('k') | third_party/WebKit/Source/wtf/text/Unicode.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: third_party/WebKit/Source/wtf/text/UTF8.cpp
diff --git a/third_party/WebKit/Source/wtf/text/UTF8.cpp b/third_party/WebKit/Source/wtf/text/UTF8.cpp
index 0beca10497c8e8411d13883305a172c28b264b45..3fd09afd1e2f3bb68065a79261bad2cedf433bc3 100644
--- a/third_party/WebKit/Source/wtf/text/UTF8.cpp
+++ b/third_party/WebKit/Source/wtf/text/UTF8.cpp
@@ -33,22 +33,20 @@
namespace WTF {
namespace Unicode {
-inline int inlineUTF8SequenceLengthNonASCII(char b0)
-{
- if ((b0 & 0xC0) != 0xC0)
- return 0;
- if ((b0 & 0xE0) == 0xC0)
- return 2;
- if ((b0 & 0xF0) == 0xE0)
- return 3;
- if ((b0 & 0xF8) == 0xF0)
- return 4;
+inline int inlineUTF8SequenceLengthNonASCII(char b0) {
+ if ((b0 & 0xC0) != 0xC0)
return 0;
+ if ((b0 & 0xE0) == 0xC0)
+ return 2;
+ if ((b0 & 0xF0) == 0xE0)
+ return 3;
+ if ((b0 & 0xF8) == 0xF0)
+ return 4;
+ return 0;
}
-inline int inlineUTF8SequenceLength(char b0)
-{
- return isASCII(b0) ? 1 : inlineUTF8SequenceLengthNonASCII(b0);
+inline int inlineUTF8SequenceLength(char b0) {
+ return isASCII(b0) ? 1 : inlineUTF8SequenceLengthNonASCII(b0);
}
// Once the bits are split out into bytes of UTF-8, this is a mask OR-ed
@@ -56,391 +54,413 @@ inline int inlineUTF8SequenceLength(char b0)
// as many entries in this table as there are UTF-8 sequence types.
// (I.e., one byte sequence, two byte... etc.). Remember that sequences
// for *legal* UTF-8 will be 4 or fewer bytes total.
-static const unsigned char firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
-
-ConversionResult convertLatin1ToUTF8(
- const LChar** sourceStart, const LChar* sourceEnd,
- char** targetStart, char* targetEnd)
-{
- ConversionResult result = conversionOK;
- const LChar* source = *sourceStart;
- char* target = *targetStart;
- while (source < sourceEnd) {
- UChar32 ch;
- unsigned short bytesToWrite = 0;
- const UChar32 byteMask = 0xBF;
- const UChar32 byteMark = 0x80;
- const LChar* oldSource = source; // In case we have to back up because of target overflow.
- ch = static_cast<unsigned short>(*source++);
-
- // Figure out how many bytes the result will require
- if (ch < (UChar32)0x80)
- bytesToWrite = 1;
- else
- bytesToWrite = 2;
-
- target += bytesToWrite;
- if (target > targetEnd) {
- source = oldSource; // Back up source pointer!
- target -= bytesToWrite;
- result = targetExhausted;
- break;
- }
- switch (bytesToWrite) { // note: everything falls through.
- case 2:
- *--target = (char)((ch | byteMark) & byteMask);
- ch >>= 6;
- case 1:
- *--target = (char)(ch | firstByteMark[bytesToWrite]);
- }
- target += bytesToWrite;
+static const unsigned char firstByteMark[7] = {0x00, 0x00, 0xC0, 0xE0,
+ 0xF0, 0xF8, 0xFC};
+
+ConversionResult convertLatin1ToUTF8(const LChar** sourceStart,
+ const LChar* sourceEnd,
+ char** targetStart,
+ char* targetEnd) {
+ ConversionResult result = conversionOK;
+ const LChar* source = *sourceStart;
+ char* target = *targetStart;
+ while (source < sourceEnd) {
+ UChar32 ch;
+ unsigned short bytesToWrite = 0;
+ const UChar32 byteMask = 0xBF;
+ const UChar32 byteMark = 0x80;
+ const LChar* oldSource =
+ source; // In case we have to back up because of target overflow.
+ ch = static_cast<unsigned short>(*source++);
+
+ // Figure out how many bytes the result will require
+ if (ch < (UChar32)0x80)
+ bytesToWrite = 1;
+ else
+ bytesToWrite = 2;
+
+ target += bytesToWrite;
+ if (target > targetEnd) {
+ source = oldSource; // Back up source pointer!
+ target -= bytesToWrite;
+ result = targetExhausted;
+ break;
+ }
+ switch (bytesToWrite) { // note: everything falls through.
+ case 2:
+ *--target = (char)((ch | byteMark) & byteMask);
+ ch >>= 6;
+ case 1:
+ *--target = (char)(ch | firstByteMark[bytesToWrite]);
}
- *sourceStart = source;
- *targetStart = target;
- return result;
+ target += bytesToWrite;
+ }
+ *sourceStart = source;
+ *targetStart = target;
+ return result;
}
-ConversionResult convertUTF16ToUTF8(
- const UChar** sourceStart, const UChar* sourceEnd,
- char** targetStart, char* targetEnd, bool strict)
-{
- ConversionResult result = conversionOK;
- const UChar* source = *sourceStart;
- char* target = *targetStart;
- while (source < sourceEnd) {
- UChar32 ch;
- unsigned short bytesToWrite = 0;
- const UChar32 byteMask = 0xBF;
- const UChar32 byteMark = 0x80;
- const UChar* oldSource = source; // In case we have to back up because of target overflow.
- ch = static_cast<unsigned short>(*source++);
- // If we have a surrogate pair, convert to UChar32 first.
- if (ch >= 0xD800 && ch <= 0xDBFF) {
- // If the 16 bits following the high surrogate are in the source buffer...
- if (source < sourceEnd) {
- UChar32 ch2 = static_cast<unsigned short>(*source);
- // If it's a low surrogate, convert to UChar32.
- if (ch2 >= 0xDC00 && ch2 <= 0xDFFF) {
- ch = ((ch - 0xD800) << 10) + (ch2 - 0xDC00) + 0x0010000;
- ++source;
- } else if (strict) { // it's an unpaired high surrogate
- --source; // return to the illegal value itself
- result = sourceIllegal;
- break;
- }
- } else { // We don't have the 16 bits following the high surrogate.
- --source; // return to the high surrogate
- result = sourceExhausted;
- break;
- }
- } else if (strict) {
- // UTF-16 surrogate values are illegal in UTF-32
- if (ch >= 0xDC00 && ch <= 0xDFFF) {
- --source; // return to the illegal value itself
- result = sourceIllegal;
- break;
- }
- }
- // Figure out how many bytes the result will require
- if (ch < (UChar32)0x80) {
- bytesToWrite = 1;
- } else if (ch < (UChar32)0x800) {
- bytesToWrite = 2;
- } else if (ch < (UChar32)0x10000) {
- bytesToWrite = 3;
- } else if (ch < (UChar32)0x110000) {
- bytesToWrite = 4;
- } else {
- bytesToWrite = 3;
- ch = replacementCharacter;
+ConversionResult convertUTF16ToUTF8(const UChar** sourceStart,
+ const UChar* sourceEnd,
+ char** targetStart,
+ char* targetEnd,
+ bool strict) {
+ ConversionResult result = conversionOK;
+ const UChar* source = *sourceStart;
+ char* target = *targetStart;
+ while (source < sourceEnd) {
+ UChar32 ch;
+ unsigned short bytesToWrite = 0;
+ const UChar32 byteMask = 0xBF;
+ const UChar32 byteMark = 0x80;
+ const UChar* oldSource =
+ source; // In case we have to back up because of target overflow.
+ ch = static_cast<unsigned short>(*source++);
+ // If we have a surrogate pair, convert to UChar32 first.
+ if (ch >= 0xD800 && ch <= 0xDBFF) {
+ // If the 16 bits following the high surrogate are in the source buffer...
+ if (source < sourceEnd) {
+ UChar32 ch2 = static_cast<unsigned short>(*source);
+ // If it's a low surrogate, convert to UChar32.
+ if (ch2 >= 0xDC00 && ch2 <= 0xDFFF) {
+ ch = ((ch - 0xD800) << 10) + (ch2 - 0xDC00) + 0x0010000;
+ ++source;
+ } else if (strict) { // it's an unpaired high surrogate
+ --source; // return to the illegal value itself
+ result = sourceIllegal;
+ break;
}
+ } else { // We don't have the 16 bits following the high surrogate.
+ --source; // return to the high surrogate
+ result = sourceExhausted;
+ break;
+ }
+ } else if (strict) {
+ // UTF-16 surrogate values are illegal in UTF-32
+ if (ch >= 0xDC00 && ch <= 0xDFFF) {
+ --source; // return to the illegal value itself
+ result = sourceIllegal;
+ break;
+ }
+ }
+ // Figure out how many bytes the result will require
+ if (ch < (UChar32)0x80) {
+ bytesToWrite = 1;
+ } else if (ch < (UChar32)0x800) {
+ bytesToWrite = 2;
+ } else if (ch < (UChar32)0x10000) {
+ bytesToWrite = 3;
+ } else if (ch < (UChar32)0x110000) {
+ bytesToWrite = 4;
+ } else {
+ bytesToWrite = 3;
+ ch = replacementCharacter;
+ }
- target += bytesToWrite;
- if (target > targetEnd) {
- source = oldSource; // Back up source pointer!
- target -= bytesToWrite;
- result = targetExhausted;
- break;
- }
- switch (bytesToWrite) { // note: everything falls through.
- case 4:
- *--target = (char)((ch | byteMark) & byteMask);
- ch >>= 6;
- case 3:
- *--target = (char)((ch | byteMark) & byteMask);
- ch >>= 6;
- case 2:
- *--target = (char)((ch | byteMark) & byteMask);
- ch >>= 6;
- case 1:
- *--target = (char)(ch | firstByteMark[bytesToWrite]);
- }
- target += bytesToWrite;
+ target += bytesToWrite;
+ if (target > targetEnd) {
+ source = oldSource; // Back up source pointer!
+ target -= bytesToWrite;
+ result = targetExhausted;
+ break;
}
- *sourceStart = source;
- *targetStart = target;
- return result;
+ switch (bytesToWrite) { // note: everything falls through.
+ case 4:
+ *--target = (char)((ch | byteMark) & byteMask);
+ ch >>= 6;
+ case 3:
+ *--target = (char)((ch | byteMark) & byteMask);
+ ch >>= 6;
+ case 2:
+ *--target = (char)((ch | byteMark) & byteMask);
+ ch >>= 6;
+ case 1:
+ *--target = (char)(ch | firstByteMark[bytesToWrite]);
+ }
+ target += bytesToWrite;
+ }
+ *sourceStart = source;
+ *targetStart = target;
+ return result;
}
// This must be called with the length pre-determined by the first byte.
// If presented with a length > 4, this returns false. The Unicode
// definition of UTF-8 goes up to 4-byte sequences.
-static bool isLegalUTF8(const unsigned char* source, int length)
-{
- unsigned char a;
- const unsigned char* srcptr = source + length;
- switch (length) {
+static bool isLegalUTF8(const unsigned char* source, int length) {
+ unsigned char a;
+ const unsigned char* srcptr = source + length;
+ switch (length) {
default:
- return false;
+ return false;
// Everything else falls through when "true"...
case 4:
- if ((a = (*--srcptr)) < 0x80 || a > 0xBF)
- return false;
+ if ((a = (*--srcptr)) < 0x80 || a > 0xBF)
+ return false;
case 3:
- if ((a = (*--srcptr)) < 0x80 || a > 0xBF)
- return false;
+ if ((a = (*--srcptr)) < 0x80 || a > 0xBF)
+ return false;
case 2:
- if ((a = (*--srcptr)) > 0xBF)
- return false;
+ if ((a = (*--srcptr)) > 0xBF)
+ return false;
- // no fall-through in this inner switch
- switch (*source) {
+ // no fall-through in this inner switch
+ switch (*source) {
case 0xE0:
- if (a < 0xA0)
- return false;
- break;
+ if (a < 0xA0)
+ return false;
+ break;
case 0xED:
- if (a > 0x9F)
- return false;
- break;
+ if (a > 0x9F)
+ return false;
+ break;
case 0xF0:
- if (a < 0x90)
- return false;
- break;
+ if (a < 0x90)
+ return false;
+ break;
case 0xF4:
- if (a > 0x8F)
- return false;
- break;
+ if (a > 0x8F)
+ return false;
+ break;
default:
- if (a < 0x80)
- return false;
- }
+ if (a < 0x80)
+ return false;
+ }
case 1:
- if (*source >= 0x80 && *source < 0xC2)
- return false;
- }
- if (*source > 0xF4)
+ if (*source >= 0x80 && *source < 0xC2)
return false;
- return true;
+ }
+ if (*source > 0xF4)
+ return false;
+ return true;
}
// Magic values subtracted from a buffer value during UTF8 conversion.
// This table contains as many values as there might be trailing bytes
// in a UTF-8 sequence.
-static const UChar32 offsetsFromUTF8[6] = { 0x00000000UL, 0x00003080UL, 0x000E2080UL, 0x03C82080UL, static_cast<UChar32>(0xFA082080UL), static_cast<UChar32>(0x82082080UL) };
-
-static inline UChar32 readUTF8Sequence(const char*& sequence, unsigned length)
-{
- UChar32 character = 0;
-
- // The cases all fall through.
- switch (length) {
+static const UChar32 offsetsFromUTF8[6] = {0x00000000UL,
+ 0x00003080UL,
+ 0x000E2080UL,
+ 0x03C82080UL,
+ static_cast<UChar32>(0xFA082080UL),
+ static_cast<UChar32>(0x82082080UL)};
+
+static inline UChar32 readUTF8Sequence(const char*& sequence, unsigned length) {
+ UChar32 character = 0;
+
+ // The cases all fall through.
+ switch (length) {
case 6:
- character += static_cast<unsigned char>(*sequence++);
- character <<= 6;
+ character += static_cast<unsigned char>(*sequence++);
+ character <<= 6;
case 5:
- character += static_cast<unsigned char>(*sequence++);
- character <<= 6;
+ character += static_cast<unsigned char>(*sequence++);
+ character <<= 6;
case 4:
- character += static_cast<unsigned char>(*sequence++);
- character <<= 6;
+ character += static_cast<unsigned char>(*sequence++);
+ character <<= 6;
case 3:
- character += static_cast<unsigned char>(*sequence++);
- character <<= 6;
+ character += static_cast<unsigned char>(*sequence++);
+ character <<= 6;
case 2:
- character += static_cast<unsigned char>(*sequence++);
- character <<= 6;
+ character += static_cast<unsigned char>(*sequence++);
+ character <<= 6;
case 1:
- character += static_cast<unsigned char>(*sequence++);
- }
+ character += static_cast<unsigned char>(*sequence++);
+ }
- return character - offsetsFromUTF8[length - 1];
+ return character - offsetsFromUTF8[length - 1];
}
-ConversionResult convertUTF8ToUTF16(
- const char** sourceStart, const char* sourceEnd,
- UChar** targetStart, UChar* targetEnd, bool* sourceAllASCII, bool strict)
-{
- ConversionResult result = conversionOK;
- const char* source = *sourceStart;
- UChar* target = *targetStart;
- UChar orAllData = 0;
- while (source < sourceEnd) {
- int utf8SequenceLength = inlineUTF8SequenceLength(*source);
- if (sourceEnd - source < utf8SequenceLength) {
- result = sourceExhausted;
- break;
- }
- // Do this check whether lenient or strict
- if (!isLegalUTF8(reinterpret_cast<const unsigned char*>(source), utf8SequenceLength)) {
- result = sourceIllegal;
- break;
- }
+ConversionResult convertUTF8ToUTF16(const char** sourceStart,
+ const char* sourceEnd,
+ UChar** targetStart,
+ UChar* targetEnd,
+ bool* sourceAllASCII,
+ bool strict) {
+ ConversionResult result = conversionOK;
+ const char* source = *sourceStart;
+ UChar* target = *targetStart;
+ UChar orAllData = 0;
+ while (source < sourceEnd) {
+ int utf8SequenceLength = inlineUTF8SequenceLength(*source);
+ if (sourceEnd - source < utf8SequenceLength) {
+ result = sourceExhausted;
+ break;
+ }
+ // Do this check whether lenient or strict
+ if (!isLegalUTF8(reinterpret_cast<const unsigned char*>(source),
+ utf8SequenceLength)) {
+ result = sourceIllegal;
+ break;
+ }
- UChar32 character = readUTF8Sequence(source, utf8SequenceLength);
+ UChar32 character = readUTF8Sequence(source, utf8SequenceLength);
- if (target >= targetEnd) {
- source -= utf8SequenceLength; // Back up source pointer!
- result = targetExhausted;
- break;
- }
+ if (target >= targetEnd) {
+ source -= utf8SequenceLength; // Back up source pointer!
+ result = targetExhausted;
+ break;
+ }
- if (U_IS_BMP(character)) {
- // UTF-16 surrogate values are illegal in UTF-32
- if (U_IS_SURROGATE(character)) {
- if (strict) {
- source -= utf8SequenceLength; // return to the illegal value itself
- result = sourceIllegal;
- break;
- }
- *target++ = replacementCharacter;
- orAllData |= replacementCharacter;
- } else {
- *target++ = static_cast<UChar>(character); // normal case
- orAllData |= character;
- }
- } else if (U_IS_SUPPLEMENTARY(character)) {
- // target is a character in range 0xFFFF - 0x10FFFF
- if (target + 1 >= targetEnd) {
- source -= utf8SequenceLength; // Back up source pointer!
- result = targetExhausted;
- break;
- }
- *target++ = U16_LEAD(character);
- *target++ = U16_TRAIL(character);
- orAllData = 0xffff;
- } else {
- if (strict) {
- source -= utf8SequenceLength; // return to the start
- result = sourceIllegal;
- break; // Bail out; shouldn't continue
- } else {
- *target++ = replacementCharacter;
- orAllData |= replacementCharacter;
- }
+ if (U_IS_BMP(character)) {
+ // UTF-16 surrogate values are illegal in UTF-32
+ if (U_IS_SURROGATE(character)) {
+ if (strict) {
+ source -= utf8SequenceLength; // return to the illegal value itself
+ result = sourceIllegal;
+ break;
}
+ *target++ = replacementCharacter;
+ orAllData |= replacementCharacter;
+ } else {
+ *target++ = static_cast<UChar>(character); // normal case
+ orAllData |= character;
+ }
+ } else if (U_IS_SUPPLEMENTARY(character)) {
+ // target is a character in range 0xFFFF - 0x10FFFF
+ if (target + 1 >= targetEnd) {
+ source -= utf8SequenceLength; // Back up source pointer!
+ result = targetExhausted;
+ break;
+ }
+ *target++ = U16_LEAD(character);
+ *target++ = U16_TRAIL(character);
+ orAllData = 0xffff;
+ } else {
+ if (strict) {
+ source -= utf8SequenceLength; // return to the start
+ result = sourceIllegal;
+ break; // Bail out; shouldn't continue
+ } else {
+ *target++ = replacementCharacter;
+ orAllData |= replacementCharacter;
+ }
}
- *sourceStart = source;
- *targetStart = target;
+ }
+ *sourceStart = source;
+ *targetStart = target;
- if (sourceAllASCII)
- *sourceAllASCII = !(orAllData & ~0x7f);
+ if (sourceAllASCII)
+ *sourceAllASCII = !(orAllData & ~0x7f);
- return result;
+ return result;
}
-unsigned calculateStringHashAndLengthFromUTF8MaskingTop8Bits(const char* data, const char* dataEnd, unsigned& dataLength, unsigned& utf16Length)
-{
- if (!data)
- return 0;
+unsigned calculateStringHashAndLengthFromUTF8MaskingTop8Bits(
+ const char* data,
+ const char* dataEnd,
+ unsigned& dataLength,
+ unsigned& utf16Length) {
+ if (!data)
+ return 0;
- StringHasher stringHasher;
- dataLength = 0;
- utf16Length = 0;
+ StringHasher stringHasher;
+ dataLength = 0;
+ utf16Length = 0;
- while (data < dataEnd || (!dataEnd && *data)) {
- if (isASCII(*data)) {
- stringHasher.addCharacter(*data++);
- dataLength++;
- utf16Length++;
- continue;
- }
+ while (data < dataEnd || (!dataEnd && *data)) {
+ if (isASCII(*data)) {
+ stringHasher.addCharacter(*data++);
+ dataLength++;
+ utf16Length++;
+ continue;
+ }
- int utf8SequenceLength = inlineUTF8SequenceLengthNonASCII(*data);
- dataLength += utf8SequenceLength;
+ int utf8SequenceLength = inlineUTF8SequenceLengthNonASCII(*data);
+ dataLength += utf8SequenceLength;
- if (!dataEnd) {
- for (int i = 1; i < utf8SequenceLength; ++i) {
- if (!data[i])
- return 0;
- }
- } else if (dataEnd - data < utf8SequenceLength) {
- return 0;
- }
+ if (!dataEnd) {
+ for (int i = 1; i < utf8SequenceLength; ++i) {
+ if (!data[i])
+ return 0;
+ }
+ } else if (dataEnd - data < utf8SequenceLength) {
+ return 0;
+ }
- if (!isLegalUTF8(reinterpret_cast<const unsigned char*>(data), utf8SequenceLength))
- return 0;
-
- UChar32 character = readUTF8Sequence(data, utf8SequenceLength);
- ASSERT(!isASCII(character));
-
- if (U_IS_BMP(character)) {
- // UTF-16 surrogate values are illegal in UTF-32
- if (U_IS_SURROGATE(character))
- return 0;
- stringHasher.addCharacter(static_cast<UChar>(character)); // normal case
- utf16Length++;
- } else if (U_IS_SUPPLEMENTARY(character)) {
- stringHasher.addCharacters(static_cast<UChar>(U16_LEAD(character)), static_cast<UChar>(U16_TRAIL(character)));
- utf16Length += 2;
- } else {
- return 0;
- }
+ if (!isLegalUTF8(reinterpret_cast<const unsigned char*>(data),
+ utf8SequenceLength))
+ return 0;
+
+ UChar32 character = readUTF8Sequence(data, utf8SequenceLength);
+ ASSERT(!isASCII(character));
+
+ if (U_IS_BMP(character)) {
+ // UTF-16 surrogate values are illegal in UTF-32
+ if (U_IS_SURROGATE(character))
+ return 0;
+ stringHasher.addCharacter(static_cast<UChar>(character)); // normal case
+ utf16Length++;
+ } else if (U_IS_SUPPLEMENTARY(character)) {
+ stringHasher.addCharacters(static_cast<UChar>(U16_LEAD(character)),
+ static_cast<UChar>(U16_TRAIL(character)));
+ utf16Length += 2;
+ } else {
+ return 0;
}
+ }
- return stringHasher.hashWithTop8BitsMasked();
+ return stringHasher.hashWithTop8BitsMasked();
}
-template<typename CharType>
-ALWAYS_INLINE bool equalWithUTF8Internal(const CharType* a, const CharType* aEnd, const char* b, const char* bEnd)
-{
- while (b < bEnd) {
- if (isASCII(*b)) {
- if (*a++ != *b++)
- return false;
- continue;
- }
+template <typename CharType>
+ALWAYS_INLINE bool equalWithUTF8Internal(const CharType* a,
+ const CharType* aEnd,
+ const char* b,
+ const char* bEnd) {
+ while (b < bEnd) {
+ if (isASCII(*b)) {
+ if (*a++ != *b++)
+ return false;
+ continue;
+ }
- int utf8SequenceLength = inlineUTF8SequenceLengthNonASCII(*b);
+ int utf8SequenceLength = inlineUTF8SequenceLengthNonASCII(*b);
- if (bEnd - b < utf8SequenceLength)
- return false;
+ if (bEnd - b < utf8SequenceLength)
+ return false;
- if (!isLegalUTF8(reinterpret_cast<const unsigned char*>(b), utf8SequenceLength))
- return 0;
-
- UChar32 character = readUTF8Sequence(b, utf8SequenceLength);
- ASSERT(!isASCII(character));
-
- if (U_IS_BMP(character)) {
- // UTF-16 surrogate values are illegal in UTF-32
- if (U_IS_SURROGATE(character))
- return false;
- if (*a++ != character)
- return false;
- } else if (U_IS_SUPPLEMENTARY(character)) {
- if (*a++ != U16_LEAD(character))
- return false;
- if (*a++ != U16_TRAIL(character))
- return false;
- } else {
- return false;
- }
+ if (!isLegalUTF8(reinterpret_cast<const unsigned char*>(b),
+ utf8SequenceLength))
+ return 0;
+
+ UChar32 character = readUTF8Sequence(b, utf8SequenceLength);
+ ASSERT(!isASCII(character));
+
+ if (U_IS_BMP(character)) {
+ // UTF-16 surrogate values are illegal in UTF-32
+ if (U_IS_SURROGATE(character))
+ return false;
+ if (*a++ != character)
+ return false;
+ } else if (U_IS_SUPPLEMENTARY(character)) {
+ if (*a++ != U16_LEAD(character))
+ return false;
+ if (*a++ != U16_TRAIL(character))
+ return false;
+ } else {
+ return false;
}
+ }
- return a == aEnd;
+ return a == aEnd;
}
-bool equalUTF16WithUTF8(const UChar* a, const UChar* aEnd, const char* b, const char* bEnd)
-{
- return equalWithUTF8Internal(a, aEnd, b, bEnd);
+bool equalUTF16WithUTF8(const UChar* a,
+ const UChar* aEnd,
+ const char* b,
+ const char* bEnd) {
+ return equalWithUTF8Internal(a, aEnd, b, bEnd);
}
-bool equalLatin1WithUTF8(const LChar* a, const LChar* aEnd, const char* b, const char* bEnd)
-{
- return equalWithUTF8Internal(a, aEnd, b, bEnd);
+bool equalLatin1WithUTF8(const LChar* a,
+ const LChar* aEnd,
+ const char* b,
+ const char* bEnd) {
+ return equalWithUTF8Internal(a, aEnd, b, bEnd);
}
-} // namespace Unicode
-} // namespace WTF
+} // namespace Unicode
+} // namespace WTF
« no previous file with comments | « third_party/WebKit/Source/wtf/text/UTF8.h ('k') | third_party/WebKit/Source/wtf/text/Unicode.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698