Index: libcfa/src/concurrency/pthread.cfa
===================================================================
--- libcfa/src/concurrency/pthread.cfa	(revision ed52dd5a1c7e9f923332ea68382b2fcd254e9c48)
+++ libcfa/src/concurrency/pthread.cfa	(revision 3494ca9d8921c3db5e147de46abe94fce8e843e6)
@@ -50,5 +50,5 @@
 struct pthread_keys {
 	bool in_use;
-	void (*destructor)( void * );
+	void (* destructor)( void * );
 	Sequence(pthread_values) threads;
 };
@@ -62,5 +62,5 @@
 
 static void init_pthread_storage() {
-	for ( int i = 0; i < PTHREAD_KEYS_MAX; i++) {
+	for ( int i = 0; i < PTHREAD_KEYS_MAX; i++ ) {
 		cfa_pthread_keys_storage[i]{};
 	}
@@ -97,5 +97,5 @@
 static void init(pthread_cond_t * pcond) {
 	static_assert(sizeof(pthread_cond_t) >= sizeof(cfa2pthr_cond_var_t),"sizeof(pthread_t) < sizeof(cfa2pthr_cond_var_t)");
-	cfa2pthr_cond_var_t * _cond = (cfa2pthr_cond_var_t*)pcond;
+	cfa2pthr_cond_var_t * _cond = (cfa2pthr_cond_var_t *)pcond;
 	?{}(*_cond);
 }
@@ -103,8 +103,8 @@
 static cfa2pthr_cond_var_t * get(pthread_cond_t * pcond) {
 	static_assert(sizeof(pthread_cond_t) >= sizeof(cfa2pthr_cond_var_t),"sizeof(pthread_t) < sizeof(cfa2pthr_cond_var_t)");
-	return (cfa2pthr_cond_var_t*)pcond;
-}
-
-static void destroy(pthread_cond_t* cond) {
+	return (cfa2pthr_cond_var_t *)pcond;
+}
+
+static void destroy(pthread_cond_t * cond) {
 	static_assert(sizeof(pthread_cond_t) >= sizeof(cfa2pthr_cond_var_t),"sizeof(pthread_t) < sizeof(cfa2pthr_cond_var_t)");
 	^?{}(*get(cond));
@@ -115,8 +115,8 @@
 
 /* mutex helper routines */
-static void mutex_check(pthread_mutex_t* t) {
+static void mutex_check(pthread_mutex_t * t) {
 	// Use double check to improve performance.
 	// Check is safe on x86; volatile prevents compiler reordering
-	volatile pthread_mutex_t *const mutex_ = t;
+	volatile pthread_mutex_t * const mutex_ = t;
 
 	// SKULLDUGGERY: not a portable way to access the kind field, /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h
@@ -135,16 +135,16 @@
 
 
-static void init(pthread_mutex_t* plock) {
+static void init(pthread_mutex_t * plock) {
 	static_assert(sizeof(pthread_mutex_t) >= sizeof(simple_owner_lock),"sizeof(pthread_mutex_t) < sizeof(simple_owner_lock)");
-	simple_owner_lock* _lock = (simple_owner_lock*)plock;
+	simple_owner_lock * _lock = (simple_owner_lock *)plock;
 	?{}(*_lock);
 }
 
-static simple_owner_lock* get(pthread_mutex_t* plock) {
+static simple_owner_lock * get(pthread_mutex_t * plock) {
 	static_assert(sizeof(pthread_mutex_t) >= sizeof(simple_owner_lock),"sizeof(pthread_mutex_t) < sizeof(simple_owner_lock)");
-	return (simple_owner_lock*)plock;
-}
-
-static void destroy(pthread_mutex_t* plock) {
+	return (simple_owner_lock *)plock;
+}
+
+static void destroy(pthread_mutex_t * plock) {
 	static_assert(sizeof(pthread_mutex_t) >= sizeof(simple_owner_lock),"sizeof(pthread_mutex_t) < sizeof(simple_owner_lock)");
 	^?{}(*get(plock));
@@ -156,5 +156,5 @@
 		int detachstate;
 		size_t stacksize;
-		void *stackaddr;
+		void * stackaddr;
 		int policy;
 		int inheritsched;
@@ -162,9 +162,9 @@
 } typedef cfaPthread_attr_t;
 
-static const cfaPthread_attr_t default_attrs{
+static const cfaPthread_attr_t default_attrs {
 	0,
 	0,
-	(size_t)65000,
-	(void *)NULL,
+	65_000,
+	NULL,
 	0,
 	0,
@@ -172,7 +172,7 @@
 };
 
-static cfaPthread_attr_t* get(const pthread_attr_t* attr) {
-	static_assert(sizeof(pthread_attr_t) >= sizeof(cfaPthread_attr_t),"sizeof(pthread_attr_t) < sizeof(cfaPthread_attr_t)");
-	return (cfaPthread_attr_t*)attr;
+static cfaPthread_attr_t * get(const pthread_attr_t * attr) {
+	static_assert(sizeof(pthread_attr_t) >= sizeof(cfaPthread_attr_t), "sizeof(pthread_attr_t) < sizeof(cfaPthread_attr_t)");
+	return (cfaPthread_attr_t *)attr;
 }
 
@@ -189,14 +189,14 @@
 
 	// pthreads return value
-	void *joinval;
+	void * joinval;
 
 	// pthread attributes
 	pthread_attr_t pthread_attr;
 
-	void *(*start_routine)(void *);
-	void *start_arg;
+	void *(* start_routine)(void *);
+	void * start_arg;
 
 	// thread local data
-	pthread_values* pthreadData;
+	pthread_values * pthreadData;
 
 	// flag used for tryjoin
@@ -206,17 +206,17 @@
 /* thread part routines */
 //  cfaPthread entry point
-void main( cfaPthread & _thread ) with( _thread ) {
-	joinval = start_routine( start_arg );
+void main(cfaPthread & _thread) with(_thread) {
+	joinval = start_routine(start_arg);
 	isTerminated = true;
 }
 
 static cfaPthread * lookup( pthread_t p ) {
-	static_assert(sizeof(pthread_t) >= sizeof(cfaPthread*),"sizeof(pthread_t) < sizeof(cfaPthread*)");
-	return (cfaPthread*)p;
-}
-
-static void pthread_deletespecific_( pthread_values* values )  { // see uMachContext::invokeTask
-	pthread_values* value;
-	pthread_keys* key;
+	static_assert(sizeof(pthread_t) >= sizeof(cfaPthread *),"sizeof(pthread_t) < sizeof(cfaPthread *)");
+	return (cfaPthread *)p;
+}
+
+static void pthread_deletespecific_( pthread_values * values )  { // see uMachContext::invokeTask
+	pthread_values * value;
+	pthread_keys * key;
 	bool destcalled = true;
 	if (values != NULL) {
@@ -224,5 +224,5 @@
 			destcalled = false;
 			lock(key_lock);
-			for ( int i = 0; i < PTHREAD_KEYS_MAX; i++) {
+			for ( int i = 0; i < PTHREAD_KEYS_MAX; i++ ) {
 				// for each valid key
 				if ( values[i].in_use) {
@@ -254,10 +254,10 @@
 }
 
-static void ?{}(cfaPthread &t, pthread_t* _thread, const pthread_attr_t * _attr,void *(*start_routine)(void *), void * arg) {
-	static_assert(sizeof(pthread_t) >= sizeof(cfaPthread*), "pthread_t too small to hold a pointer: sizeof(pthread_t) < sizeof(cfaPthread*)");
+static void ?{}(cfaPthread & t, pthread_t * _thread, const pthread_attr_t * _attr,void *(* start_routine)(void *), void * arg) {
+	static_assert(sizeof(pthread_t) >= sizeof(cfaPthread *), "pthread_t too small to hold a pointer: sizeof(pthread_t) < sizeof(cfaPthread *)");
 
 	// set up user thread stackSize
 	cfaPthread_attr_t * attr = get(_attr);
-	((thread&)t) { attr ? attr->stacksize: DEFAULT_STACK_SIZE };
+	((thread&)t){ attr ? attr->stacksize: DEFAULT_STACK_SIZE };
 
 	// initialize _thread & cfaPthread id
@@ -277,40 +277,40 @@
 	//######################### Pthread Attrs #########################
 
-	int pthread_attr_init(pthread_attr_t *attr) libcfa_public __THROW {
-		cfaPthread_attr_t* _attr = get(attr);
+	int pthread_attr_init(pthread_attr_t * attr) libcfa_public __THROW {
+		cfaPthread_attr_t * _attr = get(attr);
 		?{}(*_attr, default_attrs);
 		return 0;
 	}
-	int pthread_attr_destroy(pthread_attr_t *attr) libcfa_public __THROW {
+	int pthread_attr_destroy(pthread_attr_t * attr) libcfa_public __THROW {
 		^?{}(*get(attr));
 		return 0;
 	}
 
-	int pthread_attr_setscope( pthread_attr_t *attr, int contentionscope ) libcfa_public __THROW {
+	int pthread_attr_setscope( pthread_attr_t * attr, int contentionscope ) libcfa_public __THROW {
 		get( attr )->contentionscope = contentionscope;
 		return 0;
 	} // pthread_attr_setscope
 
-	int pthread_attr_getscope( const pthread_attr_t *attr, int *contentionscope ) libcfa_public __THROW {
+	int pthread_attr_getscope( const pthread_attr_t * attr, int * contentionscope ) libcfa_public __THROW {
 		*contentionscope = get( attr )->contentionscope;
 		return 0;
 	} // pthread_attr_getscope
 
-	int pthread_attr_setdetachstate( pthread_attr_t *attr, int detachstate ) libcfa_public __THROW {
+	int pthread_attr_setdetachstate( pthread_attr_t * attr, int detachstate ) libcfa_public __THROW {
 		get( attr )->detachstate = detachstate;
 		return 0;
 	} // pthread_attr_setdetachstate
 
-	int pthread_attr_getdetachstate( const pthread_attr_t *attr, int *detachstate ) libcfa_public __THROW {
+	int pthread_attr_getdetachstate( const pthread_attr_t * attr, int * detachstate ) libcfa_public __THROW {
 		*detachstate = get( attr )->detachstate;
 		return 0;
 	} // pthread_attr_getdetachstate
 
-	int pthread_attr_setstacksize( pthread_attr_t *attr, size_t stacksize ) libcfa_public __THROW {
+	int pthread_attr_setstacksize( pthread_attr_t * attr, size_t stacksize ) libcfa_public __THROW {
 		get( attr )->stacksize = stacksize;
 		return 0;
 	} // pthread_attr_setstacksize
 
-	int pthread_attr_getstacksize( const pthread_attr_t *attr, size_t *stacksize ) libcfa_public __THROW {
+	int pthread_attr_getstacksize( const pthread_attr_t * attr, size_t * stacksize ) libcfa_public __THROW {
 		*stacksize = get( attr )->stacksize;
 		return 0;
@@ -325,15 +325,15 @@
 	} // pthread_attr_setguardsize
 
-	int pthread_attr_setstackaddr( pthread_attr_t *attr, void *stackaddr ) libcfa_public __THROW {
+	int pthread_attr_setstackaddr( pthread_attr_t * attr, void * stackaddr ) libcfa_public __THROW {
 		get( attr )->stackaddr = stackaddr;
 		return 0;
 	} // pthread_attr_setstackaddr
 
-	int pthread_attr_getstackaddr( const pthread_attr_t *attr, void **stackaddr ) libcfa_public __THROW {
+	int pthread_attr_getstackaddr( const pthread_attr_t * attr, void ** stackaddr ) libcfa_public __THROW {
 		*stackaddr = get( attr )->stackaddr;
 		return 0;
 	} // pthread_attr_getstackaddr
 
-	int pthread_attr_setstack( pthread_attr_t *attr, void *stackaddr, size_t stacksize ) libcfa_public __THROW {
+	int pthread_attr_setstack( pthread_attr_t * attr, void * stackaddr, size_t stacksize ) libcfa_public __THROW {
 		get( attr )->stackaddr = stackaddr;
 		get( attr )->stacksize = stacksize;
@@ -341,5 +341,5 @@
 	} // pthread_attr_setstack
 
-	int pthread_attr_getstack( const pthread_attr_t *attr, void **stackaddr, size_t *stacksize ) libcfa_public __THROW {
+	int pthread_attr_getstack( const pthread_attr_t * attr, void ** stackaddr, size_t * stacksize ) libcfa_public __THROW {
 		*stackaddr = get( attr )->stackaddr;
 		*stacksize = get( attr )->stacksize;
@@ -350,5 +350,5 @@
 	// already running thread threadID. It shall be called on unitialized attr
 	// and destroyed with pthread_attr_destroy when no longer needed.
-	int pthread_getattr_np( pthread_t threadID, pthread_attr_t *attr ) libcfa_public __THROW { // GNU extension
+	int pthread_getattr_np( pthread_t threadID, pthread_attr_t * attr ) libcfa_public __THROW { // GNU extension
 		check_nonnull(attr);
 
@@ -362,12 +362,11 @@
 	//######################### Threads #########################
 
-	int pthread_create(pthread_t * _thread, const pthread_attr_t * attr, void *(*start_routine)(void *), void * arg) libcfa_public __THROW {
-		cfaPthread *t = alloc();
-		(*t) {_thread, attr, start_routine, arg};
-		return 0;
-	}
-
-
-	int pthread_join(pthread_t _thread, void **value_ptr) libcfa_public __THROW {
+	int pthread_create(pthread_t * _thread, const pthread_attr_t * attr, void *(* start_routine)(void *), void * arg) libcfa_public __THROW {
+		cfaPthread * t = alloc();
+		(*t){_thread, attr, start_routine, arg};
+		return 0;
+	}
+
+	int pthread_join(pthread_t _thread, void ** value_ptr) libcfa_public __THROW {
 		// if thread is invalid
 		if (_thread == NULL) return EINVAL;
@@ -375,5 +374,5 @@
 
 		// get user thr pointer
-		cfaPthread* p = lookup(_thread);
+		cfaPthread * p = lookup(_thread);
 		try {
 			join(*p);
@@ -388,10 +387,10 @@
 	}
 
-	int pthread_tryjoin_np(pthread_t _thread, void **value_ptr) libcfa_public __THROW {
+	int pthread_tryjoin_np(pthread_t _thread, void ** value_ptr) libcfa_public __THROW {
 		// if thread is invalid
 		if (_thread == NULL) return EINVAL;
 		if (_thread == pthread_self()) return EDEADLK;
 
-		cfaPthread* p = lookup(_thread);
+		cfaPthread * p = lookup(_thread);
 
 		// thread not finished ?
@@ -411,8 +410,8 @@
 	void pthread_exit(void * status) libcfa_public __THROW {
 		pthread_t pid = pthread_self();
-		cfaPthread* _thread = (cfaPthread*)pid;
+		cfaPthread * _thread = (cfaPthread *)pid;
 		_thread->joinval = status;  // set return value
 		_thread->isTerminated = 1;  // set terminated flag
-		cancel_stack((pthread_exit_exp) {&exp_vt});
+		cancel_stack((pthread_exit_exp){&exp_vt});
 	}   //pthread_exit_
 
@@ -425,5 +424,5 @@
 	//######################### Mutex #########################
 
-	int pthread_mutex_init(pthread_mutex_t *_mutex, const pthread_mutexattr_t *attr) libcfa_public __THROW {
+	int pthread_mutex_init(pthread_mutex_t *_mutex, const pthread_mutexattr_t * attr) libcfa_public __THROW {
 		check_nonnull(_mutex);
 		init(_mutex);
@@ -434,5 +433,5 @@
 	int pthread_mutex_destroy(pthread_mutex_t *_mutex) libcfa_public __THROW {
 		check_nonnull(_mutex);
-		simple_owner_lock* _lock = get(_mutex);
+		simple_owner_lock * _lock = get(_mutex);
 		if (_lock->owner != NULL) {
 			return EBUSY;
@@ -445,5 +444,5 @@
 		check_nonnull(_mutex);
 		mutex_check(_mutex);
-		simple_owner_lock* _lock = get(_mutex);
+		simple_owner_lock * _lock = get(_mutex);
 		lock(*_lock);
 		return 0;
@@ -452,5 +451,5 @@
 	int pthread_mutex_unlock(pthread_mutex_t *_mutex) libcfa_public __THROW {
 		check_nonnull(_mutex);
-		simple_owner_lock* _lock = get(_mutex);
+		simple_owner_lock * _lock = get(_mutex);
 		if (_lock->owner != active_thread()) {
 			return EPERM;
@@ -462,5 +461,5 @@
 	int pthread_mutex_trylock(pthread_mutex_t *_mutex) libcfa_public __THROW {
 		check_nonnull(_mutex);
-		simple_owner_lock* _lock = get(_mutex);
+		simple_owner_lock * _lock = get(_mutex);
 		if (_lock->owner != active_thread() && _lock->owner != NULL) {
 			return EBUSY;
@@ -473,5 +472,5 @@
 
 	/* conditional variable routines */
-	int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr) libcfa_public __THROW {
+	int pthread_cond_init(pthread_cond_t * cond, const pthread_condattr_t * attr) libcfa_public __THROW {
 		check_nonnull(cond);
 		init(cond);
@@ -479,5 +478,5 @@
 	}  //pthread_cond_init
 
-	int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *_mutex) libcfa_public __THROW {
+	int pthread_cond_wait(pthread_cond_t * cond, pthread_mutex_t *_mutex) libcfa_public __THROW {
 		check_nonnull(_mutex);
 		check_nonnull(cond);
@@ -493,15 +492,15 @@
 	} // pthread_cond_timedwait
 
-	int pthread_cond_signal(pthread_cond_t *cond) libcfa_public __THROW {
+	int pthread_cond_signal(pthread_cond_t * cond) libcfa_public __THROW {
 		check_nonnull(cond);
 		return notify_one(*get(cond));
 	} // pthread_cond_signal
 
-	int pthread_cond_broadcast(pthread_cond_t *cond) libcfa_public __THROW {
+	int pthread_cond_broadcast(pthread_cond_t * cond) libcfa_public __THROW {
 		check_nonnull(cond);
 		return notify_all(*get(cond));
 	} // pthread_cond_broadcast
 
-	int pthread_cond_destroy(pthread_cond_t *cond) libcfa_public __THROW {
+	int pthread_cond_destroy(pthread_cond_t * cond) libcfa_public __THROW {
 		check_nonnull(cond);
 		destroy(cond);
@@ -513,5 +512,5 @@
 	//######################### Local storage #########################
 
-	int pthread_once(pthread_once_t *once_control, void (*init_routine)(void)) libcfa_public __THROW {
+	int pthread_once(pthread_once_t * once_control, void (* init_routine)(void)) libcfa_public __THROW {
 		static_assert(sizeof(pthread_once_t) >= sizeof(int),"sizeof(pthread_once_t) < sizeof(int)");
 		check_nonnull(once_control);
@@ -526,5 +525,5 @@
 	} // pthread_once
 
-	int pthread_key_create( pthread_key_t *key, void (*destructor)( void * ) ) libcfa_public __THROW {
+	int pthread_key_create( pthread_key_t * key, void (* destructor)( void * ) ) libcfa_public __THROW {
 		lock(key_lock);
 		for ( int i = 0; i < PTHREAD_KEYS_MAX; i += 1 ) {
@@ -561,13 +560,13 @@
 	}   // pthread_key_delete
 
-	int pthread_setspecific( pthread_key_t key, const void *value ) libcfa_public __THROW {
+	int pthread_setspecific( pthread_key_t key, const void * value ) libcfa_public __THROW {
 		// get current thread
-		cfaPthread* t = lookup(pthread_self());
+		cfaPthread * t = lookup(pthread_self());
 		// if current thread's pthreadData is NULL; initialize it
-		pthread_values* values;
+		pthread_values * values;
 		if (t->pthreadData == NULL) {
 			values = anew( PTHREAD_KEYS_MAX);
 			t->pthreadData = values;
-			for ( int i = 0;i < PTHREAD_KEYS_MAX; i++) {
+			for ( int i = 0;i < PTHREAD_KEYS_MAX; i++ ) {
 				t->pthreadData[i].in_use = false;
 			}   // for
@@ -592,9 +591,9 @@
 	} //pthread_setspecific
 
-	void* pthread_getspecific(pthread_key_t key) libcfa_public __THROW {
+	void * pthread_getspecific(pthread_key_t key) libcfa_public __THROW {
 		if (key >= PTHREAD_KEYS_MAX || ! cfa_pthread_keys[key].in_use) return NULL;
 
 		// get current thread
-		cfaPthread* t = lookup(pthread_self());
+		cfaPthread * t = lookup(pthread_self());
 		if (t->pthreadData == NULL) return NULL;
 		lock(key_lock);
@@ -604,5 +603,5 @@
 			return NULL;
 		} // if
-		void *value = entry.value;
+		void * value = entry.value;
 		unlock(key_lock);
 
@@ -905,10 +904,10 @@
 	} // pthread_cancel
 
-	int pthread_setcancelstate( int state, int *oldstate ) libcfa_public __THROW {
+	int pthread_setcancelstate( int state, int * oldstate ) libcfa_public __THROW {
 		abort("pthread_setcancelstate not implemented");
 		return 0;
 	} // pthread_setcancelstate
 
-	int pthread_setcanceltype( int type, int *oldtype ) libcfa_public __THROW {
+	int pthread_setcanceltype( int type, int * oldtype ) libcfa_public __THROW {
 		abort("pthread_setcanceltype not implemented");
 		return 0;
@@ -917,3 +916,2 @@
 
 #pragma GCC diagnostic pop
-