Index: libcfa/src/concurrency/locks.hfa
===================================================================
--- libcfa/src/concurrency/locks.hfa	(revision eba9d27bfb9dbe67e33550e6260af21e2f88541a)
+++ libcfa/src/concurrency/locks.hfa	(revision 93456846dc38174d2483127ddf47816e77c7e2a0)
@@ -39,8 +39,8 @@
 struct Semaphore0nary {
 	__spinlock_t lock; // needed to protect
-	mpsc_queue($thread) queue;
-};
-
-static inline bool P(Semaphore0nary & this, $thread * thrd) {
+	mpsc_queue(thread$) queue;
+};
+
+static inline bool P(Semaphore0nary & this, thread$ * thrd) {
 	/* paranoid */ verify(!thrd`next);
 	/* paranoid */ verify(!(&(*thrd)`next));
@@ -51,5 +51,5 @@
 
 static inline bool P(Semaphore0nary & this) {
-    $thread * thrd = active_thread();
+    thread$ * thrd = active_thread();
     P(this, thrd);
     park();
@@ -57,6 +57,6 @@
 }
 
-static inline $thread * V(Semaphore0nary & this, bool doUnpark = true) {
-	$thread * next;
+static inline thread$ * V(Semaphore0nary & this, bool doUnpark = true) {
+	thread$ * next;
 	lock(this.lock __cfaabi_dbg_ctx2);
 		for (;;) {
@@ -124,5 +124,5 @@
 static inline bool P(ThreadBenaphore & this, bool wait)   { return wait ? P(this) : tryP(this); }
 
-static inline $thread * V(ThreadBenaphore & this, bool doUnpark = true) {
+static inline thread$ * V(ThreadBenaphore & this, bool doUnpark = true) {
 	if (V(this.ben)) return 0p;
 	return V(this.sem, doUnpark);
@@ -134,5 +134,5 @@
 	__spinlock_t lock;
 	int count;
-	__queue_t($thread) waiting;
+	__queue_t(thread$) waiting;
 };
 
@@ -142,5 +142,5 @@
 bool   V (semaphore & this);
 bool   V (semaphore & this, unsigned count);
-$thread * V (semaphore & this, bool );
+thread$ * V (semaphore & this, bool );
 
 //----------
@@ -156,5 +156,5 @@
 static inline size_t on_wait  ( single_acquisition_lock & this ) { return on_wait ( (blocking_lock &)this ); }
 static inline void   on_wakeup( single_acquisition_lock & this, size_t v ) { on_wakeup ( (blocking_lock &)this, v ); }
-static inline void   on_notify( single_acquisition_lock & this, struct $thread * t ) { on_notify( (blocking_lock &)this, t ); }
+static inline void   on_notify( single_acquisition_lock & this, struct thread$ * t ) { on_notify( (blocking_lock &)this, t ); }
 
 //----------
@@ -170,8 +170,8 @@
 static inline size_t on_wait  ( owner_lock & this ) { return on_wait ( (blocking_lock &)this ); }
 static inline void   on_wakeup( owner_lock & this, size_t v ) { on_wakeup ( (blocking_lock &)this, v ); }
-static inline void   on_notify( owner_lock & this, struct $thread * t ) { on_notify( (blocking_lock &)this, t ); }
+static inline void   on_notify( owner_lock & this, struct thread$ * t ) { on_notify( (blocking_lock &)this, t ); }
 
 struct fast_lock {
-	$thread * volatile owner;
+	thread$ * volatile owner;
 	ThreadBenaphore sem;
 };
@@ -179,6 +179,6 @@
 static inline void ?{}(fast_lock & this) { this.owner = 0p; }
 
-static inline bool $try_lock(fast_lock & this, $thread * thrd) {
-    $thread * exp = 0p;
+static inline bool $try_lock(fast_lock & this, thread$ * thrd) {
+    thread$ * exp = 0p;
     return __atomic_compare_exchange_n(&this.owner, &exp, thrd, false, __ATOMIC_SEQ_CST, __ATOMIC_RELAXED);
 }
@@ -186,5 +186,5 @@
 static inline void lock( fast_lock & this ) __attribute__((artificial));
 static inline void lock( fast_lock & this ) {
-	$thread * thrd = active_thread();
+	thread$ * thrd = active_thread();
 	/* paranoid */verify(thrd != this.owner);
 
@@ -197,11 +197,11 @@
 static inline bool try_lock( fast_lock & this ) __attribute__((artificial));
 static inline bool try_lock ( fast_lock & this ) {
-	$thread * thrd = active_thread();
+	thread$ * thrd = active_thread();
 	/* paranoid */ verify(thrd != this.owner);
 	return $try_lock(this, thrd);
 }
 
-static inline $thread * unlock( fast_lock & this ) __attribute__((artificial));
-static inline $thread * unlock( fast_lock & this ) {
+static inline thread$ * unlock( fast_lock & this ) __attribute__((artificial));
+static inline thread$ * unlock( fast_lock & this ) {
 	/* paranoid */ verify(active_thread() == this.owner);
 
@@ -216,5 +216,5 @@
 static inline size_t on_wait( fast_lock & this ) { unlock(this); return 0; }
 static inline void on_wakeup( fast_lock & this, size_t ) { lock(this); }
-static inline void on_notify( fast_lock &, struct $thread * t ) { unpark(t); }
+static inline void on_notify( fast_lock &, struct thread$ * t ) { unpark(t); }
 
 struct mcs_node {
@@ -248,8 +248,8 @@
 
 	// Current thread owning the lock
-	struct $thread * owner;
+	struct thread$ * owner;
 
 	// List of blocked threads
-	dlist( $thread ) blocked_threads;
+	dlist( thread$ ) blocked_threads;
 
 	// Used for comparing and exchanging
@@ -343,5 +343,5 @@
 	// block until signalled
 	while (block(this)) if(try_lock_contention(this)) return true;
-	
+
 	// this should never be reached as block(this) always returns true
 	return false;
@@ -385,5 +385,5 @@
 	// block until signalled
 	while (block(this)) if(try_lock_contention(this)) return true;
-	
+
 	// this should never be reached as block(this) always returns true
 	return false;
@@ -395,10 +395,10 @@
     if (__atomic_exchange_n(&lock_value, 0, __ATOMIC_RELEASE) == 1) return;
 	lock( spinlock __cfaabi_dbg_ctx2 );
-	$thread * t = &try_pop_front( blocked_threads );
+	thread$ * t = &try_pop_front( blocked_threads );
 	unlock( spinlock );
 	unpark( t );
 }
 
-static inline void on_notify(linear_backoff_then_block_lock & this, struct $thread * t ) { unpark(t); }
+static inline void on_notify(linear_backoff_then_block_lock & this, struct thread$ * t ) { unpark(t); }
 static inline size_t on_wait(linear_backoff_then_block_lock & this) { unlock(this); return 0; }
 static inline void on_wakeup(linear_backoff_then_block_lock & this, size_t recursion ) { lock_improved(this); }
@@ -408,5 +408,5 @@
 trait is_blocking_lock(L & | sized(L)) {
 	// For synchronization locks to use when acquiring
-	void on_notify( L &, struct $thread * );
+	void on_notify( L &, struct thread$ * );
 
 	// For synchronization locks to use when releasing
@@ -442,5 +442,5 @@
 		int count;
 	};
-	
+
 
 	void  ?{}( condition_variable(L) & this );
