sol-log.h

Go to the documentation of this file.

/*
 * This file is part of the Soletta (TM) Project
 *
 * Copyright (C) 2015 Intel Corporation. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#pragma once

#include "sol-common-buildopts.h"

#include "sol-macros.h"
#include <inttypes.h>
#include <stdint.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <sys/types.h>

#ifdef __cplusplus

template <typename T> inline const char *sol_int_format(T) { return NULL; }
template <> inline const char *sol_int_format<int>(int) { return "%d"; }
template <> inline const char *sol_int_format<long>(long) { return "%ld"; }
template <> inline const char *sol_int_format<long long>(long long) { return "%lld"; }
template <> inline const char *sol_int_format<short>(short) { return "%hd"; }
template <> inline const char *sol_int_format<signed char>(signed char) { return "%hhd"; }
template <> inline const char *sol_int_format<unsigned>(unsigned) { return "%u"; }
template <> inline const char *sol_int_format<unsigned long>(unsigned long) { return "%lu"; }
template <> inline const char *sol_int_format<unsigned long long>(unsigned long long) { return "%llu"; }
template <> inline const char *sol_int_format<unsigned short>(unsigned short) { return "%hu"; }
template <> inline const char *sol_int_format<unsigned char>(unsigned char) { return "%hhu"; }

#define SOL_INT_CHECK_IMPL(var, exp, ...) \
    do { \
        if (SOL_UNLIKELY((var)exp)) { \
            char *str = (char *)alloca(snprintf(NULL, 0, "%s (%s) %s", #var, sol_int_format(var),  #exp) + 1); \
            sprintf(str, "%s (%s) %s", #var, sol_int_format(var), #exp); \
            SOL_WRN(str, var); \
            return __VA_ARGS__; \
        } \
    } while (0)

#define SOL_INT_CHECK_GOTO_IMPL(var, exp, label) \
    do { \
        if (SOL_UNLIKELY((var)exp)) { \
            char *str = (char *)alloca(snprintf(NULL, 0, "%s (%s) %s", #var, sol_int_format(var),  #exp) + 1); \
            sprintf(str, "%s (%s) %s", #var, sol_int_format(var), #exp); \
            SOL_WRN(str, var); \
            goto label; \
        } \
    } while (0)

#define SOL_INT_CHECK_GOTO_IMPL_ERRNO(var, exp, err, label) \
    do { \
        if (SOL_UNLIKELY((var)exp)) { \
            char *str = (char *)alloca(snprintf(NULL, 0, "%s (%s) %s", \
                # var, sol_int_format(var),  # exp) + 1); \
            sprintf(str, "%s (%s) %s", # var, sol_int_format(var), # exp); \
            SOL_WRN(str, var); \
            errno = err; \
            goto label; \
        } \
    } while (0)

#define SOL_INT_CHECK_IMPL_ERRNO(var, exp, err, ...) \
    do { \
        if (SOL_UNLIKELY((var)exp)) { \
            char *str = (char *)alloca(snprintf(NULL, 0, "%s (%s) %s", \
                # var, sol_int_format(var),  # exp) + 1); \
            sprintf(str, "%s (%s) %s", # var, sol_int_format(var), # exp); \
            SOL_WRN(str, var); \
            errno = err; \
            return __VA_ARGS__; \
        } \
    } while (0)

#else

#define _SOL_INT_CHECK_FMT(var) \
    __builtin_choose_expr( \
    __builtin_types_compatible_p(__typeof__(var), int), \
    "" # var " (%d) %s", \
    __builtin_choose_expr( \
    __builtin_types_compatible_p(__typeof__(var), long), \
    "" # var " (%ld) %s", \
    __builtin_choose_expr( \
    __builtin_types_compatible_p(__typeof__(var), size_t), \
    "" # var " (%zu) %s", \
    __builtin_choose_expr( \
    __builtin_types_compatible_p(__typeof__(var), unsigned), \
    "" # var " (%u) %s", \
    __builtin_choose_expr( \
    __builtin_types_compatible_p(__typeof__(var), uint64_t), \
    "" # var " (%" PRIu64 ") %s", \
    __builtin_choose_expr( \
    __builtin_types_compatible_p(__typeof__(var), uint32_t), \
    "" # var " (%" PRIu32 ") %s", \
    __builtin_choose_expr( \
    __builtin_types_compatible_p(__typeof__(var), uint16_t), \
    "" # var " (%" PRIu16 ") %s", \
    __builtin_choose_expr( \
    __builtin_types_compatible_p(__typeof__(var), uint8_t), \
    "" # var " (%" PRIu8 ") %s", \
    __builtin_choose_expr( \
    __builtin_types_compatible_p(__typeof__(var), int64_t), \
    "" # var " (%" PRId64 ") %s", \
    __builtin_choose_expr( \
    __builtin_types_compatible_p(__typeof__(var), int32_t), \
    "" # var " (%" PRId32 ") %s", \
    __builtin_choose_expr( \
    __builtin_types_compatible_p(__typeof__(var), int16_t), \
    "" # var " (%" PRId16 ") %s", \
    __builtin_choose_expr( \
    __builtin_types_compatible_p(__typeof__(var), int8_t), \
    "" # var " (%" PRId8 ") %s", \
    __builtin_choose_expr( \
    __builtin_types_compatible_p(__typeof__(var), ssize_t), \
    "" # var " (%zd) %s", \
    (void)0)))))))))))))

#define SOL_INT_CHECK_IMPL(var, exp, ...) \
    do { \
        if (SOL_UNLIKELY((var)exp)) { \
            SOL_WRN(_SOL_INT_CHECK_FMT(var), var, # exp); \
            return __VA_ARGS__; \
        } \
    } while (0)

#define SOL_INT_CHECK_GOTO_IMPL(var, exp, label) \
    do { \
        if (SOL_UNLIKELY((var)exp)) { \
            SOL_WRN(_SOL_INT_CHECK_FMT(var), var, # exp); \
            goto label; \
        } \
    } while (0)

#define SOL_INT_CHECK_GOTO_IMPL_ERRNO(var, exp, err, label) \
    do { \
        if (SOL_UNLIKELY((var)exp)) { \
            SOL_WRN(_SOL_INT_CHECK_FMT(var), var, # exp); \
            errno = err; \
            goto label; \
        } \
    } while (0)

#define SOL_INT_CHECK_IMPL_ERRNO(var, exp, err, ...) \
    do { \
        if (SOL_UNLIKELY((var)exp)) { \
            SOL_WRN(_SOL_INT_CHECK_FMT(var), var, # exp); \
            errno = err; \
            return __VA_ARGS__; \
        } \
    } while (0)

#endif

#ifdef __cplusplus
extern "C" {
#endif

#define SOL_LOG_COLOR_LIGHTRED    "\033[31;1m" 
#define SOL_LOG_COLOR_RED          "\033[31m" 
#define SOL_LOG_COLOR_LIGHTBLUE    "\033[34;1m" 
#define SOL_LOG_COLOR_BLUE         "\033[34m" 
#define SOL_LOG_COLOR_GREEN        "\033[32;1m" 
#define SOL_LOG_COLOR_YELLOW       "\033[33;1m" 
#define SOL_LOG_COLOR_ORANGE       "\033[0;33m" 
#define SOL_LOG_COLOR_WHITE        "\033[37;1m" 
#define SOL_LOG_COLOR_LIGHTMAGENTA "\033[35;1m" 
#define SOL_LOG_COLOR_MAGENTA      "\033[35m" 
#define SOL_LOG_COLOR_LIGHTCYAN    "\033[36;1m" 
#define SOL_LOG_COLOR_CYAN         "\033[36m" 
#define SOL_LOG_COLOR_RESET        "\033[0m" 
#define SOL_LOG_COLOR_HIGH         "\033[1m" 
#define SOL_NULL_CHECK(ptr, ...) \
    do { \
        if (SOL_UNLIKELY(!(ptr))) { \
            SOL_WRN("%s == NULL", # ptr); \
            return __VA_ARGS__; \
        } \
    } while (0)

#define SOL_NULL_CHECK_ERRNO(ptr, err, ...) \
    do { \
        if (SOL_UNLIKELY(!(ptr))) { \
            SOL_WRN("%s == NULL", # ptr); \
            errno = err; \
            return __VA_ARGS__; \
        } \
    } while (0)

#define SOL_NULL_CHECK_GOTO(ptr, label) \
    do { \
        if (SOL_UNLIKELY(!(ptr))) { \
            SOL_WRN("%s == NULL", # ptr); \
            goto label; \
        } \
    } while (0)

#define SOL_NULL_CHECK_MSG(ptr, ret, fmt, ...) \
    do { \
        if (SOL_UNLIKELY(!(ptr))) { \
            SOL_WRN(fmt, ## __VA_ARGS__); \
            return ret; \
        } \
    } while (0)

#define SOL_NULL_CHECK_MSG_GOTO(ptr, label, fmt, ...) \
    do { \
        if (SOL_UNLIKELY(!(ptr))) { \
            SOL_WRN(fmt, ## __VA_ARGS__); \
            goto label; \
        } \
    } while (0)

#define SOL_INT_CHECK(var, exp, ...) \
    SOL_INT_CHECK_IMPL(var, exp, __VA_ARGS__)

#define SOL_INT_CHECK_ERRNO(var, exp, err, ...) \
    SOL_INT_CHECK_IMPL_ERRNO(var, exp, err, __VA_ARGS__)

#define SOL_INT_CHECK_GOTO(var, exp, label) \
    SOL_INT_CHECK_GOTO_IMPL(var, exp, label)

#define SOL_INT_CHECK_GOTO_ERRNO(var, exp, err, label) \
    SOL_INT_CHECK_GOTO_IMPL_ERRNO(var, exp, label)

#define SOL_EXP_CHECK(exp, ...) \
    do { \
        if (SOL_UNLIKELY((exp))) { \
            SOL_WRN("(%s) is true", # exp); \
            return __VA_ARGS__; \
        } \
    } while (0)

#define SOL_EXP_CHECK_GOTO(exp, label) \
    do { \
        if (SOL_UNLIKELY((exp))) { \
            SOL_WRN("(%s) is true", # exp); \
            goto label; \
        } \
    } while (0)

enum sol_log_level {
    SOL_LOG_LEVEL_CRITICAL = 0, 
    SOL_LOG_LEVEL_ERROR, 
    SOL_LOG_LEVEL_WARNING, 
    SOL_LOG_LEVEL_INFO, 
    SOL_LOG_LEVEL_DEBUG 
};

typedef struct sol_log_domain {
    const char *color; 
    const char *name; 
    uint8_t level; 
} sol_log_domain;

extern struct sol_log_domain *sol_log_global_domain;

#ifdef SOL_LOG_ENABLED
void sol_log_domain_init_level(struct sol_log_domain *domain);
void sol_log_init_level_global(const char *str, size_t length);
void sol_log_init_levels(const char *str, size_t length);

#ifdef SOL_LOG_LEVEL
#define SOL_LOG_LEVEL_INIT() \
    sol_log_init_level_global(SOL_LOG_LEVEL, sizeof(SOL_LOG_LEVEL) - 1)
#else
#define SOL_LOG_LEVEL_INIT()
#endif

#ifdef SOL_LOG_LEVELS
#define SOL_LOG_LEVELS_INIT() \
    sol_log_init_levels(SOL_LOG_LEVELS, sizeof(SOL_LOG_LEVELS) - 1)
#else
#define SOL_LOG_LEVELS_INIT()
#endif

#else
static inline void
sol_log_domain_init_level(struct sol_log_domain *domain)
{
}

#define SOL_LOG_LEVEL_INIT()
#define SOL_LOG_LEVELS_INIT()

#endif

#ifndef SOL_LOG_DOMAIN

#define SOL_LOG_DOMAIN sol_log_global_domain
#endif

#if 0
#define SOL_LOG_LEVEL_MAXIMUM SOL_LOG_LEVEL_WARNING
#endif

#ifdef SOL_LOG_ENABLED
#ifdef SOL_LOG_LEVEL_MAXIMUM
#define SOL_LOG_LEVEL_POSSIBLE(level) (level <= SOL_LOG_LEVEL_MAXIMUM)
#else
#define SOL_LOG_LEVEL_POSSIBLE(level) (1)
#endif
#else
#ifdef SOL_LOG_LEVEL_MAXIMUM
#undef SOL_LOG_LEVEL_MAXIMUM
#endif
#define SOL_LOG_LEVEL_MAXIMUM -1
#define SOL_LOG_LEVEL_POSSIBLE(level) (0)
#endif

#ifdef SOL_LOG_FILES
#define SOL_LOG_FILE __FILE__
#else
#define SOL_LOG_FILE ""
#endif

#ifdef SOL_LOG_FUNCTIONS
#define SOL_LOG_FUNCTION __PRETTY_FUNCTION__
#else
#define SOL_LOG_FUNCTION ""
#endif

#define SOL_LOG(level, fmt, ...) \
    do { \
        if (SOL_LOG_LEVEL_POSSIBLE(level)) { \
            sol_log_print(SOL_LOG_DOMAIN, level, \
                SOL_LOG_FILE, SOL_LOG_FUNCTION,  __LINE__, \
                fmt, ## __VA_ARGS__); \
        } \
    } while (0)

#define SOL_CRI(fmt, ...) SOL_LOG(SOL_LOG_LEVEL_CRITICAL, fmt, ## __VA_ARGS__)

#define SOL_ERR(fmt, ...) SOL_LOG(SOL_LOG_LEVEL_ERROR, fmt, ## __VA_ARGS__)

#define SOL_WRN(fmt, ...) SOL_LOG(SOL_LOG_LEVEL_WARNING, fmt, ## __VA_ARGS__)

#define SOL_INF(fmt, ...) SOL_LOG(SOL_LOG_LEVEL_INFO, fmt, ## __VA_ARGS__)

#define SOL_DBG(fmt, ...) SOL_LOG(SOL_LOG_LEVEL_DEBUG, fmt, ## __VA_ARGS__)

#ifdef SOL_LOG_ENABLED
void sol_log_print(const struct sol_log_domain *domain, uint8_t message_level, const char *file, const char *function, int line, const char *format, ...) SOL_ATTR_PRINTF(6, 7) SOL_ATTR_NO_INSTRUMENT;

void sol_log_vprint(const struct sol_log_domain *domain, uint8_t message_level, const char *file, const char *function, int line, const char *format, va_list args) SOL_ATTR_PRINTF(6, 0) SOL_ATTR_NO_INSTRUMENT;
#else
static inline void
sol_log_print(const struct sol_log_domain *domain, uint8_t message_level, const char *file, const char *function, int line, const char *format, ...)
{
}
static inline void
sol_log_vprint(const struct sol_log_domain *domain, uint8_t message_level, const char *file, const char *function, int line, const char *format, va_list args)
{
}
#endif

#ifdef SOL_LOG_ENABLED
void sol_log_set_print_function(void (*print)(void *data, const struct sol_log_domain *domain, uint8_t message_level, const char *file, const char *function, int line, const char *format, va_list args), const void *data);
#else
static inline void
sol_log_set_print_function(void (*print)(void *data, const struct sol_log_domain *domain, uint8_t message_level, const char *file, const char *function, int line, const char *format, va_list args), const void *data)
{
}
#endif

#ifdef SOL_LOG_ENABLED
void sol_log_print_function_stderr(void *data, const struct sol_log_domain *domain, uint8_t message_level, const char *file, const char *function, int line, const char *format, va_list args) SOL_ATTR_PRINTF(7, 0);
#else
static inline void
sol_log_print_function_stderr(void *data, const struct sol_log_domain *domain, uint8_t message_level, const char *file, const char *function, int line, const char *format, va_list args)
{
}
#endif

#ifdef SOL_PLATFORM_LINUX

#ifdef SOL_LOG_ENABLED
void sol_log_print_function_file(void *data, const struct sol_log_domain *domain, uint8_t message_level, const char *file, const char *function, int line, const char *format, va_list args) SOL_ATTR_PRINTF(7, 0);
#else
static inline void
sol_log_print_function_file(void *data, const struct sol_log_domain *domain, uint8_t message_level, const char *file, const char *function, int line, const char *format, va_list args)
{
}
#endif
#endif

#ifdef SOL_PLATFORM_LINUX

#ifdef SOL_LOG_ENABLED
void sol_log_print_function_syslog(void *data, const struct sol_log_domain *domain, uint8_t message_level, const char *syslog, const char *function, int line, const char *format, va_list args) SOL_ATTR_PRINTF(7, 0);
#else
static inline void
sol_log_print_function_syslog(void *data, const struct sol_log_domain *domain, uint8_t message_level, const char *syslog, const char *function, int line, const char *format, va_list args)
{
}
#endif
#endif

#ifdef SOL_PLATFORM_LINUX

#ifdef SOL_LOG_ENABLED
void sol_log_print_function_journal(void *data, const struct sol_log_domain *domain, uint8_t message_level, const char *journal, const char *function, int line, const char *format, va_list args) SOL_ATTR_PRINTF(7, 0);
#else
static inline void
sol_log_print_function_journal(void *data, const struct sol_log_domain *domain, uint8_t message_level, const char *journal, const char *function, int line, const char *format, va_list args)
{
}
#endif
#endif

#ifdef SOL_LOG_ENABLED
/*
 * Those implementing custom logging functions may use the following getters
 */
