Changeset 3e2e9b2

Timestamp:

Nov 28, 2024, 3:31:29 PM (3 weeks ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

509ec82

Parents:

956b389 (diff), f5e37a4 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Files:

• libcfa/prelude/builtins.c (modified) (2 diffs)
• libcfa/src/Makefile.am (modified) (2 diffs)
• libcfa/src/concurrency/monitor.cfa (modified) (49 diffs)
• libcfa/src/math.cfa (added)
• libcfa/src/rational.cfa (modified) (5 diffs)
• libcfa/src/rational.hfa (modified) (6 diffs)
• tests/.expect/KRfunctions.arm64.txt (modified) (1 diff)
• tests/.expect/KRfunctions.x64.txt (modified) (1 diff)
• tests/.expect/KRfunctions.x86.txt (modified) (1 diff)
• tests/.expect/declarationSpecifier.arm64.txt (modified) (1 diff)
• tests/.expect/declarationSpecifier.x64.txt (modified) (1 diff)
• tests/.expect/declarationSpecifier.x86.txt (modified) (1 diff)
• tests/.expect/extension.arm64.txt (modified) (1 diff)
• tests/.expect/extension.x64.txt (modified) (1 diff)
• tests/.expect/extension.x86.txt (modified) (1 diff)
• tests/.expect/gccExtensions.arm64.txt (modified) (1 diff)
• tests/.expect/gccExtensions.x64.txt (modified) (1 diff)
• tests/.expect/gccExtensions.x86.txt (modified) (1 diff)

libcfa/prelude/builtins.c

@@ -44 +44 @@
 typedef unsigned long long __cfaabi_abi_exception_type_t;
 
-#include <limits.h>                                                                             // CHAR_BIT
 #include "../src/virtual.h"
 #include "../src/exception.h"
@@ -132 +131 @@
 } // distribution
 
-#define __CFA_EXP__() \
-        if ( y == 0 ) return 1;                                                         /* convention */ \
-        __CFA_EXP_INT__(                                                                        /* special cases for integral types */ \
-                if ( x == 1 ) return 1;                                                 /* base case */ \
-                if ( x == 2 ) return x << (y - 1);                              /* positive shifting */ \
-                if ( y >= sizeof(y) * CHAR_BIT ) return 0;              /* immediate overflow, negative exponent > 2^size-1 */ \
-        ) \
-        typeof(x) op = 1;                                                                       /* accumulate odd product */ \
-        typeof(x) w = x; /* FIX-ME: possible bug in the box pass changing value argument through parameter */ \
-        for ( ; y > 1; y >>= 1 ) {                                                      /* squaring exponentiation, O(log2 y) */ \
-                if ( (y & 1) == 1 ) op = op * w;                                /* odd ? */ \
-                w = w * w; \
-        } \
-        return w * op
-#define __CFA_EXP_INT__(...) __VA_ARGS__
+int ?\?( int x, unsigned int y );
+long int ?\?( long int x, unsigned long int y );
+long long int ?\?( long long int x, unsigned long long int y );
+// unsigned computation may be faster and larger
+unsigned int ?\?( unsigned int x, unsigned int y );
+unsigned long int ?\?( unsigned long int x, unsigned long int y );
+unsigned long long int ?\?( unsigned long long int x, unsigned long long int y );
 
