lib/pthreads: less warnings on OS X

[nit.git] / lib / pthreads / pthreads.nit

diff --git a/lib/pthreads/pthreads.nit b/lib/pthreads/pthreads.nit
index afb66d6..1db10b2 100644 (file)
--- a/lib/pthreads/pthreads.nit
+++ b/lib/pthreads/pthreads.nit
@@ -16,7 +16,7 @@
 
 # Main POSIX threads support and intro the classes `Thread`, `Mutex` and `Barrier`
 module pthreads is
-       cflags "-pthread"
+       cflags "-pthread -Wno-unknown-attributes"
        ldflags "-pthread"
        pkgconfig "bdw-gc"
        new_annotation threaded
@@ -33,10 +33,19 @@ in "C Header" `{
 `}
 
 in "C" `{
+       #include <string.h>
+
        // TODO protect with: #ifdef WITH_LIBGC
        // We might have to add the next line to gc_chooser.c too, especially
        // if we get an error like "thread not registered with GC".
-       #ifndef ANDROID
+       #ifdef __APPLE__
+               #include "TargetConditionals.h"
+               #if TARGET_OS_IPHONE == 1
+                       #define IOS
+               #endif
+       #endif
+
+       #if !defined(__ANDROID__) && !defined(IOS)
                #define GC_THREADS
                #include <gc.h>
        #endif
@@ -112,14 +121,14 @@ private extern class NativePthread in "C" `{ pthread_t * `}
 
        fun join: nullable Object `{
                void *thread_return;
-               pthread_join(*recv, &thread_return);
+               pthread_join(*self, &thread_return);
                if(thread_return == NULL) thread_return = null_Object();
                return (nullable_Object)thread_return;
        `}
 
-       fun equal(other: NativePthread): Bool `{ return pthread_equal(*recv, *other); `}
+       fun equal(other: NativePthread): Bool `{ return pthread_equal(*self, *other); `}
 
-       fun kill(signal: Int) `{ pthread_kill(*recv, signal); `}
+       fun kill(signal: Int) `{ pthread_kill(*self, signal); `}
 end
 
 private extern class NativePthreadAttr in "C" `{ pthread_attr_t * `}
@@ -135,7 +144,7 @@ private extern class NativePthreadAttr in "C" `{ pthread_attr_t * `}
        `}
 
        fun destroy `{
-               pthread_attr_destroy(recv);
+               pthread_attr_destroy(self);
        `}
 
        # Most features of this class are still TODO
@@ -155,29 +164,37 @@ end
 private extern class NativePthreadMutex in "C" `{ pthread_mutex_t * `}
        new (attr: NativePthreadMutexAttr) `{
                pthread_mutex_t *mutex = malloc(sizeof(pthread_mutex_t));
-               int res = pthread_mutex_init(mutex, attr);
+               int r = pthread_mutex_init(mutex, attr);
+               if (r != 0) {
+                       free(mutex);
+                       return NULL;
+               }
                return mutex;
        `}
 
-       fun destroy `{ pthread_mutex_destroy(recv); `}
+       fun destroy `{ pthread_mutex_destroy(self); `}
 
-       fun lock `{ pthread_mutex_lock(recv); `}
-       fun try_lock: Bool `{ return pthread_mutex_trylock(recv); `}
-       fun unlock `{ pthread_mutex_unlock(recv); `}
+       fun lock `{ pthread_mutex_lock(self); `}
+       fun try_lock: Bool `{ return pthread_mutex_trylock(self); `}
+       fun unlock `{ pthread_mutex_unlock(self); `}
 end
 
 private extern class NativePthreadMutexAttr in "C" `{ pthread_mutexattr_t * `}
        new `{
                pthread_mutexattr_t *attr = malloc(sizeof(pthread_mutexattr_t));
-               int res = pthread_mutexattr_init(attr);
+               int r = pthread_mutexattr_init(attr);
+               if (r != 0) {
+                       free(attr);
+                       return NULL;
+               }
                return attr;
        `}
 
-       fun destroy `{ pthread_mutexattr_destroy(recv); `}
+       fun destroy `{ pthread_mutexattr_destroy(self); `}
 
-       fun set_type_normal `{ pthread_mutexattr_settype(recv, PTHREAD_MUTEX_NORMAL); `}
-       fun set_type_recursive `{ pthread_mutexattr_settype(recv, PTHREAD_MUTEX_RECURSIVE); `}
-       fun set_type_errorcheck `{ pthread_mutexattr_settype(recv, PTHREAD_MUTEX_ERRORCHECK); `}
+       fun set_type_normal `{ pthread_mutexattr_settype(self, PTHREAD_MUTEX_NORMAL); `}
+       fun set_type_recursive `{ pthread_mutexattr_settype(self, PTHREAD_MUTEX_RECURSIVE); `}
+       fun set_type_errorcheck `{ pthread_mutexattr_settype(self, PTHREAD_MUTEX_ERRORCHECK); `}
 
        # pthread_mutexattr_setpshared
        # pthread_mutexattr_setprotocol
@@ -188,18 +205,22 @@ end
 private extern class NativePthreadKey in "C" `{ pthread_key_t * `}
        new `{
                pthread_key_t *key = malloc(sizeof(pthread_key_t));
-               int res = pthread_key_create(key, NULL);
+               int r = pthread_key_create(key, NULL);
+               if (r != 0) {
+                       free(key);
+                       return NULL;
+               }
                return key;
        `}
 
        fun get: nullable Object `{
-               void *val = pthread_getspecific(*recv);
+               void *val = pthread_getspecific(*self);
                if (val == NULL) val = null_Object();
                return val;
        `}
 
        fun set(val: nullable Object) `{
-               pthread_setspecific(*recv, val);
+               pthread_setspecific(*self, val);
        `}
 end
 
@@ -215,13 +236,13 @@ private extern class NativePthreadCond in "C" `{ pthread_cond_t * `}
                return NULL;
        `}
 
-       fun destroy `{ pthread_cond_destroy(recv); `}
+       fun destroy `{ pthread_cond_destroy(self); `}
 
-       fun signal `{ pthread_cond_signal(recv); `}
+       fun signal `{ pthread_cond_signal(self); `}
 
-       fun broadcast `{ pthread_cond_broadcast(recv);  `}
+       fun broadcast `{ pthread_cond_broadcast(self);  `}
 
-       fun wait(mutex: NativePthreadMutex) `{ pthread_cond_wait(recv, mutex); `}
+       fun wait(mutex: NativePthreadMutex) `{ pthread_cond_wait(self, mutex); `}
 end
 
 #