/* * Copyright (C) 2008 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. */ /* * UTF-8 and Unicode string manipulation, plus java/lang/String convenience * functions. * * In most cases we populate the fields in the String object directly, * rather than going through an instance field lookup. */ #include "Dalvik.h" #include <stdlib.h> /* * Allocate a new instance of the class String, performing first-use * initialization of the class if necessary. Upon success, the * returned value will have all its fields except hashCode already * filled in, including a reference to a newly-allocated char[] for * the contents, sized as given. Additionally, a reference to the * chars array is stored to the pChars pointer. Callers must * subsequently call dvmReleaseTrackedAlloc() on the result pointer. * This function returns NULL on failure. */ static StringObject* makeStringObject(u4 charsLength, ArrayObject** pChars) { /* * The String class should have already gotten found (but not * necessarily initialized) before making it here. We assert it * explicitly, since historically speaking, we have had bugs with * regard to when the class String gets set up. The assert helps * make any regressions easier to diagnose. */ assert(gDvm.classJavaLangString != NULL); if (!dvmIsClassInitialized(gDvm.classJavaLangString)) { /* Perform first-time use initialization of the class. */ if (!dvmInitClass(gDvm.classJavaLangString)) { LOGE("FATAL: Could not initialize class String"); dvmAbort(); } } Object* result = dvmAllocObject(gDvm.classJavaLangString, ALLOC_DEFAULT); if (result == NULL) { return NULL; } ArrayObject* chars = dvmAllocPrimitiveArray('C', charsLength, ALLOC_DEFAULT); if (chars == NULL) { dvmReleaseTrackedAlloc(result, NULL); return NULL; } dvmSetFieldInt(result, STRING_FIELDOFF_COUNT, charsLength); dvmSetFieldObject(result, STRING_FIELDOFF_VALUE, (Object*) chars); dvmReleaseTrackedAlloc((Object*) chars, NULL); /* Leave offset and hashCode set to zero. */ *pChars = chars; return (StringObject*) result; } /* * Compute a hash code on a UTF-8 string, for use with internal hash tables. * * This may or may not yield the same results as the java/lang/String * computeHashCode() function. (To make sure this doesn't get abused, * I'm initializing the hash code to 1 so they *don't* match up.) * * It would be more correct to invoke dexGetUtf16FromUtf8() here and compute * the hash with the result. That way, if something encoded the same * character in two different ways, the hash value would be the same. For * our purposes that isn't necessary. */ u4 dvmComputeUtf8Hash(const char* utf8Str) { u4 hash = 1; while (*utf8Str != '\0') hash = hash * 31 + *utf8Str++; return hash; } /* * Like "strlen", but for strings encoded with "modified" UTF-8. * * The value returned is the number of characters, which may or may not * be the same as the number of bytes. * * (If this needs optimizing, try: mask against 0xa0, shift right 5, * get increment {1-3} from table of 8 values.) */ size_t dvmUtf8Len(const char* utf8Str) { size_t len = 0; int ic; while ((ic = *utf8Str++) != '\0') { len++; if ((ic & 0x80) != 0) { /* two- or three-byte encoding */ utf8Str++; if ((ic & 0x20) != 0) { /* three-byte encoding */ utf8Str++; } } } return len; } /* * Convert a "modified" UTF-8 string to UTF-16. */ void dvmConvertUtf8ToUtf16(u2* utf16Str, const char* utf8Str) { while (*utf8Str != '\0') *utf16Str++ = dexGetUtf16FromUtf8(&utf8Str); } /* * Given a UTF-16 string, compute the length of the corresponding UTF-8 * string in bytes. */ static int utf16_utf8ByteLen(const u2* utf16Str, int len) { int utf8Len = 0; while (len--) { unsigned int uic = *utf16Str++; /* * The most common case is (uic > 0 && uic <= 0x7f). */ if (uic == 0 || uic > 0x7f) { if (uic > 0x07ff) utf8Len += 3; else /*(uic > 0x7f || uic == 0) */ utf8Len += 2; } else utf8Len++; } return utf8Len; } /* * Convert a UTF-16 string to UTF-8. * * Make sure you allocate "utf8Str" with the result of utf16_utf8ByteLen(), * not just "len". */ static void convertUtf16ToUtf8(char* utf8Str, const u2* utf16Str, int len) { assert(len >= 0); while (len--) { unsigned int uic = *utf16Str++; /* * The most common case is (uic > 0 && uic <= 0x7f). */ if (uic == 0 || uic > 0x7f) { if (uic > 0x07ff) { *utf8Str++ = (uic >> 12) | 0xe0; *utf8Str++ = ((uic >> 6) & 0x3f) | 0x80; *utf8Str++ = (uic & 0x3f) | 0x80; } else /*(uic > 0x7f || uic == 0)*/ { *utf8Str++ = (uic >> 6) | 0xc0; *utf8Str++ = (uic & 0x3f) | 0x80; } } else { *utf8Str++ = uic; } } *utf8Str = '\0'; } /* * Use the java/lang/String.computeHashCode() algorithm. */ static inline u4 computeUtf16Hash(const u2* utf16Str, size_t len) { u4 hash = 0; while (len--) hash = hash * 31 + *utf16Str++; return hash; } u4 dvmComputeStringHash(StringObject* strObj) { int hashCode = dvmGetFieldInt(strObj, STRING_FIELDOFF_HASHCODE); if (hashCode != 0) { return hashCode; } int len = dvmGetFieldInt(strObj, STRING_FIELDOFF_COUNT); int offset = dvmGetFieldInt(strObj, STRING_FIELDOFF_OFFSET); ArrayObject* chars = (ArrayObject*) dvmGetFieldObject(strObj, STRING_FIELDOFF_VALUE); hashCode = computeUtf16Hash((u2*)(void*)chars->contents + offset, len); dvmSetFieldInt(strObj, STRING_FIELDOFF_HASHCODE, hashCode); return hashCode; } StringObject* dvmCreateStringFromCstr(const char* utf8Str) { assert(utf8Str != NULL); return dvmCreateStringFromCstrAndLength(utf8Str, dvmUtf8Len(utf8Str)); } StringObject* dvmCreateStringFromCstr(const std::string& utf8Str) { return dvmCreateStringFromCstr(utf8Str.c_str()); } /* * Create a java/lang/String from a C string, given its UTF-16 length * (number of UTF-16 code points). * * The caller must call dvmReleaseTrackedAlloc() on the return value. * * Returns NULL and throws an exception on failure. */ StringObject* dvmCreateStringFromCstrAndLength(const char* utf8Str, size_t utf16Length) { assert(utf8Str != NULL); ArrayObject* chars; StringObject* newObj = makeStringObject(utf16Length, &chars); if (newObj == NULL) { return NULL; } dvmConvertUtf8ToUtf16((u2*)(void*)chars->contents, utf8Str); u4 hashCode = computeUtf16Hash((u2*)(void*)chars->contents, utf16Length); dvmSetFieldInt((Object*) newObj, STRING_FIELDOFF_HASHCODE, hashCode); return newObj; } /* * Create a new java/lang/String object, using the given Unicode data. */ StringObject* dvmCreateStringFromUnicode(const u2* unichars, int len) { /* We allow a NULL pointer if the length is zero. */ assert(len == 0 || unichars != NULL); ArrayObject* chars; StringObject* newObj = makeStringObject(len, &chars); if (newObj == NULL) { return NULL; } if (len > 0) memcpy(chars->contents, unichars, len * sizeof(u2)); u4 hashCode = computeUtf16Hash((u2*)(void*)chars->contents, len); dvmSetFieldInt((Object*)newObj, STRING_FIELDOFF_HASHCODE, hashCode); return newObj; } /* * Create a new C string from a java/lang/String object. * * Returns NULL if the object is NULL. */ char* dvmCreateCstrFromString(const StringObject* jstr) { assert(gDvm.classJavaLangString != NULL); if (jstr == NULL) { return NULL; } int len = dvmGetFieldInt(jstr, STRING_FIELDOFF_COUNT); int offset = dvmGetFieldInt(jstr, STRING_FIELDOFF_OFFSET); ArrayObject* chars = (ArrayObject*) dvmGetFieldObject(jstr, STRING_FIELDOFF_VALUE); const u2* data = (const u2*)(void*)chars->contents + offset; assert(offset + len <= (int) chars->length); int byteLen = utf16_utf8ByteLen(data, len); char* newStr = (char*) malloc(byteLen+1); if (newStr == NULL) { return NULL; } convertUtf16ToUtf8(newStr, data, len); return newStr; } void dvmGetStringUtfRegion(const StringObject* jstr, int start, int len, char* buf) { const u2* data = jstr->chars() + start; convertUtf16ToUtf8(buf, data, len); } int StringObject::utfLength() const { assert(gDvm.classJavaLangString != NULL); int len = dvmGetFieldInt(this, STRING_FIELDOFF_COUNT); int offset = dvmGetFieldInt(this, STRING_FIELDOFF_OFFSET); ArrayObject* chars = (ArrayObject*) dvmGetFieldObject(this, STRING_FIELDOFF_VALUE); const u2* data = (const u2*)(void*)chars->contents + offset; assert(offset + len <= (int) chars->length); return utf16_utf8ByteLen(data, len); } int StringObject::length() const { return dvmGetFieldInt(this, STRING_FIELDOFF_COUNT); } ArrayObject* StringObject::array() const { return (ArrayObject*) dvmGetFieldObject(this, STRING_FIELDOFF_VALUE); } const u2* StringObject::chars() const { int offset = dvmGetFieldInt(this, STRING_FIELDOFF_OFFSET); ArrayObject* chars = (ArrayObject*) dvmGetFieldObject(this, STRING_FIELDOFF_VALUE); return (const u2*)(void*)chars->contents + offset; } /* * Compare two String objects. * * This is a dvmHashTableLookup() callback. The function has already * compared their hash values; we need to do a full compare to ensure * that the strings really match. */ int dvmHashcmpStrings(const void* vstrObj1, const void* vstrObj2) { const StringObject* strObj1 = (const StringObject*) vstrObj1; const StringObject* strObj2 = (const StringObject*) vstrObj2; assert(gDvm.classJavaLangString != NULL); /* get offset and length into char array; all values are in 16-bit units */ int len1 = dvmGetFieldInt(strObj1, STRING_FIELDOFF_COUNT); int offset1 = dvmGetFieldInt(strObj1, STRING_FIELDOFF_OFFSET); int len2 = dvmGetFieldInt(strObj2, STRING_FIELDOFF_COUNT); int offset2 = dvmGetFieldInt(strObj2, STRING_FIELDOFF_OFFSET); if (len1 != len2) { return len1 - len2; } ArrayObject* chars1 = (ArrayObject*) dvmGetFieldObject(strObj1, STRING_FIELDOFF_VALUE); ArrayObject* chars2 = (ArrayObject*) dvmGetFieldObject(strObj2, STRING_FIELDOFF_VALUE); /* damage here actually indicates a broken java/lang/String */ assert(offset1 + len1 <= (int) chars1->length); assert(offset2 + len2 <= (int) chars2->length); return memcmp((const u2*)(void*)chars1->contents + offset1, (const u2*)(void*)chars2->contents + offset2, len1 * sizeof(u2)); } ArrayObject* dvmCreateStringArray(const std::vector<std::string>& strings) { Thread* self = dvmThreadSelf(); // Allocate an array to hold the String objects. ClassObject* elementClass = dvmFindArrayClassForElement(gDvm.classJavaLangString); ArrayObject* stringArray = dvmAllocArrayByClass(elementClass, strings.size(), ALLOC_DEFAULT); if (stringArray == NULL) { // Probably OOM. assert(dvmCheckException(self)); return NULL; } // Create the individual String objects and add them to the array. for (size_t i = 0; i < strings.size(); i++) { Object* str = (Object*) dvmCreateStringFromCstr(strings[i]); if (str == NULL) { // Probably OOM; drop out now. assert(dvmCheckException(self)); dvmReleaseTrackedAlloc((Object*) stringArray, self); return NULL; } dvmSetObjectArrayElement(stringArray, i, str); /* stored in tracked array, okay to release */ dvmReleaseTrackedAlloc(str, self); } return stringArray; }