logmod.h

Go to the documentation of this file.

#ifndef LOGMOD_H
#define LOGMOD_H
 
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
 
#ifdef LOGMOD_STATIC
#define LOGMOD_API static
#else
#define LOGMOD_API extern
#endif /* LOGMOD_STATIC */
 
#include <stdio.h>
#include <stdarg.h>
#include <time.h>
 
#if defined(__MINGW32__)                                                      \
    || (defined(__GNUC__) && __GNUC__ > 4 ? true : __GNUC_PATCHLEVEL__ >= 4)  \
    || defined(__USE_MINGW_ANSI_STDIO)
#define LOGMOD_PRINTF_LIKE(a, b) __attribute__((format(gnu_printf, a, b)))
#else
#define LOGMOD_PRINTF_LIKE(a, b)
#endif
 
#ifndef LOGMOD_FALLBACK_APPLICATION_ID
#define LOGMOD_FALLBACK_APPLICATION_ID "APPLICATION"
#endif /* LOGMOD_FALLBACK_APPLICATION_ID */
 
#ifndef LOGMOD_FALLBACK_CONTEXT_ID
#define LOGMOD_FALLBACK_CONTEXT_ID "GLOBAL"
#endif /* LOGMOD_FALLBACK_CONTEXT_ID */
 
enum logmod_levels {
    LOGMOD_LEVEL_TRACE = 0, 
    LOGMOD_LEVEL_DEBUG, 
    LOGMOD_LEVEL_INFO, 
    LOGMOD_LEVEL_WARN, 
    LOGMOD_LEVEL_ERROR, 
    LOGMOD_LEVEL_FATAL, 
    __LOGMOD_LEVEL_MAX, 
    LOGMOD_LEVEL_CUSTOM = __LOGMOD_LEVEL_MAX
};
 
typedef enum {
    LOGMOD_ERRNO = -2, 
    LOGMOD_BAD_PARAMETER = -1, 
    LOGMOD_OK = 0, 
    LOGMOD_OK_CONTINUE, 
    LOGMOD_OK_SKIPPED 
} logmod_err;
 
struct logmod_options {
    FILE *logfile; 
    int quiet; 
    int color; 
    int hide_context_id; 
    int show_application_id; 
    unsigned level; 
    int suppress_time; 
    int hide_counter; 
};
 
struct logmod_label {
    const char *const name; 
    const char *const style; 
    const char *const visibility; 
    const char *const color; 
    const int output; 
};
 
#define LOGMOD_LABEL_COLOR(_style, _visibility, _color)                       \
    LOGMOD_STYLE_##_style, LOGMOD_VISIBILITY_##_visibility,                   \
        LOGMOD_COLOR_##_color
 
struct logmod_info {
    const unsigned line; 
    const char *const filename; 
    const unsigned level; 
    const struct logmod_label *const label; 
    const struct tm time; 
};
 
/* forward declaration */
struct logmod_logger;
struct tm;
 
 
typedef void (*logmod_lock)(const struct logmod_logger *logger,
                            int should_lock);
 
typedef logmod_err (*logmod_callback)(const struct logmod_logger *logger,
                                      const struct logmod_info *info,
                                      const char *fmt,
                                      va_list args);
 
#define LOGMOD_STYLE_REGULAR       "0" 
#define LOGMOD_STYLE_BOLD          "1" 
#define LOGMOD_STYLE_UNDERLINE     "4" 
#define LOGMOD_STYLE_STRIKETHROUGH "9" 
#define LOGMOD_VISIBILITY_FOREGROUND "3" 
#define LOGMOD_VISIBILITY_BACKGROUND "4" 
#define LOGMOD_VISIBILITY_INTENSITY  "9" 
#define LOGMOD_VISIBILITY_BACKGROUND_INTENSITY                                \
    "10" 
