Changeset 11299


Ignore:
Timestamp:
Oct 11, 2010, 3:41:27 PM (12 years ago)
Author:
charles
Message:

(trunk libT) #3617 "1000+ warnings of 'inlining failed' in libtransmission when compiled with gcc 4.4.4" -- fixed.

Location:
trunk/libtransmission
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/libtransmission/bitfield.c

    r11280 r11299  
    1616#include "transmission.h"
    1717#include "bitfield.h"
     18#include "bitset.h"
    1819
    1920tr_bitfield*
    … …  
    210211    return ret;
    211212}
     213
     214/***
     215****
     216***/
     217
     218void
     219tr_bitsetReserve( tr_bitset * b, size_t size )
     220{
     221    if( b->bitfield.bitCount < size )
     222    {
     223        tr_bitfield * tmp = tr_bitfieldDup( &b->bitfield );
     224
     225        tr_bitfieldDestruct( &b->bitfield );
     226        tr_bitfieldConstruct( &b->bitfield, size );
     227
     228        if( ( tmp->bits != NULL ) && ( tmp->byteCount > 0 ) )
     229            memcpy( b->bitfield.bits, tmp->bits, tmp->byteCount );
     230
     231        tr_bitfieldFree( tmp );
     232    }
     233}

  • trunk/libtransmission/bitset.h

    r10020 r11299  
    4242}
    4343
    44 static inline void
    45 tr_bitsetReserve( tr_bitset * b, size_t size )
    46 {
    47     if( b->bitfield.bitCount < size )
    48     {
    49         tr_bitfield * tmp = tr_bitfieldDup( &b->bitfield );
    50 
    51         tr_bitfieldDestruct( &b->bitfield );
    52         tr_bitfieldConstruct( &b->bitfield, size );
    53 
    54         if( ( tmp->bits != NULL ) && ( tmp->byteCount > 0 ) )
    55             memcpy( b->bitfield.bits, tmp->bits, tmp->byteCount );
    56 
    57         tr_bitfieldFree( tmp );
    58     }
    59 }
     44void tr_bitsetReserve( tr_bitset * b, size_t size );
    6045
    6146static inline tr_bool

  • trunk/libtransmission/peer-io.c

    r10931 r11299  
    613613}
    614614
     615const char* tr_peerIoGetAddrStr( const tr_peerIo * io )
     616{
     617    return tr_isPeerIo( io ) ? tr_peerIoAddrStr( &io->addr, io->port ) : "error";
     618}
     619
    615620void
    616621tr_peerIoSetIOFuncs( tr_peerIo        * io,
    … …  
    821826}
    822827
     828void
     829tr_peerIoWriteUint16( tr_peerIo        * io,
     830                      struct evbuffer  * outbuf,
     831                      uint16_t           writeme )
     832{
     833    const uint16_t tmp = htons( writeme );
     834    tr_peerIoWriteBytes( io, outbuf, &tmp, sizeof( uint16_t ) );
     835}
     836
     837void
     838tr_peerIoWriteUint32( tr_peerIo        * io,
     839                      struct evbuffer  * outbuf,
     840                      uint32_t           writeme )
     841{
     842    const uint32_t tmp = htonl( writeme );
     843    tr_peerIoWriteBytes( io, outbuf, &tmp, sizeof( uint32_t ) );
     844}
     845
    823846/***
    824847****
    … …  
    850873            assert( 0 );
    851874    }
     875}
     876
     877void
     878tr_peerIoReadUint16( tr_peerIo        * io,
     879                     struct evbuffer  * inbuf,
     880                     uint16_t         * setme )
     881{
     882    uint16_t tmp;
     883    tr_peerIoReadBytes( io, inbuf, &tmp, sizeof( uint16_t ) );
     884    *setme = ntohs( tmp );
     885}
     886
     887void tr_peerIoReadUint32( tr_peerIo        * io,
     888                          struct evbuffer  * inbuf,
     889                          uint32_t         * setme )
     890{
     891    uint32_t tmp;
     892    tr_peerIoReadBytes( io, inbuf, &tmp, sizeof( uint32_t ) );
     893    *setme = ntohl( tmp );
    852894}
    853895

  • trunk/libtransmission/peer-io.h

    r11296 r11299  
    193193                              tr_port                   port );
    194194
    195 static inline const char* tr_peerIoGetAddrStr( const tr_peerIo * io )
    196 {
    197     return tr_isPeerIo( io ) ? tr_peerIoAddrStr( &io->addr, io->port ) : "error";
    198 }
     195const char* tr_peerIoGetAddrStr( const tr_peerIo * io );
    199196
    200197const struct tr_address * tr_peerIoGetAddress( const tr_peerIo * io,
    … …  
    301298}
    302299
    303 static inline void tr_peerIoWriteUint16( tr_peerIo        * io,
    304                                             struct evbuffer  * outbuf,
    305                                             uint16_t           writeme )
    306 {
    307     const uint16_t tmp = htons( writeme );
    308     tr_peerIoWriteBytes( io, outbuf, &tmp, sizeof( uint16_t ) );
    309 }
    310 
    311 static inline void tr_peerIoWriteUint32( tr_peerIo        * io,
    312                                             struct evbuffer  * outbuf,
    313                                             uint32_t           writeme )
    314 {
    315     const uint32_t tmp = htonl( writeme );
    316     tr_peerIoWriteBytes( io, outbuf, &tmp, sizeof( uint32_t ) );
    317 }
     300void tr_peerIoWriteUint16( tr_peerIo        * io,
     301                           struct evbuffer  * outbuf,
     302                           uint16_t           writeme );
     303
     304void tr_peerIoWriteUint32( tr_peerIo        * io,
     305                           struct evbuffer  * outbuf,
     306                           uint32_t           writeme );
    318307
    319308void tr_peerIoReadBytes( tr_peerIo        * io,
    … …  
    329318}
    330319
    331 static inline void tr_peerIoReadUint16( tr_peerIo        * io,
    332                                            struct evbuffer  * inbuf,
    333                                            uint16_t         * setme )
    334 {
    335     uint16_t tmp;
    336     tr_peerIoReadBytes( io, inbuf, &tmp, sizeof( uint16_t ) );
    337     *setme = ntohs( tmp );
    338 }
    339 
    340 static inline void tr_peerIoReadUint32( tr_peerIo        * io,
    341                                            struct evbuffer  * inbuf,
    342                                            uint32_t         * setme )
    343 {
    344     uint32_t tmp;
    345     tr_peerIoReadBytes( io, inbuf, &tmp, sizeof( uint32_t ) );
    346     *setme = ntohl( tmp );
    347 }
     320void tr_peerIoReadUint16( tr_peerIo        * io,
     321                          struct evbuffer  * inbuf,
     322                          uint16_t         * setme );
     323
     324void tr_peerIoReadUint32( tr_peerIo        * io,
     325                          struct evbuffer  * inbuf,
     326                          uint32_t         * setme );
    348327
    349328void      tr_peerIoDrain( tr_peerIo        * io,

  • trunk/libtransmission/peer-msgs.c

    r10998 r11299  
    307307}
    308308
    309 static inline void
     309static void
    310310dbgOutMessageLen( tr_peermsgs * msgs )
    311311{

  • trunk/libtransmission/session.c

    r11250 r11299  
    11621162                                    double            * setme_KBps )
    11631163{
    1164     int Bps;
     1164    int Bps = 0;
    11651165    const tr_bool is_active = tr_sessionGetActiveSpeedLimit_Bps( session, dir, &Bps );
    11661166    *setme_KBps = toSpeedKBps( Bps );

  • trunk/libtransmission/torrent.c

    r11264 r11299  
    402402{
    403403    uint16_t idleMinutes;
    404 #warning can this use the idleSecs from tr_stat?
    405404    return tr_torrentGetSeedIdle( tor, &idleMinutes )
    406405        && difftime(tr_time(), MAX(tor->startDate, tor->activityDate)) >= idleMinutes * 60u;

  • trunk/libtransmission/tr-lpd.c

    r11091 r11299  
    255255/**
    256256* @brief Configures additional capabilities for a socket */
    257 static inline int lpd_configureSocket( int sock, int add )
     257static int
     258lpd_configureSocket( int sock, int add )
    258259{
    259260#ifdef WIN32

  • trunk/libtransmission/utils.c

    r11298 r11299  
    328328    tr_lockUnlock( getMessageLock( ) );
    329329    errno = err;
     330}
     331
     332/***
     333****
     334***/
     335
     336void*
     337tr_malloc( size_t size )
     338{
     339    return size ? malloc( size ) : NULL;
     340}
     341
     342void*
     343tr_malloc0( size_t size )
     344{
     345    return size ? calloc( 1, size ) : NULL;
     346}
     347
     348void
     349tr_free( void * p )
     350{
     351    if( p != NULL )
     352        free( p );
     353}
     354
     355void*
     356tr_memdup( const void * src, size_t byteCount )
     357{
     358    return memcpy( tr_malloc( byteCount ), src, byteCount );
    330359}
    331360
    … …  
    662691
    663692char*
     693tr_strdup( const void * in )
     694{
     695    return tr_strndup( in, in ? (int)strlen((const char *)in) : 0 );
     696}
     697
     698char*
    664699tr_strndup( const void * in, int len )
    665700{
    … …  
    11291164***/
    11301165
     1166void
     1167tr_removeElementFromArray( void         * array,
     1168                           unsigned int   index_to_remove,
     1169                           size_t         sizeof_element,
     1170                           size_t         nmemb )
     1171{
     1172    char * a = (char*) array;
     1173
     1174    memmove( a + sizeof_element * index_to_remove,
     1175             a + sizeof_element * ( index_to_remove  + 1 ),
     1176             sizeof_element * ( --nmemb - index_to_remove ) );
     1177}
     1178
    11311179int
    11321180tr_lowerBound( const void * key,

  • trunk/libtransmission/utils.h

    r11250 r11299  
    296296
    297297/** @brief Portability wrapper around malloc() in which `0' is a safe argument */
    298 static inline void* tr_malloc( size_t size )
    299 {
    300     return size ? malloc( size ) : NULL;
    301 }
     298void* tr_malloc( size_t size );
    302299
    303300/** @brief Portability wrapper around calloc() in which `0' is a safe argument */
    304 static inline void* tr_malloc0( size_t size )
    305 {
    306     return size ? calloc( 1, size ) : NULL;
    307 }
     301void* tr_malloc0( size_t size );
    308302
    309303/** @brief Portability wrapper around free() in which `NULL' is a safe argument */
    310 static inline void tr_free( void * p )
    311 {
    312     if( p != NULL )
    313         free( p );
    314 }
     304void tr_free( void * p );
    315305
    316306/**
    … …  
    320310 * @return a newly-allocated copy of `src' that can be freed with tr_free()
    321311 */
    322 static inline void* tr_memdup( const void * src, size_t byteCount )
    323 {
    324     return memcpy( tr_malloc( byteCount ), src, byteCount );
    325 }
     312void* tr_memdup( const void * src, size_t byteCount );
    326313
    327314#define tr_new( struct_type, n_structs )           \
    … …  
    349336 * @return a newly-allocated copy of `in' that can be freed with tr_free()
    350337 */
    351 static inline char* tr_strdup( const void * in )
    352 {
    353     return tr_strndup( in, in ? (int)strlen((const char *)in) : 0 );
    354 }
     338char* tr_strdup( const void * in );
    355339
    356340/** @brief similar to bsearch() but returns the index of the lower bound */
    … …  
    521505
    522506/** @brief convenience function to remove an item from an array */
    523 static inline void tr_removeElementFromArray( void         * array,
    524                                               unsigned int   index_to_remove,
    525                                               size_t         sizeof_element,
    526                                               size_t         nmemb )
    527 {
    528     char * a = (char*) array;
    529 
    530     memmove( a + sizeof_element * index_to_remove,
    531              a + sizeof_element * ( index_to_remove  + 1 ),
    532              sizeof_element * ( --nmemb - index_to_remove ) );
    533 }
     507void tr_removeElementFromArray( void         * array,
     508                                unsigned int   index_to_remove,
     509                                size_t         sizeof_element,
     510                                size_t         nmemb );
    534511
    535512/***
Note: See TracChangeset for help on using the changeset viewer.