common.h

Go to the documentation of this file.

/*
 * SPDX-License-Identifier: GPL-3.0-only
 * This file is part of Lazuli.
 */
 
#ifndef LAZULI_COMMON_H
#define LAZULI_COMMON_H
 
#include <stdint.h>
 
#include <Lazuli/common_asm.h>
 
#ifdef __cplusplus
 
#define _EXTERN_C_DECL_BEGIN extern "C" {
 
#define _EXTERN_C_DECL_END }
 
#else /* __cplusplus */
 
#define _EXTERN_C_DECL_BEGIN
 
#define _EXTERN_C_DECL_END
 
#endif /* __cplusplus */
 
#define UNUSED(X) ((void)(X))
 
#define STATIC_ASSERT(C, M) extern char _static_assertion_##M[(C) ? 1 : -1]
 
#define NULL ((void *)0)
 
typedef int ptrdiff_t;
 
typedef uint8_t bool;
 
STATIC_ASSERT(sizeof(bool) == 1, bool_MUST_be_1_byte_long);
#define true ((bool)1)
 
#define false ((bool)0)
 
/* TODO: Not portable!!! */
typedef uint16_t size_t;
 
/* TODO: Arch specific */
typedef uint8_t u_read_write_atomic_t;
 
#define ALLOW_ARITHM(X) ((uint8_t *)(X))
 
STATIC_ASSERT(sizeof(uint8_t) == 1,
              uint8_t_MUST_be_1_byte_long_to_allow_arithmetic_on_void_pointers);
#define STATIC_CHECK_TYPE(V, T) UNUSED(1 ? (T*)0 : &(V))
 
#define SET_BITS(V, T, X)                           \
  do {                                              \
    STATIC_CHECK_TYPE(V, T);                        \
    (V) |= (T)(X);                                  \
  } while (0)
 
#define CLEAR_BITS(V, T, X)                     \
  do {                                          \
    STATIC_CHECK_TYPE(V, T);                    \
    (V) &= (T)(~(X));                           \
  } while (0)
 
#define INDIRECT_T(X, T) ((volatile T *)(X))
 
#define INDIRECT(X) INDIRECT_T(X, uint8_t)
 
#define DIRECT_T(X, T) (*INDIRECT_T(X, T))
 
#define DIRECT(X) DIRECT_T(X, uint8_t)
 
#define LO8(X) ((uint8_t)(X))
 
#define HI8(X) LO8((X) >> 8U)
 
#define MIN(A, B) (((A) < (B)) ? (A) : (B))
 
#define MAX(A, B) (((A) < (B)) ? (B) : (A))
 
#define ABS(A) (((A) < 0) ? (-(A)) : (A))
 
#define OFFSET_OF(M, T)                         \
  ((size_t)(&(((T*)0)->M)))
 
#define CONTAINER_OF(P, M, T)                                   \
  ((T*) ((uint8_t*) (1 ? (P) : &(((T*)0)->M)) - OFFSET_OF(M, T)))
 
#define NAME_OF(X) #X
 
#define ELEMENTS_COUNT(X) ((size_t)(sizeof(X) / sizeof((X)[0])))
 
#define DEPENDENCY_ON_MODULE(X) \
  STATIC_ASSERT(LZ_CONFIG_MODULE_ ## X ## _USED, Module_ ## X ## _must_be_used)
 
#endif /* LAZULI_COMMON_H */