#define LOGMOD_COLOR_BLACK   "0" 
#define LOGMOD_COLOR_RED     "1" 
#define LOGMOD_COLOR_GREEN   "2" 
#define LOGMOD_COLOR_YELLOW  "3" 
#define LOGMOD_COLOR_BLUE    "4" 
#define LOGMOD_COLOR_MAGENTA "5" 
#define LOGMOD_COLOR_CYAN    "6" 
#define LOGMOD_COLOR_WHITE   "7" 
#define __LOGMOD_LOGGER_ATTRS(_qualifier)                                     \
    const char *context_id;                                                   \
    _qualifier struct logmod_options options;                                 \
    const long *counter;                                                      \
    _qualifier logmod_callback callback;                                      \
    void *user_data;                                                          \
    const struct logmod_label *_qualifier custom_labels;                      \
    _qualifier size_t num_custom_labels;                                      \
    _qualifier int disabled
 
#define __BLANK
struct logmod_mut_logger {
    __LOGMOD_LOGGER_ATTRS(__BLANK);
};
#undef __BLANK
 
struct logmod_logger {
    __LOGMOD_LOGGER_ATTRS(const);
};
 
#undef __LOGMOD_LOGGER_ATTRS
 
struct logmod {
    const char *application_id; 
    const struct logmod_logger *loggers; 
    const size_t length; 
    const size_t real_length; 
    long counter; 
    const struct logmod_options
        default_options; 
    logmod_lock lock; 
};
 
LOGMOD_API logmod_err logmod_init(struct logmod *logmod,
                                  const char *const application_id,
                                  struct logmod_logger table[],
                                  unsigned length);
 
LOGMOD_API logmod_err logmod_cleanup(struct logmod *logmod);
 
LOGMOD_API logmod_err logmod_set_lock(struct logmod *logmod, logmod_lock lock);
 
LOGMOD_API logmod_err logmod_set_options(struct logmod *logmod,
                                         struct logmod_options options);
 
LOGMOD_API logmod_err logmod_toggle_logger(struct logmod *logmod,
                                           const char *const context_id);
 
LOGMOD_API logmod_err logmod_logger_set_data(struct logmod_logger *logger,
                                             void *user_data);
 
LOGMOD_API logmod_err
logmod_logger_set_callback(struct logmod_logger *logger,
                           const struct logmod_label *const custom_labels,
                           const size_t num_custom_labels,
                           logmod_callback callback);
 
LOGMOD_API logmod_err logmod_logger_set_options(struct logmod_logger *logger,
                                                struct logmod_options options);
 
LOGMOD_API logmod_err logmod_logger_set_id_visibility(
    struct logmod_logger *logger, int show_app_id, int show_context_id);
 
LOGMOD_API logmod_err logmod_logger_set_quiet(struct logmod_logger *logger,
                                              int quiet);
 
LOGMOD_API logmod_err logmod_logger_set_color(struct logmod_logger *logger,
                                              int color);
 
LOGMOD_API logmod_err logmod_logger_set_level(struct logmod_logger *logger,
                                              unsigned level);
 
LOGMOD_API logmod_err logmod_logger_set_logfile(struct logmod_logger *logger,
                                                FILE *logfile);
 
LOGMOD_API logmod_err logmod_logger_set_time(struct logmod_logger *logger,
                                             int show_time);
 
LOGMOD_API logmod_err logmod_logger_set_counter(struct logmod_logger *logger,
                                                int show_counter);
 
LOGMOD_API struct logmod_logger *logmod_get_logger(
    struct logmod *logmod, const char *const context_id);
 
LOGMOD_API const struct logmod_label *logmod_logger_get_label(
    const struct logmod_logger *logger, const unsigned level);
 
LOGMOD_API long logmod_logger_get_level(const struct logmod_logger *logger,
                                        const char *const label);
 
LOGMOD_API long logmod_logger_get_counter(const struct logmod_logger *logger);
 
