Index: src/libcfa/concurrency/alarm.c =================================================================== --- src/libcfa/concurrency/alarm.c (revision b3d413befb5307e20b7a838c4700508e2bbd8a46) +++ src/libcfa/concurrency/alarm.c (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -40,24 +40,24 @@ __cfa_time_t zero_time = { 0 }; -void ?{}( __cfa_time_t * this ) { this->val = 0; } -void ?{}( __cfa_time_t * this, zero_t zero ) { this->val = 0; } - -void ?{}( itimerval * this, __cfa_time_t * alarm ) { - this->it_value.tv_sec = alarm->val / one_second; // seconds - this->it_value.tv_usec = max( (alarm->val % one_second) / one_microsecond, 1000 ); // microseconds - this->it_interval.tv_sec = 0; - this->it_interval.tv_usec = 0; -} - - -void ?{}( __cfa_time_t * this, timespec * curr ) { +void ?{}( __cfa_time_t & this ) { this.val = 0; } +void ?{}( __cfa_time_t & this, zero_t zero ) { this.val = 0; } + +void ?{}( itimerval & this, __cfa_time_t * alarm ) { + this.it_value.tv_sec = alarm->val / one_second; // seconds + this.it_value.tv_usec = max( (alarm->val % one_second) / one_microsecond, 1000 ); // microseconds + this.it_interval.tv_sec = 0; + this.it_interval.tv_usec = 0; +} + + +void ?{}( __cfa_time_t & this, timespec * curr ) { uint64_t secs = curr->tv_sec; uint64_t nsecs = curr->tv_nsec; - this->val = (secs * one_second) + nsecs; -} - -__cfa_time_t ?=?( __cfa_time_t * this, zero_t rhs ) { - this->val = 0; - return *this; + this.val = (secs * one_second) + nsecs; +} + +__cfa_time_t ?=?( __cfa_time_t & this, zero_t rhs ) { + this.val = 0; + return this; } @@ -86,25 +86,25 @@ //============================================================================================= -void ?{}( alarm_node_t * this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) { - this->thrd = thrd; - this->alarm = alarm; - this->period = period; - this->next = 0; - this->set = false; - this->kernel_alarm = false; -} - -void ?{}( alarm_node_t * this, processor * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) { - this->proc = proc; - this->alarm = alarm; - this->period = period; - this->next = 0; - this->set = false; - this->kernel_alarm = true; -} - -void ^?{}( alarm_node_t * this ) { - if( this->set ) { - unregister_self( this ); +void ?{}( alarm_node_t & this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) { + this.thrd = thrd; + this.alarm = alarm; + this.period = period; + this.next = 0; + this.set = false; + this.kernel_alarm = false; +} + +void ?{}( alarm_node_t & this, processor * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) { + this.proc = proc; + this.alarm = alarm; + this.period = period; + this.next = 0; + this.set = false; + this.kernel_alarm = true; +} + +void ^?{}( alarm_node_t & this ) { + if( this.set ) { + unregister_self( &this ); } } Index: src/libcfa/concurrency/alarm.h =================================================================== --- src/libcfa/concurrency/alarm.h (revision b3d413befb5307e20b7a838c4700508e2bbd8a46) +++ src/libcfa/concurrency/alarm.h (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -36,10 +36,10 @@ // ctors -void ?{}( __cfa_time_t * this ); -void ?{}( __cfa_time_t * this, zero_t zero ); -void ?{}( __cfa_time_t * this, timespec * curr ); -void ?{}( itimerval * this, __cfa_time_t * alarm ); +void ?{}( __cfa_time_t & this ); +void ?{}( __cfa_time_t & this, zero_t zero ); +void ?{}( __cfa_time_t & this, timespec * curr ); +void ?{}( itimerval & this, __cfa_time_t * alarm ); -__cfa_time_t ?=?( __cfa_time_t * this, zero_t rhs ); +__cfa_time_t ?=?( __cfa_time_t & this, zero_t rhs ); // logical ops @@ -105,7 +105,7 @@ typedef alarm_node_t ** __alarm_it_t; -void ?{}( alarm_node_t * this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ); -void ?{}( alarm_node_t * this, processor * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ); -void ^?{}( alarm_node_t * this ); +void ?{}( alarm_node_t & this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ); +void ?{}( alarm_node_t & this, processor * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ); +void ^?{}( alarm_node_t & this ); struct alarm_list_t { @@ -114,7 +114,7 @@ }; -static inline void ?{}( alarm_list_t * this ) { - this->head = 0; - this->tail = &this->head; +static inline void ?{}( alarm_list_t & this ) { + this.head = 0; + this.tail = &this.head; } Index: src/libcfa/concurrency/coroutine =================================================================== --- src/libcfa/concurrency/coroutine (revision b3d413befb5307e20b7a838c4700508e2bbd8a46) +++ src/libcfa/concurrency/coroutine (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -25,17 +25,17 @@ // Anything that is resumed is a coroutine. trait is_coroutine(dtype T) { - void main(T * this); - coroutine_desc * get_coroutine(T * this); + void main(T & this); + coroutine_desc * get_coroutine(T & this); }; -#define DECL_COROUTINE(X) static inline coroutine_desc* get_coroutine(X* this) { return &this->__cor; } void main(X* this) +#define DECL_COROUTINE(X) static inline coroutine_desc* get_coroutine(X& this) { return &this.__cor; } void main(X& this) //----------------------------------------------------------------------------- // Ctors and dtors -void ?{}(coStack_t * this); -void ?{}(coroutine_desc * this); -void ?{}(coroutine_desc * this, const char * name); -void ^?{}(coStack_t * this); -void ^?{}(coroutine_desc * this); +void ?{}(coStack_t & this); +void ?{}(coroutine_desc & this); +void ?{}(coroutine_desc & this, const char * name); +void ^?{}(coStack_t & this); +void ^?{}(coroutine_desc & this); //----------------------------------------------------------------------------- @@ -44,8 +44,8 @@ forall(dtype T | is_coroutine(T)) -static inline void resume(T * cor); +static inline void resume(T & cor); forall(dtype T | is_coroutine(T)) -void prime(T * cor); +void prime(T & cor); //----------------------------------------------------------------------------- @@ -86,5 +86,5 @@ // Resume implementation inlined for performance forall(dtype T | is_coroutine(T)) -static inline void resume(T * cor) { +static inline void resume(T & cor) { coroutine_desc * src = this_coroutine; // optimization coroutine_desc * dst = get_coroutine(cor); @@ -92,5 +92,5 @@ if( unlikely(!dst->stack.base) ) { create_stack(&dst->stack, dst->stack.size); - CtxStart(cor, CtxInvokeCoroutine); + CtxStart(&cor, CtxInvokeCoroutine); } Index: src/libcfa/concurrency/coroutine.c =================================================================== --- src/libcfa/concurrency/coroutine.c (revision b3d413befb5307e20b7a838c4700508e2bbd8a46) +++ src/libcfa/concurrency/coroutine.c (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -40,55 +40,55 @@ //----------------------------------------------------------------------------- // Coroutine ctors and dtors -void ?{}(coStack_t* this) { - this->size = 65000; // size of stack - this->storage = NULL; // pointer to stack - this->limit = NULL; // stack grows towards stack limit - this->base = NULL; // base of stack - this->context = NULL; // address of cfa_context_t - this->top = NULL; // address of top of storage - this->userStack = false; +void ?{}(coStack_t& this) { + this.size = 65000; // size of stack + this.storage = NULL; // pointer to stack + this.limit = NULL; // stack grows towards stack limit + this.base = NULL; // base of stack + this.context = NULL; // address of cfa_context_t + this.top = NULL; // address of top of storage + this.userStack = false; } -void ?{}(coStack_t* this, size_t size) { +void ?{}(coStack_t& this, size_t size) { this{}; - this->size = size; + this.size = size; - create_stack(this, this->size); + create_stack(&this, this.size); } -void ?{}(coroutine_desc* this) { +void ?{}(coroutine_desc& this) { this{ "Anonymous Coroutine" }; } -void ?{}(coroutine_desc* this, const char * name) { - this->name = name; - this->errno_ = 0; - this->state = Start; - this->starter = NULL; - this->last = NULL; +void ?{}(coroutine_desc& this, const char * name) { + this.name = name; + this.errno_ = 0; + this.state = Start; + this.starter = NULL; + this.last = NULL; } -void ?{}(coroutine_desc* this, size_t size) { +void ?{}(coroutine_desc& this, size_t size) { this{}; - (&this->stack){size}; + (this.stack){size}; } -void ^?{}(coStack_t* this) { - if ( ! this->userStack ) { +void ^?{}(coStack_t& this) { + if ( ! this.userStack ) { LIB_DEBUG_DO( - if ( mprotect( this->storage, pageSize, PROT_READ | PROT_WRITE ) == -1 ) { - abortf( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", this, errno, strerror( errno ) ); + if ( mprotect( this.storage, pageSize, PROT_READ | PROT_WRITE ) == -1 ) { + abortf( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) ); } ); - free( this->storage ); + free( this.storage ); } } -void ^?{}(coroutine_desc* this) {} +void ^?{}(coroutine_desc& this) {} // Part of the Public API // Not inline since only ever called once per coroutine forall(dtype T | is_coroutine(T)) -void prime(T* cor) { +void prime(T& cor) { coroutine_desc* this = get_coroutine(cor); assert(this->state == Start); Index: src/libcfa/concurrency/invoke.h =================================================================== --- src/libcfa/concurrency/invoke.h (revision b3d413befb5307e20b7a838c4700508e2bbd8a46) +++ src/libcfa/concurrency/invoke.h (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -47,14 +47,14 @@ #ifdef __CFORALL__ extern "Cforall" { - void ?{}( struct __thread_queue_t * ); + void ?{}( struct __thread_queue_t & ); void append( struct __thread_queue_t *, struct thread_desc * ); struct thread_desc * pop_head( struct __thread_queue_t * ); - void ?{}( struct __condition_stack_t * ); + void ?{}( struct __condition_stack_t & ); void push( struct __condition_stack_t *, struct __condition_criterion_t * ); struct __condition_criterion_t * pop( struct __condition_stack_t * ); - void ?{}(spinlock * this); - void ^?{}(spinlock * this); + void ?{}(spinlock & this); + void ^?{}(spinlock & this); } #endif Index: src/libcfa/concurrency/kernel =================================================================== --- src/libcfa/concurrency/kernel (revision b3d413befb5307e20b7a838c4700508e2bbd8a46) +++ src/libcfa/concurrency/kernel (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -37,6 +37,6 @@ }; -void ?{}(semaphore * this, int count = 1); -void ^?{}(semaphore * this); +void ?{}(semaphore & this, int count = 1); +void ^?{}(semaphore & this); void P(semaphore * this); void V(semaphore * this); @@ -51,6 +51,6 @@ }; -void ?{}(cluster * this); -void ^?{}(cluster * this); +void ?{}(cluster & this); +void ^?{}(cluster & this); //----------------------------------------------------------------------------- @@ -68,10 +68,10 @@ unsigned short thrd_count; }; -static inline void ?{}(FinishAction * this) { - this->action_code = No_Action; - this->thrd = NULL; - this->lock = NULL; +static inline void ?{}(FinishAction & this) { + this.action_code = No_Action; + this.thrd = NULL; + this.lock = NULL; } -static inline void ^?{}(FinishAction * this) {} +static inline void ^?{}(FinishAction & this) {} // Processor @@ -99,7 +99,7 @@ }; -void ?{}(processor * this); -void ?{}(processor * this, cluster * cltr); -void ^?{}(processor * this); +void ?{}(processor & this); +void ?{}(processor & this, cluster * cltr); +void ^?{}(processor & this); // Local Variables: // Index: src/libcfa/concurrency/kernel.c =================================================================== --- src/libcfa/concurrency/kernel.c (revision b3d413befb5307e20b7a838c4700508e2bbd8a46) +++ src/libcfa/concurrency/kernel.c (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -73,97 +73,97 @@ }; -void ?{}( current_stack_info_t * this ) { - CtxGet( this->ctx ); - this->base = this->ctx.FP; - this->storage = this->ctx.SP; +void ?{}( current_stack_info_t & this ) { + CtxGet( this.ctx ); + this.base = this.ctx.FP; + this.storage = this.ctx.SP; rlimit r; getrlimit( RLIMIT_STACK, &r); - this->size = r.rlim_cur; - - this->limit = (void *)(((intptr_t)this->base) - this->size); - this->context = &storage_mainThreadCtx; - this->top = this->base; -} - -void ?{}( coStack_t * this, current_stack_info_t * info) { - this->size = info->size; - this->storage = info->storage; - this->limit = info->limit; - this->base = info->base; - this->context = info->context; - this->top = info->top; - this->userStack = true; -} - -void ?{}( coroutine_desc * this, current_stack_info_t * info) { - (&this->stack){ info }; - this->name = "Main Thread"; - this->errno_ = 0; - this->state = Start; -} - -void ?{}( thread_desc * this, current_stack_info_t * info) { - (&this->cor){ info }; + this.size = r.rlim_cur; + + this.limit = (void *)(((intptr_t)this.base) - this.size); + this.context = &storage_mainThreadCtx; + this.top = this.base; +} + +void ?{}( coStack_t & this, current_stack_info_t * info) { + this.size = info->size; + this.storage = info->storage; + this.limit = info->limit; + this.base = info->base; + this.context = info->context; + this.top = info->top; + this.userStack = true; +} + +void ?{}( coroutine_desc & this, current_stack_info_t * info) { + (this.stack){ info }; + this.name = "Main Thread"; + this.errno_ = 0; + this.state = Start; +} + +void ?{}( thread_desc & this, current_stack_info_t * info) { + (this.cor){ info }; } //----------------------------------------------------------------------------- // Processor coroutine -void ?{}(processorCtx_t * this, processor * proc) { - (&this->__cor){ "Processor" }; - this->proc = proc; - proc->runner = this; -} - -void ?{}(processorCtx_t * this, processor * proc, current_stack_info_t * info) { - (&this->__cor){ info }; - this->proc = proc; - proc->runner = this; -} - -void ?{}(processor * this) { +void ?{}(processorCtx_t & this, processor * proc) { + (this.__cor){ "Processor" }; + this.proc = proc; + proc->runner = &this; +} + +void ?{}(processorCtx_t & this, processor * proc, current_stack_info_t * info) { + (this.__cor){ info }; + this.proc = proc; + proc->runner = &this; +} + +void ?{}(processor & this) { this{ mainCluster }; } -void ?{}(processor * this, cluster * cltr) { - this->cltr = cltr; - (&this->terminated){ 0 }; - this->do_terminate = false; - this->preemption_alarm = NULL; - this->pending_preemption = false; - - start( this ); -} - -void ?{}(processor * this, cluster * cltr, processorCtx_t * runner) { - this->cltr = cltr; - (&this->terminated){ 0 }; - this->do_terminate = false; - this->preemption_alarm = NULL; - this->pending_preemption = false; - this->kernel_thread = pthread_self(); - - this->runner = runner; - LIB_DEBUG_PRINT_SAFE("Kernel : constructing main processor context %p\n", runner); - runner{ this }; -} - -void ^?{}(processor * this) { - if( ! this->do_terminate ) { - LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", this); - this->do_terminate = true; - P( &this->terminated ); - pthread_join( this->kernel_thread, NULL ); - } -} - -void ?{}(cluster * this) { - ( &this->ready_queue ){}; - ( &this->ready_queue_lock ){}; - - this->preemption = default_preemption(); -} - -void ^?{}(cluster * this) { +void ?{}(processor & this, cluster * cltr) { + this.cltr = cltr; + (this.terminated){ 0 }; + this.do_terminate = false; + this.preemption_alarm = NULL; + this.pending_preemption = false; + + start( &this ); +} + +void ?{}(processor & this, cluster * cltr, processorCtx_t & runner) { + this.cltr = cltr; + (this.terminated){ 0 }; + this.do_terminate = false; + this.preemption_alarm = NULL; + this.pending_preemption = false; + this.kernel_thread = pthread_self(); + + this.runner = &runner; + LIB_DEBUG_PRINT_SAFE("Kernel : constructing main processor context %p\n", &runner); + runner{ &this }; +} + +void ^?{}(processor & this) { + if( ! this.do_terminate ) { + LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", &this); + this.do_terminate = true; + P( &this.terminated ); + pthread_join( this.kernel_thread, NULL ); + } +} + +void ?{}(cluster & this) { + ( this.ready_queue ){}; + ( this.ready_queue_lock ){}; + + this.preemption = default_preemption(); +} + +void ^?{}(cluster & this) { } @@ -173,6 +173,6 @@ //============================================================================================= //Main of the processor contexts -void main(processorCtx_t * runner) { - processor * this = runner->proc; +void main(processorCtx_t & runner) { + processor * this = runner.proc; LIB_DEBUG_PRINT_SAFE("Kernel : core %p starting\n", this); @@ -219,5 +219,5 @@ // from the processor coroutine to the target thread void runThread(processor * this, thread_desc * dst) { - coroutine_desc * proc_cor = get_coroutine(this->runner); + coroutine_desc * proc_cor = get_coroutine(*this->runner); coroutine_desc * thrd_cor = get_coroutine(dst); @@ -301,5 +301,5 @@ // appropriate stack. proc_cor_storage.__cor.state = Active; - main( &proc_cor_storage ); + main( proc_cor_storage ); proc_cor_storage.__cor.state = Halted; @@ -441,5 +441,5 @@ mainThread = (thread_desc *)&storage_mainThread; current_stack_info_t info; - mainThread{ &info }; + (*mainThread){ &info }; LIB_DEBUG_PRINT_SAFE("Kernel : Main thread ready\n"); @@ -447,5 +447,5 @@ // Initialize the main cluster mainCluster = (cluster *)&storage_mainCluster; - mainCluster{}; + (*mainCluster){}; LIB_DEBUG_PRINT_SAFE("Kernel : main cluster ready\n"); @@ -454,5 +454,5 @@ // (the coroutine that contains the processing control flow) mainProcessor = (processor *)&storage_mainProcessor; - mainProcessor{ mainCluster, (processorCtx_t *)&storage_mainProcessorCtx }; + (*mainProcessor){ mainCluster, *(processorCtx_t *)&storage_mainProcessorCtx }; //initialize the global state variables @@ -471,5 +471,5 @@ // context. Hence, the main thread does not begin through CtxInvokeThread, like all other threads. The trick here is that // mainThread is on the ready queue when this call is made. - resume( mainProcessor->runner ); + resume( *mainProcessor->runner ); @@ -499,5 +499,5 @@ // Destroy the main processor and its context in reverse order of construction // These were manually constructed so we need manually destroy them - ^(mainProcessor->runner){}; + ^(*mainProcessor->runner){}; ^(mainProcessor){}; @@ -567,8 +567,8 @@ //----------------------------------------------------------------------------- // Locks -void ?{}( spinlock * this ) { - this->lock = 0; -} -void ^?{}( spinlock * this ) { +void ?{}( spinlock & this ) { + this.lock = 0; +} +void ^?{}( spinlock & this ) { } @@ -604,10 +604,10 @@ } -void ?{}( semaphore * this, int count = 1 ) { - (&this->lock){}; - this->count = count; - (&this->waiting){}; -} -void ^?{}(semaphore * this) {} +void ?{}( semaphore & this, int count = 1 ) { + (this.lock){}; + this.count = count; + (this.waiting){}; +} +void ^?{}(semaphore & this) {} void P(semaphore * this) { @@ -643,7 +643,7 @@ //----------------------------------------------------------------------------- // Queues -void ?{}( __thread_queue_t * this ) { - this->head = NULL; - this->tail = &this->head; +void ?{}( __thread_queue_t & this ) { + this.head = NULL; + this.tail = &this.head; } @@ -666,6 +666,6 @@ } -void ?{}( __condition_stack_t * this ) { - this->top = NULL; +void ?{}( __condition_stack_t & this ) { + this.top = NULL; } Index: src/libcfa/concurrency/monitor =================================================================== --- src/libcfa/concurrency/monitor (revision b3d413befb5307e20b7a838c4700508e2bbd8a46) +++ src/libcfa/concurrency/monitor (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -22,7 +22,7 @@ #include "stdlib" -static inline void ?{}(monitor_desc * this) { - this->owner = NULL; - this->recursion = 0; +static inline void ?{}(monitor_desc & this) { + this.owner = NULL; + this.recursion = 0; } @@ -38,6 +38,6 @@ } -void ?{}( monitor_guard_t * this, monitor_desc ** m, int count ); -void ^?{}( monitor_guard_t * this ); +void ?{}( monitor_guard_t & this, monitor_desc ** m, int count ); +void ^?{}( monitor_guard_t & this ); //----------------------------------------------------------------------------- @@ -64,5 +64,5 @@ }; -void ?{}( __condition_blocked_queue_t * ); +void ?{}( __condition_blocked_queue_t & ); void append( __condition_blocked_queue_t *, __condition_node_t * ); __condition_node_t * pop_head( __condition_blocked_queue_t * ); @@ -74,11 +74,11 @@ }; -static inline void ?{}( condition * this ) { - this->monitors = NULL; - this->monitor_count = 0; +static inline void ?{}( condition & this ) { + this.monitors = NULL; + this.monitor_count = 0; } -static inline void ^?{}( condition * this ) { - free( this->monitors ); +static inline void ^?{}( condition & this ) { + free( this.monitors ); } Index: src/libcfa/concurrency/monitor.c =================================================================== --- src/libcfa/concurrency/monitor.c (revision b3d413befb5307e20b7a838c4700508e2bbd8a46) +++ src/libcfa/concurrency/monitor.c (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -139,12 +139,12 @@ } -void ?{}( monitor_guard_t * this, monitor_desc ** m, int count ) { - this->m = m; - this->count = count; - qsort(this->m, count); - enter( this->m, this->count ); - - this->prev_mntrs = this_thread->current_monitors; - this->prev_count = this_thread->current_monitor_count; +void ?{}( monitor_guard_t & this, monitor_desc ** m, int count ) { + this.m = m; + this.count = count; + qsort(this.m, count); + enter( this.m, this.count ); + + this.prev_mntrs = this_thread->current_monitors; + this.prev_count = this_thread->current_monitor_count; this_thread->current_monitors = m; @@ -152,30 +152,30 @@ } -void ^?{}( monitor_guard_t * this ) { - leave( this->m, this->count ); - - this_thread->current_monitors = this->prev_mntrs; - this_thread->current_monitor_count = this->prev_count; -} - -void ?{}(__condition_node_t * this, thread_desc * waiting_thread, unsigned short count, uintptr_t user_info ) { - this->waiting_thread = waiting_thread; - this->count = count; - this->next = NULL; - this->user_info = user_info; -} - -void ?{}(__condition_criterion_t * this ) { - this->ready = false; - this->target = NULL; - this->owner = NULL; - this->next = NULL; -} - -void ?{}(__condition_criterion_t * this, monitor_desc * target, __condition_node_t * owner ) { - this->ready = false; - this->target = target; - this->owner = owner; - this->next = NULL; +void ^?{}( monitor_guard_t & this ) { + leave( this.m, this.count ); + + this_thread->current_monitors = this.prev_mntrs; + this_thread->current_monitor_count = this.prev_count; +} + +void ?{}(__condition_node_t & this, thread_desc * waiting_thread, unsigned short count, uintptr_t user_info ) { + this.waiting_thread = waiting_thread; + this.count = count; + this.next = NULL; + this.user_info = user_info; +} + +void ?{}(__condition_criterion_t & this ) { + this.ready = false; + this.target = NULL; + this.owner = NULL; + this.next = NULL; +} + +void ?{}(__condition_criterion_t & this, monitor_desc * target, __condition_node_t * owner ) { + this.ready = false; + this.target = target; + this.owner = owner; + this.next = NULL; } @@ -202,5 +202,5 @@ __condition_criterion_t criteria[count]; for(int i = 0; i < count; i++) { - (&criteria[i]){ this->monitors[i], &waiter }; + (criteria[i]){ this->monitors[i], &waiter }; // LIB_DEBUG_PRINT_SAFE( "Criterion %p\n", &criteria[i] ); } @@ -314,5 +314,5 @@ __condition_criterion_t criteria[count]; for(int i = 0; i < count; i++) { - (&criteria[i]){ this->monitors[i], &waiter }; + (criteria[i]){ this->monitors[i], &waiter }; // LIB_DEBUG_PRINT_SAFE( "Criterion %p\n", &criteria[i] ); push( &criteria[i].target->signal_stack, &criteria[i] ); @@ -505,7 +505,7 @@ } -void ?{}( __condition_blocked_queue_t * this ) { - this->head = NULL; - this->tail = &this->head; +void ?{}( __condition_blocked_queue_t & this ) { + this.head = NULL; + this.tail = &this.head; } Index: src/libcfa/concurrency/preemption.c =================================================================== --- src/libcfa/concurrency/preemption.c (revision b3d413befb5307e20b7a838c4700508e2bbd8a46) +++ src/libcfa/concurrency/preemption.c (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -71,7 +71,7 @@ static pthread_t alarm_thread; // pthread handle to alarm thread -void ?{}(event_kernel_t * this) { - (&this->alarms){}; - (&this->lock){}; +void ?{}(event_kernel_t & this) { + (this.alarms){}; + (this.lock){}; } @@ -240,5 +240,5 @@ // Initialize the event kernel event_kernel = (event_kernel_t *)&storage_event_kernel; - event_kernel{}; + (*event_kernel){}; // Setup proper signal handlers @@ -276,16 +276,16 @@ // Raii ctor/dtor for the preemption_scope // Used by thread to control when they want to receive preemption signals -void ?{}( preemption_scope * this, processor * proc ) { - (&this->alarm){ proc, zero_time, zero_time }; - this->proc = proc; - this->proc->preemption_alarm = &this->alarm; - - update_preemption( this->proc, from_us(this->proc->cltr->preemption) ); -} - -void ^?{}( preemption_scope * this ) { +void ?{}( preemption_scope & this, processor * proc ) { + (this.alarm){ proc, zero_time, zero_time }; + this.proc = proc; + this.proc->preemption_alarm = &this.alarm; + + update_preemption( this.proc, from_us(this.proc->cltr->preemption) ); +} + +void ^?{}( preemption_scope & this ) { disable_interrupts(); - update_preemption( this->proc, zero_time ); + update_preemption( this.proc, zero_time ); } Index: src/libcfa/concurrency/preemption.h =================================================================== --- src/libcfa/concurrency/preemption.h (revision b3d413befb5307e20b7a838c4700508e2bbd8a46) +++ src/libcfa/concurrency/preemption.h (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -30,6 +30,6 @@ }; -void ?{}( preemption_scope * this, processor * proc ); -void ^?{}( preemption_scope * this ); +void ?{}( preemption_scope & this, processor * proc ); +void ^?{}( preemption_scope & this ); // Local Variables: // Index: src/libcfa/concurrency/thread =================================================================== --- src/libcfa/concurrency/thread (revision b3d413befb5307e20b7a838c4700508e2bbd8a46) +++ src/libcfa/concurrency/thread (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -27,18 +27,18 @@ // Anything that is resumed is a coroutine. trait is_thread(dtype T) { - void ^?{}(T* mutex this); - void main(T* this); - thread_desc* get_thread(T* this); + void ^?{}(T& mutex this); + void main(T& this); + thread_desc* get_thread(T& this); }; -#define DECL_THREAD(X) thread_desc* get_thread(X* this) { return &this->__thrd; } void main(X* this) +#define DECL_THREAD(X) thread_desc* get_thread(X& this) { return &this.__thrd; } void main(X& this) forall( dtype T | is_thread(T) ) -static inline coroutine_desc* get_coroutine(T* this) { +static inline coroutine_desc* get_coroutine(T & this) { return &get_thread(this)->cor; } forall( dtype T | is_thread(T) ) -static inline monitor_desc* get_monitor(T * this) { +static inline monitor_desc* get_monitor(T & this) { return &get_thread(this)->mon; } @@ -55,10 +55,10 @@ forall( dtype T | is_thread(T) ) -void __thrd_start( T* this ); +void __thrd_start( T & this ); //----------------------------------------------------------------------------- // Ctors and dtors -void ?{}(thread_desc* this); -void ^?{}(thread_desc* this); +void ?{}(thread_desc& this); +void ^?{}(thread_desc& this); //----------------------------------------------------------------------------- @@ -70,12 +70,12 @@ }; -forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T*); } ) -void ?{}( scoped(T)* this ); +forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T&); } ) +void ?{}( scoped(T)& this ); -forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T*, P); } ) -void ?{}( scoped(T)* this, P params ); +forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T&, P); } ) +void ?{}( scoped(T)& this, P params ); forall( dtype T | sized(T) | is_thread(T) ) -void ^?{}( scoped(T)* this ); +void ^?{}( scoped(T)& this ); void yield(); Index: src/libcfa/concurrency/thread.c =================================================================== --- src/libcfa/concurrency/thread.c (revision b3d413befb5307e20b7a838c4700508e2bbd8a46) +++ src/libcfa/concurrency/thread.c (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -32,34 +32,34 @@ // Thread ctors and dtors -void ?{}(thread_desc* this) { - (&this->cor){}; - this->cor.name = "Anonymous Coroutine"; - this->mon.owner = this; - this->mon.recursion = 1; - this->next = NULL; +void ?{}(thread_desc& this) { + (this.cor){}; + this.cor.name = "Anonymous Coroutine"; + this.mon.owner = &this; + this.mon.recursion = 1; + this.next = NULL; - this->current_monitors = &this->mon; - this->current_monitor_count = 1; + this.current_monitors = &this.mon; + this.current_monitor_count = 1; } -void ^?{}(thread_desc* this) { - ^(&this->cor){}; +void ^?{}(thread_desc& this) { + ^(this.cor){}; } -forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T*); } ) -void ?{}( scoped(T)* this ) { - (&this->handle){}; - __thrd_start(&this->handle); +forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T&); } ) +void ?{}( scoped(T)& this ) { + (this.handle){}; + __thrd_start(this.handle); } -forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T*, P); } ) -void ?{}( scoped(T)* this, P params ) { - (&this->handle){ params }; - __thrd_start(&this->handle); +forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T&, P); } ) +void ?{}( scoped(T)& this, P params ) { + (this.handle){ params }; + __thrd_start(this.handle); } forall( dtype T | sized(T) | is_thread(T) ) -void ^?{}( scoped(T)* this ) { - ^(&this->handle){}; +void ^?{}( scoped(T)& this ) { + ^(this.handle){}; } @@ -67,5 +67,5 @@ // Starting and stopping threads forall( dtype T | is_thread(T) ) -void __thrd_start( T* this ) { +void __thrd_start( T& this ) { coroutine_desc* thrd_c = get_coroutine(this); thread_desc* thrd_h = get_thread (this); @@ -77,5 +77,5 @@ create_stack(&thrd_c->stack, thrd_c->stack.size); this_coroutine = thrd_c; - CtxStart(this, CtxInvokeThread); + CtxStart(&this, CtxInvokeThread); assert( thrd_c->last->stack.context ); CtxSwitch( thrd_c->last->stack.context, thrd_c->stack.context ); Index: src/libcfa/containers/maybe =================================================================== --- src/libcfa/containers/maybe (revision b3d413befb5307e20b7a838c4700508e2bbd8a46) +++ src/libcfa/containers/maybe (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -27,17 +27,17 @@ forall(otype T) -void ?{}(maybe(T) * this); +void ?{}(maybe(T) & this); forall(otype T) -void ?{}(maybe(T) * this, T value); +void ?{}(maybe(T) & this, T value); forall(otype T) -void ?{}(maybe(T) * this, maybe(T) other); +void ?{}(maybe(T) & this, maybe(T) other); forall(otype T) -void ^?{}(maybe(T) * this); +void ^?{}(maybe(T) & this); forall(otype T) -maybe(T) ?=?(maybe(T) * this, maybe(T) other); +maybe(T) ?=?(maybe(T) & this, maybe(T) other); forall(otype T) Index: src/libcfa/containers/maybe.c =================================================================== --- src/libcfa/containers/maybe.c (revision b3d413befb5307e20b7a838c4700508e2bbd8a46) +++ src/libcfa/containers/maybe.c (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -19,39 +19,40 @@ forall(otype T) -void ?{}(maybe(T) * this) { - this->has_value = false; +void ?{}(maybe(T) & this) { + this.has_value = false; } forall(otype T) -void ?{}(maybe(T) * this, T value) { - this->has_value = true; - (&this->value){value}; +void ?{}(maybe(T) & this, T value) { + this.has_value = true; + (this.value){value}; } forall(otype T) -void ?{}(maybe(T) * this, maybe(T) other) { - this->has_value = other.has_value; +void ?{}(maybe(T) & this, maybe(T) other) { + this.has_value = other.has_value; if (other.has_value) { - (&this->value){other.value}; + (this.value){other.value}; } } forall(otype T) -maybe(T) ?=?(maybe(T) * this, maybe(T) that) { - if (this->has_value & that.has_value) { - this->value = that.value; - } else if (this->has_value) { - ^(&this->value){}; - this->has_value = false; +maybe(T) ?=?(maybe(T) & this, maybe(T) that) { + if (this.has_value & that.has_value) { + this.value = that.value; + } else if (this.has_value) { + ^(this.value){}; + this.has_value = false; } else if (that.has_value) { - this->has_value = true; - (&this->value){that.value}; + this.has_value = true; + (this.value){that.value}; } + return this; } forall(otype T) -void ^?{}(maybe(T) * this) { - if (this->has_value) { - ^(&this->value){}; +void ^?{}(maybe(T) & this) { + if (this.has_value) { + ^(this.value){}; } } @@ -89,5 +90,5 @@ } else { this->has_value = true; - (&this->value){value}; + (this->value){value}; } } @@ -97,5 +98,5 @@ if (this->has_value) { this->has_value = false; - ^(&this->value){}; + ^(this->value){}; } } Index: src/libcfa/containers/result =================================================================== --- src/libcfa/containers/result (revision b3d413befb5307e20b7a838c4700508e2bbd8a46) +++ src/libcfa/containers/result (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -33,20 +33,20 @@ forall(otype T, otype E) -void ?{}(result(T, E) * this); +void ?{}(result(T, E) & this); forall(otype T, otype E) -void ?{}(result(T, E) * this, one_t, T value); +void ?{}(result(T, E) & this, one_t, T value); forall(otype T, otype E) -void ?{}(result(T, E) * this, zero_t, E error); +void ?{}(result(T, E) & this, zero_t, E error); forall(otype T, otype E) -void ?{}(result(T, E) * this, result(T, E) other); +void ?{}(result(T, E) & this, result(T, E) other); forall(otype T, otype E) -void ^?{}(result(T, E) * this); +void ^?{}(result(T, E) & this); forall(otype T, otype E) -result(T, E) ?=?(result(T, E) * this, result(T, E) other); +result(T, E) ?=?(result(T, E) & this, result(T, E) other); forall(otype T, otype E) Index: src/libcfa/containers/result.c =================================================================== --- src/libcfa/containers/result.c (revision b3d413befb5307e20b7a838c4700508e2bbd8a46) +++ src/libcfa/containers/result.c (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -19,54 +19,54 @@ forall(otype T, otype E) -void ?{}(result(T, E) * this) { - this->has_value = false; - (&this->error){}; +void ?{}(result(T, E) & this) { + this.has_value = false; + (this.error){}; } forall(otype T, otype E) -void ?{}(result(T, E) * this, one_t, T value) { - this->has_value = true; - (&this->value){value}; +void ?{}(result(T, E) & this, one_t, T value) { + this.has_value = true; + (this.value){value}; } forall(otype T, otype E) -void ?{}(result(T, E) * this, zero_t, E error) { - this->has_value = false; - (&this->error){error}; +void ?{}(result(T, E) & this, zero_t, E error) { + this.has_value = false; + (this.error){error}; } forall(otype T, otype E) -void ?{}(result(T, E) * this, result(T, E) other) { - this->has_value = other.has_value; +void ?{}(result(T, E) & this, result(T, E) other) { + this.has_value = other.has_value; if (other.has_value) { - (&this->value){other.value}; + (this.value){other.value}; } else { - (&this->error){other.error}; + (this.error){other.error}; } } forall(otype T, otype E) -result(T, E) ?=?(result(T, E) * this, result(T, E) that) { - if (this->has_value & that.has_value) { - this->value = that.value; - } else if (this->has_value) { - ^(&this->value){}; - this->has_value = false; - (&this->error){that.error}; +result(T, E) ?=?(result(T, E) & this, result(T, E) that) { + if (this.has_value & that.has_value) { + this.value = that.value; + } else if (this.has_value) { + ^(this.value){}; + this.has_value = false; + (this.error){that.error}; } else if (that.has_value) { - ^(&this->error){}; - this->has_value = true; - (&this->value){that.value}; + ^(this.error){}; + this.has_value = true; + (this.value){that.value}; } else { - this->error = that.error; + this.error = that.error; } } forall(otype T, otype E) -void ^?{}(result(T, E) * this) { - if (this->has_value) { - ^(&this->value){}; +void ^?{}(result(T, E) & this) { + if (this.has_value) { + ^(this.value){}; } else { - ^(&this->error){}; + ^(this.error){}; } } @@ -109,7 +109,7 @@ this->value = value; } else { - ^(&this->error){}; + ^(this->error){}; this->has_value = true; - (&this->value){value}; + (this->value){value}; } } @@ -118,7 +118,7 @@ void set_error(result(T, E) * this, E error) { if (this->has_value) { - ^(&this->value){}; + ^(this->value){}; this->has_value = false; - (&this->error){error}; + (this->error){error}; } else { this->error = error; Index: src/libcfa/containers/vector =================================================================== --- src/libcfa/containers/vector (revision b3d413befb5307e20b7a838c4700508e2bbd8a46) +++ src/libcfa/containers/vector (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -30,14 +30,14 @@ forall(otype T) -void ?{}(heap_allocator(T)* this); +void ?{}(heap_allocator(T)& this); forall(otype T) -void ?{}(heap_allocator(T)* this, heap_allocator(T) rhs); +void ?{}(heap_allocator(T)& this, heap_allocator(T) rhs); forall(otype T) -heap_allocator(T) ?=?(heap_allocator(T)* this, heap_allocator(T) rhs); +heap_allocator(T) ?=?(heap_allocator(T)& this, heap_allocator(T) rhs); forall(otype T) -void ^?{}(heap_allocator(T)* this); +void ^?{}(heap_allocator(T)& this); forall(otype T) @@ -64,14 +64,14 @@ //Initialization forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) -void ?{}(vector(T, allocator_t)* this); +void ?{}(vector(T, allocator_t)& this); forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) -void ?{}(vector(T, allocator_t)* this, vector(T, allocator_t) rhs); +void ?{}(vector(T, allocator_t)& this, vector(T, allocator_t) rhs); forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) -vector(T, allocator_t) ?=?(vector(T, allocator_t)* this, vector(T, allocator_t) rhs); +vector(T, allocator_t) ?=?(vector(T, allocator_t)& this, vector(T, allocator_t) rhs); forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) -void ^?{}(vector(T, allocator_t)* this); +void ^?{}(vector(T, allocator_t)& this); forall(otype T, otype allocator_t = heap_allocator(T) | allocator_c(T, allocator_t)) Index: src/libcfa/containers/vector.c =================================================================== --- src/libcfa/containers/vector.c (revision b3d413befb5307e20b7a838c4700508e2bbd8a46) +++ src/libcfa/containers/vector.c (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -24,15 +24,15 @@ //Initialization forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) -void ?{}(vector(T, allocator_t)* this) +void ?{}(vector(T, allocator_t)& this) { - (&this->storage){}; - this->size = 0; + (this.storage){}; + this.size = 0; } forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) -void ?{}(vector(T, allocator_t)* this, vector(T, allocator_t) rhs) +void ?{}(vector(T, allocator_t)& this, vector(T, allocator_t) rhs) { - (&this->storage){ rhs.storage }; - copy_internal(this, &rhs); + (this.storage){ rhs.storage }; + copy_internal(&this, &rhs); } @@ -46,8 +46,8 @@ forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) -void ^?{}(vector(T, allocator_t)* this) +void ^?{}(vector(T, allocator_t)& this) { - clear(this); - ^(&this->storage){}; + clear(&this); + ^(this.storage){}; } @@ -66,5 +66,5 @@ { this->size--; - ^(&data(&this->storage)[this->size]){}; + ^(data(&this->storage)[this->size]){}; } @@ -74,5 +74,5 @@ for(size_t i = 0; i < this->size; i++) { - ^(&data(&this->storage)[this->size]){}; + ^(data(&this->storage)[this->size]){}; } this->size = 0; @@ -87,5 +87,5 @@ this->size = other->size; for(size_t i = 0; i < this->size; i++) { - (&data(&this->storage)[this->size]){ data(&other->storage)[other->size] }; + (data(&this->storage)[this->size]){ data(&other->storage)[other->size] }; } } @@ -94,29 +94,29 @@ //Allocator forall(otype T) -void ?{}(heap_allocator(T)* this) +void ?{}(heap_allocator(T)& this) { - this->storage = 0; - this->capacity = 0; + this.storage = 0; + this.capacity = 0; } forall(otype T) -void ?{}(heap_allocator(T)* this, heap_allocator(T) rhs) +void ?{}(heap_allocator(T)& this, heap_allocator(T) rhs) { - this->capacity = rhs.capacity; - this->storage = (T*)realloc((void*)this->storage, this->capacity * sizeof(T)); + this.capacity = rhs.capacity; + this.storage = (T*)realloc((void*)this.storage, this.capacity * sizeof(T)); } forall(otype T) -heap_allocator(T) ?=?(heap_allocator(T)* this, heap_allocator(T) rhs) +heap_allocator(T) ?=?(heap_allocator(T)& this, heap_allocator(T) rhs) { - this->capacity = rhs.capacity; - this->storage = (T*)realloc((void*)this->storage, this->capacity * sizeof(T)); - return *this; + this.capacity = rhs.capacity; + this.storage = (T*)realloc((void*)this.storage, this.capacity * sizeof(T)); + return this; } forall(otype T) -void ^?{}(heap_allocator(T)* this) +void ^?{}(heap_allocator(T)& this) { - free(this->storage); + free(this.storage); } Index: src/libcfa/fstream =================================================================== --- src/libcfa/fstream (revision b3d413befb5307e20b7a838c4700508e2bbd8a46) +++ src/libcfa/fstream (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -56,5 +56,5 @@ int fmt( ofstream *, const char fmt[], ... ); -void ?{}( ofstream * ); +void ?{}( ofstream & ); extern ofstream * sout, * serr; Index: src/libcfa/fstream.c =================================================================== --- src/libcfa/fstream.c (revision b3d413befb5307e20b7a838c4700508e2bbd8a46) +++ src/libcfa/fstream.c (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -27,11 +27,11 @@ #define IO_MSG "I/O error: " -void ?{}( ofstream * this, void * file, _Bool sepDefault, _Bool sepOnOff, const char * separator, const char * tupleSeparator ) { - this->file = file; - this->sepDefault = sepDefault; - this->sepOnOff = sepOnOff; - sepSet( this, separator ); - sepSetCur( this, sepGet( this ) ); - sepSetTuple( this, tupleSeparator ); +void ?{}( ofstream & this, void * file, _Bool sepDefault, _Bool sepOnOff, const char * separator, const char * tupleSeparator ) { + this.file = file; + this.sepDefault = sepDefault; + this.sepOnOff = sepOnOff; + sepSet( &this, separator ); + sepSetCur( &this, sepGet( &this ) ); + sepSetTuple( &this, tupleSeparator ); } @@ -92,5 +92,5 @@ exit( EXIT_FAILURE ); } // if - ?{}( os, file, true, false, " ", ", " ); + ?{}( *os, file, true, false, " ", ", " ); } // open Index: src/libcfa/gmp =================================================================== --- src/libcfa/gmp (revision b3d413befb5307e20b7a838c4700508e2bbd8a46) +++ src/libcfa/gmp (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -1,10 +1,10 @@ -// +// // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo // // The contents of this file are covered under the licence agreement in the // file "LICENCE" distributed with Cforall. -// -// gmp -- -// +// +// gmp -- +// // Author : Peter A. Buhr // Created On : Tue Apr 19 08:43:43 2016 @@ -12,5 +12,5 @@ // Last Modified On : Fri Jul 7 09:33:20 2017 // Update Count : 15 -// +// // https://gmplib.org/gmp-man-6.1.1.pdf @@ -24,27 +24,27 @@ // constructor -static inline void ?{}( Int * this ) { mpz_init( this->mpz ); } -static inline void ?{}( Int * this, Int init ) { mpz_init_set( this->mpz, init.mpz ); } -static inline void ?{}( Int * this, zero_t ) { mpz_init_set_si( this->mpz, 0 ); } -static inline void ?{}( Int * this, one_t ) { mpz_init_set_si( this->mpz, 1 ); } -static inline void ?{}( Int * this, signed long int init ) { mpz_init_set_si( this->mpz, init ); } -static inline void ?{}( Int * this, unsigned long int init ) { mpz_init_set_ui( this->mpz, init ); } -static inline void ?{}( Int * this, const char * val ) { if ( mpz_init_set_str( this->mpz, val, 0 ) ) abort(); } -static inline void ^?{}( Int * this ) { mpz_clear( this->mpz ); } +static inline void ?{}( Int & this ) { mpz_init( this.mpz ); } +static inline void ?{}( Int & this, Int init ) { mpz_init_set( this.mpz, init.mpz ); } +static inline void ?{}( Int & this, zero_t ) { mpz_init_set_si( this.mpz, 0 ); } +static inline void ?{}( Int & this, one_t ) { mpz_init_set_si( this.mpz, 1 ); } +static inline void ?{}( Int & this, signed long int init ) { mpz_init_set_si( this.mpz, init ); } +static inline void ?{}( Int & this, unsigned long int init ) { mpz_init_set_ui( this.mpz, init ); } +static inline void ?{}( Int & this, const char * val ) { if ( mpz_init_set_str( this.mpz, val, 0 ) ) abort(); } +static inline void ^?{}( Int & this ) { mpz_clear( this.mpz ); } // assignment -static inline Int ?=?( Int * lhs, Int rhs ) { mpz_set( lhs->mpz, rhs.mpz ); return *lhs; } -static inline Int ?=?( Int * lhs, long int rhs ) { mpz_set_si( lhs->mpz, rhs ); return *lhs; } -static inline Int ?=?( Int * lhs, unsigned long int rhs ) { mpz_set_ui( lhs->mpz, rhs ); return *lhs; } -static inline Int ?=?( Int * lhs, const char * rhs ) { if ( mpz_set_str( lhs->mpz, rhs, 0 ) ) { printf( "invalid string conversion\n" ); abort(); } return *lhs; } - -static inline char ?=?( char * lhs, Int rhs ) { char val = mpz_get_si( rhs.mpz ); *lhs = val; return val; } -static inline short int ?=?( short int * lhs, Int rhs ) { short int val = mpz_get_si( rhs.mpz ); *lhs = val; return val; } -static inline int ?=?( int * lhs, Int rhs ) { int val = mpz_get_si( rhs.mpz ); *lhs = val; return val; } -static inline long int ?=?( long int * lhs, Int rhs ) { long int val = mpz_get_si( rhs.mpz ); *lhs = val; return val; } -static inline unsigned char ?=?( unsigned char * lhs, Int rhs ) { unsigned char val = mpz_get_ui( rhs.mpz ); *lhs = val; return val; } -static inline unsigned short int ?=?( unsigned short int * lhs, Int rhs ) { unsigned short int val = mpz_get_ui( rhs.mpz ); *lhs = val; return val; } -static inline unsigned int ?=?( unsigned int * lhs, Int rhs ) { unsigned int val = mpz_get_ui( rhs.mpz ); *lhs = val; return val; } -static inline unsigned long int ?=?( unsigned long int * lhs, Int rhs ) { unsigned long int val = mpz_get_ui( rhs.mpz ); *lhs = val; return val; } +static inline Int ?=?( Int & lhs, Int rhs ) { mpz_set( lhs.mpz, rhs.mpz ); return lhs; } +static inline Int ?=?( Int & lhs, long int rhs ) { mpz_set_si( lhs.mpz, rhs ); return lhs; } +static inline Int ?=?( Int & lhs, unsigned long int rhs ) { mpz_set_ui( lhs.mpz, rhs ); return lhs; } +static inline Int ?=?( Int & lhs, const char * rhs ) { if ( mpz_set_str( lhs.mpz, rhs, 0 ) ) { printf( "invalid string conversion\n" ); abort(); } return lhs; } + +static inline char ?=?( char & lhs, Int rhs ) { char val = mpz_get_si( rhs.mpz ); lhs = val; return lhs; } +static inline short int ?=?( short int & lhs, Int rhs ) { short int val = mpz_get_si( rhs.mpz ); lhs = val; return lhs; } +static inline int ?=?( int & lhs, Int rhs ) { int val = mpz_get_si( rhs.mpz ); lhs = val; return lhs; } +static inline long int ?=?( long int & lhs, Int rhs ) { long int val = mpz_get_si( rhs.mpz ); lhs = val; return lhs; } +static inline unsigned char ?=?( unsigned char & lhs, Int rhs ) { unsigned char val = mpz_get_ui( rhs.mpz ); lhs = val; return lhs; } +static inline unsigned short int ?=?( unsigned short int & lhs, Int rhs ) { unsigned short int val = mpz_get_ui( rhs.mpz ); lhs = val; return lhs; } +static inline unsigned int ?=?( unsigned int & lhs, Int rhs ) { unsigned int val = mpz_get_ui( rhs.mpz ); lhs = val; return lhs; } +static inline unsigned long int ?=?( unsigned long int & lhs, Int rhs ) { unsigned long int val = mpz_get_ui( rhs.mpz ); lhs = val; return lhs; } // conversions @@ -99,5 +99,5 @@ static inline Int ?&?( Int oper1, unsigned long int oper2 ) { Int conjunction, temp; mpz_set_ui( temp.mpz, oper2 ); mpz_and( conjunction.mpz, oper1.mpz, temp.mpz ); return conjunction; } static inline Int ?&?( unsigned long int oper1, Int oper2 ) { Int conjunction, temp; mpz_set_ui( temp.mpz, oper1 ); mpz_and( conjunction.mpz, temp.mpz, oper2.mpz ); return conjunction; } -static inline Int ?&=?( Int * lhs, Int rhs ) { return *lhs = *lhs & rhs; } +static inline Int ?&=?( Int & lhs, Int rhs ) { return lhs = lhs & rhs; } static inline Int ?|?( Int oper1, Int oper2 ) { Int disjunction; mpz_ior( disjunction.mpz, oper1.mpz, oper2.mpz ); return disjunction; } @@ -106,5 +106,5 @@ static inline Int ?|?( Int oper1, unsigned long int oper2 ) { Int disjunction, temp; mpz_set_ui( temp.mpz, oper2 ); mpz_ior( disjunction.mpz, oper1.mpz, temp.mpz ); return disjunction; } static inline Int ?|?( unsigned long int oper1, Int oper2 ) { Int disjunction, temp; mpz_set_ui( temp.mpz, oper1 ); mpz_ior( disjunction.mpz, temp.mpz, oper2.mpz ); return disjunction; } -static inline Int ?|=?( Int * lhs, Int rhs ) { return *lhs = *lhs | rhs; } +static inline Int ?|=?( Int & lhs, Int rhs ) { return lhs = lhs | rhs; } static inline Int ?^?( Int oper1, Int oper2 ) { Int disjunction; mpz_xor( disjunction.mpz, oper1.mpz, oper2.mpz ); return disjunction; } @@ -113,5 +113,5 @@ static inline Int ?^?( Int oper1, unsigned long int oper2 ) { Int disjunction, temp; mpz_set_ui( temp.mpz, oper2 ); mpz_ior( disjunction.mpz, oper1.mpz, temp.mpz ); return disjunction; } static inline Int ?^?( unsigned long int oper1, Int oper2 ) { Int disjunction, temp; mpz_set_ui( temp.mpz, oper1 ); mpz_ior( disjunction.mpz, temp.mpz, oper2.mpz ); return disjunction; } -static inline Int ?^=?( Int * lhs, Int rhs ) { return *lhs = *lhs ^ rhs; } +static inline Int ?^=?( Int & lhs, Int rhs ) { return lhs = lhs ^ rhs; } static inline Int ?+?( Int addend1, Int addend2 ) { Int sum; mpz_add( sum.mpz, addend1.mpz, addend2.mpz ); return sum; } @@ -120,9 +120,9 @@ static inline Int ?+?( Int addend1, unsigned long int addend2 ) { Int sum; mpz_add_ui( sum.mpz, addend1.mpz, addend2 ); return sum; } static inline Int ?+?( unsigned long int addend2, Int addend1 ) { Int sum; mpz_add_ui( sum.mpz, addend1.mpz, addend2 ); return sum; } -static inline Int ?+=?( Int * lhs, Int rhs ) { return *lhs = *lhs + rhs; } -static inline Int ?+=?( Int * lhs, long int rhs ) { return *lhs = *lhs + rhs; } -static inline Int ?+=?( Int * lhs, unsigned long int rhs ) { return *lhs = *lhs + rhs; } -static inline Int ++?( Int * lhs ) { return *lhs += 1; } -static inline Int ?++( Int * lhs ) { Int ret = *lhs; *lhs += 1; return ret; } +static inline Int ?+=?( Int & lhs, Int rhs ) { return lhs = lhs + rhs; } +static inline Int ?+=?( Int & lhs, long int rhs ) { return lhs = lhs + rhs; } +static inline Int ?+=?( Int & lhs, unsigned long int rhs ) { return lhs = lhs + rhs; } +static inline Int ++?( Int & lhs ) { return lhs += 1; } +static inline Int ?++( Int & lhs ) { Int ret = lhs; lhs += 1; return ret; } static inline Int ?-?( Int minuend, Int subtrahend ) { Int diff; mpz_sub( diff.mpz, minuend.mpz, subtrahend.mpz ); return diff; } @@ -131,9 +131,9 @@ static inline Int ?-?( Int minuend, unsigned long int subtrahend ) { Int diff; mpz_sub_ui( diff.mpz, minuend.mpz, subtrahend ); return diff; } static inline Int ?-?( unsigned long int minuend, Int subtrahend ) { Int diff; mpz_ui_sub( diff.mpz, minuend, subtrahend.mpz ); return diff; } -static inline Int ?-=?( Int * lhs, Int rhs ) { return *lhs = *lhs - rhs; } -static inline Int ?-=?( Int * lhs, long int rhs ) { return *lhs = *lhs - rhs; } -static inline Int ?-=?( Int * lhs, unsigned long int rhs ) { return *lhs = *lhs - rhs; } -static inline Int --?( Int * lhs ) { return *lhs -= 1; } -static inline Int ?--( Int * lhs ) { Int ret = *lhs; *lhs -= 1; return ret; } +static inline Int ?-=?( Int & lhs, Int rhs ) { return lhs = lhs - rhs; } +static inline Int ?-=?( Int & lhs, long int rhs ) { return lhs = lhs - rhs; } +static inline Int ?-=?( Int & lhs, unsigned long int rhs ) { return lhs = lhs - rhs; } +static inline Int --?( Int & lhs ) { return lhs -= 1; } +static inline Int ?--( Int & lhs ) { Int ret = lhs; lhs -= 1; return ret; } static inline Int ?*?( Int multiplicator, Int multiplicand ) { Int product; mpz_mul( product.mpz, multiplicator.mpz, multiplicand.mpz ); return product; } @@ -142,7 +142,7 @@ static inline Int ?*?( Int multiplicator, unsigned long int multiplicand ) { Int product; mpz_mul_ui( product.mpz, multiplicator.mpz, multiplicand ); return product; } static inline Int ?*?( unsigned long int multiplicand, Int multiplicator ) { Int product; mpz_mul_ui( product.mpz, multiplicator.mpz, multiplicand ); return product; } -static inline Int ?*=?( Int * lhs, Int rhs ) { return *lhs = *lhs * rhs; } -static inline Int ?*=?( Int * lhs, long int rhs ) { return *lhs = *lhs * rhs; } -static inline Int ?*=?( Int * lhs, unsigned long int rhs ) { return *lhs = *lhs * rhs; } +static inline Int ?*=?( Int & lhs, Int rhs ) { return lhs = lhs * rhs; } +static inline Int ?*=?( Int & lhs, long int rhs ) { return lhs = lhs * rhs; } +static inline Int ?*=?( Int & lhs, unsigned long int rhs ) { return lhs = lhs * rhs; } // some code for operators "/" and "%" taken from g++ gmpxx.h @@ -187,7 +187,7 @@ return quotient; } // ?/? -static inline Int ?/=?( Int * lhs, Int rhs ) { return *lhs = *lhs / rhs; } -static inline Int ?/=?( Int * lhs, long int rhs ) { return *lhs = *lhs / rhs; } -static inline Int ?/=?( Int * lhs, unsigned long int rhs ) { return *lhs = *lhs / rhs; } +static inline Int ?/=?( Int & lhs, Int rhs ) { return lhs = lhs / rhs; } +static inline Int ?/=?( Int & lhs, long int rhs ) { return lhs = lhs / rhs; } +static inline Int ?/=?( Int & lhs, unsigned long int rhs ) { return lhs = lhs / rhs; } static inline [ Int, Int ] div( Int dividend, Int divisor ) { Int quotient, remainder; mpz_fdiv_qr( quotient.mpz, remainder.mpz, dividend.mpz, divisor.mpz ); return [ quotient, remainder ]; } @@ -228,12 +228,12 @@ return remainder; } // ?%? -static inline Int ?%=?( Int * lhs, Int rhs ) { return *lhs = *lhs % rhs; } -static inline Int ?%=?( Int * lhs, long int rhs ) { return *lhs = *lhs % rhs; } -static inline Int ?%=?( Int * lhs, unsigned long int rhs ) { return *lhs = *lhs % rhs; } +static inline Int ?%=?( Int & lhs, Int rhs ) { return lhs = lhs % rhs; } +static inline Int ?%=?( Int & lhs, long int rhs ) { return lhs = lhs % rhs; } +static inline Int ?%=?( Int & lhs, unsigned long int rhs ) { return lhs = lhs % rhs; } static inline Int ?<>?( Int shiften, mp_bitcnt_t shift ) { Int shifted; mpz_fdiv_q_2exp( shifted.mpz, shiften.mpz, shift ); return shifted; } -static inline Int ?>>=?( Int * lhs, mp_bitcnt_t shift ) { return *lhs = *lhs >> shift; } +static inline Int ?>>=?( Int & lhs, mp_bitcnt_t shift ) { return lhs = lhs >> shift; } // number functions Index: src/libcfa/interpose.c =================================================================== --- src/libcfa/interpose.c (revision b3d413befb5307e20b7a838c4700508e2bbd8a46) +++ src/libcfa/interpose.c (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -49,5 +49,5 @@ union { generic_fptr_t fptr; void* ptr; } originalFunc; - + #if defined( _GNU_SOURCE ) if ( version ) { @@ -59,7 +59,7 @@ originalFunc.ptr = dlsym( library, symbol ); #endif // _GNU_SOURCE - + error = dlerror(); - if ( error ) abortf( "interpose_symbol : internal error, %s\n", error ); + if ( error ) abortf( "interpose_symbol : internal error, %s\n", error ); return originalFunc.fptr; @@ -74,7 +74,7 @@ forall(dtype T) static inline void assign_ptr( T** symbol_ptr, const char * symbol_name, const char * version) { - union { + union { generic_fptr_t gp; - T* tp; + T* tp; } u; Index: src/libcfa/iterator =================================================================== --- src/libcfa/iterator (revision b3d413befb5307e20b7a838c4700508e2bbd8a46) +++ src/libcfa/iterator (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -19,7 +19,7 @@ trait iterator( otype iterator_type, otype elt_type ) { // point to the next element -// iterator_type ?++( iterator_type * ); - iterator_type ++?( iterator_type * ); - iterator_type --?( iterator_type * ); +// iterator_type ?++( iterator_type & ); + iterator_type ++?( iterator_type & ); + iterator_type --?( iterator_type & ); // can be tested for equality with other iterators @@ -28,5 +28,5 @@ // dereference to get the pointed-at element - lvalue elt_type *?( iterator_type ); + elt_type & *?( iterator_type ); }; Index: src/libcfa/rational =================================================================== --- src/libcfa/rational (revision b3d413befb5307e20b7a838c4700508e2bbd8a46) +++ src/libcfa/rational (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -31,6 +31,6 @@ int ?>?( T, T ); int ?>=?( T, T ); - void ?{}( T *, zero_t ); - void ?{}( T *, one_t ); + void ?{}( T &, zero_t ); + void ?{}( T &, one_t ); T +?( T ); T -?( T ); @@ -40,5 +40,5 @@ T ?/?( T, T ); T ?%?( T, T ); - T ?/=?( T *, T ); + T ?/=?( T &, T ); T abs( T ); }; @@ -54,17 +54,17 @@ forall( otype RationalImpl | arithmetic( RationalImpl ) ) -void ?{}( Rational(RationalImpl) * r ); +void ?{}( Rational(RationalImpl) & r ); forall( otype RationalImpl | arithmetic( RationalImpl ) ) -void ?{}( Rational(RationalImpl) * r, RationalImpl n ); +void ?{}( Rational(RationalImpl) & r, RationalImpl n ); forall( otype RationalImpl | arithmetic( RationalImpl ) ) -void ?{}( Rational(RationalImpl) * r, RationalImpl n, RationalImpl d ); +void ?{}( Rational(RationalImpl) & r, RationalImpl n, RationalImpl d ); forall( otype RationalImpl | arithmetic( RationalImpl ) ) -void ?{}( Rational(RationalImpl) * r, zero_t ); +void ?{}( Rational(RationalImpl) & r, zero_t ); forall( otype RationalImpl | arithmetic( RationalImpl ) ) -void ?{}( Rational(RationalImpl) * r, one_t ); +void ?{}( Rational(RationalImpl) & r, one_t ); // numerator/denominator getter @@ -77,5 +77,5 @@ forall( otype RationalImpl | arithmetic( RationalImpl ) ) -[ RationalImpl, RationalImpl ] ?=?( * [ RationalImpl, RationalImpl ] dest, Rational(RationalImpl) src ); +[ RationalImpl, RationalImpl ] ?=?( & [ RationalImpl, RationalImpl ] dest, Rational(RationalImpl) src ); // numerator/denominator setter Index: src/libcfa/rational.c =================================================================== --- src/libcfa/rational.c (revision b3d413befb5307e20b7a838c4700508e2bbd8a46) +++ src/libcfa/rational.c (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -1,10 +1,10 @@ -// +// // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo // // The contents of this file are covered under the licence agreement in the // file "LICENCE" distributed with Cforall. -// -// rational.c -- -// +// +// rational.c -- +// // Author : Peter A. Buhr // Created On : Wed Apr 6 17:54:28 2016 @@ -12,5 +12,5 @@ // Last Modified On : Tue May 16 18:35:36 2017 // Update Count : 150 -// +// #include "rational" @@ -47,18 +47,18 @@ forall( otype RationalImpl | arithmetic( RationalImpl ) ) -void ?{}( Rational(RationalImpl) * r ) { +void ?{}( Rational(RationalImpl) & r ) { r{ (RationalImpl){0}, (RationalImpl){1} }; } // rational forall( otype RationalImpl | arithmetic( RationalImpl ) ) -void ?{}( Rational(RationalImpl) * r, RationalImpl n ) { +void ?{}( Rational(RationalImpl) & r, RationalImpl n ) { r{ n, (RationalImpl){1} }; } // rational forall( otype RationalImpl | arithmetic( RationalImpl ) ) -void ?{}( Rational(RationalImpl) * r, RationalImpl n, RationalImpl d ) { +void ?{}( Rational(RationalImpl) & r, RationalImpl n, RationalImpl d ) { RationalImpl t = simplify( &n, &d ); // simplify - r->numerator = n / t; - r->denominator = d / t; + r.numerator = n / t; + r.denominator = d / t; } // rational @@ -77,6 +77,6 @@ forall( otype RationalImpl | arithmetic( RationalImpl ) ) -[ RationalImpl, RationalImpl ] ?=?( * [ RationalImpl, RationalImpl ] dest, Rational(RationalImpl) src ) { - return *dest = src.[ numerator, denominator ]; +[ RationalImpl, RationalImpl ] ?=?( & [ RationalImpl, RationalImpl ] dest, Rational(RationalImpl) src ) { + return dest = src.[ numerator, denominator ]; } Index: src/libcfa/stdlib =================================================================== --- src/libcfa/stdlib (revision b3d413befb5307e20b7a838c4700508e2bbd8a46) +++ src/libcfa/stdlib (revision 9aaac6e93085196ddc22e508c0fdfa1ee11ae660) @@ -132,12 +132,12 @@ // allocation/deallocation and constructor/destructor, non-array types -forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * new( Params p ); -forall( dtype T | { void ^?{}( T * ); } ) void delete( T * ptr ); -forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } ) void delete( T * ptr, Params rest ); +forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * new( Params p ); +forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void delete( T * ptr ); +forall( dtype T, ttype Params | sized(T) | { void ^?{}( T & ); void delete( Params ); } ) void delete( T * ptr, Params rest ); // allocation/deallocation and constructor/destructor, array types -forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * anew( size_t dim, Params p ); -forall( dtype T | sized(T) | { void ^?{}( T * ); } ) void adelete( size_t dim, T arr[] ); -forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } ) void adelete( size_t dim, T arr[], Params rest ); +forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * anew( size_t dim, Params p ); +forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void adelete( size_t dim, T arr[] ); +forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype Params | { void adelete( Params ); } ) void adelete( size_t dim, T arr[], Params rest ); //--------------------------------------- @@ -201,5 +201,5 @@ double abs( double _Complex ); long double abs( long double _Complex ); -forall( otype T | { void ?{}( T *, zero_t ); int ? olen ) { // larger ? memset( nptr + olen, (int)fill, nlen - olen ); // initialize added storage - } // + } // return (T *)nptr; } // alloc // allocation/deallocation and constructor/destructor, non-array types -forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) +forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * new( Params p ) { - return (malloc()){ p }; // run constructor + return &(*malloc()){ p }; // run constructor } // new -forall( dtype T | { void ^?{}( T * ); } ) +forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void delete( T * ptr ) { if ( ptr ) { // ignore null - ^ptr{}; // run destructor + ^(*ptr){}; // run destructor free( ptr ); } // if } // delete -forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } ) +forall( dtype T, ttype Params | sized(T) | { void ^?{}( T & ); void delete( Params ); } ) void delete( T * ptr, Params rest ) { if ( ptr ) { // ignore null - ^ptr{}; // run destructor + ^(*ptr){}; // run destructor free( ptr ); } // if @@ -61,18 +61,18 @@ // allocation/deallocation and constructor/destructor, array types -forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) +forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * anew( size_t dim, Params p ) { T *arr = alloc( dim ); for ( unsigned int i = 0; i < dim; i += 1 ) { - (&arr[i]){ p }; // run constructor + (arr[i]){ p }; // run constructor } // for return arr; } // anew -forall( dtype T | sized(T) | { void ^?{}( T * ); } ) +forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void adelete( size_t dim, T arr[] ) { if ( arr ) { // ignore null for ( int i = dim - 1; i >= 0; i -= 1 ) { // reverse allocation order, must be unsigned - ^(&arr[i]){}; // run destructor + ^(arr[i]){}; // run destructor } // for free( arr ); @@ -80,9 +80,9 @@ } // adelete -forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } ) +forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype Params | { void adelete( Params ); } ) void adelete( size_t dim, T arr[], Params rest ) { if ( arr ) { // ignore null for ( int i = dim - 1; i >= 0; i -= 1 ) { // reverse allocation order, must be unsigned - ^(&arr[i]){}; // run destructor + ^(arr[i]){}; // run destructor } // for free( arr );