Index: src/libcfa/concurrency/monitor.c
===================================================================
--- src/libcfa/concurrency/monitor.c	(revision c40e7c50c63d8609881909b05381968059fbeef7)
+++ src/libcfa/concurrency/monitor.c	(revision d56ca3549a29e84c57908987b2e9e0f6adc5ba42)
@@ -10,6 +10,6 @@
 // Created On       : Thd Feb 23 12:27:26 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jul 31 14:59:05 2017
-// Update Count     : 3
+// Last Modified On : Thu Feb  8 16:12:20 2018
+// Update Count     : 4
 //
 
@@ -87,5 +87,5 @@
 		thread_desc * thrd = this_thread;
 
-		__cfaabi_dbg_print_safe("Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
+		__cfaabi_dbg_print_safe( "Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
 
 		if( !this->owner ) {
@@ -93,5 +93,5 @@
 			set_owner( this, thrd );
 
-			__cfaabi_dbg_print_safe("Kernel :  mon is free \n");
+			__cfaabi_dbg_print_safe( "Kernel :  mon is free \n" );
 		}
 		else if( this->owner == thrd) {
@@ -99,5 +99,5 @@
 			this->recursion += 1;
 
-			__cfaabi_dbg_print_safe("Kernel :  mon already owned \n");
+			__cfaabi_dbg_print_safe( "Kernel :  mon already owned \n" );
 		}
 		else if( is_accepted( this, group) ) {
@@ -108,8 +108,8 @@
 			reset_mask( this );
 
-			__cfaabi_dbg_print_safe("Kernel :  mon accepts \n");
+			__cfaabi_dbg_print_safe( "Kernel :  mon accepts \n" );
 		}
 		else {
-			__cfaabi_dbg_print_safe("Kernel :  blocking \n");
+			__cfaabi_dbg_print_safe( "Kernel :  blocking \n" );
 
 			// Some one else has the monitor, wait in line for it
@@ -118,5 +118,5 @@
 			BlockInternal( &this->lock );
 
-			__cfaabi_dbg_print_safe("Kernel : %10p Entered  mon %p\n", thrd, this);
+			__cfaabi_dbg_print_safe( "Kernel : %10p Entered  mon %p\n", thrd, this);
 
 			// BlockInternal will unlock spinlock, no need to unlock ourselves
@@ -124,5 +124,5 @@
 		}
 
-		__cfaabi_dbg_print_safe("Kernel : %10p Entered  mon %p\n", thrd, this);
+		__cfaabi_dbg_print_safe( "Kernel : %10p Entered  mon %p\n", thrd, this);
 
 		// Release the lock and leave
@@ -136,9 +136,9 @@
 		thread_desc * thrd = this_thread;
 
-		__cfaabi_dbg_print_safe("Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner);
+		__cfaabi_dbg_print_safe( "Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner);
 
 
 		if( !this->owner ) {
-			__cfaabi_dbg_print_safe("Kernel : Destroying free mon %p\n", this);
+			__cfaabi_dbg_print_safe( "Kernel : Destroying free mon %p\n", this);
 
 			// No one has the monitor, just take it
@@ -151,5 +151,5 @@
 			// We already have the monitor... but where about to destroy it so the nesting will fail
 			// Abort!
-			abortf("Attempt to destroy monitor %p by thread \"%.256s\" (%p) in nested mutex.");
+			abort( "Attempt to destroy monitor %p by thread \"%.256s\" (%p) in nested mutex." );
 		}
 
@@ -158,5 +158,5 @@
 		__monitor_group_t group = { &this, 1, func };
 		if( is_accepted( this, group) ) {
-			__cfaabi_dbg_print_safe("Kernel :  mon accepts dtor, block and signal it \n");
+			__cfaabi_dbg_print_safe( "Kernel :  mon accepts dtor, block and signal it \n" );
 
 			// Wake the thread that is waiting for this
@@ -177,5 +177,5 @@
 		}
 		else {
-			__cfaabi_dbg_print_safe("Kernel :  blocking \n");
+			__cfaabi_dbg_print_safe( "Kernel :  blocking \n" );
 
 			wait_ctx( this_thread, 0 )
@@ -190,5 +190,5 @@
 		}
 
-		__cfaabi_dbg_print_safe("Kernel : Destroying %p\n", this);
+		__cfaabi_dbg_print_safe( "Kernel : Destroying %p\n", this);
 
 	}
@@ -199,5 +199,5 @@
 		lock( this->lock __cfaabi_dbg_ctx2 );
 
-		__cfaabi_dbg_print_safe("Kernel : %10p Leaving mon %p (%p)\n", this_thread, this, this->owner);
+		__cfaabi_dbg_print_safe( "Kernel : %10p Leaving mon %p (%p)\n", this_thread, this, this->owner);
 
 		verifyf( this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", this_thread, this->owner, this->recursion, this );
@@ -209,5 +209,5 @@
 		// it means we don't need to do anything
 		if( this->recursion != 0) {
-			__cfaabi_dbg_print_safe("Kernel :  recursion still %d\n", this->recursion);
+			__cfaabi_dbg_print_safe( "Kernel :  recursion still %d\n", this->recursion);
 			unlock( this->lock );
 			return;
@@ -228,8 +228,8 @@
 		__cfaabi_dbg_debug_do(
 			if( this_thread != this->owner ) {
-				abortf("Destroyed monitor %p has inconsistent owner, expected %p got %p.\n", this, this_thread, this->owner);
+				abort( "Destroyed monitor %p has inconsistent owner, expected %p got %p.\n", this, this_thread, this->owner);
 			}
 			if( this->recursion != 1 ) {
-				abortf("Destroyed monitor %p has %d outstanding nested calls.\n", this, this->recursion - 1);
+				abort( "Destroyed monitor %p has %d outstanding nested calls.\n", this, this->recursion - 1);
 			}
 		)
@@ -256,5 +256,5 @@
 		// If we haven't left the last level of recursion
 		// it must mean there is an error
-		if( this->recursion != 0) { abortf("Thread internal monitor has unbalanced recursion"); }
+		if( this->recursion != 0) { abort( "Thread internal monitor has unbalanced recursion" ); }
 
 		// Fetch the next thread, can be null
@@ -302,5 +302,5 @@
 	(this_thread->monitors){m, count, func};
 
-	// __cfaabi_dbg_print_safe("MGUARD : enter %d\n", count);
+	// __cfaabi_dbg_print_safe( "MGUARD : enter %d\n", count);
 
 	// Enter the monitors in order
@@ -308,5 +308,5 @@
 	enter( group );
 
-	// __cfaabi_dbg_print_safe("MGUARD : entered\n");
+	// __cfaabi_dbg_print_safe( "MGUARD : entered\n" );
 }
 
@@ -314,10 +314,10 @@
 // Dtor for monitor guard
 void ^?{}( monitor_guard_t & this ) {
-	// __cfaabi_dbg_print_safe("MGUARD : leaving %d\n", this.count);
+	// __cfaabi_dbg_print_safe( "MGUARD : leaving %d\n", this.count);
 
 	// Leave the monitors in order
 	leave( this.m, this.count );
 
-	// __cfaabi_dbg_print_safe("MGUARD : left\n");
+	// __cfaabi_dbg_print_safe( "MGUARD : left\n" );
 
 	// Restore thread context
@@ -427,10 +427,10 @@
 		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 );
+			abort( "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[i] ) {
-				abortf( "Signal on condition %p made with different monitor, expected %p got %i", &this, this.monitors[i], this_thrd->monitors[i] );
+				abort( "Signal on condition %p made with different monitor, expected %p got %i", &this, this.monitors[i], this_thrd->monitors[i] );
 			}
 		}
@@ -534,5 +534,5 @@
 	if(actual_count == 0) return;
 
-	__cfaabi_dbg_print_buffer_local( "Kernel : waitfor internal proceeding\n");
+	__cfaabi_dbg_print_buffer_local( "Kernel : waitfor internal proceeding\n" );
 
 	// Create storage for monitor context
@@ -551,5 +551,5 @@
 			__acceptable_t& accepted = mask[index];
 			if( accepted.is_dtor ) {
-				__cfaabi_dbg_print_buffer_local( "Kernel : dtor already there\n");
+				__cfaabi_dbg_print_buffer_local( "Kernel : dtor already there\n" );
 				verifyf( accepted.size == 1,  "ERROR: Accepted dtor has more than 1 mutex parameter." );
 
@@ -563,5 +563,5 @@
 			}
 			else {
-				__cfaabi_dbg_print_buffer_local( "Kernel : thread present, baton-passing\n");
+				__cfaabi_dbg_print_buffer_local( "Kernel : thread present, baton-passing\n" );
 
 				// Create the node specific to this wait operation
@@ -577,5 +577,5 @@
 					}
 				#endif
-				__cfaabi_dbg_print_buffer_local( "\n");
+				__cfaabi_dbg_print_buffer_local( "\n" );
 
 				// Set the owners to be the next thread
@@ -588,5 +588,5 @@
 				monitor_restore;
 
-				__cfaabi_dbg_print_buffer_local( "Kernel : thread present, returned\n");
+				__cfaabi_dbg_print_buffer_local( "Kernel : thread present, returned\n" );
 			}
 
@@ -598,5 +598,5 @@
 
 	if( duration == 0 ) {
-		__cfaabi_dbg_print_buffer_local( "Kernel : non-blocking, exiting\n");
+		__cfaabi_dbg_print_buffer_local( "Kernel : non-blocking, exiting\n" );
 
 		unlock_all( locks, count );
@@ -607,7 +607,7 @@
 
 
-	verifyf( duration < 0, "Timeout on waitfor statments not supported yet.");
-
-	__cfaabi_dbg_print_buffer_local( "Kernel : blocking waitfor\n");
+	verifyf( duration < 0, "Timeout on waitfor statments not supported yet." );
+
+	__cfaabi_dbg_print_buffer_local( "Kernel : blocking waitfor\n" );
 
 	// Create the node specific to this wait operation
@@ -631,5 +631,5 @@
 	monitor_restore;
 
-	__cfaabi_dbg_print_buffer_local( "Kernel : exiting\n");
+	__cfaabi_dbg_print_buffer_local( "Kernel : exiting\n" );
 
 	__cfaabi_dbg_print_buffer_local( "Kernel : accepted %d\n", *mask.accepted);
@@ -640,5 +640,5 @@
 
 static inline void set_owner( monitor_desc * this, thread_desc * owner ) {
-	// __cfaabi_dbg_print_safe("Kernal :   Setting owner of %p to %p ( was %p)\n", this, owner, this->owner );
+	// __cfaabi_dbg_print_safe( "Kernal :   Setting owner of %p to %p ( was %p)\n", this, owner, this->owner );
 
 	//Pass the monitor appropriately
@@ -672,5 +672,5 @@
 static inline thread_desc * next_thread( monitor_desc * this ) {
 	//Check the signaller stack
-	__cfaabi_dbg_print_safe("Kernel :  mon %p AS-stack top %p\n", this, this->signal_stack.top);
+	__cfaabi_dbg_print_safe( "Kernel :  mon %p AS-stack top %p\n", this, this->signal_stack.top);
 	__condition_criterion_t * urgent = pop( this->signal_stack );
 	if( urgent ) {
@@ -814,5 +814,5 @@
 	thread_desc * thrd = this_thread;
 	if( !this.monitors ) {
-		// __cfaabi_dbg_print_safe("Branding\n");
+		// __cfaabi_dbg_print_safe( "Branding\n" );
 		assertf( thrd->monitors.data != NULL, "No current monitor to brand condition %p", thrd->monitors.data );
 		this.monitor_count = thrd->monitors.size;
