Page MenuHome
Differential D4214 Diff 13229 intern/clog/clog.c

Changeset View

Standalone View

View Options

intern/clog/clog.c

Context not available.
/* For 'isatty' to check for color. */ /* For 'isatty' to check for color. */
#if defined(__unix__) || defined(__APPLE__) || defined(__HAIKU__) #if defined(__unix__) || defined(__APPLE__) || defined(__HAIKU__)
# include <unistd.h> # include <unistd.h>
# include <sys/time.h>
#endif #endif
#if defined(_MSC_VER) #if defined(_MSC_VER)
# include <io.h> # include <io.h>
# include <windows.h>
#endif #endif
/* Only other dependency (could use regular malloc too). */ /* Only other dependency (could use regular malloc too). */
#include "MEM_guardedalloc.h" #include "MEM_guardedalloc.h"
Context not available.
CLG_LogType *types; CLG_LogType *types;
/* exclude, include filters. */ /* exclude, include filters. */
CLG_IDFilter *filters[2]; CLG_IDFilter *filters[2];
bool use_color; BOOL use_color;
bool use_basename; BOOL use_basename;
BOOL use_timestamp;
BOOL use_console;
/** Borrowed, not owned. */ /** Borrowed, not owned. */
int output; int output;
Context not available.
char *data; char *data;
uint len; uint len;
uint len_alloc; uint len_alloc;
bool is_alloc; bool is_alloc;
} CLogStringBuf; } CLogStringBuf;
static void clg_str_init(CLogStringBuf *cstr, char *buf_stack, uint buf_stack_len) static void clg_str_init(CLogStringBuf *cstr, char *buf_stack, uint buf_stack_len)
Context not available.
fflush(ctx->output_file); fflush(ctx->output_file);
} }
// return time since first log message
static uint64_t clg_ctx_timestamp()
{
static uint64_t start_tick = 0;
uint64_t tick;
#if defined(_MSC_VER)
tick = GetTickCount64();
LazyDodoUnsubmitted
Not Done
Inline Actions

This will use the system timer which has 10-16ms precision. seems fine for some casual logging, @Campbell Barton (campbellbarton) will have to decide here.

LazyDodo: This will use the system timer which has 10-16ms precision. seems fine for some casual logging…
#else
struct timeval tv;
gettimeofday(&tv, NULL);
tick = tv.tv_sec * 1000 + tv.tv_usec / 1000;
#endif
if (start_tick == 0)
start_tick = tick;
return tick - start_tick;
}
/** \} */ /** \} */
/* -------------------------------------------------------------------- */ /* -------------------------------------------------------------------- */
/** \name Logging API /** \name Logging API
* \{ */ * \{ */
static void write_timestamp(CLogStringBuf *cstr)
{
char timestamp_str[64];
uint64_t timestamp = clg_ctx_timestamp();
snprintf(timestamp_str, sizeof(timestamp_str), "%llu.%03d ", timestamp / 1000, (unsigned long)(timestamp % 1000));
clg_str_append(cstr, timestamp_str);
}
static void write_severity(CLogStringBuf *cstr, enum CLG_Severity severity, bool use_color) static void write_severity(CLogStringBuf *cstr, enum CLG_Severity severity, bool use_color)
{ {
assert((unsigned int)severity < CLG_SEVERITY_LEN); assert((unsigned int)severity < CLG_SEVERITY_LEN);
Context not available.
CLG_LogType *lg, enum CLG_Severity severity, const char *file_line, const char *fn, CLG_LogType *lg, enum CLG_Severity severity, const char *file_line, const char *fn,
const char *message) const char *message)
{ {
CLogStringBuf cstr; CLG_logf(lg, severity, file_line, fn, "%s", message);
char cstr_stack_buf[CLOG_BUF_LEN_INIT];
clg_str_init(&cstr, cstr_stack_buf, sizeof(cstr_stack_buf));
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");
/* could be optional */
int bytes_written = write(lg->ctx->output, cstr.data, cstr.len);
(void)bytes_written;
clg_str_free(&cstr);
if (lg->ctx->callbacks.backtrace_fn) {
clg_ctx_backtrace(lg->ctx);
}
if (severity == CLG_SEVERITY_FATAL) {
clg_ctx_fatal_action(lg->ctx);
}
} }
void CLG_logf( void CLG_logf(
Context not available.
char cstr_stack_buf[CLOG_BUF_LEN_INIT]; char cstr_stack_buf[CLOG_BUF_LEN_INIT];
clg_str_init(&cstr, cstr_stack_buf, sizeof(cstr_stack_buf)); clg_str_init(&cstr, cstr_stack_buf, sizeof(cstr_stack_buf));
if (lg->ctx->use_timestamp)
write_timestamp(&cstr);
write_severity(&cstr, severity, lg->ctx->use_color); write_severity(&cstr, severity, lg->ctx->use_color);
write_type(&cstr, lg); write_type(&cstr, lg);
Context not available.
clg_str_append(&cstr, "\n"); clg_str_append(&cstr, "\n");
/* could be optional */ /* could be optional */
int bytes_written = write(lg->ctx->output, cstr.data, cstr.len); write(lg->ctx->output, cstr.data, cstr.len);
(void)bytes_written;
if (lg->ctx->use_console && lg->ctx->output_file != stdout)
write(fileno(stdout), cstr.data, cstr.len);
clg_str_free(&cstr); clg_str_free(&cstr);
Context not available.
#endif #endif
} }
static void CLG_ctx_output_use_basename_set(CLogContext *ctx, int value) static void CLG_ctx_output_use_basename_set(CLogContext *ctx, BOOL value)
{ {
ctx->use_basename = (bool)value; ctx->use_basename = value;
}
static void CLG_ctx_output_use_timestamp_set(CLogContext *ctx, BOOL value)
{
ctx->use_timestamp = value;
}
static void CLG_ctx_output_use_console_set(CLogContext *ctx, BOOL value)
{
ctx->use_console = value;
} }
/** Action on fatal severity. */ /** Action on fatal severity. */
Context not available.
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);
}
void CLG_output_use_console_set(int value)
{
CLG_ctx_output_use_console_set(g_ctx, value);
}
void CLG_fatal_fn_set(void (*fatal_fn)(void *file_handle)) void CLG_fatal_fn_set(void (*fatal_fn)(void *file_handle))
{ {
Context not available.