src/third_party/skia/src/core/SkString.cpp

   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 void SkString::prependVAList(const char format[], va_list args) {
 587     char    buffer[kBufferSize];
 588     VSNPRINTF(buffer, kBufferSize, format, args);
 589
 590     this->prepend(buffer, strlen(buffer));
 591 }
 592
 593
 594 ///////////////////////////////////////////////////////////////////////////////
 595
 596 void SkString::remove(size_t offset, size_t length) {
 597     size_t size = this->size();
 598
 599     if (offset < size) {
 600         if (length > size - offset) {
 601             length = size - offset;
 602         }
 603         SkASSERT(length <= size);
 604         SkASSERT(offset <= size - length);
 605         if (length > 0) {
 606             SkString    tmp(size - length);
 607             char*       dst = tmp.writable_str();
 608             const char* src = this->c_str();
 609
 610             if (offset) {
 611                 memcpy(dst, src, offset);
 612             }
 613             size_t tail = size - (offset + length);
 614             if (tail) {
 615                 memcpy(dst + offset, src + (offset + length), tail);
 616             }
 617             SkASSERT(dst[tmp.size()] == 0);
 618             this->swap(tmp);
 619         }
 620     }
 621 }
 622
 623 void SkString::swap(SkString& other) {
 624     this->validate();
 625     other.validate();
 626
 627     SkTSwap<Rec*>(fRec, other.fRec);
 628 #ifdef SK_DEBUG
 629     SkTSwap<const char*>(fStr, other.fStr);
 630 #endif
 631 }
 632
 633 ///////////////////////////////////////////////////////////////////////////////
 634
 635 SkString SkStringPrintf(const char* format, ...) {
 636     SkString formattedOutput;
 637     char buffer[kBufferSize];
 638     ARGS_TO_BUFFER(format, buffer, kBufferSize);
 639     formattedOutput.set(buffer);
 640     return formattedOutput;
 641 }
 642
 643 void SkStrSplit(const char* str, const char* delimiters, SkTArray<SkString>* out) {
 644     const char* end = str + strlen(str);
 645     while (str != end) {
 646         // Find a token.
 647         const size_t len = strcspn(str, delimiters);
 648         out->push_back().set(str, len);
 649         str += len;
 650         // Skip any delimiters.
 651         str += strspn(str, delimiters);
 652     }
 653 }
 654
 655 #undef VSNPRINTF
 656 #undef SNPRINTF