ClangFormat: apply to source, most of intern

Apply clang format as proposed in T53211.

For details on usage and instructions for migrating branches
without conflicts, see:

https://wiki.blender.org/wiki/Tools/ClangFormat

intern/atomic/atomic_ops.h

@@ -113,7 +113,8 @@ ATOMIC_INLINE size_t atomic_sub_and_fetch_z(size_t *p, size_t x);
 ATOMIC_INLINE size_t atomic_fetch_and_add_z(size_t *p, size_t x);
 ATOMIC_INLINE size_t atomic_fetch_and_sub_z(size_t *p, size_t x);
 ATOMIC_INLINE size_t atomic_cas_z(size_t *v, size_t old, size_t _new);
-ATOMIC_INLINE size_t atomic_fetch_and_update_max_z(size_t *p, size_t x); /* Uses CAS loop, see warning below. */
+ATOMIC_INLINE size_t
+atomic_fetch_and_update_max_z(size_t *p, size_t x); /* Uses CAS loop, see warning below. */
 
 ATOMIC_INLINE unsigned int atomic_add_and_fetch_u(unsigned int *p, unsigned int x);
 ATOMIC_INLINE unsigned int atomic_sub_and_fetch_u(unsigned int *p, unsigned int x);
@@ -123,7 +124,6 @@ ATOMIC_INLINE unsigned int atomic_cas_u(unsigned int *v, unsigned int old, unsig
 
 ATOMIC_INLINE void *atomic_cas_ptr(void **v, void *old, void *_new);
 
-
 ATOMIC_INLINE float atomic_cas_float(float *v, float old, float _new);
 
 /* WARNING! Float 'atomics' are really faked ones, those are actually closer to some kind of spinlock-sync'ed operation,

intern/atomic/intern/atomic_ops_ext.h

@@ -56,105 +56,106 @@ ATOMIC_STATIC_ASSERT(sizeof(size_t) == LG_SIZEOF_PTR, "sizeof(size_t) != LG_SIZE
 ATOMIC_INLINE size_t atomic_add_and_fetch_z(size_t *p, size_t x)
 {
 #if (LG_SIZEOF_PTR == 8)
-	return (size_t)atomic_add_and_fetch_uint64((uint64_t *)p, (uint64_t)x);
+  return (size_t)atomic_add_and_fetch_uint64((uint64_t *)p, (uint64_t)x);
 #elif (LG_SIZEOF_PTR == 4)
-	return (size_t)atomic_add_and_fetch_uint32((uint32_t *)p, (uint32_t)x);
+  return (size_t)atomic_add_and_fetch_uint32((uint32_t *)p, (uint32_t)x);
 #endif
 }
 
 ATOMIC_INLINE size_t atomic_sub_and_fetch_z(size_t *p, size_t x)
 {
 #if (LG_SIZEOF_PTR == 8)
-	return (size_t)atomic_add_and_fetch_uint64((uint64_t *)p, (uint64_t)-((int64_t)x));
+  return (size_t)atomic_add_and_fetch_uint64((uint64_t *)p, (uint64_t) - ((int64_t)x));
 #elif (LG_SIZEOF_PTR == 4)
-	return (size_t)atomic_add_and_fetch_uint32((uint32_t *)p, (uint32_t)-((int32_t)x));
+  return (size_t)atomic_add_and_fetch_uint32((uint32_t *)p, (uint32_t) - ((int32_t)x));
 #endif
 }
 
 ATOMIC_INLINE size_t atomic_fetch_and_add_z(size_t *p, size_t x)
 {
 #if (LG_SIZEOF_PTR == 8)
-	return (size_t)atomic_fetch_and_add_uint64((uint64_t *)p, (uint64_t)x);
+  return (size_t)atomic_fetch_and_add_uint64((uint64_t *)p, (uint64_t)x);
 #elif (LG_SIZEOF_PTR == 4)
-	return (size_t)atomic_fetch_and_add_uint32((uint32_t *)p, (uint32_t)x);
+  return (size_t)atomic_fetch_and_add_uint32((uint32_t *)p, (uint32_t)x);
 #endif
 }
 
 ATOMIC_INLINE size_t atomic_fetch_and_sub_z(size_t *p, size_t x)
 {
 #if (LG_SIZEOF_PTR == 8)
-	return (size_t)atomic_fetch_and_add_uint64((uint64_t *)p, (uint64_t)-((int64_t)x));
+  return (size_t)atomic_fetch_and_add_uint64((uint64_t *)p, (uint64_t) - ((int64_t)x));
 #elif (LG_SIZEOF_PTR == 4)
-	return (size_t)atomic_fetch_and_add_uint32((uint32_t *)p, (uint32_t)-((int32_t)x));
+  return (size_t)atomic_fetch_and_add_uint32((uint32_t *)p, (uint32_t) - ((int32_t)x));
 #endif
 }
 
 ATOMIC_INLINE size_t atomic_cas_z(size_t *v, size_t old, size_t _new)
 {
 #if (LG_SIZEOF_PTR == 8)
-	return (size_t)atomic_cas_uint64((uint64_t *)v, (uint64_t)old, (uint64_t)_new);
+  return (size_t)atomic_cas_uint64((uint64_t *)v, (uint64_t)old, (uint64_t)_new);
 #elif (LG_SIZEOF_PTR == 4)
-	return (size_t)atomic_cas_uint32((uint32_t *)v, (uint32_t)old, (uint32_t)_new);
+  return (size_t)atomic_cas_uint32((uint32_t *)v, (uint32_t)old, (uint32_t)_new);
 #endif
 }
 
 ATOMIC_INLINE size_t atomic_fetch_and_update_max_z(size_t *p, size_t x)
 {
-	size_t prev_value;
-	while((prev_value = *p) < x) {
-		if(atomic_cas_z(p, prev_value, x) == prev_value) {
-			break;
-		}
-	}
-	return prev_value;
+  size_t prev_value;
+  while ((prev_value = *p) < x) {
+    if (atomic_cas_z(p, prev_value, x) == prev_value) {
+      break;
+    }
+  }
+  return prev_value;
 }
 
 /******************************************************************************/
 /* unsigned operations. */
-ATOMIC_STATIC_ASSERT(sizeof(unsigned int) == LG_SIZEOF_INT, "sizeof(unsigned int) != LG_SIZEOF_INT");
+ATOMIC_STATIC_ASSERT(sizeof(unsigned int) == LG_SIZEOF_INT,
+                     "sizeof(unsigned int) != LG_SIZEOF_INT");
 
 ATOMIC_INLINE unsigned int atomic_add_and_fetch_u(unsigned int *p, unsigned int x)
 {
 #if (LG_SIZEOF_INT == 8)
-	return (unsigned int)atomic_add_and_fetch_uint64((uint64_t *)p, (uint64_t)x);
+  return (unsigned int)atomic_add_and_fetch_uint64((uint64_t *)p, (uint64_t)x);
 #elif (LG_SIZEOF_INT == 4)
-	return (unsigned int)atomic_add_and_fetch_uint32((uint32_t *)p, (uint32_t)x);
+  return (unsigned int)atomic_add_and_fetch_uint32((uint32_t *)p, (uint32_t)x);
 #endif
 }
 
 ATOMIC_INLINE unsigned int atomic_sub_and_fetch_u(unsigned int *p, unsigned int x)
 {
 #if (LG_SIZEOF_INT == 8)
-	return (unsigned int)atomic_add_and_fetch_uint64((uint64_t *)p, (uint64_t)-((int64_t)x));
+  return (unsigned int)atomic_add_and_fetch_uint64((uint64_t *)p, (uint64_t) - ((int64_t)x));
 #elif (LG_SIZEOF_INT == 4)
-	return (unsigned int)atomic_add_and_fetch_uint32((uint32_t *)p, (uint32_t)-((int32_t)x));
+  return (unsigned int)atomic_add_and_fetch_uint32((uint32_t *)p, (uint32_t) - ((int32_t)x));
 #endif
 }
 
 ATOMIC_INLINE unsigned int atomic_fetch_and_add_u(unsigned int *p, unsigned int x)
 {
 #if (LG_SIZEOF_INT == 8)
-	return (unsigned int)atomic_fetch_and_add_uint64((uint64_t *)p, (uint64_t)x);
+  return (unsigned int)atomic_fetch_and_add_uint64((uint64_t *)p, (uint64_t)x);
 #elif (LG_SIZEOF_INT == 4)
-	return (unsigned int)atomic_fetch_and_add_uint32((uint32_t *)p, (uint32_t)x);
+  return (unsigned int)atomic_fetch_and_add_uint32((uint32_t *)p, (uint32_t)x);
 #endif
 }
 
 ATOMIC_INLINE unsigned int atomic_fetch_and_sub_u(unsigned int *p, unsigned int x)
 {
 #if (LG_SIZEOF_INT == 8)
-	return (unsigned int)atomic_fetch_and_add_uint64((uint64_t *)p, (uint64_t)-((int64_t)x));
+  return (unsigned int)atomic_fetch_and_add_uint64((uint64_t *)p, (uint64_t) - ((int64_t)x));
 #elif (LG_SIZEOF_INT == 4)
-	return (unsigned int)atomic_fetch_and_add_uint32((uint32_t *)p, (uint32_t)-((int32_t)x));
+  return (unsigned int)atomic_fetch_and_add_uint32((uint32_t *)p, (uint32_t) - ((int32_t)x));
 #endif
 }
 
 ATOMIC_INLINE unsigned int atomic_cas_u(unsigned int *v, unsigned int old, unsigned int _new)
 {
 #if (LG_SIZEOF_INT == 8)
-	return (unsigned int)atomic_cas_uint64((uint64_t *)v, (uint64_t)old, (uint64_t)_new);
+  return (unsigned int)atomic_cas_uint64((uint64_t *)v, (uint64_t)old, (uint64_t)_new);
 #elif (LG_SIZEOF_INT == 4)
-	return (unsigned int)atomic_cas_uint32((uint32_t *)v, (uint32_t)old, (uint32_t)_new);
+  return (unsigned int)atomic_cas_uint32((uint32_t *)v, (uint32_t)old, (uint32_t)_new);
 #endif
 }
 
@@ -162,12 +163,12 @@ ATOMIC_INLINE unsigned int atomic_cas_u(unsigned int *v, unsigned int old, unsig
 /* Char operations. */
 ATOMIC_INLINE char atomic_fetch_and_or_char(char *p, char b)
 {
-	return (char)atomic_fetch_and_or_uint8((uint8_t *)p, (uint8_t)b);
+  return (char)atomic_fetch_and_or_uint8((uint8_t *)p, (uint8_t)b);
 }
 
 ATOMIC_INLINE char atomic_fetch_and_and_char(char *p, char b)
 {
-	return (char)atomic_fetch_and_and_uint8((uint8_t *)p, (uint8_t)b);
+  return (char)atomic_fetch_and_and_uint8((uint8_t *)p, (uint8_t)b);
 }
 
 /******************************************************************************/
@@ -176,9 +177,9 @@ ATOMIC_INLINE char atomic_fetch_and_and_char(char *p, char b)
 ATOMIC_INLINE void *atomic_cas_ptr(void **v, void *old, void *_new)
 {
 #if (LG_SIZEOF_PTR == 8)
-	return (void *)atomic_cas_uint64((uint64_t *)v, *(uint64_t *)&old, *(uint64_t *)&_new);
+  return (void *)atomic_cas_uint64((uint64_t *)v, *(uint64_t *)&old, *(uint64_t *)&_new);
 #elif (LG_SIZEOF_PTR == 4)
-	return (void *)atomic_cas_uint32((uint32_t *)v, *(uint32_t *)&old, *(uint32_t *)&_new);
+  return (void *)atomic_cas_uint32((uint32_t *)v, *(uint32_t *)&old, *(uint32_t *)&_new);
 #endif
 }
 
@@ -188,22 +189,22 @@ ATOMIC_STATIC_ASSERT(sizeof(float) == sizeof(uint32_t), "sizeof(float) != sizeof
 
 ATOMIC_INLINE float atomic_cas_float(float *v, float old, float _new)
 {
-	uint32_t ret = atomic_cas_uint32((uint32_t *)v, *(uint32_t *)&old, *(uint32_t *)&_new);
-	return *(float *)&ret;
+  uint32_t ret = atomic_cas_uint32((uint32_t *)v, *(uint32_t *)&old, *(uint32_t *)&_new);
+  return *(float *)&ret;
 }
 
 ATOMIC_INLINE float atomic_add_and_fetch_fl(float *p, const float x)
 {
-	float oldval, newval;
-	uint32_t prevval;
+  float oldval, newval;
+  uint32_t prevval;
 
-	do {  /* Note that since collisions are unlikely, loop will nearly always run once. */
-		oldval = *p;
-		newval = oldval + x;
-		prevval = atomic_cas_uint32((uint32_t *)p, *(uint32_t *)(&oldval), *(uint32_t *)(&newval));
-	} while (_ATOMIC_UNLIKELY(prevval != *(uint32_t *)(&oldval)));
+  do { /* Note that since collisions are unlikely, loop will nearly always run once. */
+    oldval = *p;
+    newval = oldval + x;
+    prevval = atomic_cas_uint32((uint32_t *)p, *(uint32_t *)(&oldval), *(uint32_t *)(&newval));
+  } while (_ATOMIC_UNLIKELY(prevval != *(uint32_t *)(&oldval)));
 
-	return newval;
+  return newval;
 }
 
 #endif /* __ATOMIC_OPS_EXT_H__ */

intern/atomic/intern/atomic_ops_msvc.h

@@ -40,7 +40,7 @@
 #include <windows.h>
 #include <intrin.h>
 
-#if defined (__clang__)
+#if defined(__clang__)
 #  pragma GCC diagnostic push
 #  pragma GCC diagnostic ignored "-Wincompatible-pointer-types"
 #endif
@@ -50,53 +50,53 @@
 /* Unsigned */
 ATOMIC_INLINE uint64_t atomic_add_and_fetch_uint64(uint64_t *p, uint64_t x)
 {
-	return InterlockedExchangeAdd64((int64_t *)p, (int64_t)x) + x;
+  return InterlockedExchangeAdd64((int64_t *)p, (int64_t)x) + x;
 }
 
 ATOMIC_INLINE uint64_t atomic_sub_and_fetch_uint64(uint64_t *p, uint64_t x)
 {
-	return InterlockedExchangeAdd64((int64_t *)p, -((int64_t)x)) - x;
+  return InterlockedExchangeAdd64((int64_t *)p, -((int64_t)x)) - x;
 }
 
 ATOMIC_INLINE uint64_t atomic_cas_uint64(uint64_t *v, uint64_t old, uint64_t _new)
 {
-	return InterlockedCompareExchange64((int64_t *)v, _new, old);
+  return InterlockedCompareExchange64((int64_t *)v, _new, old);
 }
 
 ATOMIC_INLINE uint64_t atomic_fetch_and_add_uint64(uint64_t *p, uint64_t x)
 {
-	return InterlockedExchangeAdd64((int64_t *)p, (int64_t)x);
+  return InterlockedExchangeAdd64((int64_t *)p, (int64_t)x);
 }
 
 ATOMIC_INLINE uint64_t atomic_fetch_and_sub_uint64(uint64_t *p, uint64_t x)
 {
-	return InterlockedExchangeAdd64((int64_t *)p, -((int64_t)x));
+  return InterlockedExchangeAdd64((int64_t *)p, -((int64_t)x));
 }
 
 /* Signed */
 ATOMIC_INLINE int64_t atomic_add_and_fetch_int64(int64_t *p, int64_t x)
 {
-	return InterlockedExchangeAdd64(p, x) + x;
+  return InterlockedExchangeAdd64(p, x) + x;
 }
 
 ATOMIC_INLINE int64_t atomic_sub_and_fetch_int64(int64_t *p, int64_t x)
 {
-	return InterlockedExchangeAdd64(p, -x) - x;
+  return InterlockedExchangeAdd64(p, -x) - x;
 }
 
 ATOMIC_INLINE int64_t atomic_cas_int64(int64_t *v, int64_t old, int64_t _new)
 {
-	return InterlockedCompareExchange64(v, _new, old);
+  return InterlockedCompareExchange64(v, _new, old);
 }
 
 ATOMIC_INLINE int64_t atomic_fetch_and_add_int64(int64_t *p, int64_t x)
 {
-	return InterlockedExchangeAdd64(p, x);
+  return InterlockedExchangeAdd64(p, x);
 }
 
 ATOMIC_INLINE int64_t atomic_fetch_and_sub_int64(int64_t *p, int64_t x)
 {
-	return InterlockedExchangeAdd64(p, -x);
+  return InterlockedExchangeAdd64(p, -x);
 }
 #endif
 
@@ -105,63 +105,63 @@ ATOMIC_INLINE int64_t atomic_fetch_and_sub_int64(int64_t *p, int64_t x)
 /* Unsigned */
 ATOMIC_INLINE uint32_t atomic_add_and_fetch_uint32(uint32_t *p, uint32_t x)
 {
-	return InterlockedExchangeAdd(p, x) + x;
+  return InterlockedExchangeAdd(p, x) + x;
 }
 
 ATOMIC_INLINE uint32_t atomic_sub_and_fetch_uint32(uint32_t *p, uint32_t x)
 {
-	return InterlockedExchangeAdd(p, -((int32_t)x)) - x;
+  return InterlockedExchangeAdd(p, -((int32_t)x)) - x;
 }
 
 ATOMIC_INLINE uint32_t atomic_cas_uint32(uint32_t *v, uint32_t old, uint32_t _new)
 {
-	return InterlockedCompareExchange((long *)v, _new, old);
+  return InterlockedCompareExchange((long *)v, _new, old);
 }
 
 ATOMIC_INLINE uint32_t atomic_fetch_and_add_uint32(uint32_t *p, uint32_t x)
 {
-	return InterlockedExchangeAdd(p, x);
+  return InterlockedExchangeAdd(p, x);
 }
 
 ATOMIC_INLINE uint32_t atomic_fetch_and_or_uint32(uint32_t *p, uint32_t x)
 {
-	return InterlockedOr((long *)p, x);
+  return InterlockedOr((long *)p, x);
 }
 
 ATOMIC_INLINE uint32_t atomic_fetch_and_and_uint32(uint32_t *p, uint32_t x)
 {
-	return InterlockedAnd((long *)p, x);
+  return InterlockedAnd((long *)p, x);
 }
 
 /* Signed */
 ATOMIC_INLINE int32_t atomic_add_and_fetch_int32(int32_t *p, int32_t x)
 {
-	return InterlockedExchangeAdd((long *)p, x) + x;
+  return InterlockedExchangeAdd((long *)p, x) + x;
 }
 
 ATOMIC_INLINE int32_t atomic_sub_and_fetch_int32(int32_t *p, int32_t x)
 {
-	return InterlockedExchangeAdd((long *)p, -x) - x;
+  return InterlockedExchangeAdd((long *)p, -x) - x;
 }
 
 ATOMIC_INLINE int32_t atomic_cas_int32(int32_t *v, int32_t old, int32_t _new)
 {
-	return InterlockedCompareExchange((long *)v, _new, old);
+  return InterlockedCompareExchange((long *)v, _new, old);
 }
 
 ATOMIC_INLINE int32_t atomic_fetch_and_add_int32(int32_t *p, int32_t x)
 {
-	return InterlockedExchangeAdd((long *)p, x);
+  return InterlockedExchangeAdd((long *)p, x);
 }
 
 ATOMIC_INLINE int32_t atomic_fetch_and_or_int32(int32_t *p, int32_t x)
 {
-	return InterlockedOr((long *)p, x);
+  return InterlockedOr((long *)p, x);
 }
 
 ATOMIC_INLINE int32_t atomic_fetch_and_and_int32(int32_t *p, int32_t x)
 {
-	return InterlockedAnd((long *)p, x);
+  return InterlockedAnd((long *)p, x);
 }
 
 /******************************************************************************/
@@ -172,9 +172,9 @@ ATOMIC_INLINE int32_t atomic_fetch_and_and_int32(int32_t *p, int32_t x)
 ATOMIC_INLINE uint8_t atomic_fetch_and_and_uint8(uint8_t *p, uint8_t b)
 {
 #if (LG_SIZEOF_PTR == 8 || LG_SIZEOF_INT == 8)
-	return InterlockedAnd8((char *)p, (char)b);
+  return InterlockedAnd8((char *)p, (char)b);
 #else
-	return _InterlockedAnd8((char *)p, (char)b);
+  return _InterlockedAnd8((char *)p, (char)b);
 #endif
 }
 
@@ -182,9 +182,9 @@ ATOMIC_INLINE uint8_t atomic_fetch_and_and_uint8(uint8_t *p, uint8_t b)
 ATOMIC_INLINE uint8_t atomic_fetch_and_or_uint8(uint8_t *p, uint8_t b)
 {
 #if (LG_SIZEOF_PTR == 8 || LG_SIZEOF_INT == 8)
-	return InterlockedOr8((char *)p, (char)b);
+  return InterlockedOr8((char *)p, (char)b);
 #else
-	return _InterlockedOr8((char *)p, (char)b);
+  return _InterlockedOr8((char *)p, (char)b);
 #endif
 }
 
@@ -193,9 +193,9 @@ ATOMIC_INLINE uint8_t atomic_fetch_and_or_uint8(uint8_t *p, uint8_t b)
 ATOMIC_INLINE int8_t atomic_fetch_and_and_int8(int8_t *p, int8_t b)
 {
 #if (LG_SIZEOF_PTR == 8 || LG_SIZEOF_INT == 8)
-	return InterlockedAnd8((char *)p, (char)b);
+  return InterlockedAnd8((char *)p, (char)b);
 #else
-	return _InterlockedAnd8((char *)p, (char)b);
+  return _InterlockedAnd8((char *)p, (char)b);
 #endif
 }
 
@@ -203,14 +203,13 @@ ATOMIC_INLINE int8_t atomic_fetch_and_and_int8(int8_t *p, int8_t b)
 ATOMIC_INLINE int8_t atomic_fetch_and_or_int8(int8_t *p, int8_t b)
 {
 #if (LG_SIZEOF_PTR == 8 || LG_SIZEOF_INT == 8)
-	return InterlockedOr8((char *)p, (char)b);
+  return InterlockedOr8((char *)p, (char)b);
 #else
-	return _InterlockedOr8((char *)p, (char)b);
+  return _InterlockedOr8((char *)p, (char)b);
 #endif
 }
 
-
-#if defined (__clang__)
+#if defined(__clang__)
 #  pragma GCC diagnostic pop
 #endif
 

intern/atomic/intern/atomic_ops_unix.h

@@ -56,140 +56,128 @@
 /* Unsigned */
 ATOMIC_INLINE uint64_t atomic_add_and_fetch_uint64(uint64_t *p, uint64_t x)
 {
-	return __sync_add_and_fetch(p, x);
+  return __sync_add_and_fetch(p, x);
 }
 
 ATOMIC_INLINE uint64_t atomic_sub_and_fetch_uint64(uint64_t *p, uint64_t x)
 {
-	return __sync_sub_and_fetch(p, x);
+  return __sync_sub_and_fetch(p, x);
 }
 
 ATOMIC_INLINE uint64_t atomic_fetch_and_add_uint64(uint64_t *p, uint64_t x)
 {
-	return __sync_fetch_and_add(p, x);
+  return __sync_fetch_and_add(p, x);
 }
 
 ATOMIC_INLINE uint64_t atomic_fetch_and_sub_uint64(uint64_t *p, uint64_t x)
 {
-	return __sync_fetch_and_sub(p, x);
+  return __sync_fetch_and_sub(p, x);
 }
 
 ATOMIC_INLINE uint64_t atomic_cas_uint64(uint64_t *v, uint64_t old, uint64_t _new)
 {
-	return __sync_val_compare_and_swap(v, old, _new);
+  return __sync_val_compare_and_swap(v, old, _new);
 }
 
 /* Signed */
 ATOMIC_INLINE int64_t atomic_add_and_fetch_int64(int64_t *p, int64_t x)
 {
-	return __sync_add_and_fetch(p, x);
+  return __sync_add_and_fetch(p, x);
 }
 
 ATOMIC_INLINE int64_t atomic_sub_and_fetch_int64(int64_t *p, int64_t x)
 {
-	return __sync_sub_and_fetch(p, x);
+  return __sync_sub_and_fetch(p, x);
 }
 
 ATOMIC_INLINE int64_t atomic_fetch_and_add_int64(int64_t *p, int64_t x)
 {
-	return __sync_fetch_and_add(p, x);
+  return __sync_fetch_and_add(p, x);
 }
 
 ATOMIC_INLINE int64_t atomic_fetch_and_sub_int64(int64_t *p, int64_t x)
 {
-	return __sync_fetch_and_sub(p, x);
+  return __sync_fetch_and_sub(p, x);
 }
 
 ATOMIC_INLINE int64_t atomic_cas_int64(int64_t *v, int64_t old, int64_t _new)
 {
-	return __sync_val_compare_and_swap(v, old, _new);
+  return __sync_val_compare_and_swap(v, old, _new);
 }
 
 #  elif (defined(__amd64__) || defined(__x86_64__))
 /* Unsigned */
 ATOMIC_INLINE uint64_t atomic_fetch_and_add_uint64(uint64_t *p, uint64_t x)
 {
-	asm volatile (
-	    "lock; xaddq %0, %1;"
-	    : "+r" (x), "=m" (*p) /* Outputs. */
-	    : "m" (*p) /* Inputs. */
-	    );
-	return x;
+  asm volatile("lock; xaddq %0, %1;"
+               : "+r"(x), "=m"(*p) /* Outputs. */
+               : "m"(*p)           /* Inputs. */
+  );
+  return x;
 }
 
 ATOMIC_INLINE uint64_t atomic_fetch_and_sub_uint64(uint64_t *p, uint64_t x)
 {
-	x = (uint64_t)(-(int64_t)x);
-	asm volatile (
-	    "lock; xaddq %0, %1;"
-	    : "+r" (x), "=m" (*p) /* Outputs. */
-	    : "m" (*p) /* Inputs. */
-	    );
-	return x;
+  x = (uint64_t)(-(int64_t)x);
+  asm volatile("lock; xaddq %0, %1;"
+               : "+r"(x), "=m"(*p) /* Outputs. */
+               : "m"(*p)           /* Inputs. */
+  );
+  return x;
 }
 
 ATOMIC_INLINE uint64_t atomic_add_and_fetch_uint64(uint64_t *p, uint64_t x)
 {
-	return atomic_fetch_and_add_uint64(p, x) + x;
+  return atomic_fetch_and_add_uint64(p, x) + x;
 }
 
 ATOMIC_INLINE uint64_t atomic_sub_and_fetch_uint64(uint64_t *p, uint64_t x)
 {
-	return atomic_fetch_and_sub_uint64(p, x) - x;
+  return atomic_fetch_and_sub_uint64(p, x) - x;
 }
 
 ATOMIC_INLINE uint64_t atomic_cas_uint64(uint64_t *v, uint64_t old, uint64_t _new)
 {
-	uint64_t ret;
-	asm volatile (
-	    "lock; cmpxchgq %2,%1"
-	    : "=a" (ret), "+m" (*v)
-	    : "r" (_new), "0" (old)
-	    : "memory");
-	return ret;
+  uint64_t ret;
+  asm volatile("lock; cmpxchgq %2,%1" : "=a"(ret), "+m"(*v) : "r"(_new), "0"(old) : "memory");
+  return ret;
 }
 
 /* Signed */
 ATOMIC_INLINE int64_t atomic_fetch_and_add_int64(int64_t *p, int64_t x)
 {
-	asm volatile (
-	    "lock; xaddq %0, %1;"
-	    : "+r" (x), "=m" (*p) /* Outputs. */
-	    : "m" (*p) /* Inputs. */
-	    );
-	return x;
+  asm volatile("lock; xaddq %0, %1;"
+               : "+r"(x), "=m"(*p) /* Outputs. */
+               : "m"(*p)           /* Inputs. */
+  );
+  return x;
 }
 
 ATOMIC_INLINE int64_t atomic_fetch_and_sub_int64(int64_t *p, int64_t x)
 {
-	x = -x;
-	asm volatile (
-	    "lock; xaddq %0, %1;"
-	    : "+r" (x), "=m" (*p) /* Outputs. */
-	    : "m" (*p) /* Inputs. */
-	    );
-	return x;
+  x = -x;
+  asm volatile("lock; xaddq %0, %1;"
+               : "+r"(x), "=m"(*p) /* Outputs. */
+               : "m"(*p)           /* Inputs. */
+  );
+  return x;
 }
 
 ATOMIC_INLINE int64_t atomic_add_and_fetch_int64(int64_t *p, int64_t x)
 {
-	return atomic_fetch_and_add_int64(p, x) + x;
+  return atomic_fetch_and_add_int64(p, x) + x;
 }
 
 ATOMIC_INLINE int64_t atomic_sub_and_fetch_int64(int64_t *p, int64_t x)
 {
-	return atomic_fetch_and_sub_int64(p, x) - x;
+  return atomic_fetch_and_sub_int64(p, x) - x;
 }
 
 ATOMIC_INLINE int64_t atomic_cas_int64(int64_t *v, int64_t old, int64_t _new)
 {
-	int64_t ret;
-	asm volatile (
-	    "lock; cmpxchgq %2,%1"
-	    : "=a" (ret), "+m" (*v)
-	    : "r" (_new), "0" (old)
-	    : "memory");
-	return ret;
+  int64_t ret;
+  asm volatile("lock; cmpxchgq %2,%1" : "=a"(ret), "+m"(*v) : "r"(_new), "0"(old) : "memory");
+  return ret;
 }
 #  else
 #    error "Missing implementation for 64-bit atomic operations"
@@ -202,102 +190,90 @@ ATOMIC_INLINE int64_t atomic_cas_int64(int64_t *v, int64_t old, int64_t _new)
 /* Unsigned */
 ATOMIC_INLINE uint32_t atomic_add_and_fetch_uint32(uint32_t *p, uint32_t x)
 {
-	return __sync_add_and_fetch(p, x);
+  return __sync_add_and_fetch(p, x);
 }
 
 ATOMIC_INLINE uint32_t atomic_sub_and_fetch_uint32(uint32_t *p, uint32_t x)
 {
-	return __sync_sub_and_fetch(p, x);
+  return __sync_sub_and_fetch(p, x);
 }
 
 ATOMIC_INLINE uint32_t atomic_cas_uint32(uint32_t *v, uint32_t old, uint32_t _new)
 {
-   return __sync_val_compare_and_swap(v, old, _new);
+  return __sync_val_compare_and_swap(v, old, _new);
 }
 
 /* Signed */
 ATOMIC_INLINE int32_t atomic_add_and_fetch_int32(int32_t *p, int32_t x)
 {
-	return __sync_add_and_fetch(p, x);
+  return __sync_add_and_fetch(p, x);
 }
 
 ATOMIC_INLINE int32_t atomic_sub_and_fetch_int32(int32_t *p, int32_t x)
 {
-	return __sync_sub_and_fetch(p, x);
+  return __sync_sub_and_fetch(p, x);
 }
 
 ATOMIC_INLINE int32_t atomic_cas_int32(int32_t *v, int32_t old, int32_t _new)
 {
-   return __sync_val_compare_and_swap(v, old, _new);
+  return __sync_val_compare_and_swap(v, old, _new);
 }
 
 #elif (defined(__i386__) || defined(__amd64__) || defined(__x86_64__))
 /* Unsigned */
 ATOMIC_INLINE uint32_t atomic_add_and_fetch_uint32(uint32_t *p, uint32_t x)
 {
-	uint32_t ret = x;
-	asm volatile (
-	    "lock; xaddl %0, %1;"
-	    : "+r" (ret), "=m" (*p) /* Outputs. */
-	    : "m" (*p) /* Inputs. */
-	    );
-	return ret + x;
+  uint32_t ret = x;
+  asm volatile("lock; xaddl %0, %1;"
+               : "+r"(ret), "=m"(*p) /* Outputs. */
+               : "m"(*p)             /* Inputs. */
+  );
+  return ret + x;
 }
 
 ATOMIC_INLINE uint32_t atomic_sub_and_fetch_uint32(uint32_t *p, uint32_t x)
 {
-	uint32_t ret = (uint32_t)(-(int32_t)x);
-	asm volatile (
-	    "lock; xaddl %0, %1;"
-	    : "+r" (ret), "=m" (*p) /* Outputs. */
-	    : "m" (*p) /* Inputs. */
-	    );
-	return ret - x;
+  uint32_t ret = (uint32_t)(-(int32_t)x);
+  asm volatile("lock; xaddl %0, %1;"
+               : "+r"(ret), "=m"(*p) /* Outputs. */
+               : "m"(*p)             /* Inputs. */
+  );
+  return ret - x;
 }
 
 ATOMIC_INLINE uint32_t atomic_cas_uint32(uint32_t *v, uint32_t old, uint32_t _new)
 {
-	uint32_t ret;
-	asm volatile (
-	    "lock; cmpxchgl %2,%1"
-	    : "=a" (ret), "+m" (*v)
-	    : "r" (_new), "0" (old)
-	    : "memory");
-	return ret;
+  uint32_t ret;
+  asm volatile("lock; cmpxchgl %2,%1" : "=a"(ret), "+m"(*v) : "r"(_new), "0"(old) : "memory");
+  return ret;
 }
 
 /* Signed */
 ATOMIC_INLINE int32_t atomic_add_and_fetch_int32(int32_t *p, int32_t x)
 {
-	int32_t ret = x;
-	asm volatile (
-	    "lock; xaddl %0, %1;"
-	    : "+r" (ret), "=m" (*p) /* Outputs. */
-	    : "m" (*p) /* Inputs. */
-	    );
-	return ret + x;
+  int32_t ret = x;
+  asm volatile("lock; xaddl %0, %1;"
+               : "+r"(ret), "=m"(*p) /* Outputs. */
+               : "m"(*p)             /* Inputs. */
+  );
+  return ret + x;
 }
 
 ATOMIC_INLINE int32_t atomic_sub_and_fetch_int32(int32_t *p, int32_t x)
 {
-	int32_t ret = -x;
-	asm volatile (
-	    "lock; xaddl %0, %1;"
-	    : "+r" (ret), "=m" (*p) /* Outputs. */
-	    : "m" (*p) /* Inputs. */
-	    );
-	return ret - x;
+  int32_t ret = -x;
+  asm volatile("lock; xaddl %0, %1;"
+               : "+r"(ret), "=m"(*p) /* Outputs. */
+               : "m"(*p)             /* Inputs. */
+  );
+  return ret - x;
 }
 
 ATOMIC_INLINE int32_t atomic_cas_int32(int32_t *v, int32_t old, int32_t _new)
 {
-	int32_t ret;
-	asm volatile (
-	    "lock; cmpxchgl %2,%1"
-	    : "=a" (ret), "+m" (*v)
-	    : "r" (_new), "0" (old)
-	    : "memory");
-	return ret;
+  int32_t ret;
+  asm volatile("lock; cmpxchgl %2,%1" : "=a"(ret), "+m"(*v) : "r"(_new), "0"(old) : "memory");
+  return ret;
 }
 
 #else
@@ -308,33 +284,33 @@ ATOMIC_INLINE int32_t atomic_cas_int32(int32_t *v, int32_t old, int32_t _new)
 /* Unsigned */
 ATOMIC_INLINE uint32_t atomic_fetch_and_add_uint32(uint32_t *p, uint32_t x)
 {
-	return __sync_fetch_and_add(p, x);
+  return __sync_fetch_and_add(p, x);
 }
 
 ATOMIC_INLINE uint32_t atomic_fetch_and_or_uint32(uint32_t *p, uint32_t x)
 {
-	return __sync_fetch_and_or(p, x);
+  return __sync_fetch_and_or(p, x);
 }
 
 ATOMIC_INLINE uint32_t atomic_fetch_and_and_uint32(uint32_t *p, uint32_t x)
 {
-	return __sync_fetch_and_and(p, x);
+  return __sync_fetch_and_and(p, x);
 }
 
 /* Signed */
 ATOMIC_INLINE int32_t atomic_fetch_and_add_int32(int32_t *p, int32_t x)
 {
-	return __sync_fetch_and_add(p, x);
+  return __sync_fetch_and_add(p, x);
 }
 
 ATOMIC_INLINE int32_t atomic_fetch_and_or_int32(int32_t *p, int32_t x)
 {
-	return __sync_fetch_and_or(p, x);
+  return __sync_fetch_and_or(p, x);
 }
 
 ATOMIC_INLINE int32_t atomic_fetch_and_and_int32(int32_t *p, int32_t x)
 {
-	return __sync_fetch_and_and(p, x);
+  return __sync_fetch_and_and(p, x);
 }
 
 #else
@@ -347,21 +323,21 @@ ATOMIC_INLINE int32_t atomic_fetch_and_and_int32(int32_t *p, int32_t x)
 /* Unsigned */
 ATOMIC_INLINE uint8_t atomic_fetch_and_and_uint8(uint8_t *p, uint8_t b)
 {
-	return __sync_fetch_and_and(p, b);
+  return __sync_fetch_and_and(p, b);
 }
 ATOMIC_INLINE uint8_t atomic_fetch_and_or_uint8(uint8_t *p, uint8_t b)
 {
-	return __sync_fetch_and_or(p, b);
+  return __sync_fetch_and_or(p, b);
 }
 
 /* Signed */
 ATOMIC_INLINE int8_t atomic_fetch_and_and_int8(int8_t *p, int8_t b)
 {
-	return __sync_fetch_and_and(p, b);
+  return __sync_fetch_and_and(p, b);
 }
 ATOMIC_INLINE int8_t atomic_fetch_and_or_int8(int8_t *p, int8_t b)
 {
-	return __sync_fetch_and_or(p, b);
+  return __sync_fetch_and_or(p, b);
 }
 
 #else

intern/atomic/intern/atomic_ops_utils.h

@@ -62,11 +62,11 @@
 #endif
 
 #ifdef __GNUC__
-#  define _ATOMIC_LIKELY(x)       __builtin_expect(!!(x), 1)
-#  define _ATOMIC_UNLIKELY(x)     __builtin_expect(!!(x), 0)
+#  define _ATOMIC_LIKELY(x) __builtin_expect(!!(x), 1)
+#  define _ATOMIC_UNLIKELY(x) __builtin_expect(!!(x), 0)
 #else
-#  define _ATOMIC_LIKELY(x)       (x)
-#  define _ATOMIC_UNLIKELY(x)     (x)
+#  define _ATOMIC_LIKELY(x) (x)
+#  define _ATOMIC_UNLIKELY(x) (x)
 #endif
 
 #if defined(__SIZEOF_POINTER__)
@@ -77,7 +77,7 @@
 #  elif (UINTPTR_MAX == 0xFFFFFFFFFFFFFFFF)
 #    define LG_SIZEOF_PTR 8
 #  endif
-#elif defined(__WORDSIZE)  /* Fallback for older glibc and cpp */
+#elif defined(__WORDSIZE) /* Fallback for older glibc and cpp */
 #  if (__WORDSIZE == 32)
 #    define LG_SIZEOF_PTR 4
 #  elif (__WORDSIZE == 64)
@@ -100,9 +100,8 @@
 /* Copied from BLI_utils... */
 /* C++ can't use _Static_assert, expects static_assert() but c++0x only,
  * Coverity also errors out. */
-#if (!defined(__cplusplus)) && \
-    (!defined(__COVERITY__)) && \
-    (defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 406))  /* gcc4.6+ only */
+#if (!defined(__cplusplus)) && (!defined(__COVERITY__)) && \
+    (defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 406)) /* gcc4.6+ only */
 #  define ATOMIC_STATIC_ASSERT(a, msg) __extension__ _Static_assert(a, msg);
 #else
 /* Code adapted from http://www.pixelbeat.org/programming/gcc/static_assert.html */
@@ -110,17 +109,19 @@
  * expand __LINE__ with one indirection before doing the actual concatenation. */
 #  define ATOMIC_ASSERT_CONCAT_(a, b) a##b
 #  define ATOMIC_ASSERT_CONCAT(a, b) ATOMIC_ASSERT_CONCAT_(a, b)
-   /* These can't be used after statements in c89. */
-#  if defined(__COUNTER__)  /* MSVC */
+/* These can't be used after statements in c89. */
+#  if defined(__COUNTER__) /* MSVC */
 #    define ATOMIC_STATIC_ASSERT(a, msg) \
-         ; enum { ATOMIC_ASSERT_CONCAT(static_assert_, __COUNTER__) = 1 / (int)(!!(a)) };
-#  else  /* older gcc, clang... */
-    /* This can't be used twice on the same line so ensure if using in headers
+      ; \
+      enum { ATOMIC_ASSERT_CONCAT(static_assert_, __COUNTER__) = 1 / (int)(!!(a)) };
+#  else /* older gcc, clang... */
+/* This can't be used twice on the same line so ensure if using in headers
      * that the headers are not included twice (by wrapping in #ifndef...#endif)
      * Note it doesn't cause an issue when used on same line of separate modules
      * compiled with gcc -combine -fwhole-program. */
 #    define ATOMIC_STATIC_ASSERT(a, msg) \
-         ; enum { ATOMIC_ASSERT_CONCAT(assert_line_, __LINE__) = 1 / (int)(!!(a)) };
+      ; \
+      enum { ATOMIC_ASSERT_CONCAT(assert_line_, __LINE__) = 1 / (int)(!!(a)) };
 #  endif
 #endif
 

intern/audaspace/CMakeLists.txt

@@ -22,46 +22,46 @@
 remove_strict_flags()
 
 if(CMAKE_COMPILER_IS_GNUCC)
-	remove_cc_flag("-Wunused-macros")
+  remove_cc_flag("-Wunused-macros")
 endif()
-	set(INC
-		.
-	)
+  set(INC
+    .
+  )
 
-	set(INC_SYS
-		${AUDASPACE_C_INCLUDE_DIRS}
-		${AUDASPACE_PY_INCLUDE_DIRS}
-	)
+  set(INC_SYS
+    ${AUDASPACE_C_INCLUDE_DIRS}
+    ${AUDASPACE_PY_INCLUDE_DIRS}
+  )
 
-	set(SRC
-		intern/AUD_Set.cpp
-		intern/AUD_Set.h
-	)
+  set(SRC
+    intern/AUD_Set.cpp
+    intern/AUD_Set.h
+  )
 
 set(LIB
 )
 
 if(NOT WITH_SYSTEM_AUDASPACE)
-	list(APPEND LIB
-		audaspace
-	)
+  list(APPEND LIB
+    audaspace
+  )
 endif()
 
 if(WITH_PYTHON)
-	list(APPEND INC_SYS
-		${PYTHON_INCLUDE_DIRS}
-	)
-	list(APPEND SRC
-		intern/AUD_PyInit.cpp
-		intern/AUD_PyInit.h
-	)
-	if(NOT WITH_SYSTEM_AUDASPACE)
-		list(APPEND LIB
-			audaspace-py
-		)
-	endif()
+  list(APPEND INC_SYS
+    ${PYTHON_INCLUDE_DIRS}
+  )
+  list(APPEND SRC
+    intern/AUD_PyInit.cpp
+    intern/AUD_PyInit.h
+  )
+  if(NOT WITH_SYSTEM_AUDASPACE)
+    list(APPEND LIB
+      audaspace-py
+    )
+  endif()
 
-	add_definitions(-DWITH_PYTHON)
+  add_definitions(-DWITH_PYTHON)
 endif()
 
 blender_add_lib(bf_intern_audaspace "${SRC}" "${INC}" "${INC_SYS}" "${LIB}")

intern/audaspace/intern/AUD_PyInit.cpp

@@ -34,46 +34,47 @@ extern void *BKE_sound_get_factory(void *sound);
 
 static PyObject *AUD_getSoundFromPointer(PyObject *self, PyObject *args)
 {
-	long int lptr;
+  long int lptr;
 
-	if (PyArg_Parse(args, "l:_sound_from_pointer", &lptr)) {
-		if (lptr) {
-			AUD_Sound* sound = BKE_sound_get_factory((void *) lptr);
+  if (PyArg_Parse(args, "l:_sound_from_pointer", &lptr)) {
+    if (lptr) {
+      AUD_Sound *sound = BKE_sound_get_factory((void *)lptr);
 
-			if (sound) {
-				Sound *obj = (Sound *)Sound_empty();
-				if (obj) {
-					obj->sound = AUD_Sound_copy(sound);
-					return (PyObject *) obj;
-				}
-			}
-		}
-	}
+      if (sound) {
+        Sound *obj = (Sound *)Sound_empty();
+        if (obj) {
+          obj->sound = AUD_Sound_copy(sound);
+          return (PyObject *)obj;
+        }
+      }
+    }
+  }
 
-	Py_RETURN_NONE;
+  Py_RETURN_NONE;
 }
 
 static PyMethodDef meth_sound_from_pointer[] = {
-    {"_sound_from_pointer", (PyCFunction)AUD_getSoundFromPointer, METH_O,
+    {"_sound_from_pointer",
+     (PyCFunction)AUD_getSoundFromPointer,
+     METH_O,
      "_sound_from_pointer(pointer)\n\n"
      "Returns the corresponding :class:`Factory` object.\n\n"
      ":arg pointer: The pointer to the bSound object as long.\n"
      ":type pointer: long\n"
      ":return: The corresponding :class:`Factory` object.\n"
-     ":rtype: :class:`Factory`"}
-};
+     ":rtype: :class:`Factory`"}};
 
 PyObject *AUD_initPython(void)
 {
-	PyObject *module = PyInit_aud();
-	if (module == NULL) {
-		printf("Unable to initialise audio\n");
-		return NULL;
-	}
+  PyObject *module = PyInit_aud();
+  if (module == NULL) {
+    printf("Unable to initialise audio\n");
+    return NULL;
+  }
 
-	PyModule_AddObject(module, "_sound_from_pointer", (PyObject *)PyCFunction_New(meth_sound_from_pointer, NULL));
-	PyDict_SetItemString(PyImport_GetModuleDict(), "aud", module);
+  PyModule_AddObject(
+      module, "_sound_from_pointer", (PyObject *)PyCFunction_New(meth_sound_from_pointer, NULL));
+  PyDict_SetItemString(PyImport_GetModuleDict(), "aud", module);
 
-	return module;
+  return module;
 }
