Changeset 7d51ef8


Ignore:
Timestamp:
May 11, 2021, 9:52:18 PM (19 months ago)
Author:
Michael Brooks <mlbrooks@…>
Branches:
arm-eh, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum
Children:
1e5cd9a, 67b421c
Parents:
8d1ad36
Message:

Changing how the dlist API specifies which list direction you're working on.

New style is:
with( DLINK_VIA( request, request.priority ) ) remove( myItem );

This change eliminates the diref type from the public API. The diref type did not support intutive use of taking the address of its referent, as is needed to null-check or identity-compare a reference.

Files:
2 edited

Legend:

Unmodified
Added
Removed
  • libcfa/src/containers/list2.hfa

    r8d1ad36 r7d51ef8  
    1818#include <assert.h>
    1919
    20 extern "C" {
    21     void * memset ( void * ptr, int value, size_t num );
    22 }
    23 
    24 trait embedded( tOuter &, tInner & ) {
    25     tInner & ?`inner( tOuter & );
     20forall( Decorator &, T & )
     21struct tytagref {
     22    inline T &;
    2623};
    2724
    28 // embedded is reflexive
    29 forall( tX & )
    30 static inline tX & ?`inner( tX & this ) { return this; }
     25trait embedded( tOuter &, tMid &, tInner & ) {
     26    tytagref( tMid, tInner ) ?`inner( tOuter & );
     27};
     28
     29// embedded is reflexive, with no info (void) as the type tag
     30forall (T &)
     31tytagref(void, T) ?`inner ( T & this ) { tytagref( void, T ) ret = {this}; return ret; }
    3132
    3233// use this on every case of plan-9 inheritance, to make embedded a closure of plan-9 inheritance
    33 #define P9_EMBEDDED( tOuter, tInner ) \
    34    static inline tInner & ?`inner( tOuter & this ) { return this; }
     34#define P9_EMBEDDED( derived, immedBase ) \
     35forall( Tbase &, TdiscardPath & | { tytagref( TdiscardPath, Tbase ) ?`inner( immedBase & ); } ) \
     36    static inline tytagref(immedBase, Tbase) ?`inner( derived & this ) { \
     37        immedBase & ib = this; \
     38        Tbase & b = ib`inner; \
     39        tytagref(immedBase, Tbase) result = { b }; \
     40        return result; \
     41    }
     42
     43#define EMBEDDED_VIA( OUTER, MID, INNER ) \
     44   (struct { tytagref(MID, INNER) ( * ?`inner ) ( OUTER & ); }){ ?`inner }
     45
     46#define DLINK_VIA( TE, TLINK ) \
     47   EMBEDDED_VIA( TE, TLINK, dlink(TE) )
    3548
    3649
     
    8194    }
    8295
    83     forall( tLinks & = tE ) {
    84 
    85         struct dlist {
    86             inline dlink(tE);
    87         };
    88 
    89         struct diref {
    90             inline tE &;
    91         };
    92     }
    93 
    94     forall( tLinks & = tE | embedded( tE, tLinks ) | embedded( tLinks, dlink(tE) ) ) {
     96    forall( tLinks & = dlink(tE) )
     97    struct dlist {
     98        inline dlink(tE);
     99    };
     100
     101    forall( tLinks & | embedded( tE, tLinks, dlink(tE) ) ) {
    95102        static inline tE * $get_list_origin_addr( dlist(tE, tLinks) & lst ) {
    96             dlink(tE) & link_from_null = ( * (tE *) 0p )`inner`inner;
     103            dlink(tE) & link_from_null = ( * (tE *) 0p )`inner;
    97104            ptrdiff_t link_offset = (ptrdiff_t) & link_from_null;
    98105            size_t origin_addr = ((size_t) & lst) - link_offset;
     
    105112            ( ( dlink(tE) & ) this ){ listOrigin, listOrigin } ;
    106113        }
    107 
    108         // redundant
    109         // void ?{}( diref(tE, tLinks) & this, tE & target ) {
    110         //     tE && ref = this;
    111         //     &ref = &target;
    112         // }
    113114    }
    114115
     
    116117
    117118
    118 forall( tE &, tLinks & | embedded( tE, tLinks ) | embedded( tLinks, dlink(tE) ) ) {
    119 
    120         static inline void insert_after(diref(tE, tLinks) list_pos, tE &to_insert) {
     119forall( tE &, tLinks & | embedded( tE, tLinks, dlink(tE) ) ) {
     120
     121        static inline void insert_after(tE & list_pos, tE &to_insert) {
    121122                verify (&list_pos != 0p);
    122123                verify (&to_insert != 0p);
    123         dlink(tE) & linkToInsert = to_insert`inner`inner;
     124        dlink(tE) & linkToInsert = to_insert`inner;
    124125                verify(linkToInsert.prev == 0p);
    125126                verify(linkToInsert.next == 0p);
    126127        tE & list_pos_raw = list_pos;
    127128        tE & list_pos_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & list_pos_raw );
    128         asm( "" : : : "memory" );
    129         tE & after_raw = * (list_pos_elem`inner`inner).next;
     129        dlink(tE) & list_pos_links = list_pos_elem`inner;
     130        asm( "" : : : "memory" );
     131        tE & after_raw = * list_pos_links.next;
    130132        tE & after_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & after_raw );
    131133                linkToInsert.prev = & list_pos_raw;
    132134                linkToInsert.next = & after_raw;
    133         (after_elem`inner`inner).prev = &to_insert;
    134                 (list_pos_elem`inner`inner).next = &to_insert;
    135         asm( "" : : : "memory" );
    136         }
    137 
    138         static inline void insert_before(diref(tE, tLinks) list_pos, tE &to_insert) {
     135        dlink(tE) & afterLinks = after_elem`inner;
     136        afterLinks.prev = &to_insert;
     137                list_pos_links.next = &to_insert;
     138        asm( "" : : : "memory" );
     139        }
     140
     141        static inline void insert_before(tE & list_pos, tE &to_insert) {
    139142                verify (&list_pos != 0p);
    140143                verify (&to_insert != 0p);
    141         dlink(tE) & linkToInsert = to_insert`inner`inner;
     144        dlink(tE) & linkToInsert = to_insert`inner;
    142145                verify(linkToInsert.next == 0p);
    143146                verify(linkToInsert.prev == 0p);
    144147        tE & list_pos_raw = list_pos;
    145148        tE & list_pos_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & list_pos_raw );
    146         asm( "" : : : "memory" );
    147         tE & before_raw = * (list_pos_elem`inner`inner).prev;
     149        dlink(tE) & list_pos_links = list_pos_elem`inner;
     150        asm( "" : : : "memory" );
     151        tE & before_raw = * (list_pos_links).prev;
    148152        tE & before_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & before_raw );
    149153                linkToInsert.next = & list_pos_raw;
    150154                linkToInsert.prev = & before_raw;
    151         (before_elem`inner`inner).next = &to_insert;
    152                 (list_pos_elem`inner`inner).prev = &to_insert;
    153         asm( "" : : : "memory" );
    154         }
    155 
    156         static inline tE & remove(diref(tE, tLinks) list_pos) {
     155        dlink(tE) & beforeLinks = before_elem`inner;
     156        beforeLinks.next = &to_insert;
     157                (list_pos_links).prev = &to_insert;
     158        asm( "" : : : "memory" );
     159        }
     160
     161        static inline tE & remove(tE & list_pos) {
    157162                verify (&list_pos != 0p);
    158163        tE & list_pos_elem = list_pos;
    159164        verify( ! ORIGIN_TAG_QUERY((size_t) & list_pos_elem) );
    160         dlink(tE) & list_pos_links = list_pos_elem`inner`inner;
     165        dlink(tE) & list_pos_links = list_pos_elem`inner;
    161166        tE & before_raw = * list_pos_links.prev;
    162167        tE & before_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & before_raw );
    163         dlink(tE) & before_links = before_elem`inner`inner;
     168        dlink(tE) & before_links = before_elem`inner;
    164169        tE & after_raw = * list_pos_links.next;
    165170        tE & after_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & after_raw );
    166         dlink(tE) & after_links = after_elem`inner`inner;
     171        dlink(tE) & after_links = after_elem`inner;
    167172        before_links.next = &after_raw;
    168173        after_links.prev = &before_raw;
     
    174179        }
    175180
    176     static inline diref(tE, tLinks) ?`first( dlist(tE, tLinks) &lst ) {
     181    static inline tE & ?`first( dlist(tE, tLinks) &lst ) {
    177182        tE * firstPtr = lst.next;
    178183        if (ORIGIN_TAG_QUERY((size_t)firstPtr)) firstPtr = 0p;
    179         diref(tE, tLinks) ret = { *firstPtr };
    180         return ret;
    181     }
    182     static inline diref(tE, tLinks) ?`last ( dlist(tE, tLinks) &lst ) {
     184        return *firstPtr;
     185    }
     186    static inline tE & ?`last ( dlist(tE, tLinks) &lst ) {
    183187        tE * lastPtr = lst.prev;
    184188        if (ORIGIN_TAG_QUERY((size_t)lastPtr)) lastPtr = 0p;
    185         diref(tE, tLinks) ret = { *lastPtr };
    186         return ret;
     189        return *lastPtr;
    187190    }
    188191
     
    193196    }
    194197
    195     static inline int ?!=?( const diref(tE, tLinks) & list_pos, zero_t ) {
    196         tE & list_pos_elem = list_pos;
    197         if (ORIGIN_TAG_QUERY((size_t) & list_pos_elem)) return 0;
    198         return & list_pos_elem != 0p;
    199     }
    200 
    201     static inline int DUMB_COMPARE( diref(tE, tLinks) list_pos, tE * elem ) {
    202         tE & signifiedLhs = list_pos;
    203         return &signifiedLhs == elem;
    204     }
    205 
    206     static inline diref(tE, tLinks) ?`from( tE & elem ) {
    207         diref(tE, tLinks) ret = { elem };
    208         return ret;
    209     }
    210 
    211     static inline diref(tE, tLinks) ?`elems( dlist(tE, tLinks) & lst ) {
     198    static inline tE & ?`elems( dlist(tE, tLinks) & lst ) {
    212199        tE * origin = $get_list_origin_addr( lst );
    213         diref(tE, tLinks) ret = { *origin };
    214         return ret;
    215     }
    216 
    217     static inline bool ?`moveNext( diref(tE, tLinks) & refx ) {
     200        return *origin;
     201    }
     202
     203    static inline bool ?`moveNext( tE && refx ) {
    218204        tE && ref_inner = refx;
    219205        tE & oldReferent = * (tE*) ORIGIN_TAG_CLEAR( (size_t) & ref_inner );
    220         &ref_inner = oldReferent`inner`inner.next;
     206        &ref_inner = oldReferent`inner.next;
    221207        return &ref_inner != 0p  &&
    222208            ! ORIGIN_TAG_QUERY( (size_t) & ref_inner );
    223209    }
    224210
    225     static inline bool ?`movePrev( diref(tE, tLinks) & refx ) {
     211    static inline bool ?`movePrev( tE && refx ) {
    226212        tE && ref_inner = refx;
    227213        tE & oldReferent = * (tE*) ORIGIN_TAG_CLEAR( (size_t) & ref_inner );
    228         &ref_inner = oldReferent`inner`inner.prev;
     214        &ref_inner = oldReferent`inner.prev;
    229215        return &ref_inner != 0p  &&
    230216            ! ORIGIN_TAG_QUERY( (size_t) & ref_inner );
    231217    }
    232218
    233     static inline bool ?`hasNext( diref(tE, tLinks) refx ) {
    234         return refx`moveNext;
    235     }
    236 
    237     static inline bool ?`hasPrev( diref(tE, tLinks) refx ) {
    238         return refx`movePrev;
    239     }
    240 
    241     static inline diref(tE, tLinks) ?`next( diref(tE, tLinks) refx ) {
    242         if( refx`moveNext ) return refx;
    243         tE && ref_inner = refx;
    244         & ref_inner = 0p;
    245         return refx;
    246     }
    247 
    248     static inline diref(tE, tLinks) ?`prev( diref(tE, tLinks) refx ) {
    249         if( refx`movePrev ) return refx;
    250         tE && ref_inner = refx;
    251         & ref_inner = 0p;
    252         return refx;
     219    static inline bool ?`hasNext( tE & e ) {
     220        return e`moveNext;
     221    }
     222
     223    static inline bool ?`hasPrev( tE & e ) {
     224        return e`movePrev;
     225    }
     226
     227    static inline tE & ?`next( tE & e ) {
     228        if( e`moveNext ) return e;
     229        return * 0p;
     230    }
     231
     232    static inline tE & ?`prev( tE & e ) {
     233        if( e`movePrev ) return e;
     234        return * 0p;
    253235    }
    254236
     
    262244
    263245    static inline tE & try_pop_front( dlist(tE, tLinks) &lst ) {
    264         diref(tE, tLinks) first_inlist = lst`first;
     246        tE & first_inlist = lst`first;
    265247        tE & first_item = first_inlist;
    266248        if (&first_item) remove(first_inlist);
     
    269251
    270252    static inline tE & try_pop_back( dlist(tE, tLinks) &lst ) {
    271         diref(tE, tLinks) last_inlist = lst`last;
     253        tE & last_inlist = lst`last;
    272254        tE & last_item = last_inlist;
    273255        if (&last_item) remove(last_inlist);
     
    282264        tE & lagElem = *0p;
    283265
    284         while ( diref(tE, tLinks) it = this`elems; it`moveNext ) {
     266        while ( tE & it = this`elems; it`moveNext ) {
    285267            if (& lagElem == 0p &&  &it != & this`first ) return false;
    286268            & lagElem = & it;
     
    297279        tE & lagElem = *0p;
    298280
    299         while ( diref(tE, tLinks) it = this`elems; it`movePrev ) {
     281        while ( tE & it = this`elems; it`movePrev ) {
    300282            if (& lagElem == 0p &&  &it != & this`last ) return false;
    301283            & lagElem = & it;
     
    314296}
    315297
    316 forall( tE & | embedded( tE, dlink(tE) ) ) {
    317         static inline void insert_after(tE & list_pos, tE &to_insert ) {
    318         diref(tE, tE) list_pos_ref = list_pos`from;
    319         insert_after( list_pos_ref, to_insert );
    320     }
    321         static inline void insert_before(tE & list_pos, tE &to_insert ) {
    322         diref(tE, tE) list_pos_ref = list_pos`from;
    323         insert_before( list_pos_ref, to_insert );
    324     }
    325         static inline tE & remove(tE & list_pos ) {
    326         diref(tE, tE) list_pos_ref = list_pos`from;
    327         return remove( list_pos_ref );
    328     }
    329     static inline bool ?`moveNext( tE && ref ) {
    330         diref(tE, tE) & ref_dird = (diref(tE, tE) &) & ref;
    331         return ref_dird`moveNext;
    332     }
    333     static inline bool ?`movePrev( tE && ref ) {
    334         diref(tE, tE) & ref_dird = (diref(tE, tE) &) & ref;
    335         return ref_dird`movePrev;
    336     }
    337     static inline bool ?`hasNext( tE & ref ) {
    338         diref(tE, tE) ref_dird = { ref };
    339         return ref_dird`hasNext;
    340     }
    341     static inline bool ?`hasPrev( tE & ref ) {
    342         diref(tE, tE) ref_dird = { ref };
    343         return ref_dird`hasPrev;
    344     }
    345     static inline tE & ?`next( tE & ref ) {
    346         diref(tE, tE) ref_dird = { ref };
    347         diref(tE, tE) rslt = ref_dird`next;
    348         return rslt;
    349     }
    350     static inline tE & ?`prev( tE & ref ) {
    351         diref(tE, tE) ref_dird = { ref };
    352         diref(tE, tE) rslt = ref_dird`prev;
    353         return rslt;
    354     }
    355 }
  • tests/list/dlist-insert-remove-2.cfa

    r8d1ad36 r7d51ef8  
    5555////////////////////////////////////////////////////////////
    5656
    57 void printMyFredsFwd(diref(fred, fred.mine) f) {
     57void printMyFredsFwd(fred & f) {
     58    with( DLINK_VIA( fred, fred.mine ) )
    5859        do {
    5960                sout | f.adatum;
     
    6162}
    6263
    63 void printMyFredsRev(diref(fred, fred.mine) f) {
     64void printMyFredsRev(fred & f) {
     65    with( DLINK_VIA( fred, fred.mine ) )
    6466        do {
    6567                sout | f.adatum;
     
    7577        }
    7678        if (&f1) {
    77                 printMyFredsFwd(f1`from);       sout | '-';
    78                 printMyFredsRev(f1`from);       sout | '-';
     79                printMyFredsFwd(f1);    sout | '-';
     80                printMyFredsRev(f1);    sout | '-';
    7981        } else {
    8082                sout | '-'; sout | '-';
    8183        }
    8284        if (&f2) {
    83                 printMyFredsFwd(f2`from);       sout | '-';
    84                 printMyFredsRev(f2`from);       sout | '-';
     85                printMyFredsFwd(f2);    sout | '-';
     86                printMyFredsRev(f2);    sout | '-';
    8587        } else {
    8688                sout | '-'; sout | '-';
     
    8890}
    8991
    90 void printYourFredsFwd(diref(fred, fred.yours) f) {
     92void printYourFredsFwd(fred & f) {
     93    with( DLINK_VIA( fred, fred.yours ) )
    9194        do {
    9295                sout | f.adatum;
     
    9497}
    9598
    96 void printYourFredsRev(diref(fred, fred.yours) f) {
     99void printYourFredsRev(fred & f) {
     100    with( DLINK_VIA( fred, fred.yours ) )
    97101        do {
    98102                sout | f.adatum;
     
    107111        }
    108112        if (&f1) {
    109                 printYourFredsFwd(f1`from);     sout | '-';
    110                 printYourFredsRev(f1`from);     sout | '-';
     113                printYourFredsFwd(f1);  sout | '-';
     114                printYourFredsRev(f1);  sout | '-';
    111115        } else {
    112116                sout | '-'; sout | '-';
    113117        }
    114118        if (&f2) {
    115                 printYourFredsFwd(f2`from);     sout | '-';
    116                 printYourFredsRev(f2`from);     sout | '-';
     119                printYourFredsFwd(f2);  sout | '-';
     120                printYourFredsRev(f2);  sout | '-';
    117121        } else {
    118122                sout | '-'; sout | '-';
     
    275279// All three tests exercise the case of creating an empty container and
    276280// adding two items to it.
    277 
    278281void test__insertfirst_two_on_empty__fred_mine() {
    279282
     
    317320        printYourFreddies(f1, f2, 0);   // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified)
    318321}
    319 
    320322void test__insertfirst_two_on_empty__mary() {
    321323
     
    323325        mary m2 = {0.5};
    324326
    325         dlist(mary, mary) lm;
     327        dlist(mary) lm;
    326328
    327329        verify(validate(lm));
     
    392394        mary m2 = {0.5};
    393395
    394         dlist(mary, mary) lm;
     396        dlist(mary) lm;
    395397
    396398        verify(validate(lm));
     
    421423        dlist(fred, fred.mine) lf;
    422424
    423         assert(! lf`first);
    424         assert(! lf`last);
     425        assert( & lf`first == 0p );
     426        assert( & lf`last == 0p );
    425427
    426428        insert_first(lf, f1);
    427429
    428         assert(DUMB_COMPARE(lf`first, & f1));
    429         assert(DUMB_COMPARE(lf`last , & f1));
     430        assert( & lf`first == & f1 );
     431        assert( & lf`last  == & f1 );
    430432
    431433        verify(validate(lf));
    432434
    433         diref(fred, fred.mine) f1_mine = f1`from;
    434         insert_after(f1_mine, f2);
     435        with ( DLINK_VIA(fred, fred.mine) ) insert_after(f1, f2);
    435436
    436437        verify(validate(lf));
     
    439440        printYourFreddies(f1, f2, 0);   // 3.14; 3.14; 0.5; 0.5 (unmodified)
    440441
    441         assert(DUMB_COMPARE(lf`first, & f1));
    442         assert(DUMB_COMPARE(lf`last , & f2));
     442        assert( & lf`first == & f1 );
     443        assert( & lf`last  == & f2 );
    443444}
    444445
     
    450451        dlist(fred, fred.yours) lf;
    451452
    452         assert(! lf`first);
    453         assert(! lf`last);
     453        assert( & lf`first == 0p );
     454        assert( & lf`last == 0p );
    454455
    455456        insert_first(lf, f1);
    456457
    457         assert(DUMB_COMPARE(lf`first, & f1));
    458         assert(DUMB_COMPARE(lf`last , & f1));
     458        assert( & lf`first == & f1 );
     459        assert( & lf`last  == & f1 );
    459460
    460461        verify(validate(lf));
    461462
    462         diref(fred, fred.yours) f1_yours = f1`from;
    463         insert_after(f1_yours, f2);
     463    with ( DLINK_VIA(fred, fred.yours) ) insert_after(f1, f2);
    464464
    465465        verify(validate(lf));
     
    468468        printYourFreddies(f1, f2, 0);   // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified)
    469469
    470         assert(DUMB_COMPARE(lf`first, & f1));
    471         assert(DUMB_COMPARE(lf`last , & f2));
     470        assert( & lf`first == & f1 );
     471        assert( & lf`last  == & f2 );
    472472}
    473473
     
    477477        mary m2 = {0.5};
    478478
    479         dlist(mary, mary) lm;
    480 
    481         assert(! lm`first);
    482         assert(! lm`last);
     479        dlist(mary) lm;
     480
     481        assert( & lm`first == 0p );
     482        assert( & lm`last == 0p );
    483483
    484484        insert_first(lm, m1);
    485485
    486         assert(DUMB_COMPARE(lm`first, & m1));
    487         assert(DUMB_COMPARE(lm`last , & m1));
     486        assert( & lm`first == & m1 );
     487        assert( & lm`last  == & m1 );
    488488
    489489        verify(validate(lm));
     
    495495        printMariatheotokos(m1, m2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified)
    496496
    497         assert(DUMB_COMPARE(lm`first, & m1));
    498         assert(DUMB_COMPARE(lm`last , & m2));
     497        assert( & lm`first == & m1 );
     498        assert( & lm`last  == & m2 );
    499499}
    500500
     
    516516        dlist(fred, fred.mine) lf;
    517517
    518         assert(! lf`first);
    519         assert(! lf`last);
     518        assert( & lf`first == 0p );
     519        assert( & lf`last == 0p );
    520520
    521521        insert_last(lf, f2);
    522522
    523         assert(DUMB_COMPARE(lf`first, & f2));
    524         assert(DUMB_COMPARE(lf`last , & f2));
     523        assert( & lf`first == & f2 );
     524        assert( & lf`last  == & f2 );
    525525
    526526        verify(validate(lf));
    527527
    528         diref(fred, fred.mine) f2_mine = f2`from;
    529         insert_before(f2_mine, f1);
     528        with ( DLINK_VIA(fred, fred.mine) ) insert_before(f2, f1);
    530529
    531530        verify(validate(lf));
     
    534533        printYourFreddies(f1, f2, 0);   // 3.14; 3.14; 0.5; 0.5 (unmodified)
    535534
    536         assert(DUMB_COMPARE(lf`first, & f1));
    537         assert(DUMB_COMPARE(lf`last , & f2));
     535        assert( & lf`first == & f1 );
     536        assert( & lf`last  == & f2 );
    538537}
    539538
     
    545544        dlist(fred, fred.yours) lf;
    546545
    547         assert(! lf`first);
    548         assert(! lf`last);
     546        assert( & lf`first == 0p );
     547        assert( & lf`last == 0p );
    549548
    550549        insert_last(lf, f2);
    551550
    552         assert(DUMB_COMPARE(lf`first, & f2));
    553         assert(DUMB_COMPARE(lf`last , & f2));
     551        assert( & lf`first == & f2 );
     552        assert( & lf`last  == & f2 );
    554553
    555554        verify(validate(lf));
    556555
    557         diref(fred, fred.yours) f2_yours = f2`from;
    558         insert_before(f2_yours, f1);
     556        with ( DLINK_VIA(fred, fred.yours) )insert_before(f2, f1);
    559557
    560558        verify(validate(lf));
     
    563561        printYourFreddies(f1, f2, 0);   // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified)
    564562
    565         assert(DUMB_COMPARE(lf`first, & f1));
    566         assert(DUMB_COMPARE(lf`last , & f2));
     563        assert( & lf`first == & f1 );
     564        assert( & lf`last  == & f2 );
    567565}
    568566
     
    572570        mary m2 = {0.5};
    573571
    574         dlist(mary, mary) lm;
    575 
    576         assert(! lm`first);
    577         assert(! lm`last);
     572        dlist(mary) lm;
     573
     574        assert( & lm`first == 0p );
     575        assert( & lm`last == 0p );
    578576
    579577        insert_last(lm, m2);
    580578
    581         assert(DUMB_COMPARE(lm`first, & m2));
    582         assert(DUMB_COMPARE(lm`last , & m2));
     579        assert( & lm`first == & m2 );
     580        assert( & lm`last  == & m2 );
    583581
    584582        verify(validate(lm));
     
    590588        printMariatheotokos(m1, m2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified)
    591589
    592         assert(DUMB_COMPARE(lm`first, & m1));
    593         assert(DUMB_COMPARE(lm`last , & m2));
    594 }
    595 
     590        assert( & lm`first == & m1 );
     591        assert( & lm`last  == & m2 );
     592}
    596593#if 0
    597594
     
    900897        verify(validate(flm));
    901898
    902         diref(fred, fred.mine) f1_mine = f1`from;
    903         remove(f1_mine);
     899        with( DLINK_VIA(fred, fred.mine) ) remove(f1);
    904900
    905901        verify(validate(fly));
     
    916912        // assert(f1.$links_mine.prev.is_terminator == false);
    917913}
     914
    918915
    919916void test__remove_at_head__fred_yours() {
     
    939936        verify(validate(flm));
    940937
    941         diref(fred, fred.yours) f1_yours = f1`from;
    942         remove(f1_yours);
     938        with( DLINK_VIA(fred, fred.yours) ) remove(f1);
    943939
    944940        verify(validate(fly));
     
    962958        mary m3 = {3.7};
    963959
    964         dlist(mary, mary) ml;
     960        dlist(mary) ml;
    965961        insert_last(ml, m1);
    966962        insert_last(ml, m2);
     
    10171013        verify(validate(flm));
    10181014
    1019         diref(fred, fred.mine) f3_mine = f3`from;
    1020         remove(f3_mine);
     1015        with( DLINK_VIA(fred, fred.mine) ) remove(f3);
    10211016
    10221017        verify(validate(fly));
     
    10561051        verify(validate(flm));
    10571052
    1058         diref(fred, fred.yours) f3_yours = f3`from;
    1059         remove(f3_yours);
     1053        with( DLINK_VIA(fred, fred.yours) ) remove(f3);
    10601054
    10611055        verify(validate(fly));
     
    10791073        mary m3 = {3.7};
    10801074
    1081         dlist(mary, mary) ml;
     1075        dlist(mary) ml;
    10821076        insert_last(ml, m1);
    10831077        insert_last(ml, m2);
     
    11281122        verify(validate(flm));
    11291123
    1130         diref(fred, fred.mine) f_mine = f`from;
    1131         remove(f_mine);
    1132 
    1133         verify(validate(fly));
    1134         verify(validate(flm));
    1135 
    1136         assert(! flm`first);
    1137         assert(! flm`last);
     1124        with( DLINK_VIA(fred, fred.mine) ) remove(f);
     1125
     1126        verify(validate(fly));
     1127        verify(validate(flm));
     1128
     1129        assert( & flm`first == 0p );
     1130        assert( & flm`last == 0p );
    11381131
    11391132        printYourFreddies(fly`first, fly`last, 0);   // 0.7; 0.7; 0.7; 0.7 (unmodified)
     
    11681161        verify(validate(flm));
    11691162
    1170         diref(fred, fred.yours) f_yours = f`from;
    1171         remove(f_yours);
    1172 
    1173         verify(validate(fly));
    1174         verify(validate(flm));
    1175 
    1176         assert(! fly`first);
    1177         assert(! fly`last);
     1163        with( DLINK_VIA(fred, fred.yours) ) remove(f);
     1164
     1165        verify(validate(fly));
     1166        verify(validate(flm));
     1167
     1168        assert( & fly`first == 0p );
     1169        assert( & fly`last == 0p );
    11781170
    11791171        printYourFreddies(flm`first, flm`last, 0);   // 0.7; 0.7; 0.7; 0.7 (unmodified)
     
    11961188        mary m = {0.7};
    11971189
    1198         dlist(mary, mary) ml;
     1190        dlist(mary) ml;
    11991191        insert_last(ml, m);
    12001192
     
    12071199        verify(validate(ml));
    12081200
    1209         assert(! ml`first);
    1210         assert(! ml`last);
     1201        assert( & ml`first == 0p );
     1202        assert( & ml`last == 0p );
    12111203
    12121204        // observe f is solo in mine (now unlisted); in yours, it was just traversed
     
    12561248        verify(validate(flm));
    12571249
    1258         fred & popped = remove(flm`first);
     1250        fred & popped = try_pop_front(flm);
    12591251
    12601252        verify(validate(fly));
     
    12921284        verify(validate(flm));
    12931285
    1294         fred & popped = remove(fly`first);
     1286        fred & popped = try_pop_front(fly);
    12951287
    12961288        verify(validate(fly));
     
    13121304        mary m3 = {3.7};
    13131305
    1314         dlist(mary, mary) ml;
     1306        dlist(mary) ml;
    13151307        insert_last(ml, m1);
    13161308        insert_last(ml, m2);
     
    13211313        verify(validate(ml));
    13221314
    1323         mary & popped = remove(ml`first);
     1315        mary & popped = try_pop_front(ml);
    13241316
    13251317        verify(validate(ml));
     
    13551347        verify(validate(flm));
    13561348
    1357         fred & popped = remove(flm`last);
     1349        fred & popped = try_pop_back(flm);
    13581350
    13591351        verify(validate(fly));
     
    13911383        verify(validate(flm));
    13921384
    1393         fred & popped = remove(fly`last);
     1385        fred & popped = try_pop_back(fly);
    13941386
    13951387        verify(validate(fly));
     
    14111403        mary m3 = {3.7};
    14121404
    1413         dlist(mary, mary) ml;
     1405        dlist(mary) ml;
    14141406        insert_last(ml, m1);
    14151407        insert_last(ml, m2);
     
    14201412        verify(validate(ml));
    14211413
    1422         mary & popped = remove(ml`last);
     1414        mary & popped = try_pop_back(ml);
    14231415
    14241416        verify(validate(ml));
     
    14311423        assert( &popped == &m3 );
    14321424}
    1433 
    14341425
    14351426////////////////////////////////////////////////////////////
     
    14501441        mary m3 = {3.7};
    14511442
    1452         dlist(mary, mary) ml;   assert( ml`isEmpty);
     1443        dlist(mary) ml;                 assert( ml`isEmpty);
    14531444
    14541445        insert_last(ml, m1);    assert(!ml`isEmpty);
     
    14861477        mary m3 = {3.7};
    14871478
    1488         dlist(mary, mary) ml;
     1479        dlist(mary) ml;
    14891480
    14901481        mary &m1r = *0p;
     
    15881579        mary m1 = {1.7};
    15891580
    1590         dlist(mary, mary) ml;
     1581        dlist(mary) ml;
    15911582        mary & mlorigin = ml`elems;
    15921583
Note: See TracChangeset for help on using the changeset viewer.