Changes in / [c0b23644:fdd3786]

Location:

src

Files:

• Concurrency/Waitfor.cc (modified) (1 diff)
• benchmark/bench.h (modified) (2 diffs)
• libcfa/Makefile.am (modified) (1 diff)
• libcfa/Makefile.in (modified) (2 diffs)
• libcfa/bits/containers.h (modified) (10 diffs)
• libcfa/bits/defs.h (modified) (2 diffs)
• libcfa/bits/locks.h (modified) (1 diff)
• libcfa/concurrency/invoke.h (modified) (8 diffs)
• libcfa/concurrency/kernel (modified) (2 diffs)
• libcfa/concurrency/kernel.c (modified) (2 diffs)
• libcfa/concurrency/monitor (modified) (6 diffs)
• libcfa/concurrency/monitor.c (modified) (17 diffs)
• libcfa/exception.h (modified) (2 diffs)
• libcfa/stdhdr/assert.h (modified) (3 diffs)
• libcfa/virtual.h (modified) (2 diffs)
• tests/designations.c (modified) (1 diff)

src/Concurrency/Waitfor.cc

@@ -416 +416 @@
                                 makeAccStatement( acceptables, index, "is_dtor", detectIsDtor( clause.target.function )                                    , indexer ),
                                 makeAccStatement( acceptables, index, "func"   , new CastExpr( clause.target.function, fptr_t )                            , indexer ),
-                                makeAccStatement( acceptables, index, "list"   , new VariableExpr( monitors )                                              , indexer ),
+                                makeAccStatement( acceptables, index, "data"   , new VariableExpr( monitors )                                              , indexer ),
                                 makeAccStatement( acceptables, index, "size"   , new ConstantExpr( Constant::from_ulong( clause.target.arguments.size() ) ), indexer ),
                                 setter->clone()

src/benchmark/bench.h

@@ -1 +1 @@
 #pragma once
 
-#if defined(__CFORALL__)
+#if defined(__cforall)
 extern "C" {
 #endif
@@ -8 +8 @@
         #include <sys/times.h>                                  // times
         #include <time.h>
-#if defined(__CFORALL__)
+#if defined(__cforall)
 }
 #endif

src/libcfa/Makefile.am

@@ -100 +100 @@
         math                            \
         gmp                             \
+        bits/containers.h               \
         bits/defs.h             \
         bits/locks.h            \

src/libcfa/Makefile.in

@@ -264 +264 @@
         containers/result containers/vector concurrency/coroutine \
         concurrency/thread concurrency/kernel concurrency/monitor \
