Index: libcfa/src/bits/sequence.hfa =================================================================== --- libcfa/src/bits/sequence.hfa (revision 00675ed4c2f48a20d015179ca8dc1e151fce57a5) +++ libcfa/src/bits/sequence.hfa (revision 81ab5ebb3b497e7c713dd340f479f3d7e803ea4a) @@ -65,5 +65,5 @@ void ?{}( Sequence(T) & s ) with( s ) { ((Collection &)s){}; - } // post: isEmpty() + } // post: empty() } Index: libcfa/src/collections/list.hfa =================================================================== --- libcfa/src/collections/list.hfa (revision 00675ed4c2f48a20d015179ca8dc1e151fce57a5) +++ libcfa/src/collections/list.hfa (revision 81ab5ebb3b497e7c713dd340f479f3d7e803ea4a) @@ -10,6 +10,6 @@ // Created On : Wed Apr 22 18:00:00 2020 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Mar 27 08:02:56 2026 -// Update Count : 99 +// Last Modified On : Sun Mar 29 21:20:44 2026 +// Update Count : 101 // @@ -206,5 +206,5 @@ } - bool isEmpty( dlist( tE, tLinks ) & list ) { + bool isEmpty( dlist( tE, tLinks ) & list ) { // deprecated return empty( list ); } @@ -413,6 +413,6 @@ // Transfer the "from" list to the end of this sequence; the "from" list is empty after the transfer. // void transfer( dlist( tE, tLinks ) & to, dlist( tE, tLinks ) & from ) { -// if ( isEmpty( from ) ) return; // "from" list empty ? -// if ( isEmpty( to ) ) { // "to" list empty ? +// if ( empty( from ) ) return; // "from" list empty ? +// if ( empty( to ) ) { // "to" list empty ? // root = from.root; // } else { // "to" list not empty Index: libcfa/src/collections/list2.hfa =================================================================== --- libcfa/src/collections/list2.hfa (revision 00675ed4c2f48a20d015179ca8dc1e151fce57a5) +++ libcfa/src/collections/list2.hfa (revision 81ab5ebb3b497e7c713dd340f479f3d7e803ea4a) @@ -19,6 +19,6 @@ // Created On : Wed Apr 22 18:00:00 2020 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Mar 24 22:20:56 2026 -// Update Count : 8 +// Last Modified On : Sun Mar 29 21:47:53 2026 +// Update Count : 12 // @@ -206,8 +206,8 @@ }; - static inline tE * $get_list_origin_addr( dlist(tE, tLinks) & lst ) { + static inline tE * $get_list_origin_addr( dlist(tE, tLinks) & list ) { dlink(tE) & link_from_null = ( * (tE *) 0p )`inner; ptrdiff_t link_offset = (ptrdiff_t) & link_from_null; - size_t origin_addr = ((size_t) & lst) - link_offset; + size_t origin_addr = ((size_t) & list) - link_offset; size_t preResult = ORIGIN_TAG_ENABL( origin_addr ); return (tE *)preResult; @@ -430,14 +430,14 @@ } - static inline tE & first( dlist(tE, tLinks) & lst ) { - verify (&lst != 0p); - dlink(tE) * firstLnk = lst.next; + static inline tE & first( dlist(tE, tLinks) & list ) { + verify (&list != 0p); + dlink(tE) * firstLnk = list.next; if (ORIGIN_TAG_QUERY((size_t)firstLnk)) return * 0p; tytagref( tLinks, dlink(tE) ) firstLnkTagged = {*firstLnk}; return downcast$( firstLnkTagged ); } - static inline tE & last ( dlist(tE, tLinks) & lst ) { - verify (&lst != 0p); - dlink(tE) * lastLnk = lst.prev; + static inline tE & last ( dlist(tE, tLinks) & list ) { + verify (&list != 0p); + dlink(tE) * lastLnk = list.prev; if (ORIGIN_TAG_QUERY((size_t)lastLnk)) return * 0p; tytagref( tLinks, dlink(tE) ) lastLnkTagged = {*lastLnk}; @@ -445,11 +445,16 @@ } - static inline bool isEmpty( dlist(tE, tLinks) & lst ) { - verify (&lst != 0p); - if ( & first(lst) == 0p || & last(lst) == 0p ) { - verify( & last(lst) == 0p && & last(lst) == 0p ); + static inline bool empty( dlist(tE, tLinks) & list ) { + verify (&list != 0p); + if ( & first(list) == 0p || & last(list) == 0p ) { + verify( & last(list) == 0p && & last(list) == 0p ); return true; } return false; + } + + static inline bool isEmpty( dlist(tE, tLinks) & list ) __attribute__ ((deprecated)); + static inline bool isEmpty( dlist(tE, tLinks) & list ) { + return empty( list ); } @@ -469,6 +474,6 @@ } - static inline tE & iter( dlist(tE, tLinks) & lst ) { - tE * origin = $get_list_origin_addr( lst ); + static inline tE & iter( dlist(tE, tLinks) & list ) { + tE * origin = $get_list_origin_addr( list ); return *origin; } @@ -538,5 +543,5 @@ // Applies knowledge of tag pattern around head (unknown to optimizer) to reduce runtime tag operations. - static inline void insert_first( dlist(tE, tLinks) &lst, tE & e ) { + static inline void insert_first( dlist(tE, tLinks) &list, tE & e ) { dlink(tE) & linkToInsert = e`inner; NOLOOSE( @@ -548,5 +553,5 @@ verify(ORIGIN_TAG_CLEAR((size_t)linkToInsert.next) == (size_t)&linkToInsert); ) - dlink(tE) & list_pos_links = lst; + dlink(tE) & list_pos_links = list; MAYBE_INSERT_READ_EARLY( dlink(tE) & afterLinks = * (dlink(tE) *) ORIGIN_TAG_CLEAR( (size_t) list_pos_links.next ); @@ -577,5 +582,5 @@ } - static inline void insert_last( dlist(tE, tLinks) &lst, tE & e ) { + static inline void insert_last( dlist(tE, tLinks) &list, tE & e ) { dlink(tE) & linkToInsert = e`inner; NOLOOSE( @@ -587,5 +592,5 @@ verify(ORIGIN_TAG_CLEAR((size_t)linkToInsert.prev) == (size_t)&linkToInsert); ) - dlink(tE) & list_pos_links = lst; + dlink(tE) & list_pos_links = list; MAYBE_INSERT_READ_EARLY( dlink(tE) & beforeLinks = * (dlink(tE) *) ORIGIN_TAG_CLEAR( (size_t) list_pos_links.prev ); @@ -630,7 +635,7 @@ } - static inline tE & remove_first( dlist(tE, tLinks) &lst ) { - verify (&lst != 0p); - dlink(tE) & list_links = lst; + static inline tE & remove_first( dlist(tE, tLinks) &list ) { + verify (&list != 0p); + dlink(tE) & list_links = list; // call is valid on empty list; when so, list_links.next and after_links.prev have otags set @@ -657,7 +662,7 @@ } - static inline tE & remove_last( dlist(tE, tLinks) &lst ) { - verify (&lst != 0p); - dlink(tE) & list_links = lst; + static inline tE & remove_last( dlist(tE, tLinks) &list ) { + verify (&list != 0p); + dlink(tE) & list_links = list; // call is valid on empty list; when so, list_links.prev and before_links.next have otags set @@ -684,6 +689,6 @@ } - static inline tE & try_pop_first( dlist(tE, tLinks) &lst ) { - tE & first_inlist = first(lst); + static inline tE & try_pop_first( dlist(tE, tLinks) &list ) { + tE & first_inlist = first(list); tE & first_item = first_inlist; if (&first_item) remove(first_inlist); // TODO: should it use pop_front? @@ -691,6 +696,6 @@ } - static inline tE & try_pop_last( dlist(tE, tLinks) &lst ) { - tE & last_inlist = last(lst); + static inline tE & try_pop_last( dlist(tE, tLinks) &list ) { + tE & last_inlist = last(list); tE & last_item = last_inlist; if (&last_item) remove(last_inlist); // TODO: should it use pop_back? Index: libcfa/src/concurrency/channel.hfa =================================================================== --- libcfa/src/concurrency/channel.hfa (revision 00675ed4c2f48a20d015179ca8dc1e151fce57a5) +++ libcfa/src/concurrency/channel.hfa (revision 81ab5ebb3b497e7c713dd340f479f3d7e803ea4a) @@ -117,5 +117,5 @@ printf("Channel %p Producer Blocks: %lu,\tProducer Ops: %lu,\t%.2f%% of Producer ops blocked\n", &c, c_blocks, c_ops, ((double)c_blocks)/c_ops * 100); #endif - verifyf( __handle_waituntil_OR( cons ) || __handle_waituntil_OR( prods ) || isEmpty( cons ) && isEmpty( prods ), + verifyf( __handle_waituntil_OR( cons ) || __handle_waituntil_OR( prods ) || empty( cons ) && empty( prods ), "Attempted to delete channel with waiting threads (Deadlock).\n" ); if ( size != 0 ) delete( buffer ); @@ -123,7 +123,7 @@ size_t get_count( channel(T) & chan ) with(chan) { return __atomic_load_n( &count, __ATOMIC_RELAXED ); } size_t get_size( channel(T) & chan ) with(chan) { return __atomic_load_n( &size, __ATOMIC_RELAXED ); } - bool has_waiters( channel(T) & chan ) with(chan) { return ! isEmpty( cons ) || ! isEmpty( prods ); } - bool has_waiting_consumers( channel(T) & chan ) with(chan) { return ! isEmpty( cons ); } - bool has_waiting_producers( channel(T) & chan ) with(chan) { return ! isEmpty( prods ); } + bool has_waiters( channel(T) & chan ) with(chan) { return ! empty( cons ) || ! empty( prods ); } + bool has_waiting_consumers( channel(T) & chan ) with(chan) { return ! empty( cons ); } + bool has_waiting_producers( channel(T) & chan ) with(chan) { return ! empty( prods ); } // closes the channel and notifies all blocked threads @@ -164,5 +164,5 @@ void flush( channel(T) & chan, T elem ) with(chan) { lock( mutex_lock ); - while ( count == 0 && ! isEmpty( cons ) ) { + while ( count == 0 && ! empty( cons ) ) { __cons_handoff( chan, elem ); } @@ -186,5 +186,5 @@ ConsEmpty: - if ( ! isEmpty( cons ) ) { + if ( ! empty( cons ) ) { if ( ! __handle_waituntil_OR( cons ) ) break ConsEmpty; __cons_handoff( chan, elem ); @@ -233,5 +233,5 @@ // buffer count must be zero if cons are blocked (also handles zero-size case) ConsEmpty: - if ( ! isEmpty( cons ) ) { + if ( ! empty( cons ) ) { if ( ! __handle_waituntil_OR( cons ) ) break ConsEmpty; __cons_handoff( chan, elem ); @@ -261,5 +261,5 @@ count -= 1; front = (front + 1) % size; - if (count == size - 1 && ! isEmpty( prods ) ) { + if (count == size - 1 && ! empty( prods ) ) { if ( ! __handle_waituntil_OR( prods ) ) return; __buf_insert( chan, *(T *)first( prods ).extra ); // do waiting producer work @@ -276,5 +276,5 @@ ZeroSize: - if ( size == 0 && ! isEmpty( prods ) ) { + if ( size == 0 && ! empty( prods ) ) { if ( ! __handle_waituntil_OR( prods ) ) break ZeroSize; __prods_handoff( chan, retval ); @@ -332,5 +332,5 @@ // have to check for the zero size channel case ZeroSize: - if ( size == 0 && ! isEmpty( prods ) ) { + if ( size == 0 && ! empty( prods ) ) { if ( ! __handle_waituntil_OR( prods ) ) break ZeroSize; __prods_handoff( chan, retval ); @@ -384,5 +384,5 @@ // special case of __handle_waituntil_OR, that does some work to avoid starvation/deadlock case bool __handle_pending( dlist( select_node ) & queue, select_node & mine ) { - while ( ! isEmpty( queue ) ) { + while ( ! empty( queue ) ) { // if node not a special OR case or if we win the special OR case race break if ( ! first( queue ).clause_status || first( queue ).park_counter || __pending_set_other( first( queue ), mine, ((unsigned long int)(&(first( queue )))) ) ) @@ -421,5 +421,5 @@ if ( ! node.park_counter ) { // are we special case OR and front of cons is also special case OR - if ( ! unlikely(closed) && ! isEmpty( prods ) && first( prods ).clause_status && ! first( prods ).park_counter ) { + if ( ! unlikely(closed) && ! empty( prods ) && first( prods ).clause_status && ! first( prods ).park_counter ) { if ( ! __make_select_node_pending( node ) ) { unlock( mutex_lock ); @@ -437,5 +437,5 @@ } // check if we can complete operation. If so race to establish winner in special OR case - if ( count != 0 || ! isEmpty( prods ) || unlikely(closed) ) { + if ( count != 0 || ! empty( prods ) || unlikely(closed) ) { if ( ! __make_select_node_available( node ) ) { // we didn't win the race so give up on registering unlock( mutex_lock ); @@ -453,5 +453,5 @@ // have to check for the zero size channel case ZeroSize: - if ( size == 0 && ! isEmpty( prods ) ) { + if ( size == 0 && ! empty( prods ) ) { if ( ! __handle_waituntil_OR( prods ) ) break ZeroSize; __prods_handoff( *chan, *ret ); @@ -522,5 +522,5 @@ if ( ! node.park_counter ) { // are we special case OR and front of cons is also special case OR - if ( ! unlikely(closed) && ! isEmpty( cons ) && first( cons ).clause_status && ! first( cons ).park_counter ) { + if ( ! unlikely(closed) && ! empty( cons ) && first( cons ).clause_status && ! first( cons ).park_counter ) { if ( ! __make_select_node_pending( node ) ) { unlock( mutex_lock ); @@ -537,5 +537,5 @@ } // check if we can complete operation. If so race to establish winner in special OR case - if ( count != size || ! isEmpty( cons ) || unlikely(closed) ) { + if ( count != size || ! empty( cons ) || unlikely(closed) ) { if ( ! __make_select_node_available( node ) ) { // we didn't win the race so give up on registering unlock( mutex_lock ); @@ -554,5 +554,5 @@ // handle blocked consumer case via handoff (buffer is implicitly empty) ConsEmpty: - if ( ! isEmpty( cons ) ) { + if ( ! empty( cons ) ) { if ( ! __handle_waituntil_OR( cons ) ) break ConsEmpty; __cons_handoff( *chan, elem ); Index: libcfa/src/concurrency/cofor.hfa =================================================================== --- libcfa/src/concurrency/cofor.hfa (revision 00675ed4c2f48a20d015179ca8dc1e151fce57a5) +++ libcfa/src/concurrency/cofor.hfa (revision 81ab5ebb3b497e7c713dd340f479f3d7e803ea4a) @@ -33,5 +33,5 @@ void main( cofor_runner & this ) with(this) { - while ( ! done || ! isEmpty( items ) ) { + while ( ! done || ! empty( items ) ) { lock( mutex_lock ); runner_node * node = &remove_first( items ); Index: libcfa/src/concurrency/future.hfa =================================================================== --- libcfa/src/concurrency/future.hfa (revision 00675ed4c2f48a20d015179ca8dc1e151fce57a5) +++ libcfa/src/concurrency/future.hfa (revision 81ab5ebb3b497e7c713dd340f479f3d7e803ea4a) @@ -10,6 +10,6 @@ // Created On : Wed Jan 06 17:33:18 2021 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Nov 24 16:08:52 2025 -// Update Count : 222 +// Last Modified On : Sun Mar 29 21:13:04 2026 +// Update Count : 223 // @@ -173,7 +173,7 @@ bool fulfil$( future(T) & fut ) with( fut ) { // helper - bool ret_val = ! isEmpty( waiters ); + bool ret_val = ! empty( waiters ); state = FUTURE_FULFILLED$; - while ( ! isEmpty( waiters ) ) { + while ( ! empty( waiters ) ) { if ( !__handle_waituntil_OR( waiters ) ) // handle special waituntil OR case break; // if handle_OR returns false then waiters is empty so break @@ -211,5 +211,5 @@ void reset( future(T) & fut ) with( fut ) { // mark future as empty (for reuse) lock( lock ); - if ( ! isEmpty( waiters ) ) abort( "Attempting to reset a future with blocked waiters" ); + if ( ! empty( waiters ) ) abort( "Attempting to reset a future with blocked waiters" ); state = FUTURE_EMPTY$; free( except ); Index: libcfa/src/concurrency/io.cfa =================================================================== --- libcfa/src/concurrency/io.cfa (revision 00675ed4c2f48a20d015179ca8dc1e151fce57a5) +++ libcfa/src/concurrency/io.cfa (revision 81ab5ebb3b497e7c713dd340f479f3d7e803ea4a) @@ -594,5 +594,5 @@ lock( queue.lock __cfaabi_dbg_ctx2 ); { - was_empty = isEmpty( queue.queue ); + was_empty = empty( queue.queue ); // Add our request to the list @@ -632,5 +632,5 @@ // notify the arbiter that new allocations are available static void __ioarbiter_notify( io_arbiter$ & this, io_context$ * ctx ) { - /* paranoid */ verify( ! isEmpty( this.pending.queue ) ); + /* paranoid */ verify( ! empty( this.pending.queue ) ); /* paranoid */ verify( __preemption_enabled() ); @@ -642,5 +642,5 @@ // as long as there are pending allocations try to satisfy them // for simplicity do it in FIFO order - while( ! isEmpty( this.pending.queue ) ) { + while( ! empty( this.pending.queue ) ) { // get first pending allocs __u32 have = ctx->sq.free_ring.tail - ctx->sq.free_ring.head; @@ -727,5 +727,5 @@ // pop each operation one at a time. // There is no wait morphing because of the io sq ring - while( ! isEmpty( ctx.ext_sq.queue ) ) { + while( ! empty( ctx.ext_sq.queue ) ) { // drop the element from the queue __external_io & ei = (__external_io&)remove_first( ctx.ext_sq.queue ); Index: libcfa/src/concurrency/kernel.cfa =================================================================== --- libcfa/src/concurrency/kernel.cfa (revision 00675ed4c2f48a20d015179ca8dc1e151fce57a5) +++ libcfa/src/concurrency/kernel.cfa (revision 81ab5ebb3b497e7c713dd340f479f3d7e803ea4a) @@ -10,6 +10,6 @@ // Created On : Tue Jan 17 12:27:26 2017 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Apr 25 07:02:42 2025 -// Update Count : 82 +// Last Modified On : Sun Mar 29 21:20:54 2026 +// Update Count : 83 // @@ -785,5 +785,5 @@ // update the pointer to the head wait context struct __fd_waitctx * wctx = 0; - if ( ! isEmpty( this.idles )) wctx = &first( this. idles ).idle_wctx; + if ( ! empty( this.idles )) wctx = &first( this. idles ).idle_wctx; __atomic_store_n(&this.fdw, wctx, __ATOMIC_SEQ_CST); } Index: libcfa/src/concurrency/select.hfa =================================================================== --- libcfa/src/concurrency/select.hfa (revision 00675ed4c2f48a20d015179ca8dc1e151fce57a5) +++ libcfa/src/concurrency/select.hfa (revision 81ab5ebb3b497e7c713dd340f479f3d7e803ea4a) @@ -11,6 +11,6 @@ // Created On : Thu Jan 21 19:46:50 2023 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun Nov 23 22:38:36 2025 -// Update Count : 8 +// Last Modified On : Sun Mar 29 21:12:52 2026 +// Update Count : 9 // @@ -169,7 +169,7 @@ // Returns true if execution can continue normally and false if the queue has now been drained static inline bool __handle_waituntil_OR( dlist( select_node ) & queue ) { - if ( isEmpty( queue ) ) return false; + if ( empty( queue ) ) return false; if ( first( queue ).clause_status && ! first( queue ).park_counter ) { - while ( ! isEmpty( queue ) ) { + while ( ! empty( queue ) ) { // if node not a special OR case or if we win the special OR case race break if ( ! first( queue ).clause_status || first( queue ).park_counter || __make_select_node_available( first( queue ) ) ) Index: tests/list/dlist-insert-remove.cfa =================================================================== --- tests/list/dlist-insert-remove.cfa (revision 00675ed4c2f48a20d015179ca8dc1e151fce57a5) +++ tests/list/dlist-insert-remove.cfa (revision 81ab5ebb3b497e7c713dd340f479f3d7e803ea4a) @@ -1436,5 +1436,5 @@ // Section 4g // -// Test cases of isEmpty, isFirst, isLast, +// Test cases of empty, isFirst, isLast, // remove_first, remove_last, modifications via iter // @@ -1449,9 +1449,9 @@ mary m3 = {3.7}; - dlist(mary) ml; assert( isEmpty( ml )); - - insert_last(ml, m1); assert(!isEmpty( ml )); - insert_last(ml, m2); assert(!isEmpty( ml )); - insert_last(ml, m3); assert(!isEmpty( ml )); + dlist(mary) ml; assert(empty( ml )); + + insert_last(ml, m1); assert(!empty( ml )); + insert_last(ml, m2); assert(!empty( ml )); + insert_last(ml, m3); assert(!empty( ml )); mary & m1prev = prev( m1 ); @@ -1494,5 +1494,5 @@ // queue, back to front - assert( isEmpty( ml )); + assert(empty( ml )); insert_last(ml, m1); @@ -1500,8 +1500,8 @@ insert_last(ml, m3); - &m1r = & remove_first(ml); assert(!isEmpty( ml )); - &m2r = & remove_first(ml); assert(!isEmpty( ml )); - &m3r = & remove_first(ml); assert( isEmpty( ml )); - &mxr = & remove_first(ml); assert( isEmpty( ml )); + &m1r = & remove_first(ml); assert(!empty( ml )); + &m2r = & remove_first(ml); assert(!empty( ml )); + &m3r = & remove_first(ml); assert(empty( ml )); + &mxr = & remove_first(ml); assert(empty( ml )); assert( &m1r == &m1 ); @@ -1516,5 +1516,5 @@ // queue, front to back - assert( isEmpty( ml )); + assert(empty( ml )); insert_first(ml, m1); @@ -1522,8 +1522,8 @@ insert_first(ml, m3); - &m1r = & remove_last(ml); assert(!isEmpty( ml )); - &m2r = & remove_last(ml); assert(!isEmpty( ml )); - &m3r = & remove_last(ml); assert( isEmpty( ml )); - &mxr = & remove_last(ml); assert( isEmpty( ml )); + &m1r = & remove_last(ml); assert(!empty( ml )); + &m2r = & remove_last(ml); assert(!empty( ml )); + &m3r = & remove_last(ml); assert(empty( ml )); + &mxr = & remove_last(ml); assert(empty( ml )); assert( &m1r == &m1 ); @@ -1538,5 +1538,5 @@ // stack at front - assert( isEmpty( ml )); + assert(empty( ml )); insert_first(ml, m1); @@ -1544,8 +1544,8 @@ insert_first(ml, m3); - &m3r = & remove_first(ml); assert(!isEmpty( ml )); - &m2r = & remove_first(ml); assert(!isEmpty( ml )); - &m1r = & remove_first(ml); assert( isEmpty( ml )); - &mxr = & remove_first(ml); assert( isEmpty( ml )); + &m3r = & remove_first(ml); assert(!empty( ml )); + &m2r = & remove_first(ml); assert(!empty( ml )); + &m1r = & remove_first(ml); assert(empty( ml )); + &mxr = & remove_first(ml); assert(empty( ml )); assert( &m1r == &m1 ); @@ -1560,5 +1560,5 @@ // stack at back - assert( isEmpty( ml )); + assert(empty( ml )); insert_last(ml, m1); @@ -1566,8 +1566,8 @@ insert_last(ml, m3); - &m3r = & remove_last(ml); assert(!isEmpty( ml )); - &m2r = & remove_last(ml); assert(!isEmpty( ml )); - &m1r = & remove_last(ml); assert( isEmpty( ml )); - &mxr = & remove_last(ml); assert( isEmpty( ml )); + &m3r = & remove_last(ml); assert(!empty( ml )); + &m2r = & remove_last(ml); assert(!empty( ml )); + &m1r = & remove_last(ml); assert(empty( ml )); + &mxr = & remove_last(ml); assert(empty( ml )); assert( &m1r == &m1 ); @@ -1593,5 +1593,5 @@ insert_before( iter( ml ), m1 ); - assert( ! isEmpty( ml ) ); + assert( !empty( ml ) ); mary & mlfirst = first( ml );