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

diff --git a/lib/pthreads/pthreads.nit b/lib/pthreads/pthreads.nit
index 5d6b80d..bbff9fc 100644
--- a/lib/pthreads/pthreads.nit
+++ b/lib/pthreads/pthreads.nit
@@ -19,6 +19,7 @@ module pthreads is
 	cflags "-pthread"
 	ldflags "-pthread"
 	pkgconfig "bdw-gc"
+	new_annotation threaded
 end
 
 #
@@ -111,14 +112,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 * `}
@@ -134,7 +135,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
@@ -154,29 +155,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
@@ -187,18 +196,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
 
@@ -214,13 +227,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
 
 #
@@ -235,19 +248,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
@@ -265,12 +285,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