Changes in / [e2f601f:8cd5434]

Files:

• libcfa/src/Makefile.am (modified) (1 diff)
• libcfa/src/concurrency/alarm.hfa (modified) (3 diffs)
• libcfa/src/concurrency/kernel.cfa (modified) (1 diff)
• libcfa/src/concurrency/kernel.hfa (modified) (4 diffs)
• libcfa/src/concurrency/ready_queue.cfa (modified) (1 diff)
• libcfa/src/containers/list.hfa (modified) (1 diff)
• libcfa/src/containers/list2.hfa (added)
• libcfa/src/executor.baseline.txt (deleted)
• libcfa/src/executor.cfa (modified) (2 diffs)
• src/Concurrency/Keywords.cc (modified) (2 diffs)
• tests/list/.expect/dlist-insert-remove-2.txt (added)
• tests/list/.expect/dlist-insert-remove.txt (modified) (3 diffs)
• tests/list/dlist-insert-remove-2.cfa (added)
• tests/list/dlist-insert-remove.cfa (modified) (76 diffs)
• tests/zombies/linked-list-perf/experiment.koad (modified) (2 diffs)
• tests/zombies/linked-list-perf/mike-old.hfa (deleted)

libcfa/src/Makefile.am

@@ -59 +59 @@
         concurrency/iofwd.hfa \
         containers/list.hfa \
+        containers/list2.hfa \
         containers/queueLockFree.hfa \
         containers/stackLockFree.hfa \

libcfa/src/concurrency/alarm.hfa

@@ -49 +49 @@
         Duration period;                        // if > 0 => period of alarm
 
-        inline dlink(alarm_node_t);
+        DLISTED_MGD_IMPL_IN(alarm_node_t)
 
         union {
@@ -60 +60 @@
         enum alarm_type type;           // true if this is not a user defined alarm
 };
-P9_EMBEDDED( alarm_node_t, dlink(alarm_node_t) )
+DLISTED_MGD_IMPL_OUT(alarm_node_t)
 
 void ?{}( alarm_node_t & this, $thread * thrd, Time alarm, Duration period );
@@ -67 +67 @@
 void ^?{}( alarm_node_t & this );
 
-typedef dlist(alarm_node_t) alarm_list_t;
+typedef dlist(alarm_node_t, alarm_node_t) alarm_list_t;
 
 void insert( alarm_list_t * this, alarm_node_t * n );

libcfa/src/concurrency/kernel.cfa

@@ -903 +903 @@
         }
 
-        static void crawl_list( cluster * cltr, dlist(processor) & list, unsigned count ) {
+        static void crawl_list( cluster * cltr, dlist(processor, processor) & list, unsigned count ) {
                 /* paranoid */ verify( cltr->stats );
 

libcfa/src/concurrency/kernel.hfa

@@ -107 +107 @@
 
         // Link lists fields
-        inline dlink(processor);
+        DLISTED_MGD_IMPL_IN(processor)
 
         // special init fields
@@ -129 +129 @@
 #endif
 };
-P9_EMBEDDED( processor, dlink(processor) )
 
 void  ?{}(processor & this, const char name[], struct cluster & cltr);
@@ -137 +136 @@
 static inline void  ?{}(processor & this, struct cluster & cltr) { this{ "Anonymous Processor", cltr}; }
 static inline void  ?{}(processor & this, const char name[])     { this{name, *mainCluster}; }
+
+DLISTED_MGD_IMPL_OUT(processor)
 
 //-----------------------------------------------------------------------------
@@ -191 +192 @@
 
         // List of idle processors
-        dlist(processor) idles;
+        dlist(processor, processor) idles;
 
         // List of active processors
-        dlist(processor) actives;
+        dlist(processor, processor) actives;
 };
 

libcfa/src/concurrency/ready_queue.cfa

@@ -552 +552 @@
 }
 
