2 * Copyright (C) 2008 The Android Open Source Project
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
18 * UTF-8 and Unicode string manipulation, plus java/lang/String convenience
21 * In most cases we populate the fields in the String object directly,
22 * rather than going through an instance field lookup.
28 * Initialize string globals.
30 * This isn't part of the VM init sequence because it's hard to get the
31 * timing right -- we need it to happen after java/lang/String has been
32 * loaded, but before anybody wants to use a string. It's easiest to
33 * just initialize it on first use.
35 * In some unusual circumstances (e.g. trying to throw an exception because
36 * String implements java/lang/CharSequence, but CharSequence doesn't exist)
37 * we can try to create an exception string internally before anything has
38 * really tried to use String. In that case we basically self-destruct.
40 * We're expecting to be essentially single-threaded at this point.
41 * We employ atomics to ensure everything is observed correctly, and also
42 * to guarantee that we do detect a problem if our assumption is wrong.
44 static bool stringStartup()
46 if (gDvm.javaLangStringReady < 0) {
47 LOGE("ERROR: reentrant string initialization\n");
52 if (android_atomic_acquire_cas(0, -1, &gDvm.javaLangStringReady) != 0) {
53 LOGE("ERROR: initial string-ready state not 0 (%d)\n",
54 gDvm.javaLangStringReady);
58 if (gDvm.classJavaLangString == NULL)
59 gDvm.classJavaLangString =
60 dvmFindSystemClassNoInit("Ljava/lang/String;");
62 gDvm.offJavaLangString_value =
63 dvmFindFieldOffset(gDvm.classJavaLangString, "value", "[C");
64 gDvm.offJavaLangString_count =
65 dvmFindFieldOffset(gDvm.classJavaLangString, "count", "I");
66 gDvm.offJavaLangString_offset =
67 dvmFindFieldOffset(gDvm.classJavaLangString, "offset", "I");
68 gDvm.offJavaLangString_hashCode =
69 dvmFindFieldOffset(gDvm.classJavaLangString, "hashCode", "I");
71 if (gDvm.offJavaLangString_value < 0 ||
72 gDvm.offJavaLangString_count < 0 ||
73 gDvm.offJavaLangString_offset < 0 ||
74 gDvm.offJavaLangString_hashCode < 0)
76 LOGE("VM-required field missing from java/lang/String\n");
80 bool badValue = false;
81 if (gDvm.offJavaLangString_value != STRING_FIELDOFF_VALUE) {
82 LOGE("InlineNative: String.value offset = %d, expected %d\n",
83 gDvm.offJavaLangString_value, STRING_FIELDOFF_VALUE);
86 if (gDvm.offJavaLangString_count != STRING_FIELDOFF_COUNT) {
87 LOGE("InlineNative: String.count offset = %d, expected %d\n",
88 gDvm.offJavaLangString_count, STRING_FIELDOFF_COUNT);
91 if (gDvm.offJavaLangString_offset != STRING_FIELDOFF_OFFSET) {
92 LOGE("InlineNative: String.offset offset = %d, expected %d\n",
93 gDvm.offJavaLangString_offset, STRING_FIELDOFF_OFFSET);
96 if (gDvm.offJavaLangString_hashCode != STRING_FIELDOFF_HASHCODE) {
97 LOGE("InlineNative: String.hashCode offset = %d, expected %d\n",
98 gDvm.offJavaLangString_hashCode, STRING_FIELDOFF_HASHCODE);
104 android_atomic_release_store(1, &gDvm.javaLangStringReady);
110 * Discard heap-allocated storage.
112 void dvmStringShutdown()
118 * Compute a hash code on a UTF-8 string, for use with internal hash tables.
120 * This may or may not yield the same results as the java/lang/String
121 * computeHashCode() function. (To make sure this doesn't get abused,
122 * I'm initializing the hash code to 1 so they *don't* match up.)
124 * It would be more correct to invoke dexGetUtf16FromUtf8() here and compute
125 * the hash with the result. That way, if something encoded the same
126 * character in two different ways, the hash value would be the same. For
127 * our purposes that isn't necessary.
129 u4 dvmComputeUtf8Hash(const char* utf8Str)
133 while (*utf8Str != '\0')
134 hash = hash * 31 + *utf8Str++;
140 * Like "strlen", but for strings encoded with "modified" UTF-8.
142 * The value returned is the number of characters, which may or may not
143 * be the same as the number of bytes.
145 * (If this needs optimizing, try: mask against 0xa0, shift right 5,
146 * get increment {1-3} from table of 8 values.)
148 int dvmUtf8Len(const char* utf8Str)
152 while ((ic = *utf8Str++) != '\0') {
154 if ((ic & 0x80) != 0) {
155 /* two- or three-byte encoding */
157 if ((ic & 0x20) != 0) {
158 /* three-byte encoding */
168 * Convert a "modified" UTF-8 string to UTF-16.
170 void dvmConvertUtf8ToUtf16(u2* utf16Str, const char* utf8Str)
172 while (*utf8Str != '\0')
173 *utf16Str++ = dexGetUtf16FromUtf8(&utf8Str);
177 * Given a UTF-16 string, compute the length of the corresponding UTF-8
180 static int utf16_utf8ByteLen(const u2* utf16Str, int len)
185 unsigned int uic = *utf16Str++;
188 * The most common case is (uic > 0 && uic <= 0x7f).
190 if (uic == 0 || uic > 0x7f) {
193 else /*(uic > 0x7f || uic == 0) */
202 * Convert a UTF-16 string to UTF-8.
204 * Make sure you allocate "utf8Str" with the result of utf16_utf8ByteLen(),
207 static void convertUtf16ToUtf8(char* utf8Str, const u2* utf16Str, int len)
212 unsigned int uic = *utf16Str++;
215 * The most common case is (uic > 0 && uic <= 0x7f).
217 if (uic == 0 || uic > 0x7f) {
219 *utf8Str++ = (uic >> 12) | 0xe0;
220 *utf8Str++ = ((uic >> 6) & 0x3f) | 0x80;
221 *utf8Str++ = (uic & 0x3f) | 0x80;
222 } else /*(uic > 0x7f || uic == 0)*/ {
223 *utf8Str++ = (uic >> 6) | 0xc0;
224 *utf8Str++ = (uic & 0x3f) | 0x80;
235 * Use the java/lang/String.computeHashCode() algorithm.
237 static inline u4 dvmComputeUtf16Hash(const u2* utf16Str, int len)
242 hash = hash * 31 + *utf16Str++;
246 u4 dvmComputeStringHash(const StringObject* strObj) {
247 ArrayObject* chars = (ArrayObject*) dvmGetFieldObject((Object*) strObj,
248 STRING_FIELDOFF_VALUE);
251 len = dvmGetFieldInt((Object*) strObj, STRING_FIELDOFF_COUNT);
252 offset = dvmGetFieldInt((Object*) strObj, STRING_FIELDOFF_OFFSET);
254 return dvmComputeUtf16Hash((u2*) chars->contents + offset, len);
258 * Create a new java/lang/String object, using the string data in "utf8Str".
260 * The caller must call dvmReleaseTrackedAlloc() on the return value.
262 * Returns NULL and throws an exception on failure.
264 StringObject* dvmCreateStringFromCstr(const char* utf8Str)
266 assert(utf8Str != NULL);
267 return dvmCreateStringFromCstrAndLength(utf8Str, dvmUtf8Len(utf8Str));
271 * Create a java/lang/String from a C string, given its UTF-16 length
272 * (number of UTF-16 code points).
274 * The caller must call dvmReleaseTrackedAlloc() on the return value.
276 * Returns NULL and throws an exception on failure.
278 StringObject* dvmCreateStringFromCstrAndLength(const char* utf8Str,
281 StringObject* newObj;
285 //LOGV("Creating String from '%s'\n", utf8Str);
286 assert(utf8Str != NULL);
288 if (gDvm.javaLangStringReady <= 0) {
289 if (!stringStartup())
293 /* init before alloc */
294 if (!dvmIsClassInitialized(gDvm.classJavaLangString) &&
295 !dvmInitClass(gDvm.classJavaLangString))
300 newObj = (StringObject*) dvmAllocObject(gDvm.classJavaLangString,
305 chars = dvmAllocPrimitiveArray('C', utf16Length, ALLOC_DEFAULT);
307 dvmReleaseTrackedAlloc((Object*) newObj, NULL);
310 dvmConvertUtf8ToUtf16((u2*)chars->contents, utf8Str);
311 hashCode = dvmComputeUtf16Hash((u2*) chars->contents, utf16Length);
313 dvmSetFieldObject((Object*)newObj, STRING_FIELDOFF_VALUE,
315 dvmReleaseTrackedAlloc((Object*) chars, NULL);
316 dvmSetFieldInt((Object*)newObj, STRING_FIELDOFF_COUNT, utf16Length);
317 dvmSetFieldInt((Object*)newObj, STRING_FIELDOFF_HASHCODE, hashCode);
318 /* leave offset set to zero */
320 /* debugging stuff */
321 //dvmDumpObject((Object*)newObj);
322 //printHexDumpEx(ANDROID_LOG_DEBUG, chars->contents, utf16Length * 2,
325 /* caller may need to dvmReleaseTrackedAlloc(newObj) */
330 * Create a new java/lang/String object, using the Unicode data.
332 StringObject* dvmCreateStringFromUnicode(const u2* unichars, int len)
334 StringObject* newObj;
338 /* we allow a null pointer if the length is zero */
339 assert(len == 0 || unichars != NULL);
341 if (gDvm.javaLangStringReady <= 0) {
342 if (!stringStartup())
346 /* init before alloc */
347 if (!dvmIsClassInitialized(gDvm.classJavaLangString) &&
348 !dvmInitClass(gDvm.classJavaLangString))
353 newObj = (StringObject*) dvmAllocObject(gDvm.classJavaLangString,
358 chars = dvmAllocPrimitiveArray('C', len, ALLOC_DEFAULT);
360 dvmReleaseTrackedAlloc((Object*) newObj, NULL);
364 memcpy(chars->contents, unichars, len * sizeof(u2));
365 hashCode = dvmComputeUtf16Hash((u2*) chars->contents, len);
367 dvmSetFieldObject((Object*)newObj, STRING_FIELDOFF_VALUE,
369 dvmReleaseTrackedAlloc((Object*) chars, NULL);
370 dvmSetFieldInt((Object*)newObj, STRING_FIELDOFF_COUNT, len);
371 dvmSetFieldInt((Object*)newObj, STRING_FIELDOFF_HASHCODE, hashCode);
372 /* leave offset set to zero */
374 /* debugging stuff */
375 //dvmDumpObject((Object*)newObj);
376 //printHexDumpEx(ANDROID_LOG_DEBUG, chars->contents, len*2, kHexDumpMem);
378 /* caller must dvmReleaseTrackedAlloc(newObj) */
383 * Create a new C string from a java/lang/String object.
385 * Returns NULL if the object is NULL.
387 char* dvmCreateCstrFromString(StringObject* jstr)
391 int len, byteLen, offset;
394 assert(gDvm.javaLangStringReady > 0);
399 len = dvmGetFieldInt((Object*) jstr, STRING_FIELDOFF_COUNT);
400 offset = dvmGetFieldInt((Object*) jstr, STRING_FIELDOFF_OFFSET);
401 chars = (ArrayObject*) dvmGetFieldObject((Object*) jstr,
402 STRING_FIELDOFF_VALUE);
403 data = (const u2*) chars->contents + offset;
404 assert(offset + len <= (int) chars->length);
406 byteLen = utf16_utf8ByteLen(data, len);
407 newStr = (char*) malloc(byteLen+1);
410 convertUtf16ToUtf8(newStr, data, len);
416 * Create a UTF-8 C string from a region of a java/lang/String. (Used by
417 * the JNI GetStringUTFRegion call.)
419 void dvmCreateCstrFromStringRegion(StringObject* jstr, int start, int len,
424 data = dvmStringChars(jstr) + start;
425 convertUtf16ToUtf8(buf, data, len);
429 * Compute the length, in modified UTF-8, of a java/lang/String object.
431 * Does not include the terminating null byte.
433 int dvmStringUtf8ByteLen(StringObject* jstr)
439 assert(gDvm.javaLangStringReady > 0);
442 return 0; // should we throw something? assert?
444 len = dvmGetFieldInt((Object*) jstr, STRING_FIELDOFF_COUNT);
445 offset = dvmGetFieldInt((Object*) jstr, STRING_FIELDOFF_OFFSET);
446 chars = (ArrayObject*) dvmGetFieldObject((Object*) jstr,
447 STRING_FIELDOFF_VALUE);
448 data = (const u2*) chars->contents + offset;
449 assert(offset + len <= (int) chars->length);
451 return utf16_utf8ByteLen(data, len);
455 * Get the string's length.
457 int dvmStringLen(StringObject* jstr)
459 return dvmGetFieldInt((Object*) jstr, STRING_FIELDOFF_COUNT);
463 * Get the char[] object from the String.
465 ArrayObject* dvmStringCharArray(StringObject* jstr)
467 return (ArrayObject*) dvmGetFieldObject((Object*) jstr,
468 STRING_FIELDOFF_VALUE);
472 * Get the string's data.
474 const u2* dvmStringChars(StringObject* jstr)
479 offset = dvmGetFieldInt((Object*) jstr, STRING_FIELDOFF_OFFSET);
480 chars = (ArrayObject*) dvmGetFieldObject((Object*) jstr,
481 STRING_FIELDOFF_VALUE);
482 return (const u2*) chars->contents + offset;
487 * Compare two String objects.
489 * This is a dvmHashTableLookup() callback. The function has already
490 * compared their hash values; we need to do a full compare to ensure
491 * that the strings really match.
493 int dvmHashcmpStrings(const void* vstrObj1, const void* vstrObj2)
495 const StringObject* strObj1 = (const StringObject*) vstrObj1;
496 const StringObject* strObj2 = (const StringObject*) vstrObj2;
499 int len1, len2, offset1, offset2;
501 assert(gDvm.javaLangStringReady > 0);
503 /* get offset and length into char array; all values are in 16-bit units */
504 len1 = dvmGetFieldInt((Object*) strObj1, STRING_FIELDOFF_COUNT);
505 offset1 = dvmGetFieldInt((Object*) strObj1, STRING_FIELDOFF_OFFSET);
506 len2 = dvmGetFieldInt((Object*) strObj2, STRING_FIELDOFF_COUNT);
507 offset2 = dvmGetFieldInt((Object*) strObj2, STRING_FIELDOFF_OFFSET);
511 chars1 = (ArrayObject*) dvmGetFieldObject((Object*) strObj1,
512 STRING_FIELDOFF_VALUE);
513 chars2 = (ArrayObject*) dvmGetFieldObject((Object*) strObj2,
514 STRING_FIELDOFF_VALUE);
516 /* damage here actually indicates a broken java/lang/String */
517 assert(offset1 + len1 <= (int) chars1->length);
518 assert(offset2 + len2 <= (int) chars2->length);
520 return memcmp((const u2*) chars1->contents + offset1,
521 (const u2*) chars2->contents + offset2,