nxs_thread.h

#ifndef NXS_HEADERS_THREAD
#define NXS_HEADERS_THREAD

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <stdbool.h>

/* MACROS */
#define NXS_THREAD_USABLE

#define NXS_THREAD_HAS_TLS

#if defined(HAVE_PTHREAD_H)
    #include <pthread.h>
#elif defined(HAVE_WINDOWS_H)
    #include <windows.h>
#else
    #undef NXS_THREAD_USABLE
    #undef NXS_THREAD_HAS_TLS
#endif

#define nxs_thread_semaphore(_type) \
    struct {                                                                \
        nxs_thread_mutex    _mutex;                                         \
        _type               value;                                          \
    }

/* TYPES */
typedef struct {
#if defined(HAVE_PTHREAD_H)
    pthread_t           _id;
#elif defined(HAVE_WINDOWS_H)
    HANDLE              _id;
#endif

    void              (*_entry)(void *);
    void *              _data;
} nxs_thread;

#if defined(HAVE_PTHREAD_H)
typedef pthread_mutex_t     nxs_thread_mutex[1];
#elif defined(HAVE_WINDOWS_H)
typedef HANDLE              nxs_thread_mutex;
#else
typedef int                 nxs_thread_mutex;
#endif

typedef
#if defined(HAVE_PTHREAD_H)
        pthread_key_t 
#elif defined(HAVE_WINDOWS_H)
        DWORD
#else
        int
#endif
                      nxs_thread_tls;

/* PUBLIC FUNCTION PROTOTYPES */
bool    nxs_thread_create           (nxs_thread *thread, void (*entry)(void *), void *data);

void    nxs_thread_exit             (void);

bool    nxs_thread_kill             (nxs_thread *thread);

bool    nxs_thread_mutex_alloc      (nxs_thread_mutex *mutex);

bool    nxs_thread_mutex_free       (nxs_thread_mutex mutex);

bool    nxs_thread_mutex_lock       (nxs_thread_mutex mutex);

bool    nxs_thread_mutex_tryLock    (nxs_thread_mutex mutex);

bool    nxs_thread_mutex_unlock     (nxs_thread_mutex mutex);

static inline
bool    nxs_thread_sem_init         (void *semaphore);

static inline
bool    nxs_thread_sem_release      (void *semaphore);

static inline
bool    nxs_thread_sem_lock         (void *semaphore);

static inline
bool    nxs_thread_sem_tryLock      (void *semaphore);

static inline
bool    nxs_thread_sem_unlock       (void *semaphore);

void    nxs_thread_sleep            (unsigned long ms);

bool    nxs_thread_tls_alloc        (nxs_thread_tls *tls);

bool    nxs_thread_tls_free         (nxs_thread_tls tls);

void *  nxs_thread_tls_get          (nxs_thread_tls tls);

bool    nxs_thread_tls_set          (nxs_thread_tls tls, const void *data);

bool    nxs_thread_wait             (nxs_thread *thread);

/* IMPLEMENTATION DETAILS BELOW */
typedef struct {
    nxs_thread_mutex    mutex;
} nxs_thread_semaphore_;

/* INLINE FUNCTION DEFINITIONS */
static inline
bool    nxs_thread_sem_init         (void *semaphore) {
    nxs_thread_semaphore_ * const sem = semaphore;
    
    return nxs_thread_mutex_alloc   (&sem->mutex);
}

static inline
bool    nxs_thread_sem_release      (void *semaphore) {
    nxs_thread_semaphore_ * const sem = semaphore;
    
    return nxs_thread_mutex_free    ( sem->mutex);
}

static inline
bool    nxs_thread_sem_lock         (void *semaphore) {
    nxs_thread_semaphore_ * const sem = semaphore;
    
    return nxs_thread_mutex_lock    ( sem->mutex);
}

static inline
bool    nxs_thread_sem_tryLock      (void *semaphore) {
    nxs_thread_semaphore_ * const sem = semaphore;
    
    return nxs_thread_mutex_tryLock ( sem->mutex);
}

static inline
bool    nxs_thread_sem_unlock       (void *semaphore) {
    nxs_thread_semaphore_ * const sem = semaphore;
    
    return nxs_thread_mutex_unlock  ( sem->mutex);
}
#endif

---