code style

git-svn-id: http://skia.googlecode.com/svn/trunk@1095 2bbb7eff-a529-9590-31e7-b0007b416f81

1 files changed, 119 insertions, 153 deletions

diff --git a/src/core/SkString.cpp b/src/core/SkString.cpp
index 8a1591a86e..49182ea77c 100644
--- a/src/core/SkString.cpp
+++ b/src/core/SkString.cpp
@@ -42,15 +42,13 @@ static const size_t kBufferSize = 256;
 
 ///////////////////////////////////////////////////////////////////////////////
 
-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 @@ bool SkStrEndsWith(const char string[], const char suffix[])
             !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 @@ char* SkStrAppendS64(char string[], int64_t dec, int minDigits)
         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 @@ char* SkStrAppendS64(char string[], int64_t dec, int minDigits)
 }
 
 #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 @@ char* SkStrAppendFloat(char string[], float value)
 }
 #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 @@ char* SkStrAppendFixed(char string[], SkFixed x)
     return string;
 }
 
-////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
 
 #define kMaxRefCnt_SkString     SK_MaxU16
 
@@ -198,47 +195,43 @@ const SkString::Rec SkString::gEmptyRec = { 0, 0, 0 };
 
 #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 @@ void SkString::validate() const
 }
 #endif
 
-///////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
 
 SkString::SkString() : fRec(const_cast<Rec*>(&gEmptyRec)) {
 #ifdef SK_DEBUG
@@ -255,8 +248,7 @@ SkString::SkString() : fRec(const_cast<Rec*>(&gEmptyRec)) {
 #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 @@ SkString::SkString(size_t len)
 #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 @@ SkString::SkString(const char text[])
 #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 @@ SkString::SkString(const SkString& src)
 #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 @@ void SkString::reset()
 #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 @@ char* SkString::writable_str()
     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 @@ void SkString::insert(size_t offset, const char text[], size_t len)
             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 @@ void SkString::insertHex(size_t offset, uint32_t hex, int minDigits)
         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::prependf(const char format[], ...) {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-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::remove(size_t offset, size_t length)
     }
 }
 
-void SkString::swap(SkString& other)
-{
+void SkString::swap(SkString& other) {
     this->validate();
     other.validate();
 
@@ -610,7 +576,7 @@ void SkString::swap(SkString& other)
 #endif
 }
 
-/////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
 
 SkAutoUCS2::SkAutoUCS2(const char utf8[]) {
     size_t len = strlen(utf8);