// in some foo.h file
#include "x.h"

// in some foo.c file
#include "x.h"

#ifndef X_ENABLE_ATOMIC
#define X_ENABLE_ATOMIC (0)
#endif

#ifndef X_ENABLE_CONCURRENCY
#define X_ENABLE_CONCURRENCY (0)
#endif

#ifndef X_ENABLE_CUDA
#define X_ENABLE_CUDA (0)
#endif

#ifndef X_ENABLE_SOCKET
#define X_ENABLE_SOCKET (0)
#endif

#ifndef X_ENABLE_STRUCT_FUNCTION
#define X_ENABLE_STRUCT_FUNCTION (1)
#endif

#ifndef X_EXPORT
#if X_WINDOWS
#define X_EXPORT __declspec(dllexport)
#else
#define X_EXPORT __attribute__ ((visibility("default")))
#endif
#endif

#ifndef X_IMPORT
#if X_WINDOWS
#define X_IMPORT __declspec(dllimport)
#else
#define X_IMPORT __attribute__ ((visibility("hidden")))
#endif
#endif

#define X_KEY_ESC   (0x1B)
#define X_KEY_A     (0x41)
#define X_KEY_B     (0x42)
#define X_KEY_C     (0x43)
#define X_KEY_D     (0x44)
#define X_KEY_Q     (0x51)
#if X_WINDOWS
#define X_KEY_LEFT  (0x4B)
#define X_KEY_UP    (0x48)
#define X_KEY_RIGHT (0x4D)
#define X_KEY_DOWN  (0x50)
#else
#define X_KEY_LEFT  (-1)
#define X_KEY_UP    (-2)
#define X_KEY_RIGHT (-3)
#define X_KEY_DOWN  (-4)
#endif

x_assert(expr)

x_assert(1 == 1);
x_assert(1 != 1);

T x_bit(bit)  // In this document, T indicats a return type from a macro.

enum
{
  FLAG_NONE   = 0,
  FLAG_READ   = x_bit(1),
  FLAG_WRITE  = x_bit(2),
};

int read_and_write = FLAG_READ | FLAG_WRITE;

#define x_buffer_valid(buffer, size) \
  (((buffer) == NULL && (size) == 0) || ((buffer) != NULL && (size) != 0))

int read_file(const char* file, void* buffer, size_t size)
{
  if (!x_buffer_valid(buffer, size)) {
    return EINVAL;
  }

  // operations

  return 0;
}

T x_count(array)

int a[5] = {1, 2, 3, 4, 5};

for (size_t i = 0; i < x_count(a); ++i)
{
  printf("%d", a[i]);
}

bool x_fail(err)

int err = EINVAL;
if (x_fail(err))
{
  printf("%s\n", strerror(err));
}

void x_free(ptr)

int *a = (int*)malloc(5 * sizeof(int));
x_free(a);

T x_Pi(T)

float a = x_pi(float);
double b = x_pi(double);

bool x_succ(err)

int err = 0;
if (x_succ(err))
{
  printf("%s\n", strerror(err));
}

size_t x_cpu_count()

double x_duration(const struct timespec start, const struct timespec end, const char* unit)

long long x_file_size(const char* file)

const char* x_full_path(char* dst, const char* src)

const char* file = "./foo/bar.txt";
char buf[X_PATH_MAX] = {0};
x_full_path(buf, file);

int x_getch()

int main(int argc, char** argv)
{
  while (true)
  {
    if (x_getch() == X_KEY_ESC)
    {
      break;  // When the 'Esc' key is pressed, the loop breaks.
    }

    x_sleep(10);
  }

  return 0;
}

struct timespec x_now();

bool x_path_exists(const char* path)

int x_spli_tpath(
    const char *path,
    char *root, const size_t rsz, char *dir, const size_t dsz,
    char *file, const size_t fsz, char *ext, const size_t esz)

void x_sleep(const unsigned long ms)

bool x_strmty(const char* string)

const char* x_timestamp(char* buffer, const size_t size)

void x_log(char level, FILE* file, const char* format, ...)

int a = 0;

x_log('P', NULL "hello");
x_log('D', NULL "%s", "world");
x_log('I', NULL "%d", 10);
x_log('W', NULL "%d", ++a);
x_log('E', pf, "%d", ++a);  // e.g. FILE* pf = fopen("log.txt", "w")
x_log('F', pf, "%s", "fatal");

// Enumerations of error categories.
enum
{
  x_err_custom = 0,           // Custom errors.
  x_err_posix  = 1,           // POSIX errors.
  x_err_win32  = 2,           // Win32 API errors, which also includes WSA errors.
  x_err_socket = 3,           // WSA errors (on Windows) or POSIX errors.
#if X_ENABLE_CUDA
  x_err_cuda   = 4,           // CUDA errors.
#endif
#if X_WINDOWS
  x_err_system = x_err_win32, // System errors, for Windows OS.
#else
  x_err_system = x_err_posix, // System errors, for POSIX OS.
#endif
};

