Index: src/libcfa/concurrency/kernel
===================================================================
--- src/libcfa/concurrency/kernel	(revision e1e8408b22136702256cde37d937165f85a711fb)
+++ src/libcfa/concurrency/kernel	(revision 4cedd9fd7388881d56f46c8b5b5520dee1f9e9b2)
@@ -39,6 +39,6 @@
 void  ?{}(semaphore & this, int count = 1);
 void ^?{}(semaphore & this);
-void P(semaphore * this);
-void V(semaphore * this);
+void   P (semaphore & this);
+void   V (semaphore & this);
 
 
@@ -51,5 +51,5 @@
 };
 
-void ?{}(cluster & this);
+void ?{} (cluster & this);
 void ^?{}(cluster & this);
 
Index: src/libcfa/concurrency/kernel.c
===================================================================
--- src/libcfa/concurrency/kernel.c	(revision e1e8408b22136702256cde37d937165f85a711fb)
+++ src/libcfa/concurrency/kernel.c	(revision 4cedd9fd7388881d56f46c8b5b5520dee1f9e9b2)
@@ -158,5 +158,5 @@
 		LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", &this);
 		this.do_terminate = true;
-		P( &this.terminated );
+		P( this.terminated );
 		pthread_join( this.kernel_thread, NULL );
 	}
@@ -216,5 +216,5 @@
 	}
 
-	V( &this->terminated );
+	V( this->terminated );
 
 	LIB_DEBUG_PRINT_SAFE("Kernel : core %p terminated\n", this);
@@ -618,29 +618,29 @@
 void ^?{}(semaphore & this) {}
 