#define logmod_nlog(_level, _logger, _parenthesized_params, num_params)       \
    _logmod_log(_logger, __LINE__, __FILE__, LOGMOD_LEVEL_##_level,           \
                LOGMOD_SPREAD_TUPLE_##num_params _parenthesized_params)
 
#if __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
#define _logmod_log_permissive(_level, _logger, _line, _file, _fmt, ...)      \
    _logmod_log(_logger, _line, _file, _level, _fmt "%s", __VA_ARGS__)
 
#define logmod_log(_level, _logger, ...)                                      \
    _logmod_log_permissive(LOGMOD_LEVEL_##_level, _logger, __LINE__,          \
                           __FILE__, __VA_ARGS__, "")
#else
#define logmod_log logmod_nlog
#endif /* __STDC_VERSION__ */
 
LOGMOD_API logmod_err _logmod_log(const struct logmod_logger *logger,
                                  const unsigned line,
                                  const char *const filename,
                                  const unsigned level,
                                  const char *fmt,
                                  ...) LOGMOD_PRINTF_LIKE(5, 6);
 
#define LOGMOD_ENCODE(_style, _visibility, _color, buf)                       \
    "\x1b[" _style ";" _visibility _color "m" buf "\x1b[0m"
 
#define LOGMOD_ENCODE_STATIC(_style, _visibility, _color, buf)                \
    LOGMOD_ENCODE(LOGMOD_STYLE_##_style, LOGMOD_VISIBILITY_##_visibility,     \
                  LOGMOD_COLOR_##_color, buf)
 
#define LOGMOD_ENCODE_TOGGLE(_toggle, _style, _visibility, _color, buf)       \
    ((_toggle) ? LOGMOD_ENCODE_STATIC(_style, _visibility, _color, buf) : buf)
 
#define LOGMOD_ENCODE_LOGGER(_logger, _style, _visibility, _color, buf)       \
    LOGMOD_ENCODE_TOGGLE((_logger)->options.color, _style, _visibility,       \
                         _color, buf)
 
#define LMS LOGMOD_ENCODE_STATIC
#define LMT LOGMOD_ENCODE_TOGGLE
#define LML LOGMOD_ENCODE_LOGGER
#define LME LOGMOD_ENCODE
 
#define LOGMOD_SPREAD_TUPLE_0(_fmt)                 _fmt
#define LOGMOD_SPREAD_TUPLE_1(_fmt, _1)             _fmt, _1
#define LOGMOD_SPREAD_TUPLE_2(_fmt, _1, _2)         _fmt, _1, _2
#define LOGMOD_SPREAD_TUPLE_3(_fmt, _1, _2, _3)     _fmt, _1, _2, _3
#define LOGMOD_SPREAD_TUPLE_4(_fmt, _1, _2, _3, _4) _fmt, _2, _3, _4
#define LOGMOD_SPREAD_TUPLE_5(_fmt, _1, _2, _3, _4, _5)                       \
    _fmt, _1, _2, _3, _4, _5
#define LOGMOD_SPREAD_TUPLE_6(_fmt, _1, _2, _3, _4, _5, _6)                   \
    _fmt, _1, _2, _3, _4, _6
#define LOGMOD_SPREAD_TUPLE_7(_fmt, _1, _2, _3, _4, _5, _6, _7)               \
    _fmt, _1, _2, _3, _4, _5, _6, _7
#define LOGMOD_SPREAD_TUPLE_8(_fmt, _1, _2, _3, _4, _5, _6, _7, _8)           \
    _fmt, _1, _2, _3, _4, _5, _6, _7, _8
#define LOGMOD_SPREAD_TUPLE_9(_fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9)       \
    _fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9
#define LOGMOD_SPREAD_TUPLE_10(_fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) \
    _fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10
#define LOGMOD_SPREAD_TUPLE_11(_fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
                               _11)                                           \
    _fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11
#define LOGMOD_SPREAD_TUPLE_12(_fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
                               _11, _12)                                      \
    _fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12
#define LOGMOD_SPREAD_TUPLE_13(_fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
                               _11, _12, _13)                                 \
    _fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13
#define LOGMOD_SPREAD_TUPLE_14(_fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
                               _11, _12, _13, _14)                            \
    _fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14
