/*

* 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;

}