-void P(semaphore * this) {
-	lock( &this->lock DEBUG_CTX2 );
-	this->count -= 1;
-	if ( this->count < 0 ) {
+void P(semaphore & this) {
+	lock( &this.lock DEBUG_CTX2 );
+	this.count -= 1;
+	if ( this.count < 0 ) {
 		// queue current task
-		append( &this->waiting, (thread_desc *)this_thread );
+		append( &this.waiting, (thread_desc *)this_thread );
 
 		// atomically release spin lock and block
-		BlockInternal( &this->lock );
+		BlockInternal( &this.lock );
 	}
 	else {
-	    unlock( &this->lock );
-	}
-}
-
-void V(semaphore * this) {
+	    unlock( &this.lock );
+	}
+}
+
+void V(semaphore & this) {
 	thread_desc * thrd = NULL;
-	lock( &this->lock DEBUG_CTX2 );
-	this->count += 1;
-	if ( this->count <= 0 ) {
+	lock( &this.lock DEBUG_CTX2 );
+	this.count += 1;
+	if ( this.count <= 0 ) {
 		// remove task at head of waiting list
-		thrd = pop_head( &this->waiting );
-	}
-
-	unlock( &this->lock );
+		thrd = pop_head( &this.waiting );
+	}
+
+	unlock( &this.lock );
 
 	// make new owner
Index: src/libcfa/concurrency/monitor
===================================================================
--- src/libcfa/concurrency/monitor	(revision e1e8408b22136702256cde37d937165f85a711fb)
+++ src/libcfa/concurrency/monitor	(revision 4cedd9fd7388881d56f46c8b5b5520dee1f9e9b2)
@@ -116,9 +116,9 @@
 }
 
-void wait( condition * this, uintptr_t user_info = 0 );
-bool signal( condition * this );
-bool signal_block( condition * this );
-static inline bool is_empty( condition * this ) { return !this->blocked.head; }
-uintptr_t front( condition * this );
+void wait( condition & this, uintptr_t user_info = 0 );
+bool signal( condition & this );
+bool signal_block( condition & this );
+static inline bool is_empty( condition & this ) { return !this.blocked.head; }
+uintptr_t front( condition & this );
 
 //-----------------------------------------------------------------------------
Index: src/libcfa/concurrency/monitor.c
===================================================================
--- src/libcfa/concurrency/monitor.c	(revision e1e8408b22136702256cde37d937165f85a711fb)
+++ src/libcfa/concurrency/monitor.c	(revision 4cedd9fd7388881d56f46c8b5b5520dee1f9e9b2)
@@ -45,5 +45,5 @@
 
 static inline thread_desc *        check_condition   ( __condition_criterion_t * );
-static inline void                 brand_condition   ( condition * );
+static inline void                 brand_condition   ( condition & );
 static inline [thread_desc *, int] search_entry_queue( const __waitfor_mask_t &, monitor_desc ** monitors, int count );
 
@@ -69,5 +69,5 @@
 	unsigned short count = cnt;                               /* Save the count to a local variable                                                  */ \
 	unsigned int recursions[ count ];                         /* Save the current recursion levels to restore them later                             */ \
-	__waitfor_mask_t masks[ count ];                          /* Save the current waitfor masks to restore them later                                */ \
+	__waitfor_mask_t masks [ count ];                         /* Save the current waitfor masks to restore them later                                */ \
 	spinlock *   locks     [ count ];                         /* We need to pass-in an array of locks to BlockInternal                               */ \
 
@@ -387,14 +387,14 @@
 //-----------------------------------------------------------------------------
 // Internal scheduling
-void wait( condition * this, uintptr_t user_info = 0 ) {
+void wait( condition & this, uintptr_t user_info = 0 ) {
 	brand_condition( this );
 
 	// Check that everything is as expected
-	assertf( this->monitors != NULL, "Waiting with no monitors (%p)", this->monitors );
-	verifyf( this->monitor_count != 0, "Waiting with 0 monitors (%i)", this->monitor_count );
-	verifyf( this->monitor_count < 32u, "Excessive monitor count (%i)", this->monitor_count );
+	assertf( this.monitors != NULL, "Waiting with no monitors (%p)", this.monitors );
+	verifyf( this.monitor_count != 0, "Waiting with 0 monitors (%i)", this.monitor_count );
+	verifyf( this.monitor_count < 32u, "Excessive monitor count (%i)", this.monitor_count );
 
 	// Create storage for monitor context
-	monitor_ctx( this->monitors, this->monitor_count );
+	monitor_ctx( this.monitors, this.monitor_count );
 
 	// Create the node specific to this wait operation
@@ -403,5 +403,5 @@
 	// Append the current wait operation to the ones already queued on the condition
 	// We don't need locks for that since conditions must always be waited on inside monitor mutual exclusion
-	append( &this->blocked, &waiter );
+	append( &this.blocked, &waiter );
 
 	// Lock all monitors (aggregates the locks as well)
@@ -429,32 +429,32 @@
 }
 
-bool signal( condition * this ) {
+bool signal( condition & this ) {
 	if( is_empty( this ) ) { return false; }
 
 	//Check that everything is as expected
-	verify( this->monitors );
-	verify( this->monitor_count != 0 );
+	verify( this.monitors );
+	verify( this.monitor_count != 0 );
 
 	//Some more checking in debug
 	LIB_DEBUG_DO(
 		thread_desc * this_thrd = this_thread;
-		if ( this->monitor_count != this_thrd->monitors.size ) {
-			abortf( "Signal on condition %p made with different number of monitor(s), expected %i got %i", this, this->monitor_count, this_thrd->monitors.size );
-		}
-
-		for(int i = 0; i < this->monitor_count; i++) {
-			if ( this->monitors[i] != this_thrd->monitors.list[i] ) {
-				abortf( "Signal on condition %p made with different monitor, expected %p got %i", this, this->monitors[i], this_thrd->monitors.list[i] );
+		if ( this.monitor_count != this_thrd->monitors.size ) {
+			abortf( "Signal on condition %p made with different number of monitor(s), expected %i got %i", &this, this.monitor_count, this_thrd->monitors.size );
+		}
+
+		for(int i = 0; i < this.monitor_count; i++) {
+			if ( this.monitors[i] != this_thrd->monitors.list[i] ) {
+				abortf( "Signal on condition %p made with different monitor, expected %p got %i", &this, this.monitors[i], this_thrd->monitors.list[i] );
 			}
 		}
 	);
 
-	unsigned short count = this->monitor_count;
+	unsigned short count = this.monitor_count;
 
 	// Lock all monitors
-	lock_all( this->monitors, NULL, count );
+	lock_all( this.monitors, NULL, count );
 
 	//Pop the head of the waiting queue
-	__condition_node_t * node = pop_head( &this->blocked );
+	__condition_node_t * node = pop_head( &this.blocked );
 
 	//Add the thread to the proper AS stack
@@ -466,18 +466,18 @@
 
 	//Release
-	unlock_all( this->monitors, count );
+	unlock_all( this.monitors, count );
 
 	return true;
 }
 
-bool signal_block( condition * this ) {
-	if( !this->blocked.head ) { return false; }
+bool signal_block( condition & this ) {
+	if( !this.blocked.head ) { return false; }
 
 	//Check that everything is as expected
-	verifyf( this->monitors != NULL, "Waiting with no monitors (%p)", this->monitors );
-	verifyf( this->monitor_count != 0, "Waiting with 0 monitors (%i)", this->monitor_count );
+	verifyf( this.monitors != NULL, "Waiting with no monitors (%p)", this.monitors );
+	verifyf( this.monitor_count != 0, "Waiting with 0 monitors (%i)", this.monitor_count );
 
 	// Create storage for monitor context
-	monitor_ctx( this->monitors, this->monitor_count );
+	monitor_ctx( this.monitors, this.monitor_count );
 
 	// Lock all monitors (aggregates the locks them as well)
@@ -491,8 +491,8 @@
 
 	//Find the thread to run
-	thread_desc * signallee = pop_head( &this->blocked )->waiting_thread;
+	thread_desc * signallee = pop_head( &this.blocked )->waiting_thread;
 	set_owner( monitors, count, signallee );
 
-	LIB_DEBUG_PRINT_BUFFER_DECL( "Kernel : signal_block condition %p (s: %p)\n", this, signallee );
+	LIB_DEBUG_PRINT_BUFFER_DECL( "Kernel : signal_block condition %p (s: %p)\n", &this, signallee );
 
 	//Everything is ready to go to sleep
@@ -512,10 +512,10 @@
 
 // Access the user_info of the thread waiting at the front of the queue
-uintptr_t front( condition * this ) {
+uintptr_t front( condition & this ) {
 	verifyf( !is_empty(this),
 		"Attempt to access user data on an empty condition.\n"
 		"Possible cause is not checking if the condition is empty before reading stored data."
 	);
-	return this->blocked.head->user_info;
+	return this.blocked.head->user_info;
 }
 
@@ -811,14 +811,14 @@
 }
 
-static inline void brand_condition( condition * this ) {
+static inline void brand_condition( condition & this ) {
 	thread_desc * thrd = this_thread;
-	if( !this->monitors ) {
+	if( !this.monitors ) {
 		// LIB_DEBUG_PRINT_SAFE("Branding\n");
 		assertf( thrd->monitors.list != NULL, "No current monitor to brand condition %p", thrd->monitors.list );
-		this->monitor_count = thrd->monitors.size;
-
-		this->monitors = malloc( this->monitor_count * sizeof( *this->monitors ) );
-		for( int i = 0; i < this->monitor_count; i++ ) {
-			this->monitors[i] = thrd->monitors.list[i];
+		this.monitor_count = thrd->monitors.size;
+
+		this.monitors = malloc( this.monitor_count * sizeof( *this.monitors ) );
+		for( int i = 0; i < this.monitor_count; i++ ) {
+			this.monitors[i] = thrd->monitors.list[i];
 		}
 	}