Ignore:
Timestamp:
Sep 23, 2008, 7:11:04 PM (13 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/list.c

    r6425 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.
     
    3232
    3333void
    34 tr_list_free( tr_list** list, TrListForeachFunc data_free_func )
     34tr_list_free( tr_list**         list,
     35              TrListForeachFunc data_free_func )
    3536{
    3637    while( *list )
    3738    {
    3839        tr_list *node = *list;
    39         *list = (*list)->next;
     40        *list = ( *list )->next;
    4041        if( data_free_func )
    4142            data_free_func( node->data );
     
    4546
    4647void
    47 tr_list_prepend( tr_list ** list, void * data )
    48 {
    49     tr_list * node = node_alloc ();
     48tr_list_prepend( tr_list ** list,
     49                 void *     data )
     50{
     51    tr_list * node = node_alloc ( );
     52
    5053    node->data = data;
    5154    node->next = *list;
    5255    if( *list )
    53         (*list)->prev = node;
     56        ( *list )->prev = node;
    5457    *list = node;
    5558}
    5659
    5760void
    58 tr_list_append( tr_list ** list, void * data )
     61tr_list_append( tr_list ** list,
     62                void *     data )
    5963{
    6064    tr_list * node = node_alloc( );
     65
    6166    node->data = data;
    6267    if( !*list )
    6368        *list = node;
    64     else {
     69    else
     70    {
    6571        tr_list * l = *list;
    6672        while( l->next )
    6773            l = l->next;
     74
    6875        l->next = node;
    6976        node->prev = l;
     
    7380void
    7481tr_list_insert_sorted( tr_list ** list,
    75                        void       * data,
    76                        int          compare(const void*,const void*) )
     82                       void *    data,
     83                        int          compare(const void*, const void*) )
    7784{
    7885    /* find l, the node that we'll insert this data before */
    7986    tr_list * l;
    80     for( l=*list; l!=NULL; l=l->next ) {
     87
     88    for( l = *list; l != NULL; l = l->next )
     89    {
    8190        const int c = (compare)( data, l->data );
    8291        if( c <= 0 )
     
    8493    }
    8594
    86     if( l == NULL)
     95    if( l == NULL )
    8796        tr_list_append( list, data );
    8897    else if( l == *list )
    8998        tr_list_prepend( list, data );
    90     else {
     99    else
     100    {
    91101        tr_list * node = node_alloc( );
    92102        node->data = data;
    93         if( l->prev ) { node->prev = l->prev; node->prev->next = node; }
     103        if( l->prev ){ node->prev = l->prev; node->prev->next = node; }
    94104        node->next = l;
    95105        l->prev = node;
     
    97107}
    98108
    99 
    100109tr_list*
    101 tr_list_find_data ( tr_list * list, const void * data )
    102 {
    103     for(; list; list=list->next )
     110tr_list_find_data( tr_list *    list,
     111                   const void * data )
     112{
     113    for( ; list; list = list->next )
    104114        if( list->data == data )
    105115            return list;
     
    109119
    110120static void*
    111 tr_list_remove_node ( tr_list ** list, tr_list * node )
    112 {
    113     void * data;
     121tr_list_remove_node( tr_list ** list,
     122                     tr_list *  node )
     123{
     124    void *    data;
    114125    tr_list * prev = node ? node->prev : NULL;
    115126    tr_list * next = node ? node->next : NULL;
     127
    116128    if( prev ) prev->next = next;
    117129    if( next ) next->prev = prev;
     
    126138{
    127139    void * ret = NULL;
     140
    128141    if( *list )
    129142    {
    130         ret = (*list)->data;
     143        ret = ( *list )->data;
    131144        tr_list_remove_node( list, *list );
    132145    }
     
    135148
    136149void*
    137 tr_list_remove_data ( tr_list ** list, const void * data )
     150tr_list_remove_data( tr_list **   list,
     151                     const void * data )
    138152{
    139153    return tr_list_remove_node( list, tr_list_find_data( *list, data ) );
     
    141155
    142156void*
    143 tr_list_remove( tr_list         ** list,
    144                 const void       * b,
    145                 TrListCompareFunc  compare_func )
     157tr_list_remove( tr_list **        list,
     158                const void *      b,
     159                TrListCompareFunc compare_func )
    146160{
    147161    return tr_list_remove_node( list, tr_list_find( *list, b, compare_func ) );
    148162}
    149163
    150 
    151164tr_list*
    152 tr_list_find ( tr_list * list , const void * b, TrListCompareFunc func )
    153 {
    154     for( ; list; list=list->next )
     165tr_list_find( tr_list *         list,
     166              const void *      b,
     167              TrListCompareFunc func )
     168{
     169    for( ; list; list = list->next )
    155170        if( !func( list->data, b ) )
    156171            return list;
     
    160175
    161176void
    162 tr_list_foreach( tr_list * list, TrListForeachFunc func )
    163 {
    164     while( list ) {
     177tr_list_foreach( tr_list *         list,
     178                 TrListForeachFunc func )
     179{
     180    while( list )
     181    {
    165182        func( list->data );
    166183        list = list->next;
     
    172189{
    173190    int size = 0;
    174     while( list ) {
     191
     192    while( list )
     193    {
    175194        ++size;
    176195        list = list->next;
    177196    }
     197
    178198    return size;
    179199}
     200
Note: See TracChangeset for help on using the changeset viewer.