Ignore:
Timestamp:
Dec 3, 2020, 11:56:01 AM (12 months ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
arm-eh, jacob/cs343-translation, master, new-ast-unique-expr
Children:
89c982c, a78c3ff, cc5cc27
Parents:
1db306a
Message:

more code sharing in containers

File:
1 edited

Legend:

Unmodified
Added
Removed
  • libcfa/src/bits/sequence.hfa

    r1db306a r636d3715  
    1010inline {
    1111        void ?{}( Seqable & sq ) with( sq ) {
    12                 ((Colable & ) sq){};
     12                ((Colable &) sq){};
    1313                back = 0p;
    1414        } // post: ! listed()
     
    3434                } // post: empty() & head() == 0 | !empty() & head() in *s
    3535
    36                 bool empty( Sequence(T) & s ) with( s ) {               // 0 <=> *s contains no elements
    37                         return empty( (Collection &)s );
    38                 }
    39 
    40                 bool listed( T * n ) {
    41                         return Next( (Colable *)n ) != 0;
    42                 }
    43 
    44                 T *& Next( T * n ) {
    45                         return (T *)Next( (Colable *)n );
    46                 }
    47 
    4836                T *& Back( T * n ) {
    4937                        return (T *)Back( (Seqable *)n );
    50                 }
    51 
    52                 T * Root( Sequence(T) & s ) with( s ) {
    53                         return (T *)root;
    5438                }
    5539
     
    6347                // Return a pointer to the last sequence element, without removing it. 
    6448                T & tail( Sequence(T) & s ) with( s ) {
    65                         return root ? (T &)Back( Root( s ) ) : *0p;     // needs cast?
     49                        return root ? (T &)Back( head( s ) ) : *0p;     // needs cast?
    6650                }       // post: empty() & tail() == 0 | !empty() & tail() in *s
    6751
     
    7155                        if ( ! listed( n ) ) abort( "(Sequence &)%p.succ( %p ) : Node is not on a list.", &s, n );
    7256#endif // __CFA_DEBUG__
    73                         return Next( n ) == Root( s ) ? 0p : Next( n );
     57                        return Next( n ) == head( s ) ? 0p : Next( n );
    7458                }       // post: n == tail() & succ(n) == 0 | n != tail() & *succ(n) in *s
    7559
     
    7963                        if ( ! listed( n ) ) abort( "(Sequence &)%p.pred( %p ) : Node is not on a list.", &s, n );
    8064#endif // __CFA_DEBUG__
    81                         return n == Root( s ) ? 0p : Back( n );
     65                        return n == head( s ) ? 0p : Back( n );
    8266                }       // post: n == head() & head(n) == 0 | n != head() & *pred(n) in *s
    8367
     
    8872                        if ( listed( &n ) ) abort( "(Sequence &)%p.insertBef( %p, %p ) : Node is already on another list.", &s, n, &bef );
    8973#endif // __CFA_DEBUG__
    90                         if ( &bef == Root( s ) ) {                                      // must change root
     74                        if ( &bef == head( s ) ) {                                      // must change root
    9175                                if ( root ) {
    92                                         Next( &n ) = Root( s );
    93                                         Back( &n ) = Back( Root( s ) );
     76                                        Next( &n ) = head( s );
     77                                        Back( &n ) = Back( head( s ) );
    9478                                        // inserted node must be consistent before it is seen
    9579                                        asm( "" : : : "memory" );                       // prevent code movement across barrier
    96                                         Back( Root( s ) ) = &n;
     80                                        Back( head( s ) ) = &n;
    9781                                        Next( Back( &n ) ) = &n;
    9882                                } else {
     
    10488                                root = &n;
    10589                        } else {
    106                                 if ( ! &bef ) &bef = Root( s );
     90                                if ( ! &bef ) &bef = head( s );
    10791                                Next( &n ) = &bef;
    10892                                Back( &n ) = Back( &bef );
     
    122106                        if ( ! &aft ) {                                                         // must change root
    123107                                if ( root ) {
    124                                         Next( &n ) = Root( s );
    125                                         Back( &n ) = Back( Root( s ) );
     108                                        Next( &n ) = head( s );
     109                                        Back( &n ) = Back( head( s ) );
    126110                                        // inserted node must be consistent before it is seen
    127111                                        asm( "" : : : "memory" );                       // prevent code movement across barrier
    128                                         Back( Root( s ) ) = &n;
     112                                        Back( head( s ) ) = &n;
    129113                                        Next( Back( &n ) ) = &n;
    130114                                } else {
     
    149133                        if ( ! listed( &n ) ) abort( "(Sequence &)%p.remove( %p ) : Node is not on a list.", &s, &n );
    150134#endif // __CFA_DEBUG__
    151                         if ( &n == Root( s ) ) {
    152                                 if ( Next( Root( s ) ) == Root( s ) ) root = 0p;
    153                                 else root = Next( Root(s ) );
     135                        if ( &n == head( s ) ) {
     136                                if ( Next( head( s ) ) == head( s ) ) root = 0p;
     137                                else root = Next( head(s ) );
    154138                        } // if
    155139                        Back( Next( &n ) ) = Back( &n );
     
    191175                                root = from.root;
    192176                        } else {                                                                        // "to" list not empty
    193                                 T * toEnd = Back( Root( s ) );
    194                                 T * fromEnd = Back( Root( from ) );
     177                                T * toEnd = Back( head( s ) );
     178                                T * fromEnd = Back( head( from ) );
    195179                                Back( root ) = fromEnd;
    196                                 Next( fromEnd ) = Root( s );
     180                                Next( fromEnd ) = head( s );
    197181                                Back( from.root ) = toEnd;
    198                                 Next( toEnd ) = Root( from );
     182                                Next( toEnd ) = head( from );
    199183                        } // if
    200184                        from.root = 0p;                                                         // mark "from" list empty
     
    213197                                from.root = 0p;                                                 // mark "from" list empty
    214198                        } else {
    215                                 Back( Root( from ) ) = Back( Root( to ) ); // fix "from" list
    216                                 Next( Back( Root( to ) ) ) = Root( from );
    217                                 Next( n ) = Root( to );                                 // fix "to" list
    218                                 Back( Root( to ) ) = n;
     199                                Back( head( from ) ) = Back( head( to ) ); // fix "from" list
     200                                Next( Back( head( to ) ) ) = head( from );
     201                                Next( n ) = head( to );                                 // fix "to" list
     202                                Back( head( to ) ) = n;
    219203                        } // if
    220204                        transfer( s, to );
     
    231215
    232216        inline {
    233                 // wrappers to make ColIter have T
    234                 T * Curr( SeqIter(T) & si ) with( si ) {
    235                         return (T *)curr;
    236                 }
    237 
    238                 void ?{}( SeqIter(T) & si ) with( si ) {       
    239                         ((ColIter &) si){};
     217                void ?{}( SeqIter(T) & si ) with( si ) {
     218                        ((ColIter &)si){};
    240219                        seq = 0p;
    241220                } // post: elts = null.
     
    270249
    271250        inline {
    272                 // wrappers to make ColIter have T
    273                 T * Curr( SeqIterRev(T) & si ) with( si ) {
    274                         return (T *)curr;
    275                 }
    276 
    277251                void ?{}( SeqIterRev(T) & si ) with( si ) {     
    278252                        ((ColIter &) si){};
Note: See TracChangeset for help on using the changeset viewer.