Changeset e84ab3d

Timestamp:

Jul 5, 2021, 4:44:20 PM (2 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

7f62b708

Parents:

ee23a8d

Message:

Step 1 of changing $thread to thread$

Files:

• libcfa/prelude/builtins.c (modified) (1 diff)
• libcfa/src/bits/weakso_locks.cfa (modified) (1 diff)
• libcfa/src/bits/weakso_locks.hfa (modified) (5 diffs)
• libcfa/src/concurrency/alarm.cfa (modified) (1 diff)
• libcfa/src/concurrency/alarm.hfa (modified) (3 diffs)
• libcfa/src/concurrency/clib/cfathread.cfa (modified) (6 diffs)
• libcfa/src/concurrency/coroutine.cfa (modified) (7 diffs)
• libcfa/src/concurrency/coroutine.hfa (modified) (10 diffs)
• libcfa/src/concurrency/exception.cfa (modified) (3 diffs)
• libcfa/src/concurrency/invoke.c (modified) (4 diffs)
• libcfa/src/concurrency/invoke.h (modified) (11 diffs)
• libcfa/src/concurrency/io.cfa (modified) (1 diff)
• libcfa/src/concurrency/io/types.hfa (modified) (1 diff)
• libcfa/src/concurrency/kernel.cfa (modified) (19 diffs)
• libcfa/src/concurrency/kernel.hfa (modified) (2 diffs)
• libcfa/src/concurrency/kernel/fwd.hfa (modified) (11 diffs)
• libcfa/src/concurrency/kernel/startup.cfa (modified) (13 diffs)
• libcfa/src/concurrency/kernel_private.hfa (modified) (7 diffs)
• libcfa/src/concurrency/locks.cfa (modified) (7 diffs)
• libcfa/src/concurrency/locks.hfa (modified) (18 diffs)
• libcfa/src/concurrency/monitor.cfa (modified) (43 diffs)
• libcfa/src/concurrency/monitor.hfa (modified) (6 diffs)
• libcfa/src/concurrency/mutex.cfa (modified) (1 diff)
• libcfa/src/concurrency/mutex.hfa (modified) (3 diffs)
• libcfa/src/concurrency/preemption.cfa (modified) (2 diffs)
• libcfa/src/concurrency/ready_queue.cfa (modified) (21 diffs)
• libcfa/src/concurrency/ready_subqueue.hfa (modified) (6 diffs)
• libcfa/src/concurrency/thread.cfa (modified) (4 diffs)
• libcfa/src/concurrency/thread.hfa (modified) (4 diffs)
• src/Concurrency/Keywords.cc (modified) (14 diffs)

libcfa/prelude/builtins.c

@@ -57 +57 @@
 
 // generator support
-struct $generator {
+struct generator$ {
         inline int;
 };
 
-static inline void  ?{}($generator & this) { ((int&)this) = 0; }
-static inline void ^?{}($generator &) {}
+static inline void  ?{}(generator$ & this) { ((int&)this) = 0; }
+static inline void ^?{}(generator$ &) {}
 
 trait is_generator(T &) {
       void main(T & this);
-      $generator * get_generator(T & this);
+      generator$ * get_generator(T & this);
 };
 

libcfa/src/bits/weakso_locks.cfa

@@ -24 +24 @@
 bool try_lock( blocking_lock & ) { return false; }
 void unlock( blocking_lock & ) {}
-void on_notify( blocking_lock &, struct $thread * ) {}
+void on_notify( blocking_lock &, struct thread$ * ) {}
 size_t on_wait( blocking_lock & ) { return 0; }
 void on_wakeup( blocking_lock &, size_t ) {}

libcfa/src/bits/weakso_locks.hfa

@@ -23 +23 @@
 #include "containers/list.hfa"
 
-struct $thread;
+struct thread$;
 
 //-----------------------------------------------------------------------------
@@ -32 +32 @@
 
         // List of blocked threads
-        dlist( $thread ) blocked_threads;
+        dlist( thread$ ) blocked_threads;
 
         // Count of current blocked threads
@@ -44 +44 @@
 
         // Current thread owning the lock
-        struct $thread * owner;
+        struct thread$ * owner;
 
         // Number of recursion level
@@ -56 +56 @@
 bool try_lock( blocking_lock & this ) OPTIONAL_THREAD;
 void unlock( blocking_lock & this ) OPTIONAL_THREAD;
-void on_notify( blocking_lock & this, struct $thread * t ) OPTIONAL_THREAD;
+void on_notify( blocking_lock & this, struct thread$ * t ) OPTIONAL_THREAD;
 size_t on_wait( blocking_lock & this ) OPTIONAL_THREAD;
 void on_wakeup( blocking_lock & this, size_t ) OPTIONAL_THREAD;
@@ -74 +74 @@
 static inline size_t on_wait  ( multiple_acquisition_lock & this ) { return on_wait ( (blocking_lock &)this ); }
 static inline void   on_wakeup( multiple_acquisition_lock & this, size_t v ) { on_wakeup ( (blocking_lock &)this, v ); }
-static inline void   on_notify( multiple_acquisition_lock & this, struct $thread * t ){ on_notify( (blocking_lock &)this, t ); }
+static inline void   on_notify( multiple_acquisition_lock & this, struct thread$ * t ){ on_notify( (blocking_lock &)this, t ); }

libcfa/src/concurrency/alarm.cfa

@@ -51 +51 @@
 //=============================================================================================
 
-void ?{}( alarm_node_t & this, $thread * thrd, Duration alarm, Duration period) with( this ) {
+void ?{}( alarm_node_t & this, thread$ * thrd, Duration alarm, Duration period) with( this ) {
         this.initial = alarm;
         this.period  = period;

libcfa/src/concurrency/alarm.hfa

@@ -25 +25 @@
 #include "containers/list.hfa"
 
-struct $thread;
+struct thread$;
 struct processor;
 
@@ -52 +52 @@
 
         union {
-                $thread * thrd;                 // thrd who created event
+                thread$ * thrd;                 // thrd who created event
                 processor * proc;                       // proc who created event
                 Alarm_Callback callback;        // callback to handle event
@@ -63 +63 @@
 P9_EMBEDDED( alarm_node_t, dlink(alarm_node_t) )
 
-void ?{}( alarm_node_t & this, $thread * thrd, Duration alarm, Duration period );
+void ?{}( alarm_node_t & this, thread$ * thrd, Duration alarm, Duration period );
 void ?{}( alarm_node_t & this, processor * proc, Duration alarm, Duration period );
 void ?{}( alarm_node_t & this, Alarm_Callback callback, Duration alarm, Duration period );

libcfa/src/concurrency/clib/cfathread.cfa

@@ -23 +23 @@
 #include "cfathread.h"
 
-extern void ?{}(processor &, const char[], cluster &, $thread *);
+extern void ?{}(processor &, const char[], cluster &, thread$ *);
 extern "C" {
       extern void __cfactx_invoke_thread(void (*main)(void *), void * this);
@@ -34 +34 @@
 
 struct cfathread_object {
-        $thread self;
+        thread$ self;
         void * (*themain)( void * );
         void * arg;
@@ -42 +42 @@
 void ^?{}(cfathread_object & mutex this);
 
-static inline $thread * get_thread( cfathread_object & this ) { return &this.self; }
+static inline thread$ * get_thread( cfathread_object & this ) { return &this.self; }
 
 typedef ThreadCancelled(cfathread_object) cfathread_exception;
@@ -81 +81 @@
 // Special Init Thread responsible for the initialization or processors
 struct __cfainit {
-        $thread self;
+        thread$ self;
         void (*init)( void * );
         void * arg;
@@ -88 +88 @@
 void ^?{}(__cfainit & mutex this);
 
-static inline $thread * get_thread( __cfainit & this ) { return &this.self; }
+static inline thread$ * get_thread( __cfainit & this ) { return &this.self; }
 
 typedef ThreadCancelled(__cfainit) __cfainit_exception;
@@ -109 +109 @@
 
         // Don't use __thrd_start! just prep the context manually
-        $thread * this_thrd = get_thread(this);
+        thread$ * this_thrd = get_thread(this);
         void (*main_p)(__cfainit &) = main;
 

libcfa/src/concurrency/coroutine.cfa

@@ -37 +37 @@
 
 extern "C" {
-        void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct $coroutine *) __attribute__ ((__noreturn__));
+        void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine$ *) __attribute__ ((__noreturn__));
         static void _CtxCoroutine_UnwindCleanup(_Unwind_Reason_Code, struct _Unwind_Exception *) __attribute__ ((__noreturn__));
         static void _CtxCoroutine_UnwindCleanup(_Unwind_Reason_Code, struct _Unwind_Exception *) {
@@ -62 +62 @@
 forall(T & | is_coroutine(T))
 void __cfaehm_cancelled_coroutine(
-                T & cor, $coroutine * desc, EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)) ) {
+                T & cor, coroutine$ * desc, EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)) ) {
         verify( desc->cancellation );
         desc->state = Cancelled;
@@ -114 +114 @@
 }
 
-void ?{}( $coroutine & this, const char name[], void * storage, size_t storageSize ) with( this ) {
+void ?{}( coroutine$ & this, const char name[], void * storage, size_t storageSize ) with( this ) {
         (this.context){0p, 0p};
         (this.stack){storage, storageSize};
@@ -124 +124 @@
 }
 
-void ^?{}($coroutine& this) {
+void ^?{}(coroutine$& this) {
         if(this.state != Halted && this.state != Start && this.state != Primed) {
-                $coroutine * src = active_coroutine();
-                $coroutine * dst = &this;
+                coroutine$ * src = active_coroutine();
+                coroutine$ * dst = &this;
 
                 struct _Unwind_Exception storage;
@@ -148 +148 @@
 forall(T & | is_coroutine(T) | { EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)); })
 void prime(T& cor) {
-        $coroutine* this = get_coroutine(cor);
+        coroutine$* this = get_coroutine(cor);
         assert(this->state == Start);
 
@@ -248 +248 @@
 // is not inline (We can't inline Cforall in C)
 extern "C" {
-        void __cfactx_cor_leave( struct $coroutine * src ) {
-                $coroutine * starter = src->cancellation != 0 ? src->last : src->starter;
+        void __cfactx_cor_leave( struct coroutine$ * src ) {
+                coroutine$ * starter = src->cancellation != 0 ? src->last : src->starter;
 
                 src->state = Halted;
@@ -265 +265 @@
         }
 
-        struct $coroutine * __cfactx_cor_finish(void) {
-                struct $coroutine * cor = active_coroutine();
+        struct coroutine$ * __cfactx_cor_finish(void) {
+                struct coroutine$ * cor = active_coroutine();
 
                 // get the active thread once
-                $thread * athrd = active_thread();
+                thread$ * athrd = active_thread();
 
                 /* paranoid */ verify( athrd->corctx_flag );

libcfa/src/concurrency/coroutine.hfa

@@ -39 +39 @@
 trait is_coroutine(T & | IS_RESUMPTION_EXCEPTION(CoroutineCancelled, (T))) {
         void main(T & this);
-        $coroutine * get_coroutine(T & this);
+        coroutine$ * get_coroutine(T & this);
 };
 
-#define DECL_COROUTINE(X) static inline $coroutine* get_coroutine(X& this) { return &this.__cor; } void main(X& this)
+#define DECL_COROUTINE(X) static inline coroutine$* get_coroutine(X& this) { return &this.__cor; } void main(X& this)
 
 //-----------------------------------------------------------------------------
@@ -49 +49 @@
 // void ^?{}( coStack_t & this );
 
-void  ?{}( $coroutine & this, const char name[], void * storage, size_t storageSize );
-void ^?{}( $coroutine & this );
-
-static inline void ?{}( $coroutine & this)                                       { this{ "Anonymous Coroutine", 0p, 0 }; }
-static inline void ?{}( $coroutine & this, size_t stackSize)                     { this{ "Anonymous Coroutine", 0p, stackSize }; }
-static inline void ?{}( $coroutine & this, void * storage, size_t storageSize )  { this{ "Anonymous Coroutine", storage, storageSize }; }
-static inline void ?{}( $coroutine & this, const char name[])                    { this{ name, 0p, 0 }; }
-static inline void ?{}( $coroutine & this, const char name[], size_t stackSize ) { this{ name, 0p, stackSize }; }
+void  ?{}( coroutine$ & this, const char name[], void * storage, size_t storageSize );
+void ^?{}( coroutine$ & this );
+
+static inline void ?{}( coroutine$ & this)                                       { this{ "Anonymous Coroutine", 0p, 0 }; }
+static inline void ?{}( coroutine$ & this, size_t stackSize)                     { this{ "Anonymous Coroutine", 0p, stackSize }; }
+static inline void ?{}( coroutine$ & this, void * storage, size_t storageSize )  { this{ "Anonymous Coroutine", storage, storageSize }; }
+static inline void ?{}( coroutine$ & this, const char name[])                    { this{ name, 0p, 0 }; }
+static inline void ?{}( coroutine$ & this, const char name[], size_t stackSize ) { this{ name, 0p, stackSize }; }
 
 //-----------------------------------------------------------------------------
@@ -63 +63 @@
 void prime(T & cor);
 
-static inline struct $coroutine * active_coroutine() { return active_thread()->curr_cor; }
+static inline struct coroutine$ * active_coroutine() { return active_thread()->curr_cor; }
 
 //-----------------------------------------------------------------------------
@@ -73 +73 @@
 
         forall(T &)
-        void __cfactx_start(void (*main)(T &), struct $coroutine * cor, T & this, void (*invoke)(void (*main)(void *), void *));
-
-        extern void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct $coroutine *) __attribute__ ((__noreturn__));
+        void __cfactx_start(void (*main)(T &), struct coroutine$ * cor, T & this, void (*invoke)(void (*main)(void *), void *));
+
+        extern void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct coroutine$ *) __attribute__ ((__noreturn__));
 
         extern void __cfactx_switch( struct __stack_context_t * from, struct __stack_context_t * to ) asm ("__cfactx_switch");
@@ -82 +82 @@
 // Private wrappers for context switch and stack creation
 // Wrapper for co
-static inline void $ctx_switch( $coroutine * src, $coroutine * dst ) __attribute__((nonnull (1, 2))) {
+static inline void $ctx_switch( coroutine$ * src, coroutine$ * dst ) __attribute__((nonnull (1, 2))) {
         // set state of current coroutine to inactive
         src->state = src->state == Halted ? Halted : Blocked;
 
         // get the active thread once
-        $thread * athrd = active_thread();
+        thread$ * athrd = active_thread();
 
         // Mark the coroutine
@@ -124 +124 @@
                 // will also migrate which means this value will
                 // stay in syn with the TLS
-                $coroutine * src = active_coroutine();
+                coroutine$ * src = active_coroutine();
 
                 assertf( src->last != 0,
@@ -141 +141 @@
 forall(T & | is_coroutine(T))
 void __cfaehm_cancelled_coroutine(
-        T & cor, $coroutine * desc, EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)) );
+        T & cor, coroutine$ * desc, EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)) );
 
 // Resume implementation inlined for performance
@@ -151 +151 @@
         // will also migrate which means this value will
         // stay in syn with the TLS
-        $coroutine * src = active_coroutine();
-        $coroutine * dst = get_coroutine(cor);
+        coroutine$ * src = active_coroutine();
+        coroutine$ * dst = get_coroutine(cor);
 
         if( unlikely(dst->context.SP == 0p) ) {
@@ -180 +180 @@
 }
 
-static inline void resume( $coroutine * dst ) __attribute__((nonnull (1))) {
+static inline void resume( coroutine$ * dst ) __attribute__((nonnull (1))) {
         // optimization : read TLS once and reuse it
         // Safety note: this is preemption safe since if
@@ -186 +186 @@
         // will also migrate which means this value will
         // stay in syn with the TLS
-        $coroutine * src = active_coroutine();
+        coroutine$ * src = active_coroutine();
 
         // not resuming self ?

libcfa/src/concurrency/exception.cfa

@@ -20 +20 @@
 #include "coroutine.hfa"
 
-extern struct $thread * mainThread;
+extern struct thread$ * mainThread;
 extern "C" {
 extern void __cfactx_thrd_leave();
@@ -55 +55 @@
 
 STOP_AT_END_FUNCTION(coroutine_cancelstop,
-        struct $coroutine * src = ($coroutine *)stop_param;
-        struct $coroutine * dst = src->last;
+        struct coroutine$ * src = (coroutine$ *)stop_param;
+        struct coroutine$ * dst = src->last;
 
         $ctx_switch( src, dst );
@@ -72 +72 @@
         void * stop_param;
 
-        struct $thread * this_thread = active_thread();
+        struct thread$ * this_thread = active_thread();
         if ( &this_thread->self_cor != this_thread->curr_cor ) {
-                struct $coroutine * cor = this_thread->curr_cor;
+                struct coroutine$ * cor = this_thread->curr_cor;
                 cor->cancellation = unwind_exception;
 

libcfa/src/concurrency/invoke.c

@@ -29 +29 @@
 // Called from the kernel when starting a coroutine or task so must switch back to user mode.
 
-extern struct $coroutine * __cfactx_cor_finish(void);
-extern void __cfactx_cor_leave ( struct $coroutine * );
+extern struct coroutine$ * __cfactx_cor_finish(void);
+extern void __cfactx_cor_leave ( struct coroutine$ * );
 extern void __cfactx_thrd_leave();
 
@@ -41 +41 @@
 ) {
         // Finish setting up the coroutine by setting its state
-        struct $coroutine * cor = __cfactx_cor_finish();
+        struct coroutine$ * cor = __cfactx_cor_finish();
 
         // Call the main of the coroutine
@@ -70 +70 @@
 }
 
-void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct $coroutine * cor) __attribute__ ((__noreturn__));
-void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct $coroutine * cor) {
+void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct coroutine$ * cor) __attribute__ ((__noreturn__));
+void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct coroutine$ * cor) {
         _Unwind_Reason_Code ret = _Unwind_ForcedUnwind( storage, __cfactx_coroutine_unwindstop, cor );
         printf("UNWIND ERROR %d after force unwind\n", ret);
@@ -100 +100 @@
 void __cfactx_start(
         void (*main)(void *),
-        struct $coroutine * cor,
+        struct coroutine$ * cor,
         void *this,
         void (*invoke)(void *)

libcfa/src/concurrency/invoke.h

@@ -71 +71 @@
         enum __Coroutine_State { Halted, Start, Primed, Blocked, Ready, Active, Cancelled, Halting };
 
-        struct $coroutine {
+        struct coroutine$ {
                 // context that is switch during a __cfactx_switch
                 struct __stack_context_t context;
@@ -85 +85 @@
 
                 // first coroutine to resume this one
-                struct $coroutine * starter;
+                struct coroutine$ * starter;
 
                 // last coroutine to resume this one
-                struct $coroutine * last;
+                struct coroutine$ * last;
 
                 // If non-null stack must be unwound with this exception
@@ -95 +95 @@
         };
         // Wrapper for gdb
-        struct cfathread_coroutine_t { struct $coroutine debug; };
-
-        static inline struct __stack_t * __get_stack( struct $coroutine * cor ) {
+        struct cfathread_coroutine_t { struct coroutine$ debug; };
+
+        static inline struct __stack_t * __get_stack( struct coroutine$ * cor ) {
                 return (struct __stack_t*)(((uintptr_t)cor->stack.storage) & ((uintptr_t)-2));
         }
@@ -110 +110 @@
         };
 
-        struct $monitor {
+        struct monitor$ {
                 // spinlock to protect internal data
                 struct __spinlock_t lock;
 
                 // current owner of the monitor
-                struct $thread * owner;
+                struct thread$ * owner;
 
                 // queue of threads that are blocked waiting for the monitor
-                __queue_t(struct $thread) entry_queue;
+                __queue_t(struct thread$) entry_queue;
 
                 // stack of conditions to run next once we exit the monitor
@@ -133 +133 @@
         };
         // Wrapper for gdb
-        struct cfathread_monitor_t { struct $monitor debug; };
+        struct cfathread_monitor_t { struct monitor$ debug; };
 
         struct __monitor_group_t {
                 // currently held monitors
-                __cfa_anonymous_object( __small_array_t($monitor*) );
+                __cfa_anonymous_object( __small_array_t(monitor$*) );
 
                 // last function that acquired monitors
@@ -146 +146 @@
         // instrusive link field for threads
         struct __thread_desc_link {
-                struct $thread * next;
+                struct thread$ * next;
                 volatile unsigned long long ts;
         };
 
-        struct $thread {
+        struct thread$ {
                 // Core threading fields
                 // context that is switch during a __cfactx_switch
@@ -179 +179 @@
 
                 // coroutine body used to store context
-                struct $coroutine  self_cor;
+                struct coroutine$  self_cor;
 
                 // current active context
-                struct $coroutine * curr_cor;
+                struct coroutine$ * curr_cor;
 
                 // monitor body used for mutual exclusion
-                struct $monitor    self_mon;
+                struct monitor$    self_mon;
 
                 // pointer to monitor with sufficient lifetime for current monitors
-                struct $monitor *  self_mon_p;
+                struct monitor$ *  self_mon_p;
 
                 // monitors currently held by this thread
@@ -195 +195 @@
                 // used to put threads on user data structures
                 struct {
-                        struct $thread * next;
-                        struct $thread * back;
+                        struct thread$ * next;
+                        struct thread$ * back;
                 } seqable;
 
                 // used to put threads on dlist data structure
-                __cfa_dlink($thread);
+                __cfa_dlink(thread$);
 
                 struct {
-                        struct $thread * next;
-                        struct $thread * prev;
+                        struct thread$ * next;
+                        struct thread$ * prev;
                 } node;
 
@@ -214 +214 @@
         };
         #ifdef __cforall
-                P9_EMBEDDED( $thread, dlink($thread) )
+                P9_EMBEDDED( thread$, dlink(thread$) )
         #endif
         // Wrapper for gdb
-        struct cfathread_thread_t { struct $thread debug; };
+        struct cfathread_thread_t { struct thread$ debug; };
 
         #ifdef __CFA_DEBUG__
-                void __cfaabi_dbg_record_thrd($thread & this, bool park, const char prev_name[]);
+                void __cfaabi_dbg_record_thrd(thread$ & this, bool park, const char prev_name[]);
         #else
                 #define __cfaabi_dbg_record_thrd(x, y, z)
@@ -228 +228 @@
         extern "Cforall" {
 
-                static inline $thread *& get_next( $thread & this ) __attribute__((const)) {
+                static inline thread$ *& get_next( thread$ & this ) __attribute__((const)) {
                         return this.link.next;
                 }
 
-                static inline [$thread *&, $thread *& ] __get( $thread & this ) __attribute__((const)) {
+                static inline [thread$ *&, thread$ *& ] __get( thread$ & this ) __attribute__((const)) {
                         return this.node.[next, prev];
                 }
 
-                static inline $thread * volatile & ?`next ( $thread * this )  __attribute__((const)) {
+                static inline thread$ * volatile & ?`next ( thread$ * this )  __attribute__((const)) {
                         return this->seqable.next;
                 }
 
-                static inline $thread *& Back( $thread * this ) __attribute__((const)) {
+                static inline thread$ *& Back( thread$ * this ) __attribute__((const)) {
                         return this->seqable.back;
                 }
 
-                static inline $thread *& Next( $thread * this ) __attribute__((const)) {
+                static inline thread$ *& Next( thread$ * this ) __attribute__((const)) {
                                 return this->seqable.next;
                 }
 
-                static inline bool listed( $thread * this ) {
+                static inline bool listed( thread$ * this ) {
                         return this->seqable.next != 0p;
                 }
@@ -258 +258 @@
                 }
 
-                static inline void ?{}(__monitor_group_t & this, struct $monitor ** data, __lock_size_t size, fptr_t func) {
+                static inline void ?{}(__monitor_group_t & this, struct monitor$ ** data, __lock_size_t size, fptr_t func) {
                         (this.data){data};
                         (this.size){size};

libcfa/src/concurrency/io.cfa

@@ -90 +90 @@
         static inline unsigned __flush( struct $io_context & );
         static inline __u32 __release_sqes( struct $io_context & );
-        extern void __kernel_unpark( $thread * thrd );
+        extern void __kernel_unpark( thread$ * thrd );
 
         bool __cfa_io_drain( processor * proc ) {

libcfa/src/concurrency/io/types.hfa

@@ -179 +179 @@
 
 static inline {
-        $thread * fulfil( io_future_t & this, __s32 result, bool do_unpark = true ) {
+        thread$ * fulfil( io_future_t & this, __s32 result, bool do_unpark = true ) {
                 this.result = result;
                 return fulfil(this.self, do_unpark);

libcfa/src/concurrency/kernel.cfa

@@ -110 +110 @@
 #endif
 
-extern $thread * mainThread;
+extern thread$ * mainThread;
 extern processor * mainProcessor;
 
 //-----------------------------------------------------------------------------
 // Kernel Scheduling logic
-static $thread * __next_thread(cluster * this);
-static $thread * __next_thread_slow(cluster * this);
-static inline bool __must_unpark( $thread * thrd ) __attribute((nonnull(1)));
-static void __run_thread(processor * this, $thread * dst);
+static thread$ * __next_thread(cluster * this);
+static thread$ * __next_thread_slow(cluster * this);
+static inline bool __must_unpark( thread$ * thrd ) __attribute((nonnull(1)));
+static void __run_thread(processor * this, thread$ * dst);
 static void __wake_one(cluster * cltr);
 
@@ -181 +181 @@
                 __cfadbg_print_safe(runtime_core, "Kernel : core %p started\n", this);
 
-                $thread * readyThread = 0p;
+                thread$ * readyThread = 0p;
                 MAIN_LOOP:
                 for() {
@@ -388 +388 @@
 // runThread runs a thread by context switching
 // from the processor coroutine to the target thread
-static void __run_thread(processor * this, $thread * thrd_dst) {
+static void __run_thread(processor * this, thread$ * thrd_dst) {
         /* paranoid */ verify( ! __preemption_enabled() );
         /* paranoid */ verifyf( thrd_dst->state == Ready || thrd_dst->preempted != __NO_PREEMPTION, "state : %d, preempted %d\n", thrd_dst->state, thrd_dst->preempted);
@@ -396 +396 @@
         __cfadbg_print_safe(runtime_core, "Kernel : core %p running thread %p (%s)\n", this, thrd_dst, thrd_dst->self_cor.name);
 
-        $coroutine * proc_cor = get_coroutine(this->runner);
+        coroutine$ * proc_cor = get_coroutine(this->runner);
 
         // set state of processor coroutine to inactive
@@ -415 +415 @@
                 /* paranoid */ verify( thrd_dst->context.SP );
                 /* paranoid */ verify( thrd_dst->state != Halted );
-                /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ) || thrd_dst->curr_cor == proc_cor || thrd_dst->corctx_flag, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too small.\n", thrd_dst ); // add escape condition if we are setting up the processor
-                /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit) || thrd_dst->curr_cor == proc_cor || thrd_dst->corctx_flag, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too large.\n", thrd_dst ); // add escape condition if we are setting up the processor
+                /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ) || thrd_dst->curr_cor == proc_cor || thrd_dst->corctx_flag, "ERROR : Destination thread$ %p has been corrupted.\n StackPointer too small.\n", thrd_dst ); // add escape condition if we are setting up the processor
+                /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit) || thrd_dst->curr_cor == proc_cor || thrd_dst->corctx_flag, "ERROR : Destination thread$ %p has been corrupted.\n StackPointer too large.\n", thrd_dst ); // add escape condition if we are setting up the processor
                 /* paranoid */ verify( 0x0D15EA5E0D15EA5Ep == thrd_dst->canary );
 
@@ -428 +428 @@
 
                 /* paranoid */ verify( 0x0D15EA5E0D15EA5Ep == thrd_dst->canary );
-                /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit) || thrd_dst->corctx_flag, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too large.\n", thrd_dst );
-                /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ) || thrd_dst->corctx_flag, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too small.\n", thrd_dst );
+                /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit) || thrd_dst->corctx_flag, "ERROR : Destination thread$ %p has been corrupted.\n StackPointer too large.\n", thrd_dst );
+                /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ) || thrd_dst->corctx_flag, "ERROR : Destination thread$ %p has been corrupted.\n StackPointer too small.\n", thrd_dst );
                 /* paranoid */ verify( thrd_dst->context.SP );
                 /* paranoid */ verify( thrd_dst->curr_cluster == this->cltr );
@@ -497 +497 @@
 void returnToKernel() {
         /* paranoid */ verify( ! __preemption_enabled() );
-        $coroutine * proc_cor = get_coroutine(kernelTLS().this_processor->runner);
-        $thread * thrd_src = kernelTLS().this_thread;
+        coroutine$ * proc_cor = get_coroutine(kernelTLS().this_processor->runner);
+        thread$ * thrd_src = kernelTLS().this_thread;
 
         __STATS( thrd_src->last_proc = kernelTLS().this_processor; )
@@ -526 +526 @@
 
         /* paranoid */ verify( ! __preemption_enabled() );
-        /* paranoid */ verifyf( ((uintptr_t)thrd_src->context.SP) < ((uintptr_t)__get_stack(thrd_src->curr_cor)->base ) || thrd_src->corctx_flag, "ERROR : Returning $thread %p has been corrupted.\n StackPointer too small.\n", thrd_src );
-        /* paranoid */ verifyf( ((uintptr_t)thrd_src->context.SP) > ((uintptr_t)__get_stack(thrd_src->curr_cor)->limit) || thrd_src->corctx_flag, "ERROR : Returning $thread %p has been corrupted.\n StackPointer too large.\n", thrd_src );
+        /* paranoid */ verifyf( ((uintptr_t)thrd_src->context.SP) < ((uintptr_t)__get_stack(thrd_src->curr_cor)->base ) || thrd_src->corctx_flag, "ERROR : Returning thread$ %p has been corrupted.\n StackPointer too small.\n", thrd_src );
+        /* paranoid */ verifyf( ((uintptr_t)thrd_src->context.SP) > ((uintptr_t)__get_stack(thrd_src->curr_cor)->limit) || thrd_src->corctx_flag, "ERROR : Returning thread$ %p has been corrupted.\n StackPointer too large.\n", thrd_src );
 }
 
@@ -533 +533 @@
 // Scheduler routines
 // KERNEL ONLY
-static void __schedule_thread( $thread * thrd ) {
+static void __schedule_thread( thread$ * thrd ) {
         /* paranoid */ verify( ! __preemption_enabled() );
         /* paranoid */ verify( ready_schedule_islocked());
@@ -583 +583 @@
 }
 
-void schedule_thread$( $thread * thrd ) {
+void schedule_thread$( thread$ * thrd ) {
         ready_schedule_lock();
                 __schedule_thread( thrd );
@@ -590 +590 @@
 
 // KERNEL ONLY
-static inline $thread * __next_thread(cluster * this) with( *this ) {
+static inline thread$ * __next_thread(cluster * this) with( *this ) {
         /* paranoid */ verify( ! __preemption_enabled() );
 
         ready_schedule_lock();
-                $thread * thrd = pop_fast( this );
+                thread$ * thrd = pop_fast( this );
         ready_schedule_unlock();
 
@@ -602 +602 @@
 
 // KERNEL ONLY
-static inline $thread * __next_thread_slow(cluster * this) with( *this ) {
+static inline thread$ * __next_thread_slow(cluster * this) with( *this ) {
         /* paranoid */ verify( ! __preemption_enabled() );
 
         ready_schedule_lock();
-                $thread * thrd;
+                thread$ * thrd;
                 for(25) {
                         thrd = pop_slow( this );
@@ -620 +620 @@
 }
 
-static inline bool __must_unpark( $thread * thrd ) {
+static inline bool __must_unpark( thread$ * thrd ) {
         int old_ticket = __atomic_fetch_add(&thrd->ticket, 1, __ATOMIC_SEQ_CST);
         switch(old_ticket) {
@@ -636 +636 @@
 }
 
-void __kernel_unpark( $thread * thrd ) {
+void __kernel_unpark( thread$ * thrd ) {
         /* paranoid */ verify( ! __preemption_enabled() );
         /* paranoid */ verify( ready_schedule_islocked());
@@ -651 +651 @@
 }
 
-void unpark( $thread * thrd ) {
+void unpark( thread$ * thrd ) {
         if( !thrd ) return;
 
@@ -675 +675 @@
         // Should never return
         void __cfactx_thrd_leave() {
-                $thread * thrd = active_thread();
-                $monitor * this = &thrd->self_mon;
+                thread$ * thrd = active_thread();
+                monitor$ * this = &thrd->self_mon;
 
                 // Lock the monitor now
@@ -688 +688 @@
                 /* paranoid */ verify( kernelTLS().this_thread == thrd );
                 /* paranoid */ verify( thrd->context.SP );
-                /* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) > ((uintptr_t)__get_stack(thrd->curr_cor)->limit), "ERROR : $thread %p has been corrupted.\n StackPointer too large.\n", thrd );
-                /* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) < ((uintptr_t)__get_stack(thrd->curr_cor)->base ), "ERROR : $thread %p has been corrupted.\n StackPointer too small.\n", thrd );
+                /* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) > ((uintptr_t)__get_stack(thrd->curr_cor)->limit), "ERROR : thread$ %p has been corrupted.\n StackPointer too large.\n", thrd );
+                /* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) < ((uintptr_t)__get_stack(thrd->curr_cor)->base ), "ERROR : thread$ %p has been corrupted.\n StackPointer too small.\n", thrd );
 
                 thrd->state = Halting;
@@ -707 +707 @@
 bool force_yield( __Preemption_Reason reason ) {
         __disable_interrupts_checked();
-                $thread * thrd = kernelTLS().this_thread;
+                thread$ * thrd = kernelTLS().this_thread;
                 /* paranoid */ verify(thrd->state == Active);
 
@@ -819 +819 @@
 //=============================================================================================
 void __kernel_abort_msg( char * abort_text, int abort_text_size ) {
-        $thread * thrd = __cfaabi_tls.this_thread;
+        thread$ * thrd = __cfaabi_tls.this_thread;
 
         if(thrd) {

libcfa/src/concurrency/kernel.hfa

@@ -115 +115 @@
         // it is not a particularly safe scheme as it can make processors less homogeneous
         struct {
-                $thread * thrd;
+                thread$ * thrd;
         } init;
 
@@ -215 +215 @@
         // List of threads
         __spinlock_t thread_list_lock;
-        __dllist_t(struct $thread) threads;
+        __dllist_t(struct thread$) threads;
         unsigned int nthreads;
 

libcfa/src/concurrency/kernel/fwd.hfa

@@ -24 +24 @@
 #endif
 
-struct $thread;
+struct thread$;
 struct processor;
 struct cluster;
@@ -36 +36 @@
         extern "Cforall" {
                 extern __attribute__((aligned(128))) thread_local struct KernelThreadData {
-                        struct $thread          * volatile this_thread;
+                        struct thread$          * volatile this_thread;
                         struct processor        * volatile this_processor;
                         volatile bool sched_lock;
@@ -120 +120 @@
         extern "Cforall" {
                 extern void park( void );
-                extern void unpark( struct $thread * this );
-                static inline struct $thread * active_thread () {
-                        struct $thread * t = publicTLS_get( this_thread );
+                extern void unpark( struct thread$ * this );
+                static inline struct thread$ * active_thread () {
+                        struct thread$ * t = publicTLS_get( this_thread );
                         /* paranoid */ verify( t );
                         return t;
@@ -144 +144 @@
                 // Semaphore which only supports a single thread
                 struct single_sem {
-                        struct $thread * volatile ptr;
+                        struct thread$ * volatile ptr;
                 };
 
@@ -156 +156 @@
                         bool wait(single_sem & this) {
                                 for() {
-                                        struct $thread * expected = this.ptr;
+                                        struct thread$ * expected = this.ptr;
                                         if(expected == 1p) {
                                                 if(__atomic_compare_exchange_n(&this.ptr, &expected, 0p, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
@@ -175 +175 @@
                         bool post(single_sem & this) {
                                 for() {
-                                        struct $thread * expected = this.ptr;
+                                        struct thread$ * expected = this.ptr;
                                         if(expected == 1p) return false;
                                         if(expected == 0p) {
@@ -200 +200 @@
                         //     1p     : fulfilled (wait won't block)
                         // any thread : a thread is currently waiting
-                        struct $thread * volatile ptr;
+                        struct thread$ * volatile ptr;
                 };
 
@@ -214 +214 @@
                         bool wait(oneshot & this) {
                                 for() {
-                                        struct $thread * expected = this.ptr;
+                                        struct thread$ * expected = this.ptr;
                                         if(expected == 1p) return false;
                                         /* paranoid */ verify( expected == 0p );
@@ -227 +227 @@
                         // Mark as fulfilled, wake thread if needed
                         // return true if a thread was unparked
-                        $thread * post(oneshot & this, bool do_unpark = true) {
-                                struct $thread * got = __atomic_exchange_n( &this.ptr, 1p, __ATOMIC_SEQ_CST);
+                        thread$ * post(oneshot & this, bool do_unpark = true) {
+                                struct thread$ * got = __atomic_exchange_n( &this.ptr, 1p, __ATOMIC_SEQ_CST);
                                 if( got == 0p ) return 0p;
                                 if(do_unpark) unpark( got );
@@ -343 +343 @@
                         // from the server side, mark the future as fulfilled
                         // delete it if needed
-                        $thread * fulfil( future_t & this, bool do_unpark = true  ) {
+                        thread$ * fulfil( future_t & this, bool do_unpark = true  ) {
                                 for() {
                                         struct oneshot * expected = this.ptr;
@@ -364 +364 @@
                                         if(__atomic_compare_exchange_n(&this.ptr, &expected, want, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
                                                 if( expected == 0p ) { /* paranoid */ verify( this.ptr == 1p); return 0p; }
-                                                $thread * ret = post( *expected, do_unpark );
+                                                thread$ * ret = post( *expected, do_unpark );
                                                 __atomic_store_n( &this.ptr, 1p, __ATOMIC_SEQ_CST);
                                                 return ret;

libcfa/src/concurrency/kernel/startup.cfa

@@ -77 +77 @@
 static void __kernel_first_resume( processor * this );
 static void __kernel_last_resume ( processor * this );
-static void init(processor & this, const char name[], cluster & _cltr, $thread * initT);
+static void init(processor & this, const char name[], cluster & _cltr, thread$ * initT);
 static void deinit(processor & this);
 static void doregister( struct cluster & cltr );
@@ -83 +83 @@
 static void register_tls( processor * this );
 static void unregister_tls( processor * this );
-static void ?{}( $coroutine & this, current_stack_info_t * info);
-static void ?{}( $thread & this, current_stack_info_t * info);
+static void ?{}( coroutine$ & this, current_stack_info_t * info);
+static void ?{}( thread$ & this, current_stack_info_t * info);
 static void ?{}(processorCtx_t & this) {}
 static void ?{}(processorCtx_t & this, processor * proc, current_stack_info_t * info);
@@ -105 +105 @@
 KERNEL_STORAGE(cluster,              mainCluster);
 KERNEL_STORAGE(processor,            mainProcessor);
-KERNEL_STORAGE($thread,              mainThread);
+KERNEL_STORAGE(thread$,              mainThread);
 KERNEL_STORAGE(__stack_t,            mainThreadCtx);
 KERNEL_STORAGE(__scheduler_RWLock_t, __scheduler_lock);
@@ -114 +114 @@
 cluster              * mainCluster;
 processor            * mainProcessor;
-$thread              * mainThread;
+thread$              * mainThread;
 __scheduler_RWLock_t * __scheduler_lock;
 
@@ -203 +203 @@
         // SKULLDUGGERY: the mainThread steals the process main thread
         // which will then be scheduled by the mainProcessor normally
-        mainThread = ($thread *)&storage_mainThread;
+        mainThread = (thread$ *)&storage_mainThread;
         current_stack_info_t info;
         info.storage = (__stack_t*)&storage_mainThreadCtx;
@@ -397 +397 @@
 
 static void __kernel_first_resume( processor * this ) {
-        $thread * src = mainThread;
-        $coroutine * dst = get_coroutine(this->runner);
+        thread$ * src = mainThread;
+        coroutine$ * dst = get_coroutine(this->runner);
 
         /* paranoid */ verify( ! __preemption_enabled() );
@@ -430 +430 @@
 // KERNEL_ONLY
 static void __kernel_last_resume( processor * this ) {
-        $coroutine * src = &mainThread->self_cor;
-        $coroutine * dst = get_coroutine(this->runner);
+        coroutine$ * src = &mainThread->self_cor;
+        coroutine$ * dst = get_coroutine(this->runner);
 
         /* paranoid */ verify( ! __preemption_enabled() );
@@ -459 +459 @@
 //-----------------------------------------------------------------------------
 // Main thread construction
-static void ?{}( $coroutine & this, current_stack_info_t * info) with( this ) {
+static void ?{}( coroutine$ & this, current_stack_info_t * info) with( this ) {
         stack.storage = info->storage;
         with(*stack.storage) {
@@ -474 +474 @@
 }
 
-static void ?{}( $thread & this, current_stack_info_t * info) with( this ) {
+static void ?{}( thread$ & this, current_stack_info_t * info) with( this ) {
         ticket = TICKET_RUNNING;
         state = Start;
@@ -506 +506 @@
 }
 
-static void init(processor & this, const char name[], cluster & _cltr, $thread * initT) with( this ) {
+static void init(processor & this, const char name[], cluster & _cltr, thread$ * initT) with( this ) {
         this.name = name;
         this.cltr = &_cltr;
@@ -545 +545 @@
 }
 
-void ?{}(processor & this, const char name[], cluster & _cltr, $thread * initT) {
+void ?{}(processor & this, const char name[], cluster & _cltr, thread$ * initT) {
         ( this.terminated ){};
         ( this.runner ){};
@@ -663 +663 @@
 }
 
-void doregister( cluster * cltr, $thread & thrd ) {
+void doregister( cluster * cltr, thread$ & thrd ) {
         lock      (cltr->thread_list_lock __cfaabi_dbg_ctx2);
         cltr->nthreads += 1;
@@ -670 +670 @@
 }
 
-void unregister( cluster * cltr, $thread & thrd ) {
+void unregister( cluster * cltr, thread$ & thrd ) {
         lock  (cltr->thread_list_lock __cfaabi_dbg_ctx2);
         remove(cltr->threads, thrd );

libcfa/src/concurrency/kernel_private.hfa

@@ -46 +46 @@
 }
 
-void schedule_thread$( $thread * ) __attribute__((nonnull (1)));
+void schedule_thread$( thread$ * ) __attribute__((nonnull (1)));
 
 extern bool __preemption_enabled();
 
 //release/wake-up the following resources
-void __thread_finish( $thread * thrd );
+void __thread_finish( thread$ * thrd );
 
 //-----------------------------------------------------------------------------
@@ -95 +95 @@
 
 __cfaabi_dbg_debug_do(
-        extern void __cfaabi_dbg_thread_register  ( $thread * thrd );
-        extern void __cfaabi_dbg_thread_unregister( $thread * thrd );
+        extern void __cfaabi_dbg_thread_register  ( thread$ * thrd );
+        extern void __cfaabi_dbg_thread_unregister( thread$ * thrd );
 )
 
@@ -105 +105 @@
 //-----------------------------------------------------------------------------
 // Utils
-void doregister( struct cluster * cltr, struct $thread & thrd );
-void unregister( struct cluster * cltr, struct $thread & thrd );
+void doregister( struct cluster * cltr, struct thread$ & thrd );
+void unregister( struct cluster * cltr, struct thread$ & thrd );
 
 //-----------------------------------------------------------------------------
@@ -300 +300 @@
 // push thread onto a ready queue for a cluster
 // returns true if the list was previously empty, false otherwise
-__attribute__((hot)) void push(struct cluster * cltr, struct $thread * thrd, bool local);
+__attribute__((hot)) void push(struct cluster * cltr, struct thread$ * thrd, bool local);
 
 //-----------------------------------------------------------------------
@@ -306 +306 @@
 // returns 0p if empty
 // May return 0p spuriously
-__attribute__((hot)) struct $thread * pop_fast(struct cluster * cltr);
+__attribute__((hot)) struct thread$ * pop_fast(struct cluster * cltr);
 
 //-----------------------------------------------------------------------
@@ -312 +312 @@
 // returns 0p if empty
 // May return 0p spuriously
-__attribute__((hot)) struct $thread * pop_slow(struct cluster * cltr);
+__attribute__((hot)) struct thread$ * pop_slow(struct cluster * cltr);
 
 //-----------------------------------------------------------------------
@@ -318 +318 @@
 // returns 0p if empty
 // guaranteed to find any threads added before this call
-__attribute__((hot)) struct $thread * pop_search(struct cluster * cltr);
+__attribute__((hot)) struct thread$ * pop_search(struct cluster * cltr);
 
 //-----------------------------------------------------------------------

libcfa/src/concurrency/locks.cfa

@@ -32 +32 @@
 
                 // waiting thread
-                struct $thread * t;
+                struct thread$ * t;
 
                 // shadow field
@@ -45 +45 @@
         P9_EMBEDDED( info_thread(L), dlink(info_thread(L)) )
 
-        void ?{}( info_thread(L) & this, $thread * t, uintptr_t info, L * l ) {
+        void ?{}( info_thread(L) & this, thread$ * t, uintptr_t info, L * l ) {
                 this.t = t;
                 this.info = info;
@@ -71 +71 @@
 void lock( blocking_lock & this ) with( this ) {
         lock( lock __cfaabi_dbg_ctx2 );
-        $thread * thrd = active_thread();
+        thread$ * thrd = active_thread();
 
         // single acquisition lock is held by current thread
@@ -117 +117 @@
 
 void pop_and_set_new_owner( blocking_lock & this ) with( this ) {
-        $thread * t = &try_pop_front( blocked_threads );
+        thread$ * t = &try_pop_front( blocked_threads );
         owner = t;
         recursion_count = ( t ? 1 : 0 );
@@ -142 +142 @@
 }
 
-void on_notify( blocking_lock & this, $thread * t ) with( this ) {
+void on_notify( blocking_lock & this, thread$ * t ) with( this ) {
         lock( lock __cfaabi_dbg_ctx2 );
         // lock held
@@ -366 +366 @@
 }
 
-$thread * V (semaphore & this, const bool doUnpark ) with( this ) {
-        $thread * thrd = 0p;
+thread$ * V (semaphore & this, const bool doUnpark ) with( this ) {
+        thread$ * thrd = 0p;
         lock( lock __cfaabi_dbg_ctx2 );
         count += 1;
@@ -384 +384 @@
 
 bool V(semaphore & this) with( this ) {
-        $thread * thrd = V(this, true);
+        thread$ * thrd = V(this, true);
         return thrd != 0p;
 }
 
 bool V(semaphore & this, unsigned diff) with( this ) {
-        $thread * thrd = 0p;
+        thread$ * thrd = 0p;
         lock( lock __cfaabi_dbg_ctx2 );
         int release = max(-count, (int)diff);

libcfa/src/concurrency/locks.hfa

@@ -39 +39 @@
 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 +51 @@
 
 static inline bool P(Semaphore0nary & this) {
-    $thread * thrd = active_thread();
+    thread$ * thrd = active_thread();
     P(this, thrd);
     park();
@@ -57 +57 @@
 }
 
-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 +124 @@
 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 +134 @@
         __spinlock_t lock;
         int count;
-        __queue_t($thread) waiting;
+        __queue_t(thread$) waiting;
 };
 
@@ -142 +142 @@
 bool   V (semaphore & this);
 bool   V (semaphore & this, unsigned count);
-$thread * V (semaphore & this, bool );
+thread$ * V (semaphore & this, bool );
 
 //----------
@@ -156 +156 @@
 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 +170 @@
 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 +179 @@
 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 +186 @@
 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 +197 @@
 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 +216 @@
 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 +248 @@
 
         // 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
@@ -342 +342 @@
         // 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;
@@ -384 +384 @@
         // 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;
@@ -394 +394 @@
     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); }
@@ -407 +407 @@
 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
@@ -441 +441 @@
                 int count;
         };
-        
+
 
         void  ?{}( condition_variable(L) & this );

libcfa/src/concurrency/monitor.cfa

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// $monitor.c --
+// monitor.cfa --
 //
 // Author           : Thierry Delisle
@@ -28 +28 @@
 //-----------------------------------------------------------------------------
 // Forward declarations
-static inline void __set_owner ( $monitor * this, $thread * owner );
-static inline void __set_owner ( $monitor * storage [], __lock_size_t count, $thread * owner );
-static inline void set_mask  ( $monitor * storage [], __lock_size_t count, const __waitfor_mask_t & mask );
-static inline void reset_mask( $monitor * this );
-
-static inline $thread * next_thread( $monitor * this );
-static inline bool is_accepted( $monitor * this, const __monitor_group_t & monitors );
+static inline void __set_owner ( monitor$ * this, thread$ * owner );
+static inline void __set_owner ( monitor$ * storage [], __lock_size_t count, thread$ * owner );
+static inline void set_mask  ( monitor$ * storage [], __lock_size_t count, const __waitfor_mask_t & mask );
+static inline void reset_mask( monitor$ * this );
+
+static inline thread$ * next_thread( monitor$ * this );
+static inline bool is_accepted( monitor$ * this, const __monitor_group_t & monitors );
 
 static inline void lock_all  ( __spinlock_t * locks [], __lock_size_t count );
-static inline void lock_all  ( $monitor * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count );
+static inline void lock_all  ( monitor$ * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count );
 static inline void unlock_all( __spinlock_t * locks [], __lock_size_t count );
-static inline void unlock_all( $monitor * locks [], __lock_size_t count );
-
-static inline void save   ( $monitor * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*out*/ recursions [], __waitfor_mask_t /*out*/ masks [] );
-static inline void restore( $monitor * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*in */ recursions [], __waitfor_mask_t /*in */ masks [] );
-
-static inline void init     ( __lock_size_t count, $monitor * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
-static inline void init_push( __lock_size_t count, $monitor * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
-
-static inline $thread *        check_condition   ( __condition_criterion_t * );
+static inline void unlock_all( monitor$ * locks [], __lock_size_t count );
+
+static inline void save   ( monitor$ * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*out*/ recursions [], __waitfor_mask_t /*out*/ masks [] );
+static inline void restore( monitor$ * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*in */ recursions [], __waitfor_mask_t /*in */ masks [] );
+
+static inline void init     ( __lock_size_t count, monitor$ * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
+static inline void init_push( __lock_size_t count, monitor$ * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
+
+static inline thread$ *        check_condition   ( __condition_criterion_t * );
 static inline void                 brand_condition   ( condition & );
-static inline [$thread *, int] search_entry_queue( const __waitfor_mask_t &, $monitor * monitors [], __lock_size_t count );
+static inline [thread$ *, int] search_entry_queue( const __waitfor_mask_t &, monitor$ * monitors [], __lock_size_t count );
 
 forall(T & | sized( T ))
 static inline __lock_size_t insert_unique( T * array [], __lock_size_t & size, T * val );
 static inline __lock_size_t count_max    ( const __waitfor_mask_t & mask );
-static inline __lock_size_t aggregate    ( $monitor * storage [], const __waitfor_mask_t & mask );
+static inline __lock_size_t aggregate    ( monitor$ * storage [], const __waitfor_mask_t & mask );
 
 //-----------------------------------------------------------------------------
@@ -69 +69 @@
 
 #define monitor_ctx( mons, cnt )                                /* Define that create the necessary struct for internal/external scheduling operations */ \
-        $monitor ** monitors = mons;                          /* Save the targeted monitors                                                          */ \
+        monitor$ ** monitors = mons;                          /* Save the targeted monitors                                                          */ \
         __lock_size_t count = cnt;                                /* Save the count to a local variable                                                  */ \
         unsigned int recursions[ count ];                         /* Save the current recursion levels to restore them later                             */ \
@@ -82 +82 @@
 // Enter/Leave routines
 // Enter single monitor
-static void __enter( $monitor * this, const __monitor_group_t & group ) {
-        $thread * thrd = active_thread();
+static void __enter( monitor$ * this, const __monitor_group_t & group ) {
+        thread$ * thrd = active_thread();
 
         // Lock the monitor spinlock
@@ -141 +141 @@
 }
 
-static void __dtor_enter( $monitor * this, fptr_t func, bool join ) {
-        $thread * thrd = active_thread();
+static void __dtor_enter( monitor$ * this, fptr_t func, bool join ) {
+        thread$ * thrd = active_thread();
         #if defined( __CFA_WITH_VERIFY__ )
                 bool is_thrd = this == &thrd->self_mon;
@@ -173 +173 @@
         // because join will not release the monitor after it executed.
         // to avoid that it sets the owner to the special value thrd | 1p before exiting
-        else if( this->owner == ($thread*)(1 | (uintptr_t)thrd) ) {
+        else if( this->owner == (thread$*)(1 | (uintptr_t)thrd) ) {
                 // restore the owner and just return
                 __cfaabi_dbg_print_safe( "Kernel : Destroying free mon %p\n", this);
@@ -191 +191 @@
 
         __lock_size_t count = 1;
-        $monitor ** monitors = &this;
+        monitor$ ** monitors = &this;
         __monitor_group_t group = { &this, 1, func };
         if( is_accepted( this, group) ) {
@@ -243 +243 @@
 
 // Leave single monitor
-void __leave( $monitor * this ) {
+void __leave( monitor$ * this ) {
         // Lock the monitor spinlock
         lock( this->lock __cfaabi_dbg_ctx2 );
@@ -263 +263 @@
 
         // Get the next thread, will be null on low contention monitor
-        $thread * new_owner = next_thread( this );
+        thread$ * new_owner = next_thread( this );
 
         // Check the new owner is consistent with who we wake-up
@@ -278 +278 @@
 
 // Leave single monitor for the last time
-void __dtor_leave( $monitor * this, bool join ) {
+void __dtor_leave( monitor$ * this, bool join ) {
         __cfaabi_dbg_debug_do(
                 if( active_thread() != this->owner ) {
@@ -288 +288 @@
         )
 
-        this->owner = ($thread*)(1 | (uintptr_t)this->owner);
-}
-
-void __thread_finish( $thread * thrd ) {
-        $monitor * this = &thrd->self_mon;
+        this->owner = (thread$*)(1 | (uintptr_t)this->owner);
+}
+
+void __thread_finish( thread$ * thrd ) {
+        monitor$ * this = &thrd->self_mon;
 
         // Lock the monitor now
@@ -298 +298 @@
         /* paranoid */ verify( this->lock.lock );
         /* paranoid */ verify( thrd->context.SP );
-        /* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) > ((uintptr_t)__get_stack(thrd->curr_cor)->limit), "ERROR : $thread %p has been corrupted.\n StackPointer too large.\n", thrd );
-        /* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) < ((uintptr_t)__get_stack(thrd->curr_cor)->base ), "ERROR : $thread %p has been corrupted.\n StackPointer too small.\n", thrd );
+        /* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) > ((uintptr_t)__get_stack(thrd->curr_cor)->limit), "ERROR : thread$ %p has been corrupted.\n StackPointer too large.\n", thrd );
+        /* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) < ((uintptr_t)__get_stack(thrd->curr_cor)->base ), "ERROR : thread$ %p has been corrupted.\n StackPointer too small.\n", thrd );
         /* paranoid */ verify( ! __preemption_enabled() );
 
@@ -311 +311 @@
 
         // Fetch the next thread, can be null
-        $thread * new_owner = next_thread( this );
+        thread$ * new_owner = next_thread( this );
 
         // Mark the state as fully halted
@@ -336 +336 @@
 // Leave multiple monitor
 // relies on the monitor array being sorted
-static inline void leave($monitor * monitors [], __lock_size_t count) {
+static inline void leave(monitor$ * monitors [], __lock_size_t count) {
         for( __lock_size_t i = count - 1; i >= 0; i--) {
                 __leave( monitors[i] );
@@ -344 +344 @@
 // Ctor for monitor guard
 // Sorts monitors before entering
-void ?{}( monitor_guard_t & this, $monitor * m [], __lock_size_t count, fptr_t func ) {
-        $thread * thrd = active_thread();
+void ?{}( monitor_guard_t & this, monitor$ * m [], __lock_size_t count, fptr_t func ) {
+        thread$ * thrd = active_thread();
 
         // Store current array
@@ -385 +385 @@
 // Ctor for monitor guard
 // Sorts monitors before entering
-void ?{}( monitor_dtor_guard_t & this, $monitor * m [], fptr_t func, bool join ) {
+void ?{}( monitor_dtor_guard_t & this, monitor$ * m [], fptr_t func, bool join ) {
         // optimization
-        $thread * thrd = active_thread();
+        thread$ * thrd = active_thread();
 
         // Store current array
@@ -415 +415 @@
 //-----------------------------------------------------------------------------
 // Internal scheduling types
-void ?{}(__condition_node_t & this, $thread * waiting_thread, __lock_size_t count, uintptr_t user_info ) {
+void ?{}(__condition_node_t & this, thread$ * waiting_thread, __lock_size_t count, uintptr_t user_info ) {
         this.waiting_thread = waiting_thread;
         this.count = count;
@@ -429 +429 @@
 }
 
-void ?{}(__condition_criterion_t & this, $monitor * target, __condition_node_t & owner ) {
+void ?{}(__condition_criterion_t & this, monitor$ * target, __condition_node_t & owner ) {
         this.ready  = false;
         this.target = target;
@@ -463 +463 @@
         // Find the next thread(s) to run
         __lock_size_t thread_count = 0;
-        $thread * threads[ count ];
+        thread$ * threads[ count ];
         __builtin_memset( threads, 0, sizeof( threads ) );
 
@@ -471 +471 @@
         // Remove any duplicate threads
         for( __lock_size_t i = 0; i < count; i++) {
-                $thread * new_owner = next_thread( monitors[i] );
+                thread$ * new_owner = next_thread( monitors[i] );
                 insert_unique( threads, thread_count, new_owner );
         }
@@ -501 +501 @@
         //Some more checking in debug
         __cfaabi_dbg_debug_do(
-                $thread * this_thrd = active_thread();
+                thread$ * this_thrd = active_thread();
                 if ( this.monitor_count != this_thrd->monitors.size ) {
                         abort( "Signal on condition %p made with different number of monitor(s), expected %zi got %zi", &this, this.monitor_count, this_thrd->monitors.size );
@@ -555 +555 @@
 
         //Find the thread to run
-        $thread * signallee = pop_head( this.blocked )->waiting_thread;
+        thread$ * signallee = pop_head( this.blocked )->waiting_thread;
         __set_owner( monitors, count, signallee );
 
@@ -608 +608 @@
         // Create one!
         __lock_size_t max = count_max( mask );
-        $monitor * mon_storage[max];
+        monitor$ * mon_storage[max];
         __builtin_memset( mon_storage, 0, sizeof( mon_storage ) );
         __lock_size_t actual_count = aggregate( mon_storage, mask );
@@ -626 +626 @@
         {
                 // Check if the entry queue
-                $thread * next; int index;
+                thread$ * next; int index;
                 [next, index] = search_entry_queue( mask, monitors, count );
 
@@ -636 +636 @@
                                 verifyf( accepted.size == 1,  "ERROR: Accepted dtor has more than 1 mutex parameter." );
 
-                                $monitor * mon2dtor = accepted[0];
+                                monitor$ * mon2dtor = accepted[0];
                                 verifyf( mon2dtor->dtor_node, "ERROR: Accepted monitor has no dtor_node." );
 
@@ -730 +730 @@
 // Utilities
 
-static inline void __set_owner( $monitor * this, $thread * owner ) {
+static inline void __set_owner( monitor$ * this, thread$ * owner ) {
         /* paranoid */ verify( this->lock.lock );
 
@@ -740 +740 @@
 }
 
-static inline void __set_owner( $monitor * monitors [], __lock_size_t count, $thread * owner ) {
+static inline void __set_owner( monitor$ * monitors [], __lock_size_t count, thread$ * owner ) {
         /* paranoid */ verify ( monitors[0]->lock.lock );
         /* paranoid */ verifyf( monitors[0]->owner == active_thread(), "Expected owner to be %p, got %p (r: %i, m: %p)", active_thread(), monitors[0]->owner, monitors[0]->recursion, monitors[0] );
@@ -753 +753 @@
 }
 
-static inline void set_mask( $monitor * storage [], __lock_size_t count, const __waitfor_mask_t & mask ) {
+static inline void set_mask( monitor$ * storage [], __lock_size_t count, const __waitfor_mask_t & mask ) {
         for( __lock_size_t i = 0; i < count; i++) {
                 storage[i]->mask = mask;
@@ -759 +759 @@
 }
 
-static inline void reset_mask( $monitor * this ) {
+static inline void reset_mask( monitor$ * this ) {
         this->mask.accepted = 0p;
         this->mask.data = 0p;
@@ -765 +765 @@
 }
 
-static inline $thread * next_thread( $monitor * this ) {
+static inline thread$ * next_thread( monitor$ * this ) {
         //Check the signaller stack
         __cfaabi_dbg_print_safe( "Kernel :  mon %p AS-stack top %p\n", this, this->signal_stack.top);
@@ -781 +781 @@
         // No signaller thread
         // Get the next thread in the entry_queue
-        $thread * new_owner = pop_head( this->entry_queue );
+        thread$ * new_owner = pop_head( this->entry_queue );
         /* paranoid */ verifyf( !this->owner || active_thread() == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", active_thread(), this->owner, this->recursion, this );
         /* paranoid */ verify( !new_owner || new_owner->link.next == 0p );
@@ -789 +789 @@
 }
 
-static inline bool is_accepted( $monitor * this, const __monitor_group_t & group ) {
+static inline bool is_accepted( monitor$ * this, const __monitor_group_t & group ) {
         __acceptable_t * it = this->mask.data; // Optim
         __lock_size_t count = this->mask.size;
@@ -811 +811 @@
 }
 
-static inline void init( __lock_size_t count, $monitor * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) {
+static inline void init( __lock_size_t count, monitor$ * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) {
         for( __lock_size_t i = 0; i < count; i++) {
                 (criteria[i]){ monitors[i], waiter };
@@ -819 +819 @@
 }
 
-static inline void init_push( __lock_size_t count, $monitor * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) {
+static inline void init_push( __lock_size_t count, monitor$ * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) {
         for( __lock_size_t i = 0; i < count; i++) {
                 (criteria[i]){ monitors[i], waiter };
@@ -835 +835 @@
 }
 
-static inline void lock_all( $monitor * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count ) {
+static inline void lock_all( monitor$ * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count ) {
         for( __lock_size_t i = 0; i < count; i++ ) {
                 __spinlock_t * l = &source[i]->lock;
@@ -849 +849 @@
 }
 
-static inline void unlock_all( $monitor * locks [], __lock_size_t count ) {
+static inline void unlock_all( monitor$ * locks [], __lock_size_t count ) {
         for( __lock_size_t i = 0; i < count; i++ ) {
                 unlock( locks[i]->lock );
@@ -856 +856 @@
 
 static inline void save(
-        $monitor * ctx [],
+        monitor$ * ctx [],
         __lock_size_t count,
         __attribute((unused)) __spinlock_t * locks [],
@@ -869 +869 @@
 
 static inline void restore(
-        $monitor * ctx [],
+        monitor$ * ctx [],
         __lock_size_t count,
         __spinlock_t * locks [],
@@ -887 +887 @@
 // 2 - Checks if all the monitors are ready to run
 //     if so return the thread to run
-static inline $thread * check_condition( __condition_criterion_t * target ) {
+static inline thread$ * check_condition( __condition_criterion_t * target ) {
         __condition_node_t * node = target->owner;
         unsigned short count = node->count;
@@ -910 +910 @@
 
 static inline void brand_condition( condition & this ) {
-        $thread * thrd = active_thread();
+        thread$ * thrd = active_thread();
         if( !this.monitors ) {
                 // __cfaabi_dbg_print_safe( "Branding\n" );
@@ -916 +916 @@
                 this.monitor_count = thrd->monitors.size;
 
-                this.monitors = ($monitor **)malloc( this.monitor_count * sizeof( *this.monitors ) );
+                this.monitors = (monitor$ **)malloc( this.monitor_count * sizeof( *this.monitors ) );
                 for( int i = 0; i < this.monitor_count; i++ ) {
                         this.monitors[i] = thrd->monitors[i];
@@ -923 +923 @@
 }
 
-static inline [$thread *, int] search_entry_queue( const __waitfor_mask_t & mask, $monitor * monitors [], __lock_size_t count ) {
-
-        __queue_t($thread) & entry_queue = monitors[0]->entry_queue;
+static inline [thread$ *, int] search_entry_queue( const __waitfor_mask_t & mask, monitor$ * monitors [], __lock_size_t count ) {
+
+        __queue_t(thread$) & entry_queue = monitors[0]->entry_queue;
 
         // For each thread in the entry-queue
-        for(    $thread ** thrd_it = &entry_queue.head;
+        for(    thread$ ** thrd_it = &entry_queue.head;
                 (*thrd_it) != 1p;
                 thrd_it = &(*thrd_it)->link.next
@@ -972 +972 @@
 }
 
-static inline __lock_size_t aggregate( $monitor * storage [], const __waitfor_mask_t & mask ) {
+static inline __lock_size_t aggregate( monitor$ * storage [], const __waitfor_mask_t & mask ) {
         __lock_size_t size = 0;
         for( __lock_size_t i = 0; i < mask.size; i++ ) {

libcfa/src/concurrency/monitor.hfa

@@ -23 +23 @@
 
 trait is_monitor(T &) {
-        $monitor * get_monitor( T & );
+        monitor$ * get_monitor( T & );
         void ^?{}( T & mutex );
 };
 
-static inline void ?{}($monitor & this) with( this ) {
+static inline void ?{}(monitor$ & this) with( this ) {
         lock{};
         entry_queue{};
@@ -39 +39 @@
 }
 
-static inline void ^?{}($monitor & ) {}
+static inline void ^?{}(monitor$ & ) {}
 
 struct monitor_guard_t {
-        $monitor **     m;
+        monitor$ **     m;
         __lock_size_t           count;
         __monitor_group_t prev;
 };
 
-void ?{}( monitor_guard_t & this, $monitor ** m, __lock_size_t count, void (*func)() );
+void ?{}( monitor_guard_t & this, monitor$ ** m, __lock_size_t count, void (*func)() );
 void ^?{}( monitor_guard_t & this );
 
 struct monitor_dtor_guard_t {
-        $monitor *    m;
+        monitor$ *    m;
         __monitor_group_t prev;
         bool join;
 };
 
-void ?{}( monitor_dtor_guard_t & this, $monitor ** m, void (*func)(), bool join );
+void ?{}( monitor_dtor_guard_t & this, monitor$ ** m, void (*func)(), bool join );
 void ^?{}( monitor_dtor_guard_t & this );
 
@@ -73 +73 @@
 
         // The monitor this criterion concerns
-        $monitor * target;
+        monitor$ * target;
 
         // The parent node to which this criterion belongs
@@ -88 +88 @@
 struct __condition_node_t {
         // Thread that needs to be woken when all criteria are met
-        $thread * waiting_thread;
+        thread$ * waiting_thread;
 
         // Array of criteria (Criterions are contiguous in memory)
@@ -107 +107 @@
 }
 
-void ?{}(__condition_node_t & this, $thread * waiting_thread, __lock_size_t count, uintptr_t user_info );
+void ?{}(__condition_node_t & this, thread$ * waiting_thread, __lock_size_t count, uintptr_t user_info );
 void ?{}(__condition_criterion_t & this );
-void ?{}(__condition_criterion_t & this, $monitor * target, __condition_node_t * owner );
+void ?{}(__condition_criterion_t & this, monitor$ * target, __condition_node_t * owner );
 
 struct condition {
@@ -116 +116 @@
 
         // Array of monitor pointers (Monitors are NOT contiguous in memory)
-        $monitor ** monitors;
+        monitor$ ** monitors;
 
         // Number of monitors in the array

libcfa/src/concurrency/mutex.cfa

@@ -122 +122 @@
         recursion_count--;
         if( recursion_count == 0 ) {
-                $thread * thrd = pop_head( blocked_threads );
+                thread$ * thrd = pop_head( blocked_threads );
                 owner = thrd;
                 recursion_count = (thrd ? 1 : 0);

libcfa/src/concurrency/mutex.hfa

@@ -36 +36 @@
 
         // List of blocked threads
-        __queue_t(struct $thread) blocked_threads;
+        __queue_t(struct thread$) blocked_threads;
 
         // Locked flag
@@ -55 +55 @@
 
         // List of blocked threads
-        __queue_t(struct $thread) blocked_threads;
+        __queue_t(struct thread$) blocked_threads;
 
         // Current thread owning the lock
-        struct $thread * owner;
+        struct thread$ * owner;
 
         // Number of recursion level
@@ -83 +83 @@
 
         // List of blocked threads
-        __queue_t(struct $thread) blocked_threads;
+        __queue_t(struct thread$) blocked_threads;
 };
 

libcfa/src/concurrency/preemption.cfa

@@ -61 +61 @@
 // FwdDeclarations : timeout handlers
 static void preempt( processor   * this );
-static void timeout( $thread * this );
+static void timeout( thread$ * this );
 
 // FwdDeclarations : Signal handlers
@@ -420 +420 @@
 
 // reserved for future use
-static void timeout( $thread * this ) {
+static void timeout( thread$ * this ) {
         unpark( this );
 }

libcfa/src/concurrency/ready_queue.cfa

@@ -67 +67 @@
 #endif
 
-static inline struct $thread * try_pop(struct cluster * cltr, unsigned w __STATS(, __stats_readyQ_pop_t & stats));
-static inline struct $thread * try_pop(struct cluster * cltr, unsigned i, unsigned j __STATS(, __stats_readyQ_pop_t & stats));
-static inline struct $thread * search(struct cluster * cltr);
+static inline struct thread$ * try_pop(struct cluster * cltr, unsigned w __STATS(, __stats_readyQ_pop_t & stats));
+static inline struct thread$ * try_pop(struct cluster * cltr, unsigned i, unsigned j __STATS(, __stats_readyQ_pop_t & stats));
+static inline struct thread$ * search(struct cluster * cltr);
 static inline [unsigned, bool] idx_from_r(unsigned r, unsigned preferred);
 
@@ -274 +274 @@
 //-----------------------------------------------------------------------
 #if defined(USE_CPU_WORK_STEALING)
-        __attribute__((hot)) void push(struct cluster * cltr, struct $thread * thrd, bool push_local) with (cltr->ready_queue) {
+        __attribute__((hot)) void push(struct cluster * cltr, struct thread$ * thrd, bool push_local) with (cltr->ready_queue) {
                 __cfadbg_print_safe(ready_queue, "Kernel : Pushing %p on cluster %p\n", thrd, cltr);
 
@@ -316 +316 @@
 
         // Pop from the ready queue from a given cluster
-        __attribute__((hot)) $thread * pop_fast(struct cluster * cltr) with (cltr->ready_queue) {
+        __attribute__((hot)) thread$ * pop_fast(struct cluster * cltr) with (cltr->ready_queue) {
                 /* paranoid */ verify( lanes.count > 0 );
                 /* paranoid */ verify( kernelTLS().this_processor );
@@ -371 +371 @@
                                 proc->rdq.target = -1u;
                                 if(lanes.tscs[target].tv < cutoff && ts(lanes.data[target]) < cutoff) {
-                                        $thread * t = try_pop(cltr, target __STATS(, __tls_stats()->ready.pop.help));
+                                        thread$ * t = try_pop(cltr, target __STATS(, __tls_stats()->ready.pop.help));
                                         proc->rdq.last = target;
                                         if(t) return t;
@@ -379 +379 @@
                         unsigned last = proc->rdq.last;
                         if(last != -1u && lanes.tscs[last].tv < cutoff && ts(lanes.data[last]) < cutoff) {
-                                $thread * t = try_pop(cltr, last __STATS(, __tls_stats()->ready.pop.help));
+                                thread$ * t = try_pop(cltr, last __STATS(, __tls_stats()->ready.pop.help));
                                 if(t) return t;
                         }
@@ -389 +389 @@
                 for(READYQ_SHARD_FACTOR) {
                         unsigned i = start + (proc->rdq.itr++ % READYQ_SHARD_FACTOR);
-                        if($thread * t = try_pop(cltr, i __STATS(, __tls_stats()->ready.pop.local))) return t;
+                        if(thread$ * t = try_pop(cltr, i __STATS(, __tls_stats()->ready.pop.local))) return t;
                 }
 
@@ -396 +396 @@
         }
 
-        __attribute__((hot)) struct $thread * pop_slow(struct cluster * cltr) with (cltr->ready_queue) {
+        __attribute__((hot)) struct thread$ * pop_slow(struct cluster * cltr) with (cltr->ready_queue) {
                 processor * const proc = kernelTLS().this_processor;
                 unsigned last = proc->rdq.last;
                 if(last != -1u) {
-                        struct $thread * t = try_pop(cltr, last __STATS(, __tls_stats()->ready.pop.steal));
+                        struct thread$ * t = try_pop(cltr, last __STATS(, __tls_stats()->ready.pop.steal));
                         if(t) return t;
                         proc->rdq.last = -1u;
@@ -408 +408 @@
                 return try_pop(cltr, i __STATS(, __tls_stats()->ready.pop.steal));
         }
-        __attribute__((hot)) struct $thread * pop_search(struct cluster * cltr) {
+        __attribute__((hot)) struct thread$ * pop_search(struct cluster * cltr) {
                 return search(cltr);
         }
@@ -435 +435 @@
         }
 
-        __attribute__((hot)) void push(struct cluster * cltr, struct $thread * thrd, bool push_local) with (cltr->ready_queue) {
+        __attribute__((hot)) void push(struct cluster * cltr, struct thread$ * thrd, bool push_local) with (cltr->ready_queue) {
                 __cfadbg_print_safe(ready_queue, "Kernel : Pushing %p on cluster %p\n", thrd, cltr);
 
@@ -482 +482 @@
 
         // Pop from the ready queue from a given cluster
-        __attribute__((hot)) $thread * pop_fast(struct cluster * cltr) with (cltr->ready_queue) {
+        __attribute__((hot)) thread$ * pop_fast(struct cluster * cltr) with (cltr->ready_queue) {
                 /* paranoid */ verify( lanes.count > 0 );
                 /* paranoid */ verify( kernelTLS().this_processor );
@@ -506 +506 @@
 
                         // try popping from the 2 picked lists
-                        struct $thread * thrd = try_pop(cltr, i, j __STATS(, *(locali || localj ? &__tls_stats()->ready.pop.local : &__tls_stats()->ready.pop.help)));
+                        struct thread$ * thrd = try_pop(cltr, i, j __STATS(, *(locali || localj ? &__tls_stats()->ready.pop.local : &__tls_stats()->ready.pop.help)));
                         if(thrd) {
                                 return thrd;
@@ -516 +516 @@
         }
 
-        __attribute__((hot)) struct $thread * pop_slow(struct cluster * cltr) { return pop_fast(cltr); }
-        __attribute__((hot)) struct $thread * pop_search(struct cluster * cltr) {
+        __attribute__((hot)) struct thread$ * pop_slow(struct cluster * cltr) { return pop_fast(cltr); }
+        __attribute__((hot)) struct thread$ * pop_search(struct cluster * cltr) {
                 return search(cltr);
         }
 #endif
 #if defined(USE_WORK_STEALING)
-        __attribute__((hot)) void push(struct cluster * cltr, struct $thread * thrd, bool push_local) with (cltr->ready_queue) {
+        __attribute__((hot)) void push(struct cluster * cltr, struct thread$ * thrd, bool push_local) with (cltr->ready_queue) {
                 __cfadbg_print_safe(ready_queue, "Kernel : Pushing %p on cluster %p\n", thrd, cltr);
 
@@ -576 +576 @@
 
         // Pop from the ready queue from a given cluster
-        __attribute__((hot)) $thread * pop_fast(struct cluster * cltr) with (cltr->ready_queue) {
+        __attribute__((hot)) thread$ * pop_fast(struct cluster * cltr) with (cltr->ready_queue) {
                 /* paranoid */ verify( lanes.count > 0 );
                 /* paranoid */ verify( kernelTLS().this_processor );
@@ -598 +598 @@
                         const unsigned long long cutoff = proc->rdq.cutoff > bias ? proc->rdq.cutoff - bias : proc->rdq.cutoff;
                         if(lanes.tscs[target].tv < cutoff && ts(lanes.data[target]) < cutoff) {
-                                $thread * t = try_pop(cltr, target __STATS(, __tls_stats()->ready.pop.help));
+                                thread$ * t = try_pop(cltr, target __STATS(, __tls_stats()->ready.pop.help));
                                 if(t) return t;
                         }
@@ -605 +605 @@
                 for(READYQ_SHARD_FACTOR) {
                         unsigned i = proc->rdq.id + (proc->rdq.itr++ % READYQ_SHARD_FACTOR);
-                        if($thread * t = try_pop(cltr, i __STATS(, __tls_stats()->ready.pop.local))) return t;
+                        if(thread$ * t = try_pop(cltr, i __STATS(, __tls_stats()->ready.pop.local))) return t;
                 }
                 return 0p;
         }
 
-        __attribute__((hot)) struct $thread * pop_slow(struct cluster * cltr) with (cltr->ready_queue) {
+        __attribute__((hot)) struct thread$ * pop_slow(struct cluster * cltr) with (cltr->ready_queue) {
                 unsigned i = __tls_rand() % lanes.count;
                 return try_pop(cltr, i __STATS(, __tls_stats()->ready.pop.steal));
         }
 
-        __attribute__((hot)) struct $thread * pop_search(struct cluster * cltr) with (cltr->ready_queue) {
+        __attribute__((hot)) struct thread$ * pop_search(struct cluster * cltr) with (cltr->ready_queue) {
                 return search(cltr);
         }
@@ -628 +628 @@
 //-----------------------------------------------------------------------
 // try to pop from a lane given by index w
-static inline struct $thread * try_pop(struct cluster * cltr, unsigned w __STATS(, __stats_readyQ_pop_t & stats)) with (cltr->ready_queue) {
+static inline struct thread$ * try_pop(struct cluster * cltr, unsigned w __STATS(, __stats_readyQ_pop_t & stats)) with (cltr->ready_queue) {
         __STATS( stats.attempt++; )
 
@@ -651 +651 @@
 
         // Actually pop the list
-        struct $thread * thrd;
+        struct thread$ * thrd;
         unsigned long long tsv;
         [thrd, tsv] = pop(lane);
@@ -678 +678 @@
 // try to pop from any lanes making sure you don't miss any threads push
 // before the start of the function
-static inline struct $thread * search(struct cluster * cltr) with (cltr->ready_queue) {
+static inline struct thread$ * search(struct cluster * cltr) with (cltr->ready_queue) {
         /* paranoid */ verify( lanes.count > 0 );
         unsigned count = __atomic_load_n( &lanes.count, __ATOMIC_RELAXED );
@@ -684 +684 @@
         for(i; count) {
                 unsigned idx = (offset + i) % count;
-                struct $thread * thrd = try_pop(cltr, idx __STATS(, __tls_stats()->ready.pop.search));
+                struct thread$ * thrd = try_pop(cltr, idx __STATS(, __tls_stats()->ready.pop.search));
                 if(thrd) {
                         return thrd;
@@ -719 +719 @@
 //-----------------------------------------------------------------------
 // Given 2 indexes, pick the list with the oldest push an try to pop from it
-static inline struct $thread * try_pop(struct cluster * cltr, unsigned i, unsigned j __STATS(, __stats_readyQ_pop_t & stats)) with (cltr->ready_queue) {
+static inline struct thread$ * try_pop(struct cluster * cltr, unsigned i, unsigned j __STATS(, __stats_readyQ_pop_t & stats)) with (cltr->ready_queue) {
         // Pick the bet list
         int w = i;
@@ -854 +854 @@
                                 // As long as we can pop from this lane to push the threads somewhere else in the queue
                                 while(!is_empty(lanes.data[idx])) {
-                                        struct $thread * thrd;
+                                        struct thread$ * thrd;
                                         unsigned long long _;
                                         [thrd, _] = pop(lanes.data[idx]);

libcfa/src/concurrency/ready_subqueue.hfa

@@ -7 +7 @@
 // Intrusives lanes which are used by the relaxed ready queue
 struct __attribute__((aligned(128))) __intrusive_lane_t {
-        struct $thread * prev;
+        struct thread$ * prev;
 
         // spin lock protecting the queue
@@ -20 +20 @@
 
 // Get the head pointer (one before the first element) from the anchor
-static inline $thread * mock_head(const __intrusive_lane_t & this) {
-        $thread * rhead = ($thread *)(
-                (uintptr_t)( &this.anchor ) - __builtin_offsetof( $thread, link )
+static inline thread$ * mock_head(const __intrusive_lane_t & this) {
+        thread$ * rhead = (thread$ *)(
+                (uintptr_t)( &this.anchor ) - __builtin_offsetof( thread$, link )
         );
         return rhead;
@@ -38 +38 @@
 
         // We add a boat-load of assertions here because the anchor code is very fragile
-        /* paranoid */ _Static_assert( offsetof( $thread, link ) == offsetof(__intrusive_lane_t, anchor) );
-        /* paranoid */ verify( offsetof( $thread, link ) == offsetof(__intrusive_lane_t, anchor) );
-        /* paranoid */ verify( ((uintptr_t)( mock_head(this) ) + offsetof( $thread, link )) == (uintptr_t)(&this.anchor) );
+        /* paranoid */ _Static_assert( offsetof( thread$, link ) == offsetof(__intrusive_lane_t, anchor) );
+        /* paranoid */ verify( offsetof( thread$, link ) == offsetof(__intrusive_lane_t, anchor) );
+        /* paranoid */ verify( ((uintptr_t)( mock_head(this) ) + offsetof( thread$, link )) == (uintptr_t)(&this.anchor) );
         /* paranoid */ verify( &mock_head(this)->link.next == &this.anchor.next );
         /* paranoid */ verify( &mock_head(this)->link.ts   == &this.anchor.ts   );
@@ -61 +61 @@
 // Push a thread onto this lane
 // returns true of lane was empty before push, false otherwise
-static inline void push( __intrusive_lane_t & this, $thread * node ) {
+static inline void push( __intrusive_lane_t & this, thread$ * node ) {
         /* paranoid */ verify( this.lock );
         /* paranoid */ verify( node->link.next == 0p );
@@ -91 +91 @@
 // returns popped
 // returns true of lane was empty before push, false otherwise
-static inline [* $thread, unsigned long long] pop( __intrusive_lane_t & this ) {
+static inline [* thread$, unsigned long long] pop( __intrusive_lane_t & this ) {
         /* paranoid */ verify( this.lock );
         /* paranoid */ verify( this.anchor.next != 0p );
@@ -99 +99 @@
         // Get the relevant nodes locally
         unsigned long long ts = this.anchor.ts;
-        $thread * node = this.anchor.next;
+        thread$ * node = this.anchor.next;
         this.anchor.next = node->link.next;
         this.anchor.ts   = node->link.ts;

libcfa/src/concurrency/thread.cfa

@@ -27 +27 @@
 //-----------------------------------------------------------------------------
 // Thread ctors and dtors
-void ?{}($thread & this, const char * const name, cluster & cl, void * storage, size_t storageSize ) with( this ) {
+void ?{}(thread$ & this, const char * const name, cluster & cl, void * storage, size_t storageSize ) with( this ) {
         context{ 0p, 0p };
         self_cor{ name, storage, storageSize };
@@ -57 +57 @@
 }
 
-void ^?{}($thread& this) with( this ) {
+void ^?{}(thread$& this) with( this ) {
         #if defined( __CFA_WITH_VERIFY__ )
                 canary = 0xDEADDEADDEADDEADp;
@@ -87 +87 @@
 void ?{}( thread_dtor_guard_t & this,
                 T & thrd, void(*cancelHandler)(ThreadCancelled(T) &)) {
-        $monitor * m = get_monitor(thrd);
-        $thread * desc = get_thread(thrd);
+        monitor$ * m = get_monitor(thrd);
+        thread$ * desc = get_thread(thrd);
 
         // Setup the monitor guard
@@ -130 +130 @@
 forall( T & | is_thread(T) )
 void __thrd_start( T & this, void (*main_p)(T &) ) {
-        $thread * this_thrd = get_thread(this);
+        thread$ * this_thrd = get_thread(this);
 
         disable_interrupts();

libcfa/src/concurrency/thread.hfa

@@ -29 +29 @@
         void ^?{}(T& mutex this);
         void main(T& this);
-        $thread* get_thread(T& this);
+        thread$ * get_thread(T& this);
 };
 
@@ -45 +45 @@
 // Inline getters for threads/coroutines/monitors
 forall( T & | is_thread(T) )
-static inline $coroutine* get_coroutine(T & this) __attribute__((const)) { return &get_thread(this)->self_cor; }
+static inline coroutine$ * get_coroutine(T & this) __attribute__((const)) { return &get_thread(this)->self_cor; }
 
 forall( T & | is_thread(T) )
-static inline $monitor  * get_monitor  (T & this) __attribute__((const)) { return &get_thread(this)->self_mon; }
+static inline monitor$   * get_monitor  (T & this) __attribute__((const)) { return &get_thread(this)->self_mon; }
 
-static inline $coroutine* get_coroutine($thread * this) __attribute__((const)) { return &this->self_cor; }
-static inline $monitor  * get_monitor  ($thread * this) __attribute__((const)) { return &this->self_mon; }
+static inline coroutine$ * get_coroutine(thread$ * this) __attribute__((const)) { return &this->self_cor; }
+static inline monitor$   * get_monitor  (thread$ * this) __attribute__((const)) { return &this->self_mon; }
 
 //-----------------------------------------------------------------------------
@@ -62 +62 @@
 //-----------------------------------------------------------------------------
 // Ctors and dtors
-void ?{}($thread & this, const char * const name, struct cluster & cl, void * storage, size_t storageSize );
-void ^?{}($thread & this);
+void ?{}(thread$ & this, const char * const name, struct cluster & cl, void * storage, size_t storageSize );
+void ^?{}(thread$ & this);
 
-static inline void ?{}($thread & this)                                                                  { this{ "Anonymous Thread", *mainCluster, 0p, 65000 }; }
-static inline void ?{}($thread & this, size_t stackSize )                                               { this{ "Anonymous Thread", *mainCluster, 0p, stackSize }; }
-static inline void ?{}($thread & this, void * storage, size_t storageSize )                             { this{ "Anonymous Thread", *mainCluster, storage, storageSize }; }
-static inline void ?{}($thread & this, struct cluster & cl )                                            { this{ "Anonymous Thread", cl, 0p, 65000 }; }
-static inline void ?{}($thread & this, struct cluster & cl, size_t stackSize )                          { this{ "Anonymous Thread", cl, 0p, stackSize }; }
-static inline void ?{}($thread & this, struct cluster & cl, void * storage, size_t storageSize )        { this{ "Anonymous Thread", cl, storage, storageSize }; }
-static inline void ?{}($thread & this, const char * const name)                                         { this{ name, *mainCluster, 0p, 65000 }; }
-static inline void ?{}($thread & this, const char * const name, struct cluster & cl )                   { this{ name, cl, 0p, 65000 }; }
-static inline void ?{}($thread & this, const char * const name, struct cluster & cl, size_t stackSize ) { this{ name, cl, 0p, stackSize }; }
+static inline void ?{}(thread$ & this)                                                                  { this{ "Anonymous Thread", *mainCluster, 0p, 65000 }; }
+static inline void ?{}(thread$ & this, size_t stackSize )                                               { this{ "Anonymous Thread", *mainCluster, 0p, stackSize }; }
+static inline void ?{}(thread$ & this, void * storage, size_t storageSize )                             { this{ "Anonymous Thread", *mainCluster, storage, storageSize }; }
+static inline void ?{}(thread$ & this, struct cluster & cl )                                            { this{ "Anonymous Thread", cl, 0p, 65000 }; }
+static inline void ?{}(thread$ & this, struct cluster & cl, size_t stackSize )                          { this{ "Anonymous Thread", cl, 0p, stackSize }; }
+static inline void ?{}(thread$ & this, struct cluster & cl, void * storage, size_t storageSize )        { this{ "Anonymous Thread", cl, storage, storageSize }; }
+static inline void ?{}(thread$ & this, const char * const name)                                         { this{ name, *mainCluster, 0p, 65000 }; }
+static inline void ?{}(thread$ & this, const char * const name, struct cluster & cl )                   { this{ name, cl, 0p, 65000 }; }
+static inline void ?{}(thread$ & this, const char * const name, struct cluster & cl, size_t stackSize ) { this{ name, cl, 0p, stackSize }; }
 
 struct thread_dtor_guard_t {
@@ -111 +111 @@
 // Unpark a thread, if the thread is already blocked, schedule it
 //                  if the thread is not yet block, signal that it should rerun immediately
-void unpark( $thread * this );
+void unpark( thread$ * this );
 
 forall( T & | is_thread(T) )

src/Concurrency/Keywords.cc

@@ -122 +122 @@
         //      int data;                                  int data;
         //      a_struct_t more_data;                      a_struct_t more_data;
-        //                                =>             $thread __thrd_d;
+        //                                =>             thread$ __thrd_d;
         // };                                        };
-        //                                           static inline $thread * get_thread( MyThread * this ) { return &this->__thrd_d; }
+        //                                           static inline thread$ * get_thread( MyThread * this ) { return &this->__thrd_d; }
         //
         class ThreadKeyword final : public ConcurrentSueKeyword {
@@ -130 +130 @@
 
                 ThreadKeyword() : ConcurrentSueKeyword(
-                        "$thread",
+                        "thread$",
                         "__thrd",
                         "get_thread",
@@ -155 +155 @@
         //      int data;                                  int data;
         //      a_struct_t more_data;                      a_struct_t more_data;
-        //                                =>             $coroutine __cor_d;
+        //                                =>             coroutine$ __cor_d;
         // };                                        };
-        //                                           static inline $coroutine * get_coroutine( MyCoroutine * this ) { return &this->__cor_d; }
+        //                                           static inline coroutine$ * get_coroutine( MyCoroutine * this ) { return &this->__cor_d; }
         //
         class CoroutineKeyword final : public ConcurrentSueKeyword {
@@ -163 +163 @@
 
                 CoroutineKeyword() : ConcurrentSueKeyword(
-                        "$coroutine",
+                        "coroutine$",
                         "__cor",
                         "get_coroutine",
@@ -190 +190 @@
         //      int data;                                  int data;
         //      a_struct_t more_data;                      a_struct_t more_data;
-        //                                =>             $monitor __mon_d;
+        //                                =>             monitor$ __mon_d;
         // };                                        };
-        //                                           static inline $monitor * get_coroutine( MyMonitor * this ) { return &this->__cor_d; }
+        //                                           static inline monitor$ * get_coroutine( MyMonitor * this ) { return &this->__cor_d; }
         //
         class MonitorKeyword final : public ConcurrentSueKeyword {
@@ -198 +198 @@
 
                 MonitorKeyword() : ConcurrentSueKeyword(
-                        "$monitor",
+                        "monitor$",
                         "__mon",
                         "get_monitor",
@@ -230 +230 @@
 
                 GeneratorKeyword() : ConcurrentSueKeyword(
-                        "$generator",
+                        "generator$",
                         "__generator_state",
                         "get_generator",
-                        "Unable to find builtin type $generator\n",
+                        "Unable to find builtin type generator$\n",
                         "",
                         true,
@@ -292 +292 @@
         //Handles mutex routines definitions :
         // void foo( A * mutex a, B * mutex b,  int i ) {                  void foo( A * a, B * b,  int i ) {
-        //                                                                       $monitor * __monitors[] = { get_monitor(a), get_monitor(b) };
+        //                                                                       monitor$ * __monitors[] = { get_monitor(a), get_monitor(b) };
         //                                                                       monitor_guard_t __guard = { __monitors, 2 };
         //    /*Some code*/                                       =>           /*Some code*/
@@ -333 +333 @@
         //Handles mutex routines definitions :
         // void foo( A * mutex a, B * mutex b,  int i ) {                  void foo( A * a, B * b,  int i ) {
-        //                                                                       $monitor * __monitors[] = { get_monitor(a), get_monitor(b) };
+        //                                                                       monitor$ * __monitors[] = { get_monitor(a), get_monitor(b) };
         //                                                                       monitor_guard_t __guard = { __monitors, 2 };
         //    /*Some code*/                                       =>           /*Some code*/
@@ -449 +449 @@
         Expression * ConcurrentSueKeyword::postmutate( KeywordCastExpr * cast ) {
                 if ( cast_target == cast->target ) {
-                        // convert (thread &)t to ($thread &)*get_thread(t), etc.
+                        // convert (thread &)t to (thread$ &)*get_thread(t), etc.
                         if( !type_decl ) SemanticError( cast, context_error );
                         if( !dtor_decl ) SemanticError( cast, context_error );
@@ -919 +919 @@
         void MutexKeyword::postvisit(StructDecl* decl) {
 
-                if( decl->name == "$monitor" && decl->body ) {
+                if( decl->name == "monitor$" && decl->body ) {
                         assert( !monitor_decl );
                         monitor_decl = decl;
@@ -1020 +1020 @@
                 );
 
-                //$monitor * __monitors[] = { get_monitor(a), get_monitor(b) };
+                //monitor$ * __monitors[] = { get_monitor(a), get_monitor(b) };
                 body->push_front( new DeclStmt( monitors ) );
         }
@@ -1117 +1117 @@
                 );
 
-                //$monitor * __monitors[] = { get_monitor(a), get_monitor(b) };
+                //monitor$ * __monitors[] = { get_monitor(a), get_monitor(b) };
                 body->push_front( new DeclStmt( monitors) );
         }
@@ -1125 +1125 @@
         //=============================================================================================
         void ThreadStarter::previsit( StructDecl * decl ) {
-                if( decl->name == "$thread" && decl->body ) {
+                if( decl->name == "thread$" && decl->body ) {
                         assert( !thread_decl );
                         thread_decl = decl;