Changeset 1e5cd9a


Ignore:
Timestamp:
May 12, 2021, 1:37:09 PM (17 months ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
arm-eh, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum
Children:
8cd40bf
Parents:
1680072 (diff), 7d51ef8 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

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

Files:
3 edited

Legend:

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

    r1680072 r1e5cd9a  
    1818#include <assert.h>
    1919
    20 forall( T & ) struct tag {};
    21 #define ttag(T) ((tag(T)){})
    22 #define ztag(n) ttag(Z(n))
    23 
    24 extern "C" {
    25     void * memset ( void * ptr, int value, size_t num );
    26 }
    27 
    28 trait embedded( tOuter &, tInner & ) {
    29     tInner & ?`inner( tOuter & );
     20forall( Decorator &, T & )
     21struct tytagref {
     22    inline T &;
    3023};
    3124
    32 // embedded is reflexive
    33 forall( tX & )
    34 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; }
    3532
    3633// use this on every case of plan-9 inheritance, to make embedded a closure of plan-9 inheritance
    37 #define P9_EMBEDDED( tOuter, tInner ) \
    38    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) )
    3948
    4049
     
    8594    }
    8695
    87     forall( tLinks & = tE ) {
    88 
    89         struct dlist {
    90             inline dlink(tE);
    91         };
    92 
    93         struct diref {
    94             inline tE &;
    95         };
    96     }
    97 
    98     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) ) ) {
    99102        static inline tE * $get_list_origin_addr( dlist(tE, tLinks) & lst ) {
    100             dlink(tE) & link_from_null = ( * (tE *) 0p )`inner`inner;
     103            dlink(tE) & link_from_null = ( * (tE *) 0p )`inner;
    101104            ptrdiff_t link_offset = (ptrdiff_t) & link_from_null;
    102105            size_t origin_addr = ((size_t) & lst) - link_offset;
     
    109112            ( ( dlink(tE) & ) this ){ listOrigin, listOrigin } ;
    110113        }
    111 
    112         // redundant
    113         // void ?{}( diref(tE, tLinks) & this, tE & target ) {
    114         //     tE && ref = this;
    115         //     &ref = &target;
    116         // }
    117114    }
    118115
     
    120117
    121118
    122 forall( tE &, tLinks & | embedded( tE, tLinks ) | embedded( tLinks, dlink(tE) ) ) {
    123 
    124         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) {
    125122                verify (&list_pos != 0p);
    126123                verify (&to_insert != 0p);
    127         dlink(tE) & linkToInsert = to_insert`inner`inner;
     124        dlink(tE) & linkToInsert = to_insert`inner;
    128125                verify(linkToInsert.prev == 0p);
    129126                verify(linkToInsert.next == 0p);
    130127        tE & list_pos_raw = list_pos;
    131128        tE & list_pos_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & list_pos_raw );
    132         asm( "" : : : "memory" );
    133         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;
    134132        tE & after_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & after_raw );
    135133                linkToInsert.prev = & list_pos_raw;
    136134                linkToInsert.next = & after_raw;
    137         (after_elem`inner`inner).prev = &to_insert;
    138                 (list_pos_elem`inner`inner).next = &to_insert;
    139         asm( "" : : : "memory" );
    140         }
    141 
    142         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) {
    143142                verify (&list_pos != 0p);
    144143                verify (&to_insert != 0p);
    145         dlink(tE) & linkToInsert = to_insert`inner`inner;
     144        dlink(tE) & linkToInsert = to_insert`inner;
    146145                verify(linkToInsert.next == 0p);
    147146                verify(linkToInsert.prev == 0p);
    148147        tE & list_pos_raw = list_pos;
    149148        tE & list_pos_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & list_pos_raw );
    150         asm( "" : : : "memory" );
    151         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;
    152152        tE & before_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & before_raw );
    153153                linkToInsert.next = & list_pos_raw;
    154154                linkToInsert.prev = & before_raw;
    155         (before_elem`inner`inner).next = &to_insert;
    156                 (list_pos_elem`inner`inner).prev = &to_insert;
    157         asm( "" : : : "memory" );
    158         }
    159 
    160         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) {
    161162                verify (&list_pos != 0p);
    162163        tE & list_pos_elem = list_pos;
    163164        verify( ! ORIGIN_TAG_QUERY((size_t) & list_pos_elem) );
    164         dlink(tE) & list_pos_links = list_pos_elem`inner`inner;
     165        dlink(tE) & list_pos_links = list_pos_elem`inner;
    165166        tE & before_raw = * list_pos_links.prev;
    166167        tE & before_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & before_raw );
    167         dlink(tE) & before_links = before_elem`inner`inner;
     168        dlink(tE) & before_links = before_elem`inner;
    168169        tE & after_raw = * list_pos_links.next;
    169170        tE & after_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & after_raw );
    170         dlink(tE) & after_links = after_elem`inner`inner;
     171        dlink(tE) & after_links = after_elem`inner;
    171172        before_links.next = &after_raw;
    172173        after_links.prev = &before_raw;
     
    178179        }
    179180
    180     static inline diref(tE, tLinks) ?`first( dlist(tE, tLinks) &lst ) {
     181    static inline tE & ?`first( dlist(tE, tLinks) &lst ) {
    181182        tE * firstPtr = lst.next;
    182183        if (ORIGIN_TAG_QUERY((size_t)firstPtr)) firstPtr = 0p;
    183         diref(tE, tLinks) ret = { *firstPtr };
    184         return ret;
    185     }
    186     static inline diref(tE, tLinks) ?`last ( dlist(tE, tLinks) &lst ) {
     184        return *firstPtr;
     185    }
     186    static inline tE & ?`last ( dlist(tE, tLinks) &lst ) {
    187187        tE * lastPtr = lst.prev;
    188188        if (ORIGIN_TAG_QUERY((size_t)lastPtr)) lastPtr = 0p;
    189         diref(tE, tLinks) ret = { *lastPtr };
    190         return ret;
    191     }
    192 
    193     static inline int ?!=?( const diref(tE, tLinks) & list_pos, zero_t ) {
    194         tE & list_pos_elem = list_pos;
    195         if (ORIGIN_TAG_QUERY((size_t) & list_pos_elem)) return 0;
    196         return & list_pos_elem != 0p;
    197     }
    198 
    199     static inline int DUMB_COMPARE( diref(tE, tLinks) list_pos, tE * elem ) {
    200         tE & signifiedLhs = list_pos;
    201         return &signifiedLhs == elem;
    202     }
    203 
    204     static inline diref(tE, tLinks) ?`from( tE & elem ) {
    205         diref(tE, tLinks) ret = { elem };
    206         return ret;
    207     }
    208 
    209     static inline diref(tE, tLinks) ?`elems( dlist(tE, tLinks) & lst ) {
     189        return *lastPtr;
     190    }
     191
     192    static inline bool ?`isEmpty( dlist(tE, tLinks) & lst ) {
     193        tE * firstPtr = lst.next;
     194        if (ORIGIN_TAG_QUERY((size_t)firstPtr)) firstPtr = 0p;
     195        return firstPtr == 0p;
     196    }
     197
     198    static inline tE & ?`elems( dlist(tE, tLinks) & lst ) {
    210199        tE * origin = $get_list_origin_addr( lst );
    211         diref(tE, tLinks) ret = { *origin };
    212         return ret;
    213     }
    214 
    215     static inline bool ?`moveNext( diref(tE, tLinks) & refx ) {
     200        return *origin;
     201    }
     202
     203    static inline bool ?`moveNext( tE && refx ) {
    216204        tE && ref_inner = refx;
    217205        tE & oldReferent = * (tE*) ORIGIN_TAG_CLEAR( (size_t) & ref_inner );
    218         &ref_inner = oldReferent`inner`inner.next;
     206        &ref_inner = oldReferent`inner.next;
    219207        return &ref_inner != 0p  &&
    220208            ! ORIGIN_TAG_QUERY( (size_t) & ref_inner );
    221209    }
    222210
    223     static inline bool ?`movePrev( diref(tE, tLinks) & refx ) {
     211    static inline bool ?`movePrev( tE && refx ) {
    224212        tE && ref_inner = refx;
    225213        tE & oldReferent = * (tE*) ORIGIN_TAG_CLEAR( (size_t) & ref_inner );
    226         &ref_inner = oldReferent`inner`inner.prev;
     214        &ref_inner = oldReferent`inner.prev;
    227215        return &ref_inner != 0p  &&
    228216            ! ORIGIN_TAG_QUERY( (size_t) & ref_inner );
    229217    }
    230218
     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;
     235    }
     236
    231237    static inline void insert_first( dlist(tE, tLinks) &lst, tE & e ) {
    232238        insert_after(lst`elems, e);
     
    235241    static inline void insert_last( dlist(tE, tLinks) &lst, tE & e ) {
    236242        insert_before(lst`elems, e);
     243    }
     244
     245    static inline tE & try_pop_front( dlist(tE, tLinks) &lst ) {
     246        tE & first_inlist = lst`first;
     247        tE & first_item = first_inlist;
     248        if (&first_item) remove(first_inlist);
     249        return first_item;
     250    }
     251
     252    static inline tE & try_pop_back( dlist(tE, tLinks) &lst ) {
     253        tE & last_inlist = lst`last;
     254        tE & last_item = last_inlist;
     255        if (&last_item) remove(last_inlist);
     256        return last_item;
    237257    }
    238258
     
    244264        tE & lagElem = *0p;
    245265
    246         while ( diref(tE, tLinks) it = this`elems; it`moveNext ) {
     266        while ( tE & it = this`elems; it`moveNext ) {
    247267            if (& lagElem == 0p &&  &it != & this`first ) return false;
    248268            & lagElem = & it;
     
    259279        tE & lagElem = *0p;
    260280
    261         while ( diref(tE, tLinks) it = this`elems; it`movePrev ) {
     281        while ( tE & it = this`elems; it`movePrev ) {
    262282            if (& lagElem == 0p &&  &it != & this`last ) return false;
    263283            & lagElem = & it;
     
    276296}
    277297
    278 forall( tE & | embedded( tE, dlink(tE) ) ) {
    279         static inline void insert_after(tE & list_pos, tE &to_insert ) {
    280         diref(tE, tE) list_pos_ref = list_pos`from;
    281         insert_after( list_pos_ref, to_insert );
    282     }
    283         static inline void insert_before(tE & list_pos, tE &to_insert ) {
    284         diref(tE, tE) list_pos_ref = list_pos`from;
    285         insert_before( list_pos_ref, to_insert );
    286     }
    287         static inline tE & remove(tE & list_pos ) {
    288         diref(tE, tE) list_pos_ref = list_pos`from;
    289         return remove( list_pos_ref );
    290     }
    291     static inline bool ?`moveNext( tE && ref ) {
    292         diref(tE, tE) & ref_dird = (diref(tE, tE) &) & ref;
    293         return ref_dird`moveNext;
    294     }
    295     static inline bool ?`movePrev( tE && ref ) {
    296         diref(tE, tE) & ref_dird = (diref(tE, tE) &) & ref;
    297         return ref_dird`movePrev;
    298     }
    299 
    300 }
  • tests/list/.expect/dlist-insert-remove-2.txt

    r1680072 r1e5cd9a  
    10921092-
    10931093-
     1094
     1095~~~~~~~~~~~~~~~~~~~ Ease-of-access cases ~~~~~~~~~~~~~~~~~~
     1096
     1097~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     1098Test 18-i.  Modifying Freds on MINE
     1099~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     1100Not implmented
     1101~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     1102Test 18-ii.  Modifying Freds on YOURS
     1103~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     1104Not implmented
     1105~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     1106Test 18-iii.  Modifying Maries
     1107~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     1108accessor_cases done
     1109try_pop cases done
     1110origin_mutation cases done
  • tests/list/dlist-insert-remove-2.cfa

    r1680072 r1e5cd9a  
    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));
     
    14301422
    14311423        assert( &popped == &m3 );
     1424}
     1425
     1426////////////////////////////////////////////////////////////
     1427//
     1428// Section 4g
     1429//
     1430// Test cases of `isEmpty, `hasPrev, `hasNext,
     1431// try_pop_front, try_pop_back, modifications via `elems
     1432//
     1433// Example of call-side user code
     1434//
     1435////////////////////////////////////////////////////////////
     1436
     1437void test__accessor_cases__mary() {
     1438
     1439        mary m1 = {1.7};
     1440        mary m2 = {2.7};
     1441        mary m3 = {3.7};
     1442
     1443        dlist(mary) ml;                 assert( ml`isEmpty);
     1444
     1445        insert_last(ml, m1);    assert(!ml`isEmpty);
     1446        insert_last(ml, m2);    assert(!ml`isEmpty);
     1447        insert_last(ml, m3);    assert(!ml`isEmpty);
     1448
     1449        mary & m1prev = m1`prev;
     1450        mary & m1next = m1`next;
     1451        mary & m2prev = m2`prev;
     1452        mary & m2next = m2`next;
     1453        mary & m3prev = m3`prev;
     1454        mary & m3next = m3`next;
     1455
     1456        assert (&m1prev == 0p);
     1457        assert (&m1next == &m2);
     1458        assert (&m2prev == &m1);
     1459        assert (&m2next == &m3);
     1460        assert (&m3prev == &m2);
     1461        assert (&m3next == 0p);
     1462
     1463        assert(!m1`hasPrev);
     1464        assert( m1`hasNext);
     1465        assert( m2`hasPrev);
     1466        assert( m2`hasNext);
     1467        assert( m3`hasPrev);
     1468        assert(!m3`hasNext);
     1469
     1470        printf("accessor_cases done\n");
     1471}
     1472
     1473void test__try_pop__mary() {
     1474
     1475        mary m1 = {1.7};
     1476        mary m2 = {2.7};
     1477        mary m3 = {3.7};
     1478
     1479        dlist(mary) ml;
     1480
     1481        mary &m1r = *0p;
     1482        mary &m2r = *0p;
     1483        mary &m3r = *0p;
     1484        mary &mxr = *0p;
     1485
     1486        // queue, back to front
     1487
     1488        assert( ml`isEmpty);
     1489
     1490        insert_last(ml, m1);
     1491        insert_last(ml, m2);
     1492        insert_last(ml, m3);
     1493
     1494        &m1r = & try_pop_front(ml);     assert(!ml`isEmpty);
     1495        &m2r = & try_pop_front(ml);     assert(!ml`isEmpty);
     1496        &m3r = & try_pop_front(ml);     assert( ml`isEmpty);
     1497        &mxr = & try_pop_front(ml);     assert( ml`isEmpty);
     1498
     1499        assert( &m1r == &m1 );
     1500        assert( &m2r == &m2 );
     1501        assert( &m3r == &m3 );
     1502        assert( &mxr == 0p  );
     1503
     1504        &m1r = 0p;
     1505        &m2r = 0p;
     1506        &m3r = 0p;
     1507
     1508        // queue, front to back
     1509
     1510        assert( ml`isEmpty);
     1511
     1512        insert_first(ml, m1);
     1513        insert_first(ml, m2);
     1514        insert_first(ml, m3);
     1515
     1516        &m1r = & try_pop_back(ml);      assert(!ml`isEmpty);
     1517        &m2r = & try_pop_back(ml);      assert(!ml`isEmpty);
     1518        &m3r = & try_pop_back(ml);      assert( ml`isEmpty);
     1519        &mxr = & try_pop_back(ml);      assert( ml`isEmpty);
     1520
     1521        assert( &m1r == &m1 );
     1522        assert( &m2r == &m2 );
     1523        assert( &m3r == &m3 );
     1524        assert( &mxr == 0p  );
     1525
     1526        &m1r = 0p;
     1527        &m2r = 0p;
     1528        &m3r = 0p;
     1529
     1530        // stack at front
     1531
     1532        assert( ml`isEmpty);
     1533
     1534        insert_first(ml, m1);
     1535        insert_first(ml, m2);
     1536        insert_first(ml, m3);
     1537
     1538        &m3r = & try_pop_front(ml);     assert(!ml`isEmpty);
     1539        &m2r = & try_pop_front(ml);     assert(!ml`isEmpty);
     1540        &m1r = & try_pop_front(ml);     assert( ml`isEmpty);
     1541        &mxr = & try_pop_front(ml);     assert( ml`isEmpty);
     1542
     1543        assert( &m1r == &m1 );
     1544        assert( &m2r == &m2 );
     1545        assert( &m3r == &m3 );
     1546        assert( &mxr == 0p  );
     1547
     1548        &m1r = 0p;
     1549        &m2r = 0p;
     1550        &m3r = 0p;
     1551
     1552        // stack at back
     1553
     1554        assert( ml`isEmpty);
     1555
     1556        insert_last(ml, m1);
     1557        insert_last(ml, m2);
     1558        insert_last(ml, m3);
     1559
     1560        &m3r = & try_pop_back(ml);      assert(!ml`isEmpty);
     1561        &m2r = & try_pop_back(ml);      assert(!ml`isEmpty);
     1562        &m1r = & try_pop_back(ml);      assert( ml`isEmpty);
     1563        &mxr = & try_pop_back(ml);      assert( ml`isEmpty);
     1564
     1565        assert( &m1r == &m1 );
     1566        assert( &m2r == &m2 );
     1567        assert( &m3r == &m3 );
     1568        assert( &mxr == 0p  );
     1569
     1570        &m1r = 0p;
     1571        &m2r = 0p;
     1572        &m3r = 0p;
     1573
     1574        printf("try_pop cases done\n");
     1575}
     1576
     1577void test__origin_mutation__mary() {
     1578
     1579        mary m1 = {1.7};
     1580
     1581        dlist(mary) ml;
     1582        mary & mlorigin = ml`elems;
     1583
     1584        // insert before the origin
     1585
     1586        insert_before( ml`elems, m1 );
     1587        assert( ! ml`isEmpty );
     1588
     1589        mary & mlfirst = ml`first;
     1590        mary & mllast = ml`last;
     1591
     1592        assert( &m1 == & mlfirst );
     1593        assert( &m1 == & mllast );
     1594
     1595        // moveNext after last goes back to origin, &vv
     1596
     1597        bool canMoveNext = mllast`moveNext;
     1598        bool canMovePrev = mlfirst`movePrev;
     1599
     1600        assert( ! canMoveNext );
     1601        assert( ! canMovePrev );
     1602
     1603        assert( &mlorigin == & mlfirst );
     1604        assert( &mlorigin == & mllast );
     1605
     1606        printf("origin_mutation cases done\n");
    14321607}
    14331608
     
    17081883        test__pop_last__maries();
    17091884
     1885        sout | "";
     1886        sout | "~~~~~~~~~~~~~~~~~~~ Ease-of-access cases ~~~~~~~~~~~~~~~~~~";
     1887        sout | "";
     1888
     1889        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
     1890        sout | "Test 18-i.  Modifying Freds on MINE";
     1891        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
     1892        sout | "Not implmented";
     1893
     1894        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
     1895        sout | "Test 18-ii.  Modifying Freds on YOURS";
     1896        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
     1897        sout | "Not implmented";
     1898
     1899        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
     1900        sout | "Test 18-iii.  Modifying Maries";
     1901        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
     1902
     1903        test__accessor_cases__mary();
     1904        test__try_pop__mary();
     1905        test__origin_mutation__mary();
     1906
    17101907        return 0;
    17111908}
Note: See TracChangeset for help on using the changeset viewer.