-static inline {
-        int ?\?( int x, unsigned int y ) { __CFA_EXP__(); }
-        long int ?\?( long int x, unsigned long int y ) { __CFA_EXP__(); }
-        long long int ?\?( long long int x, unsigned long long int y ) { __CFA_EXP__(); }
-        // unsigned computation may be faster and larger
-        unsigned int ?\?( unsigned int x, unsigned int y ) { __CFA_EXP__(); }
-        unsigned long int ?\?( unsigned long int x, unsigned long int y ) { __CFA_EXP__(); }
-        unsigned long long int ?\?( unsigned long long int x, unsigned long long int y ) { __CFA_EXP__(); }
+forall( OT | { void ?{}( OT & this, one_t ); OT ?*?( OT, OT ); } ) {
+        OT ?\?( OT x, unsigned int y );
+        OT ?\?( OT x, unsigned long int y );
+        OT ?\?( OT x, unsigned long long int y );
 } // distribution
-
-#undef __CFA_EXP_INT__
-#define __CFA_EXP_INT__(...)
-
-static inline forall( OT | { void ?{}( OT & this, one_t ); OT ?*?( OT, OT ); } ) {
-        OT ?\?( OT x, unsigned int y ) { __CFA_EXP__(); }
-        OT ?\?( OT x, unsigned long int y ) { __CFA_EXP__(); }
-        OT ?\?( OT x, unsigned long long int y ) { __CFA_EXP__(); }
-} // distribution
-
-#undef __CFA_EXP_INT__
-#undef __CFA_EXP__
 
 static inline {

libcfa/src/Makefile.am

@@ -47 +47 @@
         gmp.hfa \
         math.trait.hfa \
-        math.hfa \
         raii.hfa \
         time_t.hfa \
@@ -81 +80 @@
         iterator.hfa \
         limits.hfa \
+        math.hfa \
         memory.hfa \
         parseargs.hfa \

libcfa/src/concurrency/monitor.cfa

@@ -10 +10 @@
 // Created On       : Thd Feb 23 12:27:26 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Nov 21 08:31:55 2024
-// Update Count     : 18
+// Last Modified On : Wed Nov 27 12:13:14 2024
+// Update Count     : 72
 //
 
@@ -27 +27 @@
 //-----------------------------------------------------------------------------
 // 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 __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 );
 
@@ -35 +35 @@
 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( __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 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 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 [] );
 
@@ -47 +47 @@
 static inline void ?{}(__condition_criterion_t & this, monitor$ * target, __condition_node_t * owner );
 
-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 [] );
 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$ * 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 );
 
 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 count_max( const __waitfor_mask_t & mask );
+static inline __lock_size_t aggregate( monitor$ * storage [], const __waitfor_mask_t & mask );
 
 //-----------------------------------------------------------------------------
 // Useful defines
-#define wait_ctx(thrd, user_info)                               /* Create the necessary information to use the signaller stack                         */ \
-        __condition_node_t waiter = { thrd, count, user_info };   /* Create the node specific to this wait operation                                     */ \
-        __condition_criterion_t criteria[count];                  /* Create the creteria this wait operation needs to wake up                            */ \
-        init( count, monitors, waiter, criteria );                /* Link everything together                                                            */ \
-
-#define wait_ctx_primed(thrd, user_info)                        /* Create the necessary information to use the signaller stack                         */ \
-        __condition_node_t waiter = { thrd, count, user_info };   /* Create the node specific to this wait operation                                     */ \
-        __condition_criterion_t criteria[count];                  /* Create the creteria this wait operation needs to wake up                            */ \
-        init_push( count, monitors, waiter, criteria );           /* Link everything together and push it to the AS-Stack                                */ \
-
-#define monitor_ctx( mons, cnt )                                /* Define that create the necessary struct for internal/external scheduling operations */ \
-        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                             */ \
-        __waitfor_mask_t masks [ count ];                         /* Save the current waitfor masks to restore them later                                */ \
-        __spinlock_t *   locks [ count ];                         /* We need to pass-in an array of locks to BlockInternal                               */ \
+#define wait_ctx( thrd, user_info )                                                     /* Create the necessary information to use the signaller stack */ \
+        __condition_node_t waiter = { thrd, count, user_info }; /* Create the node specific to this wait operation */ \
+        __condition_criterion_t criteria[count];                                /* Create the creteria this wait operation needs to wake up */ \
+        init( count, monitors, waiter, criteria );                              /* Link everything together */
+
+#define wait_ctx_primed( thrd, user_info )                                      /* Create the necessary information to use the signaller stack */ \
+        __condition_node_t waiter = { thrd, count, user_info }; /* Create the node specific to this wait operation */ \
+        __condition_criterion_t criteria[count];                                /* Create the creteria this wait operation needs to wake up */ \
+        init_push( count, monitors, waiter, criteria );                 /* Link everything together and push it to the AS-Stack */
+
+#define monitor_ctx( mons, cnt )                                                        /* Define that create the necessary struct for internal/external scheduling operations */ \
+        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 */ \
+        __waitfor_mask_t masks[count];                                                  /* Save the current waitfor masks to restore them later */ \
+        __spinlock_t * locks[count];                                                    /* We need to pass-in an array of locks to BlockInternal */
 
 #define monitor_save    save   ( monitors, count, locks, recursions, masks )
