Ignore:
Timestamp:
Sep 23, 2008, 7:11:04 PM (12 years ago)
Author:
charles
Message:

run libT, cli, daemon, gtk through the source-code formatter "uncrustify" as promised/threatened

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/ptrarray.c

    r6699 r6795  
    44 * This file is licensed by the GPL version 2.  Works owned by the
    55 * Transmission project are granted a special exemption to clause 2(b)
    6  * so that the bulk of its code can remain under the MIT license. 
     6 * so that the bulk of its code can remain under the MIT license.
    77 * This exemption does not extend to derived works not owned by
    88 * the Transmission project.
     
    2323{
    2424    void ** items;
    25     int n_items;
    26     int n_alloc;
     25    int     n_items;
     26    int     n_alloc;
    2727};
    2828
     
    4747    out = tr_new( tr_ptrArray, 1 );
    4848    out->n_items = out->n_alloc = in->n_items;
    49     out->items = tr_memdup( in->items, out->n_items * sizeof(void*) );
     49    out->items = tr_memdup( in->items, out->n_items * sizeof( void* ) );
    5050
    5151    return out;
     
    5353
    5454void
    55 tr_ptrArrayForeach( tr_ptrArray * t, PtrArrayForeachFunc func )
     55tr_ptrArrayForeach( tr_ptrArray *       t,
     56                    PtrArrayForeachFunc func )
    5657{
    5758    int i;
     
    6162    assert( func );
    6263
    63     for( i=0; i<t->n_items; ++i )
     64    for( i = 0; i < t->n_items; ++i )
    6465        func( t->items[i] );
    6566}
    6667
    6768void
    68 tr_ptrArrayFree( tr_ptrArray * t, PtrArrayForeachFunc func )
     69tr_ptrArrayFree( tr_ptrArray *       t,
     70                 PtrArrayForeachFunc func )
    6971{
    7072    assert( t );
     
    7981
    8082void**
    81 tr_ptrArrayPeek( tr_ptrArray * t, int * size )
     83tr_ptrArrayPeek( tr_ptrArray * t,
     84                 int *         size )
    8285{
    8386    *size = t->n_items;
     
    9295
    9396void*
    94 tr_ptrArrayNth( tr_ptrArray* t, int i )
     97tr_ptrArrayNth( tr_ptrArray* t,
     98                int          i )
    9599{
    96100    assert( t );
     
    106110    assert( t->n_items > 0 );
    107111
    108     return tr_ptrArrayNth( t, t->n_items-1 );
     112    return tr_ptrArrayNth( t, t->n_items - 1 );
    109113}
    110114
     
    128132
    129133int
    130 tr_ptrArrayInsert( tr_ptrArray * t, void * ptr, int pos )
    131 {
    132     if( pos<0 || pos>t->n_items )
     134tr_ptrArrayInsert( tr_ptrArray * t,
     135                   void *        ptr,
     136                   int           pos )
     137{
     138    if( pos < 0 || pos > t->n_items )
    133139        pos = t->n_items;
    134140
    135     if( t->n_items >= t->n_alloc ) {
     141    if( t->n_items >= t->n_alloc )
     142    {
    136143        t->n_alloc = t->n_items + GROW;
    137144        t->items = tr_renew( void*, t->items, t->n_alloc );
     
    139146
    140147    memmove( t->items + pos + 1,
    141              t->items + pos,
    142              sizeof(void*) * (t->n_items - pos));
     148            t->items + pos,
     149            sizeof( void* ) * ( t->n_items - pos ) );
    143150
    144151    t->items[pos] = ptr;
     
    148155
    149156int
    150 tr_ptrArrayAppend( tr_ptrArray * t, void * ptr )
     157tr_ptrArrayAppend( tr_ptrArray * t,
     158                   void *        ptr )
    151159{
    152160    return tr_ptrArrayInsert( t, ptr, -1 );
     
    160168    if( t->n_items )
    161169        ret = t->items[--t->n_items];
    162    
     170
    163171    return ret;
    164172}
    165173
    166174void
    167 tr_ptrArrayErase( tr_ptrArray * t, int begin, int end )
     175tr_ptrArrayErase( tr_ptrArray * t,
     176                  int           begin,
     177                  int           end )
    168178{
    169179    assert( begin >= 0 );
     
    173183
    174184    memmove( t->items + begin,
    175              t->items + end,
    176              sizeof(void*) * (t->n_items - end) );
    177 
    178     t->n_items -= (end - begin);
     185            t->items + end,
     186            sizeof( void* ) * ( t->n_items - end ) );
     187
     188    t->n_items -= ( end - begin );
    179189}
    180190
     
    184194
    185195static int
    186 tr_ptrArrayLowerBound( const tr_ptrArray * t,
    187                        const void        * ptr,
    188                        int                 compare( const void *,const void * ),
    189                        int               * exact_match )
     196tr_ptrArrayLowerBound( const tr_ptrArray *                t,
     197                       const void *                       ptr,
     198                       int                 compare( const void *,
     199                                                    const void * ),
     200                       int *                              exact_match )
    190201{
    191202    int len = t->n_items;
     
    194205    while( len > 0 )
    195206    {
    196         int half = len / 2;
    197         int middle = first + half;
     207        int       half = len / 2;
     208        int       middle = first + half;
    198209        const int c = compare( t->items[middle], ptr );
    199         if( c < 0 ) {
     210        if( c < 0 )
     211        {
    200212            first = middle + 1;
    201213            len = len - half - 1;
    202         } else if (!c ) {
     214        }
     215        else if( !c )
     216        {
    203217            if( exact_match )
    204218                *exact_match = 1;
    205219            return middle;
    206220            break;
    207         } else {
     221        }
     222        else
     223        {
    208224            len = half;
    209225        }
     
    218234static void
    219235assertSortedAndUnique( const tr_ptrArray * t,
    220                        int compare(const void*, const void*) )
     236                        int compare(const void*, const void*) )
    221237{
    222238    int i;
    223     for( i=0; i<t->n_items-2; ++i )
    224         assert( compare( t->items[i], t->items[i+1] ) < 0 );
    225 }
    226 
    227 int
    228 tr_ptrArrayInsertSorted( tr_ptrArray  * t,
    229                          void         * ptr,
    230                          int            compare(const void*,const void*) )
     239
     240    for( i = 0; i < t->n_items - 2; ++i )
     241        assert( compare( t->items[i], t->items[i + 1] ) < 0 );
     242}
     243
     244int
     245tr_ptrArrayInsertSorted( tr_ptrArray * t,
     246                         void *        ptr,
     247                          int            compare(const void*, const void*) )
    231248{
    232249    const int pos = tr_ptrArrayLowerBound( t, ptr, compare, NULL );
    233250    const int ret = tr_ptrArrayInsert( t, ptr, pos );
     251
    234252    assertSortedAndUnique( t, compare );
    235253    return ret;
     
    237255
    238256void*
    239 tr_ptrArrayFindSorted( tr_ptrArray  * t,
    240                        const void   * ptr,
    241                        int            compare(const void*,const void*) )
    242 {
    243     int match;
     257tr_ptrArrayFindSorted( tr_ptrArray * t,
     258                       const void * ptr,
     259                        int            compare(const void*, const void*) )
     260{
     261    int       match;
    244262    const int pos = tr_ptrArrayLowerBound( t, ptr, compare, &match );
     263
    245264    return match ? t->items[pos] : NULL;
    246265}
    247266
    248267void*
    249 tr_ptrArrayRemoveSorted( tr_ptrArray  * t,
    250                          void         * ptr,
    251                          int            compare(const void*,const void*) )
    252 {
    253     void * ret = NULL;
    254     int match;
     268tr_ptrArrayRemoveSorted( tr_ptrArray * t,
     269                         void *        ptr,
     270                          int            compare(const void*, const void*) )
     271{
     272    void *    ret = NULL;
     273    int       match;
    255274    const int pos = tr_ptrArrayLowerBound( t, ptr, compare, &match );
    256     if( match ) {
     275
     276    if( match )
     277    {
    257278        ret = t->items[pos];
    258         tr_ptrArrayErase( t, pos, pos+1 );
     279        tr_ptrArrayErase( t, pos, pos + 1 );
    259280    }
    260281    assertSortedAndUnique( t, compare );
    261282    return ret;
    262283}
     284
Note: See TracChangeset for help on using the changeset viewer.