vl_log.h

Go to the documentation of this file.

 
#ifndef VL_LOG_H
#define VL_LOG_H
 
#include "vl_memory.h"
#include "vl_numtypes.h"
#include "vl_stream.h"
 
typedef struct vl_logger_ vl_logger;
 
typedef struct vl_log_sink_vtbl_
{
    void (*write)(void* sink_data, const char* msg, vl_memsize_t len);
 
    void (*flush)(void* sink_data);
 
    void (*destroy)(void* sink_data);
} vl_log_sink_vtbl;
 
typedef struct vl_log_sink_
{
    const vl_log_sink_vtbl* vtbl;
 
    void* sink_data;
} vl_log_sink;
 
typedef struct vl_log_config_
{
    vl_bool_t async;
} vl_log_config;
 
VL_API vl_logger* vlLoggerNew(const vl_log_config* config);
 
VL_API void vlLoggerDelete(vl_logger* logger);
 
VL_API vl_bool_t vlLoggerAddSink(vl_logger* logger, vl_log_sink sink);
 
VL_API void vlLoggerMessage(vl_logger* logger, const char* msg);
 
VL_API void vlLoggerMessageF(vl_logger* logger, const char* msgFormat, ...);
 
VL_API void vlLoggerFlush(vl_logger* logger);
 
VL_API vl_log_sink vlLogSinkStdout(void);
 
VL_API vl_log_sink vlLogSinkStream(vl_stream* stream);
 
/* ---------------- Global convenience API ---------------- */
 
VL_API void vlLogInit(const vl_log_config* config);
 
VL_API void vlLogFlush(void);
 
VL_API void vlLogShutdown(void);
 
VL_API void vlLogMessage(const char* msg);
 
VL_API void vlLogMessageF(const char* msgFormat, ...);
 
VL_API void vlLogError(const char* msg);
 
VL_API void vlLogErrorF(const char* msgFormat, ...);
 
VL_API vl_bool_t vlLogAddSink(vl_log_sink sink);
 
VL_API vl_bool_t vlLogAddStdoutSink(void);
 
VL_API vl_bool_t vlLogAddStreamSink(vl_stream* stream);
 
/* ---------------- Debug compile control ----------------
 *
 * The logger provides macros for debug-only logs that compile out completely
 * when disabled.
 *
 * - Define `VL_ENABLE_DEBUG_LOG` to 1 to force-enable debug logging macros.
 * - Define `VL_ENABLE_DEBUG_LOG` to 0 to force-disable debug logging macros.
 * - If not defined, the default is: enabled when !NDEBUG.
 *
 * Important: To avoid cross-compiler issues with empty variadic macro arguments
 * in C11, debug and release logging macros are provided as two forms:
 * - `*_MSG0(msg)` : message-only (no variadic arguments)
 * - `*_MSGF(fmt, ...)` : formatted
 */
 
#ifndef VL_ENABLE_DEBUG_LOG
#if !defined(NDEBUG)
#define VL_ENABLE_DEBUG_LOG 1
#else
#define VL_ENABLE_DEBUG_LOG 0
#endif
#endif
 
#if VL_ENABLE_DEBUG_LOG
 
#include "vl_ansi_term.h"
 
#define VL_LOGD_MSG0(msg)                                                                                              \
    vlLogMessageF(VL_ANSI_FG_MAGENTA "[DBG | %s @ line %d] " VL_ANSI_RESET "%s", __FILE__, __LINE__, msg)
 
#define VL_LOGD_MSGF(fmt, ...)                                                                                         \
    vlLogMessageF(VL_ANSI_FG_MAGENTA "[DBG | %s @ line %d] " VL_ANSI_RESET fmt, __FILE__, __LINE__, __VA_ARGS__)
 
#define VL_LOGD_ERR0(msg)                                                                                              \
    vlLogErrorF(VL_ANSI_FG_YELLOW "[DBG | %s @ line %d] " VL_ANSI_RESET "%s", __FILE__, __LINE__, msg)
 
#define VL_LOGD_ERRF(fmt, ...)                                                                                         \
    vlLogErrorF(VL_ANSI_FG_YELLOW "[DBG | %s @ line %d] " VL_ANSI_RESET fmt, __FILE__, __LINE__, __VA_ARGS__)
#else
#define VL_LOGD_MSG0(msg) ((void)0)
#define VL_LOGD_MSGF(fmt, ...) ((void)0)
#define VL_LOGD_ERR0(msg) ((void)0)
#define VL_LOGD_ERRF(fmt, ...) ((void)0)
#endif
 
#define VL_LOG_MSG0(msg) vlLogMessage(msg)
 
#define VL_LOG_MSGF(fmt, ...) vlLogMessageF((fmt), __VA_ARGS__)
 
#define VL_LOG_ERR0(msg) vlLogError(msg)
 
#define VL_LOG_ERRF(fmt, ...) vlLogErrorF((fmt), __VA_ARGS__)
 
#endif // VL_LOG_H