@@ -93 +93 @@
         __cfaabi_dbg_print_safe( "Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
 
-        if( unlikely(0 != (0x1 & (uintptr_t)this->owner)) ) {
+        if ( unlikely(0 != (0x1 & (uintptr_t)this->owner)) ) {
                 abort( "Attempt by thread \"%.256s\" (%p) to access joined monitor %p.", thrd->self_cor.name, thrd, this );
-        }
-        else if( !this->owner ) {
+        } else if ( !this->owner ) {
                 // No one has the monitor, just take it
                 __set_owner( this, thrd );
 
                 __cfaabi_dbg_print_safe( "Kernel :  mon is free \n" );
-        }
-        else if( this->owner == thrd) {
+        } else if ( this->owner == thrd) {
                 // We already have the monitor, just note how many times we took it
                 this->recursion += 1;
 
                 __cfaabi_dbg_print_safe( "Kernel :  mon already owned \n" );
-        }
-        else if( is_accepted( this, group) ) {
+        } else if ( is_accepted( this, group) ) {
                 // Some one was waiting for us, enter
                 __set_owner( this, thrd );
@@ -116 +113 @@
 
                 __cfaabi_dbg_print_safe( "Kernel :  mon accepts \n" );
-        }
-        else {
+        } else {
                 __cfaabi_dbg_print_safe( "Kernel :  blocking \n" );
 
@@ -156 +152 @@
 
 
-        if( !this->owner ) {
+        if ( !this->owner ) {
                 __cfaabi_dbg_print_safe( "Kernel : Destroying free mon %p\n", this);
 
@@ -167 +163 @@
                 unlock( this->lock );
                 return;
-        }
-        else if( this->owner == thrd && !join) {
+        } else if ( this->owner == thrd && !join) {
                 // We already have the monitor... but where about to destroy it so the nesting will fail
                 // Abort!
@@ -176 +171 @@
         // 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);
@@ -196 +191 @@
         monitor$ ** monitors = &this;
         __monitor_group_t group = { &this, 1, func };
-        if( is_accepted( this, group) ) {
+        if ( is_accepted( this, group) ) {
                 __cfaabi_dbg_print_safe( "Kernel :  mon accepts dtor, block and signal it \n" );
 
@@ -224 +219 @@
                 __cfaabi_dbg_print_safe( "Kernel : Destroying %p\n", this);
                 return;
-        }
-        else {
+        } else {
                 __cfaabi_dbg_print_safe( "Kernel :  blocking \n" );
 
@@ -259 +253 @@
         // If we haven't left the last level of recursion
         // it means we don't need to do anything
-        if( this->recursion != 0) {
+        if ( this->recursion != 0) {
                 __cfaabi_dbg_print_safe( "Kernel :  recursion still %d\n", this->recursion);
                 unlock( this->lock );
@@ -283 +277 @@
 static void __dtor_leave( monitor$ * this, bool join ) {
         __cfaabi_dbg_debug_do(
-                if( active_thread() != this->owner ) {
+                if ( active_thread() != this->owner ) {
                         abort( "Destroyed monitor %p has inconsistent owner, expected %p got %p.\n", this, active_thread(), this->owner);
                 }
-                if( this->recursion != 1  && !join ) {
+                if ( this->recursion != 1  && !join ) {
                         abort( "Destroyed monitor %p has %d outstanding nested calls.\n", this, this->recursion - 1);
                 }
@@ -332 +326 @@
 // relies on the monitor array being sorted
 static inline void enter( __monitor_group_t monitors ) {
-        for( __lock_size_t i = 0; i < monitors.size; i++) {
+        for ( i; monitors.size ) {
                 __enter( monitors[i], monitors );
         }
@@ -340 +334 @@
 // relies on the monitor array being sorted
 static inline void leave(monitor$ * monitors [], __lock_size_t count) {
-        for( __lock_size_t i = count - 1; i >= 0; i--) {
+        for ( i; -~= count - 1 ) {
                 __leave( monitors[i] );
         }
@@ -454 +448 @@
 
         // Create storage for monitor context
-        monitor_ctx( this.monitors, this.monitor_count );
+        monitor_ctx( this.monitors, this.monitor_count );       // creates monitors, count, recursions, masks, locks
 
         // Create the node specific to this wait operation
@@ -477 +471 @@
 
         // Remove any duplicate threads
-        for( __lock_size_t i = 0; i < count; i++) {
+        for ( i; count ) {
                 thread$ * new_owner = next_thread( monitors[i] );
                 insert_unique( threads, thread_count, new_owner );
@@ -483 +477 @@
 
         // Unlock the locks, we don't need them anymore
-        for(int i = 0; i < count; i++) {
+        for ( i; count ) {
                 unlock( *locks[i] );
         }
 
         // Wake the threads
-        for(int i = 0; i < thread_count; i++) {
+        for ( i; thread_count ) {
                 unpark( threads[i] );
         }
@@ -500 +494 @@
 
 bool signal( condition & this ) libcfa_public {
-        if( is_empty( this ) ) { return false; }
+        if ( is_empty( this ) ) { return false; }
 
         //Check that everything is as expected
@@ -513 +507 @@
                 }
 
-                for(int i = 0; i < this.monitor_count; i++) {
+                for ( i; this.monitor_count ) {
                         if ( this.monitors[i] != this_thrd->monitors[i] ) {
                                 abort( "Signal on condition %p made with different monitor, expected %p got %p", &this, this.monitors[i], this_thrd->monitors[i] );
@@ -529 +523 @@
 
         //Add the thread to the proper AS stack
-        for(int i = 0; i < count; i++) {
+        for ( i; count ) {
                 __condition_criterion_t * crit = &node->criteria[i];
                 assert( !crit->ready );
@@ -542 +536 @@
 
 bool signal_block( condition & this ) libcfa_public {
-        if( !this.blocked.head ) { return false; }
+        if ( !this.blocked.head ) { return false; }
 
         //Check that everything is as expected
@@ -549 +543 @@
 
         // Create storage for monitor context
-        monitor_ctx( this.monitors, this.monitor_count );
+        monitor_ctx( this.monitors, this.monitor_count );       // creates monitors, count, recursions, masks, locks
 
         // Lock all monitors (aggregates the locks them as well)
         lock_all( monitors, locks, count );
-
 
         // Create the node specific to this wait operation
@@ -576 +569 @@
         park();
 
-
         // WE WOKE UP
-
 
         __cfaabi_dbg_print_buffer_local( "Kernel :   signal_block returned\n" );
@@ -621 +612 @@
         __cfaabi_dbg_print_buffer_decl( "Kernel : waitfor %"PRIdFAST16" (s: %"PRIdFAST16", m: %"PRIdFAST16")\n", actual_count, mask.size, (__lock_size_t)max);
 
-        if(actual_count == 0) return;
+        if (actual_count == 0) return;
 
         __cfaabi_dbg_print_buffer_local( "Kernel : waitfor internal proceeding\n" );
 
         // Create storage for monitor context
-        monitor_ctx( mon_storage, actual_count );
+        monitor_ctx( mon_storage, actual_count );                       // creates monitors, count, recursions, masks, locks
 
         // Lock all monitors (aggregates the locks as well)
@@ -636 +627 @@
                 [next, index] = search_entry_queue( mask, monitors, count );
 
-                if( next ) {
+                if ( next ) {
                         *mask.accepted = index;
                         __acceptable_t& accepted = mask[index];
-                        if( accepted.is_dtor ) {
+                        if ( accepted.is_dtor ) {
                                 __cfaabi_dbg_print_buffer_local( "Kernel : dtor already there\n" );
                                 verifyf( accepted.size == 1,  "ERROR: Accepted dtor has more than 1 mutex parameter." );
@@ -662 +653 @@
                                 __cfaabi_dbg_print_buffer_local( "Kernel :  baton of %"PRIdFAST16" monitors : ", count );
                                 #ifdef __CFA_DEBUG_PRINT__
-                                        for( int i = 0; i < count; i++) {
+                                        for ( i; count ) {
                                                 __cfaabi_dbg_print_buffer_local( "%p %p ", monitors[i], monitors[i]->signal_stack.top );
                                         }
@@ -692 +683 @@
 
 
-        if( duration == 0 ) {
+        if ( duration == 0 ) {
                 __cfaabi_dbg_print_buffer_local( "Kernel : non-blocking, exiting\n" );
 
@@ -712 +703 @@
         set_mask( monitors, count, mask );
 
-        for( __lock_size_t i = 0; i < count; i++) {
+        for ( i; count ) {
                 verify( monitors[i]->owner == active_thread() );
         }
@@ -752 +743 @@
         monitors[0]->owner        = owner;
         monitors[0]->recursion    = 1;
-        for( __lock_size_t i = 1; i < count; i++ ) {
+        for ( i; 1~count ) {
                 /* paranoid */ verify ( monitors[i]->lock.lock );
                 /* paranoid */ verifyf( monitors[i]->owner == active_thread(), "Expected owner to be %p, got %p (r: %i, m: %p)", active_thread(), monitors[i]->owner, monitors[i]->recursion, monitors[i] );
@@ -761 +752 @@
 
 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++) {
+        for ( i; count) {
                 storage[i]->mask = mask;
         }
@@ -776 +767 @@
         __cfaabi_dbg_print_safe( "Kernel :  mon %p AS-stack top %p\n", this, this->signal_stack.top);
         __condition_criterion_t * urgent = pop( this->signal_stack );
-        if( urgent ) {
+        if ( urgent ) {
                 //The signaller stack is not empty,
                 //regardless of if we are ready to baton pass,
@@ -801 +792 @@
 
         // Check if there are any acceptable functions
-        if( !it ) return false;
+        if ( !it ) return false;
 
         // If this isn't the first monitor to test this, there is no reason to repeat the test.
-        if( this != group[0] ) return group[0]->mask.accepted >= 0;
+        if ( this != group[0] ) return group[0]->mask.accepted >= 0;
 
         // For all acceptable functions check if this is the current function.
-        for( __lock_size_t i = 0; i < count; i++, it++ ) {
-                if( *it == group ) {
+        for ( __lock_size_t i = 0; i < count; i++, it++ ) {
+                if ( *it == group ) {
                         *this->mask.accepted = i;
                         return true;
@@ -819 +810 @@
 
 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++) {
+        for ( i; count ) {
                 (criteria[i]){ monitors[i], waiter };
         }
@@ -827 +818 @@
 
 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++) {
+        for ( i; count ) {
                 (criteria[i]){ monitors[i], waiter };
                 __cfaabi_dbg_print_safe( "Kernel :  target %p = %p\n", criteria[i].target, &criteria[i] );
@@ -837 +828 @@
 
 static inline void lock_all( __spinlock_t * locks [], __lock_size_t count ) {
-        for( __lock_size_t i = 0; i < count; i++ ) {
+        for ( i; count ) {
                 lock( *locks[i] __cfaabi_dbg_ctx2 );
         }
@@ -843 +834 @@
 
 static inline void lock_all( monitor$ * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count ) {
-        for( __lock_size_t i = 0; i < count; i++ ) {
+        for ( i; count ) {
                 __spinlock_t * l = &source[i]->lock;
                 lock( *l __cfaabi_dbg_ctx2 );
-                if(locks) locks[i] = l;
+                if (locks) locks[i] = l;
         }
 }
 
 static inline void unlock_all( __spinlock_t * locks [], __lock_size_t count ) {
-        for( __lock_size_t i = 0; i < count; i++ ) {
+        for ( i; count ) {
                 unlock( *locks[i] );
         }
@@ -857 +848 @@
 
 static inline void unlock_all( monitor$ * locks [], __lock_size_t count ) {
-        for( __lock_size_t i = 0; i < count; i++ ) {
+        for ( i; count ) {
                 unlock( locks[i]->lock );
         }
@@ -869 +860 @@
         __waitfor_mask_t /*out*/ masks []
 ) {
-        for( __lock_size_t i = 0; i < count; i++ ) {
+        for ( i; count ) {
                 recursions[i] = ctx[i]->recursion;
-                masks[i]      = ctx[i]->mask;
+                masks[i] = ctx[i]->mask;
         }
 }
@@ -883 +874 @@
 ) {
         lock_all( locks, count );
-        for( __lock_size_t i = 0; i < count; i++ ) {
+        for ( i; count ) {
                 ctx[i]->recursion = recursions[i];
-                ctx[i]->mask      = masks[i];
+                ctx[i]->mask = masks[i];
         }
         unlock_all( locks, count );
@@ -901 +892 @@
         bool ready2run = true;
 
-        for(    int i = 0; i < count; i++ ) {
-
+        for ( i; count ) {
                 // __cfaabi_dbg_print_safe( "Checking %p for %p\n", &criteria[i], target );
-                if( &criteria[i] == target ) {
+                if ( &criteria[i] == target ) {
                         criteria[i].ready = true;
                         // __cfaabi_dbg_print_safe( "True\n" );
@@ -918 +908 @@
 static inline void brand_condition( condition & this ) {
         thread$ * thrd = active_thread();
-        if( !this.monitors ) {
+        if ( !this.monitors ) {
                 // __cfaabi_dbg_print_safe( "Branding\n" );
                 assertf( thrd->monitors.data != 0p, "No current monitor to brand condition %p", thrd->monitors.data );
@@ -924 +914 @@
 
                 this.monitors = (monitor$ **)malloc( this.monitor_count * sizeof( *this.monitors ) );
-                for( int i = 0; i < this.monitor_count; i++ ) {
+                for ( i; this.monitor_count ) {
                         this.monitors[i] = thrd->monitors[i];
                 }
@@ -947 +937 @@
                 // For each acceptable check if it matches
                 int i = 0;
-                __acceptable_t * end   = end  (mask);
+                __acceptable_t * end = end(mask);
                 __acceptable_t * begin = begin(mask);
                 for ( __acceptable_t * it = begin; it != end; it++, i++ ) {
@@ -961 +951 @@
                 #endif
         }
-#endif
-        int i = 0;
-        __acceptable_t * end   = end  (mask);
-        __acceptable_t * begin = begin(mask);
+#else
         // For each acceptable (respect lexical priority in waitfor statement)
-        for ( __acceptable_t * it = begin; it != end; it++, i++ ) {
+        __acceptable_t * it = end(mask); it--;                          // end is passed the last node, so backup
+        for ( int i = mask.size - 1; i >= 0; i -= 1, it-- ) {
                 #if defined( __CFA_WITH_VERIFY__ )
                 thread$ * last = 0p;
@@ -980 +968 @@
                         // For each thread in the entry-queue check for a match
                         if ( *it == curr->monitors ) {
-                                // If match, return it after removeing from the entry queue
+                                // If match, return it after removing from the entry queue
                                 return [remove( entry_queue, thrd_it ), i];
                         } // if
@@ -989 +977 @@
                 } // for
         } // for
+#endif
         return [0, -1];
 }
 
-forall(T & | sized( T ))
+forall( T & | sized( T ) )
 static inline __lock_size_t insert_unique( T * array [], __lock_size_t & size, T * val ) {
-        if( !val ) return size;
-
-        for( __lock_size_t i = 0; i <= size; i++) {
-                if( array[i] == val ) return size;
+        if ( ! val ) return size;
+
+        for ( __lock_size_t i; ~= size ) {
+                if ( array[i] == val ) return size;
         }
 
         array[size] = val;
-        size = size + 1;
-        return size;
+        return size += 1;
 }
 
 static inline __lock_size_t count_max( const __waitfor_mask_t & mask ) {
         __lock_size_t max = 0;
-        for( __lock_size_t i = 0; i < mask.size; i++ ) {
+        for ( i; mask.size ) {
                 __acceptable_t & accepted = mask[i];
                 max += accepted.size;
@@ -1016 +1004 @@
 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++ ) {
+        for ( i; mask.size ) {
                 __acceptable_t & accepted = mask[i];
                 __libcfa_small_sort( accepted.data, accepted.size );
-                for( __lock_size_t j = 0; j < accepted.size; j++) {
+                for ( __lock_size_t j = 0; j < accepted.size; j++) {
                         insert_unique( storage, size, accepted[j] );
                 }
@@ -1040 +1028 @@
         __cfaabi_dbg_print_safe( "Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
 
-        if( unlikely(0 != (0x1 & (uintptr_t)this->owner)) ) {
+        if ( unlikely(0 != (0x1 & (uintptr_t)this->owner)) ) {
                 abort( "Attempt by thread \"%.256s\" (%p) to access joined monitor %p.", thrd->self_cor.name, thrd, this );
-        }
-        else if( !this->owner ) {
+        } else if ( !this->owner ) {
                 // No one has the monitor, just take it
                 __set_owner( this, thrd );
 
                 __cfaabi_dbg_print_safe( "Kernel :  mon is free \n" );
-        }
-        else if( this->owner == thrd) {
+        } else if ( this->owner == thrd) {
                 // We already have the monitor, just note how many times we took it
                 this->recursion += 1;
 
                 __cfaabi_dbg_print_safe( "Kernel :  mon already owned \n" );
-        }
-        else {
+        } else {
                 __cfaabi_dbg_print_safe( "Kernel :  blocking \n" );
 

libcfa/src/rational.cfa

@@ -10 +10 @@
 // Created On       : Wed Apr  6 17:54:28 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Nov 11 22:37:12 2024
-// Update Count     : 206
+// Last Modified On : Wed Nov 27 18:06:43 2024
+// Update Count     : 208
 //
 
@@ -19 +19 @@
 
 #pragma GCC visibility push(default)
+
+// Arithmetic, Relational
 
 forall( T | arithmetic( T ) ) {
@@ -190 +192 @@
                 return l = l / r;
         } // ?/?
-
-        // I/O
-
-        forall( istype & | istream( istype ) | { istype & ?|?( istype &, T & ); } )
+} // distribution
+
+// I/O
+
+forall( T ) {
+        forall( istype & | istream( istype ) | { istype & ?|?( istype &, T & ); } | arithmetic( T ) )
         istype & ?|?( istype & is, rational(T) & r ) {
                 is | r.numerator | r.denominator;
@@ -210 +214 @@
 } // distribution
 
+// Exponentiation
+
 forall( T | arithmetic( T ) | { T ?\?( T, unsigned long ); } ) {
         rational(T) ?\?( rational(T) x, long int y ) {
@@ -224 +230 @@
 } // distribution
 
-// conversion
+// Conversion
 
 forall( T | arithmetic( T ) | { double convert( T ); } )

libcfa/src/rational.hfa

@@ -12 +12 @@
 // Created On       : Wed Apr  6 17:56:25 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Nov  8 17:02:09 2024
-// Update Count     : 126
+// Last Modified On : Wed Nov 27 18:11:07 2024
+// Update Count     : 128
 //
 
@@ -21 +21 @@
 #include "math.trait.hfa"                                                               // arithmetic
 
-// implementation
+// Implementation
 
 forall( T ) {
@@ -28 +28 @@
         }; // rational
 }
+
+// Arithmetic, Relational
 
 forall( T | arithmetic( T ) ) {
@@ -73 +75 @@
         rational(T) ?/?( rational(T) l, rational(T) r );
         rational(T) ?/=?( rational(T) & l, rational(T) r );
+} // distribution
 
-        // I/O
-        forall( istype & | istream( istype ) | { istype & ?|?( istype &, T & ); } )
+// I/O
+
+forall( T ) {
+        forall( istype & | istream( istype ) | { istype & ?|?( istype &, T & ); } | arithmetic( T ) )
         istype & ?|?( istype &, rational(T) & );
 
@@ -84 +89 @@
 } // distribution
 
+// Exponentiation
+
 forall( T | arithmetic( T ) | { T ?\?( T, unsigned long ); } ) {
         rational(T) ?\?( rational(T) x, long int y );
@@ -89 +96 @@
 } // distribution
 
-// conversion
+// Conversion
+
 forall( T | arithmetic( T ) | { double convert( T ); } )
 double widen( rational(T) r );

tests/.expect/KRfunctions.arm64.txt

@@ -104 +104 @@
     signed int _X1bi_2;
     {
-        signed int *(*_tmp_cp_ret6)(signed int __param_0, signed int __param_1);
-        ((void)(_X1xFPi_ii__2=(((void)(_tmp_cp_ret6=_X3f10FFPi_ii__iPiPid__1(3, (&_X1ai_2), (&_X1bi_2), 3.5))) , _tmp_cp_ret6)));
+        signed int *(*_tmp_cp_ret0)(signed int __param_0, signed int __param_1);
+        ((void)(_X1xFPi_ii__2=(((void)(_tmp_cp_ret0=_X3f10FFPi_ii__iPiPid__1(3, (&_X1ai_2), (&_X1bi_2), 3.5))) , _tmp_cp_ret0)));
     }
 

tests/.expect/KRfunctions.x64.txt

@@ -104 +104 @@
     signed int _X1bi_2;
     {
-        signed int *(*_tmp_cp_ret6)(signed int __param_0, signed int __param_1);
-        ((void)(_X1xFPi_ii__2=(((void)(_tmp_cp_ret6=_X3f10FFPi_ii__iPiPid__1(3, (&_X1ai_2), (&_X1bi_2), 3.5))) , _tmp_cp_ret6)));
+        signed int *(*_tmp_cp_ret0)(signed int __param_0, signed int __param_1);
+        ((void)(_X1xFPi_ii__2=(((void)(_tmp_cp_ret0=_X3f10FFPi_ii__iPiPid__1(3, (&_X1ai_2), (&_X1bi_2), 3.5))) , _tmp_cp_ret0)));
     }
 

tests/.expect/KRfunctions.x86.txt

@@ -104 +104 @@
     signed int _X1bi_2;
     {
-        signed int *(*_tmp_cp_ret6)(signed int __param_0, signed int __param_1);
-        ((void)(_X1xFPi_ii__2=(((void)(_tmp_cp_ret6=_X3f10FFPi_ii__iPiPid__1(3, (&_X1ai_2), (&_X1bi_2), 3.5))) , _tmp_cp_ret6)));
+        signed int *(*_tmp_cp_ret0)(signed int __param_0, signed int __param_1);
+        ((void)(_X1xFPi_ii__2=(((void)(_tmp_cp_ret0=_X3f10FFPi_ii__iPiPid__1(3, (&_X1ai_2), (&_X1bi_2), 3.5))) , _tmp_cp_ret0)));
     }
 

tests/.expect/declarationSpecifier.arm64.txt

@@ -1059 +1059 @@
     }
 
-    signed int _tmp_cp_ret6;
-    signed int _X3reti_2 = (((void)(_tmp_cp_ret6=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret6);
+    signed int _tmp_cp_ret0;
+    signed int _X3reti_2 = (((void)(_tmp_cp_ret0=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret0);
     if ( ((&_X17cfa_main_returnedi_1)!=((signed int *)0)) ) {
         {

tests/.expect/declarationSpecifier.x64.txt

@@ -1059 +1059 @@
     }
 
-    signed int _tmp_cp_ret6;
-    signed int _X3reti_2 = (((void)(_tmp_cp_ret6=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret6);
+    signed int _tmp_cp_ret0;
+    signed int _X3reti_2 = (((void)(_tmp_cp_ret0=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret0);
     if ( ((&_X17cfa_main_returnedi_1)!=((signed int *)0)) ) {
         {

tests/.expect/declarationSpecifier.x86.txt

@@ -1059 +1059 @@
     }
 
-    signed int _tmp_cp_ret6;
-    signed int _X3reti_2 = (((void)(_tmp_cp_ret6=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret6);
+    signed int _tmp_cp_ret0;
+    signed int _X3reti_2 = (((void)(_tmp_cp_ret0=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret0);
     if ( ((&_X17cfa_main_returnedi_1)!=((signed int *)0)) ) {
         {

tests/.expect/extension.arm64.txt

@@ -457 +457 @@
 
     {
-        signed int _tmp_cp_ret6;
-        ((void)(((void)(_tmp_cp_ret6=__extension__ _X4fredFi_i__1(3))) , _tmp_cp_ret6));
+        signed int _tmp_cp_ret0;
+        ((void)(((void)(_tmp_cp_ret0=__extension__ _X4fredFi_i__1(3))) , _tmp_cp_ret0));
     }
 

tests/.expect/extension.x64.txt

@@ -457 +457 @@
 
     {
-        signed int _tmp_cp_ret6;
-        ((void)(((void)(_tmp_cp_ret6=__extension__ _X4fredFi_i__1(3))) , _tmp_cp_ret6));
+        signed int _tmp_cp_ret0;
+        ((void)(((void)(_tmp_cp_ret0=__extension__ _X4fredFi_i__1(3))) , _tmp_cp_ret0));
     }
 

tests/.expect/extension.x86.txt

@@ -457 +457 @@
 
     {
-        signed int _tmp_cp_ret6;
-        ((void)(((void)(_tmp_cp_ret6=__extension__ _X4fredFi_i__1(3))) , _tmp_cp_ret6));
+        signed int _tmp_cp_ret0;
+        ((void)(((void)(_tmp_cp_ret0=__extension__ _X4fredFi_i__1(3))) , _tmp_cp_ret0));
     }
 

tests/.expect/gccExtensions.arm64.txt

@@ -339 +339 @@
     }
 
-    signed int _tmp_cp_ret6;
-    signed int _X3reti_2 = (((void)(_tmp_cp_ret6=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret6);
+    signed int _tmp_cp_ret0;
+    signed int _X3reti_2 = (((void)(_tmp_cp_ret0=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret0);
     if ( ((&_X17cfa_main_returnedi_1)!=((signed int *)0)) ) {
         {

tests/.expect/gccExtensions.x64.txt

@@ -339 +339 @@
     }
 
-    signed int _tmp_cp_ret6;
-    signed int _X3reti_2 = (((void)(_tmp_cp_ret6=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret6);
+    signed int _tmp_cp_ret0;
+    signed int _X3reti_2 = (((void)(_tmp_cp_ret0=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret0);
     if ( ((&_X17cfa_main_returnedi_1)!=((signed int *)0)) ) {
         {

tests/.expect/gccExtensions.x86.txt

@@ -317 +317 @@
     }
 
-    signed int _tmp_cp_ret6;
-    signed int _X3reti_2 = (((void)(_tmp_cp_ret6=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret6);
+    signed int _tmp_cp_ret0;
+    signed int _X3reti_2 = (((void)(_tmp_cp_ret0=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret0);
     if ( ((&_X17cfa_main_returnedi_1)!=((signed int *)0)) ) {
         {