Index: src/libcfa/concurrency/alarm.c
===================================================================
--- src/libcfa/concurrency/alarm.c	(revision 135b43118e38aa40c2f0cbfa16829e4b41313af7)
+++ src/libcfa/concurrency/alarm.c	(revision 6b224a52e644258a65fc4b1af5b45c5d9c835149)
@@ -40,24 +40,24 @@
 __cfa_time_t zero_time = { 0 };
 
-void ?{}( __cfa_time_t * this ) { this->val = 0; }
-void ?{}( __cfa_time_t * this, zero_t zero ) { this->val = 0; }
-
-void ?{}( itimerval * this, __cfa_time_t * alarm ) {
-	this->it_value.tv_sec = alarm->val / one_second;			// seconds
-	this->it_value.tv_usec = max( (alarm->val % one_second) / one_microsecond, 1000 ); // microseconds
-	this->it_interval.tv_sec = 0;
-	this->it_interval.tv_usec = 0;
-}
-
-
-void ?{}( __cfa_time_t * this, timespec * curr ) {
+void ?{}( __cfa_time_t & this ) { this.val = 0; }
+void ?{}( __cfa_time_t & this, zero_t zero ) { this.val = 0; }
+
+void ?{}( itimerval & this, __cfa_time_t * alarm ) {
+	this.it_value.tv_sec = alarm->val / one_second;			// seconds
+	this.it_value.tv_usec = max( (alarm->val % one_second) / one_microsecond, 1000 ); // microseconds
+	this.it_interval.tv_sec = 0;
+	this.it_interval.tv_usec = 0;
+}
+
+
+void ?{}( __cfa_time_t & this, timespec * curr ) {
 	uint64_t secs  = curr->tv_sec;
 	uint64_t nsecs = curr->tv_nsec;
-	this->val = (secs * one_second) + nsecs;
-}
-
-__cfa_time_t ?=?( __cfa_time_t * this, zero_t rhs ) {
-	this->val = 0;
-	return *this;
+	this.val = (secs * one_second) + nsecs;
+}
+
+__cfa_time_t ?=?( __cfa_time_t & this, zero_t rhs ) {
+	this.val = 0;
+	return this;
 }
 
@@ -86,25 +86,25 @@
 //=============================================================================================
 
-void ?{}( alarm_node_t * this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) {
-	this->thrd = thrd;
-	this->alarm = alarm;
-	this->period = period;
-	this->next = 0;
-	this->set = false;
-	this->kernel_alarm = false;
-}
-
-void ?{}( alarm_node_t * this, processor   * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) {
-	this->proc = proc;
-	this->alarm = alarm;
-	this->period = period;
-	this->next = 0;
-	this->set = false;
-	this->kernel_alarm = true;
-}
-
-void ^?{}( alarm_node_t * this ) {
-	if( this->set ) {
-		unregister_self( this );
+void ?{}( alarm_node_t & this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) {
+	this.thrd = thrd;
+	this.alarm = alarm;
+	this.period = period;
+	this.next = 0;
+	this.set = false;
+	this.kernel_alarm = false;
+}
+
+void ?{}( alarm_node_t & this, processor   * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) {
+	this.proc = proc;
+	this.alarm = alarm;
+	this.period = period;
+	this.next = 0;
+	this.set = false;
+	this.kernel_alarm = true;
+}
+
+void ^?{}( alarm_node_t & this ) {
+	if( this.set ) {
+		unregister_self( &this );
 	}
 }
Index: src/libcfa/concurrency/alarm.h
===================================================================
--- src/libcfa/concurrency/alarm.h	(revision 135b43118e38aa40c2f0cbfa16829e4b41313af7)
+++ src/libcfa/concurrency/alarm.h	(revision 6b224a52e644258a65fc4b1af5b45c5d9c835149)
@@ -36,10 +36,10 @@
 
 // ctors
-void ?{}( __cfa_time_t * this );
-void ?{}( __cfa_time_t * this, zero_t zero );
-void ?{}( __cfa_time_t * this, timespec * curr );
-void ?{}( itimerval * this, __cfa_time_t * alarm );
+void ?{}( __cfa_time_t & this );
+void ?{}( __cfa_time_t & this, zero_t zero );
+void ?{}( __cfa_time_t & this, timespec * curr );
+void ?{}( itimerval & this, __cfa_time_t * alarm );
 
-__cfa_time_t ?=?( __cfa_time_t * this, zero_t rhs );
+__cfa_time_t ?=?( __cfa_time_t & this, zero_t rhs );
 
 // logical ops
@@ -105,7 +105,7 @@
 typedef alarm_node_t ** __alarm_it_t;
 
-void ?{}( alarm_node_t * this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time );
-void ?{}( alarm_node_t * this, processor   * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time );
-void ^?{}( alarm_node_t * this );
+void ?{}( alarm_node_t & this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time );
+void ?{}( alarm_node_t & this, processor   * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time );
+void ^?{}( alarm_node_t & this );
 
 struct alarm_list_t {
@@ -114,7 +114,7 @@
 };
 
-static inline void ?{}( alarm_list_t * this ) {
-	this->head = 0;
-	this->tail = &this->head;
+static inline void ?{}( alarm_list_t & this ) {
+	this.head = 0;
+	this.tail = &this.head;
 }
 
Index: src/libcfa/concurrency/coroutine
===================================================================
--- src/libcfa/concurrency/coroutine	(revision 135b43118e38aa40c2f0cbfa16829e4b41313af7)
+++ src/libcfa/concurrency/coroutine	(revision 6b224a52e644258a65fc4b1af5b45c5d9c835149)
@@ -25,17 +25,17 @@
 // Anything that is resumed is a coroutine.
 trait is_coroutine(dtype T) {
-      void main(T * this);
-      coroutine_desc * get_coroutine(T * this);
+      void main(T & this);
+      coroutine_desc * get_coroutine(T & this);
 };
 
-#define DECL_COROUTINE(X) static inline coroutine_desc* get_coroutine(X* this) { return &this->__cor; } void main(X* this)
+#define DECL_COROUTINE(X) static inline coroutine_desc* get_coroutine(X& this) { return &this.__cor; } void main(X& this)
 
 //-----------------------------------------------------------------------------
 // Ctors and dtors
-void ?{}(coStack_t * this);
-void ?{}(coroutine_desc * this);
-void ?{}(coroutine_desc * this, const char * name);
-void ^?{}(coStack_t * this);
-void ^?{}(coroutine_desc * this);
+void ?{}(coStack_t & this);
+void ?{}(coroutine_desc & this);
+void ?{}(coroutine_desc & this, const char * name);
+void ^?{}(coStack_t & this);
+void ^?{}(coroutine_desc & this);
 
 //-----------------------------------------------------------------------------
@@ -44,8 +44,8 @@
 
 forall(dtype T | is_coroutine(T))
-static inline void resume(T * cor);
+static inline void resume(T & cor);
 
 forall(dtype T | is_coroutine(T))
-void prime(T * cor);
+void prime(T & cor);
 
 //-----------------------------------------------------------------------------
@@ -86,5 +86,5 @@
 // Resume implementation inlined for performance
 forall(dtype T | is_coroutine(T))
-static inline void resume(T * cor) {
+static inline void resume(T & cor) {
 	coroutine_desc * src = this_coroutine;		// optimization
 	coroutine_desc * dst = get_coroutine(cor);
@@ -92,5 +92,5 @@
 	if( unlikely(!dst->stack.base) ) {
 		create_stack(&dst->stack, dst->stack.size);
-		CtxStart(cor, CtxInvokeCoroutine);
+		CtxStart(&cor, CtxInvokeCoroutine);
 	}
 
Index: src/libcfa/concurrency/coroutine.c
===================================================================
--- src/libcfa/concurrency/coroutine.c	(revision 135b43118e38aa40c2f0cbfa16829e4b41313af7)
+++ src/libcfa/concurrency/coroutine.c	(revision 6b224a52e644258a65fc4b1af5b45c5d9c835149)
@@ -40,55 +40,55 @@
 //-----------------------------------------------------------------------------
 // Coroutine ctors and dtors
-void ?{}(coStack_t* this) {
-	this->size		= 65000;	// size of stack
-	this->storage	= NULL;	// pointer to stack
-	this->limit		= NULL;	// stack grows towards stack limit
-	this->base		= NULL;	// base of stack
-	this->context	= NULL;	// address of cfa_context_t
-	this->top		= NULL;	// address of top of storage
-	this->userStack	= false;
+void ?{}(coStack_t& this) {
+	this.size		= 65000;	// size of stack
+	this.storage	= NULL;	// pointer to stack
+	this.limit		= NULL;	// stack grows towards stack limit
+	this.base		= NULL;	// base of stack
+	this.context	= NULL;	// address of cfa_context_t
+	this.top		= NULL;	// address of top of storage
+	this.userStack	= false;
 }
 
-void ?{}(coStack_t* this, size_t size) {
+void ?{}(coStack_t& this, size_t size) {
 	this{};
-	this->size = size;
+	this.size = size;
 
-	create_stack(this, this->size);
+	create_stack(&this, this.size);
 }
 
-void ?{}(coroutine_desc* this) {
+void ?{}(coroutine_desc& this) {
 	this{ "Anonymous Coroutine" };
 }
 
-void ?{}(coroutine_desc* this, const char * name) {
-	this->name = name;
-	this->errno_ = 0;
-	this->state = Start;
-	this->starter = NULL;
-	this->last = NULL;
+void ?{}(coroutine_desc& this, const char * name) {
+	this.name = name;
+	this.errno_ = 0;
+	this.state = Start;
+	this.starter = NULL;
+	this.last = NULL;
 }
 
-void ?{}(coroutine_desc* this, size_t size) {
+void ?{}(coroutine_desc& this, size_t size) {
 	this{};
-	(&this->stack){size};
+	(this.stack){size};
 }
 
-void ^?{}(coStack_t* this) {
-	if ( ! this->userStack ) {
+void ^?{}(coStack_t& this) {
+	if ( ! this.userStack ) {
 		LIB_DEBUG_DO(
-			if ( mprotect( this->storage, pageSize, PROT_READ | PROT_WRITE ) == -1 ) {
-				abortf( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", this, errno, strerror( errno ) );
+			if ( mprotect( this.storage, pageSize, PROT_READ | PROT_WRITE ) == -1 ) {
+				abortf( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) );
 			}
 		);
-		free( this->storage );
+		free( this.storage );
 	}
 }
 
-void ^?{}(coroutine_desc* this) {}
+void ^?{}(coroutine_desc& this) {}
 
 // Part of the Public API
 // Not inline since only ever called once per coroutine
 forall(dtype T | is_coroutine(T))
-void prime(T* cor) {
+void prime(T& cor) {
 	coroutine_desc* this = get_coroutine(cor);
 	assert(this->state == Start);
Index: src/libcfa/concurrency/invoke.h
===================================================================
--- src/libcfa/concurrency/invoke.h	(revision 135b43118e38aa40c2f0cbfa16829e4b41313af7)
+++ src/libcfa/concurrency/invoke.h	(revision 6b224a52e644258a65fc4b1af5b45c5d9c835149)
@@ -49,15 +49,15 @@
       #ifdef __CFORALL__
       extern "Cforall" {
-            void ?{}( struct __thread_queue_t * );
+            void ?{}( struct __thread_queue_t & );
             void append( struct __thread_queue_t *, struct thread_desc * );
             struct thread_desc * pop_head( struct __thread_queue_t * );
             struct thread_desc * remove( struct __thread_queue_t *, struct thread_desc ** );
 
-            void ?{}( struct __condition_stack_t * );
+            void ?{}( struct __condition_stack_t & );
             void push( struct __condition_stack_t *, struct __condition_criterion_t * );
             struct __condition_criterion_t * pop( struct __condition_stack_t * );
 
-            void ?{}(spinlock * this);
-            void ^?{}(spinlock * this);
+            void ?{}(spinlock & this);
+            void ^?{}(spinlock & this);
       }
       #endif
Index: src/libcfa/concurrency/kernel
===================================================================
--- src/libcfa/concurrency/kernel	(revision 135b43118e38aa40c2f0cbfa16829e4b41313af7)
+++ src/libcfa/concurrency/kernel	(revision 6b224a52e644258a65fc4b1af5b45c5d9c835149)
@@ -37,6 +37,6 @@
 };
 
-void  ?{}(semaphore * this, int count = 1);
-void ^?{}(semaphore * this);
+void  ?{}(semaphore & this, int count = 1);
+void ^?{}(semaphore & this);
 void P(semaphore * this);
 void V(semaphore * this);
@@ -51,6 +51,6 @@
 };
 
-void ?{}(cluster * this);
-void ^?{}(cluster * this);
+void ?{}(cluster & this);
+void ^?{}(cluster & this);
 
 //-----------------------------------------------------------------------------
@@ -68,10 +68,10 @@
 	unsigned short thrd_count;
 };
-static inline void ?{}(FinishAction * this) {
-	this->action_code = No_Action;
-	this->thrd = NULL;
-	this->lock = NULL;
+static inline void ?{}(FinishAction & this) {
+	this.action_code = No_Action;
+	this.thrd = NULL;
+	this.lock = NULL;
 }
-static inline void ^?{}(FinishAction * this) {}
+static inline void ^?{}(FinishAction & this) {}
 
 // Processor
@@ -99,7 +99,7 @@
 };
 
-void ?{}(processor * this);
-void ?{}(processor * this, cluster * cltr);
-void ^?{}(processor * this);
+void ?{}(processor & this);
+void ?{}(processor & this, cluster * cltr);
+void ^?{}(processor & this);
 
 // Local Variables: //
Index: src/libcfa/concurrency/kernel.c
===================================================================
--- src/libcfa/concurrency/kernel.c	(revision 135b43118e38aa40c2f0cbfa16829e4b41313af7)
+++ src/libcfa/concurrency/kernel.c	(revision 6b224a52e644258a65fc4b1af5b45c5d9c835149)
@@ -73,97 +73,97 @@
 };
 
-void ?{}( current_stack_info_t * this ) {
-	CtxGet( this->ctx );
-	this->base = this->ctx.FP;
-	this->storage = this->ctx.SP;
+void ?{}( current_stack_info_t & this ) {
+	CtxGet( this.ctx );
+	this.base = this.ctx.FP;
+	this.storage = this.ctx.SP;
 
 	rlimit r;
 	getrlimit( RLIMIT_STACK, &r);
-	this->size = r.rlim_cur;
-
-	this->limit = (void *)(((intptr_t)this->base) - this->size);
-	this->context = &storage_mainThreadCtx;
-	this->top = this->base;
-}
-
-void ?{}( coStack_t * this, current_stack_info_t * info) {
-	this->size = info->size;
-	this->storage = info->storage;
-	this->limit = info->limit;
-	this->base = info->base;
-	this->context = info->context;
-	this->top = info->top;
-	this->userStack = true;
-}
-
-void ?{}( coroutine_desc * this, current_stack_info_t * info) {
-	(&this->stack){ info };
-	this->name = "Main Thread";
-	this->errno_ = 0;
-	this->state = Start;
-}
-
-void ?{}( thread_desc * this, current_stack_info_t * info) {
-	(&this->cor){ info };
+	this.size = r.rlim_cur;
+
+	this.limit = (void *)(((intptr_t)this.base) - this.size);
+	this.context = &storage_mainThreadCtx;
+	this.top = this.base;
+}
+
+void ?{}( coStack_t & this, current_stack_info_t * info) {
+	this.size = info->size;
+	this.storage = info->storage;
+	this.limit = info->limit;
+	this.base = info->base;
+	this.context = info->context;
+	this.top = info->top;
+	this.userStack = true;
+}
+
+void ?{}( coroutine_desc & this, current_stack_info_t * info) {
+	(this.stack){ info };
+	this.name = "Main Thread";
+	this.errno_ = 0;
+	this.state = Start;
+}
+
+void ?{}( thread_desc & this, current_stack_info_t * info) {
+	(this.cor){ info };
 }
 
 //-----------------------------------------------------------------------------
 // Processor coroutine
-void ?{}(processorCtx_t * this, processor * proc) {
-	(&this->__cor){ "Processor" };
-	this->proc = proc;
-	proc->runner = this;
-}
-
-void ?{}(processorCtx_t * this, processor * proc, current_stack_info_t * info) {
-	(&this->__cor){ info };
-	this->proc = proc;
-	proc->runner = this;
-}
-
-void ?{}(processor * this) {
+void ?{}(processorCtx_t & this, processor * proc) {
+	(this.__cor){ "Processor" };
+	this.proc = proc;
+	proc->runner = &this;
+}
+
+void ?{}(processorCtx_t & this, processor * proc, current_stack_info_t * info) {
+	(this.__cor){ info };
+	this.proc = proc;
+	proc->runner = &this;
+}
+
+void ?{}(processor & this) {
 	this{ mainCluster };
 }
 
-void ?{}(processor * this, cluster * cltr) {
-	this->cltr = cltr;
-	(&this->terminated){ 0 };
-	this->do_terminate = false;
-	this->preemption_alarm = NULL;
-	this->pending_preemption = false;
-
-	start( this );
-}
-
-void ?{}(processor * this, cluster * cltr, processorCtx_t * runner) {
-	this->cltr = cltr;
-	(&this->terminated){ 0 };
-	this->do_terminate = false;
-	this->preemption_alarm = NULL;
-	this->pending_preemption = false;
-	this->kernel_thread = pthread_self();
-
-	this->runner = runner;
-	LIB_DEBUG_PRINT_SAFE("Kernel : constructing main processor context %p\n", runner);
-	runner{ this };
-}
-
-void ^?{}(processor * this) {
-	if( ! this->do_terminate ) {
-		LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", this);
-		this->do_terminate = true;
-		P( &this->terminated );
-		pthread_join( this->kernel_thread, NULL );
-	}
-}
-
-void ?{}(cluster * this) {
-	( &this->ready_queue ){};
-	( &this->ready_queue_lock ){};
-
-	this->preemption = default_preemption();
-}
-
-void ^?{}(cluster * this) {
+void ?{}(processor & this, cluster * cltr) {
+	this.cltr = cltr;
+	(this.terminated){ 0 };
+	this.do_terminate = false;
+	this.preemption_alarm = NULL;
+	this.pending_preemption = false;
+
+	start( &this );
+}
+
+void ?{}(processor & this, cluster * cltr, processorCtx_t & runner) {
+	this.cltr = cltr;
+	(this.terminated){ 0 };
+	this.do_terminate = false;
+	this.preemption_alarm = NULL;
+	this.pending_preemption = false;
+	this.kernel_thread = pthread_self();
+
+	this.runner = &runner;
+	LIB_DEBUG_PRINT_SAFE("Kernel : constructing main processor context %p\n", &runner);
+	runner{ &this };
+}
+
+void ^?{}(processor & this) {
+	if( ! this.do_terminate ) {
+		LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", &this);
+		this.do_terminate = true;
+		P( &this.terminated );
+		pthread_join( this.kernel_thread, NULL );
+	}
+}
+
+void ?{}(cluster & this) {
+	( this.ready_queue ){};
+	( this.ready_queue_lock ){};
+
+	this.preemption = default_preemption();
+}
+
+void ^?{}(cluster & this) {
 
 }
@@ -173,6 +173,6 @@
 //=============================================================================================
 //Main of the processor contexts
-void main(processorCtx_t * runner) {
-	processor * this = runner->proc;
+void main(processorCtx_t & runner) {
+	processor * this = runner.proc;
 
 	LIB_DEBUG_PRINT_SAFE("Kernel : core %p starting\n", this);
@@ -219,5 +219,5 @@
 // from the processor coroutine to the target thread
 void runThread(processor * this, thread_desc * dst) {
-	coroutine_desc * proc_cor = get_coroutine(this->runner);
+	coroutine_desc * proc_cor = get_coroutine(*this->runner);
 	coroutine_desc * thrd_cor = get_coroutine(dst);
 
@@ -301,5 +301,5 @@
 	// appropriate stack.
 	proc_cor_storage.__cor.state = Active;
-	main( &proc_cor_storage );
+	main( proc_cor_storage );
 	proc_cor_storage.__cor.state = Halted;
 
@@ -443,5 +443,5 @@
 	mainThread = (thread_desc *)&storage_mainThread;
 	current_stack_info_t info;
-	mainThread{ &info };
+	(*mainThread){ &info };
 
 	LIB_DEBUG_PRINT_SAFE("Kernel : Main thread ready\n");
@@ -449,5 +449,5 @@
 	// Initialize the main cluster
 	mainCluster = (cluster *)&storage_mainCluster;
-	mainCluster{};
+	(*mainCluster){};
 
 	LIB_DEBUG_PRINT_SAFE("Kernel : main cluster ready\n");
@@ -456,5 +456,5 @@
 	// (the coroutine that contains the processing control flow)
 	mainProcessor = (processor *)&storage_mainProcessor;
-	mainProcessor{ mainCluster, (processorCtx_t *)&storage_mainProcessorCtx };
+	(*mainProcessor){ mainCluster, *(processorCtx_t *)&storage_mainProcessorCtx };
 
 	//initialize the global state variables
@@ -473,5 +473,5 @@
 	// context. Hence, the main thread does not begin through CtxInvokeThread, like all other threads. The trick here is that
 	// mainThread is on the ready queue when this call is made.
-	resume( mainProcessor->runner );
+	resume( *mainProcessor->runner );
 
 
@@ -501,5 +501,5 @@
 	// Destroy the main processor and its context in reverse order of construction
 	// These were manually constructed so we need manually destroy them
-	^(mainProcessor->runner){};
+	^(*mainProcessor->runner){};
 	^(mainProcessor){};
 
@@ -569,8 +569,8 @@
 //-----------------------------------------------------------------------------
 // Locks
-void ?{}( spinlock * this ) {
-	this->lock = 0;
-}
-void ^?{}( spinlock * this ) {
+void ?{}( spinlock & this ) {
+	this.lock = 0;
+}
+void ^?{}( spinlock & this ) {
 
 }
@@ -606,10 +606,10 @@
 }
 
-void  ?{}( semaphore * this, int count = 1 ) {
-	(&this->lock){};
-	this->count = count;
-	(&this->waiting){};
-}
-void ^?{}(semaphore * this) {}
+void  ?{}( semaphore & this, int count = 1 ) {
+	(this.lock){};
+	this.count = count;
+	(this.waiting){};
+}
+void ^?{}(semaphore & this) {}
 
 void P(semaphore * this) {
@@ -645,7 +645,7 @@
 //-----------------------------------------------------------------------------
 // Queues
-void ?{}( __thread_queue_t * this ) {
-	this->head = NULL;
-	this->tail = &this->head;
+void ?{}( __thread_queue_t & this ) {
+	this.head = NULL;
+	this.tail = &this.head;
 }
 
@@ -685,8 +685,6 @@
 }
 
-
-
-void ?{}( __condition_stack_t * this ) {
-	this->top = NULL;
+void ?{}( __condition_stack_t & this ) {
+	this.top = NULL;
 }
 
Index: src/libcfa/concurrency/monitor
===================================================================
--- src/libcfa/concurrency/monitor	(revision 135b43118e38aa40c2f0cbfa16829e4b41313af7)
+++ src/libcfa/concurrency/monitor	(revision 6b224a52e644258a65fc4b1af5b45c5d9c835149)
@@ -22,13 +22,13 @@
 #include "stdlib"
 
-static inline void ?{}(monitor_desc * this) {
-	(&this->lock){};
-	this->owner = NULL;
-	(&this->entry_queue){};
-	(&this->signal_stack){};
-	this->recursion = 0;
-	this->acceptables = NULL;
-	this->acceptable_count = 0;
-	this->accepted_index = -1;
+static inline void ?{}(monitor_desc & this) {
+	(this.lock){};
+	this.owner = NULL;
+	(this.entry_queue){};
+	(this.signal_stack){};
+	this.recursion = 0;
+	this.acceptables = NULL;
+	this.acceptable_count = 0;
+	this.accepted_index = -1;
 }
 
@@ -45,6 +45,6 @@
 }
 
-void ?{}( monitor_guard_t * this, monitor_desc ** m, int count, void (*func)() );
-void ^?{}( monitor_guard_t * this );
+void ?{}( monitor_guard_t & this, monitor_desc ** m, int count );
+void ^?{}( monitor_guard_t & this );
 
 //-----------------------------------------------------------------------------
@@ -71,5 +71,5 @@
 };
 
-void ?{}( __condition_blocked_queue_t * );
+void ?{}( __condition_blocked_queue_t & );
 void append( __condition_blocked_queue_t *, __condition_node_t * );
 __condition_node_t * pop_head( __condition_blocked_queue_t * );
@@ -81,11 +81,11 @@
 };
 
-static inline void ?{}( condition * this ) {
-	this->monitors = NULL;
-	this->monitor_count = 0;
+static inline void ?{}( condition & this ) {
+	this.monitors = NULL;
+	this.monitor_count = 0;
 }
 
-static inline void ^?{}( condition * this ) {
-	free( this->monitors );
+static inline void ^?{}( condition & this ) {
+	free( this.monitors );
 }
 
Index: src/libcfa/concurrency/monitor.c
===================================================================
--- src/libcfa/concurrency/monitor.c	(revision 135b43118e38aa40c2f0cbfa16829e4b41313af7)
+++ src/libcfa/concurrency/monitor.c	(revision 6b224a52e644258a65fc4b1af5b45c5d9c835149)
@@ -194,16 +194,16 @@
 // Ctor for monitor guard
 // Sorts monitors before entering
-void ?{}( monitor_guard_t * this, monitor_desc ** m, int count, void (*func)() ) {
+void ?{}( monitor_guard_t & this, monitor_desc ** m, int count, void (*func)() ) {
 	// Store current array
-	this->m = m;
-	this->count = count;
+	this.m = m;
+	this.count = count;
 
 	// Sort monitors based on address -> TODO use a sort specialized for small numbers
-	qsort(this->m, count);
+	qsort(this.m, count);
 
 	// Save previous thread context
-	this->prev_mntrs = this_thread->current_monitors;
-	this->prev_count = this_thread->current_monitor_count;
-	this->prev_func  = this_thread->current_monitor_func;
+	this.prev_mntrs = this_thread->current_monitors;
+	this.prev_count = this_thread->current_monitor_count;
+	this.prev_func  = this_thread->current_monitor_func;
 
 	// Update thread context (needed for conditions)
@@ -213,40 +213,40 @@
 
 	// Enter the monitors in order
-	enter( this->m, this->count, func );
-}
+	enter( this.m, this.count, func );
+}
+
 
 // Dtor for monitor guard
-void ^?{}( monitor_guard_t * this ) {
+void ^?{}( monitor_guard_t & this ) {
 	// Leave the monitors in order
-	leave( this->m, this->count );
+	leave( this.m, this.count );
 
 	// Restore thread context
-	this_thread->current_monitors      = this->prev_mntrs;
-	this_thread->current_monitor_count = this->prev_count;
-	this_thread->current_monitor_func  = this->prev_func;
+	this_thread->current_monitors      = this.prev_mntrs;
+	this_thread->current_monitor_count = this.prev_count;
+	this_thread->current_monitor_func  = this.prev_func;
 }
 
 //-----------------------------------------------------------------------------
 // Internal scheduling types
-
-void ?{}(__condition_node_t * this, thread_desc * waiting_thread, unsigned short count, uintptr_t user_info ) {
-	this->waiting_thread = waiting_thread;
-	this->count = count;
-	this->next = NULL;
-	this->user_info = user_info;
-}
-
-void ?{}(__condition_criterion_t * this ) {
-	this->ready  = false;
-	this->target = NULL;
-	this->owner  = NULL;
-	this->next   = NULL;
-}
-
-void ?{}(__condition_criterion_t * this, monitor_desc * target, __condition_node_t * owner ) {
-	this->ready  = false;
-	this->target = target;
-	this->owner  = owner;
-	this->next   = NULL;
+void ?{}(__condition_node_t & this, thread_desc * waiting_thread, unsigned short count, uintptr_t user_info ) {
+	this.waiting_thread = waiting_thread;
+	this.count = count;
+	this.next = NULL;
+	this.user_info = user_info;
+}
+
+void ?{}(__condition_criterion_t & this ) {
+	this.ready  = false;
+	this.target = NULL;
+	this.owner  = NULL;
+	this.next   = NULL;
+}
+
+void ?{}(__condition_criterion_t & this, monitor_desc * target, __condition_node_t * owner ) {
+	this.ready  = false;
+	this.target = target;
+	this.owner  = owner;
+	this.next   = NULL;
 }
 
@@ -523,5 +523,5 @@
 static inline void init( int count, monitor_desc ** monitors, __condition_node_t * waiter, __condition_criterion_t * criteria ) {
 	for(int i = 0; i < count; i++) {
-		(&criteria[i]){ monitors[i], waiter };
+		(criteria[i]){ monitors[i], waiter };
 	}
 
@@ -531,5 +531,5 @@
 static inline void init_push( int count, monitor_desc ** monitors, __condition_node_t * waiter, __condition_criterion_t * criteria ) {
 	for(int i = 0; i < count; i++) {
-		(&criteria[i]){ monitors[i], waiter };
+		(criteria[i]){ monitors[i], waiter };
 		push( &criteria[i].target->signal_stack, &criteria[i] );
 	}
@@ -627,4 +627,5 @@
 	return end + 1;
 }
+
 
 static inline bool match( __acceptable_t * acc, thread_desc * thrd ) {
@@ -660,8 +661,7 @@
 	return NULL;
 }
-
-void ?{}( __condition_blocked_queue_t * this ) {
-	this->head = NULL;
-	this->tail = &this->head;
+void ?{}( __condition_blocked_queue_t & this ) {
+	this.head = NULL;
+	this.tail = &this.head;
 }
 
Index: src/libcfa/concurrency/preemption.c
===================================================================
--- src/libcfa/concurrency/preemption.c	(revision 135b43118e38aa40c2f0cbfa16829e4b41313af7)
+++ src/libcfa/concurrency/preemption.c	(revision 6b224a52e644258a65fc4b1af5b45c5d9c835149)
@@ -71,7 +71,7 @@
 static pthread_t alarm_thread;                        // pthread handle to alarm thread
 
-void ?{}(event_kernel_t * this) {
-	(&this->alarms){};
-	(&this->lock){};
+void ?{}(event_kernel_t & this) {
+	(this.alarms){};
+	(this.lock){};
 }
 
@@ -240,5 +240,5 @@
 	// Initialize the event kernel
 	event_kernel = (event_kernel_t *)&storage_event_kernel;
-	event_kernel{};
+	(*event_kernel){};
 
 	// Setup proper signal handlers
@@ -276,16 +276,16 @@
 // Raii ctor/dtor for the preemption_scope
 // Used by thread to control when they want to receive preemption signals
-void ?{}( preemption_scope * this, processor * proc ) {
-	(&this->alarm){ proc, zero_time, zero_time };
-	this->proc = proc;
-	this->proc->preemption_alarm = &this->alarm;
-
-	update_preemption( this->proc, from_us(this->proc->cltr->preemption) );
-}
-
-void ^?{}( preemption_scope * this ) {
+void ?{}( preemption_scope & this, processor * proc ) {
+	(this.alarm){ proc, zero_time, zero_time };
+	this.proc = proc;
+	this.proc->preemption_alarm = &this.alarm;
+
+	update_preemption( this.proc, from_us(this.proc->cltr->preemption) );
+}
+
+void ^?{}( preemption_scope & this ) {
 	disable_interrupts();
 
-	update_preemption( this->proc, zero_time );
+	update_preemption( this.proc, zero_time );
 }
 
Index: src/libcfa/concurrency/preemption.h
===================================================================
--- src/libcfa/concurrency/preemption.h	(revision 135b43118e38aa40c2f0cbfa16829e4b41313af7)
+++ src/libcfa/concurrency/preemption.h	(revision 6b224a52e644258a65fc4b1af5b45c5d9c835149)
@@ -30,6 +30,6 @@
 };
 
-void ?{}( preemption_scope * this, processor * proc );
-void ^?{}( preemption_scope * this );
+void ?{}( preemption_scope & this, processor * proc );
+void ^?{}( preemption_scope & this );
 
 // Local Variables: //
Index: src/libcfa/concurrency/thread
===================================================================
--- src/libcfa/concurrency/thread	(revision 135b43118e38aa40c2f0cbfa16829e4b41313af7)
+++ src/libcfa/concurrency/thread	(revision 6b224a52e644258a65fc4b1af5b45c5d9c835149)
@@ -27,18 +27,18 @@
 // Anything that is resumed is a coroutine.
 trait is_thread(dtype T) {
-      void ^?{}(T* mutex this);
-      void main(T* this);
-      thread_desc* get_thread(T* this);
+      void ^?{}(T& mutex this);
+      void main(T& this);
+      thread_desc* get_thread(T& this);
 };
 
-#define DECL_THREAD(X) thread_desc* get_thread(X* this) { return &this->__thrd; } void main(X* this)
+#define DECL_THREAD(X) thread_desc* get_thread(X& this) { return &this.__thrd; } void main(X& this)
 
 forall( dtype T | is_thread(T) )
-static inline coroutine_desc* get_coroutine(T* this) {
+static inline coroutine_desc* get_coroutine(T & this) {
 	return &get_thread(this)->cor;
 }
 
 forall( dtype T | is_thread(T) )
-static inline monitor_desc* get_monitor(T * this) {
+static inline monitor_desc* get_monitor(T & this) {
 	return &get_thread(this)->mon;
 }
@@ -55,10 +55,10 @@
 
 forall( dtype T | is_thread(T) )
-void __thrd_start( T* this );
+void __thrd_start( T & this );
 
 //-----------------------------------------------------------------------------
 // Ctors and dtors
-void ?{}(thread_desc* this);
-void ^?{}(thread_desc* this);
+void ?{}(thread_desc& this);
+void ^?{}(thread_desc& this);
 
 //-----------------------------------------------------------------------------
@@ -70,12 +70,12 @@
 };
 
-forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T*); } )
-void ?{}( scoped(T)* this );
+forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T&); } )
+void ?{}( scoped(T)& this );
 
-forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T*, P); } )
-void ?{}( scoped(T)* this, P params );
+forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T&, P); } )
+void ?{}( scoped(T)& this, P params );
 
 forall( dtype T | sized(T) | is_thread(T) )
-void ^?{}( scoped(T)* this );
+void ^?{}( scoped(T)& this );
 
 void yield();
Index: src/libcfa/concurrency/thread.c
===================================================================
--- src/libcfa/concurrency/thread.c	(revision 135b43118e38aa40c2f0cbfa16829e4b41313af7)
+++ src/libcfa/concurrency/thread.c	(revision 6b224a52e644258a65fc4b1af5b45c5d9c835149)
@@ -32,34 +32,34 @@
 // Thread ctors and dtors
 
-void ?{}(thread_desc* this) {
-	(&this->cor){};
-	this->cor.name = "Anonymous Coroutine";
-	this->mon.owner = this;
-	this->mon.recursion = 1;
-	this->next = NULL;
+void ?{}(thread_desc& this) {
+	(this.cor){};
+	this.cor.name = "Anonymous Coroutine";
+	this.mon.owner = &this;
+	this.mon.recursion = 1;
+	this.next = NULL;
 
-	this->current_monitors      = &this->mon;
-	this->current_monitor_count = 1;
+	this.current_monitors      = &this.mon;
+	this.current_monitor_count = 1;
 }
 
-void ^?{}(thread_desc* this) {
-	^(&this->cor){};
+void ^?{}(thread_desc& this) {
+	^(this.cor){};
 }
 
-forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T*); } )
-void ?{}( scoped(T)* this ) {
-	(&this->handle){};
-	__thrd_start(&this->handle);
+forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T&); } )
+void ?{}( scoped(T)& this ) {
+	(this.handle){};
+	__thrd_start(this.handle);
 }
 
-forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T*, P); } )
-void ?{}( scoped(T)* this, P params ) {
-	(&this->handle){ params };
-	__thrd_start(&this->handle);
+forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T&, P); } )
+void ?{}( scoped(T)& this, P params ) {
+	(this.handle){ params };
+	__thrd_start(this.handle);
 }
 
 forall( dtype T | sized(T) | is_thread(T) )
-void ^?{}( scoped(T)* this ) {
-	^(&this->handle){};
+void ^?{}( scoped(T)& this ) {
+	^(this.handle){};
 }
 
@@ -67,5 +67,5 @@
 // Starting and stopping threads
 forall( dtype T | is_thread(T) )
-void __thrd_start( T* this ) {
+void __thrd_start( T& this ) {
 	coroutine_desc* thrd_c = get_coroutine(this);
 	thread_desc*  thrd_h = get_thread   (this);
@@ -77,5 +77,5 @@
 	create_stack(&thrd_c->stack, thrd_c->stack.size);
 	this_coroutine = thrd_c;
-	CtxStart(this, CtxInvokeThread);
+	CtxStart(&this, CtxInvokeThread);
 	assert( thrd_c->last->stack.context );
 	CtxSwitch( thrd_c->last->stack.context, thrd_c->stack.context );