Pre-Alpha Limited C11 Threading Emulation

#if ! defined (CT_C11_THREADS_H_EMULATION_H)
#   define CT_C11_THREADS_H_EMULATION_H 1
#   if defined (__cplusplus)
        extern "C"
        {
#   endif



#if defined (CT_C11_THREADS_H_PRINTF_LOG)
#   include <stdio.h>
#   define CT_C11_THREADS_H_PRINTF(mp_exp) printf mp_exp
#else
#   define CT_C11_THREADS_H_PRINTF(mp_exp) ((void)(0))
#endif




#include <stdlib.h>
#include <pthread.h>
#include <assert.h>


typedef int (*ct_thrd_start_t) (void*);

struct ct_thrd_user
{
    pthread_t ptid;
};


struct ct_thrd_sys
{
    ct_thrd_start_t fp_user;
    void* user_ctx;
    int user_ret;
};


enum ct_thrd_sys_status
{
    ct_thrd_success = 0,
    ct_thrd_nomem = 1,
    ct_thrd_timedout = 2,
    ct_thrd_busy = 3,
    ct_thrd_error = 4
};





/* low-level system threading API's
__________________________________________________________________*/
static struct ct_thrd_sys*
ct_thrd_sys_create(
    ct_thrd_start_t fp_user,
    void* user_ctx
);

static void
ct_thrd_sys_destroy(
    struct ct_thrd_sys* const self
);

static void*
ct_thrd_sys_entry(
    void* self_raw
);



struct ct_thrd_sys*
ct_thrd_sys_create(
    ct_thrd_start_t fp_user,
    void* user_ctx
){
    struct ct_thrd_sys* const self = malloc(sizeof(*self));

    if (self)
    {
        self->fp_user = fp_user;
        self->user_ctx = user_ctx;
        self->user_ret = 0;
    }

    CT_C11_THREADS_H_PRINTF(("ct_thrd_sys_create = %p\r\n", (void*)self));

    return self;
}

void
ct_thrd_sys_destroy(
    struct ct_thrd_sys* const self
){
    free(self);

    CT_C11_THREADS_H_PRINTF(
        ("ct_thrd_sys_destroy(self = %p)\r\n", (void*)self)
    );
}


void*
ct_thrd_sys_entry(
    void* self_raw
){
    struct ct_thrd_sys* const self = self_raw;

    CT_C11_THREADS_H_PRINTF(
        ("ct_thrd_sys_entry(self_raw = %p):Enter\r\n", self_raw)
    );

    self->user_ret = self->fp_user(self->user_ctx);

    CT_C11_THREADS_H_PRINTF(
        ("ct_thrd_sys_entry(self_raw = %p):Exit = %p\r\n", self_raw, (void*)self)
    );

    return self;
}






/* C11 emulation API layer
__________________________________________________________________*/


/* Threading API
______________________________________________________________*/
typedef struct ct_thrd_user ct_thrd_t;


static int
ct_thrd_create(
    ct_thrd_t* uself,
    ct_thrd_start_t fp_user,
    void* user_ctx
);

static int
ct_thrd_join(
    ct_thrd_t self,
    int* user_retv
);


int
ct_thrd_create(
    ct_thrd_t* uself,
    ct_thrd_start_t fp_user,
    void* user_ctx
){
    struct ct_thrd_sys* const self =
        ct_thrd_sys_create(fp_user, user_ctx);

    if (self)
    {
        int status = pthread_create(&uself->ptid, NULL, ct_thrd_sys_entry, self);

        if (! status)
        {
            return ct_thrd_success;
        }

        ct_thrd_sys_destroy(self);
    }

    return ct_thrd_nomem;
}


int
ct_thrd_join(
    ct_thrd_t self,
    int* user_retv
){
    void* ptjret = NULL;

    pthread_join(self.ptid, &ptjret);

    if (ptjret)
    {
        struct ct_thrd_sys* const self = ptjret;

        if (user_retv)
        {
            *user_retv = self->user_ret;
        }

        ct_thrd_sys_destroy(self);

        return ct_thrd_success;
    }

    return ct_thrd_error;
}




/* Thread Specific Storage API
______________________________________________________________*/
typedef pthread_key_t ct_tss_t;
typedef void(*ct_tss_dtor_t) (void*);

static int
ct_tss_create(
    ct_tss_t* self,
    ct_tss_dtor_t fp_user_dtor
);

static void
ct_tss_delete(
    ct_tss_t self
);

static int
ct_tss_set(
    ct_tss_t self,
    void* user_ctx
);

#define ct_tss_get(mp_self) pthread_getspecific((mp_self))



int
ct_tss_create(
    ct_tss_t* self,
    ct_tss_dtor_t fp_user_dtor
){
    int status = pthread_key_create(self, fp_user_dtor);

    if (!status)
    {
        return ct_thrd_success;
    }

    return ct_thrd_error;
}


void
ct_tss_delete(
    ct_tss_t self
){
    int status = pthread_key_delete(self);

    if (! status)
    {
        return;
    }

    assert(! status);
}


int
ct_tss_set(
    ct_tss_t self,
    void* user_ctx
){
    int status = pthread_setspecific(self, user_ctx);

    if (!status)
    {
        return ct_thrd_success;
    }

    return ct_thrd_error;
}




/* Mutex API
______________________________________________________________*/
typedef pthread_mutex_t ct_mtx_t;

enum {
    ct_mtx_plain = 1,
    ct_mtx_recursive = 2,
    ct_mtx_timed = 4
};


int
ct_mtx_init(
    ct_mtx_t* self,
    int type
){
    if (type == ct_mtx_plain)
    {
        int status = pthread_mutex_init(self, NULL);

        if (! status)
        {
            return ct_thrd_success;
        }
    }

    return ct_thrd_error;
}


void
ct_mtx_destroy(
    ct_mtx_t* self
){
    int status = pthread_mutex_destroy(self);

    if (! status)
    {
        return;
    }

    assert(! status);
}


int
ct_mtx_lock(
    ct_mtx_t* self
){
    int status = pthread_mutex_lock(self);

    if (! status)
    {
        return ct_thrd_success;
    }

    assert(! status);

    return ct_thrd_error;
}


int
ct_mtx_unlock(
    ct_mtx_t* self
){
    int status = pthread_mutex_unlock(self);

    if (!status)
    {
        return ct_thrd_success;
    }

    assert(! status);

    return ct_thrd_error;
}




/* Mutex API
______________________________________________________________*/
typedef pthread_cond_t ct_cnd_t;

int
ct_cnd_init(
    ct_cnd_t* self
){
    int status = pthread_cond_init(self, NULL);

    if (! status)
    {
        return ct_thrd_success;
    }

    return ct_thrd_error;
}


void
ct_cnd_destroy(
    ct_cnd_t* self
){
    int status = pthread_cond_destroy(self);

    if (! status)
    {
        return;
    }

    assert(! status);
}


int
ct_cnd_signal(
    ct_cnd_t* self
){
    int status = pthread_cond_signal(self);

    if (! status)
    {
        return ct_thrd_success;
    }

    assert(! status);

    return ct_thrd_error;
}


int
ct_cnd_broadcast(
    ct_cnd_t* self
){
    int status = pthread_cond_broadcast(self);

    if (! status)
    {
        return ct_thrd_success;
    }

    assert(! status);

    return ct_thrd_error;
}


int
ct_cnd_wait(
    ct_cnd_t* self,
    ct_mtx_t* mtx
){
    int status = pthread_cond_wait(self, mtx);

    if (! status)
    {
        return ct_thrd_success;
    }

    assert(! status);

    return ct_thrd_error;
}






/* Mock up the final C11 API with some macros...  ;^o
______________________________________________________________*/



/* C11 threading API
_________________________________________________*/
#define thrd_success    ct_thrd_success
#define thrd_nomem      ct_thrd_nomem
#define thrd_timedout   ct_thrd_timedout
#define thrd_busy       ct_thrd_busy
#define thrd_error      ct_thrd_error

#define thrd_t          ct_thrd_t

#define thrd_create     ct_thrd_create
#define thrd_join       ct_thrd_join



/* C11 thread specific storage API
_________________________________________________*/
#define tss_t           ct_tss_t

#define tss_create      ct_tss_create
#define tss_delete      ct_tss_delete
#define tss_set         ct_tss_set
#define tss_get         ct_tss_get



/* C11 mutex API
_________________________________________________*/
#define mtx_plain       ct_mtx_plain
#define mtx_recursive   ct_mtx_recursive
#define mtx_timed       ct_mtx_timed

#define mtx_t           ct_mtx_t

#define mtx_init        ct_mtx_init
#define mtx_destroy     ct_mtx_destroy
#define mtx_lock        ct_mtx_lock
#define mtx_unlock      ct_mtx_unlock



/* C11 condition variable API
_________________________________________________*/
#define cnd_t           ct_cnd_t

#define cnd_init        ct_cnd_init
#define cnd_destroy     ct_cnd_destroy
#define cnd_signal      ct_cnd_signal
#define cnd_broadcast   ct_cnd_broadcast
#define cnd_wait        ct_cnd_wait




#   if defined (__cplusplus)
        }
#   endif
#endif