Apply clang-format update to repo (#1154)

Commit bc6c183 introduced a bunch of discrepancies between what files
look like in the repo and what clang-format says they should look like.
However, there were already a few discrepancies prior to that. Most of
these discrepancies seemed to be unintentional, but a few of them were
load-bearing (e.g., a #include that violated header ordering needing
something to have been #defined by a 'later' #include.)

I opted to take what I hope is a relatively smooth-brained approach: I
reverted the .clang-format change, ran clang-format on the whole repo,
reapplied the .clang-format change, reran clang-format again, and then
reverted the commit that contained the first run. Thus the full effect
of this PR should only be to apply the changed formatting rules to the
repo, and from skimming the results, this seems to be the case.

My work can be checked by applying the short, manual commits, and then
rerunning the command listed in the autogenerated commits (those whose
messages I have prefixed auto:) and seeing if your results agree.

It might be that the other diffs should be fixed at some point but I'm
leaving that aside for now.

fd '\.c(c|pp)?$' --print0| xargs -0 clang-format -i

libc/str/a64l.c

@@ -46,7 +46,8 @@ long a64l(const char *s) {
   uint32_t i, v, x;
   for (x = i = 0; i < 6; ++i) {
     v = kBase64i[s[i] & 0xff];
-    if (v == -1) break;
+    if (v == -1)
+      break;
     x |= v << (i * 6);
   }
   return (int32_t)x;

libc/str/blake2.c

@@ -117,7 +117,8 @@ int BLAKE2B256_Update(struct Blake2b *b2b, const void *in_data, size_t len) {
   if (todo > len) {
     todo = len;
   }
-  if (todo) memcpy(&b2b->block.bytes[b2b->block_used], data, todo);
+  if (todo)
+    memcpy(&b2b->block.bytes[b2b->block_used], data, todo);
   b2b->block_used += todo;
   data += todo;
   len -= todo;
@@ -136,7 +137,8 @@ int BLAKE2B256_Update(struct Blake2b *b2b, const void *in_data, size_t len) {
     data += BLAKE2B_CBLOCK;
     len -= BLAKE2B_CBLOCK;
   }
-  if (len) memcpy(b2b->block.bytes, data, len);
+  if (len)
+    memcpy(b2b->block.bytes, data, len);
   b2b->block_used = len;
   return 0;
 }

libc/str/c16rtomb.c

@@ -34,11 +34,13 @@ __static_yoink("musl_libc_notice");
 
 size_t c16rtomb(char *restrict s, char16_t c16, mbstate_t *restrict ps) {
   static unsigned internal_state;
-  if (!ps) ps = (void *)&internal_state;
+  if (!ps)
+    ps = (void *)&internal_state;
   unsigned *x = (unsigned *)ps;
   wchar_t wc;
   if (!s) {
-    if (*x) goto ilseq;
+    if (*x)
+      goto ilseq;
     return 1;
   }
   if (!*x && c16 - 0xd800u < 0x400) {

libc/str/compareslices.c

@@ -21,8 +21,11 @@
 
 int CompareSlices(const char *a, size_t n, const char *b, size_t m) {
   int c;
-  if ((c = memcmp(a, b, MIN(n, m)))) return c;
-  if (n < m) return -1;
-  if (n > m) return +1;
+  if ((c = memcmp(a, b, MIN(n, m))))
+    return c;
+  if (n < m)
+    return -1;
+  if (n > m)
+    return +1;
   return 0;
 }

libc/str/compareslicescase.c

@@ -21,8 +21,11 @@
 
 int CompareSlicesCase(const char *a, size_t n, const char *b, size_t m) {
   int c;
-  if ((c = memcasecmp(a, b, MIN(n, m)))) return c;
-  if (n < m) return -1;
-  if (n > m) return +1;
+  if ((c = memcasecmp(a, b, MIN(n, m))))
+    return c;
+  if (n < m)
+    return -1;
+  if (n > m)
+    return +1;
   return 0;
 }

libc/str/endswith.c

@@ -28,6 +28,7 @@ bool32 endswith(const char *s, const char *suffix) {
   size_t n, m;
   n = strlen(s);
   m = strlen(suffix);
-  if (m > n) return false;
+  if (m > n)
+    return false;
   return !memcmp(s + n - m, suffix, m);
 }

libc/str/endswith16.c

@@ -28,6 +28,7 @@ bool32 endswith16(const char16_t *s, const char16_t *suffix) {
   size_t n, m;
   n = strlen16(s);
   m = strlen16(suffix);
-  if (m > n) return false;
+  if (m > n)
+    return false;
   return memcmp(s + n - m, suffix, m * sizeof(char16_t)) == 0;
 }

libc/str/getzipcfiletimestamps.c

@@ -36,9 +36,12 @@ void GetZipCfileTimestamps(const uint8_t *cf, struct timespec *mtim,
                            struct timespec *atim, struct timespec *ctim,
                            int gmtoff) {
   const uint8_t *p, *pe;
-  if (mtim) *mtim = (struct timespec){0};
-  if (atim) *atim = (struct timespec){0};
-  if (ctim) *ctim = (struct timespec){0};
+  if (mtim)
+    *mtim = (struct timespec){0};
+  if (atim)
+    *atim = (struct timespec){0};
+  if (ctim)
+    *ctim = (struct timespec){0};
   for (p = ZIP_CFILE_EXTRA(cf), pe = p + ZIP_CFILE_EXTRASIZE(cf); p + 4 <= pe;
        p += ZIP_EXTRA_SIZE(p)) {
     if (ZIP_EXTRA_HEADERID(p) == kZipExtraNtfs &&
@@ -88,8 +91,10 @@ void GetZipCfileTimestamps(const uint8_t *cf, struct timespec *mtim,
        p += ZIP_EXTRA_SIZE(p)) {
     if (ZIP_EXTRA_HEADERID(p) == kZipExtraUnix &&
         ZIP_EXTRA_CONTENTSIZE(p) >= 4 + 4) {
-      if (atim) atim->tv_sec = (int32_t)ZIP_READ32(ZIP_EXTRA_CONTENT(p) + 0);
-      if (mtim) mtim->tv_sec = (int32_t)ZIP_READ32(ZIP_EXTRA_CONTENT(p) + 4);
+      if (atim)
+        atim->tv_sec = (int32_t)ZIP_READ32(ZIP_EXTRA_CONTENT(p) + 0);
+      if (mtim)
+        mtim->tv_sec = (int32_t)ZIP_READ32(ZIP_EXTRA_CONTENT(p) + 4);
       return;
     }
   }

libc/str/getzipeocd.c

@@ -83,6 +83,7 @@ void *GetZipEocd(const void *f, size_t n, int *e) {
       return (void *)(p + i);
     }
   } while (i > 0 && i-- + 0x10000 + 0x1000 >= n);
-  if (e) *e = err;
+  if (e)
+    *e = err;
   return 0;
 }

libc/str/highwayhash64.c

@@ -137,7 +137,8 @@ static void PermuteAndUpdate(HighwayHashState *state) {
 
 static uint64_t HighwayHashFinalize64(HighwayHashState *state) {
   int i;
-  for (i = 0; i < 4; i++) PermuteAndUpdate(state);
+  for (i = 0; i < 4; i++)
+    PermuteAndUpdate(state);
   return state->v0[0] + state->v1[0] + state->mul0[0] + state->mul1[0];
 }
 
@@ -148,7 +149,8 @@ static void ProcessAll(const uint8_t *data, size_t size, const uint64_t key[4],
   for (i = 0; i + 32 <= size; i += 32) {
     HighwayHashUpdatePacket(data + i, state);
   }
-  if ((size & 31) != 0) HighwayHashUpdateRemainder(data + i, size & 31, state);
+  if ((size & 31) != 0)
+    HighwayHashUpdateRemainder(data + i, size & 31, state);
 }
 
 /**

libc/str/intsort.c

@@ -39,9 +39,12 @@ static void IntSort(int *A, long n) {
     InsertionSort(A, n);
   } else {
     for (p = A[n >> 1], i = 0, j = n - 1;; i++, j--) {
-      while (A[i] < p) i++;
-      while (A[j] > p) j--;
-      if (i >= j) break;
+      while (A[i] < p)
+        i++;
+      while (A[j] > p)
+        j--;
+      if (i >= j)
+        break;
       t = A[i];
       A[i] = A[j];
       A[j] = t;

libc/str/isutf8.c

@@ -51,7 +51,8 @@ static const char kUtf8Dispatch[] = {
 bool32 isutf8(const void *data, size_t size) {
   long c;
   const char *p, *e;
-  if (size == -1) size = data ? strlen(data) : 0;
+  if (size == -1)
+    size = data ? strlen(data) : 0;
   p = data;
   e = p + size;
   while (p < e) {
@@ -74,8 +75,10 @@ bool32 isutf8(const void *data, size_t size) {
       }
     }
 #endif
-    if (LIKELY((c = *p++ & 255) < 0200)) continue;
-    if (UNLIKELY(c < 0300)) return false;
+    if (LIKELY((c = *p++ & 255) < 0200))
+      continue;
+    if (UNLIKELY(c < 0300))
+      return false;
     switch (kUtf8Dispatch[c - 0300]) {
       case 0:
         return false;

libc/str/iswlower.c

@@ -25,7 +25,8 @@ int iswlower(wint_t c) {
   if (c < 0200) {
     return 'a' <= c && c <= 'z';
   } else {
-    if (towupper(c) != c) return 1;
+    if (towupper(c) != c)
+      return 1;
     switch (c) {
       case 0x00df:  /* ß Watin */
       case 0x0138:  /* ĸ Watin-A */

libc/str/iswupper.c

@@ -25,7 +25,8 @@ int iswupper(wint_t c) {
   if (c < 0200) {
     return 'A' <= c && c <= 'Z';
   } else {
-    if (towlower(c) != c) return 1;
+    if (towlower(c) != c)
+      return 1;
     switch (c) {
       case 0x03d2:  /* ϒ Greek */
       case 0x03d3:  /* ϓ Greek */

libc/str/joinpaths.c

@@ -41,8 +41,10 @@
 char *__join_paths(char *buf, size_t size, const char *path,
                    const char *other) {
   size_t pathlen, otherlen;
-  if (!other) return (char *)path;
-  if (!path) return (char *)other;
+  if (!other)
+    return (char *)path;
+  if (!path)
+    return (char *)other;
   pathlen = strlen(path);
   if (!pathlen || *other == '/') {
     return (/*unconst*/ char *)other;

libc/str/longsort.c

@@ -38,9 +38,12 @@ static void LongSort(long *A, long n) {
     InsertionSort(A, n);
   } else {
     for (p = A[n >> 1], i = 0, j = n - 1;; i++, j--) {
-      while (A[i] < p) i++;
-      while (A[j] > p) j--;
-      if (i >= j) break;
+      while (A[i] < p)
+        i++;
+      while (A[j] > p)
+        j--;
+      if (i >= j)
+        break;
       t = A[i];
       A[i] = A[j];
       A[j] = t;

libc/str/lz4cpy.c

@@ -45,7 +45,8 @@ textstartup void *lz4cpy(void *dest, const void *blockdata, size_t blocksize) {
       } while (*ip++ == 255);
     }
     repmovsb((void **)&op, (const void **)&ip, length);
-    if (ip >= ipe) break;
+    if (ip >= ipe)
+      break;
     offset = READ16LE(ip);
     matchlen = token & fifteen;
     ip += 2;

libc/str/lz4len.c

@@ -41,7 +41,8 @@ size_t lz4len(const void *blockdata, size_t blocksize) {
     }
     ip += length;
     unpacklen += length;
-    if (ip >= ipe) break;
+    if (ip >= ipe)
+      break;
     matchlen = token & fifteen;
     ip += 2;
     if (matchlen == fifteen) {

libc/str/mbrlen.c

@@ -20,6 +20,7 @@
 
 size_t mbrlen(const char *s, size_t n, mbstate_t *t) {
   static mbstate_t ss;
-  if (!t) t = &ss;
+  if (!t)
+    t = &ss;
   return mbrtowc(0, s, n, t);
 }

libc/str/mbrtoc16.c

@@ -33,13 +33,16 @@ __static_yoink("musl_libc_notice");
 
 size_t mbrtoc16(char16_t *pc16, const char *s, size_t n, mbstate_t *ps) {
   static unsigned internal_state;
-  if (!ps) ps = (void *)&internal_state;
+  if (!ps)
+    ps = (void *)&internal_state;
   unsigned *pending = (unsigned *)ps;
-  if (!s) return mbrtoc16(0, "", 1, ps);
+  if (!s)
+    return mbrtoc16(0, "", 1, ps);
   /* mbrtowc states for partial UTF-8 characters have the high bit set;
    * we use nonzero states without high bit for pending surrogates. */
   if ((int)*pending > 0) {
-    if (pc16) *pc16 = *pending;
+    if (pc16)
+      *pc16 = *pending;
     *pending = 0;
     return -3;
   }
@@ -50,7 +53,8 @@ size_t mbrtoc16(char16_t *pc16, const char *s, size_t n, mbstate_t *ps) {
       *pending = (wc & 0x3ff) + 0xdc00;
       wc = 0xd7c0 + (wc >> 10);
     }
-    if (pc16) *pc16 = wc;
+    if (pc16)
+      *pc16 = wc;
   }
   return ret;
 }

libc/str/mbrtoc32.c

@@ -33,10 +33,13 @@ __static_yoink("musl_libc_notice");
 
 size_t mbrtoc32(char32_t *pc32, const char *s, size_t n, mbstate_t *ps) {
   static unsigned internal_state;
-  if (!ps) ps = (void *)&internal_state;
-  if (!s) return mbrtoc32(0, "", 1, ps);
+  if (!ps)
+    ps = (void *)&internal_state;
+  if (!s)
+    return mbrtoc32(0, "", 1, ps);
   wchar_t wc;
   size_t ret = mbrtowc(&wc, s, n, ps);
-  if (ret <= 4 && pc32) *pc32 = wc;
+  if (ret <= 4 && pc32)
+    *pc32 = wc;
   return ret;
 }

libc/str/mbrtowc.c

@@ -39,26 +39,33 @@ size_t mbrtowc(wchar_t *wc, const char *src, size_t n, mbstate_t *st) {
   const unsigned char *s = (const void *)src;
   const unsigned N = n;
   wchar_t dummy;
-  if (!st) st = (void *)&internal_state;
+  if (!st)
+    st = (void *)&internal_state;
   c = *(unsigned *)st;
   if (!s) {
-    if (c) goto ilseq;
+    if (c)
+      goto ilseq;
     return 0;
   } else if (!wc) {
     wc = &dummy;
   }
-  if (!n) return -2;
+  if (!n)
+    return -2;
   if (!c) {
-    if (*s < 0x80) return !!(*wc = *s);
-    if (MB_CUR_MAX == 1) return (*wc = CODEUNIT(*s)), 1;
-    if (*s - SA > SB - SA) goto ilseq;
+    if (*s < 0x80)
+      return !!(*wc = *s);
+    if (MB_CUR_MAX == 1)
+      return (*wc = CODEUNIT(*s)), 1;
+    if (*s - SA > SB - SA)
+      goto ilseq;
     wut = *s++ - SA;
     wut = MAX(0, MIN(ARRAYLEN(kMbBittab) - 1, wut));
     c = kMbBittab[wut];
     n--;
   }
   if (n) {
-    if (OOB(c, *s)) goto ilseq;
+    if (OOB(c, *s))
+      goto ilseq;
   loop:
     c = c << 6 | (*s++ - 0x80);
     n--;
@@ -68,7 +75,8 @@ size_t mbrtowc(wchar_t *wc, const char *src, size_t n, mbstate_t *st) {
       return N - n;
     }
     if (n) {
-      if (*s - 0x80u >= 0x40) goto ilseq;
+      if (*s - 0x80u >= 0x40)
+        goto ilseq;
       goto loop;
     }
   }

libc/str/mbsnrtowcs.c

@@ -47,7 +47,8 @@ size_t mbsnrtowcs(wchar_t *wcs, const char **src, size_t n, size_t wn,
    * that mbsrtowcs never reads more than n input bytes. thus
    * we can use mbsrtowcs as long as it's practical.. */
   while (s && wn && ((n2 = n / 4) >= wn || n2 > 32)) {
-    if (n2 >= wn) n2 = wn;
+    if (n2 >= wn)
+      n2 = wn;
     tmp_s = s;
     l = mbsrtowcs(ws, &s, n2, st);
     if (!(l + 1)) {
@@ -85,6 +86,7 @@ size_t mbsnrtowcs(wchar_t *wcs, const char **src, size_t n, size_t wn,
       wn--;
       cnt++;
     }
-  if (wcs) *src = s;
+  if (wcs)
+    *src = s;
   return cnt;
 }

libc/str/mbsrtowcs.c

@@ -45,13 +45,15 @@ size_t mbsrtowcs(wchar_t *ws, const char **src, size_t wn, mbstate_t *st) {
     }
   }
   if (MB_CUR_MAX == 1) {
-    if (!ws) return strlen((const char *)s);
+    if (!ws)
+      return strlen((const char *)s);
     for (;;) {
       if (!wn) {
         *src = (const void *)s;
         return wn0;
       }
-      if (!*s) break;
+      if (!*s)
+        break;
       c = *s++;
       *ws++ = CODEUNIT(c);
       wn--;
@@ -67,7 +69,8 @@ size_t mbsrtowcs(wchar_t *ws, const char **src, size_t wn, mbstate_t *st) {
         wn--;
         continue;
       }
-      if (*s - SA > SB - SA) break;
+      if (*s - SA > SB - SA)
+        break;
       c = kMbBittab[*s++ - SA];
     resume0:
       if (OOB(c, *s)) {
@@ -103,7 +106,8 @@ size_t mbsrtowcs(wchar_t *ws, const char **src, size_t wn, mbstate_t *st) {
         wn--;
         continue;
       }
-      if (*s - SA > SB - SA) break;
+      if (*s - SA > SB - SA)
+        break;
       c = kMbBittab[*s++ - SA];
     resume:
       if (OOB(c, *s)) {
@@ -137,6 +141,7 @@ size_t mbsrtowcs(wchar_t *ws, const char **src, size_t wn, mbstate_t *st) {
     return wn0 - wn;
   }
   errno = EILSEQ;
-  if (ws) *src = (const void *)s;
+  if (ws)
+    *src = (const void *)s;
   return -1;
 }

libc/str/mbtowc.c

@@ -35,30 +35,40 @@ int mbtowc(wchar_t *restrict wc, const char *restrict src, size_t n) {
   unsigned c;
   const unsigned char *s = (const void *)src;
   wchar_t dummy;
-  if (!s) return 0;
-  if (!n) goto ilseq;
-  if (!wc) wc = &dummy;
-  if (*s < 0x80) return !!(*wc = *s);
-  if (MB_CUR_MAX == 1) return (*wc = CODEUNIT(*s)), 1;
-  if (*s - SA > SB - SA) goto ilseq;
+  if (!s)
+    return 0;
+  if (!n)
+    goto ilseq;
+  if (!wc)
+    wc = &dummy;
+  if (*s < 0x80)
+    return !!(*wc = *s);
+  if (MB_CUR_MAX == 1)
+    return (*wc = CODEUNIT(*s)), 1;
+  if (*s - SA > SB - SA)
+    goto ilseq;
   c = kMbBittab[*s++ - SA];
   /* Avoid excessive checks against n: If shifting the state n-1
    * times does not clear the high bit, then the value of n is
    * insufficient to read a character */
-  if (n < 4 && ((c << (6 * n - 6)) & (1U << 31))) goto ilseq;
-  if (OOB(c, *s)) goto ilseq;
+  if (n < 4 && ((c << (6 * n - 6)) & (1U << 31)))
+    goto ilseq;
+  if (OOB(c, *s))
+    goto ilseq;
   c = c << 6 | (*s++ - 0x80);
   if (!(c & (1U << 31))) {
     *wc = c;
     return 2;
   }
-  if (*s - 0x80u >= 0x40) goto ilseq;
+  if (*s - 0x80u >= 0x40)
+    goto ilseq;
   c = c << 6 | (*s++ - 0x80);
   if (!(c & (1U << 31))) {
     *wc = c;
     return 3;
   }
-  if (*s - 0x80u >= 0x40) goto ilseq;
+  if (*s - 0x80u >= 0x40)
+    goto ilseq;
   *wc = c << 6 | (*s++ - 0x80);
   return 4;
 ilseq:

libc/str/memmem.c

@@ -39,8 +39,10 @@ __vex void *memmem(const void *haystack, size_t haystacklen, const void *needle,
   const xmm_t *v;
   unsigned i, k, m;
   const char *p, *q, *e;
-  if (!needlelen) return (void *)haystack;
-  if (UNLIKELY(needlelen > haystacklen)) return 0;
+  if (!needlelen)
+    return (void *)haystack;
+  if (UNLIKELY(needlelen > haystacklen))
+    return 0;
   q = needle;
   c = *q;
   n = (xmm_t){c, c, c, c, c, c, c, c, c, c, c, c, c, c, c, c};
@@ -54,29 +56,38 @@ __vex void *memmem(const void *haystack, size_t haystacklen, const void *needle,
   for (;;) {
     while (!m) {
       ++v;
-      if ((const char *)v >= e) return 0;
+      if ((const char *)v >= e)
+        return 0;
       m = __builtin_ia32_pmovmskb128(*v == n);
     }
     do {
       k = __builtin_ctzl(m);
       p = (const char *)v + k;
-      if (UNLIKELY(p + needlelen > e)) return 0;
+      if (UNLIKELY(p + needlelen > e))
+        return 0;
       for (i = 1;; ++i) {
-        if (i == needlelen) return (/*unconst*/ char *)p;
-        if (p[i] != q[i]) break;
+        if (i == needlelen)
+          return (/*unconst*/ char *)p;
+        if (p[i] != q[i])
+          break;
       }
       m &= ~(1 << k);
     } while (m);
   }
 #else
   size_t i, j;
-  if (!needlelen) return (void *)haystack;
-  if (needlelen > haystacklen) return 0;
+  if (!needlelen)
+    return (void *)haystack;
+  if (needlelen > haystacklen)
+    return 0;
   for (i = 0; i < haystacklen; ++i) {
     for (j = 0;; ++j) {
-      if (j == needlelen) return (/*unconst*/ char *)haystack + i;
-      if (i + j == haystacklen) break;
-      if (((char *)haystack)[i + j] != ((char *)needle)[j]) break;
+      if (j == needlelen)
+        return (/*unconst*/ char *)haystack + i;
+      if (i + j == haystacklen)
+        break;
+      if (((char *)haystack)[i + j] != ((char *)needle)[j])
+        break;
     }
   }
   return 0;

libc/str/rawmemchr.c

@@ -81,7 +81,8 @@ __vex void *rawmemchr(const void *s, int c) {
   c &= 255;
   v = 0x0101010101010101ul * c;
   for (; (uintptr_t)p & 7; ++p) {
-    if (*p == c) return (void *)p;
+    if (*p == c)
+      return (void *)p;
   }
   for (;; p += 8) {
     w = UncheckedAlignedRead64(p);

libc/str/smoothsort.c

@@ -159,7 +159,8 @@ static void SmoothSort(struct SmoothSort *s, void *base, size_t nel,
   size_t p[2] = {1, 0};
   int pshift = 1;
   int trail;
-  if (!size) return;
+  if (!size)
+    return;
   head = base;
   high = head + size - width;
   // precompute Leonardo numbers, scaled by element width

libc/str/startswith.c

@@ -26,8 +26,11 @@
  */
 bool32 startswith(const char *s, const char *prefix) {
   for (;;) {
-    if (!*prefix) return true;
-    if (!*s) return false;
-    if (*s++ != *prefix++) return false;
+    if (!*prefix)
+      return true;
+    if (!*s)
+      return false;
+    if (*s++ != *prefix++)
+      return false;
   }
 }

libc/str/startswith16.c

@@ -26,8 +26,11 @@
  */
 bool32 startswith16(const char16_t *s, const char16_t *prefix) {
   for (;;) {
-    if (!*prefix) return true;
-    if (!*s) return false;
-    if (*s++ != *prefix++) return false;
+    if (!*prefix)
+      return true;
+    if (!*s)
+      return false;
+    if (*s++ != *prefix++)
+      return false;
   }
 }

libc/str/startswithi.c

@@ -24,8 +24,11 @@
  */
 bool32 startswithi(const char *s, const char *prefix) {
   for (;;) {
-    if (!*prefix) return true;
-    if (!*s) return false;
-    if (kToLower[*s++ & 255] != kToLower[*prefix++ & 255]) return false;
+    if (!*prefix)
+      return true;
+    if (!*s)
+      return false;
+    if (kToLower[*s++ & 255] != kToLower[*prefix++ & 255])
+      return false;
   }
 }

libc/str/stpncpy.c

@@ -38,8 +38,10 @@ char *stpncpy(char *dst, const char *src, size_t dstlen) {
   size_t srclen, cpylen, zerlen;
   srclen = strlen(src);
   cpylen = MIN(srclen, dstlen);
-  if (cpylen) memcpy(dst, src, cpylen);
+  if (cpylen)
+    memcpy(dst, src, cpylen);
   zerlen = dstlen - cpylen;
-  if (zerlen) bzero(dst + cpylen, zerlen);
+  if (zerlen)
+    bzero(dst + cpylen, zerlen);
   return dst + cpylen;
 }

libc/str/strcasecmp.c

@@ -32,7 +32,8 @@ int strcasecmp(const char *a, const char *b) {
   int x, y;
   size_t i = 0;
   uint64_t v, w;
-  if (a == b) return 0;
+  if (a == b)
+    return 0;
   if (((uintptr_t)a & 7) == ((uintptr_t)b & 7)) {
     for (; (uintptr_t)(a + i) & 7; ++i) {
     CheckEm:
@@ -50,7 +51,8 @@ int strcasecmp(const char *a, const char *b) {
       }
     }
   } else {
-    while ((x = kToLower[a[i] & 255]) == (y = kToLower[b[i] & 255]) && y) ++i;
+    while ((x = kToLower[a[i] & 255]) == (y = kToLower[b[i] & 255]) && y)
+      ++i;
     return x - y;
   }
 }

libc/str/strcasecmp16.c

@@ -29,6 +29,7 @@
 int strcasecmp16(const char16_t *l, const char16_t *r) {
   int x, y;
   size_t i = 0;
-  while ((x = towlower(l[i])) == (y = towlower(r[i])) && r[i]) ++i;
+  while ((x = towlower(l[i])) == (y = towlower(r[i])) && r[i])
+    ++i;
   return x - y;
 }

libc/str/strcasestr.c

@@ -41,7 +41,8 @@ __vex char *strcasestr(const char *haystack, const char *needle) {
   unsigned k, m;
   const xmm_t *p;
   xmm_t v, n1, n2, z = {0};
-  if (haystack == needle || !*needle) return (char *)haystack;
+  if (haystack == needle || !*needle)
+    return (char *)haystack;
   c = *needle;
   n1 = (xmm_t){c, c, c, c, c, c, c, c, c, c, c, c, c, c, c, c};
   c = kToLower[c & 255];
@@ -59,23 +60,32 @@ __vex char *strcasestr(const char *haystack, const char *needle) {
     }
     haystack = (const char *)p + __builtin_ctzl(m);
     for (i = 0;; ++i) {
-      if (!needle[i]) return (/*unconst*/ char *)haystack;
-      if (!haystack[i]) break;
-      if (kToLower[needle[i] & 255] != kToLower[haystack[i] & 255]) break;
+      if (!needle[i])
+        return (/*unconst*/ char *)haystack;
+      if (!haystack[i])
+        break;
+      if (kToLower[needle[i] & 255] != kToLower[haystack[i] & 255])
+        break;
     }
-    if (!*haystack++) break;
+    if (!*haystack++)
+      break;
   }
   return 0;
 #else
   size_t i;
-  if (haystack == needle || !*needle) return (void *)haystack;
+  if (haystack == needle || !*needle)
+    return (void *)haystack;
   for (;;) {
     for (i = 0;; ++i) {
-      if (!needle[i]) return (/*unconst*/ char *)haystack;
-      if (!haystack[i]) break;
-      if (kToLower[needle[i] & 255] != kToLower[haystack[i] & 255]) break;
+      if (!needle[i])
+        return (/*unconst*/ char *)haystack;
+      if (!haystack[i])
+        break;
+      if (kToLower[needle[i] & 255] != kToLower[haystack[i] & 255])
+        break;
     }
-    if (!*haystack++) break;
+    if (!*haystack++)
+      break;
   }
   return 0;
 #endif

libc/str/strchr16.c

@@ -23,7 +23,9 @@
  */
 char16_t *strchr16(const char16_t *s, int c) {
   for (;; ++s) {
-    if ((*s & 65535) == (c & 65535)) return (char16_t *)s;
-    if (!*s) return (char16_t *)0;
+    if ((*s & 65535) == (c & 65535))
+      return (char16_t *)s;
+    if (!*s)
+      return (char16_t *)0;
   }
 }

libc/str/strchrnul16.c

@@ -23,7 +23,9 @@
  */
 char16_t *strchrnul16(const char16_t *s, int c) {
   for (;; ++s) {
-    if ((*s & 65535) == (c & 65535)) return (char16_t *)s;
-    if (!*s) return (char16_t *)s;
+    if ((*s & 65535) == (c & 65535))
+      return (char16_t *)s;
+    if (!*s)
+      return (char16_t *)s;
   }
 }

libc/str/strcmp16.c

@@ -28,6 +28,7 @@
  */
 int strcmp16(const char16_t *l, const char16_t *r) {
   size_t i = 0;
-  while (l[i] == r[i] && r[i]) ++i;
+  while (l[i] == r[i] && r[i])
+    ++i;
   return l[i] - r[i];
 }

libc/str/strlen16.c

@@ -35,12 +35,14 @@ __vex size_t strlen16(const char16_t *s) {
   unsigned m, k = (uintptr_t)s & 15;
   const xmm_t *p = (const xmm_t *)((uintptr_t)s & -16);
   m = __builtin_ia32_pmovmskb128(*p == z) >> k << k;
-  while (!m) m = __builtin_ia32_pmovmskb128(*++p == z);
+  while (!m)
+    m = __builtin_ia32_pmovmskb128(*++p == z);
   n = (const char16_t *)p + (__builtin_ctzl(m) >> 1) - s;
   return n;
 #else
   size_t n = 0;
-  while (*s++) ++n;
+  while (*s++)
+    ++n;
   return n;
 #endif
 }

libc/str/strncasecmp.c

@@ -30,7 +30,8 @@
 int strncasecmp(const char *a, const char *b, size_t n) {
   int x, y;
   size_t i = 0;
-  if (!n-- || a == b) return 0;
+  if (!n-- || a == b)
+    return 0;
   while ((x = kToLower[a[i] & 0xff]) == (y = kToLower[b[i] & 0xff]) && b[i] &&
          i < n) {
     ++i;

libc/str/strncasecmp16.c

@@ -29,7 +29,9 @@
 int strncasecmp16(const char16_t *a, const char16_t *b, size_t n) {
   int x, y;
   size_t i = 0;
-  if (!n-- || a == b) return 0;
-  while ((x = towlower(a[i])) == (y = towlower(b[i])) && b[i] && i < n) ++i;
+  if (!n-- || a == b)
+    return 0;
+  while ((x = towlower(a[i])) == (y = towlower(b[i])) && b[i] && i < n)
+    ++i;
   return x - y;
 }

libc/str/strncat16.c

@@ -33,7 +33,8 @@ char16_t *strncat16(char16_t *d, const char16_t *s, size_t n) {
   size_t i;
   char16_t *r = d;
   d += strlen16(d);
-  for (i = 0; i < n && s[i]; ++i) d[i] = s[i];
+  for (i = 0; i < n && s[i]; ++i)
+    d[i] = s[i];
   d[i] = 0;
   return r;
 }

libc/str/strncmp16.c

@@ -28,7 +28,9 @@
  */
 int strncmp16(const char16_t *a, const char16_t *b, size_t n) {
   size_t i = 0;
-  if (!n-- || a == b) return 0;
-  while (i < n && a[i] == b[i] && b[i]) ++i;
+  if (!n-- || a == b)
+    return 0;
+  while (i < n && a[i] == b[i] && b[i])
+    ++i;
   return a[i] - b[i];
 }

libc/str/strncpy.c

@@ -38,8 +38,10 @@ char *strncpy(char *dst, const char *src, size_t dstlen) {
   size_t srclen, cpylen, zerlen;
   srclen = strlen(src);
   cpylen = MIN(srclen, dstlen);
-  if (cpylen) memcpy(dst, src, cpylen);
+  if (cpylen)
+    memcpy(dst, src, cpylen);
   zerlen = dstlen - cpylen;
-  if (zerlen) bzero(dst + cpylen, zerlen);
+  if (zerlen)
+    bzero(dst + cpylen, zerlen);
   return dst;
 }

libc/str/strnlen16.c

@@ -30,7 +30,8 @@
 size_t strnlen16(const char16_t *s, size_t n) {
   size_t i;
   for (i = 0;; ++i) {
-    if (i == n || !s[i]) break;
+    if (i == n || !s[i])
+      break;
   }
   unassert(i == n || (i < n && !s[i]));
   return i;

libc/str/strnlen_s.c

@@ -46,13 +46,16 @@ static size_t strnlen_s_x64(const char *s, size_t n, size_t i) {
  */
 size_t strnlen_s(const char *s, size_t n) {
   size_t i;
-  if (!s) return 0;
+  if (!s)
+    return 0;
   for (i = 0; (uintptr_t)(s + i) & 7; ++i) {
-    if (i == n || !s[i]) return i;
+    if (i == n || !s[i])
+      return i;
   }
   i = strnlen_s_x64(s, n, i);
   for (;; ++i) {
-    if (i == n || !s[i]) break;
+    if (i == n || !s[i])
+      break;
   }
   unassert(i == n || (i < n && !s[i]));
   return i;

libc/str/strnwidth.c

@@ -64,7 +64,8 @@ int strnwidth(const char *s, size_t n, size_t o) {
         case kUtf8:
           if (ThomPikeCont(c)) {
             w = ThomPikeMerge(w, c);
-            if (--r) break;
+            if (--r)
+              break;
           }
           l += MAX(0, wcwidth(w));
           t = kAscii;

libc/str/strstr.c

@@ -40,7 +40,8 @@ __vex char *strstr(const char *haystack, const char *needle) {
   unsigned k, m;
   const xmm_t *p;
   xmm_t v, n, z = {0};
-  if (haystack == needle || !*needle) return (char *)haystack;
+  if (haystack == needle || !*needle)
+    return (char *)haystack;
   n = (xmm_t){*needle, *needle, *needle, *needle, *needle, *needle,
               *needle, *needle, *needle, *needle, *needle, *needle,
               *needle, *needle, *needle, *needle};
@@ -57,23 +58,32 @@ __vex char *strstr(const char *haystack, const char *needle) {
     }
     haystack = (const char *)p + __builtin_ctzl(m);
     for (i = 0;; ++i) {
-      if (!needle[i]) return (/*unconst*/ char *)haystack;
-      if (!haystack[i]) break;
-      if (needle[i] != haystack[i]) break;
+      if (!needle[i])
+        return (/*unconst*/ char *)haystack;
+      if (!haystack[i])
+        break;
+      if (needle[i] != haystack[i])
+        break;
     }
-    if (!*haystack++) break;
+    if (!*haystack++)
+      break;
   }
   return 0;
 #else
   size_t i;
-  if (haystack == needle || !*needle) return (void *)haystack;
+  if (haystack == needle || !*needle)
+    return (void *)haystack;
   for (;;) {
     for (i = 0;; ++i) {
-      if (!needle[i]) return (/*unconst*/ char *)haystack;
-      if (!haystack[i]) break;
-      if (needle[i] != haystack[i]) break;
+      if (!needle[i])
+        return (/*unconst*/ char *)haystack;
+      if (!haystack[i])
+        break;
+      if (needle[i] != haystack[i])
+        break;
     }
-    if (!*haystack++) break;
+    if (!*haystack++)
+      break;
   }
   return 0;
 #endif

libc/str/strstr16.c

@@ -31,12 +31,16 @@ char16_t *strstr16(const char16_t *haystack, const char16_t *needle) {
   size_t i;
   for (;;) {
     for (i = 0;;) {
-      if (!needle[i]) return (/*unconst*/ char16_t *)haystack;
-      if (!haystack[i]) break;
-      if (needle[i] != haystack[i]) break;
+      if (!needle[i])
+        return (/*unconst*/ char16_t *)haystack;
+      if (!haystack[i])
+        break;
+      if (needle[i] != haystack[i])
+        break;
       ++i;
     }
-    if (!*haystack++) break;
+    if (!*haystack++)
+      break;
   }
   return NULL;
 }

libc/str/towctrans.c

@@ -19,7 +19,9 @@
 #include "libc/str/str.h"
 
 wint_t towctrans(wint_t c, wctrans_t t) {
-  if (t == (wctrans_t)1) return towupper(c);
-  if (t == (wctrans_t)2) return towlower(c);
+  if (t == (wctrans_t)1)
+    return towupper(c);
+  if (t == (wctrans_t)2)
+    return towlower(c);
   return c;
 }

libc/str/tprecode16to8.c

@@ -37,7 +37,8 @@ static axdx_t tprecode16to8_sse2(char *dst, size_t dstsize, const char16_t *src,
     pcmpgtw(v2, v1, vz);
     pcmpgtw(v3, v1, kDel16);
     pandn((void *)v2, (void *)v3, (void *)v2);
-    if (pmovmskb((void *)v2) != 0xFFFF) break;
+    if (pmovmskb((void *)v2) != 0xFFFF)
+      break;
     packsswb((void *)v1, v1, v1);
     memcpy(dst + r.ax, v1, 8);
     r.ax += 8;
@@ -70,10 +71,13 @@ axdx_t tprecode16to8(char *dst, size_t dstsize, const char16_t *src) {
       r = tprecode16to8_sse2(dst, dstsize, src, r);
     }
 #endif
-    if (!(x = src[r.dx++])) break;
-    if (IsUtf16Cont(x)) continue;
+    if (!(x = src[r.dx++]))
+      break;
+    if (IsUtf16Cont(x))
+      continue;
     if (!IsUcs2(x)) {
-      if (!(y = src[r.dx++])) break;
+      if (!(y = src[r.dx++]))
+        break;
       x = MergeUtf16(x, y);
     }
     w = tpenc(x);

libc/str/tprecode8to16.c

@@ -32,7 +32,8 @@ static inline axdx_t tprecode8to16_sse2(char16_t *dst, size_t dstsize,
   while (r.ax + 16 < dstsize) {
     memcpy(v1, src + r.dx, 16);
     pcmpgtb((int8_t *)v2, (int8_t *)v1, (int8_t *)vz);
-    if (pmovmskb(v2) != 0xFFFF) break;
+    if (pmovmskb(v2) != 0xFFFF)
+      break;
     punpcklbw(v2, v1, vz);
     punpckhbw(v1, v1, vz);
     memcpy(dst + r.ax + 0, v2, 16);
@@ -73,8 +74,10 @@ axdx_t tprecode8to16(char16_t *dst, size_t dstsize, const char *src) {
       a = ThomPikeByte(x);
       n = ThomPikeLen(x) - 1;
       for (i = 0;;) {
-        if (!(b = src[r.dx + i] & 0377)) break;
-        if (!ThomPikeCont(b)) break;
+        if (!(b = src[r.dx + i] & 0377))
+          break;
+        if (!ThomPikeCont(b))
+          break;
         a = ThomPikeMerge(a, b);
         if (++i == n) {
           r.dx += i;
@@ -83,7 +86,8 @@ axdx_t tprecode8to16(char16_t *dst, size_t dstsize, const char *src) {
         }
       }
     }
-    if (!x) break;
+    if (!x)
+      break;
     w = EncodeUtf16(x);
     while (w && r.ax + 1 < dstsize) {
       dst[r.ax++] = w;

libc/str/wcrtomb.c

@@ -32,7 +32,8 @@
 __static_yoink("musl_libc_notice");
 
 size_t wcrtomb(char *s, wchar_t wc, mbstate_t *st) {
-  if (!s) return 1;
+  if (!s)
+    return 1;
   if ((unsigned)wc < 0x80) {
     *s = wc;
     return 1;

libc/str/wcscasecmp.c

@@ -29,7 +29,9 @@
 int wcscasecmp(const wchar_t *a, const wchar_t *b) {
   size_t i = 0;
   unsigned x, y;
-  if (a == b) return 0;
-  while ((x = towlower(a[i])) == (y = towlower(b[i])) && b[i]) ++i;
+  if (a == b)
+    return 0;
+  while ((x = towlower(a[i])) == (y = towlower(b[i])) && b[i])
+    ++i;
   return x - y;
 }

libc/str/wcschr.c

@@ -23,7 +23,9 @@
  */
 wchar_t *wcschr(const wchar_t *s, wchar_t c) {
   for (;; ++s) {
-    if (*s == c) return (wchar_t *)s;
-    if (!*s) return 0;
+    if (*s == c)
+      return (wchar_t *)s;
+    if (!*s)
+      return 0;
   }
 }

libc/str/wcschrnul.c

@@ -20,7 +20,9 @@
 
 wchar_t *wcschrnul(const wchar_t *s, wchar_t c) {
   for (;; ++s) {
-    if (*s == c) return (wchar_t *)s;
-    if (!*s) return (wchar_t *)s;
+    if (*s == c)
+      return (wchar_t *)s;
+    if (!*s)
+      return (wchar_t *)s;
   }
 }

libc/str/wcscmp.c

@@ -28,8 +28,10 @@
  */
 int wcscmp(const wchar_t *a, const wchar_t *b) {
   size_t i = 0;
-  if (a == b) return 0;
-  while (a[i] == b[i] && b[i]) ++i;
+  if (a == b)
+    return 0;
+  while (a[i] == b[i] && b[i])
+    ++i;
   return (int)a[i] < (int)b[i] ? -1 : (int)a[i] > (int)b[i];
 }
 

libc/str/wcsendswith.c

@@ -28,6 +28,7 @@ bool32 wcsendswith(const wchar_t *s, const wchar_t *suffix) {
   size_t n, m;
   n = wcslen(s);
   m = wcslen(suffix);
-  if (m > n) return false;
+  if (m > n)
+    return false;
   return memcmp(s + n - m, suffix, m * sizeof(wchar_t)) == 0;
 }

libc/str/wcslen.c

@@ -35,12 +35,14 @@ __vex size_t wcslen(const wchar_t *s) {
   unsigned m, k = (uintptr_t)s & 15;
   const xmm_t *p = (const xmm_t *)((uintptr_t)s & -16);
   m = __builtin_ia32_pmovmskb128(*p == z) >> k << k;
-  while (!m) m = __builtin_ia32_pmovmskb128(*++p == z);
+  while (!m)
+    m = __builtin_ia32_pmovmskb128(*++p == z);
   n = (const wchar_t *)p + (__builtin_ctzl(m) >> 2) - s;
   return n;
 #else
   size_t n = 0;
-  while (*s++) ++n;
+  while (*s++)
+    ++n;
   return n;
 #endif
 }

libc/str/wcsncasecmp.c

@@ -29,7 +29,9 @@
 int wcsncasecmp(const wchar_t *a, const wchar_t *b, size_t n) {
   size_t i = 0;
   unsigned x, y;
-  if (!n-- || a == b) return 0;
-  while ((x = towlower(a[i])) == (y = towlower(b[i])) && b[i] && i < n) ++i;
+  if (!n-- || a == b)
+    return 0;
+  while ((x = towlower(a[i])) == (y = towlower(b[i])) && b[i] && i < n)
+    ++i;
   return x - y;
 }

libc/str/wcsncat.c

@@ -33,7 +33,8 @@ wchar_t *wcsncat(wchar_t *d, const wchar_t *s, size_t n) {
   size_t i;
   wchar_t *r = d;
   d += wcslen(d);
-  for (i = 0; i < n && s[i]; ++i) d[i] = s[i];
+  for (i = 0; i < n && s[i]; ++i)
+    d[i] = s[i];
   d[i] = 0;
   return r;
 }

libc/str/wcsncmp.c

@@ -28,7 +28,9 @@
  */
 int wcsncmp(const wchar_t *a, const wchar_t *b, size_t n) {
   size_t i = 0;
-  if (!n-- || a == b) return 0;
-  while (i < n && a[i] == b[i] && b[i]) ++i;
+  if (!n-- || a == b)
+    return 0;
+  while (i < n && a[i] == b[i] && b[i])
+    ++i;
   return (int)a[i] < (int)b[i] ? -1 : (int)a[i] > (int)b[i];
 }

libc/str/wcsnlen_s.c

@@ -27,6 +27,7 @@
  * @asyncsignalsafe
  */
 size_t wcsnlen_s(const wchar_t *s, size_t n) {
-  if (!s) return 0;
+  if (!s)
+    return 0;
   return wcsnlen(s, n);
 }

libc/str/wcsnrtombs.c

@@ -35,7 +35,8 @@ size_t wcsnrtombs(char *dst, const wchar_t **wcs, size_t wn, size_t n,
                   mbstate_t *st) {
   const wchar_t *ws = *wcs;
   size_t cnt = 0;
-  if (!dst) n = 0;
+  if (!dst)
+    n = 0;
   while (ws && wn) {
     char tmp[MB_LEN_MAX];
     size_t l = wcrtomb(n < MB_LEN_MAX ? tmp : dst, *ws, 0);
@@ -45,7 +46,8 @@ size_t wcsnrtombs(char *dst, const wchar_t **wcs, size_t wn, size_t n,
     }
     if (dst) {
       if (n < MB_LEN_MAX) {
-        if (l > n) break;
+        if (l > n)
+          break;
         memcpy(dst, tmp, l);
       }
       dst += l;
@@ -59,6 +61,7 @@ size_t wcsnrtombs(char *dst, const wchar_t **wcs, size_t wn, size_t n,
     wn--;
     cnt += l;
   }
-  if (dst) *wcs = ws;
+  if (dst)
+    *wcs = ws;
   return cnt;
 }

libc/str/wcsrtombs.c

@@ -39,7 +39,8 @@ size_t wcsrtombs(char *s, const wchar_t **ws, size_t n, mbstate_t *st) {
     for (n = 0, ws2 = *ws; *ws2; ws2++) {
       if (*ws2 >= 0x80u) {
         l = wcrtomb(buf, *ws2, 0);
-        if (!(l + 1)) return -1;
+        if (!(l + 1))
+          return -1;
         n += l;
       } else
         n++;
@@ -54,7 +55,8 @@ size_t wcsrtombs(char *s, const wchar_t **ws, size_t n, mbstate_t *st) {
         return N - n;
       }
       l = wcrtomb(s, **ws, 0);
-      if (!(l + 1)) return -1;
+      if (!(l + 1))
+        return -1;
       s += l;
       n -= l;
     } else {
@@ -71,8 +73,10 @@ size_t wcsrtombs(char *s, const wchar_t **ws, size_t n, mbstate_t *st) {
         return N - n;
       }
       l = wcrtomb(buf, **ws, 0);
-      if (!(l + 1)) return -1;
-      if (l > n) return N - n;
+      if (!(l + 1))
+        return -1;
+      if (l > n)
+        return N - n;
       wcrtomb(s, **ws, 0);
       s += l;
       n -= l;

libc/str/wcsstartswith.c

@@ -26,8 +26,11 @@
  */
 bool32 wcsstartswith(const wchar_t *s, const wchar_t *prefix) {
   for (;;) {
-    if (!*prefix) return true;
-    if (!*s) return false;
-    if (*s++ != *prefix++) return false;
+    if (!*prefix)
+      return true;
+    if (!*s)
+      return false;
+    if (*s++ != *prefix++)
+      return false;
   }
 }

libc/str/wcsstr.c

@@ -31,12 +31,16 @@ wchar_t *wcsstr(const wchar_t *haystack, const wchar_t *needle) {
   size_t i;
   for (;;) {
     for (i = 0;;) {
-      if (!needle[i]) return (/*unconst*/ wchar_t *)haystack;
-      if (!haystack[i]) break;
-      if (needle[i] != haystack[i]) break;
+      if (!needle[i])
+        return (/*unconst*/ wchar_t *)haystack;
+      if (!haystack[i])
+        break;
+      if (needle[i] != haystack[i])
+        break;
       ++i;
     }
-    if (!*haystack++) break;
+    if (!*haystack++)
+      break;
   }
   return NULL;
 }

libc/str/wctob.c

@@ -32,7 +32,9 @@
 __static_yoink("musl_libc_notice");
 
 int wctob(wint_t c) {
-  if (c < 128U) return c;
-  if (MB_CUR_MAX == 1 && IS_CODEUNIT(c)) return (unsigned char)c;
+  if (c < 128U)
+    return c;
+  if (MB_CUR_MAX == 1 && IS_CODEUNIT(c))
+    return (unsigned char)c;
   return EOF;
 }

libc/str/wctomb.c

@@ -20,6 +20,7 @@
 #include "libc/str/str.h"
 
 int wctomb(char *s, wchar_t wc) {
-  if (!s) return 0;
+  if (!s)
+    return 0;
   return wcrtomb(s, wc, 0);
 }

libc/str/wctrans.c

@@ -19,7 +19,9 @@
 #include "libc/str/str.h"
 
 wctrans_t wctrans(const char *s) {
-  if (!strcmp(s, "toupper")) return (wctrans_t)1;
-  if (!strcmp(s, "tolower")) return (wctrans_t)2;
+  if (!strcmp(s, "toupper"))
+    return (wctrans_t)1;
+  if (!strcmp(s, "tolower"))
+    return (wctrans_t)2;
   return 0;
 }

libc/str/wcwidth.c

@@ -26,15 +26,19 @@
  */
 int wcwidth(wchar_t c) {
   int res;
-  if (LIKELY(32 <= c && c < 127)) return 1;
+  if (LIKELY(32 <= c && c < 127))
+    return 1;
   if (VERY_UNLIKELY((uint32_t)c >= 0x100000)) {
-    if ((uint32_t)c <= 0x10FFFD) return 1;
+    if ((uint32_t)c <= 0x10FFFD)
+      return 1;
     return -1;
   }
   res = _wcwidth_osx(c);
   if (VERY_UNLIKELY(!res)) {
-    if (!c) return 0;
-    if (iswcntrl(c)) return -1;
+    if (!c)
+      return 0;
+    if (iswcntrl(c))
+      return -1;
   }
   return res;
 }

libc/str/wmemcpy.c

@@ -21,6 +21,7 @@
 
 wchar_t *wmemcpy(wchar_t *dest, const wchar_t *src, size_t count) {
   size_t bytes;
-  if (ckd_mul(&bytes, count, sizeof(wchar_t))) bytes = -1;
+  if (ckd_mul(&bytes, count, sizeof(wchar_t)))
+    bytes = -1;
   return memcpy(dest, src, bytes);
 }

libc/str/wmemmove.c

@@ -21,6 +21,7 @@
 
 wchar_t *wmemmove(wchar_t *dest, const wchar_t *src, size_t count) {
   size_t bytes;
-  if (ckd_mul(&bytes, count, sizeof(wchar_t))) bytes = -1;
+  if (ckd_mul(&bytes, count, sizeof(wchar_t)))
+    bytes = -1;
   return memmove(dest, src, bytes);
 }

libc/str/wmempcpy.c

@@ -21,6 +21,7 @@
 
 wchar_t *wmempcpy(wchar_t *dest, const wchar_t *src, size_t count) {
   size_t bytes;
-  if (ckd_mul(&bytes, count, sizeof(wchar_t))) bytes = -1;
+  if (ckd_mul(&bytes, count, sizeof(wchar_t)))
+    bytes = -1;
   return mempcpy(dest, src, bytes);
 }