code style
git-svn-id: http://skia.googlecode.com/svn/trunk@1095 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/src/core/SkString.cpp b/src/core/SkString.cpp
index 8a1591a..49182ea 100644
--- a/src/core/SkString.cpp
+++ b/src/core/SkString.cpp
@@ -42,15 +42,13 @@
///////////////////////////////////////////////////////////////////////////////
-bool SkStrStartsWith(const char string[], const char prefix[])
-{
+bool SkStrStartsWith(const char string[], const char prefix[]) {
SkASSERT(string);
SkASSERT(prefix);
return !strncmp(string, prefix, strlen(prefix));
}
-bool SkStrEndsWith(const char string[], const char suffix[])
-{
+bool SkStrEndsWith(const char string[], const char suffix[]) {
SkASSERT(string);
SkASSERT(suffix);
size_t strLen = strlen(string);
@@ -59,50 +57,50 @@
!strncmp(string + strLen - suffixLen, suffix, suffixLen);
}
-int SkStrStartsWithOneOf(const char string[], const char prefixes[])
-{
+int SkStrStartsWithOneOf(const char string[], const char prefixes[]) {
int index = 0;
do {
const char* limit = strchr(prefixes, '\0');
- if (!strncmp(string, prefixes, limit - prefixes))
+ if (!strncmp(string, prefixes, limit - prefixes)) {
return index;
+ }
prefixes = limit + 1;
index++;
} while (prefixes[0]);
return -1;
}
-char* SkStrAppendS32(char string[], int32_t dec)
-{
+char* SkStrAppendS32(char string[], int32_t dec) {
SkDEBUGCODE(char* start = string;)
char buffer[SkStrAppendS32_MaxSize];
char* p = buffer + sizeof(buffer);
bool neg = false;
- if (dec < 0)
- {
+ if (dec < 0) {
neg = true;
dec = -dec;
}
+
do {
*--p = SkToU8('0' + dec % 10);
dec /= 10;
} while (dec != 0);
- if (neg)
+
+ if (neg) {
*--p = '-';
+ }
SkASSERT(p >= buffer);
char* stop = buffer + sizeof(buffer);
- while (p < stop)
+ while (p < stop) {
*string++ = *p++;
-
+ }
SkASSERT(string - start <= SkStrAppendS32_MaxSize);
return string;
}
-char* SkStrAppendS64(char string[], int64_t dec, int minDigits)
-{
+char* SkStrAppendS64(char string[], int64_t dec, int minDigits) {
SkDEBUGCODE(char* start = string;)
char buffer[SkStrAppendS64_MaxSize];
@@ -113,18 +111,21 @@
neg = true;
dec = -dec;
}
+
do {
*--p = SkToU8('0' + dec % 10);
dec /= 10;
minDigits--;
} while (dec != 0);
+
while (minDigits > 0) {
*--p = '0';
minDigits--;
}
- if (neg)
- *--p = '-';
+ if (neg) {
+ *--p = '-';
+ }
SkASSERT(p >= buffer);
size_t cp_len = buffer + sizeof(buffer) - p;
memcpy(string, p, cp_len);
@@ -135,8 +136,7 @@
}
#ifdef SK_CAN_USE_FLOAT
-char* SkStrAppendFloat(char string[], float value)
-{
+char* SkStrAppendFloat(char string[], float value) {
// since floats have at most 8 significant digits, we limit our %g to that.
static const char gFormat[] = "%.8g";
// make it 1 larger for the terminating 0
@@ -148,27 +148,24 @@
}
#endif
-char* SkStrAppendFixed(char string[], SkFixed x)
-{
+char* SkStrAppendFixed(char string[], SkFixed x) {
SkDEBUGCODE(char* start = string;)
- if (x < 0)
- {
+ if (x < 0) {
*string++ = '-';
x = -x;
}
unsigned frac = x & 0xFFFF;
x >>= 16;
- if (frac == 0xFFFF) // need to do this to "round up", since 65535/65536 is closer to 1 than to .9999
- {
+ if (frac == 0xFFFF) {
+ // need to do this to "round up", since 65535/65536 is closer to 1 than to .9999
x += 1;
frac = 0;
}
string = SkStrAppendS32(string, x);
// now handle the fractional part (if any)
- if (frac)
- {
+ if (frac) {
static const uint16_t gTens[] = { 1000, 100, 10, 1 };
const uint16_t* tens = gTens;
@@ -189,7 +186,7 @@
return string;
}
-////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
#define kMaxRefCnt_SkString SK_MaxU16
@@ -198,47 +195,43 @@
#define SizeOfRec() (gEmptyRec.data() - (const char*)&gEmptyRec)
-SkString::Rec* SkString::AllocRec(const char text[], U16CPU len)
-{
+SkString::Rec* SkString::AllocRec(const char text[], U16CPU len) {
Rec* rec;
- if (len == 0)
+ if (len == 0) {
rec = const_cast<Rec*>(&gEmptyRec);
- else
- {
+ } else {
// add 1 for terminating 0, then align4 so we can have some slop when growing the string
rec = (Rec*)sk_malloc_throw(SizeOfRec() + SkAlign4(len + 1));
rec->fLength = SkToU16(len);
rec->fRefCnt = 1;
- if (text)
+ if (text) {
memcpy(rec->data(), text, len);
+ }
rec->data()[len] = 0;
}
return rec;
}
-SkString::Rec* SkString::RefRec(Rec* src)
-{
- if (src != &gEmptyRec)
- {
+SkString::Rec* SkString::RefRec(Rec* src) {
+ if (src != &gEmptyRec) {
if (src->fRefCnt == kMaxRefCnt_SkString) {
src = AllocRec(src->data(), src->fLength);
- } else
+ } else {
src->fRefCnt += 1;
+ }
}
return src;
}
#ifdef SK_DEBUG
-void SkString::validate() const
-{
+void SkString::validate() const {
// make sure know one has written over our global
SkASSERT(gEmptyRec.fLength == 0);
SkASSERT(gEmptyRec.fRefCnt == 0);
SkASSERT(gEmptyRec.data()[0] == 0);
- if (fRec != &gEmptyRec)
- {
+ if (fRec != &gEmptyRec) {
SkASSERT(fRec->fLength > 0);
SkASSERT(fRec->fRefCnt > 0);
SkASSERT(fRec->data()[fRec->fLength] == 0);
@@ -247,7 +240,7 @@
}
#endif
-///////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
SkString::SkString() : fRec(const_cast<Rec*>(&gEmptyRec)) {
#ifdef SK_DEBUG
@@ -255,8 +248,7 @@
#endif
}
-SkString::SkString(size_t len)
-{
+SkString::SkString(size_t len) {
SkASSERT(SkToU16(len) == len); // can't handle larger than 64K
fRec = AllocRec(NULL, (U16CPU)len);
@@ -265,8 +257,7 @@
#endif
}
-SkString::SkString(const char text[])
-{
+SkString::SkString(const char text[]) {
size_t len = text ? strlen(text) : 0;
fRec = AllocRec(text, (U16CPU)len);
@@ -275,16 +266,14 @@
#endif
}
-SkString::SkString(const char text[], size_t len)
-{
+SkString::SkString(const char text[], size_t len) {
fRec = AllocRec(text, (U16CPU)len);
#ifdef SK_DEBUG
fStr = fRec->data();
#endif
}
-SkString::SkString(const SkString& src)
-{
+SkString::SkString(const SkString& src) {
src.validate();
fRec = RefRec(src.fRec);
@@ -293,56 +282,49 @@
#endif
}
-SkString::~SkString()
-{
+SkString::~SkString() {
this->validate();
- if (fRec->fLength)
- {
+ if (fRec->fLength) {
SkASSERT(fRec->fRefCnt > 0);
- if (--fRec->fRefCnt == 0)
+ if (--fRec->fRefCnt == 0) {
sk_free(fRec);
+ }
}
}
-bool SkString::equals(const SkString& src) const
-{
+bool SkString::equals(const SkString& src) const {
return fRec == src.fRec || this->equals(src.c_str(), src.size());
}
-bool SkString::equals(const char text[]) const
-{
+bool SkString::equals(const char text[]) const {
return this->equals(text, text ? strlen(text) : 0);
}
-bool SkString::equals(const char text[], size_t len) const
-{
+bool SkString::equals(const char text[], size_t len) const {
SkASSERT(len == 0 || text != NULL);
return fRec->fLength == len && !memcmp(fRec->data(), text, len);
}
-SkString& SkString::operator=(const SkString& src)
-{
+SkString& SkString::operator=(const SkString& src) {
this->validate();
- if (fRec != src.fRec)
- {
+ if (fRec != src.fRec) {
SkString tmp(src);
this->swap(tmp);
}
return *this;
}
-void SkString::reset()
-{
+void SkString::reset() {
this->validate();
- if (fRec->fLength)
- {
+ if (fRec->fLength) {
SkASSERT(fRec->fRefCnt > 0);
- if (--fRec->fRefCnt == 0)
+ if (--fRec->fRefCnt == 0) {
sk_free(fRec);
+ }
}
fRec = const_cast<Rec*>(&gEmptyRec);
@@ -351,14 +333,11 @@
#endif
}
-char* SkString::writable_str()
-{
+char* SkString::writable_str() {
this->validate();
- if (fRec->fLength)
- {
- if (fRec->fRefCnt > 1)
- {
+ if (fRec->fLength) {
+ if (fRec->fRefCnt > 1) {
fRec->fRefCnt -= 1;
fRec = AllocRec(fRec->data(), fRec->fLength);
#ifdef SK_DEBUG
@@ -369,86 +348,79 @@
return fRec->data();
}
-void SkString::set(const char text[])
-{
+void SkString::set(const char text[]) {
this->set(text, text ? strlen(text) : 0);
}
-void SkString::set(const char text[], size_t len)
-{
- if (len == 0)
+void SkString::set(const char text[], size_t len) {
+ if (len == 0) {
this->reset();
- else if (fRec->fRefCnt == 1 && len <= fRec->fLength) // should we resize if len <<<< fLength, to save RAM? (e.g. len < (fLength>>1))
- {
+ } else if (fRec->fRefCnt == 1 && len <= fRec->fLength) {
+ // should we resize if len <<<< fLength, to save RAM? (e.g. len < (fLength>>1))?
// just use less of the buffer without allocating a smaller one
char* p = this->writable_str();
- if (text)
+ if (text) {
memcpy(p, text, len);
+ }
p[len] = 0;
fRec->fLength = SkToU16(len);
- }
- else if (fRec->fRefCnt == 1 && ((unsigned)fRec->fLength >> 2) == (len >> 2))
- {
+ } else if (fRec->fRefCnt == 1 && ((unsigned)fRec->fLength >> 2) == (len >> 2)) {
// we have spare room in the current allocation, so don't alloc a larger one
char* p = this->writable_str();
- if (text)
+ if (text) {
memcpy(p, text, len);
+ }
p[len] = 0;
fRec->fLength = SkToU16(len);
- }
- else
- {
+ } else {
SkString tmp(text, len);
this->swap(tmp);
}
}
-void SkString::setUTF16(const uint16_t src[])
-{
+void SkString::setUTF16(const uint16_t src[]) {
int count = 0;
- while (src[count])
+ while (src[count]) {
count += 1;
+ }
setUTF16(src, count);
}
-void SkString::setUTF16(const uint16_t src[], size_t count)
-{
- if (count == 0)
+void SkString::setUTF16(const uint16_t src[], size_t count) {
+ if (count == 0) {
this->reset();
- else if (count <= fRec->fLength) // should we resize if len <<<< fLength, to save RAM? (e.g. len < (fLength>>1))
- {
- if (count < fRec->fLength)
+ } else if (count <= fRec->fLength) {
+ // should we resize if len <<<< fLength, to save RAM? (e.g. len < (fLength>>1))
+ if (count < fRec->fLength) {
this->resize(count);
+ }
char* p = this->writable_str();
- for (size_t i = 0; i < count; i++)
+ for (size_t i = 0; i < count; i++) {
p[i] = SkToU8(src[i]);
+ }
p[count] = 0;
- }
- else
- {
- SkString tmp(count); // puts a null terminator at the end of the string
- char* p = tmp.writable_str();
+ } else {
+ SkString tmp(count); // puts a null terminator at the end of the string
+ char* p = tmp.writable_str();
- for (size_t i = 0; i < count; i++)
+ for (size_t i = 0; i < count; i++) {
p[i] = SkToU8(src[i]);
-
+ }
this->swap(tmp);
}
}
-void SkString::insert(size_t offset, const char text[])
-{
+void SkString::insert(size_t offset, const char text[]) {
this->insert(offset, text, text ? strlen(text) : 0);
}
-void SkString::insert(size_t offset, const char text[], size_t len)
-{
- if (len)
- {
+void SkString::insert(size_t offset, const char text[], size_t len) {
+ if (len) {
size_t length = fRec->fLength;
- if (offset > length)
+ if (offset > length) {
offset = length;
+ }
/* If we're the only owner, and we have room in our allocation for the insert,
do it in place, rather than allocating a new buffer.
@@ -460,61 +432,59 @@
which is equivalent for testing to (length + 1 + 3) >> 2 == (length + 1 + 3 + len) >> 2
and we can then eliminate the +1+3 since that doesn't affec the answer
*/
- if (fRec->fRefCnt == 1 && (length >> 2) == ((length + len) >> 2))
- {
+ if (fRec->fRefCnt == 1 && (length >> 2) == ((length + len) >> 2)) {
char* dst = this->writable_str();
- if (offset < length)
+ if (offset < length) {
memmove(dst + offset + len, dst + offset, length - offset);
+ }
memcpy(dst + offset, text, len);
dst[length + len] = 0;
fRec->fLength = SkToU16(length + len);
- }
- else
- {
+ } else {
/* Seems we should use realloc here, since that is safe if it fails
(we have the original data), and might be faster than alloc/copy/free.
*/
SkString tmp(fRec->fLength + len);
char* dst = tmp.writable_str();
- if (offset > 0)
+ if (offset > 0) {
memcpy(dst, fRec->data(), offset);
+ }
memcpy(dst + offset, text, len);
- if (offset < fRec->fLength)
- memcpy(dst + offset + len, fRec->data() + offset, fRec->fLength - offset);
+ if (offset < fRec->fLength) {
+ memcpy(dst + offset + len, fRec->data() + offset,
+ fRec->fLength - offset);
+ }
this->swap(tmp);
}
}
}
-void SkString::insertUnichar(size_t offset, SkUnichar uni)
-{
+void SkString::insertUnichar(size_t offset, SkUnichar uni) {
char buffer[kMaxBytesInUTF8Sequence];
size_t len = SkUTF8_FromUnichar(uni, buffer);
- if (len)
+ if (len) {
this->insert(offset, buffer, len);
+ }
}
-void SkString::insertS32(size_t offset, int32_t dec)
-{
+void SkString::insertS32(size_t offset, int32_t dec) {
char buffer[SkStrAppendS32_MaxSize];
char* stop = SkStrAppendS32(buffer, dec);
this->insert(offset, buffer, stop - buffer);
}
-void SkString::insertS64(size_t offset, int64_t dec, int minDigits)
-{
+void SkString::insertS64(size_t offset, int64_t dec, int minDigits) {
char buffer[SkStrAppendS64_MaxSize];
char* stop = SkStrAppendS64(buffer, dec, minDigits);
this->insert(offset, buffer, stop - buffer);
}
-void SkString::insertHex(size_t offset, uint32_t hex, int minDigits)
-{
+void SkString::insertHex(size_t offset, uint32_t hex, int minDigits) {
minDigits = SkPin32(minDigits, 0, 8);
static const char gHex[] = "0123456789ABCDEF";
@@ -527,15 +497,16 @@
hex >>= 4;
minDigits -= 1;
} while (hex != 0);
- while (--minDigits >= 0)
+
+ while (--minDigits >= 0) {
*--p = '0';
+ }
SkASSERT(p >= buffer);
this->insert(offset, p, buffer + sizeof(buffer) - p);
}
-void SkString::insertScalar(size_t offset, SkScalar value)
-{
+void SkString::insertScalar(size_t offset, SkScalar value) {
char buffer[SkStrAppendScalar_MaxSize];
char* stop = SkStrAppendScalar(buffer, value);
this->insert(offset, buffer, stop - buffer);
@@ -566,30 +537,26 @@
///////////////////////////////////////////////////////////////////////////////
-void SkString::remove(size_t offset, size_t length)
-{
+void SkString::remove(size_t offset, size_t length) {
size_t size = this->size();
- if (offset < size)
- {
- if (offset + length > size)
+ if (offset < size) {
+ if (offset + length > size) {
length = size - offset;
- if (length > 0)
- {
+ }
+ if (length > 0) {
SkASSERT(size > length);
SkString tmp(size - length);
char* dst = tmp.writable_str();
const char* src = this->c_str();
- if (offset)
- {
+ if (offset) {
SkASSERT(offset <= tmp.size());
memcpy(dst, src, offset);
}
size_t tail = size - offset - length;
SkASSERT((int32_t)tail >= 0);
- if (tail)
- {
+ if (tail) {
// SkASSERT(offset + length <= tmp.size());
memcpy(dst + offset, src + offset + length, tail);
}
@@ -599,8 +566,7 @@
}
}
-void SkString::swap(SkString& other)
-{
+void SkString::swap(SkString& other) {
this->validate();
other.validate();
@@ -610,7 +576,7 @@
#endif
}
-/////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
SkAutoUCS2::SkAutoUCS2(const char utf8[]) {
size_t len = strlen(utf8);