1 /*
2 * Copyright (C) 2005 The Android Open Source Project
3 *
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
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
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.
15 */
16
17 #include <utils/String16.h>
18
19 #include <utils/Log.h>
20
21 #include <ctype.h>
22
23 #include "SharedBuffer.h"
24
25 namespace android {
26
27 static const StaticString16 emptyString(u"");
getEmptyString()28 static inline char16_t* getEmptyString() {
29 return const_cast<char16_t*>(emptyString.string());
30 }
31
32 // ---------------------------------------------------------------------------
33
alloc(size_t size)34 void* String16::alloc(size_t size)
35 {
36 SharedBuffer* buf = SharedBuffer::alloc(size);
37 buf->mClientMetadata = kIsSharedBufferAllocated;
38 return buf;
39 }
40
allocFromUTF8(const char * u8str,size_t u8len)41 char16_t* String16::allocFromUTF8(const char* u8str, size_t u8len)
42 {
43 if (u8len == 0) return getEmptyString();
44
45 const uint8_t* u8cur = (const uint8_t*) u8str;
46
47 const ssize_t u16len = utf8_to_utf16_length(u8cur, u8len);
48 if (u16len < 0) {
49 return getEmptyString();
50 }
51
52 SharedBuffer* buf = static_cast<SharedBuffer*>(alloc(sizeof(char16_t) * (u16len + 1)));
53 if (buf) {
54 u8cur = (const uint8_t*) u8str;
55 char16_t* u16str = (char16_t*)buf->data();
56
57 utf8_to_utf16(u8cur, u8len, u16str, ((size_t) u16len) + 1);
58
59 //printf("Created UTF-16 string from UTF-8 \"%s\":", in);
60 //printHexData(1, str, buf->size(), 16, 1);
61 //printf("\n");
62
63 return u16str;
64 }
65
66 return getEmptyString();
67 }
68
allocFromUTF16(const char16_t * u16str,size_t u16len)69 char16_t* String16::allocFromUTF16(const char16_t* u16str, size_t u16len) {
70 if (u16len >= SIZE_MAX / sizeof(char16_t)) {
71 android_errorWriteLog(0x534e4554, "73826242");
72 abort();
73 }
74
75 SharedBuffer* buf = static_cast<SharedBuffer*>(alloc((u16len + 1) * sizeof(char16_t)));
76 ALOG_ASSERT(buf, "Unable to allocate shared buffer");
77 if (buf) {
78 char16_t* str = (char16_t*)buf->data();
79 memcpy(str, u16str, u16len * sizeof(char16_t));
80 str[u16len] = 0;
81 return str;
82 }
83 return getEmptyString();
84 }
85
86 // ---------------------------------------------------------------------------
87
String16()88 String16::String16()
89 : mString(getEmptyString())
90 {
91 }
92
String16(const String16 & o)93 String16::String16(const String16& o)
94 : mString(o.mString)
95 {
96 acquire();
97 }
98
String16(const String16 & o,size_t len,size_t begin)99 String16::String16(const String16& o, size_t len, size_t begin)
100 : mString(getEmptyString())
101 {
102 setTo(o, len, begin);
103 }
104
String16(const char16_t * o)105 String16::String16(const char16_t* o) : mString(allocFromUTF16(o, strlen16(o))) {}
106
String16(const char16_t * o,size_t len)107 String16::String16(const char16_t* o, size_t len) : mString(allocFromUTF16(o, len)) {}
108
String16(const String8 & o)109 String16::String16(const String8& o)
110 : mString(allocFromUTF8(o.string(), o.size()))
111 {
112 }
113
String16(const char * o)114 String16::String16(const char* o)
115 : mString(allocFromUTF8(o, strlen(o)))
116 {
117 }
118
String16(const char * o,size_t len)119 String16::String16(const char* o, size_t len)
120 : mString(allocFromUTF8(o, len))
121 {
122 }
123
~String16()124 String16::~String16()
125 {
126 release();
127 }
128
size() const129 size_t String16::size() const
130 {
131 if (isStaticString()) {
132 return staticStringSize();
133 } else {
134 return SharedBuffer::sizeFromData(mString) / sizeof(char16_t) - 1;
135 }
136 }
137
setTo(const String16 & other)138 void String16::setTo(const String16& other)
139 {
140 release();
141 mString = other.mString;
142 acquire();
143 }
144
setTo(const String16 & other,size_t len,size_t begin)145 status_t String16::setTo(const String16& other, size_t len, size_t begin)
146 {
147 const size_t N = other.size();
148 if (begin >= N) {
149 release();
150 mString = getEmptyString();
151 return OK;
152 }
153 if ((begin+len) > N) len = N-begin;
154 if (begin == 0 && len == N) {
155 setTo(other);
156 return OK;
157 }
158
159 if (&other == this) {
160 LOG_ALWAYS_FATAL("Not implemented");
161 }
162
163 return setTo(other.string()+begin, len);
164 }
165
setTo(const char16_t * other)166 status_t String16::setTo(const char16_t* other)
167 {
168 return setTo(other, strlen16(other));
169 }
170
setTo(const char16_t * other,size_t len)171 status_t String16::setTo(const char16_t* other, size_t len)
172 {
173 if (len >= SIZE_MAX / sizeof(char16_t)) {
174 android_errorWriteLog(0x534e4554, "73826242");
175 abort();
176 }
177
178 SharedBuffer* buf = static_cast<SharedBuffer*>(editResize((len + 1) * sizeof(char16_t)));
179 if (buf) {
180 char16_t* str = (char16_t*)buf->data();
181 memmove(str, other, len*sizeof(char16_t));
182 str[len] = 0;
183 mString = str;
184 return OK;
185 }
186 return NO_MEMORY;
187 }
188
append(const String16 & other)189 status_t String16::append(const String16& other)
190 {
191 const size_t myLen = size();
192 const size_t otherLen = other.size();
193 if (myLen == 0) {
194 setTo(other);
195 return OK;
196 } else if (otherLen == 0) {
197 return OK;
198 }
199
200 if (myLen >= SIZE_MAX / sizeof(char16_t) - otherLen) {
201 android_errorWriteLog(0x534e4554, "73826242");
202 abort();
203 }
204
205 SharedBuffer* buf =
206 static_cast<SharedBuffer*>(editResize((myLen + otherLen + 1) * sizeof(char16_t)));
207 if (buf) {
208 char16_t* str = (char16_t*)buf->data();
209 memcpy(str+myLen, other, (otherLen+1)*sizeof(char16_t));
210 mString = str;
211 return OK;
212 }
213 return NO_MEMORY;
214 }
215
append(const char16_t * chrs,size_t otherLen)216 status_t String16::append(const char16_t* chrs, size_t otherLen)
217 {
218 const size_t myLen = size();
219 if (myLen == 0) {
220 setTo(chrs, otherLen);
221 return OK;
222 } else if (otherLen == 0) {
223 return OK;
224 }
225
226 if (myLen >= SIZE_MAX / sizeof(char16_t) - otherLen) {
227 android_errorWriteLog(0x534e4554, "73826242");
228 abort();
229 }
230
231 SharedBuffer* buf =
232 static_cast<SharedBuffer*>(editResize((myLen + otherLen + 1) * sizeof(char16_t)));
233 if (buf) {
234 char16_t* str = (char16_t*)buf->data();
235 memcpy(str+myLen, chrs, otherLen*sizeof(char16_t));
236 str[myLen+otherLen] = 0;
237 mString = str;
238 return OK;
239 }
240 return NO_MEMORY;
241 }
242
insert(size_t pos,const char16_t * chrs)243 status_t String16::insert(size_t pos, const char16_t* chrs)
244 {
245 return insert(pos, chrs, strlen16(chrs));
246 }
247
insert(size_t pos,const char16_t * chrs,size_t len)248 status_t String16::insert(size_t pos, const char16_t* chrs, size_t len)
249 {
250 const size_t myLen = size();
251 if (myLen == 0) {
252 return setTo(chrs, len);
253 return OK;
254 } else if (len == 0) {
255 return OK;
256 }
257
258 if (pos > myLen) pos = myLen;
259
260 #if 0
261 printf("Insert in to %s: pos=%d, len=%d, myLen=%d, chrs=%s\n",
262 String8(*this).string(), pos,
263 len, myLen, String8(chrs, len).string());
264 #endif
265
266 SharedBuffer* buf =
267 static_cast<SharedBuffer*>(editResize((myLen + len + 1) * sizeof(char16_t)));
268 if (buf) {
269 char16_t* str = (char16_t*)buf->data();
270 if (pos < myLen) {
271 memmove(str+pos+len, str+pos, (myLen-pos)*sizeof(char16_t));
272 }
273 memcpy(str+pos, chrs, len*sizeof(char16_t));
274 str[myLen+len] = 0;
275 mString = str;
276 #if 0
277 printf("Result (%d chrs): %s\n", size(), String8(*this).string());
278 #endif
279 return OK;
280 }
281 return NO_MEMORY;
282 }
283
findFirst(char16_t c) const284 ssize_t String16::findFirst(char16_t c) const
285 {
286 const char16_t* str = string();
287 const char16_t* p = str;
288 const char16_t* e = p + size();
289 while (p < e) {
290 if (*p == c) {
291 return p-str;
292 }
293 p++;
294 }
295 return -1;
296 }
297
findLast(char16_t c) const298 ssize_t String16::findLast(char16_t c) const
299 {
300 const char16_t* str = string();
301 const char16_t* p = str;
302 const char16_t* e = p + size();
303 while (p < e) {
304 e--;
305 if (*e == c) {
306 return e-str;
307 }
308 }
309 return -1;
310 }
311
startsWith(const String16 & prefix) const312 bool String16::startsWith(const String16& prefix) const
313 {
314 const size_t ps = prefix.size();
315 if (ps > size()) return false;
316 return strzcmp16(mString, ps, prefix.string(), ps) == 0;
317 }
318
startsWith(const char16_t * prefix) const319 bool String16::startsWith(const char16_t* prefix) const
320 {
321 const size_t ps = strlen16(prefix);
322 if (ps > size()) return false;
323 return strncmp16(mString, prefix, ps) == 0;
324 }
325
contains(const char16_t * chrs) const326 bool String16::contains(const char16_t* chrs) const
327 {
328 return strstr16(mString, chrs) != nullptr;
329 }
330
edit()331 void* String16::edit() {
332 SharedBuffer* buf;
333 if (isStaticString()) {
334 buf = static_cast<SharedBuffer*>(alloc((size() + 1) * sizeof(char16_t)));
335 if (buf) {
336 memcpy(buf->data(), mString, (size() + 1) * sizeof(char16_t));
337 }
338 } else {
339 buf = SharedBuffer::bufferFromData(mString)->edit();
340 buf->mClientMetadata = kIsSharedBufferAllocated;
341 }
342 return buf;
343 }
344
editResize(size_t newSize)345 void* String16::editResize(size_t newSize) {
346 SharedBuffer* buf;
347 if (isStaticString()) {
348 size_t copySize = (size() + 1) * sizeof(char16_t);
349 if (newSize < copySize) {
350 copySize = newSize;
351 }
352 buf = static_cast<SharedBuffer*>(alloc(newSize));
353 if (buf) {
354 memcpy(buf->data(), mString, copySize);
355 }
356 } else {
357 buf = SharedBuffer::bufferFromData(mString)->editResize(newSize);
358 buf->mClientMetadata = kIsSharedBufferAllocated;
359 }
360 return buf;
361 }
362
acquire()363 void String16::acquire()
364 {
365 if (!isStaticString()) {
366 SharedBuffer::bufferFromData(mString)->acquire();
367 }
368 }
369
release()370 void String16::release()
371 {
372 if (!isStaticString()) {
373 SharedBuffer::bufferFromData(mString)->release();
374 }
375 }
376
isStaticString() const377 bool String16::isStaticString() const {
378 // See String16.h for notes on the memory layout of String16::StaticData and
379 // SharedBuffer.
380 static_assert(sizeof(SharedBuffer) - offsetof(SharedBuffer, mClientMetadata) == 4);
381 const uint32_t* p = reinterpret_cast<const uint32_t*>(mString);
382 return (*(p - 1) & kIsSharedBufferAllocated) == 0;
383 }
384
staticStringSize() const385 size_t String16::staticStringSize() const {
386 // See String16.h for notes on the memory layout of String16::StaticData and
387 // SharedBuffer.
388 static_assert(sizeof(SharedBuffer) - offsetof(SharedBuffer, mClientMetadata) == 4);
389 const uint32_t* p = reinterpret_cast<const uint32_t*>(mString);
390 return static_cast<size_t>(*(p - 1));
391 }
392
makeLower()393 status_t String16::makeLower()
394 {
395 const size_t N = size();
396 const char16_t* str = string();
397 char16_t* edited = nullptr;
398 for (size_t i=0; i<N; i++) {
399 const char16_t v = str[i];
400 if (v >= 'A' && v <= 'Z') {
401 if (!edited) {
402 SharedBuffer* buf = static_cast<SharedBuffer*>(edit());
403 if (!buf) {
404 return NO_MEMORY;
405 }
406 edited = (char16_t*)buf->data();
407 mString = str = edited;
408 }
409 edited[i] = tolower((char)v);
410 }
411 }
412 return OK;
413 }
414
replaceAll(char16_t replaceThis,char16_t withThis)415 status_t String16::replaceAll(char16_t replaceThis, char16_t withThis)
416 {
417 const size_t N = size();
418 const char16_t* str = string();
419 char16_t* edited = nullptr;
420 for (size_t i=0; i<N; i++) {
421 if (str[i] == replaceThis) {
422 if (!edited) {
423 SharedBuffer* buf = static_cast<SharedBuffer*>(edit());
424 if (!buf) {
425 return NO_MEMORY;
426 }
427 edited = (char16_t*)buf->data();
428 mString = str = edited;
429 }
430 edited[i] = withThis;
431 }
432 }
433 return OK;
434 }
435
remove(size_t len,size_t begin)436 status_t String16::remove(size_t len, size_t begin)
437 {
438 const size_t N = size();
439 if (begin >= N) {
440 release();
441 mString = getEmptyString();
442 return OK;
443 }
444 if ((begin+len) > N) len = N-begin;
445 if (begin == 0 && len == N) {
446 return OK;
447 }
448
449 if (begin > 0) {
450 SharedBuffer* buf = static_cast<SharedBuffer*>(editResize((N + 1) * sizeof(char16_t)));
451 if (!buf) {
452 return NO_MEMORY;
453 }
454 char16_t* str = (char16_t*)buf->data();
455 memmove(str, str+begin, (N-begin+1)*sizeof(char16_t));
456 mString = str;
457 }
458 SharedBuffer* buf = static_cast<SharedBuffer*>(editResize((len + 1) * sizeof(char16_t)));
459 if (buf) {
460 char16_t* str = (char16_t*)buf->data();
461 str[len] = 0;
462 mString = str;
463 return OK;
464 }
465 return NO_MEMORY;
466 }
467
468 }; // namespace android
469