X-Git-Url: http://nitlanguage.org

diff --git a/lib/pthreads/pthreads.nit b/lib/pthreads/pthreads.nit
index d4af111..1db10b2 100644
--- a/lib/pthreads/pthreads.nit
+++ b/lib/pthreads/pthreads.nit
@@ -16,9 +16,10 @@
 
 # Main POSIX threads support and intro the classes `Thread`, `Mutex` and `Barrier`
 module pthreads is
-	c_compiler_option("-pthread")
-	c_linker_option("-pthread")
+	cflags "-pthread -Wno-unknown-attributes"
+	ldflags "-pthread"
 	pkgconfig "bdw-gc"
+	new_annotation threaded
 end
 
 #
@@ -32,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
@@ -111,20 +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 attr: NativePthreadAttr `{
-		pthread_attr_t *pattr = malloc(sizeof(pthread_attr_t));
-		pthread_getattr_np(*recv, pattr);
-		return pattr;
-	`}
+	fun equal(other: NativePthread): Bool `{ return pthread_equal(*self, *other); `}
 
-	fun equal(other: NativePthread): Bool `{ pthread_equal(*recv, *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 * `}
@@ -140,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
@@ -160,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
@@ -193,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
 
@@ -220,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
 
 #
@@ -241,19 +257,26 @@ end
 abstract class Thread
 	super Finalizable
 
+	# Type returned by `main`
+	type E : nullable Object
+
 	private var native: nullable NativePthread = null
 
+	# Is this thread finished ? True when main returned
+	var is_done = false
+
 	# Main method of this thread
 	#
 	# The returned valued is passed to the caller of `join`.
-	fun main: nullable Object do return null
+	fun main: E do return null
 
-	private fun main_intern: nullable Object
+	private fun main_intern: E
 	do
 		# Register thread local data
 		sys.self_thread_key.set self
-
-		return main
+		var r = main
+		self.is_done = true
+		return r
 	end
 
 	# Start executing this thread
@@ -271,12 +294,12 @@ abstract class Thread
 	# `Sys::thread_exit`. Returns the object returned from the other thread.
 	#
 	# Stats the thread if now already done by a call to `start`.
-	fun join: nullable Object
+	fun join: E
 	do
 		if native == null then start
 		var r = native.join
 		native = null
-		return r
+		return r.as(E)
 	end
 
 	redef fun finalize