35a154e57f
Add dumpsys integration for the native input dispatcher. Add some InputDevice API stubs. Add an appendFormat helper method to String8 for printf style string formatting mainly for debugging purposes. Use generic ArrayList<WindowState> everywhere in WindowManagerService to eliminate unnecessary casts all over. Change-Id: I9d1e3bd90eb7222d10620200477f11b7bfd25e44
940 lines
22 KiB
C++
940 lines
22 KiB
C++
/*
|
|
* Copyright (C) 2005 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <utils/String8.h>
|
|
|
|
#include <utils/Log.h>
|
|
#include <utils/String16.h>
|
|
#include <utils/TextOutput.h>
|
|
#include <utils/threads.h>
|
|
|
|
#include <private/utils/Static.h>
|
|
|
|
#include <ctype.h>
|
|
|
|
/*
|
|
* Functions outside android is below the namespace android, since they use
|
|
* functions and constants in android namespace.
|
|
*/
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
namespace android {
|
|
|
|
static const char32_t kByteMask = 0x000000BF;
|
|
static const char32_t kByteMark = 0x00000080;
|
|
|
|
// Surrogates aren't valid for UTF-32 characters, so define some
|
|
// constants that will let us screen them out.
|
|
static const char32_t kUnicodeSurrogateHighStart = 0x0000D800;
|
|
static const char32_t kUnicodeSurrogateHighEnd = 0x0000DBFF;
|
|
static const char32_t kUnicodeSurrogateLowStart = 0x0000DC00;
|
|
static const char32_t kUnicodeSurrogateLowEnd = 0x0000DFFF;
|
|
static const char32_t kUnicodeSurrogateStart = kUnicodeSurrogateHighStart;
|
|
static const char32_t kUnicodeSurrogateEnd = kUnicodeSurrogateLowEnd;
|
|
static const char32_t kUnicodeMaxCodepoint = 0x0010FFFF;
|
|
|
|
// Mask used to set appropriate bits in first byte of UTF-8 sequence,
|
|
// indexed by number of bytes in the sequence.
|
|
// 0xxxxxxx
|
|
// -> (00-7f) 7bit. Bit mask for the first byte is 0x00000000
|
|
// 110yyyyx 10xxxxxx
|
|
// -> (c0-df)(80-bf) 11bit. Bit mask is 0x000000C0
|
|
// 1110yyyy 10yxxxxx 10xxxxxx
|
|
// -> (e0-ef)(80-bf)(80-bf) 16bit. Bit mask is 0x000000E0
|
|
// 11110yyy 10yyxxxx 10xxxxxx 10xxxxxx
|
|
// -> (f0-f7)(80-bf)(80-bf)(80-bf) 21bit. Bit mask is 0x000000F0
|
|
static const char32_t kFirstByteMark[] = {
|
|
0x00000000, 0x00000000, 0x000000C0, 0x000000E0, 0x000000F0
|
|
};
|
|
|
|
// Separator used by resource paths. This is not platform dependent contrary
|
|
// to OS_PATH_SEPARATOR.
|
|
#define RES_PATH_SEPARATOR '/'
|
|
|
|
// Return number of utf8 bytes required for the character.
|
|
static size_t utf32_to_utf8_bytes(char32_t srcChar)
|
|
{
|
|
size_t bytesToWrite;
|
|
|
|
// Figure out how many bytes the result will require.
|
|
if (srcChar < 0x00000080)
|
|
{
|
|
bytesToWrite = 1;
|
|
}
|
|
else if (srcChar < 0x00000800)
|
|
{
|
|
bytesToWrite = 2;
|
|
}
|
|
else if (srcChar < 0x00010000)
|
|
{
|
|
if ((srcChar < kUnicodeSurrogateStart)
|
|
|| (srcChar > kUnicodeSurrogateEnd))
|
|
{
|
|
bytesToWrite = 3;
|
|
}
|
|
else
|
|
{
|
|
// Surrogates are invalid UTF-32 characters.
|
|
return 0;
|
|
}
|
|
}
|
|
// Max code point for Unicode is 0x0010FFFF.
|
|
else if (srcChar <= kUnicodeMaxCodepoint)
|
|
{
|
|
bytesToWrite = 4;
|
|
}
|
|
else
|
|
{
|
|
// Invalid UTF-32 character.
|
|
return 0;
|
|
}
|
|
|
|
return bytesToWrite;
|
|
}
|
|
|
|
// Write out the source character to <dstP>.
|
|
|
|
static void utf32_to_utf8(uint8_t* dstP, char32_t srcChar, size_t bytes)
|
|
{
|
|
dstP += bytes;
|
|
switch (bytes)
|
|
{ /* note: everything falls through. */
|
|
case 4: *--dstP = (uint8_t)((srcChar | kByteMark) & kByteMask); srcChar >>= 6;
|
|
case 3: *--dstP = (uint8_t)((srcChar | kByteMark) & kByteMask); srcChar >>= 6;
|
|
case 2: *--dstP = (uint8_t)((srcChar | kByteMark) & kByteMask); srcChar >>= 6;
|
|
case 1: *--dstP = (uint8_t)(srcChar | kFirstByteMark[bytes]);
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
static SharedBuffer* gEmptyStringBuf = NULL;
|
|
static char* gEmptyString = NULL;
|
|
|
|
extern int gDarwinCantLoadAllObjects;
|
|
int gDarwinIsReallyAnnoying;
|
|
|
|
static inline char* getEmptyString()
|
|
{
|
|
gEmptyStringBuf->acquire();
|
|
return gEmptyString;
|
|
}
|
|
|
|
void initialize_string8()
|
|
{
|
|
// HACK: This dummy dependency forces linking libutils Static.cpp,
|
|
// which is needed to initialize String8/String16 classes.
|
|
// These variables are named for Darwin, but are needed elsewhere too,
|
|
// including static linking on any platform.
|
|
gDarwinIsReallyAnnoying = gDarwinCantLoadAllObjects;
|
|
|
|
SharedBuffer* buf = SharedBuffer::alloc(1);
|
|
char* str = (char*)buf->data();
|
|
*str = 0;
|
|
gEmptyStringBuf = buf;
|
|
gEmptyString = str;
|
|
}
|
|
|
|
void terminate_string8()
|
|
{
|
|
SharedBuffer::bufferFromData(gEmptyString)->release();
|
|
gEmptyStringBuf = NULL;
|
|
gEmptyString = NULL;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
static char* allocFromUTF8(const char* in, size_t len)
|
|
{
|
|
if (len > 0) {
|
|
SharedBuffer* buf = SharedBuffer::alloc(len+1);
|
|
LOG_ASSERT(buf, "Unable to allocate shared buffer");
|
|
if (buf) {
|
|
char* str = (char*)buf->data();
|
|
memcpy(str, in, len);
|
|
str[len] = 0;
|
|
return str;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
return getEmptyString();
|
|
}
|
|
|
|
template<typename T, typename L>
|
|
static char* allocFromUTF16OrUTF32(const T* in, L len)
|
|
{
|
|
if (len == 0) return getEmptyString();
|
|
|
|
size_t bytes = 0;
|
|
const T* end = in+len;
|
|
const T* p = in;
|
|
|
|
while (p < end) {
|
|
bytes += utf32_to_utf8_bytes(*p);
|
|
p++;
|
|
}
|
|
|
|
SharedBuffer* buf = SharedBuffer::alloc(bytes+1);
|
|
LOG_ASSERT(buf, "Unable to allocate shared buffer");
|
|
if (buf) {
|
|
p = in;
|
|
char* str = (char*)buf->data();
|
|
char* d = str;
|
|
while (p < end) {
|
|
const T c = *p++;
|
|
size_t len = utf32_to_utf8_bytes(c);
|
|
utf32_to_utf8((uint8_t*)d, c, len);
|
|
d += len;
|
|
}
|
|
*d = 0;
|
|
|
|
return str;
|
|
}
|
|
|
|
return getEmptyString();
|
|
}
|
|
|
|
static char* allocFromUTF16(const char16_t* in, size_t len)
|
|
{
|
|
if (len == 0) return getEmptyString();
|
|
|
|
const size_t bytes = utf8_length_from_utf16(in, len);
|
|
|
|
SharedBuffer* buf = SharedBuffer::alloc(bytes+1);
|
|
LOG_ASSERT(buf, "Unable to allocate shared buffer");
|
|
if (buf) {
|
|
char* str = (char*)buf->data();
|
|
|
|
utf16_to_utf8(in, len, str, bytes+1);
|
|
|
|
return str;
|
|
}
|
|
|
|
return getEmptyString();
|
|
}
|
|
|
|
static char* allocFromUTF32(const char32_t* in, size_t len)
|
|
{
|
|
return allocFromUTF16OrUTF32<char32_t, size_t>(in, len);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
String8::String8()
|
|
: mString(getEmptyString())
|
|
{
|
|
}
|
|
|
|
String8::String8(const String8& o)
|
|
: mString(o.mString)
|
|
{
|
|
SharedBuffer::bufferFromData(mString)->acquire();
|
|
}
|
|
|
|
String8::String8(const char* o)
|
|
: mString(allocFromUTF8(o, strlen(o)))
|
|
{
|
|
if (mString == NULL) {
|
|
mString = getEmptyString();
|
|
}
|
|
}
|
|
|
|
String8::String8(const char* o, size_t len)
|
|
: mString(allocFromUTF8(o, len))
|
|
{
|
|
if (mString == NULL) {
|
|
mString = getEmptyString();
|
|
}
|
|
}
|
|
|
|
String8::String8(const String16& o)
|
|
: mString(allocFromUTF16(o.string(), o.size()))
|
|
{
|
|
}
|
|
|
|
String8::String8(const char16_t* o)
|
|
: mString(allocFromUTF16(o, strlen16(o)))
|
|
{
|
|
}
|
|
|
|
String8::String8(const char16_t* o, size_t len)
|
|
: mString(allocFromUTF16(o, len))
|
|
{
|
|
}
|
|
|
|
String8::String8(const char32_t* o)
|
|
: mString(allocFromUTF32(o, strlen32(o)))
|
|
{
|
|
}
|
|
|
|
String8::String8(const char32_t* o, size_t len)
|
|
: mString(allocFromUTF32(o, len))
|
|
{
|
|
}
|
|
|
|
String8::~String8()
|
|
{
|
|
SharedBuffer::bufferFromData(mString)->release();
|
|
}
|
|
|
|
void String8::setTo(const String8& other)
|
|
{
|
|
SharedBuffer::bufferFromData(other.mString)->acquire();
|
|
SharedBuffer::bufferFromData(mString)->release();
|
|
mString = other.mString;
|
|
}
|
|
|
|
status_t String8::setTo(const char* other)
|
|
{
|
|
const char *newString = allocFromUTF8(other, strlen(other));
|
|
SharedBuffer::bufferFromData(mString)->release();
|
|
mString = newString;
|
|
if (mString) return NO_ERROR;
|
|
|
|
mString = getEmptyString();
|
|
return NO_MEMORY;
|
|
}
|
|
|
|
status_t String8::setTo(const char* other, size_t len)
|
|
{
|
|
const char *newString = allocFromUTF8(other, len);
|
|
SharedBuffer::bufferFromData(mString)->release();
|
|
mString = newString;
|
|
if (mString) return NO_ERROR;
|
|
|
|
mString = getEmptyString();
|
|
return NO_MEMORY;
|
|
}
|
|
|
|
status_t String8::setTo(const char16_t* other, size_t len)
|
|
{
|
|
const char *newString = allocFromUTF16(other, len);
|
|
SharedBuffer::bufferFromData(mString)->release();
|
|
mString = newString;
|
|
if (mString) return NO_ERROR;
|
|
|
|
mString = getEmptyString();
|
|
return NO_MEMORY;
|
|
}
|
|
|
|
status_t String8::setTo(const char32_t* other, size_t len)
|
|
{
|
|
const char *newString = allocFromUTF32(other, len);
|
|
SharedBuffer::bufferFromData(mString)->release();
|
|
mString = newString;
|
|
if (mString) return NO_ERROR;
|
|
|
|
mString = getEmptyString();
|
|
return NO_MEMORY;
|
|
}
|
|
|
|
status_t String8::append(const String8& other)
|
|
{
|
|
const size_t otherLen = other.bytes();
|
|
if (bytes() == 0) {
|
|
setTo(other);
|
|
return NO_ERROR;
|
|
} else if (otherLen == 0) {
|
|
return NO_ERROR;
|
|
}
|
|
|
|
return real_append(other.string(), otherLen);
|
|
}
|
|
|
|
status_t String8::append(const char* other)
|
|
{
|
|
return append(other, strlen(other));
|
|
}
|
|
|
|
status_t String8::append(const char* other, size_t otherLen)
|
|
{
|
|
if (bytes() == 0) {
|
|
return setTo(other, otherLen);
|
|
} else if (otherLen == 0) {
|
|
return NO_ERROR;
|
|
}
|
|
|
|
return real_append(other, otherLen);
|
|
}
|
|
|
|
status_t String8::appendFormat(const char* fmt, ...)
|
|
{
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
|
|
int result = NO_ERROR;
|
|
int n = vsnprintf(NULL, 0, fmt, ap);
|
|
if (n != 0) {
|
|
size_t oldLength = length();
|
|
char* buf = lockBuffer(oldLength + n);
|
|
if (buf) {
|
|
vsnprintf(buf + oldLength, n + 1, fmt, ap);
|
|
} else {
|
|
result = NO_MEMORY;
|
|
}
|
|
}
|
|
|
|
va_end(ap);
|
|
return result;
|
|
}
|
|
|
|
status_t String8::real_append(const char* other, size_t otherLen)
|
|
{
|
|
const size_t myLen = bytes();
|
|
|
|
SharedBuffer* buf = SharedBuffer::bufferFromData(mString)
|
|
->editResize(myLen+otherLen+1);
|
|
if (buf) {
|
|
char* str = (char*)buf->data();
|
|
mString = str;
|
|
str += myLen;
|
|
memcpy(str, other, otherLen);
|
|
str[otherLen] = '\0';
|
|
return NO_ERROR;
|
|
}
|
|
return NO_MEMORY;
|
|
}
|
|
|
|
char* String8::lockBuffer(size_t size)
|
|
{
|
|
SharedBuffer* buf = SharedBuffer::bufferFromData(mString)
|
|
->editResize(size+1);
|
|
if (buf) {
|
|
char* str = (char*)buf->data();
|
|
mString = str;
|
|
return str;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
void String8::unlockBuffer()
|
|
{
|
|
unlockBuffer(strlen(mString));
|
|
}
|
|
|
|
status_t String8::unlockBuffer(size_t size)
|
|
{
|
|
if (size != this->size()) {
|
|
SharedBuffer* buf = SharedBuffer::bufferFromData(mString)
|
|
->editResize(size+1);
|
|
if (! buf) {
|
|
return NO_MEMORY;
|
|
}
|
|
|
|
char* str = (char*)buf->data();
|
|
str[size] = 0;
|
|
mString = str;
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
ssize_t String8::find(const char* other, size_t start) const
|
|
{
|
|
size_t len = size();
|
|
if (start >= len) {
|
|
return -1;
|
|
}
|
|
const char* s = mString+start;
|
|
const char* p = strstr(s, other);
|
|
return p ? p-mString : -1;
|
|
}
|
|
|
|
void String8::toLower()
|
|
{
|
|
toLower(0, size());
|
|
}
|
|
|
|
void String8::toLower(size_t start, size_t length)
|
|
{
|
|
const size_t len = size();
|
|
if (start >= len) {
|
|
return;
|
|
}
|
|
if (start+length > len) {
|
|
length = len-start;
|
|
}
|
|
char* buf = lockBuffer(len);
|
|
buf += start;
|
|
while (length > 0) {
|
|
*buf = tolower(*buf);
|
|
buf++;
|
|
length--;
|
|
}
|
|
unlockBuffer(len);
|
|
}
|
|
|
|
void String8::toUpper()
|
|
{
|
|
toUpper(0, size());
|
|
}
|
|
|
|
void String8::toUpper(size_t start, size_t length)
|
|
{
|
|
const size_t len = size();
|
|
if (start >= len) {
|
|
return;
|
|
}
|
|
if (start+length > len) {
|
|
length = len-start;
|
|
}
|
|
char* buf = lockBuffer(len);
|
|
buf += start;
|
|
while (length > 0) {
|
|
*buf = toupper(*buf);
|
|
buf++;
|
|
length--;
|
|
}
|
|
unlockBuffer(len);
|
|
}
|
|
|
|
size_t String8::getUtf32Length() const
|
|
{
|
|
return utf32_length(mString, length());
|
|
}
|
|
|
|
int32_t String8::getUtf32At(size_t index, size_t *next_index) const
|
|
{
|
|
return utf32_at(mString, length(), index, next_index);
|
|
}
|
|
|
|
size_t String8::getUtf32(char32_t* dst, size_t dst_len) const
|
|
{
|
|
return utf8_to_utf32(mString, length(), dst, dst_len);
|
|
}
|
|
|
|
TextOutput& operator<<(TextOutput& to, const String8& val)
|
|
{
|
|
to << val.string();
|
|
return to;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Path functions
|
|
|
|
void String8::setPathName(const char* name)
|
|
{
|
|
setPathName(name, strlen(name));
|
|
}
|
|
|
|
void String8::setPathName(const char* name, size_t len)
|
|
{
|
|
char* buf = lockBuffer(len);
|
|
|
|
memcpy(buf, name, len);
|
|
|
|
// remove trailing path separator, if present
|
|
if (len > 0 && buf[len-1] == OS_PATH_SEPARATOR)
|
|
len--;
|
|
|
|
buf[len] = '\0';
|
|
|
|
unlockBuffer(len);
|
|
}
|
|
|
|
String8 String8::getPathLeaf(void) const
|
|
{
|
|
const char* cp;
|
|
const char*const buf = mString;
|
|
|
|
cp = strrchr(buf, OS_PATH_SEPARATOR);
|
|
if (cp == NULL)
|
|
return String8(*this);
|
|
else
|
|
return String8(cp+1);
|
|
}
|
|
|
|
String8 String8::getPathDir(void) const
|
|
{
|
|
const char* cp;
|
|
const char*const str = mString;
|
|
|
|
cp = strrchr(str, OS_PATH_SEPARATOR);
|
|
if (cp == NULL)
|
|
return String8("");
|
|
else
|
|
return String8(str, cp - str);
|
|
}
|
|
|
|
String8 String8::walkPath(String8* outRemains) const
|
|
{
|
|
const char* cp;
|
|
const char*const str = mString;
|
|
const char* buf = str;
|
|
|
|
cp = strchr(buf, OS_PATH_SEPARATOR);
|
|
if (cp == buf) {
|
|
// don't include a leading '/'.
|
|
buf = buf+1;
|
|
cp = strchr(buf, OS_PATH_SEPARATOR);
|
|
}
|
|
|
|
if (cp == NULL) {
|
|
String8 res = buf != str ? String8(buf) : *this;
|
|
if (outRemains) *outRemains = String8("");
|
|
return res;
|
|
}
|
|
|
|
String8 res(buf, cp-buf);
|
|
if (outRemains) *outRemains = String8(cp+1);
|
|
return res;
|
|
}
|
|
|
|
/*
|
|
* Helper function for finding the start of an extension in a pathname.
|
|
*
|
|
* Returns a pointer inside mString, or NULL if no extension was found.
|
|
*/
|
|
char* String8::find_extension(void) const
|
|
{
|
|
const char* lastSlash;
|
|
const char* lastDot;
|
|
int extLen;
|
|
const char* const str = mString;
|
|
|
|
// only look at the filename
|
|
lastSlash = strrchr(str, OS_PATH_SEPARATOR);
|
|
if (lastSlash == NULL)
|
|
lastSlash = str;
|
|
else
|
|
lastSlash++;
|
|
|
|
// find the last dot
|
|
lastDot = strrchr(lastSlash, '.');
|
|
if (lastDot == NULL)
|
|
return NULL;
|
|
|
|
// looks good, ship it
|
|
return const_cast<char*>(lastDot);
|
|
}
|
|
|
|
String8 String8::getPathExtension(void) const
|
|
{
|
|
char* ext;
|
|
|
|
ext = find_extension();
|
|
if (ext != NULL)
|
|
return String8(ext);
|
|
else
|
|
return String8("");
|
|
}
|
|
|
|
String8 String8::getBasePath(void) const
|
|
{
|
|
char* ext;
|
|
const char* const str = mString;
|
|
|
|
ext = find_extension();
|
|
if (ext == NULL)
|
|
return String8(*this);
|
|
else
|
|
return String8(str, ext - str);
|
|
}
|
|
|
|
String8& String8::appendPath(const char* name)
|
|
{
|
|
// TODO: The test below will fail for Win32 paths. Fix later or ignore.
|
|
if (name[0] != OS_PATH_SEPARATOR) {
|
|
if (*name == '\0') {
|
|
// nothing to do
|
|
return *this;
|
|
}
|
|
|
|
size_t len = length();
|
|
if (len == 0) {
|
|
// no existing filename, just use the new one
|
|
setPathName(name);
|
|
return *this;
|
|
}
|
|
|
|
// make room for oldPath + '/' + newPath
|
|
int newlen = strlen(name);
|
|
|
|
char* buf = lockBuffer(len+1+newlen);
|
|
|
|
// insert a '/' if needed
|
|
if (buf[len-1] != OS_PATH_SEPARATOR)
|
|
buf[len++] = OS_PATH_SEPARATOR;
|
|
|
|
memcpy(buf+len, name, newlen+1);
|
|
len += newlen;
|
|
|
|
unlockBuffer(len);
|
|
|
|
return *this;
|
|
} else {
|
|
setPathName(name);
|
|
return *this;
|
|
}
|
|
}
|
|
|
|
String8& String8::convertToResPath()
|
|
{
|
|
#if OS_PATH_SEPARATOR != RES_PATH_SEPARATOR
|
|
size_t len = length();
|
|
if (len > 0) {
|
|
char * buf = lockBuffer(len);
|
|
for (char * end = buf + len; buf < end; ++buf) {
|
|
if (*buf == OS_PATH_SEPARATOR)
|
|
*buf = RES_PATH_SEPARATOR;
|
|
}
|
|
unlockBuffer(len);
|
|
}
|
|
#endif
|
|
return *this;
|
|
}
|
|
|
|
}; // namespace android
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
size_t strlen32(const char32_t *s)
|
|
{
|
|
const char32_t *ss = s;
|
|
while ( *ss )
|
|
ss++;
|
|
return ss-s;
|
|
}
|
|
|
|
size_t strnlen32(const char32_t *s, size_t maxlen)
|
|
{
|
|
const char32_t *ss = s;
|
|
while ((maxlen > 0) && *ss) {
|
|
ss++;
|
|
maxlen--;
|
|
}
|
|
return ss-s;
|
|
}
|
|
|
|
size_t utf8_length(const char *src)
|
|
{
|
|
const char *cur = src;
|
|
size_t ret = 0;
|
|
while (*cur != '\0') {
|
|
const char first_char = *cur++;
|
|
if ((first_char & 0x80) == 0) { // ASCII
|
|
ret += 1;
|
|
continue;
|
|
}
|
|
// (UTF-8's character must not be like 10xxxxxx,
|
|
// but 110xxxxx, 1110xxxx, ... or 1111110x)
|
|
if ((first_char & 0x40) == 0) {
|
|
return 0;
|
|
}
|
|
|
|
int32_t mask, to_ignore_mask;
|
|
size_t num_to_read = 0;
|
|
char32_t utf32 = 0;
|
|
for (num_to_read = 1, mask = 0x40, to_ignore_mask = 0x80;
|
|
num_to_read < 5 && (first_char & mask);
|
|
num_to_read++, to_ignore_mask |= mask, mask >>= 1) {
|
|
if ((*cur & 0xC0) != 0x80) { // must be 10xxxxxx
|
|
return 0;
|
|
}
|
|
// 0x3F == 00111111
|
|
utf32 = (utf32 << 6) + (*cur++ & 0x3F);
|
|
}
|
|
// "first_char" must be (110xxxxx - 11110xxx)
|
|
if (num_to_read == 5) {
|
|
return 0;
|
|
}
|
|
to_ignore_mask |= mask;
|
|
utf32 |= ((~to_ignore_mask) & first_char) << (6 * (num_to_read - 1));
|
|
if (utf32 > android::kUnicodeMaxCodepoint) {
|
|
return 0;
|
|
}
|
|
|
|
ret += num_to_read;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
size_t utf32_length(const char *src, size_t src_len)
|
|
{
|
|
if (src == NULL || src_len == 0) {
|
|
return 0;
|
|
}
|
|
size_t ret = 0;
|
|
const char* cur;
|
|
const char* end;
|
|
size_t num_to_skip;
|
|
for (cur = src, end = src + src_len, num_to_skip = 1;
|
|
cur < end;
|
|
cur += num_to_skip, ret++) {
|
|
const char first_char = *cur;
|
|
num_to_skip = 1;
|
|
if ((first_char & 0x80) == 0) { // ASCII
|
|
continue;
|
|
}
|
|
int32_t mask;
|
|
|
|
for (mask = 0x40; (first_char & mask); num_to_skip++, mask >>= 1) {
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
size_t utf8_length_from_utf32(const char32_t *src, size_t src_len)
|
|
{
|
|
if (src == NULL || src_len == 0) {
|
|
return 0;
|
|
}
|
|
size_t ret = 0;
|
|
const char32_t *end = src + src_len;
|
|
while (src < end) {
|
|
ret += android::utf32_to_utf8_bytes(*src++);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
size_t utf8_length_from_utf16(const char16_t *src, size_t src_len)
|
|
{
|
|
if (src == NULL || src_len == 0) {
|
|
return 0;
|
|
}
|
|
size_t ret = 0;
|
|
const char16_t* const end = src + src_len;
|
|
while (src < end) {
|
|
if ((*src & 0xFC00) == 0xD800 && (src + 1) < end
|
|
&& (*++src & 0xFC00) == 0xDC00) {
|
|
// surrogate pairs are always 4 bytes.
|
|
ret += 4;
|
|
src++;
|
|
} else {
|
|
ret += android::utf32_to_utf8_bytes((char32_t) *src++);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int32_t utf32_at_internal(const char* cur, size_t *num_read)
|
|
{
|
|
const char first_char = *cur;
|
|
if ((first_char & 0x80) == 0) { // ASCII
|
|
*num_read = 1;
|
|
return *cur;
|
|
}
|
|
cur++;
|
|
char32_t mask, to_ignore_mask;
|
|
size_t num_to_read = 0;
|
|
char32_t utf32 = first_char;
|
|
for (num_to_read = 1, mask = 0x40, to_ignore_mask = 0xFFFFFF80;
|
|
(first_char & mask);
|
|
num_to_read++, to_ignore_mask |= mask, mask >>= 1) {
|
|
// 0x3F == 00111111
|
|
utf32 = (utf32 << 6) + (*cur++ & 0x3F);
|
|
}
|
|
to_ignore_mask |= mask;
|
|
utf32 &= ~(to_ignore_mask << (6 * (num_to_read - 1)));
|
|
|
|
*num_read = num_to_read;
|
|
return static_cast<int32_t>(utf32);
|
|
}
|
|
|
|
int32_t utf32_at(const char *src, size_t src_len,
|
|
size_t index, size_t *next_index)
|
|
{
|
|
if (index >= src_len) {
|
|
return -1;
|
|
}
|
|
size_t dummy_index;
|
|
if (next_index == NULL) {
|
|
next_index = &dummy_index;
|
|
}
|
|
size_t num_read;
|
|
int32_t ret = utf32_at_internal(src + index, &num_read);
|
|
if (ret >= 0) {
|
|
*next_index = index + num_read;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
size_t utf8_to_utf32(const char* src, size_t src_len,
|
|
char32_t* dst, size_t dst_len)
|
|
{
|
|
if (src == NULL || src_len == 0 || dst == NULL || dst_len == 0) {
|
|
return 0;
|
|
}
|
|
|
|
const char* cur = src;
|
|
const char* end = src + src_len;
|
|
char32_t* cur_utf32 = dst;
|
|
const char32_t* end_utf32 = dst + dst_len;
|
|
while (cur_utf32 < end_utf32 && cur < end) {
|
|
size_t num_read;
|
|
*cur_utf32++ =
|
|
static_cast<char32_t>(utf32_at_internal(cur, &num_read));
|
|
cur += num_read;
|
|
}
|
|
if (cur_utf32 < end_utf32) {
|
|
*cur_utf32 = 0;
|
|
}
|
|
return static_cast<size_t>(cur_utf32 - dst);
|
|
}
|
|
|
|
size_t utf32_to_utf8(const char32_t* src, size_t src_len,
|
|
char* dst, size_t dst_len)
|
|
{
|
|
if (src == NULL || src_len == 0 || dst == NULL || dst_len == 0) {
|
|
return 0;
|
|
}
|
|
const char32_t *cur_utf32 = src;
|
|
const char32_t *end_utf32 = src + src_len;
|
|
char *cur = dst;
|
|
const char *end = dst + dst_len;
|
|
while (cur_utf32 < end_utf32 && cur < end) {
|
|
size_t len = android::utf32_to_utf8_bytes(*cur_utf32);
|
|
android::utf32_to_utf8((uint8_t *)cur, *cur_utf32++, len);
|
|
cur += len;
|
|
}
|
|
if (cur < end) {
|
|
*cur = '\0';
|
|
}
|
|
return cur - dst;
|
|
}
|
|
|
|
size_t utf16_to_utf8(const char16_t* src, size_t src_len,
|
|
char* dst, size_t dst_len)
|
|
{
|
|
if (src == NULL || src_len == 0 || dst == NULL || dst_len == 0) {
|
|
return 0;
|
|
}
|
|
const char16_t* cur_utf16 = src;
|
|
const char16_t* const end_utf16 = src + src_len;
|
|
char *cur = dst;
|
|
const char* const end = dst + dst_len;
|
|
while (cur_utf16 < end_utf16 && cur < end) {
|
|
char32_t utf32;
|
|
// surrogate pairs
|
|
if ((*cur_utf16 & 0xFC00) == 0xD800 && (cur_utf16 + 1) < end_utf16) {
|
|
utf32 = (*cur_utf16++ - 0xD800) << 10;
|
|
utf32 |= *cur_utf16++ - 0xDC00;
|
|
utf32 += 0x10000;
|
|
} else {
|
|
utf32 = (char32_t) *cur_utf16++;
|
|
}
|
|
size_t len = android::utf32_to_utf8_bytes(utf32);
|
|
android::utf32_to_utf8((uint8_t*)cur, utf32, len);
|
|
cur += len;
|
|
}
|
|
if (cur < end) {
|
|
*cur = '\0';
|
|
}
|
|
return cur - dst;
|
|
}
|