Thread.clcl

class pthread_mutex_t 
{
    include MObjectBase;

    def initialize() {}
    def allocSize(): static native size_t;

    def clone():pthread_mutex_t {
        result := pthread_mutex_t();

        memcpy(result.headOfMemory(), self.headOfMemory(), allocSize());

        return result;
    }
}

class pthread_cond_t
{
    include MObjectBase;

    def initialize() {}
    def allocSize(): static native size_t;

    def clone():pthread_cond_t {
        result := pthread_cond_t();

        memcpy(result.headOfMemory(), self.headOfMemory(), allocSize());

        return result;
    }
}

class timespec
{
    include MObjectBase;

    tv_sec: time_t;
    tv_nsec: long;

    def initialize() {
        self.tv_sec = 0;
        self.tv_nsec = 0.to_long;
    }

    def initialize(tv_sec: time_t, tv_nsec:long) {
        self.tv_sec = tv_sec;
        self.tv_nsec = tv_nsec;
    }

    def clone():timespec {
        result := timespec();
        result.tv_sec = self.tv_sec;
        result.tv_nsec = self.tv_nsec;
        return result;
    }

    def minus(right:timespec):timespec {
        result:timespec = timespec();

        result.tv_sec = self.tv_sec - right.tv_sec;
        result.tv_nsec = self.tv_nsec - right.tv_nsec;

        return result;
    }
}

inherit System
{
    typedef pid_t int;

    def gettid():static native pid_t;
    typedef pthread_mutexattr_t uint;
    typedef pthread_condattr_t uint;

    def initialize_thread_system(): static native;

    def initialize(): static {
        initialize_thread_system();
    }

    EINVAL: static int;
    EDEADLK: static int;
    EBUSY: static int;
    EPERM: static int;
    EBUSY: static int;
    ETIMEDOUT: static int;
    EINTR: static int;

    PTHREAD_MUTEX_RECURSIVE: static uint;
    PTHREAD_MUTEX_ERRORCHECK: static uint;

    def pthread_mutex_init(mutex:pthread_mutex_t, attr:pthread_mutexattr_t): static native;
    def pthread_mutex_destroy(mutex:pthread_mutex_t): static native int throws Exception;
    def pthread_mutex_lock(mutex:pthread_mutex_t): static native int throws Exception;
    def pthread_mutex_unlock(mutex:pthread_mutex_t): static native int throws Exception;
    def pthread_mutex_trylock(mutex:pthread_mutex_t): static native int;

    def pthread_mutexattr_init(attr:pthread_mutexattr_t): static native;
    def pthread_mutexattr_settype(attr:pthread_mutexattr_t, kind:int): static native throws Exception;
    def pthread_mutexattr_destroy(attr:pthread_mutexattr_t): static native;
    def pthread_mutexattr_gettype(attr:pthread_mutexattr_t, kind:pointer@int): static native;

    def pthread_cond_init(cond:pthread_cond_t, cond_attr:pthread_condattr_t): static native;
    def pthread_cond_signal(cond:pthread_cond_t): static native;
    def pthread_cond_broadcast(cond:pthread_cond_t): static native;
    def pthread_cond_wait(cond:pthread_cond_t, mutex:pthread_mutex_t): static native;
    def pthread_cond_timedwait(cond:pthread_cond_t, mutex:pthread_mutex_t, abtime:timespec): static native int throws Exception;
    def pthread_cond_destroy(cond:pthread_cond_t): static native int throws Exception;
}

class Thread 
{
    include MObjectBase;

    typedef pthread_t ulong;

    thread_id:pthread_t;
    block:lambda()?;
    
    def initialize_thread(thread:Thread, block:lambda()): static native throws Exception;
    def pthread_join(thread_id:pthread_t): static native throws Exception;

    def initialize() {
        self.thread_id = 0;
        block = null;
    }

    def initialize(block:lambda()) throws Exception {
        Thread.initialize_thread(self, block);
    }

    def join() throws Exception {
        Thread.pthread_join(thread_id);
    }

    def clone():Thread {
        result := Thread();
        result.thread_id = self.thread_id;
        result.block = self.block;
        return result;
    }
}

class Mutex 
{
    include MObjectBase;

    mutex: pthread_mutex_t;
    attr: pthread_mutexattr_t;

    def initialize() {
        mutex = pthread_mutex_t();

        pthread_mutexattr_init(attr);
        pthread_mutex_init(mutex, attr);
    }

    def initialize(recursive:bool, error_check:bool) {
        mutex = pthread_mutex_t();

        pthread_mutexattr_init(attr);
        if(recursive) {
            pthread_mutexattr_settype(attr, PTHREAD_MUTEX_RECURSIVE);
        }
        elif(error_check) {
            pthread_mutexattr_settype(attr, PTHREAD_MUTEX_ERRORCHECK);
        }
        pthread_mutex_init(mutex, attr);
    }

    def finalize() {
        if(mutex.identifyWith(null).negative()) {
            pthread_mutex_destroy(mutex);
        }
    }

    def clone():Mutex {
        result := Mutex();

        if(self.mutex.identifyWith(null).negative()) {
            result.mutex = self.mutex.clone();
        }
        result.attr = self.attr;

        return result;
    }

    def lock() {
        pthread_mutex_lock(mutex);
    }

    def unlock() {
        pthread_mutex_unlock(mutex);
    }

    def run(block:lambda()) {
        pthread_mutex_lock(mutex);
        block();
        pthread_mutex_unlock(mutex);
    }
}