#define LOGMOD_SPREAD_TUPLE_15(_fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
                               _11, _12, _13, _14, _15)                       \
    _fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15
#define LOGMOD_SPREAD_TUPLE_16(_fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
                               _11, _12, _13, _14, _15, _16)                  \
    _fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16
 
#ifndef LOGMOD_HEADER
 
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <stddef.h>
#include <string.h>
#include <time.h>
 
#include "logmod.h"
 
static const struct logmod_label default_labels[__LOGMOD_LEVEL_MAX] = {
    /*[LOGMOD_LEVEL_TRACE]:*/
    { "TRACE", LOGMOD_LABEL_COLOR(REGULAR, BACKGROUND_INTENSITY, BLUE), 0 },
    /*[LOGMOD_LEVEL_DEBUG]:*/
    { "DEBUG", LOGMOD_LABEL_COLOR(REGULAR, BACKGROUND, CYAN), 0 },
    /*[LOGMOD_LEVEL_INFO]: */
    { "INFO", LOGMOD_LABEL_COLOR(REGULAR, BACKGROUND, GREEN), 0 },
    /*[LOGMOD_LEVEL_WARN]: */
    { "WARN", LOGMOD_LABEL_COLOR(REGULAR, BACKGROUND, YELLOW), 1 },
    /*[LOGMOD_LEVEL_ERROR]:*/
    { "ERROR", LOGMOD_LABEL_COLOR(REGULAR, BACKGROUND, RED), 1 },
    /*[LOGMOD_LEVEL_FATAL]:*/
    { "FATAL", LOGMOD_LABEL_COLOR(REGULAR, BACKGROUND, MAGENTA), 1 },
};
 
#define LOGMOD_FROM_LOGGER(_ctx)                                              \
    ((struct logmod *)((char *)(_ctx)->counter                                \
                       - offsetof(struct logmod, counter)))
 