-

intern/audaspace/intern/AUD_PyInit.h

@@ -22,26 +22,25 @@
  * \ingroup audaspaceintern
  */
 
-
 #ifndef __AUD_PYINIT_H__
 #define __AUD_PYINIT_H__
 
 #ifdef WITH_PYTHON
-#include "Python.h"
+#  include "Python.h"
 
-#ifdef __cplusplus
+#  ifdef __cplusplus
 extern "C" {
-#endif
+#  endif
 
 /**
  * Initializes the Python module.
  */
 extern PyObject *AUD_initPython(void);
 
-#ifdef __cplusplus
+#  ifdef __cplusplus
 }
-#endif
+#  endif
 
 #endif
 
-#endif //__AUD_PYINIT_H__
+#endif  //__AUD_PYINIT_H__

intern/audaspace/intern/AUD_Set.cpp

@@ -28,38 +28,38 @@
 
 void *AUD_createSet()
 {
-	return new std::set<void *>();
+  return new std::set<void *>();
 }
 
 void AUD_destroySet(void *set)
 {
-	delete reinterpret_cast<std::set<void *>*>(set);
+  delete reinterpret_cast<std::set<void *> *>(set);
 }
 
 char AUD_removeSet(void *set, void *entry)
 {
-	if (set)
-		return reinterpret_cast<std::set<void *>*>(set)->erase(entry);
-	return 0;
+  if (set)
+    return reinterpret_cast<std::set<void *> *>(set)->erase(entry);
+  return 0;
 }
 
 void AUD_addSet(void *set, void *entry)
 {
-	if (entry)
-		reinterpret_cast<std::set<void *>*>(set)->insert(entry);
+  if (entry)
+    reinterpret_cast<std::set<void *> *>(set)->insert(entry);
 }
 
 void *AUD_getSet(void *set)
 {
-	if (set) {
-		std::set<void *>* rset = reinterpret_cast<std::set<void *>*>(set);
-		if (!rset->empty()) {
-			std::set<void *>::iterator it = rset->begin();
-			void *result = *it;
-			rset->erase(it);
-			return result;
-		}
-	}
+  if (set) {
+    std::set<void *> *rset = reinterpret_cast<std::set<void *> *>(set);
+    if (!rset->empty()) {
+      std::set<void *>::iterator it = rset->begin();
+      void *result = *it;
+      rset->erase(it);
+      return result;
+    }
+  }
 
-	return (void*) 0;
+  return (void *)0;
 }

intern/audaspace/intern/AUD_Set.h

@@ -21,7 +21,7 @@
 /** \file
  * \ingroup audaspace
  */
- 
+
 #ifndef __AUD_SET_H__
 #define __AUD_SET_H__
 
@@ -67,4 +67,4 @@ extern void *AUD_getSet(void *set);
 }
 #endif
 
-#endif //__AUD_SET_H__
+#endif  //__AUD_SET_H__

intern/clog/CLG_log.h

@@ -73,13 +73,14 @@ extern "C" {
 #endif /* __cplusplus */
 
 #ifdef __GNUC__
-#  define _CLOG_ATTR_NONNULL(args ...) __attribute__((nonnull(args)))
+#  define _CLOG_ATTR_NONNULL(args...) __attribute__((nonnull(args)))
 #else
 #  define _CLOG_ATTR_NONNULL(...)
 #endif
 
 #ifdef __GNUC__
-#  define _CLOG_ATTR_PRINTF_FORMAT(format_param, dots_param) __attribute__((format(printf, format_param, dots_param)))
+#  define _CLOG_ATTR_PRINTF_FORMAT(format_param, dots_param) \
+    __attribute__((format(printf, format_param, dots_param)))
 #else
 #  define _CLOG_ATTR_PRINTF_FORMAT(format_param, dots_param)
 #endif
@@ -92,41 +93,44 @@ struct CLogContext;
 
 /* Don't typedef enums. */
 enum CLG_LogFlag {
-	CLG_FLAG_USE = (1 << 0),
+  CLG_FLAG_USE = (1 << 0),
 };
 
 enum CLG_Severity {
-	CLG_SEVERITY_INFO = 0,
-	CLG_SEVERITY_WARN,
-	CLG_SEVERITY_ERROR,
-	CLG_SEVERITY_FATAL,
+  CLG_SEVERITY_INFO = 0,
+  CLG_SEVERITY_WARN,
+  CLG_SEVERITY_ERROR,
+  CLG_SEVERITY_FATAL,
 };
 #define CLG_SEVERITY_LEN (CLG_SEVERITY_FATAL + 1)
 
 /* Each logger ID has one of these. */
 typedef struct CLG_LogType {
-	struct CLG_LogType *next;
-	char identifier[64];
-	/** FILE output. */
-	struct CLogContext *ctx;
-	/** Control behavior. */
-	int level;
-	enum CLG_LogFlag flag;
+  struct CLG_LogType *next;
+  char identifier[64];
+  /** FILE output. */
+  struct CLogContext *ctx;
+  /** Control behavior. */
+  int level;
+  enum CLG_LogFlag flag;
 } CLG_LogType;
 
 typedef struct CLG_LogRef {
-	const char *identifier;
-	CLG_LogType *type;
+  const char *identifier;
+  CLG_LogType *type;
 } CLG_LogRef;
 
-void CLG_log_str(
-        CLG_LogType *lg, enum CLG_Severity severity, const char *file_line, const char *fn,
-        const char *message)
-	_CLOG_ATTR_NONNULL(1, 3, 4, 5);
-void CLG_logf(
-        CLG_LogType *lg, enum CLG_Severity severity, const char *file_line, const char *fn,
-        const char *format, ...)
-	_CLOG_ATTR_NONNULL(1, 3, 4, 5) _CLOG_ATTR_PRINTF_FORMAT(5, 6);
+void CLG_log_str(CLG_LogType *lg,
+                 enum CLG_Severity severity,
+                 const char *file_line,
+                 const char *fn,
+                 const char *message) _CLOG_ATTR_NONNULL(1, 3, 4, 5);
+void CLG_logf(CLG_LogType *lg,
+              enum CLG_Severity severity,
+              const char *file_line,
+              const char *fn,
+              const char *format,
+              ...) _CLOG_ATTR_NONNULL(1, 3, 4, 5) _CLOG_ATTR_PRINTF_FORMAT(5, 6);
 
 /* Main initializer and distructor (per session, not logger). */
 void CLG_init(void);
@@ -147,51 +151,63 @@ void CLG_logref_init(CLG_LogRef *clg_ref);
 
 /** Declare outside function, declare as extern in header. */
 #define CLG_LOGREF_DECLARE_GLOBAL(var, id) \
-	static CLG_LogRef _static_ ## var = {id}; \
-	CLG_LogRef *var = &_static_ ## var
+  static CLG_LogRef _static_##var = {id}; \
+  CLG_LogRef *var = &_static_##var
 
 /** Initialize struct once. */
 #define CLOG_ENSURE(clg_ref) \
-	((clg_ref)->type ? (clg_ref)->type : (CLG_logref_init(clg_ref), (clg_ref)->type))
-
-#define CLOG_AT_SEVERITY(clg_ref, severity, verbose_level, ...) { \
-	CLG_LogType *_lg_ty = CLOG_ENSURE(clg_ref); \
-	if (((_lg_ty->flag & CLG_FLAG_USE) && (_lg_ty->level >= verbose_level)) || (severity >= CLG_SEVERITY_WARN)) { \
-		CLG_logf(_lg_ty, severity, __FILE__ ":" STRINGIFY(__LINE__), __func__, __VA_ARGS__); \
-	} \
-} ((void)0)
-
-#define CLOG_STR_AT_SEVERITY(clg_ref, severity, verbose_level, str) { \
-	CLG_LogType *_lg_ty = CLOG_ENSURE(clg_ref); \
-	if (((_lg_ty->flag & CLG_FLAG_USE) && (_lg_ty->level >= verbose_level)) || (severity >= CLG_SEVERITY_WARN)) { \
-		CLG_log_str(_lg_ty, severity, __FILE__ ":" STRINGIFY(__LINE__), __func__, str); \
-	} \
-} ((void)0)
-
-#define CLOG_STR_AT_SEVERITY_N(clg_ref, severity, verbose_level, str) { \
-	CLG_LogType *_lg_ty = CLOG_ENSURE(clg_ref); \
-	if (((_lg_ty->flag & CLG_FLAG_USE) && (_lg_ty->level >= verbose_level)) || (severity >= CLG_SEVERITY_WARN)) { \
-		const char *_str = str; \
-		CLG_log_str(_lg_ty, severity, __FILE__ ":" STRINGIFY(__LINE__), __func__, _str); \
-		MEM_freeN((void *)_str); \
-	} \
-} ((void)0)
-
-#define CLOG_INFO(clg_ref, level, ...) CLOG_AT_SEVERITY(clg_ref, CLG_SEVERITY_INFO, level, __VA_ARGS__)
-#define CLOG_WARN(clg_ref, ...)        CLOG_AT_SEVERITY(clg_ref, CLG_SEVERITY_WARN, 0, __VA_ARGS__)
-#define CLOG_ERROR(clg_ref, ...)       CLOG_AT_SEVERITY(clg_ref, CLG_SEVERITY_ERROR, 0, __VA_ARGS__)
-#define CLOG_FATAL(clg_ref, ...)       CLOG_AT_SEVERITY(clg_ref, CLG_SEVERITY_FATAL, 0, __VA_ARGS__)
-
-#define CLOG_STR_INFO(clg_ref, level, str) CLOG_STR_AT_SEVERITY(clg_ref, CLG_SEVERITY_INFO, level, str)
-#define CLOG_STR_WARN(clg_ref, str)        CLOG_STR_AT_SEVERITY(clg_ref, CLG_SEVERITY_WARN, 0, str)
-#define CLOG_STR_ERROR(clg_ref, str)       CLOG_STR_AT_SEVERITY(clg_ref, CLG_SEVERITY_ERROR, 0, str)
-#define CLOG_STR_FATAL(clg_ref, str)       CLOG_STR_AT_SEVERITY(clg_ref, CLG_SEVERITY_FATAL, 0, str)
+  ((clg_ref)->type ? (clg_ref)->type : (CLG_logref_init(clg_ref), (clg_ref)->type))
+
+#define CLOG_AT_SEVERITY(clg_ref, severity, verbose_level, ...) \
+  { \
+    CLG_LogType *_lg_ty = CLOG_ENSURE(clg_ref); \
+    if (((_lg_ty->flag & CLG_FLAG_USE) && (_lg_ty->level >= verbose_level)) || \
+        (severity >= CLG_SEVERITY_WARN)) { \
+      CLG_logf(_lg_ty, severity, __FILE__ ":" STRINGIFY(__LINE__), __func__, __VA_ARGS__); \
+    } \
+  } \
+  ((void)0)
+
+#define CLOG_STR_AT_SEVERITY(clg_ref, severity, verbose_level, str) \
+  { \
+    CLG_LogType *_lg_ty = CLOG_ENSURE(clg_ref); \
+    if (((_lg_ty->flag & CLG_FLAG_USE) && (_lg_ty->level >= verbose_level)) || \
+        (severity >= CLG_SEVERITY_WARN)) { \
+      CLG_log_str(_lg_ty, severity, __FILE__ ":" STRINGIFY(__LINE__), __func__, str); \
+    } \
+  } \
+  ((void)0)
+
+#define CLOG_STR_AT_SEVERITY_N(clg_ref, severity, verbose_level, str) \
+  { \
+    CLG_LogType *_lg_ty = CLOG_ENSURE(clg_ref); \
+    if (((_lg_ty->flag & CLG_FLAG_USE) && (_lg_ty->level >= verbose_level)) || \
+        (severity >= CLG_SEVERITY_WARN)) { \
+      const char *_str = str; \
+      CLG_log_str(_lg_ty, severity, __FILE__ ":" STRINGIFY(__LINE__), __func__, _str); \
+      MEM_freeN((void *)_str); \
+    } \
+  } \
+  ((void)0)
+
+#define CLOG_INFO(clg_ref, level, ...) \
+  CLOG_AT_SEVERITY(clg_ref, CLG_SEVERITY_INFO, level, __VA_ARGS__)
+#define CLOG_WARN(clg_ref, ...) CLOG_AT_SEVERITY(clg_ref, CLG_SEVERITY_WARN, 0, __VA_ARGS__)
+#define CLOG_ERROR(clg_ref, ...) CLOG_AT_SEVERITY(clg_ref, CLG_SEVERITY_ERROR, 0, __VA_ARGS__)
+#define CLOG_FATAL(clg_ref, ...) CLOG_AT_SEVERITY(clg_ref, CLG_SEVERITY_FATAL, 0, __VA_ARGS__)
+
+#define CLOG_STR_INFO(clg_ref, level, str) \
+  CLOG_STR_AT_SEVERITY(clg_ref, CLG_SEVERITY_INFO, level, str)
+#define CLOG_STR_WARN(clg_ref, str) CLOG_STR_AT_SEVERITY(clg_ref, CLG_SEVERITY_WARN, 0, str)
+#define CLOG_STR_ERROR(clg_ref, str) CLOG_STR_AT_SEVERITY(clg_ref, CLG_SEVERITY_ERROR, 0, str)
+#define CLOG_STR_FATAL(clg_ref, str) CLOG_STR_AT_SEVERITY(clg_ref, CLG_SEVERITY_FATAL, 0, str)
 
 /* Allocated string which is immediately freed. */
-#define CLOG_STR_INFO_N(clg_ref, level, str) CLOG_STR_AT_SEVERITY_N(clg_ref, CLG_SEVERITY_INFO, level, str)
-#define CLOG_STR_WARN_N(clg_ref, str)        CLOG_STR_AT_SEVERITY_N(clg_ref, CLG_SEVERITY_WARN, 0, str)
-#define CLOG_STR_ERROR_N(clg_ref, str)       CLOG_STR_AT_SEVERITY_N(clg_ref, CLG_SEVERITY_ERROR, 0, str)
-#define CLOG_STR_FATAL_N(clg_ref, str)       CLOG_STR_AT_SEVERITY_N(clg_ref, CLG_SEVERITY_FATAL, 0, str)
+#define CLOG_STR_INFO_N(clg_ref, level, str) \
+  CLOG_STR_AT_SEVERITY_N(clg_ref, CLG_SEVERITY_INFO, level, str)
+#define CLOG_STR_WARN_N(clg_ref, str) CLOG_STR_AT_SEVERITY_N(clg_ref, CLG_SEVERITY_WARN, 0, str)