From e12c08e8d170b7ca40f204a5b0423c23a9fbc2c1 Mon Sep 17 00:00:00 2001 From: Campbell Barton Date: Wed, 17 Apr 2019 06:17:24 +0200 Subject: 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/clog/CLG_log.h | 144 +++++---- intern/clog/CMakeLists.txt | 10 +- intern/clog/clog.c | 706 +++++++++++++++++++++++---------------------- 3 files changed, 443 insertions(+), 417 deletions(-) (limited to 'intern/clog') 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 - /* 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 } -- cgit v1.2.3