#define _LOGMOD_EXPECT(_cond, _error, _return)                                \
    do {                                                                      \
        if (!(_cond)) {                                                       \
            switch ((_error)) {                                               \
            case LOGMOD_BAD_PARAMETER:                                        \
                logmod_nlog(ERROR, NULL, ("Bad parameter: %s", #_cond), 1);   \
                break;                                                        \
            case LOGMOD_ERRNO:                                                \
                logmod_nlog(ERROR, NULL,                                      \
                            ("System error (check errno): %s", #_cond), 1);   \
                break;                                                        \
            default:                                                          \
                logmod_nlog(ERROR, NULL, ("Unknown error: %s", #_cond), 1);   \
                break;                                                        \
            }                                                                 \
            return (_return);                                                 \
        }                                                                     \
    } while (0)
 
#define LOGMOD_EXPECT(_cond, _error) _LOGMOD_EXPECT(_cond, _error, _error)
 
static void
_logmod_lock_noop(const struct logmod_logger *_, int __)
{
    (void)_;
    (void)__;
}
 
LOGMOD_API logmod_err
logmod_init(struct logmod *logmod,
            const char *const application_id,
            struct logmod_logger table[],
            unsigned length)
{
    size_t *mut_real_length = (size_t *)&logmod->real_length;
    LOGMOD_EXPECT(logmod != NULL, LOGMOD_BAD_PARAMETER);
    LOGMOD_EXPECT(application_id && *application_id, LOGMOD_BAD_PARAMETER);
    LOGMOD_EXPECT(table != NULL, LOGMOD_BAD_PARAMETER);
    LOGMOD_EXPECT(length > 0, LOGMOD_BAD_PARAMETER);
    memset(logmod, 0, sizeof *logmod);
    memset(table, 0, length * sizeof *table);
    logmod->application_id = application_id;
    logmod->loggers = table;
    *mut_real_length = length;
    logmod->lock = _logmod_lock_noop;
    return LOGMOD_OK;
}
 
LOGMOD_API logmod_err
logmod_cleanup(struct logmod *logmod)
{
    LOGMOD_EXPECT(logmod != NULL, LOGMOD_BAD_PARAMETER);
    if (logmod->loggers)
        memset((void *)logmod->loggers, 0,
               logmod->real_length * sizeof *logmod->loggers);
    memset(logmod, 0, sizeof *logmod);
    return LOGMOD_OK;
}
 
LOGMOD_API logmod_err
logmod_set_lock(struct logmod *logmod, logmod_lock lock)
{
    LOGMOD_EXPECT(logmod != NULL, LOGMOD_BAD_PARAMETER);
    logmod->lock = lock;
    return LOGMOD_OK;
}
 
LOGMOD_API logmod_err
logmod_set_options(struct logmod *logmod, struct logmod_options options)
{
    struct logmod_options *mut_default_options =
        (struct logmod_options *)&logmod->default_options;
    LOGMOD_EXPECT(logmod != NULL, LOGMOD_BAD_PARAMETER);
    *mut_default_options = options;
    return LOGMOD_OK;
}
 
LOGMOD_API logmod_err
logmod_toggle_logger(struct logmod *logmod, const char *const context_id)
{
    struct logmod_mut_logger *mut_logger =
        (struct logmod_mut_logger *)logmod_get_logger(logmod, context_id);
    LOGMOD_EXPECT(mut_logger != NULL, LOGMOD_BAD_PARAMETER);
    mut_logger->disabled = !mut_logger->disabled;
    return LOGMOD_OK;
}
 
LOGMOD_API logmod_err
logmod_logger_set_id_visibility(struct logmod_logger *logger,
                                int show_app_id,
                                int show_context_id)
{
    struct logmod_mut_logger *mut_logger = (struct logmod_mut_logger *)logger;
    LOGMOD_EXPECT(logger != NULL, LOGMOD_BAD_PARAMETER);
    mut_logger->options.show_application_id = show_app_id;
    mut_logger->options.hide_context_id = !show_context_id;
    return LOGMOD_OK;
}
 
LOGMOD_API logmod_err
logmod_logger_set_data(struct logmod_logger *logger, void *user_data)
{
    struct logmod_mut_logger *mut_logger = (struct logmod_mut_logger *)logger;
    LOGMOD_EXPECT(logger != NULL, LOGMOD_BAD_PARAMETER);
    mut_logger->user_data = user_data;
    return LOGMOD_OK;
}
 
LOGMOD_API logmod_err
logmod_logger_set_callback(struct logmod_logger *logger,
                           const struct logmod_label *const custom_labels,
                           const size_t num_custom_labels,
                           logmod_callback callback)
{
    struct logmod_mut_logger *mut_logger = (struct logmod_mut_logger *)logger;
    LOGMOD_EXPECT(logger != NULL, LOGMOD_BAD_PARAMETER);
    mut_logger->callback = callback;
    if (custom_labels != NULL) {
        LOGMOD_EXPECT(num_custom_labels > 0, LOGMOD_BAD_PARAMETER);
        mut_logger->custom_labels = custom_labels;
        mut_logger->num_custom_labels = num_custom_labels;
    }
    return LOGMOD_OK;
}
 
LOGMOD_API logmod_err
logmod_logger_set_options(struct logmod_logger *logger,
                          struct logmod_options options)
{
    struct logmod_mut_logger *mut_logger = (struct logmod_mut_logger *)logger;
    LOGMOD_EXPECT(logger != NULL, LOGMOD_BAD_PARAMETER);
    mut_logger->options = options;
    return LOGMOD_OK;
}
 
LOGMOD_API logmod_err
logmod_logger_set_quiet(struct logmod_logger *logger, int quiet)
{
    struct logmod_mut_logger *mut_logger = (struct logmod_mut_logger *)logger;
    LOGMOD_EXPECT(logger != NULL, LOGMOD_BAD_PARAMETER);
    mut_logger->options.quiet = quiet;
    return LOGMOD_OK;
}
 
LOGMOD_API logmod_err
logmod_logger_set_color(struct logmod_logger *logger, int color)
{
    struct logmod_mut_logger *mut_logger = (struct logmod_mut_logger *)logger;
    LOGMOD_EXPECT(logger != NULL, LOGMOD_BAD_PARAMETER);
    mut_logger->options.color = color;
    return LOGMOD_OK;
}
 
LOGMOD_API logmod_err
logmod_logger_set_level(struct logmod_logger *logger, unsigned level)
{
    struct logmod_mut_logger *mut_logger = (struct logmod_mut_logger *)logger;
    LOGMOD_EXPECT(logger != NULL, LOGMOD_BAD_PARAMETER);
    mut_logger->options.level = level;
    return LOGMOD_OK;
}
 
LOGMOD_API logmod_err
logmod_logger_set_logfile(struct logmod_logger *logger, FILE *logfile)
{
    struct logmod_mut_logger *mut_logger = (struct logmod_mut_logger *)logger;
    LOGMOD_EXPECT(logger != NULL, LOGMOD_BAD_PARAMETER);
    mut_logger->options.logfile = logfile;
    return LOGMOD_OK;
}
 
LOGMOD_API logmod_err
logmod_logger_set_time(struct logmod_logger *logger, int show_time)
{
    struct logmod_mut_logger *mut_logger = (struct logmod_mut_logger *)logger;
    LOGMOD_EXPECT(logger != NULL, LOGMOD_BAD_PARAMETER);
    mut_logger->options.suppress_time = !show_time;
    return LOGMOD_OK;
}
 
LOGMOD_API logmod_err
logmod_logger_set_counter(struct logmod_logger *logger, int show_counter)
{
    struct logmod_mut_logger *mut_logger = (struct logmod_mut_logger *)logger;
    LOGMOD_EXPECT(logger != NULL, LOGMOD_BAD_PARAMETER);
    mut_logger->options.hide_counter = !show_counter;
    return LOGMOD_OK;
}
 
LOGMOD_API const struct logmod_label *
logmod_logger_get_label(const struct logmod_logger *logger,
                        const unsigned level)
{
    static const struct logmod_label unknown_label = {
        "#UNKNOWN LABEL!!",
        LOGMOD_LABEL_COLOR(STRIKETHROUGH, BACKGROUND_INTENSITY, YELLOW), 1
    };
    if (level < LOGMOD_LEVEL_CUSTOM) {
        return &default_labels[level];
    }
    if (logger && level >= LOGMOD_LEVEL_CUSTOM
        && level < (LOGMOD_LEVEL_CUSTOM + logger->num_custom_labels))
    {
        return &logger->custom_labels[level - LOGMOD_LEVEL_CUSTOM];
    }
    logmod_nlog(ERROR, NULL,
                ("Invalid log level %u for logger %s", level,
                 logger ? logger->context_id : "NULL"),
                2);
    return &unknown_label;
}
 
LOGMOD_API long
logmod_logger_get_level(const struct logmod_logger *logger,
                        const char *const label)
{
    size_t i;
    LOGMOD_EXPECT(logger != NULL, LOGMOD_BAD_PARAMETER);
    LOGMOD_EXPECT(label != NULL, LOGMOD_BAD_PARAMETER);
    for (i = 0; i < __LOGMOD_LEVEL_MAX; ++i) {
        if (strcmp(label, default_labels[i].name) == 0) {
            return (long)i;
        }
    }
    for (i = 0; i < logger->num_custom_labels; ++i) {
        if (strcmp(label, logger->custom_labels[i].name) == 0) {
            return (long)(i + LOGMOD_LEVEL_CUSTOM);
        }
    }
    return LOGMOD_BAD_PARAMETER;
}
 
LOGMOD_API long
logmod_logger_get_counter(const struct logmod_logger *logger)
{
    struct logmod *logmod = LOGMOD_FROM_LOGGER(logger);
    long counter;
    LOGMOD_EXPECT(logmod != NULL, LOGMOD_BAD_PARAMETER);
    logmod->lock(logger, 1);
    counter = logmod->counter;
    logmod->lock(logger, 0);
    return counter;
}
 
LOGMOD_API struct logmod_logger *
logmod_get_logger(struct logmod *logmod, const char *const context_id)
{
    size_t i;
    _LOGMOD_EXPECT(logmod != NULL, LOGMOD_BAD_PARAMETER, NULL);
    _LOGMOD_EXPECT(logmod->loggers != NULL, LOGMOD_BAD_PARAMETER, NULL);
    _LOGMOD_EXPECT(context_id != NULL, LOGMOD_BAD_PARAMETER, NULL);
    logmod->lock(NULL, 1);
    for (i = 0; i < logmod->length; ++i) {
        if (0 == strcmp(logmod->loggers[i].context_id, context_id)) {
            struct logmod_logger *logger =
                (struct logmod_logger *)&logmod->loggers[i];
            logmod->lock(logger, 0);
            return logger;
        }
    }
    if (logmod->length < logmod->real_length) {
        size_t *mut_length = (size_t *)&logmod->length;
        struct logmod_mut_logger *mut_logger =
            (struct logmod_mut_logger *)&logmod->loggers[logmod->length];
        memset(mut_logger, 0, sizeof *mut_logger);
        mut_logger->context_id = context_id;
        mut_logger->counter = &logmod->counter;
        mut_logger->options = logmod->default_options;
        ++*mut_length;
        logmod->lock((struct logmod_logger *)mut_logger, 0);
        return (struct logmod_logger *)mut_logger;
    }
    logmod->lock(NULL, 0);
    return NULL;
}
 
static logmod_err
_logmod_print(const struct logmod_logger *logger,
              const struct logmod_info *info,
              const char *fmt,
              va_list args,
              const int color,
              FILE *output)
{
    if (!logger->options.hide_counter) {
        LOGMOD_EXPECT(fprintf(output,
                              LMT(color, BOLD, FOREGROUND, WHITE, "%-3ld "),
                              logmod_logger_get_counter(logger))
                          >= 0,
                      LOGMOD_ERRNO);
    }
    if (!logger->options.suppress_time) {
        LOGMOD_EXPECT(
            fprintf(output,
                    LMT(color, UNDERLINE, FOREGROUND, WHITE, "%02d:%02d:%02d"),
                    info->time.tm_hour, info->time.tm_min, info->time.tm_sec)
                >= 0,
            LOGMOD_ERRNO);
        LOGMOD_EXPECT(putc(' ', output) != EOF, LOGMOD_ERRNO);
    }
    if (logger->options.show_application_id) {
        const struct logmod *logmod = LOGMOD_FROM_LOGGER(logger);
        LOGMOD_EXPECT(fprintf(output,
                              LMT(color, BOLD, FOREGROUND, BLACK, "%s"),
                              logmod->application_id)
                          >= 0,
                      LOGMOD_ERRNO);
        LOGMOD_EXPECT(fputs(LMT(color, BOLD, FOREGROUND, BLACK, " » "), output)
                          != EOF,
                      LOGMOD_ERRNO);
    }
    if (!logger->options.hide_context_id) {
        LOGMOD_EXPECT(fprintf(output,
                              LMT(color, BOLD, FOREGROUND, WHITE, "%s"),
                              logger->context_id)
                          >= 0,
                      LOGMOD_ERRNO);
        LOGMOD_EXPECT(fputs(LMT(color, BOLD, FOREGROUND, WHITE, " » "), output)
                          != EOF,
                      LOGMOD_ERRNO);
    }
    if (color) {
        LOGMOD_EXPECT(fprintf(output,
                              LME("%s", "%s", "%s", "%s") " " LMS(
                                  REGULAR, FOREGROUND, YELLOW,
                                  "%s") LMS(BOLD, FOREGROUND, WHITE, ":")
                                  LMS(REGULAR, FOREGROUND, WHITE, "%d") ": ",
                              info->label->style, info->label->visibility,
                              info->label->color, info->label->name,
                              info->filename, info->line)
                          >= 0,
                      LOGMOD_ERRNO);
    }
    else {
        LOGMOD_EXPECT(fprintf(output, "%s %s:%d: ", info->label->name,
                              info->filename, info->line)
                          >= 0,
                      LOGMOD_ERRNO);
    }
    LOGMOD_EXPECT(vfprintf(output, fmt, args) >= 0, LOGMOD_ERRNO);
    LOGMOD_EXPECT(putc('\n', output) != EOF, LOGMOD_ERRNO);
    LOGMOD_EXPECT(fflush(output) != EOF, LOGMOD_ERRNO);
    return LOGMOD_OK;
}
 
static struct logmod g_logmod;
 
static struct logmod_logger g_loggers[] = {
    {
        LOGMOD_FALLBACK_CONTEXT_ID,
        { NULL, 0, 1 },
        &g_logmod.counter,
        NULL,
        NULL,
        default_labels,
        0,
    },
};
static struct logmod g_logmod = {
    LOGMOD_FALLBACK_APPLICATION_ID,
    g_loggers,
    sizeof(g_loggers) / sizeof *g_loggers,
    sizeof(g_loggers) / sizeof *g_loggers,
    0,
    { NULL, 0, 1 },
    _logmod_lock_noop,
};
 
static struct logmod_info
_logmod_info_populate(const struct logmod_logger *logger,
                      const unsigned line,
                      const char *const filename,
                      const unsigned level)
{
    const struct logmod *logmod = LOGMOD_FROM_LOGGER(logger);
    const time_t time_raw = time(NULL);
    struct logmod_info info;
    unsigned *mut_line = (unsigned *)&info.line;
    const char **mut_filename = (const char **)&info.filename;
    unsigned *mut_level = (unsigned *)&info.level;
    const struct logmod_label **mut_label =
        (const struct logmod_label **)&info.label;
    struct tm *mut_time = (struct tm *)&info.time;
    *mut_line = line;
    *mut_filename = filename;
    *mut_level = level;
    *mut_label = logmod_logger_get_label(logger, level);
    logmod->lock(logger, 1);
    *mut_time = *localtime(&time_raw);
    logmod->lock(logger, 0);
    return info;
}
 
LOGMOD_API logmod_err
_logmod_log(const struct logmod_logger *logger,
            const unsigned line,
            const char *const filename,
            const unsigned level,
            const char *fmt,
            ...)
{
    struct logmod *logmod =
        LOGMOD_FROM_LOGGER(!logger ? (logger = &g_loggers[0]) : logger);
    logmod_err code = LOGMOD_OK_SKIPPED;
    if (!logger->disabled) {
        const struct logmod_info info =
            _logmod_info_populate(logger, line, filename, level);
        va_list args;
        code = LOGMOD_OK_CONTINUE;
        if (logger->callback) {
            va_start(args, fmt);
            if ((code = logger->callback(logger, &info, fmt, args))
                < LOGMOD_OK)
            {
                goto _end;
            }
            va_end(args);
        }
        if (level >= logger->options.level && code == LOGMOD_OK_CONTINUE) {
            if (!logger->options.quiet || level == LOGMOD_LEVEL_FATAL) {
                va_start(args, fmt);
                if ((code = _logmod_print(
                         logger, &info, fmt, args, logger->options.color,
                         info.label->output == 0 ? stdout : stderr))
                    != LOGMOD_OK)
                {
                    goto _end;
                }
                va_end(args);
            }
            if (logger->options.logfile) {
                va_start(args, fmt);
                code = _logmod_print(logger, &info, fmt, args, 0,
                                     logger->options.logfile);
            }
        }
    _end:
        logmod->lock(logger, 1);
        ++logmod->counter;
        logmod->lock(logger, 0);
        va_end(args);
    }
    return code;
}
 
#undef LOGMOD_EXPECT
 
#endif /* LOGMOD_HEADER */
 
#ifdef __cplusplus
}
#endif /* __cplusplus */
 
#endif /* LOGMOD_H */