Changeset 1e5cd9a
- Timestamp:
- May 12, 2021, 1:37:09 PM (3 years ago)
- Branches:
- ADT, arm-eh, ast-experimental, 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. - Files:
-
- 3 edited
Legend:
- Unmodified
- Added
- Removed
-
libcfa/src/containers/list2.hfa
r1680072 r1e5cd9a 18 18 #include <assert.h> 19 19 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 & ); 20 forall( Decorator &, T & ) 21 struct tytagref { 22 inline T &; 30 23 }; 31 24 32 // embedded is reflexive 33 forall( tX & ) 34 static inline tX & ?`inner( tX & this ) { return this; } 25 trait embedded( tOuter &, tMid &, tInner & ) { 26 tytagref( tMid, tInner ) ?`inner( tOuter & ); 27 }; 28 29 // embedded is reflexive, with no info (void) as the type tag 30 forall (T &) 31 tytagref(void, T) ?`inner ( T & this ) { tytagref( void, T ) ret = {this}; return ret; } 35 32 36 33 // 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 ) \ 35 forall( 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) ) 39 48 40 49 … … 85 94 } 86 95 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) ) ) { 99 102 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; 101 104 ptrdiff_t link_offset = (ptrdiff_t) & link_from_null; 102 105 size_t origin_addr = ((size_t) & lst) - link_offset; … … 109 112 ( ( dlink(tE) & ) this ){ listOrigin, listOrigin } ; 110 113 } 111 112 // redundant113 // void ?{}( diref(tE, tLinks) & this, tE & target ) {114 // tE && ref = this;115 // &ref = ⌖116 // }117 114 } 118 115 … … 120 117 121 118 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) {119 forall( tE &, tLinks & | embedded( tE, tLinks, dlink(tE) ) ) { 120 121 static inline void insert_after(tE & list_pos, tE &to_insert) { 125 122 verify (&list_pos != 0p); 126 123 verify (&to_insert != 0p); 127 dlink(tE) & linkToInsert = to_insert`inner `inner;124 dlink(tE) & linkToInsert = to_insert`inner; 128 125 verify(linkToInsert.prev == 0p); 129 126 verify(linkToInsert.next == 0p); 130 127 tE & list_pos_raw = list_pos; 131 128 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; 134 132 tE & after_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & after_raw ); 135 133 linkToInsert.prev = & list_pos_raw; 136 134 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) { 143 142 verify (&list_pos != 0p); 144 143 verify (&to_insert != 0p); 145 dlink(tE) & linkToInsert = to_insert`inner `inner;144 dlink(tE) & linkToInsert = to_insert`inner; 146 145 verify(linkToInsert.next == 0p); 147 146 verify(linkToInsert.prev == 0p); 148 147 tE & list_pos_raw = list_pos; 149 148 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; 152 152 tE & before_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & before_raw ); 153 153 linkToInsert.next = & list_pos_raw; 154 154 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) { 161 162 verify (&list_pos != 0p); 162 163 tE & list_pos_elem = list_pos; 163 164 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; 165 166 tE & before_raw = * list_pos_links.prev; 166 167 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; 168 169 tE & after_raw = * list_pos_links.next; 169 170 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; 171 172 before_links.next = &after_raw; 172 173 after_links.prev = &before_raw; … … 178 179 } 179 180 180 static inline diref(tE, tLinks)?`first( dlist(tE, tLinks) &lst ) {181 static inline tE & ?`first( dlist(tE, tLinks) &lst ) { 181 182 tE * firstPtr = lst.next; 182 183 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 ) { 187 187 tE * lastPtr = lst.prev; 188 188 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 ) { 210 199 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 ) { 216 204 tE && ref_inner = refx; 217 205 tE & oldReferent = * (tE*) ORIGIN_TAG_CLEAR( (size_t) & ref_inner ); 218 &ref_inner = oldReferent`inner `inner.next;206 &ref_inner = oldReferent`inner.next; 219 207 return &ref_inner != 0p && 220 208 ! ORIGIN_TAG_QUERY( (size_t) & ref_inner ); 221 209 } 222 210 223 static inline bool ?`movePrev( diref(tE, tLinks)& refx ) {211 static inline bool ?`movePrev( tE && refx ) { 224 212 tE && ref_inner = refx; 225 213 tE & oldReferent = * (tE*) ORIGIN_TAG_CLEAR( (size_t) & ref_inner ); 226 &ref_inner = oldReferent`inner `inner.prev;214 &ref_inner = oldReferent`inner.prev; 227 215 return &ref_inner != 0p && 228 216 ! ORIGIN_TAG_QUERY( (size_t) & ref_inner ); 229 217 } 230 218 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 231 237 static inline void insert_first( dlist(tE, tLinks) &lst, tE & e ) { 232 238 insert_after(lst`elems, e); … … 235 241 static inline void insert_last( dlist(tE, tLinks) &lst, tE & e ) { 236 242 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; 237 257 } 238 258 … … 244 264 tE & lagElem = *0p; 245 265 246 while ( diref(tE, tLinks)it = this`elems; it`moveNext ) {266 while ( tE & it = this`elems; it`moveNext ) { 247 267 if (& lagElem == 0p && &it != & this`first ) return false; 248 268 & lagElem = & it; … … 259 279 tE & lagElem = *0p; 260 280 261 while ( diref(tE, tLinks)it = this`elems; it`movePrev ) {281 while ( tE & it = this`elems; it`movePrev ) { 262 282 if (& lagElem == 0p && &it != & this`last ) return false; 263 283 & lagElem = & it; … … 276 296 } 277 297 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 1092 1092 - 1093 1093 - 1094 1095 ~~~~~~~~~~~~~~~~~~~ Ease-of-access cases ~~~~~~~~~~~~~~~~~~ 1096 1097 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 1098 Test 18-i. Modifying Freds on MINE 1099 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 1100 Not implmented 1101 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 1102 Test 18-ii. Modifying Freds on YOURS 1103 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 1104 Not implmented 1105 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 1106 Test 18-iii. Modifying Maries 1107 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 1108 accessor_cases done 1109 try_pop cases done 1110 origin_mutation cases done -
tests/list/dlist-insert-remove-2.cfa
r1680072 r1e5cd9a 55 55 //////////////////////////////////////////////////////////// 56 56 57 void printMyFredsFwd(diref(fred, fred.mine) f) { 57 void printMyFredsFwd(fred & f) { 58 with( DLINK_VIA( fred, fred.mine ) ) 58 59 do { 59 60 sout | f.adatum; … … 61 62 } 62 63 63 void printMyFredsRev(diref(fred, fred.mine) f) { 64 void printMyFredsRev(fred & f) { 65 with( DLINK_VIA( fred, fred.mine ) ) 64 66 do { 65 67 sout | f.adatum; … … 75 77 } 76 78 if (&f1) { 77 printMyFredsFwd(f1 `from); sout | '-';78 printMyFredsRev(f1 `from); sout | '-';79 printMyFredsFwd(f1); sout | '-'; 80 printMyFredsRev(f1); sout | '-'; 79 81 } else { 80 82 sout | '-'; sout | '-'; 81 83 } 82 84 if (&f2) { 83 printMyFredsFwd(f2 `from); sout | '-';84 printMyFredsRev(f2 `from); sout | '-';85 printMyFredsFwd(f2); sout | '-'; 86 printMyFredsRev(f2); sout | '-'; 85 87 } else { 86 88 sout | '-'; sout | '-'; … … 88 90 } 89 91 90 void printYourFredsFwd(diref(fred, fred.yours) f) { 92 void printYourFredsFwd(fred & f) { 93 with( DLINK_VIA( fred, fred.yours ) ) 91 94 do { 92 95 sout | f.adatum; … … 94 97 } 95 98 96 void printYourFredsRev(diref(fred, fred.yours) f) { 99 void printYourFredsRev(fred & f) { 100 with( DLINK_VIA( fred, fred.yours ) ) 97 101 do { 98 102 sout | f.adatum; … … 107 111 } 108 112 if (&f1) { 109 printYourFredsFwd(f1 `from); sout | '-';110 printYourFredsRev(f1 `from); sout | '-';113 printYourFredsFwd(f1); sout | '-'; 114 printYourFredsRev(f1); sout | '-'; 111 115 } else { 112 116 sout | '-'; sout | '-'; 113 117 } 114 118 if (&f2) { 115 printYourFredsFwd(f2 `from); sout | '-';116 printYourFredsRev(f2 `from); sout | '-';119 printYourFredsFwd(f2); sout | '-'; 120 printYourFredsRev(f2); sout | '-'; 117 121 } else { 118 122 sout | '-'; sout | '-'; … … 275 279 // All three tests exercise the case of creating an empty container and 276 280 // adding two items to it. 277 278 281 void test__insertfirst_two_on_empty__fred_mine() { 279 282 … … 317 320 printYourFreddies(f1, f2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified) 318 321 } 319 320 322 void test__insertfirst_two_on_empty__mary() { 321 323 … … 323 325 mary m2 = {0.5}; 324 326 325 dlist(mary , mary) lm;327 dlist(mary) lm; 326 328 327 329 verify(validate(lm)); … … 392 394 mary m2 = {0.5}; 393 395 394 dlist(mary , mary) lm;396 dlist(mary) lm; 395 397 396 398 verify(validate(lm)); … … 421 423 dlist(fred, fred.mine) lf; 422 424 423 assert( ! lf`first);424 assert( ! lf`last);425 assert( & lf`first == 0p ); 426 assert( & lf`last == 0p ); 425 427 426 428 insert_first(lf, f1); 427 429 428 assert( DUMB_COMPARE(lf`first, & f1));429 assert( DUMB_COMPARE(lf`last , & f1));430 assert( & lf`first == & f1 ); 431 assert( & lf`last == & f1 ); 430 432 431 433 verify(validate(lf)); 432 434 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); 435 436 436 437 verify(validate(lf)); … … 439 440 printYourFreddies(f1, f2, 0); // 3.14; 3.14; 0.5; 0.5 (unmodified) 440 441 441 assert( DUMB_COMPARE(lf`first, & f1));442 assert( DUMB_COMPARE(lf`last , & f2));442 assert( & lf`first == & f1 ); 443 assert( & lf`last == & f2 ); 443 444 } 444 445 … … 450 451 dlist(fred, fred.yours) lf; 451 452 452 assert( ! lf`first);453 assert( ! lf`last);453 assert( & lf`first == 0p ); 454 assert( & lf`last == 0p ); 454 455 455 456 insert_first(lf, f1); 456 457 457 assert( DUMB_COMPARE(lf`first, & f1));458 assert( DUMB_COMPARE(lf`last , & f1));458 assert( & lf`first == & f1 ); 459 assert( & lf`last == & f1 ); 459 460 460 461 verify(validate(lf)); 461 462 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); 464 464 465 465 verify(validate(lf)); … … 468 468 printYourFreddies(f1, f2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified) 469 469 470 assert( DUMB_COMPARE(lf`first, & f1));471 assert( DUMB_COMPARE(lf`last , & f2));470 assert( & lf`first == & f1 ); 471 assert( & lf`last == & f2 ); 472 472 } 473 473 … … 477 477 mary m2 = {0.5}; 478 478 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 ); 483 483 484 484 insert_first(lm, m1); 485 485 486 assert( DUMB_COMPARE(lm`first, & m1));487 assert( DUMB_COMPARE(lm`last , & m1));486 assert( & lm`first == & m1 ); 487 assert( & lm`last == & m1 ); 488 488 489 489 verify(validate(lm)); … … 495 495 printMariatheotokos(m1, m2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified) 496 496 497 assert( DUMB_COMPARE(lm`first, & m1));498 assert( DUMB_COMPARE(lm`last , & m2));497 assert( & lm`first == & m1 ); 498 assert( & lm`last == & m2 ); 499 499 } 500 500 … … 516 516 dlist(fred, fred.mine) lf; 517 517 518 assert( ! lf`first);519 assert( ! lf`last);518 assert( & lf`first == 0p ); 519 assert( & lf`last == 0p ); 520 520 521 521 insert_last(lf, f2); 522 522 523 assert( DUMB_COMPARE(lf`first, & f2));524 assert( DUMB_COMPARE(lf`last , & f2));523 assert( & lf`first == & f2 ); 524 assert( & lf`last == & f2 ); 525 525 526 526 verify(validate(lf)); 527 527 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); 530 529 531 530 verify(validate(lf)); … … 534 533 printYourFreddies(f1, f2, 0); // 3.14; 3.14; 0.5; 0.5 (unmodified) 535 534 536 assert( DUMB_COMPARE(lf`first, & f1));537 assert( DUMB_COMPARE(lf`last , & f2));535 assert( & lf`first == & f1 ); 536 assert( & lf`last == & f2 ); 538 537 } 539 538 … … 545 544 dlist(fred, fred.yours) lf; 546 545 547 assert( ! lf`first);548 assert( ! lf`last);546 assert( & lf`first == 0p ); 547 assert( & lf`last == 0p ); 549 548 550 549 insert_last(lf, f2); 551 550 552 assert( DUMB_COMPARE(lf`first, & f2));553 assert( DUMB_COMPARE(lf`last , & f2));551 assert( & lf`first == & f2 ); 552 assert( & lf`last == & f2 ); 554 553 555 554 verify(validate(lf)); 556 555 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); 559 557 560 558 verify(validate(lf)); … … 563 561 printYourFreddies(f1, f2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified) 564 562 565 assert( DUMB_COMPARE(lf`first, & f1));566 assert( DUMB_COMPARE(lf`last , & f2));563 assert( & lf`first == & f1 ); 564 assert( & lf`last == & f2 ); 567 565 } 568 566 … … 572 570 mary m2 = {0.5}; 573 571 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 ); 578 576 579 577 insert_last(lm, m2); 580 578 581 assert( DUMB_COMPARE(lm`first, & m2));582 assert( DUMB_COMPARE(lm`last , & m2));579 assert( & lm`first == & m2 ); 580 assert( & lm`last == & m2 ); 583 581 584 582 verify(validate(lm)); … … 590 588 printMariatheotokos(m1, m2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified) 591 589 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 } 596 593 #if 0 597 594 … … 900 897 verify(validate(flm)); 901 898 902 diref(fred, fred.mine) f1_mine = f1`from; 903 remove(f1_mine); 899 with( DLINK_VIA(fred, fred.mine) ) remove(f1); 904 900 905 901 verify(validate(fly)); … … 916 912 // assert(f1.$links_mine.prev.is_terminator == false); 917 913 } 914 918 915 919 916 void test__remove_at_head__fred_yours() { … … 939 936 verify(validate(flm)); 940 937 941 diref(fred, fred.yours) f1_yours = f1`from; 942 remove(f1_yours); 938 with( DLINK_VIA(fred, fred.yours) ) remove(f1); 943 939 944 940 verify(validate(fly)); … … 962 958 mary m3 = {3.7}; 963 959 964 dlist(mary , mary) ml;960 dlist(mary) ml; 965 961 insert_last(ml, m1); 966 962 insert_last(ml, m2); … … 1017 1013 verify(validate(flm)); 1018 1014 1019 diref(fred, fred.mine) f3_mine = f3`from; 1020 remove(f3_mine); 1015 with( DLINK_VIA(fred, fred.mine) ) remove(f3); 1021 1016 1022 1017 verify(validate(fly)); … … 1056 1051 verify(validate(flm)); 1057 1052 1058 diref(fred, fred.yours) f3_yours = f3`from; 1059 remove(f3_yours); 1053 with( DLINK_VIA(fred, fred.yours) ) remove(f3); 1060 1054 1061 1055 verify(validate(fly)); … … 1079 1073 mary m3 = {3.7}; 1080 1074 1081 dlist(mary , mary) ml;1075 dlist(mary) ml; 1082 1076 insert_last(ml, m1); 1083 1077 insert_last(ml, m2); … … 1128 1122 verify(validate(flm)); 1129 1123 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 ); 1138 1131 1139 1132 printYourFreddies(fly`first, fly`last, 0); // 0.7; 0.7; 0.7; 0.7 (unmodified) … … 1168 1161 verify(validate(flm)); 1169 1162 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 ); 1178 1170 1179 1171 printYourFreddies(flm`first, flm`last, 0); // 0.7; 0.7; 0.7; 0.7 (unmodified) … … 1196 1188 mary m = {0.7}; 1197 1189 1198 dlist(mary , mary) ml;1190 dlist(mary) ml; 1199 1191 insert_last(ml, m); 1200 1192 … … 1207 1199 verify(validate(ml)); 1208 1200 1209 assert( ! ml`first);1210 assert( ! ml`last);1201 assert( & ml`first == 0p ); 1202 assert( & ml`last == 0p ); 1211 1203 1212 1204 // observe f is solo in mine (now unlisted); in yours, it was just traversed … … 1256 1248 verify(validate(flm)); 1257 1249 1258 fred & popped = remove(flm`first);1250 fred & popped = try_pop_front(flm); 1259 1251 1260 1252 verify(validate(fly)); … … 1292 1284 verify(validate(flm)); 1293 1285 1294 fred & popped = remove(fly`first);1286 fred & popped = try_pop_front(fly); 1295 1287 1296 1288 verify(validate(fly)); … … 1312 1304 mary m3 = {3.7}; 1313 1305 1314 dlist(mary , mary) ml;1306 dlist(mary) ml; 1315 1307 insert_last(ml, m1); 1316 1308 insert_last(ml, m2); … … 1321 1313 verify(validate(ml)); 1322 1314 1323 mary & popped = remove(ml`first);1315 mary & popped = try_pop_front(ml); 1324 1316 1325 1317 verify(validate(ml)); … … 1355 1347 verify(validate(flm)); 1356 1348 1357 fred & popped = remove(flm`last);1349 fred & popped = try_pop_back(flm); 1358 1350 1359 1351 verify(validate(fly)); … … 1391 1383 verify(validate(flm)); 1392 1384 1393 fred & popped = remove(fly`last);1385 fred & popped = try_pop_back(fly); 1394 1386 1395 1387 verify(validate(fly)); … … 1411 1403 mary m3 = {3.7}; 1412 1404 1413 dlist(mary , mary) ml;1405 dlist(mary) ml; 1414 1406 insert_last(ml, m1); 1415 1407 insert_last(ml, m2); … … 1420 1412 verify(validate(ml)); 1421 1413 1422 mary & popped = remove(ml`last);1414 mary & popped = try_pop_back(ml); 1423 1415 1424 1416 verify(validate(ml)); … … 1430 1422 1431 1423 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 1437 void 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 1473 void 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 1577 void 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"); 1432 1607 } 1433 1608 … … 1708 1883 test__pop_last__maries(); 1709 1884 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 1710 1907 return 0; 1711 1908 }
Note: See TracChangeset
for help on using the changeset viewer.