Changeset b5629d8 for libcfa


Ignore:
Timestamp:
Dec 3, 2020, 1:49:01 PM (5 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum
Children:
62e456f, ab0257b9
Parents:
f0d67e5 (diff), fa11053 (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

Location:
libcfa/src/bits
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • libcfa/src/bits/collection.hfa

    rf0d67e5 rb5629d8  
    1313        // return true iff *this is an element of a collection
    1414        bool listed( Colable & co ) with( co ) {                        // pre: this != 0
    15                 return next != 0;
     15                return next != 0p;
    1616        }
    1717
    … …  
    2323                return cp->next;
    2424        }
     25
     26        forall( dtype T ) {
     27                T *& Next( T * n ) {
     28                        return (T *)Next( (Colable *)n );
     29                }
     30
     31                bool listed( T * n ) {
     32                        return Next( (Colable *)n ) != 0p;
     33                }
     34        } // distribution
    2535} // distribution
     36
    2637
    2738struct Collection {
    … …  
    4152                return root == 0p;
    4253        }
     54
    4355        void * head( Collection & collection ) with( collection ) {
    4456                return root;
    … …  
    5567                curr = 0p;
    5668        } // post: elts = null
     69
     70        forall( dtype T ) {
     71                T * Curr( ColIter & ci ) with( ci ) {
     72                        return (T *)curr;
     73                }
     74        } // distribution
    5775} // distribution

  • libcfa/src/bits/queue.hfa

    rf0d67e5 rb5629d8  
    1414                        return (T *)head( (Collection &)q );
    1515                } // post: empty() & head() == 0 | !empty() & head() in *q
    16 
    17                 bool empty( Queue(T) & q ) with( q ) {                  // 0 <=> *q contains no elements
    18                         return empty( (Collection &)q );
    19                 }
    20 
    21                 bool listed( T * n ) {
    22                         return Next( (Colable *)n ) != 0;
    23                 }
    24 
    25                 T *& Next( T * n ) {
    26                         return (T *)Next( (Colable *)n );
    27                 }
    28 
    29                 T * Root( Queue(T) & q ) with( q ) {
    30                         return (T *)root;
    31                 }
    3216
    3317                void ?{}( Queue(T) &, const Queue(T) & ) = void; // no copy
    … …  
    5539#endif // __CFA_DEBUG__
    5640                        if ( last ) {
    57                                 Next( n ) = Root( q );
     41                                Next( n ) = head( q );
    5842                                q.root = n;
    5943                        } else {
    … …  
    8165                        if ( root ) {
    8266                                root = Next( root );
    83                                 if ( Root( q ) == t ) {
     67                                if ( head( q ) == t ) {
    8468                                        root = last = 0p;                                       // only one element
    8569                                }
    … …  
    132116                                root = from.root;
    133117                        } else {                                                                        // "to" list not empty
    134                                 Next( last ) = Root( from );
     118                                Next( last ) = head( from );
    135119                        }
    136120                        last = from.last;
    … …  
    148132                        to.last = n;                                                            // end of "to" list
    149133                        from.root = Next( n );                                          // start of "from" list
    150                         if ( n == Root( from ) ) {                                      // last node in list ?
     134                        if ( n == head( from ) ) {                                      // last node in list ?
    151135                                from.root = from.last = 0p;                             // mark "from" list empty
    152136                        } else {
    … …  
    164148
    165149        inline {
    166                 // wrappers to make ColIter have T
    167                 T * Curr( QueueIter(T) & qi ) with( qi ) {
    168                         return (T *)curr;
    169                 }
    170 
    171150                void ?{}( QueueIter(T) & qi ) with( qi ) {
    172151                        ((ColIter &)qi){};
    … …  
    187166                } // post: curr = {e in q}
    188167
    189                 bool ?>>?( QueueIter(T) & qi, T *& tp ) with( qi ) {
     168                bool ?>>?( QueueIter(T) & qi, T && tp ) with( qi ) {
    190169                        if ( curr ) {
    191                                 tp = Curr( qi );
     170                                &tp = Curr( qi );
    192171                                T * n = Next( Curr( qi ) );
    193172                                curr = (n == Curr( qi ) ) ? 0p : n;
    194                         } else tp = 0p;
    195                         return tp != 0p;
     173                        } else &tp = 0p;
     174                        return &tp != 0p;
    196175                }
    197176                // post: elts == null & !operator>>(tp) | elts != null & *tp' in elts & elts' == elts - *tp & operator>>(tp)

  • libcfa/src/bits/queue_example.cfa

    rf0d67e5 rb5629d8  
    1717        Queue(Fred) fred;
    1818        QueueIter(Fred) fredIter = { fred };
    19         Fred * f;
    20         int i;
     19        Fred & f;
    2120
    2221        sout | nlOff;                                                                           // turn off auto newline
    2322
    2423        for ( ; fredIter >> f; ) {                                                      // empty list
    25                 sout | f->i | ' ';
     24                sout | f.i | ' ';
    2625        }
    2726        sout | "empty" | nl;
    2827       
    29         for ( i = 0; i < 10; i += 1 ) {
     28        for ( i; 10 ) {
    3029                add( fred, new( 2 * i ) );
    3130        }
    3231
    33         for ( over( fredIter, fred ); fredIter >> f; ) {
    34                 sout | f->i | ' ';
     32        for ( QueueIter(Fred) iter = { fred }; iter >> f; ) {
     33                sout | f.i | ' ';
    3534        }
    3635        sout | nl;
    3736
    38         for ( i = 0; i < 9; i += 1 ) {
     37        for ( i; 9 ) {
    3938                delete( drop( fred ) );
    4039        }
    4140
    4241        for ( over( fredIter, fred ); fredIter >> f; ) {
    43                 sout | f->i | ' ';
     42                sout | f.i | ' ';
    4443        }
    4544        sout | nl;
    4645       
    47         for ( i = 0; i < 10; i += 1 ) {
     46        for ( i; 10 ) {
    4847                add( fred, new( 2 * i + 1 ) );
    4948        }
    5049        for ( over( fredIter, fred ); fredIter >> f; ) {
    51                 sout | f->i | ' ';
     50                sout | f.i | ' ';
    5251        }
    5352        sout | nl;
    5453
    5554        for ( over( fredIter, fred ); fredIter >> f; ) {
    56                 delete( f );
     55                delete( &f );
    5756        }
    5857
    … …  
    7170        Queue(Mary) mary;
    7271        QueueIter(Mary) maryIter = { mary };
    73         Mary * m;
     72        Mary & m;
    7473
    7574        for ( ; maryIter >> m; ) {                                                      // empty list
    76                 sout | m->i | m->j | ' ';
     75                sout | m.i | m.j | ' ';
    7776        }
    7877        sout | "empty" | nl;
    7978       
    80         for ( i = 0; i < 10; i += 1 ) {
     79        for ( i; 10 ) {
    8180                add( mary, new( 2 * i ) );
    8281        }
    8382
    84         for ( over( maryIter, mary ); maryIter >> m; ) {
    85                 sout | m->i | m->j | ' ';
     83        for ( QueueIter(Mary) iter = { mary }; iter >> m; ) {
     84                sout | m.i | m.j | ' ';
    8685        }
    8786        sout | nl;
    8887       
    89         for ( i = 0; i < 9; i += 1 ) {
     88        for ( i; 9 ) {
    9089                delete( drop( mary ) );
    9190        }
    9291
    9392        for ( over( maryIter, mary ); maryIter >> m; ) {
    94                 sout | m->i | m->j | ' ';
     93                sout | m.i | m.j | ' ';
    9594        }
    9695        sout | nl;
    9796       
    98         for ( i = 0; i < 10; i += 1 ) {
     97        for ( i; 10 ) {
    9998                add( mary, new( 2 * i + 1 ) );
    10099        }
    101100        for ( over( maryIter, mary ); maryIter >> m; ) {
    102                 sout | m->i | m->j | ' ';
     101                sout | m.i | m.j | ' ';
    103102        }
    104103        sout | nl;
    105104
    106105        for ( over( maryIter, mary ); maryIter >> m; ) {
    107                 delete( m );
     106                delete( &m );
    108107        }
    109108}

  • libcfa/src/bits/sequence.hfa

    rf0d67e5 rb5629d8  
    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
    … …  
    6246
    6347                // Return a pointer to the last sequence element, without removing it. 
    64                 T * tail( Sequence(T) & s ) with( s ) {
    65                         return root ? (T *)Back( Root( s ) ) : 0p;      // needs cast?
     48                T & tail( Sequence(T) & s ) with( s ) {
     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
    8468
    8569                // Insert *n into the sequence before *bef, or at the end if bef == 0.
    86                 void insertBef( Sequence(T) & s, T * n, T * bef ) with( s ) { // pre: !n->listed() & *bef in *s
    87 #ifdef __CFA_DEBUG__
    88                         if ( listed( n ) ) abort( "(Sequence &)%p.insertBef( %p, %p ) : Node is already on another list.", &s, n, bef );
    89 #endif // __CFA_DEBUG__
    90                         if ( bef == Root( s ) ) {                                       // must change root
     70                void insertBef( Sequence(T) & s, T & n, T & bef ) with( s ) { // pre: !n->listed() & *bef in *s
     71#ifdef __CFA_DEBUG__
     72                        if ( listed( &n ) ) abort( "(Sequence &)%p.insertBef( %p, %p ) : Node is already on another list.", &s, n, &bef );
     73#endif // __CFA_DEBUG__
     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;
    97                                         Next( Back( n ) ) = n;
     80                                        Back( head( s ) ) = &n;
     81                                        Next( Back( &n ) ) = &n;
    9882                                } else {
    99                                         Next( n ) = n;
    100                                         Back( n ) = n;
     83                                        Next( &n ) = &n;
     84                                        Back( &n ) = &n;
    10185                                } // if
    10286                                // inserted node must be consistent before it is seen
    10387                                asm( "" : : : "memory" );                               // prevent code movement across barrier
    104                                 root = n;
     88                                root = &n;
    10589                        } else {
    106                                 if ( ! bef ) bef = Root( s );
    107                                 Next( n ) = bef;
    108                                 Back( n ) = Back( bef );
     90                                if ( ! &bef ) &bef = head( s );
     91                                Next( &n ) = &bef;
     92                                Back( &n ) = Back( &bef );
    10993                                // inserted node must be consistent before it is seen
    11094                                asm( "" : : : "memory" );                               // prevent code movement across barrier
    111                                 Back( bef ) = n;
    112                                 Next( Back( n ) ) = n;
     95                                Back( &bef ) = &n;
     96                                Next( Back( &n ) ) = &n;
    11397                        } // if
    11498                }       // post: n->listed() & *n in *s & succ(n) == bef
    … …  
    116100
    117101                // Insert *n into the sequence after *aft, or at the beginning if aft == 0.
    118                 void insertAft( Sequence(T) & s, T *aft, T *n ) with( s ) {     // pre: !n->listed() & *aft in *s
    119 #ifdef __CFA_DEBUG__
    120                         if ( listed( n ) ) abort( "(Sequence &)%p.insertAft( %p, %p ) : Node is already on another list.", &s, aft, n );
    121 #endif // __CFA_DEBUG__
    122                         if ( ! aft ) {                                                          // must change root
     102                void insertAft( Sequence(T) & s, T & aft, T & n ) with( s ) {   // pre: !n->listed() & *aft in *s
     103#ifdef __CFA_DEBUG__
     104                        if ( listed( &n ) ) abort( "(Sequence &)%p.insertAft( %p, %p ) : Node is already on another list.", &s, &aft, &n );
     105#endif // __CFA_DEBUG__
     106                        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;
    129                                         Next( Back( n ) ) = n;
     112                                        Back( head( s ) ) = &n;
     113                                        Next( Back( &n ) ) = &n;
    130114                                } else {
    131                                         Next( n ) = n;
    132                                         Back( n ) = n;
     115                                        Next( &n ) = &n;
     116                                        Back( &n ) = &n;
    133117                                } // if
    134118                                asm( "" : : : "memory" );                               // prevent code movement across barrier
    135                                 root = n;
     119                                root = &n;
    136120                        } else {
    137                                 Next( n ) = Next( aft );
    138                                 Back( n ) = aft;
     121                                Next( &n ) = Next( &aft );
     122                                Back( &n ) = &aft;
    139123                                // inserted node must be consistent before it is seen
    140124                                asm( "" : : : "memory" );                               // prevent code movement across barrier
    141                                 Back( Next( n ) ) = n;
    142                                 Next( aft ) = n;
     125                                Back( Next( &n ) ) = &n;
     126                                Next( &aft ) = &n;
    143127                        } // if
    144128                }         // post: n->listed() & *n in *s & succ(n) == bef
    145129               
    146130                // pre: n->listed() & *n in *s
    147                 void remove( Sequence(T) & s, T *n ) with( s ) { // O(1)
    148 #ifdef __CFA_DEBUG__
    149                         if ( ! listed( n ) ) abort( "(Sequence &)%p.remove( %p ) : Node is not on a list.", &s, n );
    150 #endif // __CFA_DEBUG__
    151                         if ( n == Root( s ) ) {
    152                                 if ( Next( Root( s ) ) == Root( s ) ) root = 0p;
    153                                 else root = Next( Root(s ) );
    154                         } // if
    155                         Back( Next( n ) ) = Back( n );
    156                         Next( Back( n ) ) = Next( n );
    157                         Next( n ) = Back( n ) = 0p;
     131                void remove( Sequence(T) & s, T & n ) with( s ) { // O(1)
     132#ifdef __CFA_DEBUG__
     133                        if ( ! listed( &n ) ) abort( "(Sequence &)%p.remove( %p ) : Node is not on a list.", &s, &n );
     134#endif // __CFA_DEBUG__
     135                        if ( &n == head( s ) ) {
     136                                if ( Next( head( s ) ) == head( s ) ) root = 0p;
     137                                else root = Next( head(s ) );
     138                        } // if
     139                        Back( Next( &n ) ) = Back( &n );
     140                        Next( Back( &n ) ) = Next( &n );
     141                        Next( &n ) = Back( &n ) = 0p;
    158142                }                                                       // post: !n->listed().
    159143
    160144                // Add an element to the head of the sequence.
    161                 void addHead( Sequence(T) & s, T *n ) {                 // pre: !n->listed(); post: n->listed() & head() == n
    162                         insertAft( s, 0, n );
     145                void addHead( Sequence(T) & s, T & n ) {                // pre: !n->listed(); post: n->listed() & head() == n
     146                        insertAft( s, *0p, n );
    163147                }
    164148                // Add an element to the tail of the sequence.
    165                 void addTail( Sequence(T) & s, T *n ) {                 // pre: !n->listed(); post: n->listed() & head() == n
    166                         insertBef( s, n, 0 );
     149                void addTail( Sequence(T) & s, T & n ) {                // pre: !n->listed(); post: n->listed() & head() == n
     150                        insertBef( s, n, *0p );
    167151                }
    168152                // Add an element to the tail of the sequence.
    169                 void add( Sequence(T) & s, T *n ) {                             // pre: !n->listed(); post: n->listed() & head() == n
     153                void add( Sequence(T) & s, T & n ) {                    // pre: !n->listed(); post: n->listed() & head() == n
    170154                        addTail( s, n );
    171155                }
    172156                // Remove and return the head element in the sequence.
    173                 T * dropHead( Sequence(T) & s ) {
     157                T & dropHead( Sequence(T) & s ) {
    174158                        T * n = head( s );
    175                         return n ? remove( s, n ), n : 0p;
     159                        return n ? remove( s, *n ), *n : *0p;
    176160                }
    177161                // Remove and return the head element in the sequence.
    178                 T * drop( Sequence(T) & s ) {
     162                T & drop( Sequence(T) & s ) {
    179163                        return dropHead( s );
    180164                }
    181165                // Remove and return the tail element in the sequence.
    182                 T * dropTail( Sequence(T) & s ) {
    183                         T * n = tail( s );
    184                         return n ? remove( s, n ), n : 0p;
     166                T & dropTail( Sequence(T) & s ) {
     167                        T & n = tail( s );
     168                        return &n ? remove( s, n ), n : *0p;
    185169                }
    186170
    … …  
    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.
    … …  
    244223                        ((ColIter &) si){};
    245224                        seq = &s;
     225                        curr = head( s );
    246226                } // post: elts = null.
    247227               
    … …  
    251231                } // post: elts = {e in s}.
    252232
    253                 bool ?>>?( SeqIter(T) & si, T *& tp ) with( si ) {
     233                bool ?>>?( SeqIter(T) & si, T && tp ) with( si ) {
    254234                        if ( curr ) {
    255                                 tp = Curr( si );
    256                                 T *n = succ( *seq, Curr( si ) );
     235                                &tp = Curr( si );
     236                                T * n = succ( *seq, Curr( si ) );
    257237                                curr = n == head( *seq ) ? 0p : n;
    258                         } else tp = 0p;
    259                         return tp != 0p;
     238                        } else &tp = 0p;
     239                        return &tp != 0p;
    260240                }
    261241        } // distribution
    … …  
    269249
    270250        inline {
    271                 // wrappers to make ColIter have T
    272                 T * Curr( SeqIterRev(T) & si ) with( si ) {
    273                         return (T *)curr;
    274                 }
    275 
    276251                void ?{}( SeqIterRev(T) & si ) with( si ) {     
    277252                        ((ColIter &) si){};
    … …  
    282257                        ((ColIter &) si){};
    283258                        seq = &s;
     259                        curr = &tail( s );
    284260                } // post: elts = null.
    285261               
    286262                void over( SeqIterRev(T) & si, Sequence(T) & s ) with( si ) {
    287263                        seq = &s;
    288                         curr = tail( s );
     264                        curr = &tail( s );
    289265                } // post: elts = {e in s}.
    290266
    291                 bool ?>>?( SeqIterRev(T) & si, T *&tp ) with( si ) {
     267                bool ?>>?( SeqIterRev(T) & si, T && tp ) with( si ) {
    292268                        if ( curr ) {
    293                                 tp = Curr( si );
    294                                 T *n = pred( *seq, Curr( si ) );
    295                                 curr = n == tail( *seq ) ? 0p : n;
    296                         } else tp = 0p;
    297                         return tp != 0p;
     269                                &tp = Curr( si );
     270                                T * n = pred( *seq, Curr( si ) );
     271                                curr = n == &tail( *seq ) ? 0p : n;
     272                        } else &tp = 0p;
     273                        return &tp != 0p;
    298274                }
    299275        } // distribution

  • libcfa/src/bits/sequence_example.cfa

    rf0d67e5 rb5629d8  
    1717        Sequence(Fred) fred;
    1818        SeqIter(Fred) fredIter = { fred };
    19         Fred * f;
    20         int i;
     19        Fred & f;
    2120
    2221        sout | nlOff;                                                                           // turn off auto newline
    2322
    2423        for ( ; fredIter >> f; ) {                                                      // empty list
    25                 sout | f->i | ' ';
     24                sout | f.i | ' ';
    2625        }
    2726        sout | "empty" | nl;
    2827       
    29         for ( i = 0; i < 10; i += 1 ) {
    30                 add( fred, new( 2 * i ) );
     28        for ( i; 10 ) {
     29                add( fred, *new( 2 * i ) );
     30        }
     31
     32        for ( SeqIter(Fred) iter = { fred }; iter >> f; ) {
     33                sout | f.i | ' ';
     34        }
     35        sout | nl;
     36
     37        for ( i; 9 ) {
     38                delete( &dropHead( fred ) );
    3139        }
    3240
    3341        for ( over( fredIter, fred ); fredIter >> f; ) {
    34                 sout | f->i | ' ';
     42                sout | f.i | ' ';
     43        }
     44        sout | nl;
     45       
     46        for ( i; 10 ) {
     47                addTail( fred, *new( 2 * i + 1 ) );
     48        }
     49        for ( over( fredIter, fred ); fredIter >> f; ) {
     50                sout | f.i | ' ';
    3551        }
    3652        sout | nl;
    3753
    38         for ( i = 0; i < 9; i += 1 ) {
    39                 delete( dropHead( fred ) );
    40         }
    41 
    42         for ( over( fredIter, fred ); fredIter >> f; ) {
    43                 sout | f->i | ' ';
    44         }
    45         sout | nl;
    46        
    47         for ( i = 0; i < 10; i += 1 ) {
    48                 addTail( fred, new( 2 * i + 1 ) );
     54        for ( i; 9 ) {
     55                delete( &dropTail( fred ) );
    4956        }
    5057        for ( over( fredIter, fred ); fredIter >> f; ) {
    51                 sout | f->i | ' ';
    52         }
    53         sout | nl;
    54 
    55         for ( i = 0; i < 9; i += 1 ) {
    56                 delete( dropTail( fred ) );
    57         }
    58         for ( over( fredIter, fred ); fredIter >> f; ) {
    59                 sout | f->i | ' ';
     58                sout | f.i | ' ';
    6059        }
    6160        sout | nl;
    6261
    6362        for ( over( fredIter, fred ); fredIter >> f; ) {
    64                 delete( f );
     63                delete( &f );
    6564        }
    6665
    … …  
    8079        Sequence(Mary) baz;
    8180        SeqIter(Mary) maryIter = { mary };
    82         Mary * m;
     81        Mary & m;
    8382
    8483        for ( ; maryIter >> m; ) {                                                      // empty list
    85                 sout | m->i | m->j | ' ';
     84                sout | m.i | m.j | ' ';
    8685        }
    8786        sout | "empty" | nl;
    8887       
    89         for ( i = 0; i < 10; i += 1 ) {
    90                 add( mary, new( 2 * i ) );
    91                 add( baz, new( 2 * i ) );
     88        for ( i; 10 ) {
     89                add( mary, *new( 2 * i ) );
     90                add( baz, *new( 2 * i ) );
     91        }
     92
     93        for ( SeqIter(Mary) iter = { mary }; iter >> m; ) {
     94                sout | m.i | m.j | ' ';
     95        }
     96        sout | nl;
     97       
     98        for ( i; 9 ) {
     99                delete( &dropHead( mary ) );
    92100        }
    93101
    94102        for ( over( maryIter, mary ); maryIter >> m; ) {
    95                 sout | m->i | m->j | ' ';
     103                sout | m.i | m.j | ' ';
    96104        }
    97105        sout | nl;
    98106       
    99         for ( i = 0; i < 9; i += 1 ) {
    100                 delete( dropHead( mary ) );
    101         }
    102 
    103         for ( over( maryIter, mary ); maryIter >> m; ) {
    104                 sout | m->i | m->j | ' ';
    105         }
    106         sout | nl;
    107        
    108         for ( i = 0; i < 10; i += 1 ) {
    109                 addTail( mary, new( 2 * i + 1 ) );
     107        for ( i; 10 ) {
     108                addTail( mary, *new( 2 * i + 1 ) );
    110109        }
    111110        for ( over( maryIter, mary ); maryIter >> m; ) {
    112                 sout | m->i | m->j | ' ';
     111                sout | m.i | m.j | ' ';
    113112        }
    114113        sout | nl;
    115114
    116         for ( i = 0; i < 9; i += 1 ) {
    117                 delete( dropTail( mary ) );
     115        for ( i; 9 ) {
     116                delete( &dropTail( mary ) );
    118117        }
    119118        for ( over( maryIter, mary ); maryIter >> m; ) {
    120                 sout | m->i | m->j | ' ';
     119                sout | m.i | m.j | ' ';
    121120        }
    122121        sout | nl;
    … …  
    125124
    126125        for ( over( maryIter, baz ); maryIter >> m; ) {
    127                 sout | m->i | m->j | ' ';
     126                sout | m.i | m.j | ' ';
    128127        }
    129128        sout | "empty" | nl;
    130129
    131130        for ( over( maryIter, mary ); maryIter >> m; ) {
    132                 sout | m->i | m->j | ' ';
     131                sout | m.i | m.j | ' ';
    133132        }
    134133        sout | nl;
    135134
    136135        for ( over( maryIter, mary ); maryIter >> m; ) {
    137                 delete( m );
     136                delete( &m );
    138137        }
    139138}
    140139
    141140// Local Variables: //
    142 // compile-command: "cfa sequence_example.cc" //
     141// compile-command: "cfa sequence_example.cfa" //
    143142// End: //

  • libcfa/src/bits/stack.hfa

    rf0d67e5 rb5629d8  
    1414                } // post: empty() & head() == 0 | !empty() & head() in *this
    1515
    16                 bool empty( Stack(T) & s ) with( s ) {                  // 0 <=> *this contains no elements
    17                         return empty( (Collection &)s );
    18                 }
    19 
    20                 T *& Next( T * n ) {
    21                         return (T *)Next( (Colable *)n );
    22                 }
    23 
    24                 T * Root( Stack(T) & s ) with( s ) {
    25                         return (T *)root;
    26                 }
    27 
    2816                void ?{}( Stack(T) &, const Stack(T) & ) = void; // no copy
    2917                Stack(T) & ?=?( const Stack(T) & ) = void;              // no assignment
    … …  
    3321                } // post: empty()
    3422
    35                 T * top( Stack(T) & s ) with( s ) {
    36                         return head( s );
     23                T & top( Stack(T) & s ) with( s ) {
     24                        return *head( s );
    3725                }
    3826
    39                 void addHead( Stack(T) & s, T * n ) with( s ) {
     27                void addHead( Stack(T) & s, T & n ) with( s ) {
    4028#ifdef __CFA_DEBUG__
    41                         if ( listed( (Colable &)(*n) ) ) abort( "(Stack &)%p.addHead( %p ) : Node is already on another list.", &s, n );
     29                        if ( listed( (Colable &)(n) ) ) abort( "(Stack &)%p.addHead( %p ) : Node is already on another list.", &s, n );
    4230#endif // __CFA_DEBUG__
    43                         Next( n ) = Root( s ) ? Root( s ) : n;
    44                         root = n;
     31                        Next( &n ) = head( s ) ? head( s ) : &n;
     32                        root = &n;
    4533                }
    4634
    47                 void add( Stack(T) & s, T * n ) with( s ) {
     35                void add( Stack(T) & s, T & n ) with( s ) {
    4836                        addHead( s, n );
    4937                }
    5038
    51                 void push( Stack(T) & s, T * n ) with( s ) {
     39                void push( Stack(T) & s, T & n ) with( s ) {
    5240                        addHead( s, n );
    5341                }
    5442
    55                 T * drop( Stack(T) & s ) with( s ) {
    56                         T * t = head( s );
     43                T & drop( Stack(T) & s ) with( s ) {
     44                        T & t = *head( s );
    5745                        if ( root ) {
    5846                                root = ( T *)Next(root);
    59                                 if ( Root( s ) == t ) root = 0p;                // only one element ?
    60                                 Next( t ) = 0p;
     47                                if ( head( s ) == &t ) root = 0p;               // only one element ?
     48                                Next( &t ) = 0p;
    6149                        } // if
    6250                        return t;
    6351                }
    6452
    65                 T * pop( Stack(T) & s ) with( s ) {
     53                T & pop( Stack(T) & s ) with( s ) {
    6654                        return drop( s );
    6755                }
    … …  
    7664
    7765        inline {
    78                 // wrappers to make ColIter have T
    79                 T * Curr( StackIter(T) & si ) with( si ) {
    80                         return (T *)curr;
    81                 }
    82 
    8366                void ?{}( StackIter(T) & si ) with( si ) {
    8467                        ((ColIter &)si){};
    … …  
    9073                } // post: curr = {e in s}
    9174
    92                 void ?{}( StackIter(T) & si, T * start ) with( si ) {
    93                         curr = start;
     75                void ?{}( StackIter(T) & si, T & start ) with( si ) {
     76                        curr = &start;
    9477                } // post: curr = {e in s}
    9578
    … …  
    9982                } // post: curr = {e in s}
    10083
    101                 bool ?>>?( StackIter(T) & si, T *& tp ) with( si ) {
     84                bool ?>>?( StackIter(T) & si, T && tp ) with( si ) {
    10285                        if ( curr ) {
    103                                 tp = Curr( si );
     86                                &tp = Curr( si );
    10487                                T * n = Next( Curr( si ) );
    105                                 curr = (n == Curr( si ) ) ? 0p : n;
    106                         } else tp = 0p;
    107                         return tp != 0p;
     88                                curr = n == Curr( si ) ? 0p : n;
     89                        } else &tp = 0p;
     90                        return &tp != 0p;
    10891                }
    10992        } // distribution

  • libcfa/src/bits/stack_example.cfa

    rf0d67e5 rb5629d8  
    1717        Stack(Fred) fred;
    1818        StackIter(Fred) fredIter = { fred };
    19         Fred * f;
    20         int i;
     19        Fred & f;
    2120
    2221        sout | nlOff;                                                                           // turn off auto newline
    2322
    2423        for ( ; fredIter >> f; ) {                                                      // empty list
    25                 sout | f->i | ' ';
     24                sout | f.i | ' ';
    2625        }
    2726        sout | "empty" | nl;
    2827       
    29         for ( i = 0; i < 10; i += 1 ) {
    30                 push( fred, new( 2 * i ) );
     28        for ( i; 10 ) {
     29                push( fred, *new( 2 * i ) );
     30        }
     31
     32        for ( StackIter(Fred) iter = { fred }; iter >> f; ) {
     33                sout | f.i | ' ';
     34        }
     35        sout | nl;
     36       
     37        for ( i; 9 ) {
     38                delete( &pop( fred ) );
    3139        }
    3240
    3341        for ( over( fredIter, fred ); fredIter >> f; ) {
    34                 sout | f->i | ' ';
     42                sout | f.i | ' ';
    3543        }
    3644        sout | nl;
    3745       
    38         for ( i = 0; i < 9; i += 1 ) {
    39                 delete( pop( fred ) );
    40         }
    41 
    42         for ( over( fredIter, fred ); fredIter >> f; ) {
    43                 sout | f->i | ' ';
    44         }
    45         sout | nl;
    46        
    47         for ( i = 0; i < 10; i += 1 ) {
    48                 push( fred, new( 2 * i + 1 ) );
     46        for ( i; 10 ) {
     47                push( fred, *new( 2 * i + 1 ) );
    4948        }
    5049        for ( over( fredIter, fred ); fredIter >> f; ) {
    51                 sout | f->i | ' ';
     50                sout | f.i | ' ';
    5251        }
    5352        sout | nl;
    5453
    5554        for ( over( fredIter, fred ); fredIter >> f; ) {
    56                 delete( f );
     55                delete( &f );
    5756        }
    5857
    … …  
    7170        Stack(Mary) mary;
    7271        StackIter(Mary) maryIter = { mary };
    73         Mary * m;
     72        Mary & m;
    7473
    7574        for ( ; maryIter >> m; ) {                                                      // empty list
    76                 sout | m->i | m->j | ' ';
     75                sout | m.i | m.j | ' ';
    7776        }
    7877        sout | "empty" | nl;
    7978       
    80         for ( i = 0; i < 10; i += 1 ) {
    81                 push( mary, new( 2 * i ) );
     79        for ( i; 10 ) {
     80                push( mary, *new( 2 * i ) );
     81        }
     82
     83        for ( StackIter(Mary) iter = { mary }; iter >> m; ) {
     84                sout | m.i | m.j | ' ';
     85        }
     86        sout | nl;
     87       
     88        for ( i; 9 ) {
     89                delete( &pop( mary ) );
    8290        }
    8391
    8492        for ( over( maryIter, mary ); maryIter >> m; ) {
    85                 sout | m->i | m->j | ' ';
     93                sout | m.i | m.j | ' ';
    8694        }
    8795        sout | nl;
    8896       
    89         for ( i = 0; i < 9; i += 1 ) {
    90                 delete( pop( mary ) );
    91         }
    92 
    93         for ( over( maryIter, mary ); maryIter >> m; ) {
    94                 sout | m->i | m->j | ' ';
    95         }
    96         sout | nl;
    97        
    98         for ( i = 0; i < 10; i += 1 ) {
    99                 push( mary, new( 2 * i + 1 ) );
     97        for ( i; 10 ) {
     98                push( mary, *new( 2 * i + 1 ) );
    10099        }
    101100        for ( over( maryIter, mary ); maryIter >> m; ) {
    102                 sout | m->i | m->j | ' ';
     101                sout | m.i | m.j | ' ';
    103102        }
    104103        sout | nl;
    105104
    106105        for ( over( maryIter, mary ); maryIter >> m; ) {
    107                 delete( m );
     106                delete( &m );
    108107        }
    109108}
Note: See TracChangeset for help on using the changeset viewer.