gp_common.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-2.1-or-later
/*
 * Copyright (C) 2009-2012 Jiri "BlueBear" Dluhos
 *                         <jiri.bluebear.dluhos@gmail.com>
 *
 * Copyright (C) 2009-2024 Cyril Hrubis <metan@ucw.cz>
 */
 
#ifndef CORE_GP_COMMON_H
#define CORE_GP_COMMON_H
 
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <unistd.h>
#include <stddef.h>
 
#include <core/gp_compiler.h>
 
#define GP_MIN(a, b) ({ \
        typeof(a) gp_a_tmp = (a); \
        typeof(b) gp_b_tmp = (b); \
        gp_a_tmp < gp_b_tmp ? gp_a_tmp : gp_b_tmp; \
})
 
#define GP_MIN3(a, b, c) ({ \
        typeof(a) gp_a_tmp = (a); \
        typeof(b) gp_b_tmp = (b); \
        typeof(c) gp_c_tmp = (c); \
        gp_a_tmp < gp_b_tmp ? (gp_a_tmp < gp_c_tmp ? gp_a_tmp : gp_c_tmp) : (gp_b_tmp < gp_c_tmp ? gp_b_tmp : gp_c_tmp); \
})
 
#define GP_MAX(a, b) ({ \
        typeof(a) gp_a_tmp = (a); \
        typeof(b) gp_b_tmp = (b); \
        gp_a_tmp > gp_b_tmp ? gp_a_tmp : gp_b_tmp; \
})
 
#define GP_MAX3(a, b, c) ({ \
        typeof(a) gp_a_tmp = (a); \
        typeof(b) gp_b_tmp = (b); \
        typeof(c) gp_c_tmp = (c); \
        gp_a_tmp > gp_b_tmp ? (gp_a_tmp > gp_c_tmp ? gp_a_tmp : gp_c_tmp) : (gp_b_tmp > gp_c_tmp ? gp_b_tmp : gp_c_tmp); \
})
 
#define GP_CONCAT2(a, b) a##b
 
#define GP_UNIQUE_ID2(prefix, suffix) GP_CONCAT2(prefix, suffix)
 
#define GP_UNIQUE_ID(prefix) GP_UNIQUE_ID2(prefix, __COUNTER__)
 
#define GP_ABS(a) ({ \
        typeof(a) gp_a_tmp = a; \
        gp_a_tmp > 0 ? gp_a_tmp : - gp_a_tmp; \
})
 
#define GP_ABS_DIFF(a, b) ({ \
        typeof(a) gp_a_tmp = a; \
        typeof(b) gp_b_tmp = b; \
        gp_a_tmp > gp_b_tmp ? gp_a_tmp - gp_b_tmp : gp_b_tmp - gp_a_tmp; \
})
 
#define GP_ALIGN2(a) ({ \
        typeof(a) gp_a_tmp = a; \
        gp_a_tmp + (gp_a_tmp%2); \
})
 
#define GP_SWAP(a, b) do { \
        typeof(b) gp_b_tmp = b; \
        b = a; \
        a = gp_b_tmp; \
} while (0)
 
/* Determines the sign of the integer value; it is +1 if value is positive,
 * -1 if negative, and 0 if it is zero.
 */
#define GP_SIGN(a) ({ \
        typeof(a) gp_a_tmp = a; \
        (gp_a_tmp > 0) ? 1 : ((gp_a_tmp < 0) ? -1 : 0); \
})
 
#define GP_ARRAY_SIZE(array) (sizeof(array) / sizeof(*array))
 
#define GP_CONTAINER_OF(ptr, structure, member) \
        ((structure *)((char *)(ptr) - offsetof(structure, member)))
 
/*
 * Internal macros with common code for GP_ABORT, GP_ASSERT and GP_CHECK.
 * GP_INTERNAL_ABORT takes a message that may contain % (e.g. assert condition)
 * and prints message and calls abort().
 * GP_GENERAL_CHECK is a check with specified message prefix
 * (for assert and check)
 */
#define GP_INTERNAL_ABORT(...) do { \
        gp_print_abort_info(__FILE__, __FUNCTION__, __LINE__, __VA_ARGS__); \
        abort(); \
} while (0)
 
/*
 * Prints C stacktrace.
 */
void gp_debug_print_cstack(void);
 
/*
 * Print as much trace info as possible. Currently, the (C) call stack and
 * the Python stack if a Python interpreter is set up. In case more wrappers
 * are written, it should print a trace for the currently active.
 */
void gp_print_abort_info(const char *file, const char *function, unsigned int line,
                         const char *msg, const char *fmt, ...)
                         __attribute__ ((format (printf, 5, 6)));
 
#define GP_GENERAL_CHECK(gp_check_cond, gp_check_message, ...) do { \
        if (GP_UNLIKELY(!(gp_check_cond))) { \
                if (#__VA_ARGS__ [0]) \
                        GP_INTERNAL_ABORT(gp_check_message #gp_check_cond, \
                                          "\n" __VA_ARGS__); \
                else \
                        GP_INTERNAL_ABORT(gp_check_message #gp_check_cond, " "); \
        } \
} while (0)
 
/*
 * Aborts and prints the message along with the location in code
 * to stderr. Used for fatal errors.
 *
 * Use as either GP_ABORT(msg) or GP_ABORT(format, params...) where
 * msg and format must be string constants.
 */
#define GP_ABORT(...) \
        GP_INTERNAL_ABORT("\n", __VA_ARGS__)
 
/*
 * Checks the condition and aborts immediately if it is not satisfied,
 * printing the condition and location in the source.
 * (Intended for checking for bugs within the library itself.)
 *
 * Use as either GP_ASSERT(cond), GP_ASSERT(cond, msg) or
 * GP_ASSERT(cond, format, params...) where msg and format must be string
 * constants.
 */
#define GP_ASSERT(gp_check_cond, ...) \
        GP_GENERAL_CHECK(gp_check_cond, "assertion failed: ", ##__VA_ARGS__)
 
/*
 * Perform a runtime check, on failure abort and print a message.
 * (Intended for user-caused errors like invalid arguments.)
 *
 * Use as either GP_CHECK(cond), GP_CHECK(cond, msg) or
 * GP_CHECK(cond, format, params...) where msg and format must be string
 * constants.
 */
#define GP_CHECK(gp_check_cond, ...) \
        GP_GENERAL_CHECK(gp_check_cond, "check failed: ", ##__VA_ARGS__)
 
#endif /* CORE_GP_COMMON_H */