// Enumerations of error message querying method.
enum
{
  x_err_msg_literal = 0,
  x_err_msg_lookup  = 1,
};

typedef struct _x_err_
{
  int32_t cat; // Category of the error.
  int32_t val; // Numeric value of the error.
} x_err;

// Error message lookup function API.
typedef const char* (*x_err_msg_fn)(char* msg, const size_t msz, const int32_t val);

// Retrieves the last error of specific category, via GetLastError() or
// WSAGetLastError() from Win32 API or errno from POSIX.
x_err x_err_get(const int32_t cat);

// If err.cat is x_err_custom, two additional arguments are required for
// specifying the error message querying method and the method itself. Please
// checkout test/test_x_err.c, which should be self explained.
//
// Otherwish, the description will be retrieved according to the value of the
// error via FormatMessage from Win32 API or strerror from POSIX.
const char* x_err_msg(char* msg, const size_t msz, const x_err err, ...
    /* const int method, const char* generator*/);

// Constructs an x_err instance.
x_err x_err_set(const int32_t cat, const int32_t val);

// Can be used to initialize an x_err instance.
x_err x_ok();

void x_atomic_init_B(volatile x_atomic_B* obj, T desired)

void x_atomic_store_B(volatile x_atomic_B* obj, T desired, x_memory_order order)

T x_atomic_load_B(volatile x_atomic_B* obj, x_memory_order order)

T x_atomic_exchange_B(volatile x_atomic_B* obj, T desired, x_memory_order order)

bool x_atomic_compare_exchange_B(
    volatile x_atomic_B* obj, T* expected, T desired,
    x_memory_order succ, x_memory_order fail)

T x_atomic_fetch_add_B(volatile x_atomic_B* obj, T desired, x_memory_order order)

T x_atomic_fetch_sub_B(volatile x_atomic_B* obj, T desired, x_memory_order order)

T x_atomic_fetch_Or_B(volatile x_atomic_B* obj, T desired, x_memory_order order)

T x_atomic_fetch_Xor_B(volatile x_atomic_B* obj, T desired, x_memory_order order)

T x_atomic_fetch_And_B(volatile x_atomic_B* obj, T desired, x_memory_order order)

#define x_kill_dependency(x) (x)

#define x_atomic_is_lock_free(T) _x_is_size_lock_free(sizeof(T))

bool x_atomic_flag_test_and_set(volatile x_atomic_flag* obj, x_memory_order order)

void x_atomic_flag_clear(volatile x_atomic_flag* obj, x_memory_order order)

void x_atomic_signal_fence(const x_memory_order order)

void x_atomic_thread_fence(const x_memory_order order)

// before
x_atomic_32 obj = X_ATOMIC_VAR_INIT(32);  // was 32-bit data
obj.init(&obj, 0);
obj.fetch_add(&obj, 1);

// after
x_atomic_64 obj = X_ATOMIC_VAR_INIT(64);  // refactor to 64-bit
obj.init(&obj, 0);                        // no need to change this
obj.fetch_add(&obj, 1);                   // this too, woohoo!

typedef enum _x_memory_order_
{
#if X_CLANG || X_GCC
    x_mo_relaxed = __ATOMIC_RELAXED,
    x_mo_consume = __ATOMIC_CONSUME,
    x_mo_acquire = __ATOMIC_ACQUIRE,
    x_mo_release = __ATOMIC_RELEASE,
    x_mo_acq_rel = __ATOMIC_ACQ_REL,
    x_mo_seq_cst = __ATOMIC_SEQ_CST
#else
    x_mo_relaxed = 0,
    x_mo_consume = 1,
    x_mo_acquire = 2,
    x_mo_release = 3,
    x_mo_acq_rel = 4,
    x_mo_seq_cst = 5
#endif
} x_memory_order;

uint32_t x_cks_crc32(const void* data, const size_t size, const uint32_t* prev)

uint16_t x_cks_rfc1071(const void* data, const size_t size)

uint8_t x_cks_xor(const void* data, const size_t size)

typedef struct _x_tictoc_
{
  struct timespec start;  // Timestamp when the recording starts.
  double elapsed;         // Execution time of last cycle.

  struct
  {
    bool ready;  // Set to `true` once targe execution cycles are reached.
    size_t cyc;  // Total cycles to be record.
    double sum;  // Total elapsed time.
    double avg;  // Average execution time per cycle.
    struct
    {
      size_t idx;  // The index of the cycle that max/min execution time happened.
      double val;  // The execution time of `idx`th cycle.
    } max, min;  // Most (max) and least (min) execution time information.
  } report;
} x_tictoc;

X_INLINE int x_tictoc_init(x_tictoc* tictoc);

// Start point of timing.
X_INLINE int x_tic(x_tictoc* tictoc, const bool echo);

// End point of timing.
X_INLINE int x_toc(x_tictoc* tictoc, const char* unit, const bool echo);

// End point of timing in a multi-cycle recording operation.
X_INLINE int x_toc_ex(
    x_tictoc* tictoc,
    const char* unit, const long long cycle, const char* title,
    char* echo, size_t* size);