-static void assign_list(unsigned & value, dlist(processor) & list, unsigned count) {
+static void assign_list(unsigned & value, dlist(processor, processor) & list, unsigned count) {
         processor * it = &list`first;
         for(unsigned i = 0; i < count; i++) {

libcfa/src/containers/list.hfa

@@ -18 +18 @@
 #include <assert.h>
 
-forall( Decorator &, T & )
-struct tytagref {
-    inline T &;
+#define __DLISTED_MGD_COMMON(ELEM, NODE, LINKS_FLD) \
+static inline ELEM& $tempcv_n2e(NODE &node) { \
+        return node; \
+} \
+\
+static inline NODE& $tempcv_e2n(ELEM &node) { \
+        return ( NODE & ) node; \
+} \
+\
+static inline ELEM & ?`prev(NODE &node) { \
+    $dlinks(ELEM) & ls = node.LINKS_FLD; \
+        $mgd_link(ELEM) * l = &ls.prev; \
+        ELEM * e = l->elem; \
+        return *e; \
+} \
+\
+static inline ELEM & ?`next(NODE &node) { \
+    $dlinks(ELEM) & ls = node.LINKS_FLD; \
+        $mgd_link(ELEM) * l = &ls.next; \
+        ELEM * e = l->elem; \
+        return *e; \
+} \
+\
+static inline $mgd_link(ELEM) & $prev_link(NODE &node) { \
+    $dlinks(ELEM) & ls = node.LINKS_FLD; \
+        $mgd_link(ELEM) * l = &ls.prev; \
+        return *l; \
+} \
+\
+static inline $mgd_link(ELEM) & $next_link(NODE &node) { \
+    $dlinks(ELEM) & ls = node.LINKS_FLD; \
+        $mgd_link(ELEM) * l = &ls.next; \
+        return *l; \
+}
+
+#define __DLISTED_MGD_JUSTEXPL(STRUCT, IN_THELIST, STRUCT_IN_THELIST) \
+struct STRUCT_IN_THELIST { \
+        inline STRUCT; \
+}; \
+\
+void ?{}(STRUCT_IN_THELIST &) = void; \
+\
+static inline STRUCT_IN_THELIST& ?`IN_THELIST(STRUCT &this) { \
+        return (STRUCT_IN_THELIST&)this; \
+}
+
+#define __DLISTED_MGD_JUSTIMPL(STRUCT)
+
+forall( tE & ) {
+        struct $mgd_link {
+                tE *elem;
+                void *terminator;
+                _Bool is_terminator;
+                // will collapse to single pointer with tag bit
+        };
+        static inline void ?{}( $mgd_link(tE) &this, tE* elem ) {
+                (this.elem){ elem };
+                (this.terminator){ 0p };
+                (this.is_terminator){ 0 };
+        }
+        static inline void ?{}( $mgd_link(tE) &this, void * terminator ) {
+                (this.elem){ 0p };
+                (this.terminator){ terminator };
+                (this.is_terminator){ 1 };
+        }
+        static inline void ?=?( $mgd_link(tE) &this, tE* elem ) {
+                this.elem = elem ;
+                this.terminator = 0p;
+                this.is_terminator = 0;
+        }
+        static inline void ?=?( $mgd_link(tE) &this, void * terminator ) {
+                this.elem = 0p;
+                this.terminator = terminator;
+                this.is_terminator = 1;
+        }
+        struct $dlinks {
+                // containing item is not listed
+                // iff
+                // links have (elem == 0p && terminator == 0p)
+                $mgd_link(tE) next;
+                $mgd_link(tE) prev;
+        };
+        static inline void ?{}( $dlinks(tE) &this ) {
+                (this.next){ (tE *)0p };
+                (this.prev){ (tE *)0p };
+        }
+}
+
+#define DLISTED_MGD_EXPL_IN(STRUCT, LIST_SUF) \
+  $dlinks(STRUCT) $links_ ## LIST_SUF;
+
+#define DLISTED_MGD_EXPL_OUT(STRUCT, LIST_SUF) \
+  __DLISTED_MGD_JUSTEXPL(STRUCT, in_##LIST_SUF, STRUCT ## _in_ ## LIST_SUF) \
+  __DLISTED_MGD_COMMON(STRUCT, STRUCT##_in_##LIST_SUF,  $links_ ## LIST_SUF)
+
+#define DLISTED_MGD_IMPL_IN(STRUCT) \
+  $dlinks(STRUCT) $links;
+
+#define DLISTED_MGD_IMPL_OUT(STRUCT) \
+  __DLISTED_MGD_JUSTIMPL(STRUCT) \
+  __DLISTED_MGD_COMMON(STRUCT, STRUCT, $links)
+
+trait $dlistable(Tnode &, Telem &) {
+        $mgd_link(Telem) & $prev_link(Tnode &);
+        $mgd_link(Telem) & $next_link(Tnode &);
+        Telem& $tempcv_n2e(Tnode &);
+        Tnode& $tempcv_e2n(Telem &);
+
+        Telem& ?`next(Tnode &);
+        Telem& ?`prev(Tnode &);
 };
 
-trait embedded( tOuter &, tMid &, tInner & ) {
-    tytagref( tMid, tInner ) ?`inner( tOuter & );
-};
-
-// embedded is reflexive, with no info (void) as the type tag
-forall (T &)
-static inline tytagref(void, T) ?`inner ( T & this ) { tytagref( void, T ) ret = {this}; return ret; }
-
-// use this on every case of plan-9 inheritance, to make embedded a closure of plan-9 inheritance
-#define P9_EMBEDDED( derived, immedBase ) \
-forall( Tbase &, TdiscardPath & | { tytagref( TdiscardPath, Tbase ) ?`inner( immedBase & ); } ) \
-    static inline tytagref(immedBase, Tbase) ?`inner( derived & this ) { \
-        immedBase & ib = this; \
-        Tbase & b = ib`inner; \
-        tytagref(immedBase, Tbase) result = { b }; \
-        return result; \
-    }
-
-#define EMBEDDED_VIA( OUTER, MID, INNER ) \
-   (struct { tytagref(MID, INNER) ( * ?`inner ) ( OUTER & ); }){ ?`inner } 
-
-#define DLINK_VIA( TE, TLINK ) \
-   EMBEDDED_VIA( TE, TLINK, dlink(TE) )
-
-
-// The origin is the position encountered at the start of iteration,
-// signifying, "need to advance to the first element," and at the end
-// of iteration, signifying, "no more elements."  Normal comsumption of
-// an iterator runs ?`moveNext as the first step, and uses the return
-// of ?`moveNext as a guard, before dereferencing the iterator.  So
-// normal consumption of an iterator does not dereference an iterator
-// in origin position.  The value of a pointer (underlying a refence)
-// that is exposed publicly as an iteraor, and also a pointer stored
-// internally in a link field, is tagged, to indicate "is the origin"
-// (internally, is the list-head sentinel node), or untagged, to indicate
-// "is a regular node."  Intent is to help a user who dereferences an
-// iterator in origin position (which would be an API-use error on their
-// part), by failing fast.
-
-#if defined( __x86_64 )
-    // Preferred case: tag in the most-significant bit.  Dereference
-    // has been shown to segfault consistently.  Maintenance should
-    // list more architectures as "ok" here, to let them use the
-    // preferred case, when valid.
-    #define ORIGIN_TAG_BITNO ( 8 * sizeof( size_t ) - 1 )
-#else
-    // Fallback case: tag in the least-significant bit.  Dereference
-    // will often give an alignment error, but may not, e.g. if
-    // accessing a char-typed member.  32-bit x86 uses the most-
-    // significant bit for real room on the heap.
-    #define ORIGIN_TAG_BITNO 0
-#endif
-#define ORIGIN_TAG_MASK (((size_t)1) << ORIGIN_TAG_BITNO)
-
-#define ORIGIN_TAG_SET(p)   ((p) |  ORIGIN_TAG_MASK)
-#define ORIGIN_TAG_CLEAR(p) ((p) & ~ORIGIN_TAG_MASK)
-#define ORIGIN_TAG_QUERY(p) ((p) &  ORIGIN_TAG_MASK)
-
-
-forall( tE & ) {
-
-    struct dlink{
-        tE *next;
-        tE *prev;
-    };
-
-    static inline void ?{}( dlink(tE) & this ) {
-        this.next = 0p;
-        this.prev = 0p;
-    }
-
-    forall( tLinks & = dlink(tE) )
-    struct dlist {
-        inline dlink(tE);
-    };
-
-    forall( tLinks & | embedded( tE, tLinks, dlink(tE) ) ) {
-        static inline tE * $get_list_origin_addr( dlist(tE, tLinks) & lst ) {
-            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 preResult = ORIGIN_TAG_SET( origin_addr );
-            return (tE *)preResult;
-        }
-
-        static inline void ?{}( dlist(tE, tLinks) & this ) {
-            tE * listOrigin = $get_list_origin_addr( this );
-            ( ( dlink(tE) & ) this ){ listOrigin, listOrigin } ;
-        }
-    }
-
-}
-
-
-forall( tE &, tLinks & | embedded( tE, tLinks, dlink(tE) ) ) {
-
-        static inline void insert_after(tE & list_pos, tE &to_insert) {
+forall (Tnode &, Telem & | $dlistable(Tnode, Telem)) {
+
+        // implemented as a sentinel item in an underlying cicrular list
+        // theList.$links.next is first
+        // theList.$links.prev is last
+        // note this allocation preserves prev-next composition as an identity
+        struct dlist {
+                $dlinks(Telem) $links;
+        };
+
+        // an empty dlist
+        // links refer to self, making a tight circle
+        static inline void ?{}( dlist(Tnode, Telem) & this ) {
+                $mgd_link(Telem) selfRef = (void *) &this;
+                ( this.$links ) { selfRef, selfRef };
+        }
+
+        static inline Telem & ?`first( dlist(Tnode, Telem) &l ) {
+                return * l.$links.next.elem;
+        }
+
+        static inline Telem & ?`last( dlist(Tnode, Telem) &l ) {
+                return * l.$links.prev.elem;
+        }
+
+        #if !defined(NDEBUG) && (defined(__CFA_DEBUG__) || defined(__CFA_VERIFY__))
+        static bool $validate_fwd( dlist(Tnode, Telem) & this ) {
+                Tnode * it = & $tempcv_e2n( this`first );
+                if (!it) return (& this`last == 0p);
+
+                while( $next_link(*it).elem ) {
+                        it = & $tempcv_e2n( * $next_link(*it).elem );
+                }
+
+                return ( it == & $tempcv_e2n( this`last ) ) &&
+                           ( $next_link(*it).is_terminator ) &&
+                           ( ((dlist(Tnode, Telem)*)$next_link(*it).terminator) == &this );
+        }
+        static bool $validate_rev( dlist(Tnode, Telem) & this ) {
+                Tnode * it = & $tempcv_e2n( this`last );
+                if (!it) return (& this`first == 0p);
+
+                while( $prev_link(*it).elem ) {
+                        it = & $tempcv_e2n( * $prev_link(*it).elem );
+                }
+
+                return ( it == & $tempcv_e2n( this`first ) ) &&
+                           ( $prev_link(*it).is_terminator ) &&
+                           ( ((dlist(Tnode, Telem)*)$prev_link(*it).terminator) == &this );
+        }
+        static bool validate( dlist(Tnode, Telem) & this ) {
+                return $validate_fwd(this) && $validate_rev(this);
+        }
+        #endif
+
+        static inline void insert_after(Tnode &list_pos, Telem &to_insert) {
                 verify (&list_pos != 0p);
                 verify (&to_insert != 0p);
-        dlink(tE) & linkToInsert = to_insert`inner;
-                verify(linkToInsert.prev == 0p);
-                verify(linkToInsert.next == 0p);
-        tE & list_pos_raw = list_pos;
-        tE & list_pos_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & list_pos_raw );
-        dlink(tE) & list_pos_links = list_pos_elem`inner;
-        asm( "" : : : "memory" );
-        tE & after_raw = * list_pos_links.next;
-        tE & after_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & after_raw );
-                linkToInsert.prev = & list_pos_raw;
-                linkToInsert.next = & after_raw;
-        dlink(tE) & afterLinks = after_elem`inner;
-        afterLinks.prev = &to_insert;
-                list_pos_links.next = &to_insert;
-        asm( "" : : : "memory" );
-        }
-
-        static inline void insert_before(tE & list_pos, tE &to_insert) {
+                Tnode &singleton_to_insert = $tempcv_e2n(to_insert);
+                verify($prev_link(singleton_to_insert).elem == 0p);
+                verify($next_link(singleton_to_insert).elem == 0p);
+                $prev_link(singleton_to_insert) = & $tempcv_n2e(list_pos);
+                $next_link(singleton_to_insert) = $next_link(list_pos);
+                if ($next_link(list_pos).is_terminator) {
+                        dlist(Tnode, Telem) *list = ( dlist(Tnode, Telem) * ) $next_link(list_pos).terminator;
+                        $dlinks(Telem) *list_links = & list->$links;
+                        $mgd_link(Telem) *list_last = & list_links->prev;
+                        *list_last = &to_insert;
+                } else {
+                        Telem *list_pos_next = $next_link(list_pos).elem;
+                        if (list_pos_next) {
+                                Tnode & lpn_inlist = $tempcv_e2n(*list_pos_next);
+                                $prev_link(lpn_inlist) = &to_insert;
+                        }
+                }
+                $next_link(list_pos) = &to_insert;
+        }
+
+        static inline void insert_before(Tnode &list_pos, Telem &to_insert) {
                 verify (&list_pos != 0p);
                 verify (&to_insert != 0p);
-        dlink(tE) & linkToInsert = to_insert`inner;
-                verify(linkToInsert.next == 0p);
-                verify(linkToInsert.prev == 0p);
-        tE & list_pos_raw = list_pos;
-        tE & list_pos_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & list_pos_raw );
-        dlink(tE) & list_pos_links = list_pos_elem`inner;
-        asm( "" : : : "memory" );
-        tE & before_raw = * (list_pos_links).prev;
-        tE & before_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & before_raw );
-                linkToInsert.next = & list_pos_raw;
-                linkToInsert.prev = & before_raw;
-        dlink(tE) & beforeLinks = before_elem`inner;
-        beforeLinks.next = &to_insert;
-                (list_pos_links).prev = &to_insert;
-        asm( "" : : : "memory" );
-        }
-
-        static inline tE & remove(tE & list_pos) {
-                verify (&list_pos != 0p);
-        tE & list_pos_elem = list_pos;
-        verify( ! ORIGIN_TAG_QUERY((size_t) & list_pos_elem) );
-        dlink(tE) & list_pos_links = list_pos_elem`inner;
-        tE & before_raw = * list_pos_links.prev;
-        tE & before_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & before_raw );
-        dlink(tE) & before_links = before_elem`inner;
-        tE & after_raw = * list_pos_links.next;
-        tE & after_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & after_raw );
-        dlink(tE) & after_links = after_elem`inner;
-        before_links.next = &after_raw;
-        after_links.prev = &before_raw;
-        asm( "" : : : "memory" );
-                list_pos_links.prev = 0p;
-                list_pos_links.next = 0p;
-        asm( "" : : : "memory" );
-        return list_pos_elem;
-        }
-
-    static inline tE & ?`first( dlist(tE, tLinks) &lst ) {
-        tE * firstPtr = lst.next;
-        if (ORIGIN_TAG_QUERY((size_t)firstPtr)) firstPtr = 0p;
-        return *firstPtr;
-    }
-    static inline tE & ?`last ( dlist(tE, tLinks) &lst ) {
-        tE * lastPtr = lst.prev;
-        if (ORIGIN_TAG_QUERY((size_t)lastPtr)) lastPtr = 0p;
-        return *lastPtr;
-    }
-
-    static inline bool ?`isEmpty( dlist(tE, tLinks) & lst ) {
-        tE * firstPtr = lst.next;
-        if (ORIGIN_TAG_QUERY((size_t)firstPtr)) firstPtr = 0p;
-        return firstPtr == 0p;
-    }
-
-    static inline tE & ?`elems( dlist(tE, tLinks) & lst ) {
-        tE * origin = $get_list_origin_addr( lst );
-        return *origin;
-    }
-
-    static inline bool ?`moveNext( tE && refx ) {
-        tE && ref_inner = refx;
-        tE & oldReferent = * (tE*) ORIGIN_TAG_CLEAR( (size_t) & ref_inner );
-        &ref_inner = oldReferent`inner.next;
-        return &ref_inner != 0p  &&
-            ! ORIGIN_TAG_QUERY( (size_t) & ref_inner );
-    }
-
-    static inline bool ?`movePrev( tE && refx ) {
-        tE && ref_inner = refx;
-        tE & oldReferent = * (tE*) ORIGIN_TAG_CLEAR( (size_t) & ref_inner );
-        &ref_inner = oldReferent`inner.prev;
-        return &ref_inner != 0p  &&
-            ! ORIGIN_TAG_QUERY( (size_t) & ref_inner );
-    }
-
-    static inline bool ?`hasNext( tE & e ) {
-        return e`moveNext;
-    }
-
-    static inline bool ?`hasPrev( tE & e ) {
-        return e`movePrev;
-    }
-
-    static inline tE & ?`next( tE & e ) {
-        if( e`moveNext ) return e;
-        return * 0p;
-    }
-
-    static inline tE & ?`prev( tE & e ) {
-        if( e`movePrev ) return e;
-        return * 0p;
-    }
-
-    static inline void insert_first( dlist(tE, tLinks) &lst, tE & e ) {
-        insert_after(lst`elems, e);
-    }
-
-    static inline void insert_last( dlist(tE, tLinks) &lst, tE & e ) {
-        insert_before(lst`elems, e);
-    }
-
-    static inline tE & try_pop_front( dlist(tE, tLinks) &lst ) {
-        tE & first_inlist = lst`first;
-        tE & first_item = first_inlist;
-        if (&first_item) remove(first_inlist);
-        return first_item;
-    }
-
-    static inline tE & try_pop_back( dlist(tE, tLinks) &lst ) {
-        tE & last_inlist = lst`last;
-        tE & last_item = last_inlist;
-        if (&last_item) remove(last_inlist);
-        return last_item;
-    }
-
-
-  #if !defined(NDEBUG) && (defined(__CFA_DEBUG__) || defined(__CFA_VERIFY__))
-        static bool $validate_fwd( dlist(tE, tLinks) & this ) {
-        if ( ! & this`first ) return ( (& this`last) == 0p);
-
-        tE & lagElem = *0p;
-
-        while ( tE & it = this`elems; it`moveNext ) {
-            if (& lagElem == 0p &&  &it != & this`first ) return false;
-            & lagElem = & it;
-        }
-
-        if (& lagElem != & this`last) return false;
-
-        // TODO: verify that it is back at this`elems;
-        return true;
-        }
-        static bool $validate_rev( dlist(tE, tLinks) & this ) {
-        if ( ! & this`last ) return ( (& this`first) == 0p);
-
-        tE & lagElem = *0p;
-
-        while ( tE & it = this`elems; it`movePrev ) {
-            if (& lagElem == 0p &&  &it != & this`last ) return false;
-            & lagElem = & it;
-        }
-
-        if (& lagElem != & this`first) return false;
-
-        // TODO: verify that it is back at this`elems;
-        return true;
-        }
-        static bool validate( dlist(tE, tLinks) & this ) {
-                return $validate_fwd(this) && $validate_rev(this);
-        }
-  #endif
+                Tnode &singleton_to_insert = $tempcv_e2n(to_insert);
+                verify($prev_link(singleton_to_insert).elem == 0p);
+                verify($next_link(singleton_to_insert).elem == 0p);
+                $next_link(singleton_to_insert) = & $tempcv_n2e(list_pos);
+                $prev_link(singleton_to_insert) = $prev_link(list_pos);
+                if ($prev_link(list_pos).is_terminator) {
+                        dlist(Tnode, Telem) *list = ( dlist(Tnode, Telem) * ) $prev_link(list_pos).terminator;
+                        $dlinks(Telem) *list_links = & list->$links;
+                        $mgd_link(Telem) *list_first = & list_links->next;
+                        *list_first = &to_insert;
+                } else {
+                        Telem *list_pos_prev = $prev_link(list_pos).elem;
+                        if (list_pos_prev) {
+                                Tnode & lpp_inlist = $tempcv_e2n(*list_pos_prev);
+                                $next_link(lpp_inlist) = &to_insert;
+                        }
+                }
+                $prev_link(list_pos) = &to_insert;
+        }
+
+    static inline void insert_first(dlist(Tnode, Telem) &list, Telem &to_insert) {
+                verify (&list != 0p);
+                verify (&to_insert != 0p);
+                Tnode &singleton_to_insert = $tempcv_e2n(to_insert);
+                verify($prev_link(singleton_to_insert).elem == 0p);
+                verify($next_link(singleton_to_insert).elem == 0p);
+
+                $prev_link(singleton_to_insert) = (void*) &list;
+                $next_link(singleton_to_insert) = list.$links.next;
+
+                $dlinks(Telem) *listLinks = & list.$links;
+                if (listLinks->next.is_terminator) {
+                        $mgd_link(Telem) * listPrevReference = & listLinks->prev;
+                        *listPrevReference = &to_insert;
+                } else {
+                        Tnode & next_inlist = $tempcv_e2n(*list.$links.next.elem);
+                        $prev_link(next_inlist) = &to_insert;
+                }
+                $mgd_link(Telem) * listNextReference = & listLinks->next;
+                *listNextReference = &to_insert;
+        }
+
+    static inline void insert_last(dlist(Tnode, Telem) &list, Telem &to_insert) {
+                verify (&list != 0p);
+                verify (&to_insert != 0p);
+                Tnode &singleton_to_insert = $tempcv_e2n(to_insert);
+                verify($next_link(singleton_to_insert).elem == 0p);
+                verify($prev_link(singleton_to_insert).elem == 0p);
+
+                $next_link(singleton_to_insert) = (void*) &list;
+                $prev_link(singleton_to_insert) = list.$links.prev;
+
+                $dlinks(Telem) *listLinks = & list.$links;
+                if (listLinks->prev.is_terminator) {
+                        $mgd_link(Telem) * listNextReference = & listLinks->next;
+                        *listNextReference = &to_insert;
+                } else {
+                        Tnode & prev_inlist = $tempcv_e2n(*list.$links.prev.elem);
+                        $next_link(prev_inlist) = &to_insert;
+                }
+                $mgd_link(Telem) * listPrevReference = & listLinks->prev;
+                *listPrevReference = &to_insert;
+        }
+
+    static inline void remove(Tnode &list_pos) {
+                verify( &list_pos != 0p );
+
+                $mgd_link(Telem) &incoming_from_prev = *0p;
+                $mgd_link(Telem) &incoming_from_next = *0p;
+
+                if ( $prev_link(list_pos).is_terminator ) {
+                        dlist(Tnode, Telem) * tgt_before = ( dlist(Tnode, Telem) * ) $prev_link(list_pos).terminator;
+                        $dlinks(Telem) * links_before = & tgt_before->$links;
+                        &incoming_from_prev = & links_before->next;
+                } else if ($prev_link(list_pos).elem) {
+                        Telem * tgt_before = $prev_link(list_pos).elem;
+                        Tnode & list_pos_before = $tempcv_e2n(*tgt_before);
+                        &incoming_from_prev = & $next_link(list_pos_before);
+                }
+
+                if ( $next_link(list_pos).is_terminator ) {
+                        dlist(Tnode, Telem) * tgt_after = ( dlist(Tnode, Telem) * ) $next_link(list_pos).terminator;
+                        $dlinks(Telem) * links_after = & tgt_after->$links;
+                        &incoming_from_next = & links_after->prev;
+                } else if ($next_link(list_pos).elem) {
+                        Telem * tgt_after  = $next_link(list_pos).elem;
+                        Tnode & list_pos_after  = $tempcv_e2n(*tgt_after );
+                        &incoming_from_next = & $prev_link(list_pos_after );
+                }
+
+                if (& incoming_from_prev) {
+                        incoming_from_prev = $next_link(list_pos);
+                }
+                if (& incoming_from_next) {
+                        incoming_from_next = $prev_link(list_pos);
+                }
+
+                $next_link(list_pos) = (Telem*) 0p;
+                $prev_link(list_pos) = (Telem*) 0p;
+        }
+
+        static inline bool ?`is_empty(dlist(Tnode, Telem) &list) {
+                verify( &list != 0p );
+                $dlinks(Telem) *listLinks = & list.$links;
+                if (listLinks->next.is_terminator) {
+                        verify(listLinks->prev.is_terminator);
+                        verify(listLinks->next.terminator);
+                        verify(listLinks->prev.terminator);
+                        return true;
+                } else {
+                        verify(!listLinks->prev.is_terminator);
+                        verify(listLinks->next.elem);
+                        verify(listLinks->prev.elem);
+                        return false;
+                }
+        }
+
+        static inline Telem & pop_first(dlist(Tnode, Telem) &list) {
+                verify( &list != 0p );
+                verify( !list`is_empty );
+                $dlinks(Telem) *listLinks = & list.$links;
+                Telem & first = *listLinks->next.elem;
+                Tnode & list_pos_first  = $tempcv_e2n( first );
+                remove(list_pos_first);
+                return first;
+        }
+
+        static inline Telem & pop_last(dlist(Tnode, Telem) &list) {
+                verify( &list != 0p );
+                verify( !list`is_empty );
+                $dlinks(Telem) *listLinks = & list.$links;
+                Telem & last = *listLinks->prev.elem;
+                Tnode & list_pos_last  = $tempcv_e2n( last );
+                remove(list_pos_last);
+                return last;
+        }
 
 }

libcfa/src/executor.cfa

@@ -7 +7 @@
 #include <containers/list.hfa>
 
-forall( T &, TLink& = dlink(T) | embedded(T, TLink, dlink(T)) ) {
+forall( T & | $dlistable(T, T) ) {
         monitor Buffer {                                                                        // unbounded buffer
-                dlist( T, TLink ) queue;                                                // unbounded list of work requests
+                dlist( T, T ) queue;                                                    // unbounded list of work requests
                 condition delay;
         }; // Buffer
 
-        void insert( Buffer(T, TLink) & mutex buf, T * elem ) with(buf) {
-                dlist( T, TLink ) * qptr = &queue;                              // workaround https://cforall.uwaterloo.ca/trac/ticket/166
+        void insert( Buffer(T) & mutex buf, T * elem ) with(buf) {
+                dlist( T, T ) * qptr = &queue;                                  // workaround https://cforall.uwaterloo.ca/trac/ticket/166
                 insert_last( *qptr, *elem );                                    // insert element into buffer
                 signal( delay );                                                                // restart
         } // insert
 
-        T * remove( Buffer(T, TLink) & mutex buf ) with(buf) {
-                dlist( T, TLink ) * qptr = &queue;                              // workaround https://cforall.uwaterloo.ca/trac/ticket/166
-                // if ( (*qptr)`isEmpty ) wait( delay );                // no request to process ? => wait
-          if ( (*qptr)`isEmpty ) return 0p;                                     // no request to process ? => wait
-                return &try_pop_front( *qptr );
+        T * remove( Buffer(T) & mutex buf ) with(buf) {
+                dlist( T, T ) * qptr = &queue;                                  // workaround https://cforall.uwaterloo.ca/trac/ticket/166
+                // if ( (*qptr)`is_empty ) wait( delay );                       // no request to process ? => wait
+          if ( (*qptr)`is_empty ) return 0p;                            // no request to process ? => wait
+                return &pop_first( *qptr );
         } // remove
 } // forall
@@ -29 +29 @@
 struct WRequest {                                                                               // client request, no return
         void (* action)( void );
-        inline dlink(WRequest);
+        DLISTED_MGD_IMPL_IN(WRequest)
 }; // WRequest
-P9_EMBEDDED(WRequest, dlink(WRequest))
+DLISTED_MGD_IMPL_OUT(WRequest)
 
 void ?{}( WRequest & req ) with(req) { action = 0; }

src/Concurrency/Keywords.cc

@@ -432 +432 @@
                                 new ObjectDecl(
                                         Virtual::concurrentDefaultVTableName(),
-                                        noStorageClasses,
+                                        Type::Const,
                                         LinkageSpec::Cforall,
                                         /* bitfieldWidth */ nullptr,
@@ -504 +504 @@
                         new ObjectDecl(
                                 Virtual::concurrentDefaultVTableName(),
-                                Type::StorageClasses( Type::Extern ),
+                                Type::Const,
                                 LinkageSpec::Cforall,
                                 /* bitfieldWidth */ nullptr,

tests/list/.expect/dlist-insert-remove.txt

@@ +1 @@
+~~~~~~~~~~~~~~~~~ Headless List Tests - insert_after ~~~~~~~~~~~~~~~~
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Test 1-i:  Modifying Freds on MINE 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+==== fred by MINE before 
+3.14
+-
+3.14
+-
+0.5
+-
+0.5
+-
+==== fred by YOURS before 
+3.14
+-
+3.14
+-
+0.5
+-
+0.5
+-
+==== fred by MINE after 
+3.14
+0.5
+-
+3.14
+-
+0.5
+-
+0.5
+3.14
+-
+==== fred by YOURS after 
+3.14
+-
+3.14
+-
+0.5
+-
+0.5
+-
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Test 2-i.  Modifying Freds on YOURS
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+==== fred by MINE before 
+3.14
+-
+3.14
+-
+0.5
+-
+0.5
+-
+==== fred by YOURS before 
+3.14
+-
+3.14
+-
+0.5
+-
+0.5
+-
+==== fred by MINE after 
+3.14
+-
+3.14
+-
+0.5
+-
+0.5
+-
+==== fred by YOURS after 
+3.14
+0.5
+-
+3.14
+-
+0.5
+-
+0.5
+3.14
+-
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Test 3-i.  Modifying Maries
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+==== mary before 
+3.14
+-
+3.14
+-
+0.5
+-
+0.5
+-
+==== mary after 
+3.14
+0.5
+-
+3.14
+-
+0.5
+-
+0.5
+3.14
+-
+
+~~~~~~~~~~~~~~~~ Headless List Tests - insert_before ~~~~~~~~~~~~~~~~
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Test 1-ii:  Modifying Freds on MINE 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+==== fred by MINE before 
+3.14
+-
+3.14
+-
+0.5
+-
+0.5
+-
+==== fred by YOURS before 
+3.14
+-
+3.14
+-
+0.5
+-
+0.5
+-
+==== fred by MINE after 
+3.14
+0.5
+-
+3.14
+-
+0.5
+-
+0.5
+3.14
+-
+==== fred by YOURS after 
+3.14
+-
+3.14
+-
+0.5
+-
+0.5
+-
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Test 2-ii.  Modifying Freds on YOURS
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+==== fred by MINE before 
+3.14
+-
+3.14
+-
+0.5
+-
+0.5
+-
+==== fred by YOURS before 
+3.14
+-
+3.14
+-
+0.5
+-
+0.5
+-
+==== fred by MINE after 
+3.14
+-
+3.14
+-
+0.5
+-
+0.5
+-
+==== fred by YOURS after 
+3.14
+0.5
+-
+3.14
+-
+0.5
+-
+0.5
+3.14
+-
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Test 3-ii.  Modifying Maries
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+==== mary before 
+3.14
+-
+3.14
+-
+0.5
+-
+0.5
+-
+==== mary after 
+3.14
+0.5
+-
+3.14
+-
+0.5
+-
+0.5
+3.14
+-
 
 ~~~~~~~~~~~~~~~~~ Headed List Tests - insert_first ~~~~~~~~~~~~~~~~~~
@@ -342 +557 @@
 -
 
+~~~~~~~~~~ Element removal tests on Headless List: mid ~~~~~~~~~~
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Test 10-i.  Modifying Freds on MINE
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+==== fred by MINE before 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== fred by YOURS before 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== fred by MINE after 
+1.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+1.7
+-
+==== fred by YOURS after 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== fred by MINE after 
+2.7
+-
+2.7
+-
+-
+-
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Test 11-i.  Modifying Freds on YOURS
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+==== fred by MINE before 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== fred by YOURS before 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== fred by MINE after 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== fred by YOURS after 
+1.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+1.7
+-
+==== fred by YOURS after 
+2.7
+-
+2.7
+-
+-
+-
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Test 12-i.  Modifying Maries
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+==== mary before 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== mary after 
+1.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+1.7
+-
+==== mary after 
+2.7
+-
+2.7
+-
+-
+-
+
+~~~~~~~~~~ Element removal tests on Headless List: at first ~~~~~~~~~~
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Test 10-ii.  Modifying Freds on MINE
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+==== fred by MINE before 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== fred by YOURS before 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== fred by MINE after 
+2.7
+3.7
+-
+2.7
+-
+3.7
+-
+3.7
+2.7
+-
+==== fred by YOURS after 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== fred by MINE after 
+1.7
+-
+1.7
+-
+-
+-
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Test 11-ii.  Modifying Freds on YOURS
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+==== fred by MINE before 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== fred by YOURS before 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== fred by MINE after 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== fred by YOURS after 
+2.7
+3.7
+-
+2.7
+-
+3.7
+-
+3.7
+2.7
+-
+==== fred by YOURS after 
+1.7
+-
+1.7
+-
+-
+-
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Test 12-ii.  Modifying Maries
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+==== mary before 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== mary after 
+2.7
+3.7
+-
+2.7
+-
+3.7
+-
+3.7
+2.7
+-
+==== mary after 
+1.7
+-
+1.7
+-
+-
+-
+
+~~~~~~~~~~ Element removal tests on Headless List: at last ~~~~~~~~~~
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Test 10-iii.  Modifying Freds on MINE
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+==== fred by MINE before 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== fred by YOURS before 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== fred by MINE after 
+1.7
+2.7
+-
+1.7
+-
+2.7
+-
+2.7
+1.7
+-
+==== fred by YOURS after 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== fred by MINE after 
+3.7
+-
+3.7
+-
+-
+-
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Test 11-iii.  Modifying Freds on YOURS
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+==== fred by MINE before 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== fred by YOURS before 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== fred by MINE after 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== fred by YOURS after 
+1.7
+2.7
+-
+1.7
+-
+2.7
+-
+2.7
+1.7
+-
+==== fred by YOURS after 
+3.7
+-
+3.7
+-
+-
+-
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Test 12-iii.  Modifying Maries
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+==== mary before 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== mary after 
+1.7
+2.7
+-
+1.7
+-
+2.7
+-
+2.7
+1.7
+-
+==== mary after 
+3.7
+-
+3.7
+-
+-
+-
+
 ~~~~~~~~~~ Element removal tests on Headed List: at first ~~~~~~~~~~
 
@@ -1092 +1778 @@
 -
 -
-
-~~~~~~~~~~~~~~~~~~~ Ease-of-access cases ~~~~~~~~~~~~~~~~~~
-
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Test 18-i.  Modifying Freds on MINE
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Not implmented
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Test 18-ii.  Modifying Freds on YOURS
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Not implmented
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Test 18-iii.  Modifying Maries
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-accessor_cases done
-try_pop cases done
-origin_mutation cases done

tests/list/dlist-insert-remove.cfa

@@ -19 +19 @@
 struct fred {
         float adatum;
-        inline struct mine { inline dlink(fred); };
-        inline struct yours { inline dlink(fred); };
+        DLISTED_MGD_EXPL_IN(fred, mine)
+        DLISTED_MGD_EXPL_IN(fred, yours)
 };
-P9_EMBEDDED(fred, fred.mine)
-P9_EMBEDDED(fred, fred.yours)
-P9_EMBEDDED(fred.mine, dlink(fred))
-P9_EMBEDDED(fred.yours, dlink(fred))
-
+
+DLISTED_MGD_EXPL_OUT(fred, mine)
+DLISTED_MGD_EXPL_OUT(fred, yours)
 
 void ?{}(fred &this, float adatum) {
@@ -35 +33 @@
 struct mary {
         float anotherdatum;
-        inline dlink(mary);
+        DLISTED_MGD_IMPL_IN(mary)
 };
 
-P9_EMBEDDED(mary, dlink(mary))
+DLISTED_MGD_IMPL_OUT(mary)
 
 void ?{}(mary &this, float anotherdatum) {
@@ -55 +53 @@
 ////////////////////////////////////////////////////////////
 
-void printMyFredsFwd(fred & f) {
-    with( DLINK_VIA( fred, fred.mine ) )
-        do {
+void printMyFredsFwd(fred &f) {
+        while (&f != 0p) {
                 sout | f.adatum;
-        } while (f`moveNext);
-}
-
-void printMyFredsRev(fred & f) {
-    with( DLINK_VIA( fred, fred.mine ) )
-        do {
+                &f = &f`in_mine`next;
+        }
+}
+
+void printMyFredsRev(fred &f) {
+        while (&f != 0p) {
                 sout | f.adatum;
-        } while (f`movePrev);
-}
-
+                &f = &f`in_mine`prev;
+        }
+}
 
 void printMyFreddies(fred &f1, fred &f2, int isBefore) {
@@ -76 +73 @@
                 sout | "==== fred by MINE after ";
         }
-        if (&f1) {
-                printMyFredsFwd(f1);    sout | '-';
-                printMyFredsRev(f1);    sout | '-';
-        } else {
-                sout | '-'; sout | '-';
+        printMyFredsFwd(f1);    sout | '-';
+        printMyFredsRev(f1);    sout | '-';
+        printMyFredsFwd(f2);    sout | '-';
+        printMyFredsRev(f2);    sout | '-';
+}
+
+void printYourFredsFwd(fred &f) {
+        while (&f != 0p) {
+                sout | f.adatum;
+                &f = &f`in_yours`next;
         }
-        if (&f2) {
-                printMyFredsFwd(f2);    sout | '-';
-                printMyFredsRev(f2);    sout | '-';
-        } else {
-                sout | '-'; sout | '-';
+}
+
+void printYourFredsRev(fred &f) {
+        while (&f != 0p) {
+                sout | f.adatum;
+                &f = &f`in_yours`prev;
         }
-}
-
-void printYourFredsFwd(fred & f) {
-    with( DLINK_VIA( fred, fred.yours ) )
-        do {
-                sout | f.adatum;
-        } while (f`moveNext);
-}
-
-void printYourFredsRev(fred & f) {
-    with( DLINK_VIA( fred, fred.yours ) )
-        do {
-                sout | f.adatum;
-        } while (f`movePrev);
 }
 
@@ -110 +99 @@
                 sout | "==== fred by YOURS after ";
         }
-        if (&f1) {
-                printYourFredsFwd(f1);  sout | '-';
-                printYourFredsRev(f1);  sout | '-';
-        } else {
-                sout | '-'; sout | '-';
+        printYourFredsFwd(f1);  sout | '-';
+        printYourFredsRev(f1);  sout | '-';
+        printYourFredsFwd(f2);  sout | '-';
+        printYourFredsRev(f2);  sout | '-';
+}
+
+void printMariesFwd(mary &m) {
+        while (&m != 0p) {
+                sout | m.anotherdatum;
+                &m = &m`next;
         }
-        if (&f2) {
-                printYourFredsFwd(f2);  sout | '-';
-                printYourFredsRev(f2);  sout | '-';
-        } else {
-                sout | '-'; sout | '-';
+}
+
+void printMariesRev(mary &m) {
+        while (&m != 0p) {
+                sout | m.anotherdatum;
+                &m = &m`prev;
         }
-}
-
-void printMariesFwd(mary &m) {
-        do {
-                sout | m.anotherdatum;
-        } while (m`moveNext);
-}
-
-void printMariesRev(mary &m) {
-        do {
-                sout | m.anotherdatum;
-        } while (m`movePrev);
 }
 
@@ -142 +125 @@
                 sout | "==== mary after ";
         }
-        if (&m1) {
-                printMariesFwd(m1);     sout | '-';
-                printMariesRev(m1);     sout | '-';
-        } else {
-                sout | '-'; sout | '-';
-        }
-        if (&m2) {
-                printMariesFwd(m2);     sout | '-';
-                printMariesRev(m2);     sout | '-';
-        } else {
-                sout | '-'; sout | '-';
-        }
+        printMariesFwd(m1);     sout | '-';
+        printMariesRev(m1);     sout | '-';
+        printMariesFwd(m2);     sout | '-';
+        printMariesRev(m2);     sout | '-';
 }
 
@@ -178 +153 @@
 //  - from list position #2 moving backward (d)
 // The expected-output comments are in form a;b;c;d where a::=num,num,num
-#if 0
+
 void test__insertafter_singleton_on_singleton__fred_mine () {
         fred f1 = {3.14};
@@ -186 +161 @@
         printYourFreddies(f1, f2, 1);   // 3.14; 3.14; 0.5; 0.5
 
-        diref(fred, fred.mine) f1_mine = f1`from;
-        insert_after(f1_mine, f2);
+        insert_after(f1`in_mine, f2);
 
         printMyFreddies(f1, f2, 0);     // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified)
@@ -200 +174 @@
         printYourFreddies(f1, f2, 1);   // 3.14; 3.14; 0.5; 0.5
 
-        diref(fred, fred.yours) f1_yours = f1`from;
-        insert_after(f1_yours, f2);
+        insert_after(f1`in_yours, f2);
 
         printMyFreddies(f1, f2, 0);     // 3.14; 3.14; 0.5; 0.5 (unmodified)
@@ -235 +208 @@
         printYourFreddies(f1, f2, 1);   // 3.14; 3.14; 0.5; 0.5
 
-        diref(fred, fred.mine) f2_mine = f2`from;
-        insert_before(f2_mine, f1);
+        insert_before(f2`in_mine, f1);
 
         printMyFreddies(f1, f2, 0);     // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified)
@@ -249 +221 @@
         printYourFreddies(f1, f2, 1);   // 3.14; 3.14; 0.5; 0.5
 
-        diref(fred, fred.yours) f2_yours = f2`from;
-        insert_before(f2_yours, f1);
+        insert_before(f2`in_yours, f1);
 
         printMyFreddies(f1, f2, 0);     // 3.14; 3.14; 0.5; 0.5 (unmodified)
@@ -266 +237 @@
         printMariatheotokos(m1, m2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified)
 }
-#endif
+
 ////////////////////////////////////////////////////////////
 //
@@ -279 +250 @@
 // All three tests exercise the case of creating an empty container and
 // adding two items to it.
+
 void test__insertfirst_two_on_empty__fred_mine() {
 
@@ -284 +256 @@
         fred f2 = {0.5};
 
-        dlist(fred, fred.mine) lf;
+        dlist(fred_in_mine, fred) lf;
 
         verify(validate(lf));
@@ -305 +277 @@
         fred f2 = {0.5};
 
-        dlist(fred, fred.yours) lf;
+        dlist(fred_in_yours, fred) lf;
 
         verify(validate(lf));
@@ -320 +292 @@
         printYourFreddies(f1, f2, 0);   // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified)
 }
+
 void test__insertfirst_two_on_empty__mary() {
 
@@ -325 +298 @@
         mary m2 = {0.5};
 
-        dlist(mary) lm;
+        dlist(mary, mary) lm;
 
         verify(validate(lm));
@@ -352 +325 @@
         fred f2 = {0.5};
 
-        dlist(fred, fred.mine) lf;
+        dlist(fred_in_mine, fred) lf;
 
         verify(validate(lf));
@@ -373 +346 @@
         fred f2 = {0.5};
 
-        dlist(fred, fred.yours) lf;
+        dlist(fred_in_yours, fred) lf;
 
         verify(validate(lf));
@@ -394 +367 @@
         mary m2 = {0.5};
 
-        dlist(mary) lm;
+        dlist(mary, mary) lm;
 
         verify(validate(lm));
@@ -421 +394 @@
         fred f2 = {0.5};
 
-        dlist(fred, fred.mine) lf;
-
-        assert( & lf`first == 0p );
-        assert( & lf`last == 0p );
+        dlist(fred_in_mine, fred) lf;
+
+        assert(& lf`first == 0p);
+        assert(& lf`last == 0p);
 
         insert_first(lf, f1);
 
-        assert( & lf`first == & f1 );
-        assert( & lf`last  == & f1 );
+        assert(& lf`first == & f1);
+        assert(& lf`last == & f1);
 
         verify(validate(lf));
 
-        with ( DLINK_VIA(fred, fred.mine) ) insert_after(f1, f2);
+        insert_after(f1`in_mine, f2);
 
         verify(validate(lf));
@@ -440 +413 @@
         printYourFreddies(f1, f2, 0);   // 3.14; 3.14; 0.5; 0.5 (unmodified)
 
-        assert( & lf`first == & f1 );
-        assert( & lf`last  == & f2 );
+        assert(& lf`first == & f1);
+        assert(& lf`last == & f2);
 }
 
@@ -449 +422 @@
         fred f2 = {0.5};
 
-        dlist(fred, fred.yours) lf;
-
-        assert( & lf`first == 0p );
-        assert( & lf`last == 0p );
+        dlist(fred_in_yours, fred) lf;
+
+        assert(& lf`first == 0p);
+        assert(& lf`last == 0p);
 
         insert_first(lf, f1);
 
-        assert( & lf`first == & f1 );
-        assert( & lf`last  == & f1 );
+        assert(& lf`first == & f1);
+        assert(& lf`last == & f1);
 
         verify(validate(lf));
 
-    with ( DLINK_VIA(fred, fred.yours) ) insert_after(f1, f2);
+        insert_after(f1`in_yours, f2);
 
         verify(validate(lf));
@@ -468 +441 @@
         printYourFreddies(f1, f2, 0);   // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified)
 
-        assert( & lf`first == & f1 );
-        assert( & lf`last  == & f2 );
+        assert(& lf`first == & f1);
+        assert(& lf`last == & f2);
 }
 
@@ -477 +450 @@
         mary m2 = {0.5};
 
-        dlist(mary) lm;
-
-        assert( & lm`first == 0p );
-        assert( & lm`last == 0p );
+        dlist(mary, mary) lm;
+
+        assert(& lm`first == 0p);
+        assert(& lm`last == 0p);
 
         insert_first(lm, m1);
 
-        assert( & lm`first == & m1 );
-        assert( & lm`last  == & m1 );
+        assert(& lm`first == & m1);
+        assert(& lm`last == & m1);
 
         verify(validate(lm));
@@ -495 +468 @@
         printMariatheotokos(m1, m2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified)
 
-        assert( & lm`first == & m1 );
-        assert( & lm`last  == & m2 );
+        assert(& lm`first == & m1);
+        assert(& lm`last == & m2);
 }
 
@@ -514 +487 @@
         fred f2 = {0.5};
 
-        dlist(fred, fred.mine) lf;
-
-        assert( & lf`first == 0p );
-        assert( & lf`last == 0p );
+        dlist(fred_in_mine, fred) lf;
+
+        assert(& lf`first == 0p);
+        assert(& lf`last == 0p);
 
         insert_last(lf, f2);
 
-        assert( & lf`first == & f2 );
-        assert( & lf`last  == & f2 );
+        assert(& lf`first == & f2);
+        assert(& lf`last == & f2);
 
         verify(validate(lf));
 
-        with ( DLINK_VIA(fred, fred.mine) ) insert_before(f2, f1);
+        insert_before(f2`in_mine, f1);
 
         verify(validate(lf));
@@ -533 +506 @@
         printYourFreddies(f1, f2, 0);   // 3.14; 3.14; 0.5; 0.5 (unmodified)
 
-        assert( & lf`first == & f1 );
-        assert( & lf`last  == & f2 );
+        assert(& lf`first == & f1);
+        assert(& lf`last == & f2);
 }
 
@@ -542 +515 @@
         fred f2 = {0.5};
 
-        dlist(fred, fred.yours) lf;
-
-        assert( & lf`first == 0p );
-        assert( & lf`last == 0p );
+        dlist(fred_in_yours, fred) lf;
+
+        assert(& lf`first == 0p);
+        assert(& lf`last == 0p);
 
         insert_last(lf, f2);
 
-        assert( & lf`first == & f2 );
-        assert( & lf`last  == & f2 );
+        assert(& lf`first == & f2);
+        assert(& lf`last == & f2);
 
         verify(validate(lf));
 
-        with ( DLINK_VIA(fred, fred.yours) )insert_before(f2, f1);
+        insert_before(f2`in_yours, f1);
 
         verify(validate(lf));
@@ -561 +534 @@
         printYourFreddies(f1, f2, 0);   // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified)
 
-        assert( & lf`first == & f1 );
-        assert( & lf`last  == & f2 );
+        assert(& lf`first == & f1);
+        assert(& lf`last == & f2);
 }
 
@@ -570 +543 @@
         mary m2 = {0.5};
 
-        dlist(mary) lm;
-
-        assert( & lm`first == 0p );
-        assert( & lm`last == 0p );
+        dlist(mary, mary) lm;
+
+        assert(& lm`first == 0p);
+        assert(& lm`last == 0p);
 
         insert_last(lm, m2);
 
-        assert( & lm`first == & m2 );
-        assert( & lm`last  == & m2 );
+        assert(& lm`first == & m2);
+        assert(& lm`last == & m2);
 
         verify(validate(lm));
@@ -588 +561 @@
         printMariatheotokos(m1, m2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified)
 
-        assert( & lm`first == & m1 );
-        assert( & lm`last  == & m2 );
-}
-#if 0
+        assert(& lm`first == & m1);
+        assert(& lm`last == & m2);
+}
 
 ////////////////////////////////////////////////////////////
@@ -874 +846 @@
 //
 ////////////////////////////////////////////////////////////
-#endif
+
 void test__remove_at_head__fred_mine() {
 
@@ -881 +853 @@
         fred f3 = {3.7};
 
-        dlist(fred, fred.mine) flm;
+        dlist(fred_in_mine, fred) flm;
         insert_last(flm, f1);
         insert_last(flm, f2);
         insert_last(flm, f3);
 
-        dlist(fred, fred.yours) fly;
+        dlist(fred_in_yours, fred) fly;
         insert_last(fly, f1);
         insert_last(fly, f2);
@@ -897 +869 @@
         verify(validate(flm));
 
-        with( DLINK_VIA(fred, fred.mine) ) remove(f1);
+        remove(f1`in_mine);
 
         verify(validate(fly));
@@ -909 +881 @@
 
         // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics
-        // assert(f1.$links_mine.next.is_terminator == false);
-        // assert(f1.$links_mine.prev.is_terminator == false);
-}
-
+        assert(f1.$links_mine.next.is_terminator == false);
+        assert(f1.$links_mine.prev.is_terminator == false);
+}
 
 void test__remove_at_head__fred_yours() {
@@ -920 +891 @@
         fred f3 = {3.7};
 
-        dlist(fred, fred.mine) flm;
+        dlist(fred_in_mine, fred) flm;
         insert_last(flm, f1);
         insert_last(flm, f2);
         insert_last(flm, f3);
 
-        dlist(fred, fred.yours) fly;
+        dlist(fred_in_yours, fred) fly;
         insert_last(fly, f1);
         insert_last(fly, f2);
@@ -936 +907 @@
         verify(validate(flm));
 
-        with( DLINK_VIA(fred, fred.yours) ) remove(f1);
+        remove(f1`in_yours);
 
         verify(validate(fly));
@@ -948 +919 @@
 
         // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics
-        // assert(f1.$links_yours.next.is_terminator == false);
-        // assert(f1.$links_yours.prev.is_terminator == false);
+        assert(f1.$links_yours.next.is_terminator == false);
+        assert(f1.$links_yours.prev.is_terminator == false);
 }
 
@@ -958 +929 @@
         mary m3 = {3.7};
 
-        dlist(mary) ml;
+        dlist(mary, mary) ml;
         insert_last(ml, m1);
         insert_last(ml, m2);
@@ -977 +948 @@
 
         // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics
-        // assert(m1.$links.next.is_terminator == false);
-        // assert(m1.$links.prev.is_terminator == false);
+        assert(m1.$links.next.is_terminator == false);
+        assert(m1.$links.prev.is_terminator == false);
 }
 
@@ -997 +968 @@
         fred f3 = {3.7};
 
-        dlist(fred, fred.mine) flm;
+        dlist(fred_in_mine, fred) flm;
         insert_last(flm, f1);
         insert_last(flm, f2);
         insert_last(flm, f3);
 
-        dlist(fred, fred.yours) fly;
+        dlist(fred_in_yours, fred) fly;
         insert_last(fly, f1);
         insert_last(fly, f2);
@@ -1013 +984 @@
         verify(validate(flm));
 
-        with( DLINK_VIA(fred, fred.mine) ) remove(f3);
+        remove(f3`in_mine);
 
         verify(validate(fly));
@@ -1025 +996 @@
 
         // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics
-        // assert(f3.$links_mine.next.is_terminator == false);
-        // assert(f3.$links_mine.prev.is_terminator == false);
+        assert(f3.$links_mine.next.is_terminator == false);
+        assert(f3.$links_mine.prev.is_terminator == false);
 }
 
@@ -1035 +1006 @@
         fred f3 = {3.7};
 
-        dlist(fred, fred.mine) flm;
+        dlist(fred_in_mine, fred) flm;
         insert_last(flm, f1);
         insert_last(flm, f2);
         insert_last(flm, f3);
 
-        dlist(fred, fred.yours) fly;
+        dlist(fred_in_yours, fred) fly;
         insert_last(fly, f1);
         insert_last(fly, f2);
@@ -1051 +1022 @@
         verify(validate(flm));
 
-        with( DLINK_VIA(fred, fred.yours) ) remove(f3);
+        remove(f3`in_yours);
 
         verify(validate(fly));
@@ -1063 +1034 @@
 
         // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics
-        // assert(f3.$links_yours.next.is_terminator == false);
-        // assert(f3.$links_yours.prev.is_terminator == false);
+        assert(f3.$links_yours.next.is_terminator == false);
+        assert(f3.$links_yours.prev.is_terminator == false);
 }
 
@@ -1073 +1044 @@
         mary m3 = {3.7};
 
-        dlist(mary) ml;
+        dlist(mary, mary) ml;
         insert_last(ml, m1);
         insert_last(ml, m2);
@@ -1092 +1063 @@
 
         // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics
-        // assert(m3.$links.next.is_terminator == false);
-        // assert(m3.$links.prev.is_terminator == false);
+        assert(m3.$links.next.is_terminator == false);
+        assert(m3.$links.prev.is_terminator == false);
 }
 
@@ -1110 +1081 @@
         fred f = {0.7};
 
-        dlist(fred, fred.mine) flm;
+        dlist(fred_in_mine, fred) flm;
         insert_last(flm, f);
 
-        dlist(fred, fred.yours) fly;
+        dlist(fred_in_yours, fred) fly;
         insert_last(fly, f);
 
@@ -1122 +1093 @@
         verify(validate(flm));
 
-        with( DLINK_VIA(fred, fred.mine) ) remove(f);
-
-        verify(validate(fly));
-        verify(validate(flm));
-
-        assert( & flm`first == 0p );
-        assert( & flm`last == 0p );
+        remove(f`in_mine);
+
+        verify(validate(fly));
+        verify(validate(flm));
+
+        assert(& flm`first == 0p);
+        assert(& flm`last  == 0p);
 
         printYourFreddies(fly`first, fly`last, 0);   // 0.7; 0.7; 0.7; 0.7 (unmodified)
@@ -1136 +1107 @@
 
         // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics
-        // assert(f.$links_mine.next.is_terminator == false);
-        // assert(f.$links_mine.prev.is_terminator == false);
+        assert(f.$links_mine.next.is_terminator == false);
+        assert(f.$links_mine.prev.is_terminator == false);
 
         insert_last(flm, f);
@@ -1149 +1120 @@
         fred f = {0.7};
 
-        dlist(fred, fred.mine) flm;
+        dlist(fred_in_mine, fred) flm;
         insert_last(flm, f);
 
-        dlist(fred, fred.yours) fly;
+        dlist(fred_in_yours, fred) fly;
         insert_last(fly, f);
 
@@ -1161 +1132 @@
         verify(validate(flm));
 
-        with( DLINK_VIA(fred, fred.yours) ) remove(f);
-
-        verify(validate(fly));
-        verify(validate(flm));
-
-        assert( & fly`first == 0p );
-        assert( & fly`last == 0p );
+        remove(f`in_yours);
+
+        verify(validate(fly));
+        verify(validate(flm));
+
+        assert(& fly`first == 0p);
+        assert(& fly`last  == 0p);
 
         printYourFreddies(flm`first, flm`last, 0);   // 0.7; 0.7; 0.7; 0.7 (unmodified)
@@ -1175 +1146 @@
 
         // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics
-        // assert(f.$links_yours.next.is_terminator == false);
-        // assert(f.$links_yours.prev.is_terminator == false);
+        assert(f.$links_yours.next.is_terminator == false);
+        assert(f.$links_yours.prev.is_terminator == false);
 
         insert_last(fly, f);
@@ -1188 +1159 @@
         mary m = {0.7};
 
-        dlist(mary) ml;
+        dlist(mary, mary) ml;
         insert_last(ml, m);
 
@@ -1199 +1170 @@
         verify(validate(ml));
 
-        assert( & ml`first == 0p );
-        assert( & ml`last == 0p );
+        assert(& ml`first == 0p);
+        assert(& ml`last  == 0p);
 
         // observe f is solo in mine (now unlisted); in yours, it was just traversed
@@ -1206 +1177 @@
 
         // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics
-        // assert(m.$links.next.is_terminator == false);
-        // assert(m.$links.prev.is_terminator == false);
+        assert(m.$links.next.is_terminator == false);
+        assert(m.$links.prev.is_terminator == false);
 
         insert_last(ml, m);
@@ -1232 +1203 @@
         fred f3 = {3.7};
 
-        dlist(fred, fred.mine) flm;
+        dlist(fred_in_mine, fred) flm;
         insert_last(flm, f1);
         insert_last(flm, f2);
         insert_last(flm, f3);
 
-        dlist(fred, fred.yours) fly;
+        dlist(fred_in_yours, fred) fly;
         insert_last(fly, f1);
         insert_last(fly, f2);
@@ -1248 +1219 @@
         verify(validate(flm));
 
-        fred & popped = try_pop_front(flm);
+        fred & popped = pop_first(flm);
 
         verify(validate(fly));
@@ -1268 +1239 @@
         fred f3 = {3.7};
 
-        dlist(fred, fred.mine) flm;
+        dlist(fred_in_mine, fred) flm;
         insert_last(flm, f1);
         insert_last(flm, f2);
         insert_last(flm, f3);
 
-        dlist(fred, fred.yours) fly;
+        dlist(fred_in_yours, fred) fly;
         insert_last(fly, f1);
         insert_last(fly, f2);
@@ -1284 +1255 @@
         verify(validate(flm));
 
-        fred & popped = try_pop_front(fly);
+        fred & popped = pop_first(fly);
 
         verify(validate(fly));
@@ -1304 +1275 @@
         mary m3 = {3.7};
 
-        dlist(mary) ml;
+        dlist(mary, mary) ml;
         insert_last(ml, m1);
         insert_last(ml, m2);
@@ -1313 +1284 @@
         verify(validate(ml));
 
-        mary & popped = try_pop_front(ml);
+        mary & popped = pop_first(ml);
 
         verify(validate(ml));
@@ -1331 +1302 @@
         fred f3 = {3.7};
 
-        dlist(fred, fred.mine) flm;
+        dlist(fred_in_mine, fred) flm;
         insert_last(flm, f1);
         insert_last(flm, f2);
         insert_last(flm, f3);
 
-        dlist(fred, fred.yours) fly;
+        dlist(fred_in_yours, fred) fly;
         insert_last(fly, f1);
         insert_last(fly, f2);
@@ -1347 +1318 @@
         verify(validate(flm));
 
-        fred & popped = try_pop_back(flm);
+        fred & popped = pop_last(flm);
 
         verify(validate(fly));
@@ -1367 +1338 @@
         fred f3 = {3.7};
 
-        dlist(fred, fred.mine) flm;
+        dlist(fred_in_mine, fred) flm;
         insert_last(flm, f1);
         insert_last(flm, f2);
         insert_last(flm, f3);
 
-        dlist(fred, fred.yours) fly;
+        dlist(fred_in_yours, fred) fly;
         insert_last(fly, f1);
         insert_last(fly, f2);
@@ -1383 +1354 @@
         verify(validate(flm));
 
-        fred & popped = try_pop_back(fly);
+        fred & popped = pop_last(fly);
 
         verify(validate(fly));
@@ -1403 +1374 @@
         mary m3 = {3.7};
 
-        dlist(mary) ml;
+        dlist(mary, mary) ml;
         insert_last(ml, m1);
         insert_last(ml, m2);
@@ -1412 +1383 @@
         verify(validate(ml));
 
-        mary & popped = try_pop_back(ml);
+        mary & popped = pop_last(ml);
 
         verify(validate(ml));
@@ -1426 +1397 @@
 ////////////////////////////////////////////////////////////
 //
-// Section 4g
-//
-// Test cases of `isEmpty, `hasPrev, `hasNext,
-// try_pop_front, try_pop_back, modifications via `elems
-//
-// Example of call-side user code
-//
-////////////////////////////////////////////////////////////
-
-void test__accessor_cases__mary() {
-
-        mary m1 = {1.7};
-        mary m2 = {2.7};
-        mary m3 = {3.7};
-
-        dlist(mary) ml;                 assert( ml`isEmpty);
-
-        insert_last(ml, m1);    assert(!ml`isEmpty);
-        insert_last(ml, m2);    assert(!ml`isEmpty);
-        insert_last(ml, m3);    assert(!ml`isEmpty);
-
-        mary & m1prev = m1`prev;
-        mary & m1next = m1`next;
-        mary & m2prev = m2`prev;
-        mary & m2next = m2`next;
-        mary & m3prev = m3`prev;
-        mary & m3next = m3`next;
-
-        assert (&m1prev == 0p);
-        assert (&m1next == &m2);
-        assert (&m2prev == &m1);
-        assert (&m2next == &m3);
-        assert (&m3prev == &m2);
-        assert (&m3next == 0p);
-
-        assert(!m1`hasPrev);
-        assert( m1`hasNext);
-        assert( m2`hasPrev);
-        assert( m2`hasNext);
-        assert( m3`hasPrev);
-        assert(!m3`hasNext);
-
-        printf("accessor_cases done\n");
-}
-
-void test__try_pop__mary() {
-
-        mary m1 = {1.7};
-        mary m2 = {2.7};
-        mary m3 = {3.7};
-
-        dlist(mary) ml;
-
-        mary &m1r = *0p;
-        mary &m2r = *0p;
-        mary &m3r = *0p;
-        mary &mxr = *0p;
-
-        // queue, back to front
-
-        assert( ml`isEmpty);
-
-        insert_last(ml, m1);
-        insert_last(ml, m2);
-        insert_last(ml, m3);
-
-        &m1r = & try_pop_front(ml);     assert(!ml`isEmpty);
-        &m2r = & try_pop_front(ml);     assert(!ml`isEmpty);
-        &m3r = & try_pop_front(ml);     assert( ml`isEmpty);
-        &mxr = & try_pop_front(ml);     assert( ml`isEmpty);
-
-        assert( &m1r == &m1 );
-        assert( &m2r == &m2 );
-        assert( &m3r == &m3 );
-        assert( &mxr == 0p  );
-
-        &m1r = 0p;
-        &m2r = 0p;
-        &m3r = 0p;
-
-        // queue, front to back
-
-        assert( ml`isEmpty);
-
-        insert_first(ml, m1);
-        insert_first(ml, m2);
-        insert_first(ml, m3);
-
-        &m1r = & try_pop_back(ml);      assert(!ml`isEmpty);
-        &m2r = & try_pop_back(ml);      assert(!ml`isEmpty);
-        &m3r = & try_pop_back(ml);      assert( ml`isEmpty);
-        &mxr = & try_pop_back(ml);      assert( ml`isEmpty);
-
-        assert( &m1r == &m1 );
-        assert( &m2r == &m2 );
-        assert( &m3r == &m3 );
-        assert( &mxr == 0p  );
-
-        &m1r = 0p;
-        &m2r = 0p;
-        &m3r = 0p;
-
-        // stack at front
-
-        assert( ml`isEmpty);
-
-        insert_first(ml, m1);
-        insert_first(ml, m2);
-        insert_first(ml, m3);
-
-        &m3r = & try_pop_front(ml);     assert(!ml`isEmpty);
-        &m2r = & try_pop_front(ml);     assert(!ml`isEmpty);
-        &m1r = & try_pop_front(ml);     assert( ml`isEmpty);
-        &mxr = & try_pop_front(ml);     assert( ml`isEmpty);
-
-        assert( &m1r == &m1 );
-        assert( &m2r == &m2 );
-        assert( &m3r == &m3 );
-        assert( &mxr == 0p  );
-
-        &m1r = 0p;
-        &m2r = 0p;
-        &m3r = 0p;
-
-        // stack at back
-
-        assert( ml`isEmpty);
-
-        insert_last(ml, m1);
-        insert_last(ml, m2);
-        insert_last(ml, m3);
-
-        &m3r = & try_pop_back(ml);      assert(!ml`isEmpty);
-        &m2r = & try_pop_back(ml);      assert(!ml`isEmpty);
-        &m1r = & try_pop_back(ml);      assert( ml`isEmpty);
-        &mxr = & try_pop_back(ml);      assert( ml`isEmpty);
-
-        assert( &m1r == &m1 );
-        assert( &m2r == &m2 );
-        assert( &m3r == &m3 );
-        assert( &mxr == 0p  );
-
-        &m1r = 0p;
-        &m2r = 0p;
-        &m3r = 0p;
-
-        printf("try_pop cases done\n");
-}
-
-void test__origin_mutation__mary() {
-
-        mary m1 = {1.7};
-
-        dlist(mary) ml;
-        mary & mlorigin = ml`elems;
-
-        // insert before the origin
-
-        insert_before( ml`elems, m1 );
-        assert( ! ml`isEmpty );
-
-        mary & mlfirst = ml`first;
-        mary & mllast = ml`last;
-
-        assert( &m1 == & mlfirst );
-        assert( &m1 == & mllast );
-
-        // moveNext after last goes back to origin, &vv
-
-        bool canMoveNext = mllast`moveNext;
-        bool canMovePrev = mlfirst`movePrev;
-
-        assert( ! canMoveNext );
-        assert( ! canMovePrev );
-
-        assert( &mlorigin == & mlfirst );
-        assert( &mlorigin == & mllast );
-
-        printf("origin_mutation cases done\n");
-}
-
-////////////////////////////////////////////////////////////
-//
 // Section 5
 //
@@ -1616 +1404 @@
 
 int main() {
-#if 0
+
         sout | "~~~~~~~~~~~~~~~~~ Headless List Tests - insert_after ~~~~~~~~~~~~~~~~";
         sout | "";
@@ -1653 +1441 @@
         sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
         test__insertbefore_singleton_on_singleton__mary();
-#endif
+
         sout | "";
         sout | "~~~~~~~~~~~~~~~~~ Headed List Tests - insert_first ~~~~~~~~~~~~~~~~~~";
@@ -1729 +1517 @@
         sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
         test__insertbefore_before_first__mary();
-#if 0
 
         sout | "";
@@ -1787 +1574 @@
         sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
         test__remove_at_last__mary();
-#endif
+
         sout | "";
         sout | "~~~~~~~~~~ Element removal tests on Headed List: at first ~~~~~~~~~~";
@@ -1883 +1670 @@
         test__pop_last__maries();
 
-        sout | "";
-        sout | "~~~~~~~~~~~~~~~~~~~ Ease-of-access cases ~~~~~~~~~~~~~~~~~~";
-        sout | "";
-
-        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
-        sout | "Test 18-i.  Modifying Freds on MINE";
-        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
-        sout | "Not implmented";
-
-        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
-        sout | "Test 18-ii.  Modifying Freds on YOURS";
-        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
-        sout | "Not implmented";
-
-        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
-        sout | "Test 18-iii.  Modifying Maries";
-        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
-
-        test__accessor_cases__mary();
-        test__try_pop__mary();
-        test__origin_mutation__mary();
-
         return 0;
 }

tests/zombies/linked-list-perf/experiment.koad

@@ -49 +49 @@
 #elif defined IMPL_CFA_MIKE_OLD
 
-        #include "mike-old.hfa"
+        #include <containers/list.hfa>
         struct S {
                 int f[64]; // FIXME: make "is volatile" consistent; given bug #TBD
@@ -67 +67 @@
 #elif defined IMPL_CFA_MIKE_NEW
 
-        #include <containers/list.hfa>
+        #include <containers/list2.hfa>
         struct S {
                 int f[64]; // FIXME: make "is volatile" consistent; given bug #TBD