-        ${shell echo stdhdr/*} math gmp bits/defs.h bits/locks.h \
-        concurrency/invoke.h libhdr.h libhdr/libalign.h \
+        ${shell echo stdhdr/*} math gmp bits/containers.h bits/defs.h \
+        bits/locks.h concurrency/invoke.h libhdr.h libhdr/libalign.h \
         libhdr/libdebug.h libhdr/libtools.h
 HEADERS = $(nobase_cfa_include_HEADERS)
@@ -437 +437 @@
         math                            \
         gmp                             \
+        bits/containers.h               \
         bits/defs.h             \
         bits/locks.h            \

src/libcfa/bits/containers.h

@@ -15 +15 @@
 #pragma once
 
-#include <stddef.h>
+#include "bits/defs.h"
+#include "libhdr.h"
 
-#include "libhdr.h"
+//-----------------------------------------------------------------------------
+// Array
+//-----------------------------------------------------------------------------
+
+#ifdef __cforall
+        forall(dtype T)
+#else
+        #define T void
+#endif
+struct __small_array {
+        T *           data;
+        __lock_size_t size;
+};
+#undef T
+
+#ifdef __cforall
+        #define __small_array_t(T) __small_array(T)
+#else
+        #define __small_array_t(T) struct __small_array
+#endif
+
+#ifdef __cforall
+        // forall(otype T | sized(T))
+        // static inline void ?{}(__small_array(T) & this) {}
+
+        forall(dtype T | sized(T))
+        static inline T& ?[?]( __small_array(T) & this, __lock_size_t idx) {
+                return ((typeof(this.data))this.data)[idx];
+        }
+
+        forall(dtype T | sized(T))
+        static inline T& ?[?]( const __small_array(T) & this, __lock_size_t idx) {
+                return ((typeof(this.data))this.data)[idx];
+        }
+
+        forall(dtype T | sized(T))
+        static inline T* begin( const __small_array(T) & this ) {
+                return ((typeof(this.data))this.data);
+        }
+
+        forall(dtype T | sized(T))
+        static inline T* end( const __small_array(T) & this ) {
+                return ((typeof(this.data))this.data) + this.size;
+        }
+#endif
 
 //-----------------------------------------------------------------------------
@@ -23 +68 @@
 //-----------------------------------------------------------------------------
 
-#ifdef __CFORALL__
+#ifdef __cforall
         trait is_node(dtype T) {
                 T*& get_next( T& );
@@ -32 +77 @@
 // Stack
 //-----------------------------------------------------------------------------
-#ifdef __CFORALL__
+#ifdef __cforall
         forall(dtype TYPE | is_node(TYPE))
         #define T TYPE
@@ -41 +86 @@
         T * top;
 };
+#undef T
 
-#ifdef __CFORALL__
+#ifdef __cforall
 #define __stack_t(T) __stack(T)
 #else
@@ -48 +94 @@
 #endif
 
-#ifdef __CFORALL__
+#ifdef __cforall
         forall(dtype T | is_node(T))
-        void ?{}( __stack(T) & this ) {
-                this.top = NULL;
+        static inline void ?{}( __stack(T) & this ) {
+                (this.top){ NULL };
         }
 
         forall(dtype T | is_node(T) | sized(T))
-        void push( __stack(T) & this, T * val ) {
+        static inline void push( __stack(T) & this, T * val ) {
                 verify( !get_next( *val ) );
                 get_next( *val ) = this.top;
@@ -62 +108 @@
 
         forall(dtype T | is_node(T) | sized(T))
-        T * pop( __stack(T) & this ) {
+        static inline T * pop( __stack(T) & this ) {
                 T * top = this.top;
                 if( top ) {
@@ -75 +121 @@
 // Queue
 //-----------------------------------------------------------------------------
-#ifdef __CFORALL__
-        forall(dtype T | is_node(T))
+#ifdef __cforall
+        forall(dtype TYPE | is_node(TYPE))
         #define T TYPE
 #else
@@ -85 +131 @@
         T ** tail;
 };
+#undef T
 
-#ifdef __CFORALL__
+#ifdef __cforall
+#define __queue_t(T) __queue(T)
+#else
+#define __queue_t(T) struct __queue
+#endif
+
+#ifdef __cforall
         forall(dtype T | is_node(T))
-        void ?{}( __queue(T) & this ) {
-                this.head = NULL;
-                this.tail = &this.head;
+        static inline void ?{}( __queue(T) & this ) {
+                (this.head){ NULL };
+                (this.tail){ &this.head };
         }
 
         forall(dtype T | is_node(T) | sized(T))
-        void append( __queue(T) & this, T * val ) {
+        static inline void append( __queue(T) & this, T * val ) {
                 verify(this.tail != NULL);
                 *this.tail = val;
@@ -101 +154 @@
 
         forall(dtype T | is_node(T) | sized(T))
-        T * pop_head( __queue(T) & this ) {
+        static inline T * pop_head( __queue(T) & this ) {
                 T * head = this.head;
                 if( head ) {
@@ -114 +167 @@
 
         forall(dtype T | is_node(T) | sized(T))
-        T * remove( __queue(T) & this, T ** it ) {
+        static inline T * remove( __queue(T) & this, T ** it ) {
                 T * val = *it;
                 verify( val );

src/libcfa/bits/defs.h

@@ -17 +17 @@
 
 #include <stdbool.h>
+#include <stddef.h>
 #include <stdint.h>
 
@@ -22 +23 @@
 #define likely  (x)    __builtin_expect(!!(x), 1)
 #define thread_local _Thread_local
+
+typedef void (*fptr_t)();
+typedef int_fast16_t __lock_size_t;
+
+#ifdef __cforall
+#define __cfa_anonymous_object
+#else
+#define __cfa_anonymous_object __cfa_anonymous_object
+#endif

src/libcfa/bits/locks.h

@@ -56 +56 @@
 } __ALIGN__;
 
-#ifdef __CFORALL__
+#ifdef __cforall
         extern void yield( unsigned int );
         extern thread_local struct thread_desc *    volatile this_thread;

src/libcfa/concurrency/invoke.h

@@ -14 +14 @@
 //
 
+#include "bits/containers.h"
 #include "bits/defs.h"
 #include "bits/locks.h"
 
-#ifdef __CFORALL__
+#ifdef __cforall
 extern "C" {
 #endif
@@ -25 +26 @@
 #define _INVOKE_H_
 
-        typedef void (*fptr_t)();
-        typedef int_fast16_t __lock_size_t;
-
-        struct __thread_queue_t {
-                struct thread_desc * head;
-                struct thread_desc ** tail;
-        };
-
-        struct __condition_stack_t {
-                struct __condition_criterion_t * top;
-        };
-
-        #ifdef __CFORALL__
+        #ifdef __cforall
         extern "Cforall" {
-                void ?{}( struct __thread_queue_t & );
-                void append( struct __thread_queue_t &, struct thread_desc * );
-                struct thread_desc * pop_head( struct __thread_queue_t & );
-                struct thread_desc * remove( struct __thread_queue_t &, struct thread_desc ** );
-
-                void ?{}( struct __condition_stack_t & );
-                void push( struct __condition_stack_t &, struct __condition_criterion_t * );
-                struct __condition_criterion_t * pop( struct __condition_stack_t & );
+                static inline struct thread_desc             * & get_next( struct thread_desc             & this );
+                static inline struct __condition_criterion_t * & get_next( struct __condition_criterion_t & this );
         }
         #endif
@@ -100 +83 @@
 
                 // list of acceptable functions, null if any
-                struct __acceptable_t * clauses;
-
-                // number of acceptable functions
-                __lock_size_t size;
+                __small_array_t(struct __acceptable_t) __cfa_anonymous_object;
         };
 
@@ -114 +94 @@
 
                 // queue of threads that are blocked waiting for the monitor
-                struct __thread_queue_t entry_queue;
+                __queue_t(struct thread_desc) entry_queue;
 
                 // stack of conditions to run next once we exit the monitor
-                struct __condition_stack_t signal_stack;
+                __stack_t(struct __condition_criterion_t) signal_stack;
 
                 // monitor routines can be called recursively, we need to keep track of that
@@ -131 +111 @@
         struct __monitor_group_t {
                 // currently held monitors
-                struct monitor_desc ** list;
-
-                // number of currently held monitors
-                __lock_size_t size;
+                __small_array_t(monitor_desc*) __cfa_anonymous_object;
 
                 // last function that acquired monitors
@@ -159 +136 @@
      };
 
-     #ifdef __CFORALL__
+     #ifdef __cforall
      extern "Cforall" {
-                static inline monitor_desc * ?[?]( const __monitor_group_t & this, ptrdiff_t index ) {
-                        return this.list[index];
+                static inline thread_desc * & get_next( thread_desc & this ) {
+                        return this.next;
+                }
+
+                static inline struct __condition_criterion_t * & get_next( struct __condition_criterion_t & this );
+
+                static inline void ?{}(__monitor_group_t & this) {
+                        (this.data){NULL};
+                        (this.size){0};
+                        (this.func){NULL};
+                }
+
+                static inline void ?{}(__monitor_group_t & this, struct monitor_desc ** data, __lock_size_t size, fptr_t func) {
+                        (this.data){data};
+                        (this.size){size};
+                        (this.func){func};
                 }
 
                 static inline bool ?==?( const __monitor_group_t & lhs, const __monitor_group_t & rhs ) {
-                        if( (lhs.list != 0) != (rhs.list != 0) ) return false;
+                        if( (lhs.data != 0) != (rhs.data != 0) ) return false;
                         if( lhs.size != rhs.size ) return false;
                         if( lhs.func != rhs.func ) return false;
@@ -177 +168 @@
 
                         return true;
+                }
+
+                static inline void ?=?(__monitor_group_t & lhs, const __monitor_group_t & rhs) {
+                        lhs.data = rhs.data;
+                        lhs.size = rhs.size;
+                        lhs.func = rhs.func;
                 }
         }
@@ -210 +207 @@
 #endif //_INVOKE_PRIVATE_H_
 #endif //! defined(__CFA_INVOKE_PRIVATE__)
-#ifdef __CFORALL__
+#ifdef __cforall
 }
 #endif

src/libcfa/concurrency/kernel

@@ -26 +26 @@
 //-----------------------------------------------------------------------------
 // Locks
-// // Lock the spinlock, spin if already acquired
-// void lock      ( spinlock * DEBUG_CTX_PARAM2 );
-
-// // Lock the spinlock, yield repeatedly if already acquired
-// void lock_yield( spinlock * DEBUG_CTX_PARAM2 );
-
-// // Lock the spinlock, return false if already acquired
-// bool try_lock  ( spinlock * DEBUG_CTX_PARAM2 );
-
-// // Unlock the spinlock
-// void unlock    ( spinlock * );
-
 struct semaphore {
         __spinlock_t lock;
         int count;
-        __thread_queue_t waiting;
+        __queue_t(thread_desc) waiting;
 };
 
@@ -57 +45 @@
 
         // Ready queue for threads
-        __thread_queue_t ready_queue;
+        __queue_t(thread_desc) ready_queue;
 
         // Preemption rate on this cluster

src/libcfa/concurrency/kernel.c

@@ -164 +164 @@
 
 void ?{}(cluster & this) {
-        ( this.ready_queue ){};
+        (this.ready_queue){};
         ( this.ready_queue_lock ){};
 
@@ -611 +611 @@
 }
 
-//-----------------------------------------------------------------------------
-// Queues
-void ?{}( __thread_queue_t & this ) {
-        this.head = NULL;
-        this.tail = &this.head;
-}
-
-void append( __thread_queue_t & this, thread_desc * t ) {
-        verify(this.tail != NULL);
-        *this.tail = t;
-        this.tail = &t->next;
-}
-
-thread_desc * pop_head( __thread_queue_t & this ) {
-        thread_desc * head = this.head;
-        if( head ) {
-                this.head = head->next;
-                if( !head->next ) {
-                        this.tail = &this.head;
-                }
-                head->next = NULL;
-        }
-        return head;
-}
-
-thread_desc * remove( __thread_queue_t & this, thread_desc ** it ) {
-        thread_desc * thrd = *it;
-        verify( thrd );
-
-        (*it) = thrd->next;
-
-        if( this.tail == &thrd->next ) {
-                this.tail = it;
-        }
-
-        thrd->next = NULL;
-
-        verify( (this.head == NULL) == (&this.head == this.tail) );
-        verify( *this.tail == NULL );
-        return thrd;
-}
-
-void ?{}( __condition_stack_t & this ) {
-        this.top = NULL;
-}
-
-void push( __condition_stack_t & this, __condition_criterion_t * t ) {
-        verify( !t->next );
-        t->next = this.top;
-        this.top = t;
-}
-
-__condition_criterion_t * pop( __condition_stack_t & this ) {
-        __condition_criterion_t * top = this.top;
-        if( top ) {
-                this.top = top->next;
-                top->next = NULL;
-        }
-        return top;
-}
-
 // Local Variables: //
 // mode: c //

src/libcfa/concurrency/monitor

@@ -34 +34 @@
         this.recursion     = 0;
         this.mask.accepted = NULL;
-        this.mask.clauses  = NULL;
+        this.mask.data     = NULL;
         this.mask.size     = 0;
         this.dtor_node     = NULL;
@@ -40 +40 @@
 
 struct monitor_guard_t {
-        monitor_desc ** m;
-        __lock_size_t   count;
-        monitor_desc ** prev_mntrs;
-        __lock_size_t   prev_count;
-        fptr_t          prev_func;
+        monitor_desc **         m;
+        __lock_size_t           count;
+        __monitor_group_t prev;
 };
 
@@ -51 +49 @@
 
 struct monitor_dtor_guard_t {
-        monitor_desc * m;
-        monitor_desc ** prev_mntrs;
-        __lock_size_t   prev_count;
-        fptr_t          prev_func;
+        monitor_desc *    m;
+        __monitor_group_t prev;
 };
 
@@ -83 +79 @@
 };
 
+static inline __condition_criterion_t * & get_next( __condition_criterion_t & this ) {
+        return this.next;
+}
+
 struct __condition_node_t {
         // Thread that needs to be woken when all criteria are met
@@ -100 +100 @@
 };
 
-struct __condition_blocked_queue_t {
-        __condition_node_t * head;
-        __condition_node_t ** tail;
-};
+static inline __condition_node_t * & get_next( __condition_node_t & this ) {
+        return this.next;
+}
 
 void ?{}(__condition_node_t & this, thread_desc * waiting_thread, __lock_size_t count, uintptr_t user_info );
@@ -109 +108 @@
 void ?{}(__condition_criterion_t & this, monitor_desc * target, __condition_node_t * owner );
 
-void ?{}( __condition_blocked_queue_t & );
-void append( __condition_blocked_queue_t &, __condition_node_t * );
-__condition_node_t * pop_head( __condition_blocked_queue_t & );
-
 struct condition {
         // Link list which contains the blocked threads as-well as the information needed to unblock them
-        __condition_blocked_queue_t blocked;
+        __queue_t(__condition_node_t) blocked;
 
         // Array of monitor pointers (Monitors are NOT contiguous in memory)

src/libcfa/concurrency/monitor.c

@@ -280 +280 @@
 static inline void enter( __monitor_group_t monitors ) {
         for( __lock_size_t i = 0; i < monitors.size; i++) {
-                __enter_monitor_desc( monitors.list[i], monitors );
+                __enter_monitor_desc( monitors[i], monitors );
         }
 }
@@ -303 +303 @@
 
         // Save previous thread context
-        this.[prev_mntrs, prev_count, prev_func] = this_thread->monitors.[list, size, func];
+        this.prev = this_thread->monitors;
 
         // Update thread context (needed for conditions)
-        this_thread->monitors.[list, size, func] = [m, count, func];
+        (this_thread->monitors){m, count, func};
 
         // LIB_DEBUG_PRINT_SAFE("MGUARD : enter %d\n", count);
@@ -328 +328 @@
 
         // Restore thread context
-        this_thread->monitors.[list, size, func] = this.[prev_mntrs, prev_count, prev_func];
+        this_thread->monitors = this.prev;
 }
 
@@ -338 +338 @@
 
         // Save previous thread context
-        this.[prev_mntrs, prev_count, prev_func] = this_thread->monitors.[list, size, func];
+        this.prev = this_thread->monitors;
 
         // Update thread context (needed for conditions)
-        this_thread->monitors.[list, size, func] = [m, 1, func];
+        (this_thread->monitors){m, 1, func};
 
         __enter_monitor_dtor( this.m, func );
@@ -352 +352 @@
 
         // Restore thread context
-        this_thread->monitors.[list, size, func] = this.[prev_mntrs, prev_count, prev_func];
+        this_thread->monitors = this.prev;
 }
 
@@ -437 +437 @@
 
                 for(int i = 0; i < this.monitor_count; i++) {
-                        if ( this.monitors[i] != this_thrd->monitors.list[i] ) {
-                                abortf( "Signal on condition %p made with different monitor, expected %p got %i", &this, this.monitors[i], this_thrd->monitors.list[i] );
+                        if ( this.monitors[i] != this_thrd->monitors[i] ) {
+                                abortf( "Signal on condition %p made with different monitor, expected %p got %i", &this, this.monitors[i], this_thrd->monitors[i] );
                         }
                 }
@@ -510 +510 @@
                 "Possible cause is not checking if the condition is empty before reading stored data."
         );
-        return this.blocked.head->user_info;
+        return ((typeof(this.blocked.head))this.blocked.head)->user_info;
 }
 
@@ -554 +554 @@
                 if( next ) {
                         *mask.accepted = index;
-                        if( mask.clauses[index].is_dtor ) {
+                        __acceptable_t& accepted = mask[index];
+                        if( accepted.is_dtor ) {
                                 LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : dtor already there\n");
-                                verifyf( mask.clauses[index].size == 1        , "ERROR: Accepted dtor has more than 1 mutex parameter." );
-
-                                monitor_desc * mon2dtor = mask.clauses[index].list[0];
+                                verifyf( accepted.size == 1,  "ERROR: Accepted dtor has more than 1 mutex parameter." );
+
+                                monitor_desc * mon2dtor = accepted[0];
                                 verifyf( mon2dtor->dtor_node, "ERROR: Accepted monitor has no dtor_node." );
 
@@ -596 +597 @@
 
                         LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted);
-
                         return;
                 }
@@ -671 +671 @@
 static inline void reset_mask( monitor_desc * this ) {
         this->mask.accepted = NULL;
-        this->mask.clauses = NULL;
+        this->mask.data = NULL;
         this->mask.size = 0;
 }
@@ -697 +697 @@
 
 static inline bool is_accepted( monitor_desc * this, const __monitor_group_t & group ) {
-        __acceptable_t * it = this->mask.clauses; // Optim
+        __acceptable_t * it = this->mask.data; // Optim
         __lock_size_t count = this->mask.size;
 
@@ -820 +820 @@
         if( !this.monitors ) {
                 // LIB_DEBUG_PRINT_SAFE("Branding\n");
-                assertf( thrd->monitors.list != NULL, "No current monitor to brand condition %p", thrd->monitors.list );
+                assertf( thrd->monitors.data != NULL, "No current monitor to brand condition %p", thrd->monitors.data );
                 this.monitor_count = thrd->monitors.size;
 
                 this.monitors = malloc( this.monitor_count * sizeof( *this.monitors ) );
                 for( int i = 0; i < this.monitor_count; i++ ) {
-                        this.monitors[i] = thrd->monitors.list[i];
+                        this.monitors[i] = thrd->monitors[i];
                 }
         }
@@ -832 +832 @@
 static inline [thread_desc *, int] search_entry_queue( const __waitfor_mask_t & mask, monitor_desc * monitors [], __lock_size_t count ) {
 
-        __thread_queue_t & entry_queue = monitors[0]->entry_queue;
+        __queue_t(thread_desc) & entry_queue = monitors[0]->entry_queue;
 
         // For each thread in the entry-queue
@@ -841 +841 @@
                 // For each acceptable check if it matches
                 int i = 0;
-                __acceptable_t * end = mask.clauses + mask.size;
-                for( __acceptable_t * it = mask.clauses; it != end; it++, i++ ) {
+                __acceptable_t * end   = end  (mask);
+                __acceptable_t * begin = begin(mask);
+                for( __acceptable_t * it = begin; it != end; it++, i++ ) {
                         // Check if we have a match
                         if( *it == (*thrd_it)->monitors ) {
@@ -872 +873 @@
         __lock_size_t max = 0;
         for( __lock_size_t i = 0; i < mask.size; i++ ) {
-                max += mask.clauses[i].size;
+                __acceptable_t & accepted = mask[i];
+                max += accepted.size;
         }
         return max;
@@ -880 +882 @@
         __lock_size_t size = 0;
         for( __lock_size_t i = 0; i < mask.size; i++ ) {
-                __libcfa_small_sort( mask.clauses[i].list, mask.clauses[i].size );
-                for( __lock_size_t j = 0; j < mask.clauses[i].size; j++) {
-                        insert_unique( storage, size, mask.clauses[i].list[j] );
+                __acceptable_t & accepted = mask[i];
+                __libcfa_small_sort( accepted.data, accepted.size );
+                for( __lock_size_t j = 0; j < accepted.size; j++) {
+                        insert_unique( storage, size, accepted[j] );
                 }
         }
@@ -888 +891 @@
         __libcfa_small_sort( storage, size );
         return size;
-}
-
-void ?{}( __condition_blocked_queue_t & this ) {
-        this.head = NULL;
-        this.tail = &this.head;
-}
-
-void append( __condition_blocked_queue_t & this, __condition_node_t * c ) {
-        verify(this.tail != NULL);
-        *this.tail = c;
-        this.tail = &c->next;
-}
-
-__condition_node_t * pop_head( __condition_blocked_queue_t & this ) {
-        __condition_node_t * head = this.head;
-        if( head ) {
-                this.head = head->next;
-                if( !head->next ) {
-                        this.tail = &this.head;
-                }
-                head->next = NULL;
-        }
-        return head;
 }
 

src/libcfa/exception.h

@@ -17 +17 @@
 
 
-#ifdef __CFORALL__
+#ifdef __cforall
 extern "C" {
 #endif
@@ -68 +68 @@
 struct __cfaehm__cleanup_hook {};
 
-#ifdef __CFORALL__
+#ifdef __cforall
 }
 #endif

src/libcfa/stdhdr/assert.h

@@ -4 +4 @@
 // The contents of this file are covered under the licence agreement in the
 // file "LICENCE" distributed with Cforall.
-// 
-// assert.h -- 
-// 
+//
+// assert.h --
+//
 // Author           : Peter A. Buhr
 // Created On       : Mon Jul  4 23:25:26 2016
@@ -12 +12 @@
 // Last Modified On : Mon Jul 31 23:09:32 2017
 // Update Count     : 13
-// 
+//
 
-#ifdef __CFORALL__
+#ifdef __cforall
 extern "C" {
-#endif //__CFORALL__
+#endif //__cforall
 
 #include_next <assert.h>
@@ -30 +30 @@
 #endif
 
-#ifdef __CFORALL__
+#ifdef __cforall
 } // extern "C"
-#endif //__CFORALL__
+#endif //__cforall
 
 // Local Variables: //

src/libcfa/virtual.h

@@ -16 +16 @@
 #pragma once
 
-#ifdef __CFORALL__
+#ifdef __cforall
 extern "C" {
 #endif
@@ -35 +35 @@
                 struct __cfa__parent_vtable const * const * child );
 
-#ifdef __CFORALL__
+#ifdef __cforall
 }
 #endif

src/tests/designations.c

@@ -17 +17 @@
 // In particular, since the syntax for designations in Cforall differs from that of C, preprocessor substitution
 // is used for the designation syntax
-#ifdef __CFORALL__
+#ifdef __cforall
 #define DES :
 #else