Changeset 58870e6b


Ignore:
Timestamp:
Dec 7, 2020, 3:51:50 PM (12 months ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
arm-eh, jacob/cs343-translation, master, new-ast-unique-expr
Children:
d6089ad
Parents:
e91a255
Message:

switch from reference back to pointer

Location:
libcfa/src/bits
Files:
4 edited

Legend:

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

    re91a255 r58870e6b  
    3030        // wrappers to make Collection have T
    3131        forall( dtype T ) {
    32                 T *& Next( T & n ) {
    33                         return (T *)Next( (Colable *)&n );
     32                T *& Next( T * n ) {
     33                        return (T *)Next( (Colable *)n );
    3434                }
    3535
  • libcfa/src/bits/queue.hfa

    re91a255 r58870e6b  
    3131                        if ( ! listed( n ) ) abort( "(Queue &)%p.succ( %p ) : Node is not on a list.", &q, n );
    3232                        #endif // __CFA_DEBUG__
    33                         return (Next( *n ) == n) ? 0p : Next( *n );
     33                        return (Next( n ) == n) ? 0p : Next( n );
    3434                } // post: n == tail() & succ(n) == 0 | n != tail() & *succ(n) in *q
    3535
     
    3939                        #endif // __CFA_DEBUG__
    4040                        if ( last ) {
    41                                 Next( n ) = &head( q );
     41                                Next( &n ) = &head( q );
    4242                                q.root = &n;
    4343                        } else {
    4444                                root = last = &n;
    45                                 Next( n ) = &n;                                                 // last node points to itself
     45                                Next( &n ) = &n;                                                // last node points to itself
    4646                        }
    4747                }
     
    5151                        if ( listed( &n ) ) abort( "(Queue &)%p.addTail( %p ) : Node is already on another list.", &q, &n );
    5252                        #endif // __CFA_DEBUG__
    53                         if ( last ) Next( *last ) = &n;
     53                        if ( last ) Next( last ) = &n;
    5454                        else root = &n;
    5555                        last = &n;
    56                         Next( n ) = &n;                                                         // last node points to itself
     56                        Next( &n ) = &n;                                                        // last node points to itself
    5757                }
    5858
     
    6464                        T & t = head( q );
    6565                        if ( root ) {
    66                                 root = Next( *root );
     66                                root = Next( root );
    6767                                if ( &head( q ) == &t ) {
    6868                                        root = last = 0p;                                       // only one element
    6969                                }
    70                                 Next( t ) = 0p;
     70                                Next( &t ) = 0p;
    7171                        }
    7272                        return t;
     
    8181                        if ( ! listed( (Colable &)n ) ) abort( "(Queue &)%p.remove( %p ) : Node is not on a list.", &q, &n );
    8282                        #endif // __CFA_DEBUG__
    83                         T & prev = *0p;
    84                         T & curr = *(T *)root;
     83                        T * prev = 0p;
     84                        T * curr = (T *)root;
    8585                        for ( ;; ) {
    86                                 if ( &n == &curr ) {                                            // found => remove
     86                                if ( &n == curr ) {                                             // found => remove
    8787                                        if ( (T *)root == &n ) {
    8888                                                dropHead( q );
    8989                                        } else if ( last == &n ) {
    90                                                 last = &prev;
    91                                                 Next( *last ) = last;
     90                                                last = prev;
     91                                                Next( last ) = last;
    9292                                        } else {
    9393                                                Next( prev ) = Next( curr );
    9494                                        }
    95                                         Next( n ) = 0p;
     95                                        Next( &n ) = 0p;
    9696                                        break;
    9797                                }
    9898                                // not found => error
    9999                                #ifdef __CFA_DEBUG__
    100                                 if ( &curr == last ) abort( "(Queue &)%p.remove( %p ) : Node is not in list.", &q, &n );
     100                                if ( curr == last ) abort( "(Queue &)%p.remove( %p ) : Node is not in list.", &q, &n );
    101101                                #endif // __CFA_DEBUG__
    102                                 &prev = &curr;
    103                                 &curr = Next( curr );
     102                                prev = curr;
     103                                curr = Next( curr );
    104104                        }
    105105                } // post: ! listed( n )
     
    116116                                root = from.root;
    117117                        } else {                                                                        // "to" list not empty
    118                                 Next( *last ) = &head( from );
     118                                Next( last ) = &head( from );
    119119                        }
    120120                        last = from.last;
     
    131131                        to.root = from.root;                                            // start of "to" list
    132132                        to.last = &n;                                                           // end of "to" list
    133                         from.root = Next( n );                                          // start of "from" list
     133                        from.root = Next( &n );                                         // start of "from" list
    134134                        if ( &n == &head( from ) ) {                            // last node in list ?
    135135                                from.root = from.last = 0p;                             // mark "from" list empty
    136136                        } else {
    137                                 Next( n ) = &n;                                                 // fix end of "to" list
     137                                Next( &n ) = &n;                                                // fix end of "to" list
    138138                        }
    139139                        transfer( q, to );
     
    169169                        if ( curr ) {
    170170                                &tp = Curr( qi );
    171                                 T * n = Next( *Curr( qi ) );
     171                                T * n = Next( Curr( qi ) );
    172172                                curr = (n == Curr( qi ) ) ? 0p : n;
    173173                        } else &tp = 0p;
  • libcfa/src/bits/sequence.hfa

    re91a255 r58870e6b  
    1212
    1313        void ?{}( Seqable & sq ) with( sq ) {
    14                 ((Colable &) sq){};
     14                ((Colable &)sq){};
    1515                back = 0p;
    1616        } // post: ! listed()
     
    2828        // wrappers to make Collection have T
    2929        forall( dtype T ) {
    30                 T *& Back( T & n ) {
    31                         return (T *)Back( (Seqable *)&n );
     30                T *& Back( T * n ) {
     31                        return (T *)Back( (Seqable *)n );
    3232                }
    3333        } // distribution
     
    4949
    5050                void ?{}( Sequence(T) & s ) with( s ) {
    51                         ((Collection &) s){};
     51                        ((Collection &)s){};
    5252                }       // post: isEmpty().
    5353
    5454                // Return a pointer to the last sequence element, without removing it. 
    5555                T & tail( Sequence(T) & s ) with( s ) {
    56                         return root ? (T &)*Back( head( s ) ) : *0p;
     56                        return root ? (T &)*Back( &head( s ) ) : *0p;
    5757                }       // post: empty() & tail() == 0 | !empty() & tail() in *s
    5858
     
    6262                        if ( ! listed( n ) ) abort( "(Sequence &)%p.succ( %p ) : Node is not on a list.", &s, n );
    6363                        #endif // __CFA_DEBUG__
    64                         return Next( *n ) == &head( s ) ? 0p : Next( *n );
     64                        return Next( n ) == &head( s ) ? 0p : Next( n );
    6565                } // post: n == tail() & succ(n) == 0 | n != tail() & *succ(n) in *s
    6666
     
    7070                        if ( ! listed( n ) ) abort( "(Sequence &)%p.pred( %p ) : Node is not on a list.", &s, n );
    7171                        #endif // __CFA_DEBUG__
    72                         return n == &head( s ) ? 0p : Back( *n );
     72                        return n == &head( s ) ? 0p : Back( n );
    7373                }       // post: n == head() & head(n) == 0 | n != head() & *pred(n) in *s
    7474
     
    8181                        if ( &bef == &head( s ) ) {                                     // must change root
    8282                                if ( root ) {
    83                                         Next( n ) = &head( s );
    84                                         Back( n ) = Back( head( s ) );
     83                                        Next( &n ) = &head( s );
     84                                        Back( &n ) = Back( &head( s ) );
    8585                                        // inserted node must be consistent before it is seen
    8686                                        asm( "" : : : "memory" );                       // prevent code movement across barrier
    87                                         Back( head( s ) ) = &n;
    88                                         Next( *Back( n ) ) = &n;
     87                                        Back( &head( s ) ) = &n;
     88                                        Next( Back( &n ) ) = &n;
    8989                                } else {
    90                                         Next( n ) = &n;
    91                                         Back( n ) = &n;
     90                                        Next( &n ) = &n;
     91                                        Back( &n ) = &n;
    9292                                } // if
    9393                                // inserted node must be consistent before it is seen
     
    9696                        } else {
    9797                                if ( ! &bef ) &bef = &head( s );
    98                                 Next( n ) = &bef;
    99                                 Back( n ) = Back( bef );
     98                                Next( &n ) = &bef;
     99                                Back( &n ) = Back( &bef );
    100100                                // inserted node must be consistent before it is seen
    101101                                asm( "" : : : "memory" );                               // prevent code movement across barrier
    102                                 Back( bef ) = &n;
    103                                 Next( *Back( n ) ) = &n;
     102                                Back( &bef ) = &n;
     103                                Next( Back( &n ) ) = &n;
    104104                        } // if
    105105                }       // post: n->listed() & *n in *s & succ(n) == bef
     
    113113                        if ( ! &aft ) {                                                         // must change root
    114114                                if ( root ) {
    115                                         Next( n ) = &head( s );
    116                                         Back( n ) = Back( head( s ) );
     115                                        Next( &n ) = &head( s );
     116                                        Back( &n ) = Back( &head( s ) );
    117117                                        // inserted node must be consistent before it is seen
    118118                                        asm( "" : : : "memory" );                       // prevent code movement across barrier
    119                                         Back( head( s ) ) = &n;
    120                                         Next( *Back( n ) ) = &n;
     119                                        Back( &head( s ) ) = &n;
     120                                        Next( Back( &n ) ) = &n;
    121121                                } else {
    122                                         Next( n ) = &n;
    123                                         Back( n ) = &n;
     122                                        Next( &n ) = &n;
     123                                        Back( &n ) = &n;
    124124                                } // if
    125125                                asm( "" : : : "memory" );                               // prevent code movement across barrier
    126126                                root = &n;
    127127                        } else {
    128                                 Next( n ) = Next( aft );
    129                                 Back( n ) = &aft;
     128                                Next( &n ) = Next( &aft );
     129                                Back( &n ) = &aft;
    130130                                // inserted node must be consistent before it is seen
    131131                                asm( "" : : : "memory" );                               // prevent code movement across barrier
    132                                 Back( *Next( n ) ) = &n;
    133                                 Next( aft ) = &n;
     132                                Back( Next( &n ) ) = &n;
     133                                Next( &aft ) = &n;
    134134                        } // if
    135135                }         // post: n->listed() & *n in *s & succ(n) == bef
     
    141141                        #endif // __CFA_DEBUG__
    142142                        if ( &n == &head( s ) ) {
    143                                 if ( Next( head( s ) ) == &head( s ) ) root = 0p;
    144                                 else root = Next( head( s ) );
    145                         } // if
    146                         Back( *Next( n ) ) = Back( n );
    147                         Next( *Back( n ) ) = Next( n );
    148                         Next( n ) = Back( n ) = 0p;
     143                                if ( Next( &head( s ) ) == &head( s ) ) root = 0p;
     144                                else root = Next( &head( s ) );
     145                        } // if
     146                        Back( Next( &n ) ) = Back( &n );
     147                        Next( Back( &n ) ) = Next( &n );
     148                        Next( &n ) = Back( &n ) = 0p;
    149149                }                                                       // post: !n->listed().
    150150
     
    182182                                root = from.root;
    183183                        } else {                                                                        // "to" list not empty
    184                                 T * toEnd = Back( head( s ) );
    185                                 T * fromEnd = Back( head( from ) );
    186                                 Back( *root ) = fromEnd;
    187                                 Next( *fromEnd ) = &head( s );
    188                                 Back( *from.root ) = toEnd;
    189                                 Next( *toEnd ) = &head( from );
     184                                T * toEnd = Back( &head( s ) );
     185                                T * fromEnd = Back( &head( from ) );
     186                                Back( root ) = fromEnd;
     187                                Next( fromEnd ) = &head( s );
     188                                Back( from.root ) = toEnd;
     189                                Next( toEnd ) = &head( from );
    190190                        } // if
    191191                        from.root = 0p;                                                         // mark "from" list empty
     
    200200                        Sequence(T) to;
    201201                        to.root = from.root;                                            // start of "to" list
    202                         from.root = Next( n );                                          // start of "from" list
     202                        from.root = Next( &n );                                         // start of "from" list
    203203                        if ( to.root == from.root ) {                           // last node in list ?
    204204                                from.root = 0p;                                                 // mark "from" list empty
    205205                        } else {
    206                                 Back( head( from ) ) = Back( head( to ) ); // fix "from" list
    207                                 Next( *Back( head( to ) ) ) = &head( from );
    208                                 Next( n ) = &head( to );                                // fix "to" list
    209                                 Back( head( to ) ) = &n;
     206                                Back( &head( from ) ) = Back( &head( to ) ); // fix "from" list
     207                                Next( Back( &head( to ) ) ) = &head( from );
     208                                Next( &n ) = &head( to );                               // fix "to" list
     209                                Back( &head( to ) ) = &n;
    210210                        } // if
    211211                        transfer( s, to );
     
    231231
    232232                void ?{}( SeqIter(T) & si, Sequence(T) & s ) with( si ) {
    233                         ((ColIter &) si){};
     233                        ((ColIter &)si){};
    234234                        seq = &s;
    235235                        curr = &head( s );
     
    237237
    238238                void ?{}( SeqIter(T) & si, Sequence(T) & s, T & start ) with( si ) {
    239                         ((ColIter &) si){};
     239                        ((ColIter &)si){};
    240240                        seq = &s;
    241241                        curr = &start;
     
    267267        inline {
    268268                void ?{}( SeqIterRev(T) & si ) with( si ) {     
    269                         ((ColIter &) si){};
     269                        ((ColIter &)si){};
    270270                        seq = 0p;
    271271                } // post: elts = null.
    272272
    273273                void ?{}( SeqIterRev(T) & si, Sequence(T) & s ) with( si ) {   
    274                         ((ColIter &) si){};
     274                        ((ColIter &)si){};
    275275                        seq = &s;
    276276                        curr = &tail( s );
     
    278278
    279279                void ?{}( SeqIterRev(T) & si, Sequence(T) & s, T & start ) with( si ) {
    280                         ((ColIter &) si){};
     280                        ((ColIter &)si){};
    281281                        seq = &s;
    282282                        curr = &start;
  • libcfa/src/bits/stack.hfa

    re91a255 r58870e6b  
    2929                        if ( listed( (Colable &)(n) ) ) abort( "(Stack &)%p.addHead( %p ) : Node is already on another list.", &s, n );
    3030                        #endif // __CFA_DEBUG__
    31                         Next( n ) = &head( s ) ? &head( s ) : &n;
     31                        Next( &n ) = &head( s ) ? &head( s ) : &n;
    3232                        root = &n;
    3333                }
     
    4444                        T & t = head( s );
    4545                        if ( root ) {
    46                                 root = ( T *)Next( *root );
     46                                root = ( T *)Next( root );
    4747                                if ( &head( s ) == &t ) root = 0p;              // only one element ?
    48                                 Next( t ) = 0p;
     48                                Next( &t ) = 0p;
    4949                        } // if
    5050                        return t;
     
    8585                        if ( curr ) {
    8686                                &tp = Curr( si );
    87                                 T * n = Next( *Curr( si ) );
     87                                T * n = Next( Curr( si ) );
    8888                                curr = n == Curr( si ) ? 0p : n;
    8989                        } else &tp = 0p;
Note: See TracChangeset for help on using the changeset viewer.