void sol_log_level_to_str(uint8_t level, char *buf, size_t buflen);
const char *sol_log_get_level_color(uint8_t level);
uint8_t sol_log_get_abort_level(void);
uint8_t sol_log_get_level(void);
bool sol_log_get_show_colors(void);
bool sol_log_get_show_file(void);
bool sol_log_get_show_function(void);
bool sol_log_get_show_line(void);

/*
 * To force some logging setting independent of platform initializations,
 * use the following setters
 */
void sol_log_set_abort_level(uint8_t level);
void sol_log_set_level(uint8_t level);
void sol_log_set_show_colors(bool enabled);
void sol_log_set_show_file(bool enabled);
void sol_log_set_show_function(bool enabled);
void sol_log_set_show_line(bool enabled);
#else
static inline void
sol_log_level_to_str(uint8_t level, char *buf, size_t buflen)
{
}
static inline const char *
sol_log_get_level_color(uint8_t level)
{
    return "";
}
static inline uint8_t
sol_log_get_abort_level(void)
{
    return 0;
}
static inline uint8_t
sol_log_get_level(void)
{
    return 0;
}
static inline bool
sol_log_get_show_colors(void)
{
    return false;
}
static inline bool
sol_log_get_show_file(void)
{
    return false;
}
static inline bool
sol_log_get_show_function(void)
{
    return false;
}
static inline bool
sol_log_get_show_line(void)
{
    return false;
}
static inline void
sol_log_set_abort_level(uint8_t level)
{
}
static inline void
sol_log_set_level(uint8_t level)
{
}
static inline void
sol_log_set_show_colors(bool enabled)
{
}
static inline void
sol_log_set_show_file(bool enabled)
{
}
static inline void
sol_log_set_show_function(bool enabled)
{
}
static inline void
sol_log_set_show_line(bool enabled)
{
}
#endif

#ifdef __cplusplus
}
#endif