The Tor Browser / file comparison

comparison: gfx/skia/trunk/src/core/SkString.cpp

gfx/skia/trunk/src/core/SkString.cpp

branch
TOR_BUG_3246
changeset 7
129ffea94266
equal deleted inserted replaced
-1:000000000000 0:e1e0cdfabc19
1
2 /*
3 * Copyright 2006 The Android Open Source Project
4 *
5 * Use of this source code is governed by a BSD-style license that can be
6 * found in the LICENSE file.
7 */
8
9
10 #include "SkString.h"
11 #include "SkFixed.h"
12 #include "SkThread.h"
13 #include "SkUtils.h"
14 #include <stdarg.h>
15 #include <stdio.h>
16
17 // number of bytes (on the stack) to receive the printf result
18 static const size_t kBufferSize = 1024;
19
20 #ifdef SK_BUILD_FOR_WIN
21 #define VSNPRINTF(buffer, size, format, args) \
22 _vsnprintf_s(buffer, size, _TRUNCATE, format, args)
23 #define SNPRINTF _snprintf
24 #else
25 #define VSNPRINTF vsnprintf
26 #define SNPRINTF snprintf
27 #endif
28
29 #define ARGS_TO_BUFFER(format, buffer, size) \
30 do { \
31 va_list args; \
32 va_start(args, format); \
33 VSNPRINTF(buffer, size, format, args); \
34 va_end(args); \
35 } while (0)
36
37 ///////////////////////////////////////////////////////////////////////////////
38
39 bool SkStrEndsWith(const char string[], const char suffixStr[]) {
40 SkASSERT(string);
41 SkASSERT(suffixStr);
42 size_t strLen = strlen(string);
43 size_t suffixLen = strlen(suffixStr);
44 return strLen >= suffixLen &&
45 !strncmp(string + strLen - suffixLen, suffixStr, suffixLen);
46 }
47
48 bool SkStrEndsWith(const char string[], const char suffixChar) {
49 SkASSERT(string);
50 size_t strLen = strlen(string);
51 if (0 == strLen) {
52 return false;
53 } else {
54 return (suffixChar == string[strLen-1]);
55 }
56 }
57
58 int SkStrStartsWithOneOf(const char string[], const char prefixes[]) {
59 int index = 0;
60 do {
61 const char* limit = strchr(prefixes, '\0');
62 if (!strncmp(string, prefixes, limit - prefixes)) {
63 return index;
64 }
65 prefixes = limit + 1;
66 index++;
67 } while (prefixes[0]);
68 return -1;
69 }
70
71 char* SkStrAppendU32(char string[], uint32_t dec) {
72 SkDEBUGCODE(char* start = string;)
73
74 char buffer[SkStrAppendU32_MaxSize];
75 char* p = buffer + sizeof(buffer);
76
77 do {
78 *--p = SkToU8('0' + dec % 10);
79 dec /= 10;
80 } while (dec != 0);
81
82 SkASSERT(p >= buffer);
83 char* stop = buffer + sizeof(buffer);
84 while (p < stop) {
85 *string++ = *p++;
86 }
87 SkASSERT(string - start <= SkStrAppendU32_MaxSize);
88 return string;
89 }
90
91 char* SkStrAppendS32(char string[], int32_t dec) {
92 if (dec < 0) {
93 *string++ = '-';
94 dec = -dec;
95 }
96 return SkStrAppendU32(string, static_cast<uint32_t>(dec));
97 }
98
99 char* SkStrAppendU64(char string[], uint64_t dec, int minDigits) {
100 SkDEBUGCODE(char* start = string;)
101
102 char buffer[SkStrAppendU64_MaxSize];
103 char* p = buffer + sizeof(buffer);
104
105 do {
106 *--p = SkToU8('0' + (int32_t) (dec % 10));
107 dec /= 10;
108 minDigits--;
109 } while (dec != 0);
110
111 while (minDigits > 0) {
112 *--p = '0';
113 minDigits--;
114 }
115
116 SkASSERT(p >= buffer);
117 size_t cp_len = buffer + sizeof(buffer) - p;
118 memcpy(string, p, cp_len);
119 string += cp_len;
120
121 SkASSERT(string - start <= SkStrAppendU64_MaxSize);
122 return string;
123 }
124
125 char* SkStrAppendS64(char string[], int64_t dec, int minDigits) {
126 if (dec < 0) {
127 *string++ = '-';
128 dec = -dec;
129 }
130 return SkStrAppendU64(string, static_cast<uint64_t>(dec), minDigits);
131 }
132
133 char* SkStrAppendFloat(char string[], float value) {
134 // since floats have at most 8 significant digits, we limit our %g to that.
135 static const char gFormat[] = "%.8g";
136 // make it 1 larger for the terminating 0
137 char buffer[SkStrAppendScalar_MaxSize + 1];
138 int len = SNPRINTF(buffer, sizeof(buffer), gFormat, value);
139 memcpy(string, buffer, len);
140 SkASSERT(len <= SkStrAppendScalar_MaxSize);
141 return string + len;
142 }
143
144 char* SkStrAppendFixed(char string[], SkFixed x) {
145 SkDEBUGCODE(char* start = string;)
146 if (x < 0) {
147 *string++ = '-';
148 x = -x;
149 }
150
151 unsigned frac = x & 0xFFFF;
152 x >>= 16;
153 if (frac == 0xFFFF) {
154 // need to do this to "round up", since 65535/65536 is closer to 1 than to .9999
155 x += 1;
156 frac = 0;
157 }
158 string = SkStrAppendS32(string, x);
159
160 // now handle the fractional part (if any)
161 if (frac) {
162 static const uint16_t gTens[] = { 1000, 100, 10, 1 };
163 const uint16_t* tens = gTens;
164
165 x = SkFixedRoundToInt(frac * 10000);
166 SkASSERT(x <= 10000);
167 if (x == 10000) {
168 x -= 1;
169 }
170 *string++ = '.';
171 do {
172 unsigned powerOfTen = *tens++;
173 *string++ = SkToU8('0' + x / powerOfTen);
174 x %= powerOfTen;
175 } while (x != 0);
176 }
177
178 SkASSERT(string - start <= SkStrAppendScalar_MaxSize);
179 return string;
180 }
181
182 ///////////////////////////////////////////////////////////////////////////////
183
184 // the 3 values are [length] [refcnt] [terminating zero data]
185 const SkString::Rec SkString::gEmptyRec = { 0, 0, 0 };
186
187 #define SizeOfRec() (gEmptyRec.data() - (const char*)&gEmptyRec)
188
189 static uint32_t trim_size_t_to_u32(size_t value) {
190 if (sizeof(size_t) > sizeof(uint32_t)) {
191 if (value > SK_MaxU32) {
192 value = SK_MaxU32;
193 }
194 }
195 return (uint32_t)value;
196 }
197
198 static size_t check_add32(size_t base, size_t extra) {
199 SkASSERT(base <= SK_MaxU32);
200 if (sizeof(size_t) > sizeof(uint32_t)) {
201 if (base + extra > SK_MaxU32) {
202 extra = SK_MaxU32 - base;
203 }
204 }
205 return extra;
206 }
207
208 SkString::Rec* SkString::AllocRec(const char text[], size_t len) {
209 Rec* rec;
210
211 if (0 == len) {
212 rec = const_cast<Rec*>(&gEmptyRec);
213 } else {
214 len = trim_size_t_to_u32(len);
215
216 // add 1 for terminating 0, then align4 so we can have some slop when growing the string
217 rec = (Rec*)sk_malloc_throw(SizeOfRec() + SkAlign4(len + 1));
218 rec->fLength = SkToU32(len);
219 rec->fRefCnt = 1;
220 if (text) {
221 memcpy(rec->data(), text, len);
222 }
223 rec->data()[len] = 0;
224 }
225 return rec;
226 }
227
228 SkString::Rec* SkString::RefRec(Rec* src) {
229 if (src != &gEmptyRec) {
230 sk_atomic_inc(&src->fRefCnt);
231 }
232 return src;
233 }
234
235 #ifdef SK_DEBUG
236 void SkString::validate() const {
237 // make sure know one has written over our global
238 SkASSERT(0 == gEmptyRec.fLength);
239 SkASSERT(0 == gEmptyRec.fRefCnt);
240 SkASSERT(0 == gEmptyRec.data()[0]);
241
242 if (fRec != &gEmptyRec) {
243 SkASSERT(fRec->fLength > 0);
244 SkASSERT(fRec->fRefCnt > 0);
245 SkASSERT(0 == fRec->data()[fRec->fLength]);
246 }
247 SkASSERT(fStr == c_str());
248 }
249 #endif
250
251 ///////////////////////////////////////////////////////////////////////////////
252
253 SkString::SkString() : fRec(const_cast<Rec*>(&gEmptyRec)) {
254 #ifdef SK_DEBUG
255 fStr = fRec->data();
256 #endif
257 }
258
259 SkString::SkString(size_t len) {
260 fRec = AllocRec(NULL, len);
261 #ifdef SK_DEBUG
262 fStr = fRec->data();
263 #endif
264 }
265
266 SkString::SkString(const char text[]) {
267 size_t len = text ? strlen(text) : 0;
268
269 fRec = AllocRec(text, len);
270 #ifdef SK_DEBUG
271 fStr = fRec->data();
272 #endif
273 }
274
275 SkString::SkString(const char text[], size_t len) {
276 fRec = AllocRec(text, len);
277 #ifdef SK_DEBUG
278 fStr = fRec->data();
279 #endif
280 }
281
282 SkString::SkString(const SkString& src) {
283 src.validate();
284
285 fRec = RefRec(src.fRec);
286 #ifdef SK_DEBUG
287 fStr = fRec->data();
288 #endif
289 }
290
291 SkString::~SkString() {
292 this->validate();
293
294 if (fRec->fLength) {
295 SkASSERT(fRec->fRefCnt > 0);
296 if (sk_atomic_dec(&fRec->fRefCnt) == 1) {
297 sk_free(fRec);
298 }
299 }
300 }
301
302 bool SkString::equals(const SkString& src) const {
303 return fRec == src.fRec || this->equals(src.c_str(), src.size());
304 }
305
306 bool SkString::equals(const char text[]) const {
307 return this->equals(text, text ? strlen(text) : 0);
308 }
309
310 bool SkString::equals(const char text[], size_t len) const {
311 SkASSERT(len == 0 || text != NULL);
312
313 return fRec->fLength == len && !memcmp(fRec->data(), text, len);
314 }
315
316 SkString& SkString::operator=(const SkString& src) {
317 this->validate();
318
319 if (fRec != src.fRec) {
320 SkString tmp(src);
321 this->swap(tmp);
322 }
323 return *this;
324 }
325
326 SkString& SkString::operator=(const char text[]) {
327 this->validate();
328
329 SkString tmp(text);
330 this->swap(tmp);
331
332 return *this;
333 }
334
335 void SkString::reset() {
336 this->validate();
337
338 if (fRec->fLength) {
339 SkASSERT(fRec->fRefCnt > 0);
340 if (sk_atomic_dec(&fRec->fRefCnt) == 1) {
341 sk_free(fRec);
342 }
343 }
344
345 fRec = const_cast<Rec*>(&gEmptyRec);
346 #ifdef SK_DEBUG
347 fStr = fRec->data();
348 #endif
349 }
350
351 char* SkString::writable_str() {
352 this->validate();
353
354 if (fRec->fLength) {
355 if (fRec->fRefCnt > 1) {
356 Rec* rec = AllocRec(fRec->data(), fRec->fLength);
357 if (sk_atomic_dec(&fRec->fRefCnt) == 1) {
358 // In this case after our check of fRecCnt > 1, we suddenly
359 // did become the only owner, so now we have two copies of the
360 // data (fRec and rec), so we need to delete one of them.
361 sk_free(fRec);
362 }
363 fRec = rec;
364 #ifdef SK_DEBUG
365 fStr = fRec->data();
366 #endif
367 }
368 }
369 return fRec->data();
370 }
371
372 void SkString::set(const char text[]) {
373 this->set(text, text ? strlen(text) : 0);
374 }
375
376 void SkString::set(const char text[], size_t len) {
377 len = trim_size_t_to_u32(len);
378
379 if (0 == len) {
380 this->reset();
381 } else if (1 == fRec->fRefCnt && len <= fRec->fLength) {
382 // should we resize if len <<<< fLength, to save RAM? (e.g. len < (fLength>>1))?
383 // just use less of the buffer without allocating a smaller one
384 char* p = this->writable_str();
385 if (text) {
386 memcpy(p, text, len);
387 }
388 p[len] = 0;
389 fRec->fLength = SkToU32(len);
390 } else if (1 == fRec->fRefCnt && (fRec->fLength >> 2) == (len >> 2)) {
391 // we have spare room in the current allocation, so don't alloc a larger one
392 char* p = this->writable_str();
393 if (text) {
394 memcpy(p, text, len);
395 }
396 p[len] = 0;
397 fRec->fLength = SkToU32(len);
398 } else {
399 SkString tmp(text, len);
400 this->swap(tmp);
401 }
402 }
403
404 void SkString::setUTF16(const uint16_t src[]) {
405 int count = 0;
406
407 while (src[count]) {
408 count += 1;
409 }
410 this->setUTF16(src, count);
411 }
412
413 void SkString::setUTF16(const uint16_t src[], size_t count) {
414 count = trim_size_t_to_u32(count);
415
416 if (0 == count) {
417 this->reset();
418 } else if (count <= fRec->fLength) {
419 // should we resize if len <<<< fLength, to save RAM? (e.g. len < (fLength>>1))
420 if (count < fRec->fLength) {
421 this->resize(count);
422 }
423 char* p = this->writable_str();
424 for (size_t i = 0; i < count; i++) {
425 p[i] = SkToU8(src[i]);
426 }
427 p[count] = 0;
428 } else {
429 SkString tmp(count); // puts a null terminator at the end of the string
430 char* p = tmp.writable_str();
431
432 for (size_t i = 0; i < count; i++) {
433 p[i] = SkToU8(src[i]);
434 }
435 this->swap(tmp);
436 }
437 }
438
439 void SkString::insert(size_t offset, const char text[]) {
440 this->insert(offset, text, text ? strlen(text) : 0);
441 }
442
443 void SkString::insert(size_t offset, const char text[], size_t len) {
444 if (len) {
445 size_t length = fRec->fLength;
446 if (offset > length) {
447 offset = length;
448 }
449
450 // Check if length + len exceeds 32bits, we trim len
451 len = check_add32(length, len);
452 if (0 == len) {
453 return;
454 }
455
456 /* If we're the only owner, and we have room in our allocation for the insert,
457 do it in place, rather than allocating a new buffer.
458
459 To know we have room, compare the allocated sizes
460 beforeAlloc = SkAlign4(length + 1)
461 afterAlloc = SkAligh4(length + 1 + len)
462 but SkAlign4(x) is (x + 3) >> 2 << 2
463 which is equivalent for testing to (length + 1 + 3) >> 2 == (length + 1 + 3 + len) >> 2
464 and we can then eliminate the +1+3 since that doesn't affec the answer
465 */
466 if (1 == fRec->fRefCnt && (length >> 2) == ((length + len) >> 2)) {
467 char* dst = this->writable_str();
468
469 if (offset < length) {
470 memmove(dst + offset + len, dst + offset, length - offset);
471 }
472 memcpy(dst + offset, text, len);
473
474 dst[length + len] = 0;
475 fRec->fLength = SkToU32(length + len);
476 } else {
477 /* Seems we should use realloc here, since that is safe if it fails
478 (we have the original data), and might be faster than alloc/copy/free.
479 */
480 SkString tmp(fRec->fLength + len);
481 char* dst = tmp.writable_str();
482
483 if (offset > 0) {
484 memcpy(dst, fRec->data(), offset);
485 }
486 memcpy(dst + offset, text, len);
487 if (offset < fRec->fLength) {
488 memcpy(dst + offset + len, fRec->data() + offset,
489 fRec->fLength - offset);
490 }
491
492 this->swap(tmp);
493 }
494 }
495 }
496
497 void SkString::insertUnichar(size_t offset, SkUnichar uni) {
498 char buffer[kMaxBytesInUTF8Sequence];
499 size_t len = SkUTF8_FromUnichar(uni, buffer);
500
501 if (len) {
502 this->insert(offset, buffer, len);
503 }
504 }
505
506 void SkString::insertS32(size_t offset, int32_t dec) {
507 char buffer[SkStrAppendS32_MaxSize];
508 char* stop = SkStrAppendS32(buffer, dec);
509 this->insert(offset, buffer, stop - buffer);
510 }
511
512 void SkString::insertS64(size_t offset, int64_t dec, int minDigits) {
513 char buffer[SkStrAppendS64_MaxSize];
514 char* stop = SkStrAppendS64(buffer, dec, minDigits);
515 this->insert(offset, buffer, stop - buffer);
516 }
517
518 void SkString::insertU32(size_t offset, uint32_t dec) {
519 char buffer[SkStrAppendU32_MaxSize];
520 char* stop = SkStrAppendU32(buffer, dec);
521 this->insert(offset, buffer, stop - buffer);
522 }
523
524 void SkString::insertU64(size_t offset, uint64_t dec, int minDigits) {
525 char buffer[SkStrAppendU64_MaxSize];
526 char* stop = SkStrAppendU64(buffer, dec, minDigits);
527 this->insert(offset, buffer, stop - buffer);
528 }
529
530 void SkString::insertHex(size_t offset, uint32_t hex, int minDigits) {
531 minDigits = SkPin32(minDigits, 0, 8);
532
533 static const char gHex[] = "0123456789ABCDEF";
534
535 char buffer[8];
536 char* p = buffer + sizeof(buffer);
537
538 do {
539 *--p = gHex[hex & 0xF];
540 hex >>= 4;
541 minDigits -= 1;
542 } while (hex != 0);
543
544 while (--minDigits >= 0) {
545 *--p = '0';
546 }
547
548 SkASSERT(p >= buffer);
549 this->insert(offset, p, buffer + sizeof(buffer) - p);
550 }
551
552 void SkString::insertScalar(size_t offset, SkScalar value) {
553 char buffer[SkStrAppendScalar_MaxSize];
554 char* stop = SkStrAppendScalar(buffer, value);
555 this->insert(offset, buffer, stop - buffer);
556 }
557
558 void SkString::printf(const char format[], ...) {
559 char buffer[kBufferSize];
560 ARGS_TO_BUFFER(format, buffer, kBufferSize);
561
562 this->set(buffer, strlen(buffer));
563 }
564
565 void SkString::appendf(const char format[], ...) {
566 char buffer[kBufferSize];
567 ARGS_TO_BUFFER(format, buffer, kBufferSize);
568
569 this->append(buffer, strlen(buffer));
570 }
571
572 void SkString::appendVAList(const char format[], va_list args) {
573 char buffer[kBufferSize];
574 VSNPRINTF(buffer, kBufferSize, format, args);
575
576 this->append(buffer, strlen(buffer));
577 }
578
579 void SkString::prependf(const char format[], ...) {
580 char buffer[kBufferSize];
581 ARGS_TO_BUFFER(format, buffer, kBufferSize);
582
583 this->prepend(buffer, strlen(buffer));
584 }
585
586 ///////////////////////////////////////////////////////////////////////////////
587
588 void SkString::remove(size_t offset, size_t length) {
589 size_t size = this->size();
590
591 if (offset < size) {
592 if (offset + length > size) {
593 length = size - offset;
594 }
595 if (length > 0) {
596 SkASSERT(size > length);
597 SkString tmp(size - length);
598 char* dst = tmp.writable_str();
599 const char* src = this->c_str();
600
601 if (offset) {
602 SkASSERT(offset <= tmp.size());
603 memcpy(dst, src, offset);
604 }
605 size_t tail = size - offset - length;
606 SkASSERT((int32_t)tail >= 0);
607 if (tail) {
608 // SkASSERT(offset + length <= tmp.size());
609 memcpy(dst + offset, src + offset + length, tail);
610 }
611 SkASSERT(dst[tmp.size()] == 0);
612 this->swap(tmp);
613 }
614 }
615 }
616
617 void SkString::swap(SkString& other) {
618 this->validate();
619 other.validate();
620
621 SkTSwap<Rec*>(fRec, other.fRec);
622 #ifdef SK_DEBUG
623 SkTSwap<const char*>(fStr, other.fStr);
624 #endif
625 }
626
627 ///////////////////////////////////////////////////////////////////////////////
628
629 SkString SkStringPrintf(const char* format, ...) {
630 SkString formattedOutput;
631 char buffer[kBufferSize];
632 ARGS_TO_BUFFER(format, buffer, kBufferSize);
633 formattedOutput.set(buffer);
634 return formattedOutput;
635 }
636
637 void SkStrSplit(const char* str, const char* delimiters, SkTArray<SkString>* out) {
638 const char* end = str + strlen(str);
639 while (str != end) {
640 // Find a token.
641 const size_t len = strcspn(str, delimiters);
642 out->push_back().set(str, len);
643 str += len;
644 // Skip any delimiters.
645 str += strspn(str, delimiters);
646 }
647 }
648
649 #undef VSNPRINTF
650 #undef SNPRINTF

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial