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

3 files changed, 443 insertions, 417 deletions

diff --git a/intern/clog/CLG_log.h b/intern/clog/CLG_log.h
index 810997ac78b..1d78c401924 100644
--- a/intern/clog/CLG_log.h
+++ b/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)
+#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)
 
 #ifdef __cplusplus
 }
diff --git a/intern/clog/CMakeLists.txt b/intern/clog/CMakeLists.txt
index 3ca9094dae6..41009642e3f 100644
--- a/intern/clog/CMakeLists.txt
+++ b/intern/clog/CMakeLists.txt
@@ -17,9 +17,9 @@
 # ***** END GPL LICENSE BLOCK *****
 
 set(INC
-	.
-	../atomic
-	../guardedalloc
+  .
+  ../atomic
+  ../guardedalloc
 )
 
 set(INC_SYS
@@ -27,9 +27,9 @@ set(INC_SYS
 )
 
 set(SRC
-	clog.c
+  clog.c
 
-	CLG_log.h
+  CLG_log.h
 )
 
 set(LIB
diff --git a/intern/clog/clog.c b/intern/clog/clog.c
index 4bc277f8ef2..ea6f215e8f0 100644
--- a/intern/clog/clog.c
+++ b/intern/clog/clog.c
@@ -46,7 +46,6 @@
 #define __STDC_FORMAT_MACROS
 #include <inttypes.h>
 
-
 /* Only other dependency (could use regular malloc too). */
 #include "MEM_guardedalloc.h"
 
@@ -68,40 +67,40 @@
  * \{ */
 
 typedef struct CLG_IDFilter {
-	struct CLG_IDFilter *next;
-	/** Over alloc. */
-	char match[0];
+  struct CLG_IDFilter *next;
+  /** Over alloc. */
+  char match[0];
 } CLG_IDFilter;
 
 typedef struct CLogContext {
-	/** Single linked list of types.  */
-	CLG_LogType *types;
+  /** Single linked list of types.  */
+  CLG_LogType *types;
 #ifdef WITH_CLOG_PTHREADS
-	pthread_mutex_t types_lock;
+  pthread_mutex_t types_lock;
 #endif
 
-	/* exclude, include filters.  */
-	CLG_IDFilter *filters[2];
-	bool use_color;
-	bool use_basename;
-	bool use_timestamp;
+  /* exclude, include filters.  */
+  CLG_IDFilter *filters[2];
+  bool use_color;
+  bool use_basename;
+  bool use_timestamp;
 
-	/** Borrowed, not owned. */
-	int output;
-	FILE *output_file;
+  /** Borrowed, not owned. */
+  int output;
+  FILE *output_file;
 
-	/** For timer (use_timestamp). */
-	uint64_t timestamp_tick_start;
+  /** For timer (use_timestamp). */
+  uint64_t timestamp_tick_start;
 
-	/** For new types. */
-	struct {
-		int level;
-	} default_type;
+  /** For new types. */
+  struct {
+    int level;
+  } default_type;
 
-	struct {
-		void (*fatal_fn)(void *file_handle);
-		void (*backtrace_fn)(void *file_handle);
-	} callbacks;
+  struct {
+    void (*fatal_fn)(void *file_handle);
+    void (*backtrace_fn)(void *file_handle);
+  } callbacks;
 } CLogContext;
 
 /** \} */
@@ -115,92 +114,92 @@ typedef struct CLogContext {
 #define CLOG_BUF_LEN_INIT 512
 
 typedef struct CLogStringBuf {
-	char *data;
-	uint  len;
-	uint  len_alloc;
-	bool is_alloc;
+  char *data;
+  uint len;
+  uint len_alloc;
+  bool is_alloc;
 } CLogStringBuf;
 
 static void clg_str_init(CLogStringBuf *cstr, char *buf_stack, uint buf_stack_len)
 {
-	cstr->data = buf_stack;
-	cstr->len_alloc = buf_stack_len;
-	cstr->len = 0;
-	cstr->is_alloc = false;
+  cstr->data = buf_stack;
+  cstr->len_alloc = buf_stack_len;
+  cstr->len = 0;
+  cstr->is_alloc = false;
 }
 
 static void clg_str_free(CLogStringBuf *cstr)
 {
-	if (cstr->is_alloc) {
-		MEM_freeN(cstr->data);
-	}
+  if (cstr->is_alloc) {
+    MEM_freeN(cstr->data);
+  }
 }
 
 static void clg_str_reserve(CLogStringBuf *cstr, const uint len)
 {
-	if (len > cstr->len_alloc) {
-		cstr->len_alloc *= 2;
-		if (len > cstr->len_alloc) {
-			cstr->len_alloc = len;
-		}
-
-		if (cstr->is_alloc) {
-			cstr->data = MEM_reallocN(cstr->data, cstr->len_alloc);
-		}
-		else {
-			/* Copy the static buffer. */
-			char *data = MEM_mallocN(cstr->len_alloc, __func__);
-			memcpy(data, cstr->data, cstr->len);
-			cstr->data = data;
-			cstr->is_alloc = true;
-		}
-		cstr->len_alloc = len;
-	}
+  if (len > cstr->len_alloc) {
+    cstr->len_alloc *= 2;
+    if (len > cstr->len_alloc) {
+      cstr->len_alloc = len;
+    }
+
+    if (cstr->is_alloc) {
+      cstr->data = MEM_reallocN(cstr->data, cstr->len_alloc);
+    }
+    else {
+      /* Copy the static buffer. */
+      char *data = MEM_mallocN(cstr->len_alloc, __func__);
+      memcpy(data, cstr->data, cstr->len);
+      cstr->data = data;
+      cstr->is_alloc = true;
+    }
+    cstr->len_alloc = len;
+  }
 }
 
 static void clg_str_append_with_len(CLogStringBuf *cstr, const char *str, const uint len)
 {
-	uint len_next = cstr->len + len;
-	clg_str_reserve(cstr, len_next);
-	char *str_dst = cstr->data + cstr->len;
-	memcpy(str_dst, str, len);
+  uint len_next = cstr->len + len;
+  clg_str_reserve(cstr, len_next);
+  char *str_dst = cstr->data + cstr->len;
+  memcpy(str_dst, str, len);
 #if 0 /* no need. */
-	str_dst[len] = '\0';
+  str_dst[len] = '\0';
 #endif
-	cstr->len = len_next;
+  cstr->len = len_next;
 }
 
 static void clg_str_append(CLogStringBuf *cstr, const char *str)
 {
-	clg_str_append_with_len(cstr, str, strlen(str));
+  clg_str_append_with_len(cstr, str, strlen(str));
 }
 
 static void clg_str_vappendf(CLogStringBuf *cstr, const char *fmt, va_list args)
 {
-	/* Use limit because windows may use '-1' for a formatting error. */
-	const uint len_max = 65535;
-	uint len_avail = (cstr->len_alloc - cstr->len);
-	if (len_avail == 0) {
-		len_avail = CLOG_BUF_LEN_INIT;
-		clg_str_reserve(cstr, len_avail);
-	}
-	while (true) {
-		va_list args_cpy;
-		va_copy(args_cpy, args);
-		int retval = vsnprintf(cstr->data + cstr->len, len_avail, fmt, args_cpy);
-		va_end(args_cpy);
-		if (retval != -1) {
-			cstr->len += retval;
-			break;
-		}
-		else {
-			len_avail *= 2;
-			if (len_avail >= len_max) {
-				break;
-			}
-			clg_str_reserve(cstr, len_avail);
-		}
-	}
+  /* Use limit because windows may use '-1' for a formatting error. */
+  const uint len_max = 65535;
+  uint len_avail = (cstr->len_alloc - cstr->len);
+  if (len_avail == 0) {
+    len_avail = CLOG_BUF_LEN_INIT;
+    clg_str_reserve(cstr, len_avail);
+  }
+  while (true) {
+    va_list args_cpy;
+    va_copy(args_cpy, args);
+    int retval = vsnprintf(cstr->data + cstr->len, len_avail, fmt, args_cpy);
+    va_end(args_cpy);
+    if (retval != -1) {
+      cstr->len += retval;
+      break;
+    }
+    else {
+      len_avail *= 2;
+      if (len_avail >= len_max) {
+        break;
+      }
+      clg_str_reserve(cstr, len_avail);
+    }
+  }
 }
 
 /** \} */
@@ -210,12 +209,12 @@ static void clg_str_vappendf(CLogStringBuf *cstr, const char *fmt, va_list args)
  * \{ */
 
 enum eCLogColor {
-	COLOR_DEFAULT,
-	COLOR_RED,
-	COLOR_GREEN,
-	COLOR_YELLOW,
+  COLOR_DEFAULT,
+  COLOR_RED,
+  COLOR_GREEN,
+  COLOR_YELLOW,
 
-	COLOR_RESET,
+  COLOR_RESET,
 };
 #define COLOR_LEN (COLOR_RESET + 1)
 
@@ -223,61 +222,61 @@ static const char *clg_color_table[COLOR_LEN] = {NULL};
 
 static void clg_color_table_init(bool use_color)
 {
-	for (int i = 0; i < COLOR_LEN; i++) {
-		clg_color_table[i] = "";
-	}
-	if (use_color) {
+  for (int i = 0; i < COLOR_LEN; i++) {
+    clg_color_table[i] = "";
+  }
+  if (use_color) {
 #ifdef _WIN32
-		/* TODO */
+    /* TODO */
 #else
-		clg_color_table[COLOR_DEFAULT]      = "\033[1;37m";
-		clg_color_table[COLOR_RED]          = "\033[1;31m";
-		clg_color_table[COLOR_GREEN]        = "\033[1;32m";
-		clg_color_table[COLOR_YELLOW]       = "\033[1;33m";
-		clg_color_table[COLOR_RESET]        = "\033[0m";
+    clg_color_table[COLOR_DEFAULT] = "\033[1;37m";
+    clg_color_table[COLOR_RED] = "\033[1;31m";
+    clg_color_table[COLOR_GREEN] = "\033[1;32m";
+    clg_color_table[COLOR_YELLOW] = "\033[1;33m";
+    clg_color_table[COLOR_RESET] = "\033[0m";
 #endif
-	}
+  }
 }
 
 static const char *clg_severity_str[CLG_SEVERITY_LEN] = {
-	[CLG_SEVERITY_INFO] =       "INFO",
-	[CLG_SEVERITY_WARN] =       "WARN",
-	[CLG_SEVERITY_ERROR] =      "ERROR",
-	[CLG_SEVERITY_FATAL] =      "FATAL",
+    [CLG_SEVERITY_INFO] = "INFO",
+    [CLG_SEVERITY_WARN] = "WARN",
+    [CLG_SEVERITY_ERROR] = "ERROR",
+    [CLG_SEVERITY_FATAL] = "FATAL",
 };
 
 static const char *clg_severity_as_text(enum CLG_Severity severity)
 {
-	bool ok = (unsigned int)severity < CLG_SEVERITY_LEN;
-	assert(ok);
-	if (ok) {
-		return clg_severity_str[severity];
-	}
-	else {
-		return "INVALID_SEVERITY";
-	}
+  bool ok = (unsigned int)severity < CLG_SEVERITY_LEN;
+  assert(ok);
+  if (ok) {
+    return clg_severity_str[severity];
+  }
+  else {
+    return "INVALID_SEVERITY";
+  }
 }
 
 static enum eCLogColor clg_severity_to_color(enum CLG_Severity severity)
 {
-	assert((unsigned int)severity < CLG_SEVERITY_LEN);
-	enum eCLogColor color = COLOR_DEFAULT;
-	switch (severity) {
-		case CLG_SEVERITY_INFO:
-			color = COLOR_DEFAULT;
-			break;
-		case CLG_SEVERITY_WARN:
-			color = COLOR_YELLOW;
-			break;
-		case CLG_SEVERITY_ERROR:
-		case CLG_SEVERITY_FATAL:
-			color = COLOR_RED;
-			break;
-		default:
-			/* should never get here. */
-			assert(false);
-	}
-	return color;
+  assert((unsigned int)severity < CLG_SEVERITY_LEN);
+  enum eCLogColor color = COLOR_DEFAULT;
+  switch (severity) {
+    case CLG_SEVERITY_INFO:
+      color = COLOR_DEFAULT;
+      break;
+    case CLG_SEVERITY_WARN:
+      color = COLOR_YELLOW;
+      break;
+    case CLG_SEVERITY_ERROR:
+    case CLG_SEVERITY_FATAL:
+      color = COLOR_RED;
+      break;
+    default:
+      /* should never get here. */
+      assert(false);
+  }
+  return color;
 }
 
 /** \} */
@@ -295,27 +294,24 @@ static enum eCLogColor clg_severity_to_color(enum CLG_Severity severity)
  */
 static bool clg_ctx_filter_check(CLogContext *ctx, const char *identifier)
 {
-	const int identifier_len = strlen(identifier);
-	for (uint i = 0; i < 2; i++) {
-		const CLG_IDFilter *flt = ctx->filters[i];
-		while (flt != NULL) {
-			const int len = strlen(flt->match);
-			if (STREQ(flt->match, "*") ||
-				((len == identifier_len) && (STREQ(identifier, flt->match))))
-			{
-				return (bool)i;
-			}
-			if ((len >= 2) && (STREQLEN(".*", &flt->match[len - 2], 2))) {
-				if (((identifier_len == len - 2) && STREQLEN(identifier, flt->match, len - 2)) ||
-					((identifier_len >= len - 1) && STREQLEN(identifier, flt->match, len - 1)))
-				{
-					return (bool)i;
-				}
-			}
-			flt = flt->next;
-		}
-	}
-	return false;
+  const int identifier_len = strlen(identifier);
+  for (uint i = 0; i < 2; i++) {
+    const CLG_IDFilter *flt = ctx->filters[i];
+    while (flt != NULL) {
+      const int len = strlen(flt->match);
+      if (STREQ(flt->match, "*") || ((len == identifier_len) && (STREQ(identifier, flt->match)))) {
+        return (bool)i;
+      }
+      if ((len >= 2) && (STREQLEN(".*", &flt->match[len - 2], 2))) {
+        if (((identifier_len == len - 2) && STREQLEN(identifier, flt->match, len - 2)) ||
+            ((identifier_len >= len - 1) && STREQLEN(identifier, flt->match, len - 1))) {
+          return (bool)i;
+        }
+      }
+      flt = flt->next;
+    }
+  }
+  return false;
 }
 
 /**
@@ -324,58 +320,58 @@ static bool clg_ctx_filter_check(CLogContext *ctx, const char *identifier)
  */
 static CLG_LogType *clg_ctx_type_find_by_name(CLogContext *ctx, const char *identifier)
 {
-	for (CLG_LogType *ty = ctx->types; ty; ty = ty->next) {
-		if (STREQ(identifier, ty->identifier)) {
-			return ty;
-		}
-	}
-	return NULL;
+  for (CLG_LogType *ty = ctx->types; ty; ty = ty->next) {
+    if (STREQ(identifier, ty->identifier)) {
+      return ty;
+    }
+  }
+  return NULL;
 }
 
 static CLG_LogType *clg_ctx_type_register(CLogContext *ctx, const char *identifier)
 {
-	assert(clg_ctx_type_find_by_name(ctx, identifier) == NULL);
-	CLG_LogType *ty = MEM_callocN(sizeof(*ty), __func__);
-	ty->next = ctx->types;
-	ctx->types = ty;
-	strncpy(ty->identifier, identifier, sizeof(ty->identifier) - 1);
-	ty->ctx = ctx;
-	ty->level = ctx->default_type.level;
+  assert(clg_ctx_type_find_by_name(ctx, identifier) == NULL);
+  CLG_LogType *ty = MEM_callocN(sizeof(*ty), __func__);
+  ty->next = ctx->types;
+  ctx->types = ty;
+  strncpy(ty->identifier, identifier, sizeof(ty->identifier) - 1);
+  ty->ctx = ctx;
+  ty->level = ctx->default_type.level;
 
-	if (clg_ctx_filter_check(ctx, ty->identifier)) {
-		ty->flag |= CLG_FLAG_USE;
-	}
-	return ty;
+  if (clg_ctx_filter_check(ctx, ty->identifier)) {
+    ty->flag |= CLG_FLAG_USE;
+  }
+  return ty;
 }
 
 static void clg_ctx_fatal_action(CLogContext *ctx)
 {
-	if (ctx->callbacks.fatal_fn != NULL) {
-		ctx->callbacks.fatal_fn(ctx->output_file);
-	}
-	fflush(ctx->output_file);
-	abort();
+  if (ctx->callbacks.fatal_fn != NULL) {
+    ctx->callbacks.fatal_fn(ctx->output_file);
+  }
+  fflush(ctx->output_file);
+  abort();
 }
 
 static void clg_ctx_backtrace(CLogContext *ctx)
 {
-	/* Note: we avoid writing fo 'FILE', for backtrace we make an exception,
-	 * if necessary we could have a version of the callback that writes to file descriptor all at once. */
-	ctx->callbacks.backtrace_fn(ctx->output_file);
-	fflush(ctx->output_file);
+  /* Note: we avoid writing fo 'FILE', for backtrace we make an exception,
+   * if necessary we could have a version of the callback that writes to file descriptor all at once. */
+  ctx->callbacks.backtrace_fn(ctx->output_file);
+  fflush(ctx->output_file);
 }
 
 static uint64_t clg_timestamp_ticks_get(void)
 {
-	uint64_t tick;
+  uint64_t tick;
 #if defined(_MSC_VER)
-	tick = GetTickCount64();
+  tick = GetTickCount64();
 #else
-	struct timeval tv;
-	gettimeofday(&tv, NULL);
-	tick = tv.tv_sec * 1000 + tv.tv_usec / 1000;
+  struct timeval tv;
+  gettimeofday(&tv, NULL);
+  tick = tv.tv_sec * 1000 + tv.tv_usec / 1000;
 #endif
-	return tick;
+  return tick;
 }
 
 /** \} */
@@ -386,131 +382,140 @@ static uint64_t clg_timestamp_ticks_get(void)
 
 static void write_timestamp(CLogStringBuf *cstr, const uint64_t timestamp_tick_start)
 {
-	char timestamp_str[64];
-	const uint64_t timestamp = clg_timestamp_ticks_get() - timestamp_tick_start;
-	const uint timestamp_len = snprintf(
-	        timestamp_str, sizeof(timestamp_str), "%" PRIu64 ".%03u ",
-	        timestamp / 1000, (uint)(timestamp % 1000));
-	clg_str_append_with_len(cstr, timestamp_str, timestamp_len);
+  char timestamp_str[64];
+  const uint64_t timestamp = clg_timestamp_ticks_get() - timestamp_tick_start;
+  const uint timestamp_len = snprintf(timestamp_str,
+                                      sizeof(timestamp_str),
+                                      "%" PRIu64 ".%03u ",
+                                      timestamp / 1000,
+                                      (uint)(timestamp % 1000));
+  clg_str_append_with_len(cstr, timestamp_str, timestamp_len);
 }
 
 static void write_severity(CLogStringBuf *cstr, enum CLG_Severity severity, bool use_color)
 {
-	assert((unsigned int)severity < CLG_SEVERITY_LEN);
-	if (use_color) {
-		enum eCLogColor color = clg_severity_to_color(severity);
-		clg_str_append(cstr, clg_color_table[color]);
-		clg_str_append(cstr, clg_severity_as_text(severity));
-		clg_str_append(cstr, clg_color_table[COLOR_RESET]);
-	}
-	else {
-		clg_str_append(cstr, clg_severity_as_text(severity));
-	}
+  assert((unsigned int)severity < CLG_SEVERITY_LEN);
+  if (use_color) {
+    enum eCLogColor color = clg_severity_to_color(severity);
+    clg_str_append(cstr, clg_color_table[color]);
+    clg_str_append(cstr, clg_severity_as_text(severity));
+    clg_str_append(cstr, clg_color_table[COLOR_RESET]);
+  }
+  else {
+    clg_str_append(cstr, clg_severity_as_text(severity));
+  }
 }
 
 static void write_type(CLogStringBuf *cstr, CLG_LogType *lg)
 {
-	clg_str_append(cstr, " (");
-	clg_str_append(cstr, lg->identifier);
-	clg_str_append(cstr, "): ");
-}
+  clg_str_append(cstr, " (");
+  clg_str_append(cstr, lg->identifier);
+  clg_str_append(cstr, "): ");
+}
 
-static void write_file_line_fn(CLogStringBuf *cstr, const char *file_line, const char *fn, const bool use_basename)
+static void write_file_line_fn(CLogStringBuf *cstr,
+                               const char *file_line,
+                               const char *fn,
+                               const bool use_basename)
 {
-	uint file_line_len = strlen(file_line);
-	if (use_basename) {
-		uint file_line_offset = file_line_len;
-		while (file_line_offset-- > 0) {
-			if (file_line[file_line_offset] == PATHSEP_CHAR) {
-				file_line_offset++;
-				break;
-			}
-		}
-		file_line += file_line_offset;
-		file_line_len -= file_line_offset;
-	}
-	clg_str_append_with_len(cstr, file_line, file_line_len);
+  uint file_line_len = strlen(file_line);
+  if (use_basename) {
+    uint file_line_offset = file_line_len;
+    while (file_line_offset-- > 0) {
+      if (file_line[file_line_offset] == PATHSEP_CHAR) {
+        file_line_offset++;
+        break;
+      }
+    }
+    file_line += file_line_offset;
+    file_line_len -= file_line_offset;
+  }
+  clg_str_append_with_len(cstr, file_line, file_line_len);
 
-
-	clg_str_append(cstr, " ");
-	clg_str_append(cstr, fn);
-	clg_str_append(cstr, ": ");
+  clg_str_append(cstr, " ");
+  clg_str_append(cstr, fn);
+  clg_str_append(cstr, ": ");
 }
 
-void CLG_log_str(
-        CLG_LogType *lg, enum CLG_Severity severity, const char *file_line, const char *fn,
-        const char *message)
+void CLG_log_str(CLG_LogType *lg,
+                 enum CLG_Severity severity,
+                 const char *file_line,
+                 const char *fn,
+                 const char *message)
 {
-	CLogStringBuf cstr;
-	char cstr_stack_buf[CLOG_BUF_LEN_INIT];
-	clg_str_init(&cstr, cstr_stack_buf, sizeof(cstr_stack_buf));
+  CLogStringBuf cstr;
+  char cstr_stack_buf[CLOG_BUF_LEN_INIT];
+  clg_str_init(&cstr, cstr_stack_buf, sizeof(cstr_stack_buf));
 
-	if (lg->ctx->use_timestamp) {
-		write_timestamp(&cstr, lg->ctx->timestamp_tick_start);
-	}
+  if (lg->ctx->use_timestamp) {
+    write_timestamp(&cstr, lg->ctx->timestamp_tick_start);
+  }
 
-	write_severity(&cstr, severity, lg->ctx->use_color);
-	write_type(&cstr, lg);
+  write_severity(&cstr, severity, lg->ctx->use_color);
+  write_type(&cstr, lg);
 
-	{
-		write_file_line_fn(&cstr, file_line, fn, lg->ctx->use_basename);
-		clg_str_append(&cstr, message);
-	}
-	clg_str_append(&cstr, "\n");
+  {
+    write_file_line_fn(&cstr, file_line, fn, lg->ctx->use_basename);
+    clg_str_append(&cstr, message);
+  }
+  clg_str_append(&cstr, "\n");
 
-	/* could be optional */
-	int bytes_written = write(lg->ctx->output, cstr.data, cstr.len);
-	(void)bytes_written;
+  /* could be optional */
+  int bytes_written = write(lg->ctx->output, cstr.data, cstr.len);
+  (void)bytes_written;
 
-	clg_str_free(&cstr);
+  clg_str_free(&cstr);
 
-	if (lg->ctx->callbacks.backtrace_fn) {
-		clg_ctx_backtrace(lg->ctx);
-	}
+  if (lg->ctx->callbacks.backtrace_fn) {
+    clg_ctx_backtrace(lg->ctx);
+  }
 
-	if (severity == CLG_SEVERITY_FATAL) {
-		clg_ctx_fatal_action(lg->ctx);
-	}
+  if (severity == CLG_SEVERITY_FATAL) {
+    clg_ctx_fatal_action(lg->ctx);
+  }
 }
 
-void CLG_logf(
-        CLG_LogType *lg, enum CLG_Severity severity, const char *file_line, const char *fn,
-        const char *fmt, ...)
+void CLG_logf(CLG_LogType *lg,
+              enum CLG_Severity severity,
+              const char *file_line,
+              const char *fn,
+              const char *fmt,
+              ...)
 {
-	CLogStringBuf cstr;
-	char cstr_stack_buf[CLOG_BUF_LEN_INIT];
-	clg_str_init(&cstr, cstr_stack_buf, sizeof(cstr_stack_buf));
+  CLogStringBuf cstr;
+  char cstr_stack_buf[CLOG_BUF_LEN_INIT];
+  clg_str_init(&cstr, cstr_stack_buf, sizeof(cstr_stack_buf));
 
-	if (lg->ctx->use_timestamp) {
-		write_timestamp(&cstr, lg->ctx->timestamp_tick_start);
-	}
+  if (lg->ctx->use_timestamp) {
+    write_timestamp(&cstr, lg->ctx->timestamp_tick_start);
+  }
 
-	write_severity(&cstr, severity, lg->ctx->use_color);
-	write_type(&cstr, lg);
+  write_severity(&cstr, severity, lg->ctx->use_color);
+  write_type(&cstr, lg);
 
-	{
-		write_file_line_fn(&cstr, file_line, fn, lg->ctx->use_basename);
+  {
+    write_file_line_fn(&cstr, file_line, fn, lg->ctx->use_basename);
 
-		va_list ap;
-		va_start(ap, fmt);
-		clg_str_vappendf(&cstr, fmt, ap);
-		va_end(ap);
-	}
-	clg_str_append(&cstr, "\n");
+    va_list ap;
+    va_start(ap, fmt);
+    clg_str_vappendf(&cstr, fmt, ap);
+    va_end(ap);
+  }
+  clg_str_append(&cstr, "\n");
 
-	/* could be optional */
-	int bytes_written = write(lg->ctx->output, cstr.data, cstr.len);
-	(void)bytes_written;
+  /* could be optional */
+  int bytes_written = write(lg->ctx->output, cstr.data, cstr.len);
+  (void)bytes_written;
 
-	clg_str_free(&cstr);
+  clg_str_free(&cstr);
 
-	if (lg->ctx->callbacks.backtrace_fn) {
-		clg_ctx_backtrace(lg->ctx);
-	}
+  if (lg->ctx->callbacks.backtrace_fn) {
+    clg_ctx_backtrace(lg->ctx);
+  }
 
-	if (severity == CLG_SEVERITY_FATAL) {
-		clg_ctx_fatal_action(lg->ctx);
-	}
+  if (severity == CLG_SEVERITY_FATAL) {
+    clg_ctx_fatal_action(lg->ctx);
+  }
 }
 
 /** \} */
@@ -521,99 +526,105 @@ void CLG_logf(
 
 static void CLG_ctx_output_set(CLogContext *ctx, void *file_handle)
 {
-	ctx->output_file = file_handle;
-	ctx->output = fileno(ctx->output_file);
+  ctx->output_file = file_handle;
+  ctx->output = fileno(ctx->output_file);
 #if defined(__unix__) || defined(__APPLE__)
-	ctx->use_color = isatty(ctx->output);
+  ctx->use_color = isatty(ctx->output);
 #endif
 }
 
 static void CLG_ctx_output_use_basename_set(CLogContext *ctx, int value)
 {
-	ctx->use_basename = (bool)value;
+  ctx->use_basename = (bool)value;
 }
 
 static void CLG_ctx_output_use_timestamp_set(CLogContext *ctx, int value)
 {
-	ctx->use_timestamp = (bool)value;
-	if (ctx->use_timestamp) {
-		ctx->timestamp_tick_start = clg_timestamp_ticks_get();
-	}
+  ctx->use_timestamp = (bool)value;
+  if (ctx->use_timestamp) {
+    ctx->timestamp_tick_start = clg_timestamp_ticks_get();
+  }
 }
 
 /** Action on fatal severity. */
 static void CLG_ctx_fatal_fn_set(CLogContext *ctx, void (*fatal_fn)(void *file_handle))
 {
-	ctx->callbacks.fatal_fn = fatal_fn;
+  ctx->callbacks.fatal_fn = fatal_fn;
 }
 
 static void CLG_ctx_backtrace_fn_set(CLogContext *ctx, void (*backtrace_fn)(void *file_handle))
 {
-	ctx->callbacks.backtrace_fn = backtrace_fn;
+  ctx->callbacks.backtrace_fn = backtrace_fn;
 }
 
-static void clg_ctx_type_filter_append(CLG_IDFilter **flt_list, const char *type_match, int type_match_len)
+static void clg_ctx_type_filter_append(CLG_IDFilter **flt_list,
+                                       const char *type_match,
+                                       int type_match_len)
 {
-	if (type_match_len == 0) {
-		return;
-	}
-	CLG_IDFilter *flt = MEM_callocN(sizeof(*flt) + (type_match_len + 1), __func__);
-	flt->next = *flt_list;
-	*flt_list = flt;
-	memcpy(flt->match, type_match, type_match_len);
-	/* no need to null terminate since we calloc'd */
+  if (type_match_len == 0) {
+    return;
+  }
+  CLG_IDFilter *flt = MEM_callocN(sizeof(*flt) + (type_match_len + 1), __func__);
+  flt->next = *flt_list;
+  *flt_list = flt;
+  memcpy(flt->match, type_match, type_match_len);
+  /* no need to null terminate since we calloc'd */
 }
 
-static void CLG_ctx_type_filter_exclude(CLogContext *ctx, const char *type_match, int type_match_len)
+static void CLG_ctx_type_filter_exclude(CLogContext *ctx,
+                                        const char *type_match,
+                                        int type_match_len)
 {
-	clg_ctx_type_filter_append(&ctx->filters[0], type_match, type_match_len);
+  clg_ctx_type_filter_append(&ctx->filters[0], type_match, type_match_len);
 }
 
-static void CLG_ctx_type_filter_include(CLogContext *ctx, const char *type_match, int type_match_len)
+static void CLG_ctx_type_filter_include(CLogContext *ctx,
+                                        const char *type_match,
+                                        int type_match_len)
 {
-	clg_ctx_type_filter_append(&ctx->filters[1], type_match, type_match_len);
+  clg_ctx_type_filter_append(&ctx->filters[1], type_match, type_match_len);
 }
 
 static void CLG_ctx_level_set(CLogContext *ctx, int level)
 {
-	ctx->default_type.level = level;
-	for (CLG_LogType *ty = ctx->types; ty; ty = ty->next) {
-		ty->level = level;
-	}
+  ctx->default_type.level = level;
+  for (CLG_LogType *ty = ctx->types; ty; ty = ty->next) {
+    ty->level = level;
+  }
 }
 
 static CLogContext *CLG_ctx_init(void)
 {
-	CLogContext *ctx = MEM_callocN(sizeof(*ctx), __func__);
+  CLogContext *ctx = MEM_callocN(sizeof(*ctx), __func__);
 #ifdef WITH_CLOG_PTHREADS
-	pthread_mutex_init(&ctx->types_lock, NULL);
+  pthread_mutex_init(&ctx->types_lock, NULL);
 #endif
-	ctx->use_color = true;
-	ctx->default_type.level = 1;
-	CLG_ctx_output_set(ctx, stdout);
+  ctx->use_color = true;
+  ctx->default_type.level = 1;
+  CLG_ctx_output_set(ctx, stdout);
 
-	return ctx;
+  return ctx;
 }
 
 static void CLG_ctx_free(CLogContext *ctx)
 {
-	while (ctx->types != NULL) {
-		CLG_LogType *item = ctx->types;
-		ctx->types = item->next;
-		MEM_freeN(item);
-	}
-
-	for (uint i = 0; i < 2; i++) {
-		while (ctx->filters[i] != NULL) {
-			CLG_IDFilter *item = ctx->filters[i];
-			ctx->filters[i] = item->next;
-			MEM_freeN(item);
-		}
-	}
+  while (ctx->types != NULL) {
+    CLG_LogType *item = ctx->types;
+    ctx->types = item->next;
+    MEM_freeN(item);
+  }
+
+  for (uint i = 0; i < 2; i++) {
+    while (ctx->filters[i] != NULL) {
+      CLG_IDFilter *item = ctx->filters[i];
+      ctx->filters[i] = item->next;
+      MEM_freeN(item);
+    }
+  }
 #ifdef WITH_CLOG_PTHREADS
-	pthread_mutex_destroy(&ctx->types_lock);
+  pthread_mutex_destroy(&ctx->types_lock);
 #endif
-	MEM_freeN(ctx);
+  MEM_freeN(ctx);
 }
 
 /** \} */
@@ -629,57 +640,56 @@ static struct CLogContext *g_ctx = NULL;
 
 void CLG_init(void)
 {
-	g_ctx = CLG_ctx_init();
+  g_ctx = CLG_ctx_init();
 
-	clg_color_table_init(g_ctx->use_color);
+  clg_color_table_init(g_ctx->use_color);
 }
 
 void CLG_exit(void)
 {
-	CLG_ctx_free(g_ctx);
+  CLG_ctx_free(g_ctx);
 }
 
 void CLG_output_set(void *file_handle)
 {
-	CLG_ctx_output_set(g_ctx, file_handle);
+  CLG_ctx_output_set(g_ctx, file_handle);
 }
 
 void CLG_output_use_basename_set(int value)
 {
-	CLG_ctx_output_use_basename_set(g_ctx, value);
+  CLG_ctx_output_use_basename_set(g_ctx, value);
 }
 
 void CLG_output_use_timestamp_set(int value)
 {
-	CLG_ctx_output_use_timestamp_set(g_ctx, value);
+  CLG_ctx_output_use_timestamp_set(g_ctx, value);
 }
 
 void CLG_fatal_fn_set(void (*fatal_fn)(void *file_handle))
 {
-	CLG_ctx_fatal_fn_set(g_ctx, fatal_fn);
+  CLG_ctx_fatal_fn_set(g_ctx, fatal_fn);
 }
 
 void CLG_backtrace_fn_set(void (*fatal_fn)(void *file_handle))
 {
-	CLG_ctx_backtrace_fn_set(g_ctx, fatal_fn);
+  CLG_ctx_backtrace_fn_set(g_ctx, fatal_fn);
 }
 
 void CLG_type_filter_exclude(const char *type_match, int type_match_len)
 {
-	CLG_ctx_type_filter_exclude(g_ctx, type_match, type_match_len);
+  CLG_ctx_type_filter_exclude(g_ctx, type_match, type_match_len);
 }
 
 void CLG_type_filter_include(const char *type_match, int type_match_len)
 {
-	CLG_ctx_type_filter_include(g_ctx, type_match, type_match_len);
+  CLG_ctx_type_filter_include(g_ctx, type_match, type_match_len);
 }
 
 void CLG_level_set(int level)
 {
-	CLG_ctx_level_set(g_ctx, level);
+  CLG_ctx_level_set(g_ctx, level);
 }
 
-
 /** \} */
 
 /* -------------------------------------------------------------------- */
@@ -690,22 +700,22 @@ void CLG_level_set(int level)
 void CLG_logref_init(CLG_LogRef *clg_ref)
 {
 #ifdef WITH_CLOG_PTHREADS
-	/* Only runs once when initializing a static type in most cases. */
-	pthread_mutex_lock(&g_ctx->types_lock);
+  /* Only runs once when initializing a static type in most cases. */
+  pthread_mutex_lock(&g_ctx->types_lock);
 #endif
-	if (clg_ref->type == NULL) {
-		CLG_LogType *clg_ty = clg_ctx_type_find_by_name(g_ctx, clg_ref->identifier);
-		if (clg_ty == NULL) {
-			clg_ty = clg_ctx_type_register(g_ctx, clg_ref->identifier);
-		}
+  if (clg_ref->type == NULL) {
+    CLG_LogType *clg_ty = clg_ctx_type_find_by_name(g_ctx, clg_ref->identifier);
+    if (clg_ty == NULL) {
+      clg_ty = clg_ctx_type_register(g_ctx, clg_ref->identifier);
+    }
 #ifdef WITH_CLOG_PTHREADS
-		atomic_cas_ptr((void **)&clg_ref->type, clg_ref->type, clg_ty);
+    atomic_cas_ptr((void **)&clg_ref->type, clg_ref->type, clg_ty);
 #else
-		clg_ref->type = clg_ty;
+    clg_ref->type = clg_ty;
 #endif
-	}
+  }
 #ifdef WITH_CLOG_PTHREADS
-	pthread_mutex_unlock(&g_ctx->types_lock);
+  pthread_mutex_unlock(&g_ctx->types_lock);
 #endif
 }